Python 笔记 — 模块和包

一、模块

1、定义

是 Python 中组织代码的一种方式，可以将相关的函数、类和变量，组织到一个独立的文件中，以便于复用和管理。

2、创建

创建一个以 .py 为扩展名的文件，然后在其中编写 Python 代码。

3、分类

3.1、内置模块（也叫做标准库）

此类模块就是 Python 解释器提供的，比如 time、os、 random 模块。

标准库的模块非常多（200多个，每个模块又有很多功能）。

# 查看所有的内置函数 
# 大写字母开头的是 Python 的内置常量名
# 小写字母开头的是 Python 的内置函数名
import builtins

print(dir(builtins))

# 运行结果：
# ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

3.2、第三方模块（第三方库）

一些 Python 大神写的非常好用的模块，必须通过 pip install 指令安装的模块， 比如 BeautfulSoup，Django，requests 等等。大概有6000多个。

3.3、自定义模块

我们自己在项目中定义的一些模块。

导入自定义模块的时候会出现红色波浪线，解决方法：

右击文件所在的目录，然后 “Mark Directory as” 为 “Sources Root”，之后当前程序所在目录颜色会变化。

4、使用

4.1、import 使用

import 语句是可以在程序中的任意位置使用的，且针对同一个模块 import 很多次。

为了防止重复导入，Python 的优化手段是：

第一次导入后就将模块名加载到内存了，后续的 import 语句仅是对已经加载到内存中的模块对象增加了一次引用，不会重新执行模块内的语句。

Python 通过三个步骤来完成这个行为：

1、在 Python 模块加载路径中查找相应的模块文件

2、将模块文件编译成中间代码

3、执行模块文件中的代码

模块执行：

1、创建一个以模块名命名的名称空间。

2、执行这个名称空间（即导入的模块）里面的代码。

3、通过 此模块名. 的方式引用该模块里面的内容（变量，函数名，类名等）。

# my_module.py
def greet(name):
    return f"Hello, {name}!"

class Calculator:
    def add(self, a, b):
        return a + b

# main.py
import my_module

result = my_module.greet("Alice")
print(result)

calc = my_module.Calculator()
sum = calc.add(10, 20)
print(sum)

# 运行结果：
# Hello, Alice!
# 30

4.2、模块起别名

模块在导入的时候开辟了新空间内存，默认是使用模块的名称来引用这个内存地址的，有时候模块的名称很长，再加上执行调用里面的功能的时候，就显的很不方便。

为了更好的使用模块，可以给模块起别名，也就是在导入模块的时候不让它使用默认的名字来引用内存地址，而是由我们自己定义的变量来引用这个模块的内存地址。

优势：

1、好处可以将很长的模块名改成很短，方便使用。

2、有利于代码的扩展和优化。

# my_module.py
def greet(name):
    return f"Hello, {name}!"

class Calculator:
    def add(self, a, b):
        return a + b

# main.py
import my_module as mm  # 给 my_module 模块取别名为 mm

result = mm.greet("Bob")
print(result)

calc = mm.Calculator()
sum = calc.add(30, 40)
print(sum)

# 运行结果：
# Hello, Bob!
# 70

4.3、导入多模块

# 这样写可以但是不推荐
import os,sys,json  

# 多行导入：易于阅读，易于编辑，易于搜索，易于维护
# 推荐写法：不用某个模块时直接注释了就行
import os
import sys
import json

顺序说明：

导入模块其实就是在执行这个模块，我们不确定扩展模块或自定义模块里有没有某个功能调用了内置模块。

所以，我们在导入模块时的顺序最好是：

1、应先导入解释器内置的模块

2、然后在导入扩展模块，

3、最后导入自定义模块

4.4、from … import … 使用

Python 的 from 语句可以从模块中导入一个指定的部分到当前命名空间中。

有时候只需要用到模块中的某个函数，可以使用 from … import 这样的格式来进行模块的某个功能的导入。

语法：

from 模块名 import 函数名1,函数名2

这时模块是已经全部加载了，但只是为这个功能进行了引用，其它的功能并没有引用，所以在使用模块的时候，就只能使用这个模块的这个功能，其它的功能不能使用，如果想再使用这个模块的另一个功能时，可以在进行一次模块的要使用的功能的导入，这时模块不会再进行加载了，而是只对该功能进行引用，这样我们就可以使用这个功能了。

# my_module.py
def greet(name):
    return f"Hello, {name}!"

class Calculator:
    def add(self, a, b):
        return a + b

PI = 3.14159

# main.py
from my_module import greet, Calculator, PI

result = greet("Alice")
print(result)

calc = Calculator()
sum = calc.add(10, 20)
print(sum)

print(PI)

# 运行结果：
# Hello, Alice!
# 30
# 3.14159

把一个模块的所有内容全都导入到当前的命名空间也是可行的，用一个简单的方法来导入一个模块中的所有项目。

from 模块名 import * 

然而这种声明不该被过多地使用。 这种方法会污染命名空间，而且不能直观的显示导入哪些对象。

import 和 from … import … 对比

• import module_name 导入整个模块，需要使用模块名前缀。
• from module_name import name 选择性导入模块中的特定内容，无需模块名前缀。
• from module_name import * 导入模块中的所有内容，不建议在生产代码中使用。

5、模块命名空间

每个模块都有自己的命名空间，这意味着在模块内部定义的变量、函数和类不会与其它模块发生冲突。

6、py 文件的两种功能

编写好的一个 Python 文件可以有两种用途：

1、脚本，一个文件就是整个程序，用来被执行。

2、模块，文件中存放着一堆功能，用来被导入使用。

Python 为我们内置了全局变量 __name__：

当文件被当做脚本执行时：__name__ 等于 __main__。

当文件被当做模块导入时：__name__ 等于模块名。

作用：

用来控制 .py 文件在不同的应用场景下执行不同的逻辑。

# my_module.py
print(123)

if __name__ == '__main__':
    print(456)

# main.py
import my_module

# 运行结果：
# 123

二、包

1、定义

是 Python 中一种用于组织模块的方式，可以将多个相关的模块组织到一个文件夹中，以更好地管理和结构化项目。

2、结构

包是一个包含特殊文件 __init__.py 的文件夹。

包中可以包含模块（.py 文件）和子包（其它包）。

包可以形成嵌套结构，可以创建多层次的模块组织。

3、创建

要创建一个包，只需创建一个文件夹，并在其中包含一个名为 __init__.py 的文件。这个文件可以是空文件，但它必须存在。

例如，如果创建了一个名为 my_package 的文件夹，并在其中添加了 __init__.py 文件，那么它就成为了一个包。

4、导入

可以使用 import 语句导入一个包。导入包时，Python 会自动执行包中的 __init__.py 文件。

例如，要导入名为 my_module 的包，可以使用 import my_package.my_module。

5、层级

包可以有多层次的层级结构。

例如：

可以创建一个名为 my_package.subpackage 的子包。

使用点号表示包的层级关系，例如 import my_package.subpackage.my_module。

6、__init__.py 文件

__init__.py 文件在包中具有特殊的作用。它可以包含初始化包的代码，定义包级别的变量，以及设置包的导入行为。

在 Python 3.3+ 版本中，__init__.py 文件可以为空，但在较早的版本中，它必须包含至少一行有效代码，例如 pass。

7、使用包内模块

在包内的模块可以相互导入，可以使用相对导入来引用同一包内的模块。

使用相对导入时，可以使用 from .module import something 来导入同一包内的模块。

8、包的使用场景

包常用于将相关的功能组织到一个独立的单元中，使项目更具可维护性和可扩展性。

包可以用于分解大型项目，使其更易于管理和协作开发。

包也可以用于将模块分为逻辑上相关的组，使代码更结构化。

9、使用案例

1、创建一个名为 math_utils 的文件夹

2、在其中添加一个名为 __init__.py 的空文件，以使文件夹成为一个包

3、在 math_utils 包下创建两个模块 basic_operations.py 和 advanced_operations.py

4、写入代码

# math_utils/basic_operations.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

# math_utils/advanced_operations.py
import math

def square_root(a):
    if a < 0:
        raise ValueError("Cannot compute square root of a negative number")
    return math.sqrt(a)

def power(a, b):
    return math.pow(a, b)

def factorial(n):
    if n < 0:
        raise ValueError("Cannot compute factorial of a negative number")
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

5、在其它 Python 文件中导入这些模块并使用它们

# main.py
from math_utils.basic_operations import add, subtract
from math_utils.advanced_operations import square_root, factorial

result1 = add(5, 3)
result2 = subtract(10, 4)
result3 = square_root(25)
result4 = factorial(5)

print(f"加法: {result1}")  # 输出：8
print(f"减法:{result2}")  # 输出：6
print(f"平方根: {result3}")  # 输出：5.0
print(f"阶乘: {result4}")  # 输出：120

三、包、库、模块的区别

1、模块（Module）

• 模块是 Python 中最基本的组织单元。

• 一个模块就是一个包含 Python 代码的文件（通常以 .py 为扩展名）。

• 模块可以包含函数、变量和类等，它们可以被其它模块导入并重用。

• 通过 import 语句可以导入模块，从而使用其中的功能。

2、包（Package）

• 包是一种用于组织相关模块的方式，它是一个包含了多个模块的文件夹。

• 包通常包含一个特殊的 __init__.py 文件，用于标识该文件夹为一个包。

• 包内的模块可以通过点号表示法（package.module）进行导入。

• 包可以有多层次的嵌套，形成一个层次结构，以更好地组织代码。

3、库（Library）

• 库是一组相关的模块和包的集合，旨在解决特定的问题或提供特定的功能。
• 一个库可以包含多个模块和包，它们共同构成了库的功能组成部分。
• Python 有许多标准库，如 math、os、random 等，它们提供了各种各样的功能，可以通过导入来使用。
• 除了标准库，还有许多第三方库可供使用，例如 NumPy、Pandas、Requests 等，它们可以通过安装和导入来扩展 Python 的功能。

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~