python.docx

python.docx

《python.docx》由会员分享，可在线阅读，更多相关《python.docx（17页珍藏版）》请在冰点文库上搜索。

python

如果要在代码中使用中文注释,则必须在Python代码的开始位置加上注释说明语句#-*-coding:

UTF-8-*-。

如果python代码可能在windows操作系统以外的平台下运行，则需要在python代码的开始位置加上注释说明语句#！

/user/bin/python。

\作为换行符，这种做法叫做“行连接”

类的私有变量和私有方法则以两个下划线作为前缀。

私有变量__name

私有方法__getName__

使用Python语言定义的type类查询变量的类型。

type类是内置模块（__builtin__）的一个类，它将返回变量的一个类型或创建一个新的类型

Python的内置模块__builtin__定义了软件开发过程中经常使用的函数。

全局变量指的是能够被不同的函数、类或文件所共享的变量。

全局变量可以被文件内部的任何函数访问，也可以被外部文件访问。

一般情况下,在函数块之外定义的变量都可以认为是全局变量。

最好在文件的开始位置定义全局变量。

使用global语句来声明全局变量。

很多情况下，两个变量名相同的变量并非表示同一个变量，变量名只是变量的标识符。

相同的变量名出现在代码的不同位置，含义往往是不同的。

局部变量指的是只能在函数或代码块范围内使用的变量。

Python语言是面向对象编程的语言，程序中任何“东西”都被称为“对象”，因此变量也是对象。

Python语言中主要包括3种文件类型：

源代码文件（扩展名.py或.pyw）、字节代码文件（.pyc）和优先代码文件（.pyo）

扩展名为.pyw的源代码文件专门用于开发图形用户界面，由pythonw.exe解释执行。

Python语言中包含元组（tuple）、列表（list）、字典（dictionary）、序列（sequence）

等内置数据结构。

元组由一系列元素组成，且每个元素可以存储不同类型的数据（如字符串、数字）。

元组中的元素一旦被确定就不能对其修改。

tuple_name=（元素1，元素2，…）

元组的访问主要包括两种方式：

索引（index）、切片（slice）

元组还可以负数索引和切片索引

tuple_name[0]表示第一个数tuple_name[-1]表示最后一个数

tuple_name[m:

n]冒号一定要有，m和n可有可无：

即访问元组第m+1个元素开始，到第n+1个数结束（不包括第n+1个元素）。

负数也可以做切片tuple_name[:

-1]

创建元组的过程叫做打包；将元组各个元素赋值给多个变量的过程称为解包

列表指的是能够存储有序元素的数据结构。

列表中的元素可以改变。

可以使用append（）方法为列表添加元素，使用remove（）方法删除列表中的元素。

Insert（）：

将元素插入指定位置。

pop（）：

弹出列表中的最后一个元素，移除列表中的最后一个元素。

extend（）将列表中的元素添加到指定列表末尾处。

list_name=[元素1，元素2，…]

dir（list）

help（list）

字典（dictionary）将键与值进行关联，键必须是唯一，键必须选用不可变对象（例如字符串）；值则既可以是可变对象，也可以是不可变对象

字典就是使用键—值对（key-value）来表示的内置数据结构。

d={key1:

value1,key2:

value2}

编写赋值语句就可以向字典中添加或修改元素，操作起来非常简单

d[“k1”]=”k1_value”

调用del（）函数可以删除字典中的元素，调用clear（）函数则可以清空字典中的所有键-值对。

使用for…in循环或字典的items（）方法可以对字典中所有的键-对进行遍历。

序列（sequence）前面介绍的元组、列表、字符串都属于序列。

序列的两个主要特征是：

索引操作和切片操作。

索引操作可以从序列中获取需要的元素，而切片操作则可以获取序列中的部分元素。

条件语句（if…elif…else）

If（表达式）：

语句1

else:

语句2

If（表达式）：

语句1

elif（表达式2）：

语句2

else:

语句3

Python语言中的控制台输入函数input（）和raw_input（）。

Input（）函数支持输入数字或表达式，但是不支持输入字符串。

该函数的声明语句为：

input（[prompt]）->value

参数prompt指的是控制台输出的提示输入信息，返回数字类型的值。

raw_input（[prompt]）->string

返回字符串类型的值。

如果需要对返回值进行数值计算，则必须使用int（）或float（）函数将返回值进行转换。

while循环

while（表达式）：

...

else:

…

else语句可以省略，表达式两侧的括号也可以省略

for…in…循环一般用于遍历某个集合（元组、列表、字典等内置数据结构），它将以此访问集合中的每个元素。

forvariableinset:

…

else

…

执行过程中，每次循环都从set中取出1个值，并把该值赋予variable。

for…in…循环通常与range（）函数一起使用。

由于range（）函数将返回1个列表，for…in…循环将遍历列表中的每一个元素。

break语句和continue语句用于控制语句的跳转。

break语句终止执行循环语句，continue语句告知Python语句跳过当前循环体中的剩余语句，继续进行下一轮循环。

Python语言的源代码一般由函数（function）、模块（module）、包（package）组成。

函数中包含可以重复调用的代码，通过输入参数来返回计算结果；模块则是处理某一类问题的函数和类的集合；包则是有一系列模块组成的集合。

函数的定义

def函数名（参数1[=默认值1]，参数2[=默认值2]，…）:

…

return表达式

函数的返回值使用return（）语句，后面可以跟变量或表达式。

如果return语句不带任何参数，返回值为“None”。

“None”也是Python语言中的对象，它既不是数字类型也不是字符串类型。

递归函数

在函数体内直接或间接调用自身的函数称为递归函数

递归函数的实现分为递推和回归两个过程：

递推：

函数调用自身的过程。

每次调用都重新执行函数体中的代码，直到满足递归结束条件为止。

回归：

函数从后向前返回的过程。

递归函数调用完毕，再按照相反的顺序逐级返回

lambda函数

功能是创建匿名函数。

其只能使用变量和表达式，而不允许使用条件判断语句和循环语句。

因此，lambda函数也可以称为表达式函数

lambdavariable1,variable2…:

expression

如果将lambda函数赋值给变量，该变量也可以作为函数使用。

func1=lambdavariable1,variable2…:

expression

func1（）

除了将lambda函数作为变量使用之外，编写程序时还可以直接使用该函数。

print（lambdax:

x*x）（3）定义了匿名函数（没有函数名）lambdax:

x*x，用来返回x^2

Generator函数

功能是每次生成并输出1个数据项，一般用于for…in循环中对数据项进行遍历，也可以用于迭代计算。

def函数名（形参列表）：

…

yield表达式

Generator函数使用保留字yield来返回生成的数据项，而普通函数使用保留字return返回函数的计算结果。

yield保留字不会终止程序的执行，返回数据后程序继续向后执行；而return保留字返回值后，程序将终止执行。

模块（module）

模块指的是包含变量、函数和类的文件，一个Python文件（扩展名.py）就是一个模块。

导入模块的格式为：

importmodule_name

调用模块中的函数或类时，必须使用模块名作为前缀。

module_name.func（）表示将调用module_name中的函数func（）。

使用from…import…语句也可以导入模块，格式如下：

frommodule_nameimportfunction_name

上述语句表示从module_name中导入函数function_name。

此时，调用函数function_name时无需使用模块名作为前缀。

1）导入模块中的所有类和函数,使用下列导入语句:

frommodule_nameimport*

2）只导入模块中的某个类或函数

frommodule_nameimportfunction_name

3）如果导入模块的类名或函数名太长,可以使用as语句将类名或函数名命名为较短的别名，并使用别名作为类名或函数名来使用

frommodule_nameimportfunction_nameasshort_alias_name

建立新的Python文件import_module.py，用来调用create_module.py中的变量和函数。

由于使用import语句导入模块，访问模块中的变量和函数时，必须使用模块名作为前缀。

sys（system的缩写）模块中包含于Python解释器及其环境的相关函数

学习Python语言的过程中，读者应该经常会用help（）、type（）、dir（）、__members__、

__methods__来获取对象中的信息，以帮助快速编程。

apply（）函数能够调用由可变参数组成的列表，并允许将参数存放在元组或序列中。

apply（func,[,args[,kwargs]]）

func表示自定义函数名

参数args表示func函数中各参数组成的列表或元组。

如果不包含参数args，则表示函数中没有任何参数。

参数kwargs表示一个字典，字典中的键（key）指的是函数的参数名，值（value）指的是实参值

apply（）的返回值就是自定义函数func（）的返回值

filter（funcorNone,sequence）->list,tuple,orstring

参数sequence表示待处理的序列

filter（）函数将返回由func（）返回值组成的序列，序列的类型与参数sequence的类型相同

过滤函数func（）中必须包含形参用来存储序列（sequence）中的变量，否则，无法对函数func（）进行过滤。

map（）函数可以对多个序列的每个元素执行相同的操作，并返回由计算结果组成的列表。

map（func，sequence[,sequence,…]）->list

如果map（）函数中给出多个序列参数，则将序列中的元素一一对应进行计算。

如果序列的长度不完全相同，则在较短序列后面使用“None”对象补齐元素，然后再进行计算。

reduce（）函数是对序列中的元素进行连续处理，与循环语句的功能类似

reduce（func,sequence[,initial]）->value

initial可以省略。

如果initial非空，则将initial值传递到func（）中进行计算。

如果sequence参数为空，则对initial值进行计算。

defsum（x,y）:

returnx+y

printreduce（sum,range（5,10））

printreduce（sum,range（5,10）,5）

printreduce（sum,range（5,5）,5）

35

40

5

包（package）

指由一系列模块组成的集合，也是完成某些特定任务的工具箱，使用包可以重复使用程序。

包中至少包含一个由__init__.py文件组成的文件夹，__init__.py文件的功能是标识当前文件夹是一个包，相当于包的注册文件，该文件的内容可以为空。

定义类

classclass_name:

class_name类名首字母大写

创建对象的过程称为实例化。

创建一个对象后，该对象包含3个方面的特性：

句柄、属性和方法。

句柄用于区分不同的对象，创建对象后，它将获取一块存储空间，存储空间的地址即为对象的标识

如果函数、方法或属性的名称以两个下划线开始，则表示私有属性。

类的属性又分为静态属性和实例属性：

1、实例属性指的是以self作为前缀的属性。

__init__方法是Python类的构造函数，如果该方法中定义的变量没有使用self最为前缀，则表示该变量只是普通的局部变量。

类中其他方法定义的变量也只是局部变量，而非类的实例属性

2、静态属性指的是静态变量。

类可以直接调用静态变量，但是实例化对象却不能够调用静态变量。

创建新的实例化对象后，静态变量并不会获取新的内存空间，而仍然使用创建类后静态变量的内存空间。

因此，多个实例化对象可以共享静态变量。

Python语言可以使用staticmethod（）函数或者“@staticmethod”命令将普通函数转换为静态方法，静态方法属于全局函数，而没有与类的实例进行名称绑定。

Python语言中还包含一种与静态方法类似的类方法，必须提供self参数，还可以被其他实例对象共享。

该类方法可以使用classmethod（）函数或“@classmethod”命令进行定义。

类方法与静态方法的使用非常相似。

如果某个方法既需要被其他实例共享，又需要使用当前实例的属性，则可将其定义为类方法。

构造函数用来初始化类的内部状态并为类的属性设置默认值，Python语言的构造方法为__init__。

根据情况，__init__方法也可以不进行定义。

Python语言中提供了析构函数__del__（），用来释放对象所占用的资源。

析构函数也是可选的，如果程序中未提供析构函数，Python语言将在后台中提供默认的析构函数。

Python语言允许在类的内部定义类（inclass）。

有两种调用内部类的方法：

1.直接使用外部类来调用内部类，生成内部类的实例，再调用内部类的方法。

object_name=outclass_name.inclass_name（）

object_name.method（）

2.先对外部类进行实例化，再实例化内部类，最后调用内部类的方法

out_name=outclass_name（）

in_name=out_name.inclass_name（）

in_name.method（）

采用垃圾回收机制来清除对象。

Python语言中的gc模块专门用来释放不再使用的对象,它采用”引用技术算法”确定是否需要回收某个对象。

如果某个对象不再被其他对象引用时，Python语言将自动清除该对象。

collect（）函数可以一次性收集所有待处理的对象。

importgc

classAnimal:

def__init__（self,name,color）:

self.__name=name

self.__color=color

defsetName（self）:

self.__name=name

defsetColor（self）:

self.__color=color

classAnimalToys:

def__init__（self）:

#为AnimalToys类定义了属性animaltoys，用来存放动物玩具店中的动物，它是一个列表

self.animaltoys=[]

defaddAnimal（self,animal）:

#添加动物玩具定义了addAnimal（）方法，用来将对象animal添加到animaltoys列表中。

animal.parent=self#将Animal类关联到AnimalToys类设置animal对象的parent属性为self，即：

把AnimalToys实例化对象的引用关联到添加的animal对象上

self.animaltoys.append（animal）

if__name__==”__main__”:

toys=AnimalToys（）

toys.addAnimal（Animal（“monkey”,”blcak”））#向toys对象添加两个animal对象

toys.addAnimal（Animal（“tiger”,”yellow”））

printgc.get_referrers（toys）#调用gc模块中的函数get_referrers（）列出与toys对象关联的所有对象

deltoys#删除对象toys，但是与toys对象关联的其他对象并未释放

printgc.collect（）#释放与toys对象关联的其他对象

继承（inheritance）

对于两个类来说，继承指的是父子关系，子类继承父类的所有公有实例变量和方法。

Python语言中通过在类名后面使用一对圆括号的方式来表示继承关系，括号中的类表示父类。

如果父类定义了__init__方法，子类必须显示调用父类的__init__方法。

如果子类需要扩展父类的行为，可以添加__init__f方法中的参数。

多重继承

如果一个子类可以继承多个父类，则称为多重继承。

class_name（parent_class1,parent_class2,…）

多态性（polymorphism）

如果相同信息被不同类型的对象接收时，有可能出现完全不同的行为则称为多态性。

类的成员函数能够根据被调用的对象类型自动调整其行为。

文件

文件的创建或打开

调用file（）函数可以创建或打开文件。

file（name[,mode[,buffering]]）fileobject

file（）函数将返回一个file对象，以便执行各种文件操作

读取文件的方法有三种:

1.一次性读取文件的所有信息,需要调用read（），并赋值给一个变量。

2.按行读取文件的信息，需要调用readline（）

3.一次读取文件的多行信息，需要调用readlines（），读取文件时，需要通过循环语句来访问readlines（）返回列表中的元素

写入文件有write（）和writelines（）

删除和重命名文件时需要导入os模块和os.path模块：

os模块中提供了系统环境、文件、目录等系统级的接口函数；os.path模块则用于处理文件和目录的路径。

Python语言包含另一个标准模块pickle（也可称其为永久存储器），它的功能是：

存储文件中的任意Python对象，并可以根据需要从文件中取出关心的对象。

Python语言中还包含cPickle，其功能跟pickle模块完全一样，唯一区别cPickle模块使用C语言编写，执行效率比pickle模块快1000倍左右。

异常指的是能够解决的Python对象,异常处理则是处理程序运行过程中的错误。

Exception类是最常用的异常类，包括：

StandardError、StopIteration、GeneratorExit、Warning等异常类。

如果在读取文件的过程中，无论是否发生异常都希望关闭文件，则可以使用try…..finally语句实现。

打开文件open（name[,mode[,buffering]]））

假如名为somefile.txt的文本文件其存储路径是c:

\text,那么可以像下面这样打开文件

f=open（r’C:

\text\somefile.txt’）

缓冲open函数第三个参数（可选）控制着文件的缓冲。

如果是0/False，I/O就是无缓冲的（所有读写操作都直接针对硬盘）；如果是1/True，I/O就是有缓冲的（意味着Python使用内存来代替硬盘，让程序更快，只有使用Flush或者close是才会更新硬盘上的数据）大于1的数字代表缓冲区的大小（单位是字节），-1（或者任何负数）代表使用默认的缓冲区大小。

管式输出

在UNIX的shell（就像GNUbash）中，使用管道可以在一个命令后面续写其他的多个命令，就像下面的例子（假如是GNUbash）

$catsomefile.txt|pythonsomescript.py|sort

这个管道（pipeline）由一下3个命令组成

1.catsomefile.txt：

只要把somefile.txt的内容写到标准输出（sys.stdout）

2.pythonsomescript.py：

这个命令运行了Python脚本somescript。

脚本应该是从标准输入读，把结果写入到标准输出

3.sort：

这条命令从标准输入（sys.stdin）读取所有的文本，按字母排序，然后把结果写入标准输出

管道符号（|）将一个命令的标准输出和下一个命令的标准输入连在一起。

这样就知道somescript.py会从它的sys.stdin中读取数据（catsomefile.txt写入的），并把结果写入到它的sys.stdout中（sort在此得到数据）

实际上，在文件中随意移动读取位置也是可以的，可以使用类文件对象seek和tell来直接访问感兴趣的部分（称为随机访问）

seek（offset[,whence]）:

这个方法把当前位置（进行读和写的位置）移动到由offset定义的位置。

whence.offset是一个字节（字符）数，whence默认是0，也就说偏移量是从文件开头开始计算的。

（偏移量必须是非负的）。

whence可能被设置为1（相当于当前位置的移动，offset可以是负的）或者2（相当于文件结尾的移动）

tell方法返回当前文件的位置

对文件内容进行迭代

在这部分的所有例子中都是用了名为process的虚拟函数，用来表示每个字符或每行的处理过程。

读者也可以用你喜欢的方法实现这个函数。

defprocess（string）：

print“Processing:

”,string

按字节处理

在while循环中使用read方法

f=open（）

char=f.read

（1）

whilechar:

process（char）

char=f.read

（1）

f.close（）

此方法不好

f=open（）

whileTrue:

char=f.read

（1）

ifnotchar:

break

process（char）

f.close（）

读取所有内容

f=open（filename）

forcharinf.read（）:

process（char）

f.close（）

f=open（filename）

forlineinf.readlines（）:

process（line）

f.close（）

使用fileinput实现懒惰行迭代

在需要对一个非常大的文件进行迭代行的操作时，readlines会占用太多的内存。

这个时候可以使用while和readline方法来替代。

当然Python中如果能使用for循环，那么它就是首选。

本例恰好可以使用for循环可以使用一个名为懒惰行迭代的方法：

说它懒惰是因为它只是读取实际需要的文件部分。

fileinput

fileinput模块能让你能够轻松的遍历文本文件的所有行。

如果通过以下方式调用脚本

$pythonsome_script.pyfile1.txtfile2.txtfile3.txt

这样就可以依次对file1.txt到file3.txt文件中的所