函数（四）迭代器

目录

• 迭代器
  • 1 可迭代对象
  • 2 迭代器对象
  • 3 缺点
  • 4 for循环原理
• 三元表达式和列表推导式
  • 1 三元表达式
  • 2 列表推导式
• 字典生成式
  • 拉链函数
• 生成器
  • 1 定义:自定义的迭代器
  • 2 yield关键字
  • 3 yield 好处
  • 4 yield与return的区别
• 递归
  • 1 直接调用
  • 2 间接调用

迭代器

1 可迭代对象

​ 有 __ iter __ 的都是可迭代对象

​ 可迭代的对象：Python内置str、list、tuple、dict、set、file都是可迭代对象

2 迭代器对象

​ 有 __ next __ 的可迭代对象叫做迭代器对象

​ 文件本身就是迭代器对象

3 缺点

​ （1）取值麻烦，只能一个一个取，并且只能往后取，值取了就没了

​ （2）无法使用len()方法获取长度

4 for循环原理

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

hobby_list2 = ['run','read']
hobby_list2_iter = hobby_list2.__iter__()
while True:
    try:
        print(hobby_list2_iter.__next__())
    except:
        break

for i in hobby_list2:  # hobby_list2,把hobby_list2转化为可迭代对象
    print(i)

三元表达式和列表推导式

1 三元表达式

​ 条件成立时的返回值 if 条件 else 条件不成立时的返回值

x = 10
y = 20

if x > y:
    print(x)
else:
    print(y)

print((x) if x > y else (y))

2 列表推导式

list = []
lis1 = [i * 2 if i > 50 else i for i in range(100)]
print(lis1)

这两方式不推荐使用

字典生成式

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

拉链函数

​ 通过解压缩函数生成一个字典

res = zip('abcd',[1,2,3,4])
dic = dict()
for k,v in res:
    dic[k] = v
print(dic)

print({k:v for k,v in zip('abcd',[1,2,3,4])})


{'a': 1, 'b': 2, 'c': 3, 'd': 4}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

生成器

1 定义:自定义的迭代器

2 yield关键字

​ 在函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值none

3 yield 好处

​ 1.不会将所有数据取出来存入内存中；而是返回了一个对象；可以通过对象获取数据；用多少取多少，可以节省内容空间。

​ 2.除了能返回一个值，还不会终止循环的运行；

def func():
    print(1)
    yield        # 不会执行print（2）
    print(2)


g = func()
print(g)

4 yield与return的区别

1. 相同点：两者都是在函数内部使用，都可以返回值，并且返回值没有类型和个数的限制
2. 不同点：return只能返回一次之；yield可以返回多次值

递归

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

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

foo()  # 进入死循环

​ 如果递归函数不断地调用函数自身，那么这个递归函数将会进入一个死循环，因此我们应该给递归函数一个明确的结束条件。

1 直接调用

​ 直接在函数内部调用函数自身

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

foo()

2 间接调用

不在原函数体内调用函数自身，而是通过其他的方法间接调用函数自身

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

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

bar()

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

1. 递推：一层一层递归调用下去，进入下一层递归的问题规模都将会减小

2. 回溯：递归必须要有一个明确的结束条件，在满足该条件开始一层一层回溯。

   递归的精髓在于通过不断地重复逼近一个最终的结果。