文库-火龙果软件 - 关心工作者的实践

Python快速入门

1372 次浏览	59次

Python是一种高层次，解释型，交互式和面向对象的脚本语言。

Python是解释型的

Python是交互式的

Python是面向对象的

Python是初学者的语言

Python是由Guido van Rossum在八十年代末和九十年代初在荷兰国家研究所数学与计算机科学研发的。

Python的突出特点包括：

易学

易阅读

易维护

拥有广泛的标准库

交互模式

可移植

可扩展

数据库

GUI 程序

可伸缩

获取Python

当前最新源代码，二进制文件，文档，新闻等，可在Python的官方网站找到。

Python 官方网站 : http://www.python.org/

可以从网站下载以下Python文档。文档有 HTML，PDF 和 PostScript 格式。

Python 文档网站 : www.python.org/doc/

Python安装（win7）

在本教程中，使用的是 python2.7 版本，当前已经发布了 python3 ，但是考虑到两个版本不能相互很好的兼容，所以有 python3 的内容，会在后续的教程中发布，请关注：Python3教程。

打开官方网站的下载页面，如下所示：

点击 "Download Python 2.7.10" 这个链接，然后打开需要下载的版本，请定需要的版本，这里写本教程使用的是：python-2.7.10.msi
下载完成后，双击 python-2.7.10.msi 这个二进制文件并安装，指定安装路径。

第一步：双击 python-2.7.10.msi 安装

第二步：选择安装路径

第三步：将 Python 程序添加到“系统环境变量”

第四步：安装完成！

第五步：测试安装结果，点击“开始”，选择" Python(command line)"

到此，Python 的所有安装完成！接下来我们就可以编写测试 Python 程序了。

第一个Python程序

交互式模式编程：

调用解释不通过一个脚本文件作为参数，就可以调出以下提示（Linux平台下）：

root# python
Python 2.5 (r25:51908, Nov  6 2007, 16:54:01)
[GCC 4.1.2 20070925 (Red Hat 4.1.2-27)] on linux2
Type "help", "copyright", "credits" or "license" for more info.
>>>

在 Python 提示符的右侧输入下列文本并按下回车键：

>>> print "Hello, Python!";

这将产生以下结果：

Hello, Python!

Python标识符

Python标识符是一个用来标识变量，函数，类，模块，或其他对象的名称。标识符是以字母A到Z或a?z开始后面跟零个或多个字母下划线（_），下划线和数字（0?9）。

Python不允许标点字符标识符，如@，$和％。Python是一种区分大小写的编程语言。比如 Manpower 和 manpower 在Python中是两种不同的标识符。

下面是在Python标识符的命名约定：

类名称以大写字母，其他的标识符以小写字母。

单个前导下划线开始的标识符表示该标识符意味着约定是私有的。

开始是两个前导下划线的标识符表示强烈专用标识符。

如果标识符还具有两个尾随下划线结束时，所述标识符是语言定义的特殊名称。

保留字

下面的列表显示的是在Python的保留字。这些保留字不可以用作常量或变量或任何其它标识符名称。

行和缩进

一个程序员在学习Python时，遇到的第一个注意事项是，Python中不使用括号来表示代码类/函数定义块或流量控制。代码块由行缩进，这是严格执行表示。

缩进位数量是可变的，但是在块中的所有语句必须缩进量相同。在这个例子中，两个块都很好(没有问题)：

if True:
    print "True"
else:
  print "False"

然而，在这个例子中，第二块将产生一个错误：

if True:
    print "Answer"
    print "True"
else:
    print "Answer"
  print "False"

多行语句

在Python语句通常有一个新行表示结束。Python里面，但是，允许使用续行字符（\）表示该行应该继续。例如：

total = item_one + \item_two + \item_three

包含在语句[], {}, 或()括号内不能使用续行字符。例如：

days = ['Monday', 'Tuesday', 'Wednesday','Thursday', 'Friday']

在Python中的引号

Python的接受单引号（'），双引号（“）和三（'''或”“”）引用来表示字符串，只要是同一类型的引号的开始和结束的字符串。

三重引号可以用来横跨多行字符串。例如，下面所有的表示都是合法的：

word = 'word'
sentence = "This is a sentence."
paragraph = """This is a paragraph. It is
made up of multiple lines and sentences."""

在Python中的注释

哈希符号（＃）不是一个字符串字母开头，它是一个注释的开始。＃之后以及到物理行结束的所有字符都是注释的一部分，Python解释器会忽略它们。

#!/usr/bin/python
# First comment
print "Hello, Python!"; # second comment

这将产生以下结果：

Hello, Python!

注释在一个语句或表达式后的同一行：

name = "Madisetti" # This is again comment

可以注释多行，如下所示：

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

使用空行

仅包含空格，可能带有注释行，被称为一个空行，Python完全忽略它。

在交互式解释器会话，必须输入一个空的物理线路终止多行语句。

在一行上的多个语句

分号（;）允许在单一行上编写多条语句，语句开始一个新的代码块。下面是使用分号示例片断：

import sys; x = 'foo'; sys.stdout.write(x + '\n')

多组语句称为套件

组成一个单一的代码块个别语句组在Python中被称为套件。

组件或复杂的语句，如if，while，def和类，是那些需要一个标题行和套件。

标题行开始语句（用关键字），并终止并显示冒号（:），接着是一行或多行，组成套件。

例子：

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

Python - 变量类型

变量是什么，不是是保留在内存位置用来存储一些值。这意味着，当创建一个变量，它会在内存中保留一些空间。

根据一个变量的数据类型，解释器分配内存，并决定什么样的数据可以存储在保留存储器。因此，通过分配不同的数据类型的变量，可以存储整数，小数或字符在这些变量中。

给变量赋值

在=操作符的左侧是变量名，在=运算符的右边是存储在变量中的值。例如：

counter = 100 # An integer assignment
miles   = 1000.0  # A floating point
name    = "John"  # A string
print counter
print miles
print name

标准数据类型

Python有五个标准数据类型：

数字

字符串

列表

元组

字典

Python的数字

当分配一个值给创建的 Number 对象。例如：

var1 = 1
var2 = 10

Python支持四种不同的数值类型：

int (有符号整数)

long (长整数[也可以以八进制和十六进制表示])

float (浮点实数值)

complex (复数)

这里是数字的一些例子：

Python字符串

Python的字符串在引号之间确定为一组连续的字符。

例子：

str = 'Hello World!'
print str # Prints complete string
print str[0] # Prints first character of the string
print str[2:5] # Prints characters starting from 
3rd to 6th
print str[2:] # Prints string starting from 3rd 
character
print str * 2 # Prints string two times
print str + "TEST" # Prints concatenated 
string

Python 列表

列表是最通用的 Python 复合数据类型。列表包含在方括号 ([]) 内用逗号分隔，包含的各种数据类型的项目。

#!/usr/bin/python
list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list # Prints complete list
print list[0] # Prints first element of the list
print list[1:3] # Prints elements starting from 
2nd to 4th
print list[2:] # Prints elements starting from 
3rd element
print tinylist * 2 # Prints list two times
print list + tinylist # Prints concatenated lists

Python 元组

元组是类似于另一列表序列的数据类型。元组中由数个逗号分隔每一个值。不像列表，元组中括号括起来。

元组可以被认为是只读的列表。

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')
print tuple # Prints complete list
print tuple[0] # Prints first element of the list
print tuple[1:3] # Prints elements starting from 
2nd to 4th
print tuple[2:] # Prints elements starting from 
3rd element
print tinytuple * 2 # Prints list two times
print tuple + tinytuple # Prints concatenated 
lists

Python字典

Python的字典是哈希表类型。它们运作就像关联数组或类似在Perl中的哈希，由键值对组成。

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

Python基本运算符

假设 a = 10， b = 20 那么：

Python运算符优先级

下表列出了所有运算符从最高优先级到最低。

if 语句

if语句的语法是：

if expression:
   statement(s)

else 语句

以下是 if...else 语句的语法:

if expression:
   statement(s)
else:
   statement(s)

elif 语句

以下是 if...elif 语句的语法：

if expression1:
   statement(s)
elif expression2:
   statement(s)
elif expression3:
   statement(s)
else:
   statement(s)

内嵌 if...elif...else 结构

以下是内嵌的 if...elif...else 结构的语法：

if expression1:
   statement(s)
   if expression2:
      statement(s)
   elif expression3:
      statement(s)
   else
      statement(s)
elif expression4:
   statement(s)
else:
   statement(s)

while 循环

以下是 while 循环的语法：

while expression:
   statement(s)

无限循环

使用while循环时务必小心，因为如果这个条件永远解析为一个假值时，这会导致在一个循环中，永远不会结束。这种循环被称为一个无限循环。

其中，服务器需要连续运行，以使客户程序可以在有需要时与它进行通信，无限循环可能是在客户机/服务器编程有用到。

单个语句套件

类似于if语句的语法，如果while子句仅由一个单一的语句时，它可以被放置在相同的行中所述while的头部位置。

这里是一个单行while子句的例子：

while expression : statement

for 循环

for循环的语法是：

for iterating_var in sequence:
   statements(s)

遍历序列索引

替代方式是通过每个项目迭代，索引偏移到序列本身：

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
print 'Current fruit :', fruits[index]
print "Good bye!"

break 语句

Python中的break语句终止当前的循环，并继续执行下一条语句，就像在C中的传统的break语句一样。

break语句最常见的用途是当一些外部条件被触发，需要从一个循环马上退出。break语句可以在 while 和 for 两个循环使用。

for letter in 'Python': # First Example
if letter == 'h':
break
print 'Current Letter :', letter
var = 10  # Second Example
while var > 0: 
print 'Current variable value :', var
var = var -1
if var == 5:
break
print "Good bye!"

continue 语句

在Python中，continue语句返回控制 while 循环的开始。 continue语句拒绝执行循环的当前迭代所有剩余的语句，并移动控制回到循环的顶部（开始位置）。

continue语句可以在 while 和 for 两个循环中使用。

for letter in 'Python':  # First Example
if letter == 'h':
continue
print 'Current Letter :', letter
var = 10 # Second Example
while var > 0: 
print 'Current variable value :', var
var = var -1
if var == 5:
continue
print "Good bye!"

在循环中使用else语句

Python支持有一个循环语句相关联的else语句。

如果一个for循环使用else语句，当循环已用尽迭代列表执行else语句。

如果else语句使用在while循环，当 while 条件为假else语句执行。

pass 语句

Python中的pass语句，语法上必需的，但又不希望执行任何命令或代码。

pass语句是个空操作;在执行时什么也不会发生。 pass也是一个有用的地方，因为这里代码最终是有用的，只是一直没有写，但（例如，以存根为例）：

#!/usr/bin/python
for letter in 'Python': 
if letter == 'h':
pass
print 'This is pass block'
print 'Current Letter :', letter
print "Good bye!"

定义一个函数

可以定义函数，以提供所需的功能。下面是在Python定义一个函数的简单规则：

函数块首先以 def 关键字后跟函数名和括号 ( ( ) )

任何输入参数或参数应放在这些括号内。还可以定义这些括号内的参数。

函数的第一个语句可以是一个可选的声明 - 函数的文档字符串或文档字符串。

每个函数中的代码块用冒号(:) 开始和缩进。

该语句返回[表达]退出函数，可选地传递回一个表达式给调用者。不带参数的return语句返回None是一样的。

语法

def functionname( parameters ):
"function_docstring"
function_suite
return [expression]

默认情况下，参数有一个位置的行为，需要以相同的顺序定义它们。

例子：

这是最简单的Python函数形式。函数将一个字符串作为输入参数并打印标准屏幕上。

def printme( str ):
"This prints a passed string into this function"
print str
return

调用函数

定义一个函数仅赋予它一个名字，指定将被包括在该函数的参数，以及代码块结构。

一旦函数的基本结构确定后，就可以通过从其它函数或直接从Python提示符调用它执行它。

下面是一个调用 printme()函数的例子：

#!/usr/bin/python
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print str;
return;
# Now you can call printme function
printme("I'm first call to user defined function!");
printme("Again second call to the same function");

这将产生以下输出结果：

I'm first call to user defined function!
Again second call to the same function

Python 模块

模块允许在逻辑上组织Python代码。将相关代码放到一个模块使代码更容易理解和使用。

模块是可以绑定和参考任意命名的属性的Python对象。

简单地说，一个模块是由Python代码的文件组成。模块可以定义函数，类和变量。模块也可以包括可运行的代码。

例子：

Python 中一个名为 aname 的模块代码通常位于一个文件名为 aname.py. 这里有一个简单的模块的例子，hello.py

def print_func( par ):
print "Hello : ", par
return

import 语句

可以通过使用 import 语句在其他一些Python源文件作为一个模块执行任何Python源文件。import 的语法如下：

import module1[, module2[,... moduleN]

当解释遇到import语句，如果模块存在于搜索路径它导入模块。搜索路径是一个目录列表，解释器在导入模块之前搜索。

例子：

要导入模块hello.py，需要把下面的命令在脚本的顶部：

#!/usr/bin/python
# Import module hello
import hello
# Now you can call defined function that module 
as follows
hello.print_func("Zara")

这将产生以下输出结果：

Hello : Zara

一个模块只被装载一次，而不管导入的次数。如果多个导入出现这可以防止模块执行一遍又一遍。

打开和关闭文件

open函数：

在可以读取或写入一个文件之前，必须使用Python的内置open()函数来打开文件。这个函数创建文件对象，这将被用来调用与其相关联其他支持方法。

语法

file object = open(file_name [, access_mode][, buffering])

下面是详细的参数说明：

file_name: file_name参数是一个字符串值，包含要访问的文件的名称。

access_mode: access_mode 确定该文件已被打开，即模式。读，写等追加。可能值的一个完整列表在下表中给出。这是可选的参数，默认文件访问模式是读(r)

buffering: 如果缓冲值被设置为0，没有缓冲将发生。如果该缓冲值是1，将在访问一个文件进行行缓冲。如果指定的缓冲值作为大于1的整数，那么缓冲操作将被用指定缓冲器大小进行。这是可选的参数。

这里是打开一个文件的不同模式的列表：

文件对象的属性：

一旦文件被打开，就有一个文件对象，可以得到有关该文件的各种信息。

下面是文件对象相关的所有属性的列表：

close() 方法

一个文件对象的close()方法刷新未写入所有信息，并关闭文件对象，之后的数据写入将出错。

fileObject.close();

读取和写入文件

write() 方法:

语法

fileObject.write(string);

read() 方法

语法

fileObject.read([count]);

文件位置

tell()方法告诉文件内的当前位置，下一个读或写将从该文件的开头起计算经过的字节数长度：

seek(offset[, from])方法改变当前文件的位置。offset参数指示要移动的字节数。from参数指定从什么位置起参考要要移动字节数。

如果from设置为0，这意味着使用该文件的开头作为基准位置，，设置1时使用当前位置作为基准位置，如果它被设置为2，则该文件的末尾将作为基准位置。

重命名和删除文件

语法

os.rename(current_file_name, new_file_name)

remove() 方法

语法

os.remove(file_name)

Python中的目录

mkdir() 方法:

可以使用os模块中的mkdir()方法在当前目录下创建目录。需要提供参数到这个方法，其中包含的目录是要创建的目录的名称。

语法

os.mkdir("newdir")

chdir() 方法

可以使用chdir()方法来改变当前目录。chdir()方法接受一个参数，就是要进入目录的目录名称。

语法

os.chdir("newdir")

getcwd() 方法

getcwd() 方法显示当前的工作目录。

语法

os.getcwd()

rmdir() 方法

rmdir()方法删除目录，这是通过作为方法的参数（目录）。

在删除一个目录，其中的所有内容都会被删除。

语法

os.rmdir('dirname')

处理异常

如果有一些可疑代码可能会引发异常，可以通过将可疑代码放在一个try: 块以防程序出现问题。在 try: 块之后, 包含一个 except: 语句, 接着是它的代码块尽可能优雅处理问题。

语法

以下是简单的 try....except...else 块的语法:

try:
   Do you operations here;
   ......................
except ExceptionI:
   If there is ExceptionI, then execute this block.
except ExceptionII:
   If there is ExceptionII, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

这里有一些关于上面提到的语法要点：

一个try语句可以有多个except语句。当try块包含了可能抛出不同类型的异常声明这是非常有用的。

也可以提供一个通用的except子句，来处理任何异常。

except子句后，可以包括一个 else 子句。在else块中的代码，如果在try:块执行代码没有引发异常。

else区块代码是不需要try:块的保护的。

except子句没有异常

也可以使用除具有如下定义没有异常声明：

try:
   Do you operations here;
   ......................
except:
   If there is any exception, then execute this block.
   ......................
else:
   If there is no exception then execute this block.

except子句与多个异常

也可以使用相同的 except 语句来处理多个异常，如下所示：

try:
   Do you operations here;
   ......................
except(Exception1[, Exception2[,...ExceptionN]]]):
   If there is any exception from the given exception list, 
   then execute this block.
   ......................
else:
   If there is no exception then execute this block.

标准异常

这是在Python提供一个标准异常的列表：标准异常

try-finally 子句

可以使用try:块连同try:块一起。finally块是一个地方放置代码必须执行，无论在try块是否引发异常代码都会执行。try-finally语句的语法是这样的：

try:
   Do you operations here;
   ......................
   Due to any exception, this may be skipped.
finally:
   This would always be executed.
   ......................

发生异常的参数

一个异常可以有一个参数，它是一个值，该值给出了有关问题的其他信息。异常参数的内容各不相同。可以通过不同的子句中提供的变量，捕获异常的参数如下所示：

try:
   Do you operations here;
   ......................
except ExceptionType, Argument:
   You can print value of Argument here...

引发一个异常

可以通过使用 raise 语句的几种方式引发异常。一般 raise 语句的语法。

语法

raise [Exception [, args [, traceback]]]

用户定义的异常

Python中，还可以通过内置的异常标准的派生类来创建自己的异常类。

这里是一个例子有关 RuntimeError. 这里说的是从 RuntimeError 类创建一个子类。当需要显示更具体的信息时，一个异常被捕获，这非常有用。

在try块，用户定义的异常引发，陷入在 except 块中。变量e被用来创建 Networkerror 类的一个实例。

class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg

所以一旦上面的类定义后，可以按如下引发的异常：

try:
   raise Networkerror("Bad hostname")
except Networkerror,e:
   print e.args

创建类

class语句创建一个新的类定义。类的名称紧跟在关键字class后，接着又跟一个冒号，如下所示：

class ClassName:
'Optional class documentation string'
class_suite

这个类可以通过 ClassName.__doc__ 访问一个文档字符串

class_suite包括所有组件语句，定义类成员，数据属性和函数。

创建实例对象：

要创建一个类的实例，调用类使用类名和传递参数给__init__方法接收。

"This would create first object of Employee class"
emp1 = Employee("Zara", 2000)
"This would create second object of Employee class"
emp2 = Employee("Manni", 5000)

访问属性

可以访问使用点(.)对象的运算符来访问对象的属性。类变量会使用类名来访问，如下所示：

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

内置类的属性

每个Python类保存有下列内置属性，它们可以使用点运算符像任何其他属性来访问：

__dict__ : 字典包含类的命名空间。

__doc__ : 类文档字符串，或者如果是None那么表示未定义。

__name__: 类名

__module__: 其中类定义的模块名称。此属性在交互模式为“__main__”。

__bases__ : 一个可能为空的元组包含基类，其基类列表为出现的顺序。

销毁对象（垃圾回收）

Python删除不需要的对象（内置类型或类实例）会自动释放内存空间。由Python周期性回收的内存块，不再是在使用过程中回收被称为垃圾收集。

Python的垃圾收集程序执行过程中运行，当一个对象的引用计数为零时被触发。一个对象的引用计数变化为别名的数量指向它改变：

当它分配一个新的名称或放置在容器（列表，元组，或字典）的对象的引用计数增加。当它使用 del 删除对象减少引用计数 ,它引用被重新分配，或者其参考超出作用域。当一个对象的引用计数为零，Python会自动收集它。

类继承

相反，从头开始，可以通过在新类名称后列表括号中的父类，从预先存在的类派生它来创建一个类：

子类继承父类的属性，可以使用这些属性，就好像是在子类中定义一样。从父类，子类还可以重写数据成员和方法。

语法

派生类的声明很像它们的父类;然而，从类名之后给出继承的基类的列表：

class SubClassName (ParentClass1[, ParentClass2, ...]):
'Optional class documentation string'class_suite

重载方法

随时可以覆盖父类的方法。其中一个覆盖父类方法的原因，是因为可能想在在子类中特殊或实现不同的功能。

class Parent:# define parent class
def myMethod(self):
print 'Calling parent method'
class Child(Parent): # define child class
def myMethod(self):
print 'Calling child method'
c = Child() # instance of child
c.myMethod() # child calls overridden method

重载方法的基础

下表列出了一些通用的功能，可以在自己的类中覆盖：

运算符重载

假设我们已经创建了一个Vector类来表示二维向量。当使用加运算符来添加它们，会发生什么？最有可能Python会责骂我们。

但是可以定义 __add__ 方法类进行向量加法，然后相加运算符的行为也会按预期：

#!/usr/bin/python
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
 def __str__(self):
 return 'Vector (%d, %d)' % (self.a, self.b)
 def __add__(self,other):
 return Vector(self.a + other.a, self.b + other.b)
 v1 = Vector(2,10)
 v2 = Vector(5,-2)
 print v1 + v2

数据隐藏

一个对象的属性可以或不可以在类定义外部可见。对于这些情况，可以命名以双下划线前缀属性，这些属性将不会直接外部可见：

#!/usr/bin/python
class JustCounter:
__secretCount = 0
def count(self):
self.__secretCount += 1
print self.__secretCount
counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

正则表达式是字符的特殊序列，可帮助匹配或查找其他字符串或设置字符串，使用模式在特殊的语法。正则表达式被广泛应用于UNIX的世界中。

Python中的模块re提供了Perl般的正则表达式的全面支持。如果在编译或使用正则表达式时发生错误，re模块引发异常re.error。

我们将包括在其中将用于处理的正则表达式的两个重要功能。但是，首先：当它们在正则表达式中使用这此字符将有特殊的含义。为了避免任何混乱当使用正则表达式处理时，我们会用原始字符串为 r'expression'.

match 函数

此函数尝试重新模式匹配字符串并可选标志（flags）。

下面是此函数的语法：