Comment utiliser le module OS de Python et des exemples

Le module os de Python est l'une des bibliothèques standard utilisées pour interagir avec le système d'exploitation. Il fournit de nombreuses fonctions et variables utiles pour travailler avec des fichiers et des répertoires. Voici l'utilisation de certaines fonctions courantes du module OS :

1. Obtenez le répertoire de travail actuel :

import os
cwd = os.getcwd()
print(cwd)

2 Changez le répertoire de travail actuel :

import os
os.chdir('/path/to/new/directory')

3. Répertoriez tous les fichiers et sous-répertoires du répertoire :

import os
files = os.listdir('/path/to/directory')
print(files)

. 4. Vérifiez si le chemin donné est un répertoire :

import os
path = '/path/to/directory'
if os.path.isdir(path):
    print("It's a directory")
else:
    print("It's not a directory")

5. Vérifiez si le chemin donné est un fichier :

import os
path = '/path/to/file'
if os.path.isfile(path):
    print("It's a file")
else:
    print("It's not a file")

6 Obtenez la taille du fichier en octets :

import os
path = '/path/to/file'
size = os.path.getsize(path)
print(size)

7. un fichier Existe-t-il :

import os
path = '/path/to/file_or_directory'
if os.path.exists(path):
    print("It exists")
else:
    print("It doesn't exist")

8. Créer un nouveau répertoire :

import os
path = '/path/to/new/directory'
os.mkdir(path)

9. Créer récursivement un nouveau répertoire (si le répertoire n'existe pas) :

import os
path = '/path/to/new/directory'
os.makedirs(path, exist_ok=True)

10. Supprimer un fichier ou un répertoire vide :

import os
path = '/path/to/file_or_directory'
os.remove(path)

. 11. Supprimer récursivement un répertoire et son contenu :

import os
path = '/path/to/directory'
os.system('rm -rf ' + path)

Quelques autres utilisations pratiques :

La méthode 12.os.path.splitext() consiste à diviser un chemin en deux parties : le nom du fichier et l'extension. Il utilise le dernier "." du nom de fichier comme délimiteur pour séparer le nom et l'extension du fichier. Par exemple, si le chemin du fichier est "/path/to/file.txt", la méthode os.path.splitext() renvoie un tuple ("/path/to/file", ".txt").

Il est à noter que s'il n'y a pas de "." dans le nom du fichier, l'extension renvoyée est une chaîne vide. Si le nom du fichier commence par ".", il est considéré comme un fichier sans extension et la méthode os.path.splitext() renverra (chemin du fichier, '').

Ce qui suit est un exemple :

import os
path = '/path/to/file.txt'
file_name, ext = os.path.splitext(path)
print('文件名为：', file_name)
print('扩展名为：', ext)

Le résultat de sortie est :

Le nom du fichier est : /path/to/file
L'extension est : .txt

13. Définir les autorisations du fichier :

import os
os.chmod('/path/to/file', 0o777) # 设置读、写、执行权限

os. La méthode .chmod() peut être utilisée pour modifier les autorisations d’accès à un fichier ou un répertoire. Il accepte deux paramètres : le chemin du fichier et le nouveau mode d'autorisation. Le mode d'autorisation peut être représenté par un nombre octal, chaque bit représentant une autorisation différente.

Voici quelques exemples de modèles d'autorisation :

• 0o400 : autorisations en lecture seule

• 0o200 : autorisations en écriture

• 0o100 : autorisations d'exécution

• 0o700 : Toutes autorisations

14. le nombre de CPU :

import os
cpu_count = os.cpu_count()
print('CPU数量为：', cpu_count)

Il est à noter que le nombre de CPU renvoyé par os.cpu_count() est le nombre de cœurs de CPU physiques et n'inclut pas les cœurs virtuels de la technologie hyper-threading. Dans les systèmes dotés de la technologie Hyper-Threading, chaque cœur de processeur physique est divisé en deux cœurs virtuels, de sorte que la méthode os.cpu_count() peut renvoyer un nombre supérieur au nombre réel de cœurs de processeur.

De plus, la méthode os.cpu_count() peut avoir différentes implémentations sur différents systèmes d'exploitation. Sur certains systèmes d'exploitation, il peut renvoyer uniquement le nombre de cœurs de processeur logiques, et non le nombre de cœurs de processeur physiques. Par conséquent, lorsque vous utilisez cette méthode, il est préférable de consulter la documentation pertinente pour plus d’informations.

15. Démarrez un nouveau processus : la méthode

import os
os.system('notepad.exe')

os.system() peut exécuter une commande sur le système d'exploitation et renvoyer le code d'état de sortie de la commande. Son paramètre est une commande de type chaîne, qui peut être n'importe quelle commande système valide.

Ce qui suit est un exemple qui montre comment utiliser la méthode os.system() pour exécuter une commande simple :

import os
os.system('echo "Hello, World!"')

Le code ci-dessus affichera la chaîne Hello, World ! représenté par 0 réussite).

Il convient de noter que la méthode os.system() bloquera le processus en cours jusqu'à ce que l'exécution de la commande soit terminée. Si vous souhaitez exécuter la commande sans bloquer le processus en cours, vous pouvez envisager d'utiliser d'autres méthodes dans le module subprocess, telles que subprocess.Popen().

Ce qui suit est un autre exemple qui montre comment utiliser la méthode os.system() pour exécuter une commande complexe, comme utiliser wget pour télécharger un fichier sur un système Linux :

import os
url = 'https://example.com/file.zip'
output_dir = '/path/to/output'
command = f'wget {url} -P {output_dir}'
os.system(command)

Le code ci-dessus téléchargera le fichier spécifié par le paramètre url dans le répertoire spécifié par le paramètre output_dir et renvoie le code d'état de sortie de la commande.

16.os.environ : Il s'agit d'un dictionnaire contenant les variables d'environnement actuelles. Vous pouvez utiliser os.environ[key] pour obtenir la valeur d'une variable d'environnement spécifique.

17.os.exec*() : Ces méthodes permettent aux programmes Python d'exécuter d'autres programmes dans le processus en cours, remplaçant le processus en cours. Par exemple, la méthode os.execv() peut exécuter un programme en utilisant une liste d'arguments spécifiée, remplaçant ainsi le processus en cours.

18.os.fork() : Cette méthode peut créer un processus enfant sur le système d'exploitation Unix ou Linux pour l'exécution parallèle de programmes. Le processus enfant copiera tout le contenu de la mémoire du processus parent, y compris le code, les données, la pile, etc., afin que le programme puisse continuer à s'exécuter en fonction du processus parent.

19.os.kill() : Cette méthode est utilisée pour envoyer un signal au processus spécifié. Vous pouvez utiliser la méthode os.kill(pid, signal) pour envoyer un signal spécifié à un processus spécifié. Les signaux couramment utilisés incluent SIGINT (signal d'interruption), SIGTERM (signal de terminaison) et SIGKILL (signal de terminaison forcée), etc.

20.os.pipe() : Cette méthode peut créer un canal pour la communication entre les processus. La méthode os.pipe() renverra deux descripteurs de fichiers, un pour lire les données de canal et l'autre pour écrire des données de canal.

21.os.wait() : Cette méthode peut attendre la fin du processus enfant puis renvoyer le code d'état du processus enfant. Vous pouvez utiliser la méthode os.waitpid(pid, options) pour attendre la fin du processus spécifié et renvoyer le code d'état du processus.

22.os模块可以用来操作文件路径。例如，os.path.join(path, *paths)可以将多个路径拼接成一个完整路径，os.path.abspath(path)可以将相对路径转换为绝对路径，os.path.split(path)可以将路径分割成目录和文件名。

23.遍历目录树

import os
def list_files(path):
    for root, dirs, files inos.walk(path):
        for file in files:
            print(os.path.join(root, file))
list_files('.')

这段代码可以遍历当前工作目录及其子目录下的所有文件，并打印出它们的完整路径。

os.walk()是os模块中一个非常有用的函数，用于遍历指定目录及其子目录下的所有文件和目录。它返回一个三元组(root, dirs, files)，其中root是当前目录的路径，dirs是当前目录下的子目录列表，files是当前目录下的文件列表。下面是一个os.walk()的详细解释和示例：

for root, dirs, files in os.walk(top, topdown=True, onerror=None, followlinks=False):
    # Do something with root, dirs, and files

top是指定的目录路径，可以是相对路径或绝对路径。

• topdown是一个布尔值，表示遍历时是否先遍历当前目录，再遍历子目录。如果为True（默认值），则先遍历当前目录，再遍历子目录；如果为False，则先遍历子目录，再遍历当前目录。

• onerror是一个可选的错误处理函数，如果在遍历过程中出现错误，则会调用这个函数。

• followlinks是一个布尔值，表示是否跟随符号链接。如果为True，则会跟随符号链接遍历目录；如果为False（默认值），则会忽略符号链接。

在遍历过程中，os.walk()会依次遍历指定目录及其子目录下的所有文件和目录，并返回当前目录的路径、子目录列表和文件列表。可以通过遍历返回的三元组来处理目录和文件。例如，可以使用下面的代码列出指定目录下的所有文件和子目录：

import os
 
def list_files_and_dirs(path):
    for root, dirs, files in os.walk(path):
        print(f'Directory: {root}')
        for file in files:
            print(f'  File: {os.path.join(root, file)}')
        for dir in dirs:
            print(f'  Subdirectory: {os.path.join(root, dir)}')
 
list_files_and_dirs('.')

这段代码会遍历当前工作目录及其子目录下的所有文件和目录，并输出相应的信息。

需要注意的是，os.walk()只会遍历当前目录及其子目录下的文件和目录，不会遍历符号链接所指向的文件或目录。如果需要遍历符号链接所指向的文件或目录，需要设置followlinks=True。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!