Python核心语法-高级语法（六）_python 高级语法-CSDN博客

try:
    可能触发异常的语句
except 错误类型1 [as 变量1]：
    处理语句1
except 错误类型2 [as 变量2]：
    处理语句2
except Exception [as 变量3]：
    不是以上错误类型的处理语句
finally:
    无论是否发生异常的语句

as 子句是用于绑定错误对象的变量，可以省略

except 子句可以有一个或多个，用来捕获某种类型的错误。

finally 子句最多只能有一个，如果没有 except 子句，必须存在。

如果异常没有被捕获到，会向上层 ( 调用处 ) 继续传递，直到程序终止运行。

4、迭代

每一次对过程的重复称为一次“ 迭代 ” ，而每一次迭代得到的结果会作为下一次迭代的初始值。例如：循环获取容器中的元素。

（1）可迭代对象iterable

具有 __iter__ 函数的对象，可以返回迭代器对象。

语法：

# 创建：
class 可迭代对象名称:
    def __iter__(self):
        return 迭代器

# 使用：
    for 变量名 in 可迭代对象:
        语句

原理：

迭代器 = 可迭代对象.__iter__()
while True:
    try:
        print(迭代器.__next__())
    except StopIteration:
        break

（2）迭代器对象iterator

可以被next()函数调用并返回下一个值的对象。

语法：

class 迭代器类名:
    def __init__(self, 聚合对象):
        self.聚合对象= 聚合对象

    def __next__(self):
        if 没有元素:
            raise StopIteration()
            return 聚合对象元素

说明：聚合对象通常是容器对象。

作用：使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部

结构。

5、生成器generator

定义：能够动态 ( 循环一次计算一次返回一次 ) 提供数据的可迭代对象。

作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。

（1）生成器函数

定义：含有 yield 语句的函数，返回值为生成器对象。

语法：

# 创建：
def 函数名():
    …
    yield 数据
    …

# 调用：
    for 变量名 in 函数名():
        语句

说明：

-- 调用生成器函数将返回一个生成器对象，不执行函数体。

-- yield 翻译为 ” 产生 ” 或 ” 生成 ”

执行过程：

a. 调用生成器函数会自动创建迭代器对象。

b. 调用迭代器对象的 next () 方法时才执行生成器函数。

c. 每次执行到 yield 语句时返回数据，暂时离开。

d. 待下次调用 next () 方法时继续从离开处继续执行。

原理：生成迭代器对象的大致规则如下

a. 将 yield 关键字以前的代码放在 next 方法中。

b. 将 yield 关键字后面的数据作为 next 方法的返回值。

演示：

def my_range(stop):
    number = 0
    while number < stop:
        yield number
        number += 1

for number in my_range(5):
    print(number) # 0 1 2 3 4

（2）内置生成器

枚举函数enumerate

遍历可迭代对象时，可以将索引与元素组合为一个元组。

for 变量 in enumerate(可迭代对象):
    语句

for 索引, 元素in enumerate(可迭代对象):
    语句

示例：

list01 = [43, 43, 54, 56, 76]
# 从头到尾读 -- 读取数据
for item in list01:
    print(item)

# 非从头到尾读 -- 修改数据
for i in range(len(list01)):
    if list01[i] % 2 == 0:
        list01[i] += 1

for i, item in enumerate(list01): # -- 读写数据
    if item % 2 == 0:
        list01[i] += 1

zip

将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决

定。

for item in zip(可迭代对象1, 可迭代对象2):
    语句

示例：

list_name = ["张三", "李四", "丽莎"]
list_age = [22, 26, 25]
# for 变量 in zip(可迭代对象1,可迭代对象2)
for item in zip(list_name, list_age):
    print(item)
# ('张三', 22)
# ('李四', 26)
# ('丽莎', 25)

# 应用:矩阵转置
map = [
    [2, 0, 0, 2],
    [4, 2, 0, 2],
    [2, 4, 2, 4],
    [0, 4, 0, 4]
]
# new_map = []
# for item in zip(map[0],map[1],map[2],map[3]):
# new_map.append(list(item))
# print(new_map)

# new_map = []
# for item in zip(*map):
# new_map.append(list(item))

new_map = [list(item) for item in zip(*map)]
    print(new_map)
# [[2, 4, 2, 0], [0, 2, 4, 4], [0, 0, 2, 0], [2, 2, 4, 4]]

（3）生成器表达式

用推导式形式创建生成器对象。

变量 = (表达式 for 变量 in 可迭代对象 if 条件)

6、函数式编程

（1）函数作为参数

高阶函数

def 通用函数(容器,条件):
    for item in 容器:
        if 条件(item):
            return item

lambda表达式

是一种匿名方法

作为参数传递时语法简洁，优雅，代码可读性强

随时创建和销毁，减少程序耦合度。

形参没有可以不填

方法体只能有一条语句，且不支持赋值语句。

结果 = 通用函数(容器,lambda参数:函数体)

# 定义：
变量 = lambda 形参: 方法体
# 调用：
变量(实参)

（2）函数作为返回值

装饰器

定义：在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数。

本质：使用 “@ 函数装饰器名称 ” 修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。

原函数名称 = 函数装饰器名称（原函数名称）

装饰器链：一个函数可以被多个装饰器修饰，执行顺序为从近到远。

def 函数装饰器名称(func):
    def wrapper(*args, **kwargs):
        需要添加的新功能
        res = func(*args, **kwargs)
        return res
    return wrapper


@ 函数装饰器名称
def 原函数名称(参数):
    函数体


原函数(参数)