不能不知道的OS模块的那些常用函数（附内置变量）

文章目录

OS 模块

OS 模块

该模块提供了各种函数，允许您操作文件路径和检查与路径相关的信息，比如是否存在、文件扩展名、目录名等等。

1.1 常用函数

其中一些常用的函数包括：

os.path.join(*paths)：该函数用于智能地连接一个或多个路径组件。它接受多个参数，并返回通过适当的路径分隔符连接的新路径字符串，根据底层操作系统的不同使用不同的路径分隔符。
os.path.abspath(path)：该函数返回指定路径的绝对路径版本。它会解析任何符号链接，并用绝对路径替换相对路径。
os.path.exists(path)：该函数检查给定的路径是否在文件系统中存在，如果存在则返回True，否则返回False。
os.path.isdir(path)：如果指定的路径指向一个现有目录，则返回True，否则返回False。
os.path.isfile(path)：如果指定的路径指向一个现有文件，则返回True，否则返回False。
os.path.basename(path)：返回路径的基本名称，即路径的最后一个组件，一般常用来表示文件名。
os.path.dirname(path)：返回路径的目录名，即路径除了最后一个组件外的所有部分。
os.path.splitext(path)：将路径拆分为元组(root, ext)，其中root是没有扩展名的部分，而ext是文件扩展名（包括点）。

1.2 使用示例

以下是如何使用os.path的示例：

import os

path = "/home/user/documents/sample.txt"

print("拼接后的路径：", os.path.join("/home", "user", "documents", "file.txt"))
print("绝对路径：", os.path.abspath(path))
print("路径是否存在？", os.path.exists(path))
print("是一个目录？", os.path.isdir(path))
print("是一个文件？", os.path.isfile(path))
print("文件基本名称：", os.path.basename(path))
print("目录名：", os.path.dirname(path))
print("拆分扩展名：", os.path.splitext(path))

1.3 内置变量

内置变量本不属于这一部分，但是，经常与os.path模块结合使用。因此，将内置变量补充到了这一部分。

__name__: 表示当前模块的名称。当模块被直接执行时，__name__的值为'__main__'；当模块被导入时，__name__的值为模块的名称。
__file__：是一个特殊的内置变量之一，它表示当前模块（或脚本）的文件路径。
__doc__: 表示当前模块（或函数、类）的文档字符串。文档字符串是位于模块、函数或类定义之前的字符串，用于提供有关模块、函数或类的简短描述和说明。
__package__: 表示当前模块所属的包名称。对于顶层模块（非包内模块），__package__的值为None。
__builtins__: 是一个字典，包含了Python的内建函数、异常和其他内建对象。
__loader__: 表示加载当前模块的模块加载器对象。
__spec__: 表示当前模块的规范对象（ModuleSpec）。规范对象包含有关模块的元数据，如文件路径、包信息等。
__annotations__: 用于存储变量的类型注解信息。
__cached__: 仅在编译模式下可用，表示当前模块的缓存文件路径。
__package__: 表示当前模块所属的包名称。
__class__: 用于类中，表示当前实例所属的类。

1.4 附：内置变量详解

__name__：
__name__表示当前模块的名称。当模块被直接执行时，__name__的值为'__main__'；当模块被导入时，__name__的值为模块的名称。

示例：
假设我们有一个名为example_module.py的模块文件，其中包含以下代码：
```
# example_module.py

def hello():
    print("Hello from example_module!")

print("Module name:", __name__)

if __name__ == "__main__":
    hello()
```
当我们直接运行example_module.py时，输出将是：
```
Module name: __main__
Hello from example_module!
```
当我们在另一个脚本中导入example_module.py时，输出将是：
```
Module name: example_module
```
__file__：
__file__ 表示当前模块（或脚本）的文件路径。它是一个内置变量，用于获取当前Python脚本的绝对文件路径。

在Python中，当一个脚本（模块）被执行时，Python解释器会将脚本的绝对文件路径存储在__file__变量中。这允许我们在代码中获取当前脚本的文件路径，从而可以操作脚本所在的文件或者查找资源文件的路径。

注意：__file__只在脚本文件中可用，而在交互式解释器中或直接执行解释器的代码中，__file__是未定义的。

以下是一个使用__file__获取当前脚本文件路径的示例：

假设我们有一个名为example_script.py的脚本文件，其中包含以下代码：
```
# example_script.py

import os

current_script_path = os.path.abspath(__file__)
print("当前脚本文件路径：", current_script_path)
```
当我们直接运行example_script.py时，输出将是：
```
当前脚本文件路径： /path/to/example_script.py
```
__doc__：
__doc__表示当前模块（或函数、类）的文档字符串。文档字符串是位于模块、函数或类定义之前的字符串，用于提供有关模块、函数或类的简短描述和说明。

示例：
在上面的example_module.py中，我们可以添加文档字符串来描述模块的功能：
```
# example_module.py

"""This is an example module."""

def hello():
    """Prints a greeting message."""
    print("Hello from example_module!")

print("Module name:", __name__)

if __name__ == "__main__":
    hello()
```
在Python交互式解释器中，我们可以通过访问__doc__来查看模块的文档字符串：
```
import example_module

print(example_module.__doc__)
```
输出：
```
This is an example module.
```
__package__：
__package__表示当前模块所属的包名称。

示例：
假设我们有一个包结构如下所示：
```
my_package/
│── __init__.py
│── module_a.py
└── subpackage/
    │── __init__.py
    └── module_b.py
```
在module_b.py中，我们可以使用__package__来获取包名称：
```
# module_b.py

print("Package name:", __package__)
```
当我们导入module_b.py时，输出将是：
```
Package name: my_package.subpackage
```
__builtins__：
__builtins__是一个字典，包含了Python的内建函数、异常和其他内建对象。

示例：
我们可以使用__builtins__来访问一些内建函数，如print()和len()：
```
print("Built-in print function:", __builtins__.print)
print("Built-in len function:", __builtins__.len)
```
输出：
```
Built-in print function: <built-in function print>
Built-in len function: <built-in function len>
```
__builtins__通常不直接使用，因为内建函数和对象已经是全局可访问的。
__loader__：
__loader__表示加载当前模块的模块加载器对象。

示例：
我们可以在一个模块中访问__loader__来了解加载该模块的加载器：
```
# example_module.py

print("Module loader:", __loader__)
```
输出通常会显示加载器的类型和相关信息。
__spec__：
__spec__表示当前模块的规范对象（ModuleSpec）。规范对象包含有关模块的元数据，如文件路径、包信息等。

示例：
我们可以在一个模块中访问__spec__来了解该模块的规范信息：
```
# example_module.py

print("Module specification:", __spec__)
```
输出通常会显示规范对象的属性和相关信息。
__annotations__：
__annotations__用于存储变量的类型注解信息。

示例：
假设我们有一个函数，使用了类型注解：
```
def add(a: int, b: int) -> int:
    return a + b

print("Annotations:", __annotations__)
```
输出：
```
Annotations: {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}
```
__annotations__存储了参数和返回值的类型信息。
__cached__：
__cached__仅在编译模式下可用，表示当前模块的缓存文件路径。当Python解释器运行一个模块时，它会将模块的字节码缓存到硬盘上，以便下次快速加载。

示例：
在编译模式下运行模块后，可以访问__cached__来查看缓存文件的路径：
```
# example_module.py

print("Cached file path:", __cached__)
```
输出通常会显示缓存文件的路径。
__package__：
__package__表示当前模块所属的包名称。

__class__：
__class__用于类中，表示当前实例所属的类。

示例：
假设我们有一个类Person：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, I'm {
        
        self.name}.")

person = Person("Alice", 30)
print(person.__class__)

输出：

<class '__main__.Person'>

__class__返回Person类的类型对象。