python 第十二章 生成器+推导式+内置函数一（不常用的）

生成器

# 迭代器：python中内置的一种节省空间的工具
# 生成器的本质就是一个迭代器
# 区别：迭代器自带的，生成器自己写的

# return可以写多个，但是只执行一次
# yield会记录执行位置
# 一个next()对应一个yield

def func():
    print(123)
    return "you"
print(func())
# 123
# you

# return和yield 都是返回值
# 在函数体内将return改成yield的就是一个生成器
def func():
    print(123)
    yield "you" # yield也是返回值
g =func()# 产生一个生成器
print(g.__next__())
# 输出
# 123
# you

# return可以写多个，但是只执行一次
# yield 可以写多个也可以返回多次
# yield会记录执行位置
# 一个next()对应一个yield，一一对应
def func():
    print(123)
    yield "you" # 停
    yield "i" # 再加一个—__next__()方法继续往下走
    yield "l"
g =func()#产生 一个生成器
print(g.__next__())
print(g.__next__())
print(g.__next__())
# 输出
# 123
# you
# i
# l


# if 判断执行过，不在执行第一个if，继续往下走
def func():
    if 3>2:
        yield "您好"
    if 4>2:
        yield "我好"
    yield "大家好"
g = func()
print(g.__next__())
print(g.__next__())
print(g.__next__())
# 输出
# 您好
# 我好
# 大家好

# 生成器也可以使用for
def func():
    if 3>2:
        yield "您好"
    if 4>2:
        yield "我好"
    yield "大家好"
g = func()
for i in g:
    print(i)
# 输出
# 您好
# 我好
# 大家好



# 坑，输出多个print(func().__next__) 会不断产生新的生成器
# 解决方案赋值只有一个生成器
g = func()
next(g) == g.__next__()
# 推荐使用next()
print(next(g))


# send
# 第一次传参只能传None
def func():
    a = yield "我是send"
    print(a)
    a1 = yield
    print(a1)
g = func()
print(g.send(None))
print(g.send(123))
# 输出
# 我是send
# 123
# None

# 生成器应用场景：节省空间

def func():
    lst = []
    for i in range(1000000):
        lst.append(i)
    return lst
print(func())

def func():
    for i in range(10000):
        yield i
g = func()
for i in range(50):
    print(next(g))

# 获取整个列表
def func():
    lst = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    yield lst
g = func()
print(next(g))


# 获取列表一个一个元素
def func():
    lst = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    for i in lst:
        yield i
g = func()
print(next(g))
print(next(g))
print(next(g))


def func():
    lst = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    yield from lst
g = func()
print(next(g))

def func():
    lst = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    yield from lst
g = func()
for i in g:
    print(i)

# 不能同时输出两个列表
def func():
    lst = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    lst2 = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    yield from lst,lst2
g = func()
for i in g:
    print(i)

# # 坑
def func():
    lst1 = ["牛羊配","老奶奶花生米","卫龙","虾扯蛋","米老头","老干妈"]
    lst2 = ["小浣熊","老干爹","亲嘴烧","麻辣烫","黄焖鸡","井盖"]
    yield from lst1
    yield from lst2

推导式

li = []
for i in range(10):
    li.append(i)
print(li)
# 输出
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# list推导式
# 一行输出
# [] 数据类型 里面放变量(也就是结果)和for循环
# 循环模式
print([i for i in range(10)])
# 输出[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([i for i in range(1,50,2)])
# 输出[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 筛选模式
# [变量 （加工后的变量） for 循环 加工方式筛选条件]
lst = []
for i in range(20):
    if i %2 == 0:
        lst.append(i)
print([i for i in range(20) if i % 2 == 0])
# 输出[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]


# 生成器表达式：
# 变量 = (其他推导器)
# 循环模式:
g = (i for i in range(20))
print(next(g))
# list 底层有个for
print(list((i for i in range(20))))

# 筛选模式
g = (i for i in range(20) if i%2 == 1)
for i in g:
    print(next(g))

# 字典推导式
# {键:值 for循环 加工条件}
print({i:i+1 for i in range(10)})
print({i:i+1 for i in range(10) if i % 2==0})


# 集合推导式
print({i for i in range(10)})
# 筛选
print({i for i in range(10) if i % 2==0})

# list推导式:
# [变量(加工后的变量) for循环]
# [变量(加工后的变量) for循环 加工条件]

# 迭代器表达式：
# (变量(加工后的变量) for循环)
# (变量(加工后的变量) for循环 加工条件)

# 字典推导式：
# {键:值 for循环 加工条件}

# 集合推导式：
# {变量(加工后的变量) for循环}
# {变量(加工后的变量) for循环 加工条件}

内置函数一（不怎么常用的）

# s = """
# for i in range(10):
#     print(i)
# """

# s1 = """
# def func():
#     print(123)
# func()
# """
# print(eval(s))
# print(exec(s1))  # 牛逼 不能用

# print(hash("hello"))

# print(help(list))
# help(dict)


# def func():
#     pass
# print(callable(func))  # 查看是否可调用

# print(float(2))     # 浮点数
# print(complex(56))  # 复数

# print(oct(15))        # 八进制
# print(hex(15))        # 十六进制

# print(divmod(5,2))     # (2, 1) 2商 1余

# print(round(5.3234,2))     # 四舍五入 -- 默认是整数,可以指定保留小数位

# print(pow(2,3))            # 幂
# print(pow(2,3,4))          # 幂,余

# s = "alex"
# print(bytes(s,encoding="utf-8"))

# print(ord("你"))    # 当前编码
# print(chr(20320))

# s = "C:u3000"
# print(repr(s))

# print("u3000你好")

# lst = [1,2,3,False,4,5,6,7]
# print(all(lst))   # 判断元素是否都为真  相似and
# print(any(lst))     # 判断元素是否有真    相似or

# name = 1
# def func():
#     a = 123
#     # print(locals())
#     # print(globals())
# func()

# print(globals())   # 全局空间中的变量
# print(locals())   # 查看当前空间的变量

总结

# 1、生成器
# 生成器的本质是一个迭代器
# 生成器于迭代器的区别：生成器是自己写的，迭代器是python自带的
# 定义一个生成器
# 在函数体中将return改成yield就是生成器
# 函数名()就是产生一个生成器
#
# 生成器的特点：
# 节省时间--惰性机制
# 不能逆行
# 一次性的
# 一个next对应一个yield
# yield 能返回对象，可返回多次
# yield 可以临时停止循环
# yield 能够记录执行位置
#
# yield from 将一个可迭代对象的元素逐个返回
#
#
# 2、推导式，可节省代码
# 普通循环体和筛选条件
# list推导式
# [变量(加工后的变量) for循环 ]
# [变量(加工后的变量) for循环 加工条件条件 ]
#
# 生成器推导式
# (变量(加工后的变量) for循环 )
# (变量(加工后的变量) for循环 加工条件 )
#
# 字典推导式
# {键:值 for循环 }
# {键:值 for循环 加工条件 }
#
# 集合推导式
# {变量(加工后的变量) for循环 }
# {变量(加工后的变量) for循环 加工条件 }
#
# 3、内置函数
# all() any() bytes()
# callable()
# chr() complex()
# divmod() eval()
# exec() format()
# frozenset() globals()
# hash() help() id() input()
# int() iter() locals()
# next() oct() ord()
# pow() repr() round()