Python容器与迭代器详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44405644/article/details/97485645

容器类型：列表、字典、元祖、字符串
列表生成器：
1. 一遍循环一遍进行计算（generator）,列表生成器和列表生成式基本一致，只是列表生成器是使用的小括号，而列表生成式使用的是中括号。如果要获取列表生成器生成的列表里的内容，可以使用next一个一个的推导，也可以使用for循环。列表生成器保存的是算法本身，调用的时候才会进行计算。
2. 另一种定义generator的方法：在函数中使用yield关键字。**generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。**但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中，这里拓展一下在for中自带这种异常处理，在while中不自带，需要使用try和except：
```
def tri_self(row_max):
T = [1]
row = 1
while row <= row_max:
    yield T                          
    T = [0] + T + [0]
    T = [T[i] + T[i+1] for i in range(len(T)-1)]
    row += 1


for tri1 in tri_self(10):
    print(tri1)
```
可迭代对象和Iterator对象：可以直接作用于for循环的对象统称为可迭代对象Iterable；可以使用isinstance()判断。列表、元祖、字典、set、列表生成器、字符串都是可迭代对象Iterable。但是与之相对应有Iterator对象，可以被next()调用并不断返回下一个值的对象称为迭代器。生成器是Iterator对象，列表，字符串，字典不是。使用iter()函数可以把Iterable变为Iterator.
可迭代对象和Iterator对象：
凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
Python的for循环本质上就是通过不断调用next()函数实现的
del 并不是删除对象，而只是删除一个变量引用，对象自身有一个引用计数器，del操作会造成引用计数器减1，当减为0的时候，则会清除对象。

容器类型公共方法：

内置函数（其中cmp在python3中取消，可以使用云算法直接比较，其中不能比较字典）
切片
除了字典都可以进行切片。对于字符串没有reverse，所以可以使用切片进行翻转。
运算符
其中注意列表的**extend、append和+**的区别，+号是产生新的列表。
完整的for循环遍历
实例（名片管理系统）

all_student = [{"name": "苏媛", "age": "24"},
               {"name": "王跃川", "age": "25"},
               {"name": "无名氏", "age": "20"},
               {"name": "python", "age": "21"}]

while True:
    find_student = input("请输入需要查询的学生名字！")
    for single_student in all_student:
        if single_student["name"] == find_student:
            print("该学生的年龄为：%s" % single_student["age"])
            break
    else:
        judge = input("数据库中不包含该学生，是否添加该学生到数据库？（y/n）")
        if judge == "y":
            age_newstu = int(input("请输入该学生的年龄！(%s)" % find_student))
            # 此处不可以使用extend
            all_student.append({"name": find_student, "age": age_newstu})
            print(all_student)
    end = input("是否退出数据库？（y/n）")
    if end == "y":
        break
    ```

LINUX上的Shebang操作
变量进阶
数据存储在内存中，变量指向内存是保存对应数据的地址。
变量的可变类型和不可变类型
global关键字可以声明其后的变量不生成局部变量，而是使用全局变量。
代码结构
实例
如果函数传递参数时传递的是可变类型，那么在函数内如果通过方法改变该可变类型数据的内容，那么该可变类型的外部数据随之改变。（字典和列表）；
使用+=对列表进行操作，相当于使用extend进行操作。
缺省参数：不传递参数则使用默认值，在定义缺省参的时候，一定要保证缺省参数在参数列表的最后。

```python
def info(name,gender=True):
    print(name)
    print(gender)
info("wang")
```

多值参数
接受元祖：*args
接受字典：**kwargs
多值函数中，元祖和字典变量的拆包，需要在实参中遵循多值函数形参的命名方法。

高阶函数：

内建函数map()：map函数接收两个参数，其一是函数，另一个是Iterable，主要的功能是对iterable中的每一个元素执行函数操作，需要注意，map的返回值是一个iterator，所以需要通过list()进行转化。

内建函数reduce()：该函数也有两个参数，其一是函数，另一个是Iterable，但是与map不同的是，reduce中的函数的参数是两个，也及时从iterable中选择两个参数，然后计算结果又作为新的参数之一。本质上可以看做是迭代计算的过程。该函数需要使用import从functools中导入。

"""内建函数reduce练习"""
# 利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456
from functools import reduce


s_all = "123.456"


def str2float(s_all):
    def str2num(s_sig):
        if s_sig == ".":
            pass
        else:
            return int(s_sig)

    def tofloat(x, y):
        return x * 10 + y

    ind_point = s_all.find(".")
    len_s = len(s_all)
    s_num = list(map(str2num, s_all))
    s_num.pop(ind_point)                 # 注意和remove的区别
    print(reduce(tofloat, s_num)/(10 ** (len_s - ind_point - 1)))


str2float(s_all)

内建函数filter()：参数有两个，其一是函数，其二是序列，使用函数依次对序列进行操作，根据函数返回结果的真假来判断是否要保存该元素，总而言之，filter是一个用于序列过滤的函数。fitler的返回值是iterator，也就是一个惰性序列，一般需要使用list进行强制转化。

"""用filter求素数
计算素数的一个方法是埃氏筛法，它的算法理解起来非常简单：
首先，列出从2开始的所有自然数，构造一个序列：
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取序列的第一个数2，它一定是素数，然后用2把序列的2的倍数筛掉：
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数3，它一定是素数，然后用3把序列的3的倍数筛掉：
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
取新序列的第一个数5，然后用5把序列的5的倍数筛掉：
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...
不断筛下去，就可以得到所有的素数。
"""


def first1():
    """生成从2开始的序列"""
    i = 1
    while True:
        i += 1
        yield i


def second2(n):
    """定义一个筛选的函数"""
    return lambda x: x % n != 0


def third3():
    """定义一个惰性序列，用来产生素数序列"""
    i = first1()
    while True:
        n = next(i)
        yield n
        i = filter(second2(n), i)


for m in third3():
    if m < 100:
        print(m)
    else:
        break

lambda函数：https://blog.youkuaiyun.com/zjuxsl/article/details/79437563

创建序列的方法

采用range，返回的不是一个list
采用生成器或者列表生成式，可以附带条件进行序列的生成

"""回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数"""
"""实际上只需要写一个函数如同check_num就行，然后序列生成直接采用range
def bulid_num():    # 创建一个序列（Iterator）的固定套路, 先定义初始，然后在while中进行迭代。
"""创建一个序列（实际上在此题中可以使用range来创建比较简单）"""
i_num = 1
while True:
    yield i_num
    i_num += 1


def check_num(num):
    """检查是不是一个回数"""
    num2str = str(num)
    num_after = num2str[:: -1]
    if num2str == num_after:
        return True
    else:
        return False


def round_num():
    """使用filter筛选序列"""
    it = bulid_num()
    while True:
        num = next(it)
        yield num
        it = filter(check_num, it)


for i in round_num():
    if i < 800:
        print(i)
    else:
        break

返回函数：在高阶函数中，函数可以把其他函数作为自己的参数，同时也可以将函数作为参数进行返回，当调用这个返回的函数后，函数才会执行。

"""闭包问题"""


def count():
    def f(j):
        def g():
            return j*j
        return g        # 返回的也是一个函数，不能返回int
    fs = []             # fs中存储的是函数，而不是int
    for i in range(1, 3):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

f1, f2 = count()        # 拆包
print(f1())
print(f2())


def count2():      # 传统方式， 返回的是int
    def f(j):
        def g():
            return j*j
        x = g()
        return x        # 返回的也是一个函数，不能返回int
    fs = []             # fs中存储的是函数，而不是int
    for i in range(1, 3):
        y = f(i)
        fs.append(y) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

f1, f2 = count2()        # 拆包
print(f1)
print(f2)