python3.x Day4 内置方法，装饰器，生成器，迭代器

内置方法，就是python3提供的各种函数，可以认为是关键字，帮助进行一些列的牛x运算。

abs()#取绝对值
all([])#可迭代对象中的所有元素都为True 则为True，只要至少一个为False则结果为False
any() #可迭代对象中的元素只要有任意一个为True,则结果为True
bin() #10进制转为二进制
bool() #判断一个对象的boolean值
bytes() #转换为字节，字符串需要"abc".encode("utf-8") ,字符串和字节都不可修改。
bytearray() #可修改的字节格式，b=bytearray("abc".encode("utf-8")),b[2]= 97, b="aac"了
callable() #判断一个对象是否可以调用。比如函数，True/False
chr() #输入一个数字，返回ascii中对应的字符
ord() #输入一个字符，返回ascii中对应的数字
 
classmethod() #类方法
 
code="print('hello world')"
gooo=compile(code,'','exec') #用于编译代码。。。。,相当于import，但是如果代码是片段，且是其他途径传过来的，
# 无法import，就这么干，用的地方不多，不过都有代码了，直接exec()就行了。。。。 呵呵
exec(gooo)
 
complex()#复数
 
dict() #生成字典，一般直接{}
 
dir()#查看对象有哪些方法。
 
divmod(5,2) #计算两个数相除的余数
 
eval() #计算器，
exec() #程序运行器
 
#补充：匿名函数:
mmm=lambda n:0 if n < 5 else 10
print(mmm(6))
filter() #过滤器，参数1：过滤方法（支持匿名函数），参数2：需要过滤的数据，可迭代对象，filter以后结果是个filter对象，迭代器的一种。
res=filter((lambda a:a>5),range(10))
print(type(res))
for i in res:
    print(i)
 
map() #按照参数1的方法，对参数2可迭代对象的数据进行处理。结果是个map对象，迭代器的一种。
map(lambda n:n*n,range(10))
 
import functools
res=functools.reduce() #reduce方法在python3中，移到了标准库里了，这是累加
res=functools.reduce(lambda n,m:m+n,range(101))
print(res)
 
float()#转换为浮点型
format() #和字符串的.format(name="xiaoming"),一样的
 
frozenset()#不可变的集合，没有add方法什么的。
set()#可变的集合，有add方法什么的。
 
globals()#返回本文件整个程序中的所有全局的东西，返回个字典。可以用来判断变量什么的。他还有内部方法
globals().get() #用来取哪个全局的xx的值
locals() #与globals对应，这个是仅打印局部变量。
locals().get() #用来取哪个局部的xx的值，用在函数内部。。。。装饰器中？？？ 生成器中？？？
 
hash(object) #取得对象的hash值
 
help() #查看python的帮助
 
hex() #把数字转为16进制
oct() #把数字转为8进制
 
id() #返回对象的内存地址
 
input()#接收命令行输入的字符串。
 
int()#转换为整形
 
isinstance("gogo",str) #判断一个东西是否是第二个参数的对象类型
 
issubclass() #判断是否是个子类
 
iter() #可迭代对象转化为迭代器
 
len() #取得长度，主要针对数组，元组，字典。等等
 
max() #返回可迭代对象中最大的那个。。。。。
min() #返回可迭代对象中最小的那个。。。。。
 
next() #返回迭代器的下一个值，与迭代器的__next__()方法一致
 
open() #打开文件。。。。。查看文件操作。
 
pow() #运算出，第一个参数数字的第二个参数数字次方
 
print() #输出到屏幕。
 
range() #取得一段数字数组。
 
repr() #用字符串表示一个对象。
 
reversed() #反转一个序列，和列表list的[].reverse()方法一样
 
round() #保留一个数字的n位小数。不写多少位小数，则取整
 
slice() #切片，和[2:5]一样的
 
sorted() #排序，可以用于排序本来没有顺序属性的对象，比如字典，a={1:44,2:33:9:33,7:88,6:33}  sorted(a.items()),按照key来排序，如果不取items则排序完就剩下key了，这个不改变原对象
#上述 如果用value来进行排序，需要用匿名函数来做，sorted(a.items(),key=lambda x:x[1]) key为sorted第二个参数关键字。
 
sum() #求和，对于一个可迭代对象的求和,只能用数字的可迭代对象。
 
super() #面向对象的继承。
type() #查看数据类型 , python中所有的数据类型的根本都是type类型的
 
vars() #返回一个对象所有的属性名。
 
zip() #两个list按索引位置，对应起来，变成元组列表。
 
__import__("xxxxx") #引入模块，挺重要的

装饰器：

# 实现装饰器知识储备：
# 1、高阶函数 --- 把函数名字做为实参传个另一个函数（不修改原函数的源代码），返回值中包含原函数名（不改变原函数的调用方式）
# 2、函数即变量
# 3、函数嵌套 ----第一层，接收原函数名，第二层开始处理增加的装饰业务，第一层return 第二层的函数名，即可完成装饰器
 
# 高阶函数 + 函数嵌套 ==》 装饰器
 
#
# 装饰器定义：为其他函数增加额外功能的函数，本质上装饰器就是函数
# 原则：1、不去修改被装饰函数的源代码
#       2、不去修改被装饰函数的调用方式

import time
 
def timer(func):   #装饰器必然使用嵌套函数和告诫函数，嵌套外层，定义装饰器名字，和传递的函数名
    def deco(*args,**kwargs):    #装饰器嵌套函数的内层，描述装饰的额外功能，和传递原函数的各种参数，一般用*args,**kwargs
        start_time=time.time()
        func(*args,**kwargs)
        stop_time=time.time()
        print("func run time:{rt}".format(rt=stop_time-start_time))
    return deco
 
@timer
def test1():
#    time.sleep(3)
    print("i'm test1")
 
test1()
 
# 最牛X的 装饰器传参数：
def log_in(log_type):
    def wrapper(func):
        print("now func is {ffff}".format(ffff=func))
        def rawrapper(*args,**kwargs):
            print("login,{type}".format(type=log_type))
            return func(*args,**kwargs)
        return rawrapper
    return wrapper

生成器&迭代器：

#a=[i * 2 for i in range(1000000)] #这叫列表生成式  可以让代码更简洁，和装逼
a=(i*2 for i in range(1000000)) #这叫生成器 与生成式最大的区别就是 生成式的数据根据算法全部准备好，
# 但生成器就是个算法，木有数据，只有在有需要数据访问时，提供那一个数据，相当省资源，
# 但直接访问某次数据，未生成的会异常，也就是说，生成器不允许切片使用
#b=a[1000]
#print(b)
 
#生成器取值，需要用生成器自己的方法来做。只能往后读，无法往前读，只记录当前位置的数据，其他都不记录了，省内存。
#一般通过循环来取值
a.__next__() #python3.0   a.next() #python2.0
print(a.__next__())
'''
 
#复杂的逻辑生成器，可以用函数的形式定义，但要有yield关键字来说明返回的是生成的值

#斐波那契数列：
def fib(max):
    n,a,b = 0,0,1
    while n < max :
        yield b   #表示生成器值的在这个算法中就是b，所以这里的print改为yield，这个fib就不再是函数而是生成器了。
        a,b=b,a+b
        n +=1
    return "----done----" #可以用return来定义生成器溢出异常的描述值
f=fib(10)
print(f)
 
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__())
# print(f.__next__()) #超出生成器取值范围后，会异常，异常描述值，可以是定义生成器return 来进行定义
 
#用循环来取生成器的值比较常见，由于生成器的特性决定，循环一般不会有溢出异常
for i in f:
    print(i)
 
while True:
    try:
        print(f.__next__())
    except StopIteration as e:
        print(e)
        break

#利用生成器，做单线程下的并发，这玩意叫协程，比线程单位小，异步IO的雏形，epoll的雏形
 
#生产者，消费者模式？消费者，吃包子的，生产者，做包子的，消费者自己弄个生成器来吃包子，生产者做个包子让消费者来吃。
#yield关键字在生成器中是个标记，__next__()方法调用yield，开始生成器第一次算法值，返回当前的yield，但不传值，
# send()方法，用来给yield传值，并且开始一次算法值
def custom(name):
    print("i'm customer %s"%name)
    while True:
        baozi=yield
        print("%s eat the baozi [%s]"%(name,baozi))
 
# c1=custom("wy")
# c1.__next__()
# c1.send("baozi")
 
def product(name1,name2):
    c1=custom(name1)
    c2=custom(name2)
    c1.__next__()
    c2.__next__()
    for baozi in range(20):
        print("begin make baozi : [%s]"%baozi)
        c1.send(baozi)
        c2.send(baozi)
 
product("wangyue","laopeng")
 
#补充：next()方法是可以取下一个值的内置方法。
 
#迭代器：
#只要是可以作用于for循环的对象，比如string，list，set，tuple，dict等等，就都叫可迭代对象（Iterable）。
#用isinstance()方法判断是否为可迭代对象，返回值True/False，
#使用的这个方法需要引入，
# from collections import Iterable
# isinstance(...,Iterable)
 
#不但可以循环，并且可以被next()方法返回下一个值的对象，就叫迭代器（Iterator）
#用isinstance()方法判断是否为可迭代器，返回值True/False，
# from collections import Iterable
# isinstance(...,Iterabor)
#补充，可以通过dir()方法来查看全部方法，dir(....),迭代器dir()以后必须包含__next__()方法
#明确：
# ----生成器一定是可迭代对象，一定是迭代器
# ----迭代器一定是可迭代对象
 
#可以使用iter()方法，将字典dict、列表list、字符串str等可迭代对象，转化为迭代器