Day9 元组详解（推导式，生成器）——python学习之路

定义

定义空元组

# 1.
vartuple = ()
# 2.
vartuple = tuple()

定义含有数据的元组

# 1.
vartuple = (1,2,3)
# 2.
vartuple = 1,2,3
# 只有一个元素的元组定义方式，记得加逗号
vartuple = ('one',)

元组的相关操作

+ 运算

元组的 + 运算, 合并元组, 组成新的元组

res = (1, 2, 3) + (5, 6, 7)
print(res)

#(输出) (1, 2, 3, 5, 6, 7)

* 运算

元组的 * 运算

res = (1, 2) * 3
print(res)

#(输出) (1, 2, 1, 2, 1, 2)

in | not in

检测一个元素是否在元组中

res = (1, 2, 3, 4)
print(2 in res)			#(输出) True
print(6 not in res)		#(输出) True

切片操作

vart = (1, 2, 3, 4, 5)
res = vart[:]           # 获取全部
res = vart[::]          # 获取全部
res = vart[1:]          # 从索引1开始获取到最后
res = vart[1:3]         # 从索引1开始获取到索引3之前
res = vart[:3]          # 从索引0开始到索引3之前
res = vart[1:5:2]       # 从索引1开始到索引5之前, 步进值为2
res = vart[::2]         # 从索引0开始到最后, 步进值为2
res = vart[5:1:-1]      # 从索引5开始到索引1, 步进值为-1, 倒着输出

元组的相关函数

len()

len() 获取元组的长度

vart = (12345, 'hello', 54321, 'hello')
res = len(vart)
#(输出) 4

index()

index() 获取一个元素在元组中的索引值

vart = (12345, 'hello', 54321, 'hello')
print(vart.index('hello'))				#(输出) 1, 输出第一个'hello'的下标
print(vart.index('hello', 2))    		#(输出) 3, 从指定下标位置开始查找
print(vart.index('hello', 1, 3))		#(输出) 1, 从指定的 索引区间内 查找

元组推导式

• 与列表推导式的区别：列表推导式结果返回一个列表, 元组推导式返回的是生成器
• 语法： (变量运算 for i in 容器) ⇒ 一个生成器
• 生成器是迭代器的一种, 因此可以使用迭代器的操作方法来操作生成器

# 元组推导式 结果返回 生成器generator
newt = (i for i in range(10))
print(newt)         #(输出) <generator object <genexpr> at 0x000001FE3B5969C8>

# 使用next函数调用
newt = (i for i in range(10))
print(next(newt))       #(输出) 0
print(next(newt))       #(输出) 1

# 使用list或tuple函数进行操作
newt = (i for i in range(10))
print(list(newt))           #(输出) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(tuple(newt))          #(输出) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 使用for进行遍历
newt = (i for i in range(10))
for i in newt:
    print(i)

生成器 generator

定义

• 生成器是按照某种算法去推算下一个数据或结果, 只需要往内存中存储一个生成器, 节约内存消耗, 提升性能
• 生成器是一个特殊的迭代器
• 生成器可以自定义, 也可以使用元组推导式去定义

语法

1. 里面是推导式, 外面是一个() 的结果就是一个生成器
2. 自定义生成器, 含有 yield 关键字的函数就是生成器
     含有yield关键字的函数, 返回的结果是一个迭代器, 换句话说, 生成器就是一个返回迭代器的函数

实例

1. 使用 next 的时候, 会开始执行直到遇到一个 yield, 然后把结果返回, 下次会从当前位置执行, 直到遇到下一个 yield

# 定义一个普通函数
def hello():
    print('hello 1')
    return 1    # return 在函数中会把结果返回, 并且结束当前的函数, 后面的代码不再执行
    print('world 2')
    return 2

# 定义一个生成器函数
def hello():
    print('hello 1')
    yield 1
    print('world 2')
    yield 2

# 调用生成器函数, 返回一个迭代器, 并没有做任何操作
res = hello()

# 对迭代器使用 next 
r = next(res)	# 执行hello生成器函数，直到遇到一个 yield 
print(r)
#(输出)
# hello 1
# 1

# 再一次调用
r = next(res)	# 从上一次执行结束位置开始，往下执行，直到遇到一个 yield
print(r)
#(输出)
# world 2
# 2

2. 使用 list类似的函数 去调用生成器返回的迭代器时, 会把迭代器的返回结果, 作为容器的元素

def hello():
    print('hello 1')
    yield 1
    print('world 2')
    yield 2

r = list(res)	# 所有的程序会被执行完， yield 返回的值被存入一个 list 中
print(r)

#(输出)
# hello 1
# world 2
# [1, 2]

3. 同样可以通过 for 来调用生成器返回的迭代器

def hello():
    print('hello 1')
    yield 1
    print('world 2')
    yield 2
    
res = hello()
for i in res:
    print(i)

#(输出)
# hello 1
# 1
# world 2
# 2

'''
上面的生成器函数调用时的过程
首先 调用生成器函数, 返回一个迭代器
    1. 第一次去调用迭代器:
        走到当前的生成器函数中, 遇到了 yield 1, 把1返回, 并且记住当前的执行状态(位置), 暂停了执行, 等待下一次的调用
        
    2. 第二次去调用迭代器
        从上一次遇到的yield位置开始执行, 遇到了 yield 2, 把2返回, 并记住状态, 暂停执行, 等待下一次调用
        
    3. 第三次去调用迭代器
        从上一次遇到的yield位置开始执行, 遇到 yield 3, 把3返回, 并记住了状态, 暂停执行, 等待下一次调用
        
    如果在最后又调用了迭代器, 那么会从上一次的 yield位置开始, 结果后面没有了, 直接就超出范围, 报错
'''