前言
本文主要为 Python基础入门笔记(一)内容的补充。
一、迭代器和生成器
1.1 Python迭代器
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。
迭代器只能往前不会后退。
迭代器有两个基本的方法:iter() 和 next(),且字符串、列表或元组对象都可用于创建迭代器,迭代器对象可以使用常规 for 语句进行遍历,也可以使用 next() 函数来遍历。
具体的实例:
1、字符创创建迭代器对象
str1 = ‘jaybo’
iter1 = iter ( str1 )
2、list对象创建迭代器
list1 = [1,2,3,4]
iter2 = iter ( list1 )
3、tuple(元祖) 对象创建迭代器
tuple1 = ( 1,2,3,4 )
iter3 = iter ( tuple1 )
for 循环遍历迭代器对象
for x in iter1 :
print ( x , end = ’ ’ )
print(‘\n------------------------’)
next() 函数遍历迭代器
while True :
try :
print ( next ( iter3 ) )
except StopIteration :
break
最后输出的结果:
j a y b o
------------------------
1
2
3
4
list(列表)生成式:
语法为:
[expr for iter_var in iterable]
[expr for iter_var in iterable if cond_expr]
第一种语法:首先迭代 iterable 里所有内容,每一次迭代,都把 iterable 里相应内容放到iter_var 中,再在表达式中应用该 iter_var 的内容,最后用表达式的计算值生成一个列表。
第二种语法:加入了判断语句,只有满足条件的内容才把 iterable 里相应内容放到 iter_var 中,再在表达式中应用该 iter_var 的内容,最后用表达式的计算值生成一个列表。
实例,用一句代码打印九九乘法表:
print('\n'.join([' '.join ('%dx%d=%2d' % (x,y,x*y) for x in range(1,y+1)) for y in range(1,10)]))
输出结果:
1x1= 1
1x2= 2 2x2= 4
1x3= 3 2x3= 6 3x3= 9
1x4= 4 2x4= 8 3x4=12 4x4=16
1x5= 5 2x5=10 3x5=15 4x5=20 5x5=25
1x6= 6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36
1x7= 7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49
1x8= 8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64
1x9= 9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
1.2 生成器
在 Python 中,使用了 yield 的函数被称为生成器(generator)。
跟普通函数不同的是,生成器是一个返回迭代器的函数,只能用于迭代操作,更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值。并在下一次执行 next() 方法时从当前位置继续运行。
①创建:
生成器的创建:最简单最简单的方法就是把一个列表生成式的 [] 改成 ()
gen= (x * x for x in range(10))
print(gen)
输出结果:
generator object at 0x0000000002734A40
创建 List 和 generator 的区别仅在于最外层的 [] 和 () 。但是生成器并不真正创建数字列表, 而是返回一个生成器,这个生成器在每次计算出一个条目后,把这个条目“产生” ( yield ) 出来。 生成器表达式使用了“惰性计算” ( lazy evaluation,也有翻译为“延迟求值”,我以为这种按需调用 call by need 的方式翻译为惰性更好一些),只有在检索时才被赋值( evaluated ),所以在列表比较长的情况下使用内存上更有效。
②以函数形式实现生成器:
其实生成器也是一种迭代器,但是你只能对其迭代一次。这是因为它们并没有把所有的值存在内存中,而是在运行时生成值。你通过遍历来使用它们,要么用一个“for”循环,要么将它们传递给任意可以进行迭代的函数和结构。而且实际运用中,大多数的生成器都是通过函数来实现的。
生成器和函数的不同:
函数是顺序执行,遇到 return 语句或者最后一行函数语句就返回。而变成 generator 的函数,在每次调用 next() 的时候执行,遇到 yield语句返回,再次执行时从上次返回的 yield 语句处继续执行。
举个例子:
def odd():
print ( 'step 1' )
yield ( 1 )
print ( 'step 2' )
yield ( 3 )
print ( 'step 3' )
yield ( 5 )
o = odd()
print( next( o ) )
print( next( o ) )
print( next( o ) )
输出结果:
step 1
1
step 2
3
step 3
5
可以看到,odd 不是普通函数,而是 generator,在执行过程中,遇到 yield 就中断,下次又继续执行。执行 3 次 yield 后,已经没有 yield 可以执行了,如果你继续打印 print( next( o ) ) ,就会报错的。所以通常在 generator 函数中都要对错误进行捕获。
打印杨辉三角:
d
ef triangles( n ): # 杨辉三角形
L = [1]
while True:
yield L
L.append(0)
L = [ L [ i -1 ] + L [ i ] for i in range (len(L))]
n= 0
for t in triangles( 10 ): # 直接修改函数名即可运行
print(t)
n = n + 1
if n == 10:
break
输出结果:
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]
1.3 延伸
①反向迭代
使用 Python 中有内置的函数 reversed()。
要注意一点就是:反向迭代仅仅当对象的大小可预先确定或者对象实现了 reversed() 的特殊方法时才能生效。 如果两者都不符合,那你必须先将对象转换为一个列表才行。
②同时迭代多个序列
为了同时迭代多个序列,使用 zip() 函数,具体示例:
names = ['jaychou', 'zjl', '周杰伦']
ages = [18, 19, 20]
for name, age in zip(names, ages):
print(name,age)
输出的结果:
jaychou 18
zjl 19
周杰伦 20
其实 zip(a, b) 会生成一个可返回元组 (x, y) 的迭代器,其中 x 来自 a,y 来自 b。 一旦其中某个序列到底结尾,迭代宣告结束。 因此迭代长度跟参数中最短序列长度一致。注意理解这句话,也就是说如果 a , b 的长度不一致的话,以最短的为标准,遍历完后就结束。
二、模块与包
2.1 模块
2.1.1 什么是模块
在 Python 中,一个 .py 文件就称之为一个模块(Module)。
我们学习过函数,知道函数是实现一项或多项功能的一段程序 。其实模块就是函数功能的扩展。为什么这么说呢?那是因为模块其实就是实现一项或多项功能的程序块。
通过上面的定义,不难发现,函数和模块都是用来实现功能的,只是模块的范围比函数广,在模块中,可以有多个函数。
模块的好处:
模块使用的最大好处是大大提高了代码的可维护性,当然,还提高了代码的复用性。
使用模块还可以避免函数名和变量名冲突,相同名字的变量完全可以分别存在不同的模块中。
PS:但是也要注意,变量的名字尽量不要与内置函数名字冲突。常见的内置函数:链接直达
再这也顺带先延伸下关于包的内容吧:
当编写的模块多了,模块的名字重复的概率就增加了。如何解决这个问题呢?
Python 引入了按目录来组织模块,称为包(Package),比如:
extensions
├─ __init__.py
├─ dog.py
└─ cat.py
现在 dog.py 模块的名字就变成了 extensions.dog。
PS:请注意,每一个 package 目录下面都会有一个__init__.py 的文件,这个文件是必须有的,否则, Python 就把这个目录当成普通目录,而不是一个 package directory。
另外如何使用包中的模块(Module)呢?如下编写一个dog.py模块:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'jack guo'
import sys
def shout():
args = sys.argv
if len(args)==1:
print('Hello, I'm afei, welcome to world!')
elif len(args)==2:
print('Hello, %s!' % args[1])
else:
print('Yes,sir')
if __name__=='__main__':
shout()
解释下:
第1行注释可以让dog.py文件直接在linux上运行;
第2行注释表示.py文件本身使用标准UTF-8编码;
第4行表示模块的文档注释;
第6行表示模块的作者;
注意最后两行代码,当我们调试dog.py时,shout()会调用,当在其他模块导入dog.py时,shout()不执行。
模块的一种标准模板:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
' a test module '
__author__ = 'jack guo'
以上是模块的标准模板,当然,你也可以不这样做。
2.1.2 模块的导入
导入模块我们使用关键字 import,语法格式如下:import module1[, module2[,… moduleN]
如:import math 导入标准模块中的 math 模块。
一个模块只会被导入一次,不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。
Python 解释器是怎样找到对应的文件的呢?
搜索路径:由一系列目录名组成的。Python 解释器就依次从这些目录中去寻找所引入的模块。这看起来很像环境变量,事实上,也可以通过定义环境变量的方式来确定搜索路径。搜索路径是在 Python 编译或安装的时候确定的,安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量 。可以打印出来:
import sys
print(sys.path)
2.1.3 导入模块中的属性和方法及调用
①导入模块的方法
import 模块名
import 模块名 as 新名字
from 模块名 import 函数名:大型项目中应尽量避免使用此方法,除非你非常确定不会造成命名冲突;它有一个好处就是可直接使用function()而不用加module.function()了。
PS1:导入模块并不意味着在导入时执行某些操作,它们主要用于定义,比如变量、函数和类等。
PS2:可以使用 from ··· import * 语句把某个模块中的所有方法属性都导入。
②模块中变量、函数以及类的属性和方法的调用
module.variable
module.function()
module.class.variable
2.1.4 模块的搜索路径sys模块的使用)
(1)程序所在目录
(2)标准库的安装路径
(3)操作系统环境变量 PYTHONPATH 指向的路径
获得当前 Python 搜索路径的方法:
import sys
print(sys.path)
输出:
['D:\\workspace_pycharm', 'D:\\workspace_pycharm', 'D:\\python-practice', 'D:\\devInstall\\devPython\\Python36\\python36.zip', 'D:\\devInstall\\devPython\\Python36\\DLLs', 'D:\\devInstall\\devPython\\Python36\\lib', 'D:\\devInstall\\devPython\\Python36', 'D:\\devInstall\\devPython\\Python36\\lib\\site-packages']
sys 模块的 argv 变量的用法:
sys 模块