迭代器

不是函数，只是一个称呼

1.可迭代对象

如果给定一个list或tuple，我们可以使用for循环来遍历这个list，这种遍历我们称之为迭代

而只要是可迭代对象，都可以用for循环进行运行，怎样判断可迭代对象？

凡是有__iter__方法的就是可迭代对象。

# x = 1.__iter__  # SyntaxError: invalid syntax
# 以下都是可迭代的对象
name = 'nick'.__iter__
lis = [1, 2].__iter__
tup = (1, 2).__iter__
dic = {'name': 'nick'}.__iter__
s1 = {'a', 'b'}.__iter__
f = open('49w.txt', 'w', encoding='utf-8')
f.__iter__
f.close()

总结：

可迭代的对象：除了数字类型，其他都是可迭代对象。python内置str、list、tuple、dict、set、file都是可迭代对象

2.迭代器

为什么要有迭代器对象：提供了不依赖索引取值的手段

可迭代的对象执行__iter__方法得到返回值就是迭代器对象，特点是：

可迭代对象能使用__next__方法，执行会拿到迭代器对象中一个值
内置__iter__方法，执行会拿到迭代器本身
文件本身就是迭代器对象。

缺点：

取值麻烦，只能一个一个取，并且只能向后取值，值取了就没了
无法使len方法获取长度

可迭代对象: 含有__iter__方法叫做可迭代对象 --> 除了数字类型都是可迭代对象 --> 可迭代对象使用__iter__变成迭代器

# 迭代器对象: 含有__iter__和__next__方法叫做迭代器对象 --> 只有文件时迭代器对象 --> 迭代器使用__iter__依然是迭代器

# 可迭代对象不一定是迭代器对象; 迭代器对象一定是可迭代对象

3.三元表达式

条件判断写成一行输出。(又称三目表达式)

x = 10
y = 20
if x > y:
    print(x)
else:
    print(y)
########可写成##########

print(x) if x > y else print(y) #  --> 仅作了解

# 条件成立走这里 if 条件 else 条件不成立走这里

4.列表生产式

python内置的可以生成list的生成式

# 生成[1*1，2*2，3*3，...，10*10]列表
# 第一:循环
l= []
for i in range(1,11):
    l.append(i*i)
print(l)

列表生成式

print([x * x for x in range(1, 11)])
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

5.字典生成式

dic = {}
for i in range(10):
    dic[i] = i
print(dic)

字典生成器

dic = {i:i**2 for i in range(10)}
print(dic)

zip

可以使多个元素的第一个值拼接并返回元组，但只会接受最少位数

zip()
res = zip([1,2,3],[4,5,6,7,],'abcds')  
# res是一个迭代器,__next__返回元组
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple
'''
(1, 4, 'a')
(2, 5, 'b')
(3, 6, 'c')
'''

生成器表达式

generator 本质是一个迭代器==》生成器：本质就是迭代器，生成器就是一个自定义的迭代器

g = (i for i in range(10000000))
print(g)
# for i in g:
#     print(i)
lt = [i for i in range(10000000)]
print(lt)

生成器表达式：看成老母鸡，节省内存空间，用就下单

列表推导式：看成一篮子鸡蛋，清晰醒目，但占用空间

生成器

含有yield关键字的函数叫做生成器

yield的特性：

暂停函数
通过next取值

return的特效

终止函数
通过调用函数拿到值

def ge():
    yield 3  # 一个yield相当于一个next; 暂停函数
    print（1） 
    yield 4
# print(ge())  # ge()得到一个生成器 --> 生成器本质是迭代器

g = ge()  # 得到一个生成器
print(g.__next__())   #
print(g.__next__())	#依次打印 3 4

递归

函数a内部直接调用函数a本身

每一次递归,会不会结束函数?不会,

并且每一次递归都会开辟内存空间,最多递归1000次

函数内部调用函数自己
必须要有退出条件
递归必须要有规律

count = 0

def a():
    global count
    count += 1
    print(count)
    if count == 5:
        return
    a()

a()