06.Python模块与类（层级划分+命名空间+包+.py模块内容+import导入+class类与对象内容+魔术方法+代码示例）
体系结构
层级划分
概述：Python自上而下可以划分为包、模块、类。
包（Package）：是一种组织Python模块的方式，它将相关的模块组合在一起形成一个目录结构。包可以包含多个模块和子包。3.3版本之前通常包含一个名为 __init__.py 的文件，以此来标识为一个包，3.3及以后版本采用隐式标识。
模块（Module）：是一个包含Python代码的文件，可以包含函数、类、变量和其他可执行代码。通过将相关功能封装到模块中，可以实现代码的重用和模块化设计。模块可以被其他Python程序导入和使用。
类（Class）：是一种面向对象编程的基本概念，用于创建对象的蓝图或模板。类由属性（变量）和方法（函数）组成，用于描述对象的特征和行为，一个模块中包含一个或多个类。
PS：通常一个模块对应一个物理 .py 脚本文件，一个包对应一个物理文件夹。
关系：1、一个文件通常可以包含多个类或多个函数（方法），每个类可以有多个方法。
2、多个文件可以组成一个模块，模块中可以包含多个类和函数。
3、多个模块可以组成一个包，包中可以包含多个模块和子包。
命名空间
概述：Python中的命名空间是一个用于存储变量和对象名称的系统，被划分为四个层级。它决定了在代码中如何访问这些名称，并避免了命名冲突。
Local Namespace（局部命名空间）：这是函数内部的命名空间，包含了在当前函数中定义的变量和参数。
Enclosing Namespace（嵌套命名空间）：如果函数是在另一个函数内部定义的，那么外部函数的命名空间就是嵌套命名空间。这个命名空间包含了外部函数和所有直接包围该函数的函数的变量。
Global Namespace（全局命名空间）：这是模块级别的命名空间，包含了在整个模块中定义的变量、函数和类。
Built-in Namespace（内置命名空间）：这是Python解释器提供的内置函数和类型的命名空间，例如print()和len()等。
LEGB规则：Python中的命名空间搜索顺序，它确定了在代码中如何解析变量名。LEGB代表了四个不同的命名空间，搜索顺序为：局部 —— 嵌套 —— 全局 —— 内置。
.py 模块
模块概述
概述：是组织和管理代码的基本单位，对应一个 .py 脚本文件。一个模块可以包含导入声明、方法函数、类、变量、执行语句、以及其他可执行代码等，单独的一条执行语句就可以是一个模块。
PS：1、执行 Python 脚本时，解释器会按顺序执行代码，并在调用函数时执行函数体内的代码。
2、解释器执行脚本时，它会创建一个全局命名空间，并将所有顶级代码（包括函数定义）放置在该命名空间中。
3、模块中的函数和类默认是不会自动执行的，只有在执行语句中调用时才会执行。
执行语句：指的是包含在顶层（全局）范围内的语句代码，这些代码在Python文件被执行时会立即运行。这部分通常用于执行一些初始化操作、定义全局变量、导入模块等操作。
模块内容
概述：一个模块可以只包含执行语句，也可以包含导入声明、方法函数、类、模块变量等内容。
import mudule_name
global_var = 10 # 定义全局变量，可以不初始化
def public_function(): # 定义的普通方法
pass
def _private_function(): # 定义的私有方法，不被其它引用
pass
class PublicClass: # 定义的普通类
pass
class _PrivateClass: # 定义的私有类，不被其它引用
pass
# 执行语句部分
demo_class = PublicClass() # 调用普通类
demo_func = _private_function() # 调用私有方法
"""
__all__是一个特殊的变量（列表）
用于指定可被 from module import * 语法导入的公共接口
"""
__all__ = ['public_function', 'PublicClass']import
导入与调用格式：
"""
模块的引用（导入）, 调用其中的方法、变量等需要在前面加【mudule_name.】前缀
"""
import mudule1, mudule2, mudule3
import mudule4 as md
"""
函数、变量或类的引用
"""
from module5 import demo_func5, demo_var5, DemoClass5
from module6 import function6 as fc6
"""
导入模块中的所有内容，包含函数、变量和类等, 可直接调用，不用前缀
在大型代码库中并不常见，可能导致命名冲突和可读性问题
"""
from module7 import *
df1 = mudule1.demo_func1() # 调用 mudule1 模块中的函数 demo_func1
dv2 = mudule2.demo_var2 # 调用 mudule2 模块中的变量 demo_var2
dc3 = mudule3.DemoClass3 # 调用 mudule3 模块中的类 DemoClass3
df4 = md4.demo_func4() # 调用 mudule4 模块中的函数 demo_func4
df5 = demo_func5() # 调用 mudule5 模块中的函数 demo_func5
dv5 = demo_var5 # 调用 mudule5 模块中的变量 demo_var5
dc5 = DemoClass5 # 调用 mudule5 模块中的类 DemoClass5
fc6 = fc6() # 调用 mudule6 模块中的函数 function6class 类
类与对象
类：⼀系列具有相同特征和⾏为的事物的统称，特征即是属性，行为即是方法，在开发中，类是创建对象的模板。类的命名使用大写驼峰法。以继承关系进行划分，类可以分为基类（父类）和派生类（子类），基类定义通用行为和属性，派生类继承基类并添加、修改或覆盖特定行为和属性。
对象：通过类来创建，是类的实例，具有唯一的标识，具有属性和方法，可以动态地改变。
PS：面向对象的三大特征为封装、继承、多态。其中继承表现在子类对父类方法的直接调用，多态表现在子类对父类方法的重写。
self：是一个约定俗成的参数名，用于表示类的实例对象。在类的方法定义中，第一个参数通常被命名为self，它代表调用该方法的实例对象自身。
super( )：表示对父类的调用。
class MyClass:
pi = 3.14 # 类属性
def print_pi(self): # 类方法
print(self.pi)
class MyClassZ():
def area(self):
pass
def def_print(self):
print('基类方法调用')
class MyDerivedClass(MyClassZ): # 单继承类
def __init__(self, width=5, height=5):
self.width = width
self.height = height
def area(self):
print(self.width * self.height)
class MyDerivedClassMore(MyClassZ, MyClass): # 多继承类
def more_print(self):
print('子类独有方法',end=', ')
'''
super().print_pi()
# super() 表示父类调用, 在子类父类变量、方法名不重复时可替代下边两句
'''
MyClass.__init__(self) # 确保证调⽤到的是⽗类的属性
MyClass.print_pi(self)
# 对象的创建
class1 = MyClass()
class1.print_pi() # 输出 3.14
del class1
class2 = MyClassZ()
del class2
class3 = MyDerivedClass(15, 25)
print(class3.width) # 输出 15, 属性调用
class3.area() # 输出 375, 函数调用
del class3
class4 = MyDerivedClassMore()
class4.def_print() # 调用父类方法，输出：基类方法调用
class4.print_pi() # 调用父类方法，输出：3.14
class4.more_print() # 调用子类（自身）方法，输出：子类独有方法, 3.14
del class4类方法：⽤装饰器 @classmethod 来标识，类⽅法第一个参数必须是类对象，用 cls 表示，可以通过类直接调用。
静态方法：通过装饰器 @staticmethod 来进⾏修饰，不需要传递类对象也不需要传递实例对象。可通过实例对象和类进行访问。适用于不需要的参数传递的场景，有利于减少不必要的内存占用和性能消耗。
class DemoMethod():
var = 10
@classmethod
def class_method(cls, input): # 类方法
print('这是一个类方法', end=', ')
print(cls.var*input)
@staticmethod # 静态方法
def static_method():
print('这是一个静态方法')
# 函数的调用
DemoMethod.class_method(10) # 输出：这是一个类方法, 100
DemoMethod.static_method() # 输出：这是一个静态方法@装饰器
概述：Python中允许在不修改原有函数或类定义的情况下，对其进行额外的功能扩展和修饰，本质上是一个可调用对象（函数或类），它接受一个函数或类作为参数，并返回一个新的函数或类。
PS：装饰器可以使用 @ 符号来应用到目标函数或类的定义之前，也可以通过手动调用的方式来使用。
@decorator
def func():
pass
rs = func()
# 等价于
def func():
pass
rs = decorator(func)
# 其中decorator是以func为传入参数的函数
def timer_decorator(func):
def wrapper(*args, **kwargs):
start_time = time.time()
result = func(*args, **kwargs)
end_time = time.time()
execution_time = end_time - start_time
print(f"函数 {func.__name__} 的执行时间为：{execution_time} 秒")
return result
return wrapper
@timer_decorator
def my_function():
time.sleep(2)
print("Hello, World!")
my_function()PS：可以理解为，将被修饰的类或方法，作为参数传递给 @ 后面的函数进行加工，且依旧使用原方法或类的名进行调用。
魔术方法
概述：以双下划线开头和结尾的特殊方法，用于实现对象的特定行为和操作。这些方法在类定义中具有特殊的含义，并由Python解释器自动调用。
常见魔术方法：
__init__(self, ...)：初始化方法，即类的构造函数，用于创建和初始化一个新的对象，Python中构造器只能有一个。每个类都有一个默认的构造方法，当自定义构造器时，默认构造会失效。
__str__(self)：对象的字符串表示方法，在使用 str() 函数或 print() 函数时被调用，返回对象的可读性良好的字符串表示形式，类似于Java 中的“toString”方法。
__del__(self)：析构方法（destructor method）或垃圾回收方法（garbage collection method）。它定义了在对象被销毁时执行的操作，此操作不是由开发者主动调用，而是在对象不再使用时由解释器自动执行。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return f"Person(name={self.name}, age={self.age})"
def __del__(self):
print(f"Deleting instance of MyClass with name: {self.name}")
# 创建一个Person对象
person = Person('Jone', 19)
print(str(person)) # Person(name=Jone, age=19)
print(person) # Person(name=Jone, age=19)
del person # 输出 Deleting instance of MyClass with name: Jone其它魔术方法：
__contains__(self, item)：检查对象是否包含指定元素，使用关键字in时被调用。
__len__(self)：返回对象的长度，使用内置的len()函数时被调用。
__iter__(self)：返回一个可迭代对象，用于支持对象的迭代操作。
__next__(self)：迭代器的下一个值，在使用next()函数进行迭代时被调用。
__repr__(self)：对象的官方字符串表示形式，通常用于调试目的。当没有定义__str__方法时，会使用__repr__方法代替。
__getitem__(self, key)：获取指定索引或键的值，允许通过索引或键来访问对象的元素。
__setitem__(self, key, value)：设置指定索引或键的值，允许通过索引或键来修改对象的元素。
__delitem__(self, key)：删除指定索引或键的元素，允许通过索引或键来删除对象的元素。