python生成器表达式yield，面向过程编程，部分内置函数

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:Pycharmprojects619classtest.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