生成器对象和常见内置函数

for循环本质

d = {'name':'tony','pwd':123,'age':19}
res = d.__iter__
while True:
  	try:
  			print(res.__next__())
		except StopIteration as e:
      	break
        
#  相当于
for i in d:
  	print(i)

迭代取值与索引取值对比

迭代取值

* 优点：不依赖于索引取值的一种通用取值方法

*  缺点：取值顺序永远都是固定的从左往右，无法重复获取

索引取值

* 优点：可以重复取值

* 缺点：需要提供有序容器类型才可取值（不是一种通用的方式）

生成器对象

生成器就是自定义迭代器

* 定义阶段就是一个普通函数

* 当函数体内含有yield关键字，那么在第一次调用函数的时候，并不会执行函数体代码，而是将函数变成了生成器（迭代器）

# 调用函数不执行函数体代码，而是转换为生成器（迭代器）
def foo():
  	print('hello world')
    yield 111
    print('hello world1')
    yield 222
res = foo()
res1 = res.__next__()  # 每执行一个__next__代码往下运行到yield停止，返回后面的数据赋值给res1
print(res1)   # 输出返回值即yield后面的
res1 = res.__next__()  # 再次执行__next__接着上次停止的地方继续往后，遇到yield再次停止
print(res1)

自定义range功能

def my_range(start,stop=None,step=1)
		if not stop:
    		stop = start
      	start = 0
		while start < stop:
    		yield start
      	start += step
        
res = my_range(2,19,3)
for i in res:
  	print(i)

yield传值

def eat(name):
  	print('%s'%name)
    while True:
      	food = yield
     		print('%s 正在吃 %s' %(name,food))
res = eat('tony')  # 并不会执行代码 而是转换成生成器
res.__next__()
res.send('牛肉面')
res.send('泡菜汤')

yield与return对比

yield
	1.可以返回值（支持多个并组织成元组）
  2.函数体代码遇到yield不会结束而是（停住）
  3.yield可以将函数变成生成器 并且还支持外界传值
return
	1.可以返回值（支持多个并且组织成元组）
  2.函数体代码遇到return直接结束

生成器表达式

# 列表生成器
l = [11,22,33,44,55,66]
res = [i+1 for i in l if i!=44]
print(res)

res1 = (i+1 for i in l if i!=44)
"""
生成器表达式内部的代码只有在迭代取值的时候才会执行
"""
print(res1.__next__())
print(res1.__next__())
print(res1.__next__())
"""
	迭代器对象 生成器对象 我们都可以看成是"工厂"
	只有当我们所要数据的时候工厂才会加工出"数据"
			上述方式就是为了节省空间
"""

# 求和
def add(n,i):
    return n + i
# 调用之前是函数，调用之后是生成器
def test():
  	for i in range(4):
      	yield i
g = test()  # 初始化生成器对象呢
for n in [1,10]:
  	g = (add(n,i) for i in g)
    """
    第一次for循环
    		g = (add(n,i) for i in g)
    第二次for循环
    		g = (add(n,i) for i in (add(n,i) for i in g))
    """
res = list(g)
print(res)
# res=[20,21,22,23]

常见内置函数

# 1.abs()  绝对值
print(abs(123))
print(abs(-123))
# 2.all()  any()
l = [11,22,33,0]
print(all(l))  # 所有的元素都为True结果才是True
print(any(l))  # 所有的元素只要有一个为True结果就为True
# 3.bin() oct() hex()  进制数
print(bin(123))
print(oct(123))
print(hex(123))
# 4.bytes() str()
res = '今天星期一'
res1 = bytes(res,'utf8')  # 转换为二进制
print(res1)  # b'\xe4\xbb\x8a\xe5\xa4\xa9\xe6\x98\x9f\xe6\x9c\x9f\xe4\xb8\x80'
res2 = str(res1,'utf8')
print(res2)  # 今天星期一
res1 = res.encode('utf8')
print(res1)
res2 = res1.decode('utf8')
print(res2)
# 5.callable()  是否可调用(能不能加括号运行)
s1 = 'jason'
def index():
    pass
print(callable(s1),callable(index))  # False True
# 6.chr()  ord()
print(chr(65))  # 根据ASCII码转数字找字符
print(ord('A'))  # 65
# 7.complex()  复数
print(complex(123))  # (123+0j)
# 8.dir()  查看当前对象可以调用的名字,可调用的方法，相当于.
def index():
    pass
print(dir(index))
print(index.__name__)
# 9.divmod()
print(divmod(101,10))  # 前一个数除后一个数，得出的结果是：(x//y,x%y)
"""总数据100 每页10条  10页"""
"""总数据99  每页10条  10页"""
"""总数据101 每页10条  11页"""
num,more = divmod(233,10)
if more:
    num += 1
print('总共需要%s页'%num)
# 10.eval()只能识别简单的语法  exec()可以识别复杂语法  都是将字符串中的数据内容加载并执行
res = """
你好啊
for i in range(10):
    print(i)
"""
res = """
print('hello world')
"""
eval(res)
exec(res)
# 11.isinstance()  判断是否属于某个数据类型
print(isinstance(123,float))  # False
print(isinstance(123,int))  # True
# 12.pow()  
print(pow(4,3))  # 64
# 13.round()  四舍五入（实际上是五舍六入）
print(round(4.8))  
print(round(4.6))
print(round(8.5))
# 14.sum()  # 求和
l = [11,22,333,44,55,66]
print(sum(l))