Python3提升教程二个人整理.docx

Python3提升教程二个人整理.docx

《Python3提升教程二个人整理.docx》由会员分享，可在线阅读，更多相关《Python3提升教程二个人整理.docx（18页珍藏版）》请在冰豆网上搜索。

Python3提升教程二个人整理

Python3数据结构

本章节我们主要结合前面所学的知识点来介绍Python数据结构。

列表

Python中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：

列表可以修改，而字符串和元组不能。

以下是Python中列表的方法：

下面示例演示了列表的大部分方法：

注意：

类似insert,remove或sort等修改列表的方法没有返回值。

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。

用append（）方法可以把一个元素添加到堆栈顶。

用不指定索引的pop（）方法可以把一个元素从堆栈顶释放出来。

例如：

将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。

在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

列表推导式提供了从序列创建列表的简单途径。

通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在for之后跟一个表达式，然后有零到多个for或if子句。

返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。

如果希望表达式推导出一个元组，就必须使用括号。

这里我们将列表中每个数值乘三，获得一个新的列表：

>>> vec = [2, 4, 6]

>>> [3*x for x in vec]

[6, 12, 18]

现在我们玩一点小花样：

>>> [[x, x**2] for x in vec]

[[2, 4], [4, 16], [6, 36]]

这里我们对序列里每一个元素逐个调用某方法：

我们可以用if子句作为过滤器：

以下是一些关于循环和其它技巧的演示：

列表推导式可以使用复杂表达式或嵌套函数：

>>> [str（round（355/113, i）） for i in range（1, 6）]

['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

Python的列表还可以嵌套。

以下实例展示了3X4的矩阵列表：

以下实例将3X4的矩阵列表转换为4X3列表：

>>> [[row[i] for row in matrix] for i in range（4）]

[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

以下实例也可以使用以下方法来实现：

>>> transposed = []

>>> for i in range（4）:

...   transposed.append（[row[i] for row in matrix]）

...

>>> transposed

[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

另外一种实现方法：

>>> transposed = []

>>> for i in range（4）:

...   #thefollowing3linesimplementthenestedlistcomp

...   transposed_row = []

...   for row in matrix:

...     transposed_row.append（row[i]）

...   transposed.append（transposed_row）

...

>>> transposed

[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

del语句

使用del语句可以从一个列表中依索引而不是值来删除一个元素。

这与使用pop（）返回一个值不同。

可以用del语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。

例如：

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]

>>> del a[0]

>>> a

[1, 66.25, 333, 333, 1234.5]

>>> del a[2:

4]

>>> a

[1, 66.25, 1234.5]

>>> del a[:

]

>>> a

[]

也可以用del删除实体变量：

>>>dela

元组和序列

元组由若干逗号分隔的值组成，例如：

>>> t = 12345, 54321, 'hello!

'

>>> t[0]

12345

>>> t

（12345, 54321, 'hello!

'）

>>> #Tuplesmaybenested:

... u = t, （1, 2, 3, 4, 5）

>>> u

（（12345, 54321, 'hello!

'）, （1, 2, 3, 4, 5））

如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。

在输入时可能有或没有括号，不过括号通常是必须的（如果元组是更大的表达式的一部分）。

集合

集合是一个无序不重复元素的集。

基本功能包括关系测试和消除重复元素。

可以用大括号（{}）创建集合。

注意：

如果要创建一个空集合，你必须用set（）而不是{}；后者创建一个空的字典，下一节我们会介绍这个数据结构。

以下是一个简单的演示：

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

>>> print（basket）            #删除重复的

{'orange', 'banana', 'pear', 'apple'}

>>> 'orange' in basket         #检测成员

True

>>> 'crabgrass' in basket

False

>>> #以下演示了两个集合的操作

...

>>> a = set（'abracadabra'）

>>> b = set（'alacazam'）

>>> a                 #a中唯一的字母

{'a', 'r', 'b', 'c', 'd'}

>>> a-b               #在a中的字母，但不在b中

{'r', 'd', 'b'}

>>> a|b               #在a或b中的字母

{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

>>> a&b               #在a和b中都有的字母

{'a', 'c'}

>>> a^b               #在a或b中的字母，但不同时在a和b中

{'r', 'd', 'b', 'm', 'z', 'l'}

集合也支持推导式：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}

>>> a

{'r', 'd'}

字典

另一个非常有用的Python内建数据类型是字典。

序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或数值。

理解字典的最佳方式是把它看做无序的键=>值对集合。

在同一个字典之内，关键字必须是互不相同。

一对大括号创建一个空的字典：

{}。

这是一个字典运用的简单例子：

>>> tel = {'jack':

 4098, 'sape':

 4139}

>>> tel['guido'] = 4127

>>> tel

{'sape':

 4139, 'guido':

 4127, 'jack':

 4098}

>>> tel['jack']

4098

>>> del tel['sape']

>>> tel['irv'] = 4127

>>> tel

{'guido':

 4127, 'irv':

 4127, 'jack':

 4098}

>>> list（tel.keys（））

['irv', 'guido', 'jack']

>>> sorted（tel.keys（））

['guido', 'irv', 'jack']

>>> 'guido' in tel

True

>>> 'jack' not in tel

False

构造函数dict（）直接从键值对元组列表中构建字典。

如果有固定的模式，列表推导式指定特定的键值对：

>>> dict（[（'sape', 4139）, （'guido', 4127）, （'jack', 4098）]）

{'sape':

 4139, 'jack':

 4098, 'guido':

 4127}

此外，字典推导可以用来创建任意键和值的表达式词典：

>>> {x:

x**2 for x in （2, 4, 6）}

{2:

 4, 4:

 16, 6:

 36}

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：

>>> dict（sape=4139, guido=4127, jack=4098）

{'sape':

 4139, 'jack':

 4098, 'guido':

 4127}

遍历技巧

在字典中遍历时，关键字和对应的值可以使用items（）方法同时解读出来：

>>> knights = {'gallahad':

 'thepure', 'robin':

 'thebrave'}

>>> for k, v in knights.items（）:

...   print（k, v）

...

gallahad thepure

robinthebrave

在序列中遍历时，索引位置和对应值可以使用enumerate（）函数同时得到：

>>> for i, v in enumerate（['tic', 'tac', 'toe']）:

...   print（i, v）

...

0 tic

1 tac

2 toe

同时遍历两个或更多的序列，可以使用zip（）组合：

>>> questions = ['name', 'quest', 'favoritecolor']

>>> answers = ['lancelot', 'theholygrail', 'blue']

>>> for q, a in zip（questions, answers）:

...   print（'Whatisyour{0}?

 Itis{1}.'.format（q, a））

...

What is yourname?

 It is lancelot.

What is yourquest?

 It is theholygrail.

What is yourfavoritecolor?

 It is blue.

要反向遍历一个序列，首先指定这个序列，然后调用reversed（）函数：

>>> for i in reversed（range（1, 10, 2））:

...   print（i）

...

9

7

5

3

1

要按顺序遍历一个序列，使用sorted（）函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> for f in sorted（set（basket））:

...   print（f）

...

apple

banana

orange

pear

Python3模块

在前面的几个章节中我们脚本上是用python解释器来编程，如果你从Python解释器退出再进入，那么你定义的所有的方法和变量就都消失了。

为此Python提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。

模块可以被别的程序引入，以使用该模块中的函数等功能。

这也是使用python标准库的方法。

下面是一个使用python标准库中模块的例子。

执行结果如下所示：

$pythonusing_sys.py参数1参数2

命令行参数如下:

using_sys.py

参数1

参数2

Python路径为：

['/root','/usr/lib/python3.4','/usr/lib/python3.4/plat-x86_64-linux-gnu','/usr/lib/python3.4/lib-dynload','/usr/local/lib/python3.4/dist-packages','/usr/lib/python3/dist-packages']

∙1、importsys引入python标准库中的sys.py模块；这是引入某一模块的方法。

∙2、sys.argv是一个包含命令行参数的列表。

∙3、sys.path包含了一个Python解释器自动查找所需模块的路径的列表。

import语句

想使用Python源文件，只需在另一个源文件里执行import语句，语法如下：

importmodule1[,module2[,...moduleN]

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

如想要导入模块support，需要把命令放在脚本的顶端：

est.py引入support模块：

以上实例输出结果：

$python3test.py

Hello:

Runoob

一个模块只会被导入一次，不管你执行了多少次import。

这样可以防止导入模块被一遍又一遍地执行。

当我们使用import语句的时候，Python解释器是怎样找到对应的文件的呢？

这就涉及到Python的搜索路径，搜索路径是由一系列目录名组成的，Python解释器就依次从这些目录中去寻找所引入的模块。

这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。

搜索路径是在Python编译或安装的时候确定的，安装新的库应该也会修改。

搜索路径被存储在sys模块中的path变量，做一个简单的实验，在交互式解释器中，输入以下代码：

>>>importsys

>>>sys.path

['','/usr/lib/python3.4','/usr/lib/python3.4/plat-x86_64-linux-gnu','/usr/lib/python3.4/lib-dynload','/usr/local/lib/python3.4/dist-packages','/usr/lib/python3/dist-packages']

>>>

sys.path输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出是哪个目录），亦即我们执行python解释器的目录（对于脚本的话就是运行的脚本所在的目录）。

因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。

了解了搜索路径的概念，就可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

现在，在解释器的当前目录或者sys.path中的一个目录里面来创建一个fibo.py的文件，代码如下：

然后进入Python解释器，使用下面的命令导入这个模块：

>>>importfibo

这样做并没有把直接定义在fibo中的函数名称写入到当前符号表里，只是把模块fibo的名字写到了那里。

可以使用模块名称来访问函数：

如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：

>>>fib=fibo.fib

>>>fib（500）

1123581321345589144233377

from…import语句

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：

frommodnameimportname1[,name2[,...nameN]]

例如，要导入模块fibo的fib函数，使用如下语句：

>>>fromfiboimportfib,fib2

>>>fib（500）

1123581321345589144233377

这个声明不会把整个fibo模块导入到当前的命名空间中，它只会将fibo里的fib函数引入进来。

from…import*语句

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

frommodnameimport*

这提供了一个简单的方法来导入一个模块中的所有项目。

然而这种声明不该被过多地使用。

深入模块

模块除了方法定义，还可以包括可执行的代码。

这些代码一般用来初始化这个模块。

这些代码只有在第一次被导入时才会被执行。

每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。

所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞混。

从另一个方面，当你确实知道你在做什么的话，你也可以通过modname.itemname这样的表示法来访问模块内的函数。

模块是可以导入其他模块的。

在一个模块（或者脚本，或者其他地方）的最前面使用import来导入一个模块，当然这只是一个惯例，而不是强制的。

被导入的模块的名称将被放入当前操作的模块的符号表中。

还有一种导入的方法，可以使用import直接把模块内（函数，变量的）名称导入到当前操作模块。

比如:

>>>fromfiboimportfib,fib2

>>>fib（500）

1123581321345589144233377

这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面，fibo这个名称是没有定义的）。

这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:

>>>fromfiboimport*

>>>fib（500）

1123581321345589144233377

这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。

大多数情况，Python程序员不使用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。

__name__属性

一个模块被另一个程序第一次引入时，其主程序将运行。

如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

#!

/usr/bin/python3

#Filename:

using_name.py

if__name__=='__main__':

print（'程序自身在运行'）

else:

print（'我来自另一模块'）

运行输出如下：

$pythonusing_name.py

程序自身在运行

$python

>>>importusing_name

我来自另一模块

>>>

说明：

 每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。

说明：

__name__ 与 __main__ 底下是双下划线， __ 是这样去掉中间的那个空格。

dir（）函数

内置的函数dir（）可以找到模块内定义的所有名称。

以一个字符串列表的形式返回:

>>>importfibo,sys

>>>dir（fibo）

['__name__','fib','fib2']

>>>dir（sys）

['__displayhook__','__doc__','__excepthook__','__loader__','__name__',

'__package__','__stderr__','__stdin__','__stdout__',

'_clear_type_cache','_current_frames','_debugmallocstats','_getframe',

'_home','_mercurial','_xoptions','abiflags','api_version','argv',

'base_exec_prefix','base_prefix','builtin_module_names','byteorder',

'call_tracing','callstats','copyright','displayhook',

'dont_write_bytecode','exc_info','excepthook','exec_prefix',

'executable','exit','flags','float_info','float_repr_style',

'getcheckinterval','getdefaultencoding','getdlopenflags',

'getfilesystemencoding','getobjects','getprofile','getrecursionlimit',

'getrefcount','getsizeof','getswitchinterval','gettotalrefcount',

'gettrace','hash_info','hexversion','implementation','int_info',

'intern','maxsize','maxunicode','meta_path','modules','path',

'path_hooks','path_importer_cache','platform','prefix','ps1',

'setcheckinterval','setdlopenflags','setprofile','setrecursionlimit',

'setswitchinterval','settrace','stderr','stdin','stdout',

'thread_info','version','version_info','warnoptions']

如果没有给定参数，那么dir（）函数会罗列出当前定义的所有名称:

>>>a=[1,2,3,4,5]

>>>importfibo

>>>fib=fibo.fib

>>>dir（）#得到一个当前模块中定义的属性列表

['__builtins__','__name__','a','fib','fibo','sys']

>>>a=5#建立一个新的变量'a'

>>>dir（）

['__builtins__','__