yield生成器表达式的基本形式
# def foo(): # print('starting') # while True: # x=yield # print('value:',x) # # g=foo() # print(next(g)) # print(g.send(1)) # print(g.send(2)) #next(g)执行函数yield返回默认值None；print(g.send(1))先将1传值给x，打印x运行到下一个yield，返回默认 #值None
# def init(func): # def wrapper(*args,**kwargs): # g=func(*args,**kwargs) # next(g) # return g # return wrapper # @init 初始化eater函数，相当于eater.send(None) # def eater(name): # print('%s start to eat'%name) # list=[] # while True: # food=yield list # list.append(food) # print('%s have eaten %s'%(name,food)) # e=eater('xiaoh') # print(e.send('apple')) # print(e.send('banana'))
import os g=os.walk(r'F:Pycharmprojects') #g属性是generator也就是生成器，因此可是用for迭代取出内容 print(g) for i in g: print(i) 执行结果 <generator object walk at 0x000001F352E42F68> ('F:\Pycharmprojects', ['.idea', '0614', '0615', '0616', '0619'], ['1.4.py', 'asdasd.txt', 'asdasdswap.txt', 'bonus.py', 'class3', 'classwork day5.py', 'day3 homework1', 'day3 homework2', 'day3 homework3', 'homework 0612.py', 'practice1.py', 'practice2.py', 'shopping cart.py', 'test']) ('F:\Pycharmprojects\.idea', [], ['misc.xml', 'modules.xml', 'Pycharmprojects.iml', 'workspace.xml']) ('F:\Pycharmprojects\0614', [], ['classtest.py', 'homework.py', 'idpass', 'idpass.txt']) ('F:\Pycharmprojects\0615', [], ['a.txt', 'daily.txt', 'homework in class.py', 'homework.py', 'idpd.txt', 'makecache.txt']) ('F:\Pycharmprojects\0616', [], ['a.txt', 'classtest.py', 'stafftable.txt', '周末作业.py']) ('F:\Pycharmprojects\0619', [], ['classtest.py'])
import os g=os.walk(r'F:Pycharmprojects' for par_dir,_,files in g: for file in files: f=r'%s\%s'%(par_dir,file) print(f) 执行结果 F:Pycharmprojects1.4.py F:Pycharmprojectsasdasd.txt F:Pycharmprojectsasdasdswap.txt F:Pycharmprojectsonus.py F:Pycharmprojectsclass3 F:Pycharmprojectsclasswork day5.py F:Pycharmprojectsday3 homework1 F:Pycharmprojectsday3 homework2 F:Pycharmprojectsday3 homework3 F:Pycharmprojectshomework 0612.py F:Pycharmprojectspractice1.py F:Pycharmprojectspractice2.py F:Pycharmprojectsshopping cart.py F:Pycharmprojects est F:Pycharmprojects.ideamisc.xml F:Pycharmprojects.ideamodules.xml F:Pycharmprojects.ideaPycharmprojects.iml F:Pycharmprojects.ideaworkspace.xml F:Pycharmprojects0614classtest.py F:Pycharmprojects0614homework.py F:Pycharmprojects0614idpass F:Pycharmprojects0614idpass.txt F:Pycharmprojects0615a.txt F:Pycharmprojects0615daily.txt F:Pycharmprojects0615homework in class.py F:Pycharmprojects0615homework.py F:Pycharmprojects0615idpd.txt F:Pycharmprojects0615makecache.txt F:Pycharmprojects0616a.txt F:Pycharmprojects0616classtest.py F:Pycharmprojects0616stafftable.txt F:Pycharmprojects0616周末作业.py F:Pycharmprojects 619classtest.py
函数的参数传入，是函数的执行必须摄入的元素，而函数return/yield的返回值，是函数生成的结果，面向过程的思路就是，把程序的执行当做一串首尾相连的函数，一个函数摄入，生成的结果给另外一个函数使用，另外一个函数摄入再继续给下一个函数使用，以此循环直到目标结束。
举例：递归一个文件目录，找出其中含有指定内容的文件。
阶段一：递归地找文件的绝对路径，把路径发给阶段二
阶段二：收到文件路径，打开文件获取对象，把文件对象发给阶段三
阶段三：收到文件对象，for循环读取文件的每一行内容，把每一行内容发给阶段四
阶段四：收到一行内容，判断root是否在这一行中，如果在则把文件名发给阶段五
阶段五：收到文件名，打印结果
# import os # def init(func): # def wrapper(*args,**kwargs): # g=func(*args,**kwargs) # next(g) # return g # return wrapper #阶段一：递归地找文件的绝对路径，把路径发给阶段二 # @init # def search(target): # while True: # start_path=yield # g=os.walk(start_path) # for par_dir,_,files in g: # for file in files: # file_path=r'%s\%s'%(par_dir,file) # target.send(file_path) #阶段二：收到文件路径，打开文件获取对象，把文件对象发给阶段三 # @init # def opener(target): # while True: # file_path=yield # with open(file_path,encoding='utf-8')as f: # target.send((file_path,f)) #阶段三：收到文件对象，for循环读取文件的每一行内容，把每一行内容发给阶段四 # @init # def cat(target): # 'read file' # while True: # filepath,f=yield # for line in f: # res=target.send(filepath,line) # if res: # break #阶段四：收到一行内容，判断root是否在这一行中，如果在则把文件名发给阶段五 # @init # def grep(target,pattern): # 'grep function' # tag=False # while True: # filepath,line=yield tag # tag=False # if pattern in line: # target.send(filepath) # tag=True #阶段五：收到文件名，打印结果 # @init # def printer(): # 'print function' # while True: # filename=yield # print(filename) # start_path=r'' # g=search(opener(cat(grep(printer(),'root')))) # g.send(start_path)
内置函数
abxs()返回数字的绝对值
all()如果iterable的所有元素不为0、''、False或者iterable为空，all(iterable)返回True，否则返回False。空元组和空列表返回True
all(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0，结果返回True all(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素，结果返回False all([0, 1, 2, 3]) # 列表list，存在一个为0的元素，结果返回False all(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素，结果返回False all((0,1,2,3)) # 元组tuple，存在一个为0的元素，结果返回False all([]) # 空列表，结果返回True all(()) # 空元组，结果返回True
bin()十进制数转换为二进制数
oct()十进制数转换为八进制数
hex()十进制数转换为十六进制数
bytes()将字符串转换为字节
divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)
print(divmod(7,2)) 结果 (3, 1)
any() 函数用于判断给定的可迭代参数 iterable 是否全部为空对象，如果都为空、0、false，则返回 False，如果不都为空、0、false，则返回 True
any(['a', 'b', 'c', 'd']) # 列表list，元素都不为空或0，结果返回True any(['a', 'b', '', 'd']) # 列表list，存在一个为空的元素，结果返回True any([0, 1, 2, 3]) # 列表list，存在一个为0的元素，结果返回True any(('a', 'b', '', 'd')) # 元组tuple，存在一个为空的元素，结果返回True any((0,1,2,3)) # 元组tuple，存在一个为0的元素，结果返回True any([]) # 空列表，结果返回False any(()) # 空元组，结果返回False
enumerate() 同时获得索引和值,可以接收第二个参数作为索引起始值
l=['a','b','c'] for i in enumerate(l,1): print(i) 执行结果 (1, 'a') (2, 'b') (3, 'c')
dic={'name':'xiaobai','age':22} #字典获得索引和KEY但KEY顺序可能会不同
for i in enumerate(dic):
print(i)
执行结果
(0, 'name')
(1, 'age')
eval()用来执行一个字符串表达式，并返回表达式的值
print(eval('3*3')) 执行结果 9
calllable()检查一个对象是否可调用，如果返回True,仍可能调用失败，如果返回False，肯定不会调用成功,
函数，方法，lambda函式，类，以及实现了__call__方法的类实例都会返回True
print(callable(7)) def fun1(a,b): return a+b print(callable(fun1)) 执行结果 False True
chr()用一个范围在0到255的整数作为参数返回一个对应的字符，参数可以是十进制数也可以是十六进制数
print(chr(0x30),chr(0x31),chr(0x61)) print(chr(48),chr(49),chr(97)) 执行结果 0 1 a 0 1 a
cmp(x,y)用于比较两个对象，如果x<y返回-1，如果x==y返回0，如果x>y返回1
frozenset() #返回一个冻结的集合，集合不能删除或者增加任何元素
print(frozenset(range(20))) 执行结果 frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19})
#isinstance() 判断一个对象是否是一个已知的类型返回布尔值
a=9 print(isinstance(a,int)) #判断a是否为整型 print(isinstance(a,(str,int,list))) #判断a是否为字符串，整型，列表 执行结果 True True
pow(x,y[,z]) z不存在时返回x的y次方，如果z存在返回(x**y)%z
print(pow(3,2)) print(pow(3,2,2)) 执行结果 9 1
for i in range(5,0,-2): print(i) l1=[3,1,5,9] print(list(reversed(l1))) #倒序 执行结果 5 3 1 [9, 5, 1, 3]
print(round(4.5637,3)) #round四舍五入，保留位数 执行结果 4.564
slice(start,stop[,step] )切片函数
l=['a1','a2','a3','a4','a5','a6','a7'] x=slice(2,5,2) print(l[x]) 执行结果 ['a3', 'a5']
zip()将可迭代对象作为参数，将对象中对应的元素打包成一个元祖，然后返回由这些元组组成的列表。如果各个
迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符可以将元组解压为列表
s='hello' l=[1,2,3,4,5,6] print(zip(s,l)) for i in zip(s,l): print(i) 执行结果 <zip object at 0x0000020B95C4BE88> ('h', 1) ('e', 2) ('l', 3) ('l', 4) ('o', 5)
dict()用于创建一个字典
print(dict(a=1,b=2,c=3)) print(dict(zip(['one','two','three'],[1,2,3]))) print(dict([('one',1),('two',2),('three',3)])) 执行结果 {'a': 1, 'b': 2, 'c': 3} {'one': 1, 'two': 2, 'three': 3} {'one': 1, 'two': 2, 'three': 3}
dir()函数不带参数时返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包含方法__dir__()，则方法将被调用。如果参数不含__dir__()，该方法将最大限度地手机参数信息
open()函数用于打开一个文件
模式：r以只读方式打开文件，文件指针放在文件的开头，默认模式
rb以二进制打开一个文件用于只读，文件指针放在文件开头
r+打开一个文件用于读写，文件指针在文件的开头
rb+以二进制格式大爱一个文件用于读写，文件指针放在文件开头
w打开一个文件用于写入，如果该文件存在则将其覆盖，如果文件不存在则创建
wb以二进制格式打开一个文件用于写入，如果文件存在则覆盖，如果文件不存在则创建
w+打开一个文件用于读写。如果文件存在则将其覆盖，如果文件不存在则创建
wb+以二进制格式打开一个文件用于读写，如果文件存在则将其覆盖，如果不存在则创建
a打开一个文件用于追加。如果文件存在文件指针放在文件结尾。如果文件不存在则创建并写入
ab以二进制格式打开一个文件用于追加。如果文件存在，文件指针放在文件结尾，如果不存在则创建
并写入
a+打开一个文件用于读写，如果文件存在，文件指针则放在文件结尾，如果文件不存在创建并写入
ab+以二进制格式打开一个文件用于追加，如果文件存在文件指针放在文件结尾，如果不存在创建并写入
iter()函数用来生成迭代器
next()返回迭代器的下一个项目
filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件元素组成的新列表；接受两个参数
第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，将返回的布尔值放到新列表中
l=[1,2,3,4,5,6,7,8,9] b=list(filter(lambda x:x%2==1,l)) print(b)
执行结果
[1, 3, 5, 7, 9]
map()会根据提供的函数对制定序列做映射，第一个参数为函数，第二个为列表或元祖，返回新列表
c=list(map(lambda x,y:x+y,[1,3,5,7,9],[2,4,6,8,10])) print(c) 执行结果 [3, 7, 11, 15, 19]
max()内置for循环
salaries={'xiaobai':3000,'xiaohei':1000000,'xiaohong':10000,'xiaozi':2000}
print(max(salaries))
t=zip(salaries.values(),salaries.keys())
print(max(t))
print(max(salaries,key=lambda x:salaries[x]))
执行结果
xiaozi
(1000000, 'xiaohei')
xiaohei
先for会报错
salaries={'xiaobai':3000,'xiaohei':1000000,'xiaohong':10000,'xiaozi':2000}
print(max(salaries))
t=zip(salaries.values(),salaries.keys())
for i in t:
print(i)
print(max(t))
执行结果
Traceback (most recent call last):
File "F:/Pycharmprojects/0620/classtest.py", line 116, in <module>
print(max(t))
ValueError: max() arg is an empty sequence
xiaozi
(3000, 'xiaobai')
(1000000, 'xiaohei')
(10000, 'xiaohong')
(2000, 'xiaozi')
#reduce() from functools import reduce cm=reduce(lambda x,y:x+y,range(100)) print(cm) 执行结果 4950