|
推导式
list_data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#显示定义一个列表, 1, 2, 3,
# for i in range(1, 10):
# print(i)
list_data = list(range(1, 10))
print(list_data)
# 1, 2, 3, 4, 5, 6, 7, 8, 9 这些数的平方
#列表推导式：方便我们去建立列表
list_data = [i * i for i in range(1, 10)]
print(list_data)
"""
[表达式 for 临时变量 in iterable 过滤]
简洁的一条语句的形式去创建列表
"""
list_data = [i * i for i in range(1, 10) if i > 4]
print(list_data)
#practise: 1-10, 去取出 偶数的平方
#practise2: (red, blue, black)
# (L, M, S)
#去给我列出来，每个颜色对应的尺码
color_tuple = ("red", "blue", "black")
size_tuple = ("L", "M", "S")
clothes_list = [(i, j) for i in color_tuple for j in size_tuple]
clothes_list = [(i, j) for i in size_tuple for j in color_tuple if j == "red"]
print(clothes_list)
# for i in color_tuple:
# for j in size_tuple:
# print((i, j))
def my_square(x):
return x * x
list_data = [my_square(i) for i in range(1, 10)]
print(list_data)
"""
字典推导式：{}
{表达式1:表达式2 for 临时变量 in iterable 过滤}
字典中元素的格式: key:value
"""
#practise: 1-10 ,去取它的平方，1: key=1, value=1
#key=本身，value=平方， 取除掉偶数，只保留奇数
#现在的要求是：保留奇数，但是原先偶数的key不变，值设为-1
#1: 1, 2: 4, 3: 9
#1: 1, 2: -1, 3: 9, 4:-1
#把key:-1 2: 4 => 2: -1
#提示: value1 if condition else value2
flag = 0
data = 1 if flag else 2
print(data)
迭代器
"""
1.Python中什么是迭代器？
迭代器就是实现了迭代协议的对象
迭代器是一个可以记住遍历的位置的对象
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
迭代器是可迭代的对象
迭代器有两个基本的方法：iter() 和 next()。
迭代器是实现了__next__()方法
2.什么是迭代协议？
只要某个类型(类)定义了__iter__()和__next__()方法就表示支持迭代协议。
__iter__()需要返回一个可迭代对象：
只要定义了__iter__()就表示能够通过for/in/map/zip等迭代工具进行对应的迭代
__next__(): 下一个，说了迭代器从第一个元素开始, 可以记住遍历位置的对象
第一个，下一个：第二个，下一个,第三个
3.实现自己的迭代器：
__iter__: 返回迭代器本身， 返回self
__next__: 通过访问这个__next__来获取下一个元素
写的是如何获取下一个元素，以及元素的位置, 终止条件
抛出StopIteration异常
我去迭代自己的迭代器的时候(for访问的时候)，如何判定循环终止，或者说所有的元素
被访问完毕？
for循环如何去判定可迭代对象，迭代到末尾了结束了？
通过判定可迭代对象的__next__是否抛出StopIteration异常
for循环可以捕获StopIteration异常的，如果捕获到了，人为迭代结束
"""
data = 1
class MyIterator:
def __init__(self, value): #9
self.stop = value
self.start = 0
def __iter__(self):
return self
def __next__(self):
#起始是0， 结束9
if self.start < self.stop: #start < stop
data = self.start
self.start += 1 #start+1
return data
else: #手动去抛出异常
raise StopIteration #停止迭代的异常
# print(-1)
# for i in range(10): #0-9 #start, stop, step
# print(i)
my_iteraotr = MyIterator(10)
for i in my_iteraotr:
print(i)
# my_iteraotr = MyIterator(10)
print(next(my_iteraotr)) #=> my_iterator.__next__
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
print(next(my_iteraotr))
# print(next(my_iteraotr))
#作业：
# print({1: 2, 2: 3}.keys())
# print(range(10))
生成器
"""
什么是生成器？
生成器就是一个迭代器
一边循环一边计算的机制，称为生成器
使用了 yield 的函数被称为生成器
扫描内存中放不下的数据集时，我们要找到一种惰性获取数据项的方式，
即按需一次获取一个数据项。这就是迭代器模式
#生成器: 生成，产生， 器：工具
产生一个元素的工具? 每次产生一个, 调用它才产生
[1, 2, 3, ... 1000000000000000000000]
列表：一次性获取，
惰性获取：每次获取一个： 节省空间
你需要的时候去获取，不需要的时候不获取
什么叫生成器？
带有yield关键字的函数，叫做生成器函数
执行生成器函数，返回的就是一个生成器
yield关键字： 中文：产生
"""
def test_func(arg1):
return arg1
data = test_func(1)
print(data, type(data))
# 1, int
def test_func2():
value = yield "123"
# print(value)
yield "456"
yield "789"
# 带有yield关键字的函数，叫做生成器函数
# 执行生成器函数，返回的就是一个生成器
data = test_func2()
# <generator object test_func2 at 0x0000029D05D6C820> <class 'generator'>
print(data, type(data))
# generator: 生成器， data:生成器的对象，类型：生成器
"""
yield的使用形式：yield expression_list
#什么是迭代器：实现了迭代协议(__next__, __iter__)的对象
#生成器就是一个迭代器: 在它内部实现了__iter__, __next__
#__bool__ => bool(obj) => obj.__bool__()
#__next__ => next(obj) => obj.__next__()
"""
"""
执行生成器函数: 产生了一个生成器
问题是：怎么去用这个生成器？
1.当一个生成器函数被调用的时候，它返回一个迭代器，称为生成器
2.生成器(data)来控制生成器函数(test_func2)的执行
3.当生成器(data)的某一个方法?(__next__和generator.send)被调用的时候，生成器函数开始执行。
can't send non-None value to a just-started generator
不能发送一个非空值到刚开始的生成器
4.执行到第一个 yield 表达式，执行被挂起
5.通过调用生成器的某一个方法?(__next__或generator.send)，生成器函数继续执行
其实又回到了3-5这个步骤
6.直到抛出StopIteration就结束了(再也没有找到yield表达式)
"""
# print(next(data)) #next(data) => data.__next__ => data生成器-》 迭代器 -》 __next__
# print(next(data))
# print(next(data))
# print(next(data))
# print(data.send(None)) #调用了send方法，生成器函数开始执行，执行第一个yield "123"挂起
# 给调用者返回了"123" => 123
# print(data.send(666)) #继续调用send方法, 生成器函数继续执行，send:666 => yield "123"
# value = 666, print(value) => 666
# yield "456"挂起
# 返回"456"给调用者
# TypeError: can't send non-None value to a just-started generator
test_data = 2 * 2
# 执行2 * 2
# 执行赋值给 test_data
"""
yield expression_list => expression_list 计算完成后，返回给谁了？
yield返回给生成器的调用者的值是expression_list => "123"
data = yield expression_list =》 data 是什么的值
yield expression_list计算完的值是None
通过调用一个方法：__next__
另外一个方法send: 发送的意思，data.send(value) => 发送给谁了
"""
for i in data:
print(i)
# 生成器推导式：
# 表达式，推导式
# 一条语句产生一个生成器
"""
语法形式：
(表达式 for 临时变量 in iterable 过滤)
"""
gen = (i for i in range(10))
print(gen, type(gen))
print(next(gen))
print(gen.send(123))
print(gen.send(123))
print(next(gen))
|