python3入门(4)-函数、迭代器、生成器

python不定长参数函数

其他函数定义及循环方式与其他语言基本相似，不再赘述。

python中不定长参数函数的定义：

def test(*test):
    print(test)   # (1, 2, 3, 4)
    print(type(test))  # <class 'tuple'>
    
def test2(**test):
    print(test)   # {'a': 2, 'b': 3}
    print(type(test))    # <class 'dict'>

def test3(a, b, *, c):
    print(a)
    print(b)
    print(c)
    print(type(a))
    print(type(b))
    print(type(c))

if __name__ == '__main__':
    test(1, 2, 3, 4)
		test2(a=2, b=3)
    test3(1, 2, c=3)

不定长参数的参数名前为*时，类型为tuple；参数名前为**时，参数类型为dict;*也可以单独出现，当*单独出现时，*后面必须有参数，并且*后面的参数必须要用关键字传入，否则报错(TypeError: test3() takes 2 positional arguments but 3 were given)。

python的匿名函数

python使用lambda来定义匿名函数，此时不再使用def来定义函数。

匿名函数的特点：

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

匿名函数示例：

sum = lambda x, y: x + y

if __name__ == '__main__':
    print(sum(x=1, y=2))   # 3
    print(sum(3, 5))    # 8

强制位置参数：

python3.8新增，函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。

def f(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
    
if __name__ == '__main__':
		f(10, 20, 30, d=40, e=50, f=60)       # 正确
		f(10, b=20, c=30, d=40, e=50, f=60)   # b 不能使用关键字参数的形式
		f(10, 20, 30, 40, 50, f=60)           # e 必须使用关键字参数的形式

python迭代器和生成器

迭代器有两个基本的方法：iter() 和 next()。字符串，列表，元组，集合，字典(只遍历key)对象都可用于创建迭代器。

string = '12345678'
set1 = {1, 2, 3, 4}
tuple1 = (1, 2, 3, 4)
list1 = [1, 2, 3, 4]
dict1 = {1: 'yi', 2: 'er'}
it_str = iter(string)
it_set = iter(set1)
it_tuple = iter(tuple1)
it_list = iter(list1)
it_dict = iter(dict1)
print(next(it_str))
print(next(it_set))
print(next(it_tuple))
print(next(it_list))
print(next(it_dict))

#也可以对迭代器对象for循环
for x in it_str:
  print(x)

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。

for example:

class TestIter:
    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        x = self.a
        self.a += 1
        return x

if __name__ == '__main__':
    t = TestIter()
    it = iter(t)
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))
    print(next(it))

tips: 上述迭代会出现无限循环，可以利用StopIteration来终止迭代。

改进版example：

class TestIter:
    def __init__(self, stop):
        self.stop = stop

    def __iter__(self):
        self.a = 1
        return self

    def __next__(self):
        if self.a <= self.stop:
            x = self.a
            self.a += 1
            return x
        else:
            raise StopIteration

if __name__ == '__main__':
    t = TestIter(10)
    it = iter(t)
    for i in it:
        print(i)

生成器

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

#!/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()

From: https://www.runoob.com/python3/python3-iterator-generator.html