python 星号zip_易忘易忽略的Python入门知识点-续(一)

迭代器与生成器

迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。 迭代器是一个可以记住遍历位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，它只能往前不会后退。

迭代器，常用的两个方法iter()和next()；

import os
list1 = [1,2,3,4]
myiter = iter(list1) # 生成迭代器对象
# for ele in myiter:
#    print(next(ele))
while True:
    try:
        print(next(ele))
    except StopIteration:
        os._exit(1)

当抛出StopIteration异常时，调用模块 sys的 exit()方法，会出现 SystemExit exception raised from sys.exit()；解决方法是使用调用 os._exit() ,它直接退出，不会抛出异常。参数是进程返回的退出码。

应用栗子：如何将列表分隔成大小均匀的块？ 一个方法是结合使用 zip()和 iter()函数：

x = [1,2,3,4,5,6,7,8,9]
y = zip(*[iter(x)]*2)  # 2是表示每个块的大小
list(y)   # [(1, 2), (3, 4), (5, 6), (7, 8)]

过程理解：

1. iter()是序列上的迭代器

2. [iter(x)] * 2生成一个包含2个listiterator对象的列表：每个列表迭代器都是x的一个迭代器。

3. 在将序列解压缩为参数之前传递给zip()函数的*，是为了将相同的迭代器传递给zip()函数4次，每次从迭代器中提取一个项。

具体步骤：

首先，会有2个列表迭代对象，就是原来相同的2个列表：[1,2,3,4,5,6,7,8,9]，[1,2,3,4,5,6,7,8,9]

然后， 第一次，zip()将按顺序接受列表中的一个元素，[1][2]

注意：迭代对象会保留迭代器中下一个元素的位置

第二次，元素将被添加到刚刚创建的2个列表中，最终将得到：[1, 3], [2,4]

第三次，执行相同的过程，最终得到：[1, 3, 5], [2, 4, 6]

第四次，执行相同的过程，最终得到：[1, 3, 5, 7], [2, 4, 6, 8]

最后，zip 将这三个列表压缩在一起，得到：(1, 2), (3, 4), (5, 6), (7, 8)

可以自己创建迭代器，将一个类作为一个迭代器，需要实现两个方法:

class MyNumbers:
    def __iter__(self):
        self.a = 1
        return self
    def __next__(self):
        if self.a <= 5:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration #StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
    print(x)

生成器

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

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。 在调用生成器运行的过程中，每次遇到 yield时函数会暂停并保存当前所有的运行信息，返回 yield的值, 并在下一次执行next()方法时从当前位置继续运行。

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

应用栗子1：用yield实现斐波那契数列

import os
def fibonacci(n):
    a,b,count = 0,1,0
    while True:
        if count > n:
            return
        yield a
        a,b = b, a+b
        count += 1

f = fibonacci(10)
while True:
    try:
        print(next(f), end=' ')
    except StopIteration:
        os._exit(1)

应用栗子2：用yield实现将列表分隔成大小均匀的块

def chunks(list, chunkSize):
    for i in range(0, len(list), chunkSize):
        yield list[i:i + chunkSize]

函数

1 . 函数参数传递 在 python 中，类型属于对象，变量是没有类型的，例如：

a=[1,2,3]
a="ipine"

以上代码中，[1,2,3] 是List类型，"ipine" 是 String 类型，而变量 a 是没有类型，它仅仅是一个 对象的引用（一个指针），可以是指向 List 类型对象，也可以是指向 String 类型对象。

再次提到 可变 VS 不可变对象

strings，tuples和numbers不可变；list，dict等可变

• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让a指向它，而 5 被丢弃，不是改变a的值，相当于 新生成了a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

函数的参数传递分为 可变与不可变类型

• 不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
• 可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响。

2 . 参数的类型

• 必需（位置）参数，必需参数强调参数顺序。调用时的数量和位置必须和声明时的一样。
• 关键字参数，使用关键字参数来确定传入的参数值，对参数顺序不敏感，通过参数名匹配参数值。
• 默认参数，若调用没有传递参数，则使用默认参数。
• 不定长参数，不确定调用时传入几个参数，那声明参数时不命名。两种形式，一个星号的参数和两个星号的参数：

*args: 表示参数个数不确定，且想传入元组或列表形式的参数时使用；一个星号将序列或集合解包成位置参数
**kwargs: 表示参数个数不确定，且想传入字典的值作为关键字参数时使用；两个星号把字典解包成关键字参数

声明函数时，参数中星号*可以单独出现，但是星号后面的参数，必须用 关键字传入。例如：

def f(a,b,*,c):
    return a+b+c

f(1,2,3) #报错
f(1,2, c=3) #正确

3 . 匿名函数 lambda是一个表达式，不是一个代码块。它不能访问 自己参数列表之外或全局命名空间里的参数。

4 . 不带参数值的return语句返回的是None；如果函数没有使用 return 语句，则函数返回 None。

5 . 变量作用域 Python的作用域有4种，分别是：

L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内置作用域（内置函数所在模块的范围）

查找的规则是：在局部找不到，去局部外的局部找（闭包），再找不到就全局找，最后再去内置找。

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一个名为builtins 的标准模块来实现的, 必须导入这个文件才能够使用它。

import builtins
print(dir(builtins))

模块、类、函数（包括lambda表达式）会引入新的作用域，其他代码块不会。

6 . global和nonlocal关键字 当内部作用域想修改外部作用域的变量时，需要用global和nonlocal关键字。

global关键字用于修改全局作用域的变量，例如：

num = 1 
def fun1(): 
    global num # 需要使用 global 关键字声明 
    print(num)  # 1
    num = 123 
    print(num)  # 123

fun1() 
print(num) # 123，已经将全局变量的值修改了

nonlocal关键字用于修改嵌套（enclosing）作用域，例如：

def outer(): 
    num = 10 
    def inner(): 
        nonlocal num # nonlocal关键字声明 
        num = 100 
        print(num)  # 100
    inner() 
    print(num)  # 100

outer()

一种特殊情况，函数使用全局作用域的变量，如下一段代码：

a = 10
def test():
    a = a + 1
    print(a)
test(a)

会抛出 局部作用域引用错误，因为test 函数中的a 使用的是局部变量，未定义，无法修改。 正确应该是：

a = 10
def test(a):
    a = a + 1
    print(a)
test(a) # 11
print(a) # 10，传递参数类型是不可变类型，所以只是值传递

数据结构

1 . 列表的clear()方法，用于移除列表中的所有项，等于del a[:]。 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素；也可以使用它传入key来删除字典元素。

2 . 可以用花括号{}创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是{}；后者创建一个空的字典。集合的功能包括 成员关系检查和 消除重复元素。

3 . 选择正确的内置功能。 当遍历列表既要访问索引又要访问值时，使用enumerate()而不是range()进行迭代。

对于每个元素，enumerate()返回一个计数器和元素值。计数器默认为0，也是元素的索引。不想在0开始计数，只需使用可选的start参数来设置偏移量：

numbers = [45, 22, 14]
for i, num in enumerate(numbers, start=52):
    print(i, num)

当遍历字典时，使用 items() 将关键字和对应的值同时解读出来：

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k, v in knights.items():
    print(k, v)

同时遍历两个或更多的序列，使用 zip() 组合：

questions = ['name', 'favorite color']
answers = ['ipine', 'red']
for q, a in zip(questions, answers):
    print(f'What is your {q}? It is {a}.')
    # print('What is your {0}?  It is {1}.'.format(q, a))

按顺序遍历序列，使用 sorted()函数返回有序序列，不改变原序列：

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
    print(f)
print(basket)

反向遍历一个序列，首先指定序列，然后调用reversed()函数：

for i in reversed(range(1, 10, 2)):
    print(i,end=' ') # 9 7 5 3 1