迭代器，三元表达式和列表推导式，字典生成式，生成器，递归

迭代器

迭代的工具。迭代是更新换代，如你爷爷生了你爹，你爹生了你，迭代也可以说成是重复，并且但每一次的重复都是基于上一次的结果来的。如计算机中的迭代开发，就是基于软件的上一个版本更新。

可迭代对象

对于这一切的对象中，但凡有__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都是可迭代对象。

特点：内置有__iter__方法的都叫可迭代的对象。

迭代器对象

只有字符串和列表都是依赖索引取值的，而其他的可迭代对象都是无法依赖索引取值的。因此我们得找到一个方法能让其他的可迭代对象不依赖索引取值。

在找到该方法前，首先我们给出迭代器对象的概念：可迭代的对象执行__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:

# 依赖索引的数据类型迭代取值
lis = [1, 2, 3]
iter_lis = lis.__iter__()
print(iter_lis.__next__())
print(iter_lis.__next__())
print(iter_lis.__next__())
# print(iter_lis.__next__())  # StopIteration:

上述的方法是非常繁琐的，我们可以使用while循环精简下。

s = 'hello'
iter_s = s.__iter__()

while True:
    try:
        print(iter_s.__next__())
    except StopIteration:
        break

总结

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

特点：

1. 内置__next__方法，执行该方法会拿到迭代器对象中的一个值
2. 内置有__iter__方法，执行该方法会拿到迭代器本身
3. 文件本身就是迭代器对象。

缺点：

1. 取值麻烦，只能一个一个取，并且只能往后取，值取了就没了
2. 无法使用len()方法获取长度

for循环原理

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

因为迭代器使用__iter__后还是迭代器本身，因此for循环不用考虑in后的对象是可迭代对象还是迭代器对象。

由于对可迭代对象使用__iter__方法后变成一个迭代器对象，这个迭代器对象只是占用了一小块内存空间，他只有使用__next__后才会吐出一个一个值。如lis = [1,2,3,4,5,...]相当于一个一个鸡蛋，而lis = [1,2,3,4,5,...].__iter__相当于一只老母鸡，如果你需要蛋，只需要__next__即可。

三元表达式与列表推导式

三元表达式

表达式简单的时候用，复杂起来会看着很累，不利于代码可读性

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

x = 10
y = 20

print(f"x if x > y else y: {x if x > y else y}")

列表推导式

不利于代码可读性，少用

[i for i in range(10)]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

字典生成式

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

zip()方法

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 ***** 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
 
>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列：

#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

输出结果为：
0 1 1 2 3 5 8 13 21 34 55

递归

什么是递归函数

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

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

foo()  # 进入死循环

直接调用

直接调用指的是：直接在函数内部调用函数自身。

import sys

# 修改递归层数
sys.setrecursionlimit(10000)
def foo(n):
    print('from foo',n)
    foo(n+1)
foo(0)

间接调用

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

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

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

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

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

'''
...
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 26

age(n) = age(n-1) +2 
age(1) = 26  # n=1
'''

def age(n):
    if n == 1:
        return 26
    res = age(n-1) + 2
    return res

print(f"age(5): {age(5)}")

#输出结果为  34

为什么要用递归

递归的本质就是干重复的活，但是仅仅是普通的重复，我们使用while循环就可以了。

lis = [1, [2, [3, [4, [5, [6, ]]]]]]


def tell(lis):
    for i in lis:
        if type(i) is list:
            tell(i)
        else:
            print(i)


# print(f"tell(lis): {tell(lis)}")
tell(lis)

1
2
3
4
5
6

如何用递归

二分法的应用

有一个从小到大排列的整型数字列表，我们判断某一个数字是不是在这个列表里面。

nums = [1, 3, 7, 11, 22, 34, 55, 78, 111, 115]

for item in nums:
    if item == 10:
        print('find it')
        break
else:
    print('not exists')

对于上述的列表我们可能可以通过一个for循环实现我们需要的功能，但是当我们的列表中的元素个数非常多时，我们还用这种方法，那是极其复杂的，因此我们可以考虑使用二分法的思想实现。

from random import randint
nums = [randint(1, 100) for i in range(100)]
nums = sorted(nums)
print(nums)

[1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 10, 11, 11, 11, 11, 12, 13, 13, 15, 16, 16, 20, 21, 21, 23, 24, 26, 26, 27, 28, 28, 31, 33, 33, 34, 35, 38, 38, 39, 40, 42, 43, 45, 45, 46, 46, 47, 47, 51, 52, 52, 53, 53, 55, 55, 56, 56, 57, 57, 57, 58, 59, 61, 62, 64, 66, 66, 67, 68, 69, 69, 71, 72, 72, 74, 74, 75, 76, 78, 78, 79, 79, 79, 79, 80, 82, 85, 88, 89, 90, 90, 91, 91, 91, 94, 99, 99, 100]

def search(search_num, nums):
    mid_index = len(nums)//2
    print(nums)
    if not nums:
        print('not exists')
        return
    if search_num > nums[mid_index]:
        # in the right
        nums = nums[mid_index+1:]
        search(search_num, nums)
    elif search_num < nums[mid_index]:
        # in the left
        nums = nums[:mid_index]
        search(search_num, nums)
    else:
        print('find it')


search(7, nums)

[1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 10, 11, 11, 11, 11, 12, 13, 13, 15, 16, 16, 20, 21, 21, 23, 24, 26, 26, 27, 28, 28, 31, 33, 33, 34, 35, 38, 38, 39, 40, 42, 43, 45, 45, 46, 46, 47, 47, 51, 52, 52, 53, 53, 55, 55, 56, 56, 57, 57, 57, 58, 59, 61, 62, 64, 66, 66, 67, 68, 69, 69, 71, 72, 72, 74, 74, 75, 76, 78, 78, 79, 79, 79, 79, 80, 82, 85, 88, 89, 90, 90, 91, 91, 91, 94, 99, 99, 100]
[1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 10, 11, 11, 11, 11, 12, 13, 13, 15, 16, 16, 20, 21, 21, 23, 24, 26, 26, 27, 28, 28, 31, 33, 33, 34, 35, 38, 38, 39, 40, 42, 43, 45, 45, 46, 46, 47, 47]
[1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 10, 11, 11, 11, 11, 12, 13, 13, 15, 16, 16, 20, 21]
[1, 2, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7]
[6, 6, 7, 7, 7]
find it