Essas funções comuns dos módulos do sistema operacional que você deve conhecer (com variáveis integradas)

Diretório de artigos

Módulo SO

Módulo SO

Este módulo fornece várias funções que permitem manipular caminhos de arquivos e verificar informações relacionadas ao caminho, como existência, extensão de arquivo, nome de diretório e muito mais.

1.1 Funções comumente usadas

Algumas das funções comumente usadas incluem:

os.path.join(*paths): Esta função é usada para conectar de forma inteligente um ou mais componentes do caminho . Ele aceita vários argumentos e retorna uma nova string de caminho concatenada com separadores de caminho apropriados, que podem variar dependendo do sistema operacional subjacente.
os.path.abspath(path): Esta função retorna a versão do caminho absoluto do caminho especificado . Ele resolverá quaisquer links simbólicos e substituirá os caminhos relativos por caminhos absolutos.
os.path.exists(path): Esta função verifica se o caminho fornecido existe no sistema de arquivos e retorna se existir True, caso contrário retorna False.
os.path.isdir(path): Retorna se o caminho especificado apontar para um diretório existente, Truecaso contrário False.
os.path.isfile(path): Retorna se o caminho especificado apontar para um arquivo existente, Truecaso contrário False.
os.path.basename(path): Retorna o nome base do caminho , ou seja, o último componente do caminho,Geralmente usado para representar nomes de arquivos。
os.path.dirname(path): Retorna o nome do diretório do caminho, ou seja, todas as partes do caminho, exceto o último componente.
os.path.splitext(path): Divida o caminho em uma tupla (root, ext), onde rootestá a parte sem a extensão, extmas sim a extensão do arquivo (incluindo o ponto).

1.2 Exemplos de uso

Aqui está os.pathum exemplo de como usá-lo:

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 Variáveis integradas

Variáveis incorporadas não pertencem a esta seção, mas são frequentemente usadas em conjunto com o módulo os.path. Portanto, variáveis integradas foram adicionadas a esta seção.

__name__: Indica o nome do módulo atual. Quando o módulo é executado diretamente, __name__o valor é '__main__'; quando o módulo é importado, __name__o valor é o nome do módulo.
__file__: é uma das variáveis internas especiais que representa o caminho do arquivo do módulo (ou script) atual.
__doc__: Representa a string de documentação do módulo atual (ou função, classe). Uma docstring é uma string que precede uma definição de módulo, função ou classe e fornece uma breve descrição e explicação do módulo, função ou classe.
__package__: indica o nome do pacote ao qual o módulo atual pertence. Para módulos de nível superior (módulos que não são de pacote), __package__o valor é None.
__builtins__: é um dicionário que contém funções integradas, exceções e outros objetos integrados do Python.
__loader__: representa o objeto carregador de módulo que carrega o módulo atual.
__spec__: Representa o objeto de especificação (ModuleSpec) do módulo atual. O objeto de especificação contém metadados sobre o módulo, como caminhos de arquivos, informações de pacotes, etc.
__annotations__: Usado para armazenar informações de anotação de tipo de variáveis.
__cached__: Disponível apenas no modo compilado, representa o caminho do arquivo de cache do módulo atual.
__package__: indica o nome do pacote ao qual o módulo atual pertence.
__class__: Usado em classes para indicar a classe à qual pertence a instância atual.

1.4 Apêndice: Explicação detalhada das variáveis integradas

__name__:
__name__Indica o nome do módulo atual . Quando o módulo é executado diretamente, __name__o valor é '__main__'; quando o módulo é importado, __name__o valor é o nome do módulo.

Exemplo:
suponha que temos um example_module.pyarquivo de módulo nomeado com o seguinte código:
```
# example_module.py

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

print("Module name:", __name__)

if __name__ == "__main__":
    hello()
```
Quando o executamos diretamente example_module.py, a saída será:
```
Module name: __main__
Hello from example_module!
```
Quando importamos em outro script example_module.py, a saída será:
```
Module name: example_module
```
__file__:
__file__indica o caminho do arquivo do módulo atual (ou script). É uma variável integrada usada para obter o caminho absoluto do arquivo do script Python atual.

Em Python, quando um script (módulo) é executado, o interpretador Python armazena o caminho absoluto do arquivo do script em uma __file__variável. Isso nos permite obter o caminho do arquivo do script atual no código, para que possamos manipular o arquivo onde o script está localizado ou encontrar o caminho do arquivo de recurso.

Perceber:__file____file__Disponível apenas em arquivos de script, mas indefinido em interpretadores interativos ou código que executa diretamente o interpretador.。

A seguir está um __file__exemplo de uso para obter o caminho do arquivo de script atual:

Digamos que temos um example_script.pyarquivo de script nomeado com o seguinte código:
```
# example_script.py

import os

current_script_path = os.path.abspath(__file__)
print("当前脚本文件路径：", current_script_path)
```
Quando o executamos diretamente example_script.py, a saída será:
```
当前脚本文件路径： /path/to/example_script.py
```
__doc__:
__doc__Representa a string de documentação do módulo atual (ou função, classe). Uma docstring é uma string que precede uma definição de módulo, função ou classe e fornece uma breve descrição e explicação do módulo, função ou classe.

Exemplo:
acima example_module.py, podemos adicionar uma docstring para descrever a funcionalidade do módulo:
```
# 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()
```
No interpretador interativo Python, podemos __doc__visualizar a docstring do módulo acessando:
```
import example_module

print(example_module.__doc__)
```
Saída:
```
This is an example module.
```
__package__:
__package__indica o nome do pacote ao qual o módulo atual pertence.

Exemplo:
suponha que temos uma estrutura de pacote conforme mostrado abaixo:
```
my_package/
│── __init__.py
│── module_a.py
└── subpackage/
    │── __init__.py
    └── module_b.py
```
Em module_b.py, podemos __package__obter o nome do pacote usando:
```
# module_b.py

print("Package name:", __package__)
```
Quando importamos module_b.py, a saída será:
```
Package name: my_package.subpackage
```
__builtins__:
__builtins__é um dicionário que contém funções integradas, exceções e outros objetos integrados do Python.

Exemplo:
podemos __builtins__acessar algumas funções integradas como print()e usando len():
```
print("Built-in print function:", __builtins__.print)
print("Built-in len function:", __builtins__.len)
```
Saída:
```
Built-in print function: <built-in function print>
Built-in len function: <built-in function len>
```
__builtins__Geralmente não é usado diretamente porque funções e objetos integrados já estão acessíveis globalmente.
__loader__:
__loader__representa o objeto carregador de módulo que carrega o módulo atual.

Exemplo:
Podemos acessar dentro de um módulo __loader__para descobrir qual carregador carregou o módulo:
```
# example_module.py

print("Module loader:", __loader__)
```
A saída geralmente mostra o tipo de carregador e informações relacionadas.
__spec__:
__spec__Representa o objeto de especificação (ModuleSpec) do módulo atual. O objeto de especificação contém metadados sobre o módulo, como caminhos de arquivos, informações de pacotes, etc.

Exemplo:
Podemos acessar um módulo __spec__para entender as informações de especificação do módulo:
```
# example_module.py

print("Module specification:", __spec__)
```
A saída normalmente exibe as propriedades e informações relacionadas do objeto de especificação.
__annotations__:
__annotations__Usado para armazenar informações de anotação de tipo de variáveis.

Exemplo:
suponha que temos uma função usando anotações de tipo:
```
def add(a: int, b: int) -> int:
    return a + b

print("Annotations:", __annotations__)
```
Saída:
```
Annotations: {'a': <class 'int'>, 'b': <class 'int'>, 'return': <class 'int'>}
```
__annotations__Armazena as informações de tipo de parâmetros e valores de retorno.
__cached__:
__cached__Disponível apenas no modo compilado, indicando o caminho do arquivo de cache do módulo atual. Quando o interpretador Python executa um módulo, ele armazena em cache o bytecode do módulo no disco rígido para que possa ser carregado rapidamente na próxima vez.

Exemplo:
Após executar o módulo em modo compilado, você pode __cached__visualizar o caminho para o arquivo em cache acessando:
```
# example_module.py

print("Cached file path:", __cached__)
```
A saída geralmente mostra o caminho para o arquivo em cache.
__package__:
__package__indica o nome do pacote ao qual o módulo atual pertence.

__class__:
__class__Usado em classes para indicar a classe à qual pertence a instância atual.

Exemplo:
digamos que temos uma classe 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__)

Saída:

<class '__main__.Person'>

__class__Retorna Persono tipo de objeto da classe.