Python day13

迭代器

可迭代对象

python的一切都是对象,在这对些对象里,但凡有__iter__方法的对象，都是可迭代对象。

# 除了数字类型，所有数据类型都是可迭代对象
# 可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象。

迭代器对象

迭代器对象: 含有__iter__和__next__方法的对象就是迭代器对象

迭代器对象的概念：可迭代的对象执行__iter__方法得到的返回值。并且可迭代对象会有一个__next__方法。

迭代器的作用 : 提供了不依赖索引取值的手段

# 不依赖索引的数据类型迭代取值
dic = {'a': 1, 'b': 2, 'c': 3}
iter_dic = dic.__iter__()
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())
# print(iter_dic.__next__())  # StopIteration:

#可迭代对象使用__iter__变成迭代器

for 循环原理

for循环的本质是一个while循环,只不过它是一个可控的while循环

for循环称为迭代器循环，in后必须是可迭代的对象。

def for1(iterable):
    iterator = iterable.__iter__()
    while True:
        try:
            print(iterator.__next__())
        except StopIteration:
            break

for1([1,2,3])

三元表达式

x = 10
y = 20

if x > y:
    print(x)
else:
    print(y)
    
#print(x) if x > y else print(y)
# 条件成立走这里 if 条件 else 条件不成立走这里

列表推导式

lt = []

for i in range(10):
    lt.append(i)

#lt = [i for i in range(10)]  #第一个i可以做运算

字典生成式

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

# zip()
res = zip([1,2,3],[4,2,3,4,2,3,4,2,3],'abcadsfasd')  # res是一个迭代器,__next__返回元组
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple
print(res.__next__())  # type:tuple
# print(res.__next__())  # type:tuple

生成器生成公式

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关键字

def ge():
    yield 1
    yield 2
    
g = ge()# 得到一个生成器  # ge()得到一个生成器 --> 生成器本质是迭代器
print(g.__next__())
print(g.__next__())

# yield的特性

# 1. 暂停函数
# 2. 通过next取值

函数递归

函数的递归调用：它是一种特殊的嵌套调用，但是它在调用一个函数的过程中，又直接或间接地调用了它自身。

def foo():
    print('from foo')
    foo()

foo()  # 进入死循环

直接调用

def a():
    x = 1
    print(x)
    a()

a()

间接调用

def bar():
    print('from bar')
    foo()
    
def foo():
    print('from foo')
    bar()
    
bar()

递归必须要有两个明确的阶段：

递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小
回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

函数递归必须满足的条件:

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