【Python编程】百宝箱，总能用上的（模块、包、异常处理、装饰器、函数式编程）

本文链接：https://blog.csdn.net/Discover304/article/details/122385561

【Python】笔记第五部分
全系列导航见：Python教程整理

🍀碎碎念🍀
Hello米娜桑，这里是英国留学中的杨丝儿。我的博客的关键词集中在算法、机器人、人工智能、数学等等，点个关注吧，持续高质量输出中。
🌸唠嗑QQ群：兔叽的魔术工房 (942848525)
⭐️B站账号：杨丝儿今天也在科学修仙（UP主跨站求个关注）

🌟模块 Module

程序可以拆分成以.py结尾的模块，拆分相似的逻辑。

分开以后，把有关联的代码放在一起会更清晰，有利于合作开发。

不同文件之间的关联，将目标模块的成员导入到当前模块的作用域中。

# 你过来，面向过程比较多，因为用的是文件名。
import 模块 as 名称

# 主动过来，面向对象，直接可以拿来用。
from 模块 import 成员1, 成员1, 成员1

当名字有冲突的时候，遵循就近原则。但是我们要尽力避免冲突的产生。

常用的命名：

BLL 业务逻辑层 business logic layer
DAL 数据访问层 data access layer
USL 用户显示层 user show layer
model 模型层
main 程序入口代码

__name__ 显示模块名字，显示 __main__ 的时候意思是主模块，也就是第一次运行的模块/不是被导入的模块。

python是解释型语言，但为了提高运行速度，让 python 程序更快启动，python使用了一种编译的方法。

源代码 --> 编译–> 字节码 – >解释 --> 机器码

编译之后得到pyc文件，也就是pychache文件，存储了字节码（特定于Python的表现形式）。

if __name__ == '__main__' 要求从当前文件启动。

在模块导入时，模块的所有语句会执行。如果一个模块已经导入，则再次导入时不会重新执行模块内的语句。

🌟包 Packge

将模块以文件夹的形式进行分组管理。让一些相关的模块组织在一起，使逻辑结构更加清晰。

# 语法
import 包 # 将包中__init__模块内整体导入到当前模块中
import 包 as 别名

# 使用
包.成员
别名.成员

# 语法
from 包 import 成员 # 将包中__init__模块内的成员导入到当前模块作用域中
from 包  import 成员 as 别名
from 包  import * # 小心重名问题

# 使用
成员
别名

🌟异常处理Error

异常是运行时检测到的错误。当异常发生时，程序不会再向下执行，而转到函数的调用语句。

名称异常(NameError)：变量未定义。
类型异常(TypeError)：不同类型数据进行运算。
索引异常(IndexError)：超出索引范围。
属性异常(AttributeError)：对象没有对应名称的属性。
键异常(KeyError)：没有对应名称的键。
异常基类Exception。

raise 语句，主动抛出一个错误，让程序进入异常状态。在程序调用层数较深时，向主调函数传递错误信息要层层return比较麻烦，所以人为抛出异常，可以直接传递错误信息。

为了将程序由异常状态转为正常流程，我们使用以下语法进行异常处理：

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

as 子句是用于绑定错误对象的变量，可以省略。
except子句可以有一个或多个，用来捕获某种类型的错误。
else子句最多只能有一个。
finally子句最多只能有一个，如果没有except子句，必须存在。
如果异常没有被捕获到，会向上层(调用处)继续传递，直到程序终止运行。

🌟迭代Iteration

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

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

# 创建：
class 可迭代对象名称:
	def __iter__(self):
   		return 迭代器
# 使用：
	for 变量名 in 可迭代对象:
		语句

背后的原理是：

迭代器 = 可迭代对象.__iter__() # 实例一个迭代器对象。
while True:
    try: 
        print(迭代器.__next__()) # 调用迭代器中的`__next__`方法。
    except StopIteration: # 在迭代器 raise StopIteration 后停止。
        break

迭代器对象是可以被__next__()函数调用并返回下一个值的对象。

class 迭代器类名:
    def __init__(self, 聚合对象): # 聚合对象通常是容器对象。
        self.聚合对象= 聚合对象 
 
    def __next__(self): 
        if 没有元素:
            raise StopIteration
        return 聚合对象元素

迭代器让我们只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部结构。

🌟生成器Generator

能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。

数据量越大，优势越明显。以上作用也称之为 延迟操作 或 惰性操作 ，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。

含有yield语句的函数，叫做生成器函数。调用生成器函数将返回一个生成器对象，不执行函数体。

# 创建：
def 函数名():
	代码
	yield 数据
    代码
    
# 调用：
for 变量名 in 函数名():
    语句

调用生成器函数会自动创建迭代器对象。调用迭代器对象的__next__()方法时才执行生成器函数。每次执行到yield语句时返回数据，暂时离开。待下次调用__next__()方法时继续从离开处继续执行。

适用性：优先使用生成器。

内置生成器：

range：生成计数生成器对象。
枚举函数enumerate：遍历可迭代对象时，可以将索引与元素组合为一个元组。
打包zip：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。
生成器表达式：用推导式形式创建生成器对象。变量 = (表达式 for 变量 in 可迭代对象 if 条件)
累积reduce：对参数序列进行累积。注意：在python3.x中，reduce()函数被移动到functools包中。

🌟函数式编程

函数式编程的主要思想：把运算过程尽量写成一系列嵌套的函数调用。

python函数式编程的理论支柱是函数可以被赋值给变量，实现函数的间接调用。可以使函数的使用更加灵活。

多个函数主体相同，核心算法（条件）不同的时候可以使用函数式编程，分离变化点。这里我们从面向对象的角度思考函数式编程的应用场景。

“封装”[分]：将变化点封装为多个函数，通过函数类型的数据传入实现函数的嵌套调用。
“继承”[隔]：使用函数类型的参数将当前函数的变化隔离。
“多态”[做]：编码时调用函数类型的形参，运行时调用函数类型的实参。

将核心逻辑/变化点传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。

构建这样的变化点时采用的思想是函数试编程的思想，即避免副作用，不改变也不依赖当前函数外的数据，函数带有自描述性，提高可读性。

🌟Lambda 表达式

Lambda 表达式是一种匿名方法，可以定义匿名函数。当Lambda表达式作为参数传递时语法简洁，优雅，代码可读性强。可以随时创建和销毁，减少程序耦合度。

# 定义：
变量 = lambda 形参: 方法体 # 注意：代码规范PEP8不推荐使用这种方法
def 

# 调用：
变量(实参)

形参没有可以不填，方法体只能有一条语句，且不支持赋值语句。

内置高阶函数：

map（函数，可迭代对象）：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。
filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
sorted(可迭代对象，key = 函数,reverse = bool值)：排序，返回值为排序结果。
max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。
min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。

🌟装饰器函数decorator

嵌套函数是由函数及其相关的引用环境组合而成的实体。

逻辑连续，当内部函数被调用时，不脱离当前的逻辑。造成的问题是外部变量一直存在于内存中，不会在调用结束后释放，占用内存。

内嵌函数可以引用外部函数中变量，外部函数返回值是内嵌函数。

# 定义：
def 外部函数名(参数):
    外部变量
    def 内部函数名(参数):
        使用外部变量
    return 内部函数名

# 调用：
变量 = 外部函数名(参数)
变量(参数)

python装饰器使用的思想就是嵌套函数。

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

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

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

原函数(参数)