Python

Les principales caractéristiques du langage Orienté objet:

Orienté objet:

Python est un langage de programmation orientée objet. Mais comparé à d’autres langages similaires
(comme Java et C#), Python n’impose pas aux développeurs de créer spécifiquement des applications en
utilisant les principes de la programmation objet. Il est même possible de créer des programmes en
Python en suivant une approche uniquement procédurale voire même fonctionnelle

Courbe d’apprentissage linéaire:

Cette plasticité dans l’approche du développement permet à Python de posséder une courbe
d’apprentissage très linéaire. Il est possible d’apprendre rapidement les bases du langage et de réaliser
des applications sans connaître nécessairement toutes les subtilités de la programmation objet. Ainsi,
Python est très souvent proposé comme langage d’apprentissage de la programmation ou bien il est
utilisé dans des domaines d’ingénierie autres que l’informatique

Compilé et interprété:

Python est un langage compilé et interprété. Cela signifie que le code source doit être compilé,
c’est-à-dire transformé dans un langage binaire. Cependant ce langage n’est pas compréhensible
directement par le processeur de la machine. Les fichiers compilés doivent donc être interprétés,
c’est-à-dire lus et transformés en instructions exécutables par le processeur de la machine. Cette
transformation est réalisée logiciellement par un programme que l’on nomme l’interpréteur.

Typage dynamique:

Python est un langage à typage dynamique. Cela signifie que le type d’une variable (c’est-à-dire le
format des données qui peuvent être représentées par cette variable) est choisi au moment où le
programme assigne une valeur à la variable. Si le programme affecte plus tard une valeurs d’un type
différent à la même variable, celle-ci donne l’impression de changer de type.

Les domaines d’application

Python est partout ! Comme il n’est pas nécessaire d’être un expert en programmation pour pouvoir
écrire des applications complexes, Python est utilisé de son domaine de départ (l’interaction avec un
système d’exploitation avec la réalisation d’un shell). Ainsi, on trouve des programmes en Python pour
le calcul scientifique, les mathématiques, l’électronique, la robotique, l’intelligence artificielle…
Types et variables

Nombres et calcul arithmétique:

Les variables:

Python est un langage de programmation à typage dynamique. Cela signifie que le type de la variable est
déterminé par le type de la valeur qu’il contient. Dans l’exemple ci-dessus, le type de la variable x est int
(un nombre entier) et le type de la variable y est float (un nombre réel).

Note:

Python ne supporte pas directement la notion de constante. Pour signaler que le contenu d’une variable
ne devrait pas être modifié par le programme, les programmeurs ont coutume d’écrire son nom en
lettres majuscules. Il n’y a cependant rien qui interdit effectivement de modifier sa valeur :
La chaîne de caractères:

En plus des nombres, un autre type de données couramment utilisé est la chaîne de caractères
(character string ou plus simplement string), c’est-à-dire une portion de texte. En Python, une chaîne de
caractères est encadrée par le caractère apostrophe ' ou le caractère guillemet " que l’on appelle les
délimiteurs :

Le type booléen:
Un type booléen accepte deux valeurs : True et False. Les valeurs booléennes peuvent être utilisées avec
les opérateurs logiques : not, and et or.

Les fonctions:
Déclarer une fonction:

L’intérêt principal des fonctions est de pouvoir organiser un programme en le décomposant en

traitements de granularité plus faible. Ces traitements deviendront des fonctions dont le nom et la
documentation amélioreront la lisibilité et la maintenabilité.

def dire_bonjour_a(nom):

print("Bonjour", nom)
#appel de la fonction

dire_bonjour_a("David")

Les valeurs de retour:

Pour qu’une fonction retourne une valeur, il faut utiliser le mot-clé return suivi de la valeur à retourner.

expl1 : def creer_nom(prenom, nom):

nom_complet = prenom + " " + nom

return nom_complet

expl2: def creer_nom(prenom, nom):

return prenom + " " + nom

exemple:

def divmod(numerateur, denominateur):

resultat = numerateur // denominateur

reste = numerateur % denominateur

return resultat, reste

# appel

resultat, reste = divmod(10, 3)

print("Le resultat de la division de 10 par 3 est", resultat, "et le reste est", reste)

Variable globale et fonction:

Notion de méthode:

Bytes Objects:

exemple : classmethod fromhex(string)

[Link]('2Ef0 F1f2 ')

b'.\xf0\xf1\xf2'

exemple: hex()

b'\xf0\xf1\xf2'.hex()

'f0f1f2'

des methodes standards

strip()
>>> b' spacious '.strip()

b'spacious'

>>> b'[Link]'.strip(b'cmowz.')

b'example'
splitlines()
>>> "".splitlines()

[]

>>> "One line\n".splitlines()

['One line']

Comparaison entre split() et splitlines()

>>> ''.split('\n')

['']if [ -e file_path] if [ -e file_path] if [ -e file_path]

if [ -e file_path]

>>> 'Two lines\n'.split('\n')

['Two lines', '']

La liste :
Créer une liste:

liste_vide = []

ma_liste = [10, 20, 30, 40]

liste_depareillee = [None, 1, "shrubbery", True]

Accéder aux éléments:

ma_liste = [10, 20, 30, 40]

premier_element = ma_liste[0]

second_element = ma_liste[1]

modifier la valeur d’un élément de la liste:

ma_liste = [10, 20, 30, 40]

ma_liste[0] = 0

print(ma_liste)

# affiche [0, 20, 30, 40]

Les opérations sur les listes:

Connaître la taille d’une liste:

ma_liste = [10, 20, 30, 40]

taille_liste = len(ma_liste)

print(taille_liste)

# affiche 4

Supprimer un élément d’une liste:

ma_liste = [10, 20, 30, 40]

del ma_liste[1]

print(ma_liste)

# affiche [10, 30, 40]

Ajouter deux listes ensemble:

ma_liste = [0, 1, 2]

ma_liste += [10, 20, 30]

print(ma_liste)

# affiche [0, 1, 2, 10, 20, 30]

Connaître le plus grand élément d’une liste:

ma_liste = [10, 20, 30, 40]

element = max(ma_liste)

print(element)

# affiche 40

Connaître le plus petit élément d’une liste:

ma_liste = ["a", "b", "c"]

element = min(ma_liste)

print(element)

# affiche a

Découper une liste:

expl1:
ma_liste = [10, 20, 30, 40]

autre_liste = ma_liste[1:3]

print(autre_liste)

# affiche [20, 30]

expl2:

ma_liste = [10, 20, 30, 40]

liste_sauf_dernier_element = ma_liste[:-1]

print(liste_sauf_dernier_element)

# affiche [10, 20, 30]

Quelques méthodes pour les listes:

append(e)

Pour ajouter un élément à la liste

ma_liste = [1]

ma_liste.append(2)

ma_liste.append(3)

print(ma_liste)

# affiche [1, 2, 3]

extend(l)

Pour ajouter une séquence à une liste.

ma_liste = [1]

ma_liste.extend([2, 3, 4])

print(ma_liste)

# affiche [1, 2, 3, 4]

insert(i, e)

Pour insérer un nouvel élément à un index.

ma_liste = ['a', 'c', 'd']

ma_liste.insert(1, 'b')

print(ma_liste)

# affiche ['a', 'b', 'c', 'd']

remove(e)

Pour supprimer un élément de la liste.

ma_liste = ['a', 'b', 'c', 'd']

ma_liste.remove('b')

print(ma_liste)

# affiche ['a', 'c', 'd']

clear()

Pour supprimer tous les éléments d’une liste:

ma_liste = [10, 20, 30]

ma_liste.clear()

print(ma_liste)

# affiche []

count(e)

Pour compter le nombre d’occurrences d’un élément:

ma_liste = ["John", "Michael", "John", "John"]

occurrence = ma_liste.count("John")

print(occurrence)

# affiche 3

sort()

Pour trier une liste par ordre croissant:

ma_liste = [3, 2, 6, 4]
ma_liste.sort()

print(ma_liste)

# affiche [2, 3, 4, 6]

Pour trier par ordre décroissant, on utilise le paramètre nommé reverse :

ma_liste = [3, 2, 6, 4]

ma_liste.sort(reverse=True)

print(ma_liste)

# affiche [6, 4, 3, 2]

reverse()

Pour inverser l’ordre des éléments dans la liste:

ma_liste = [4, 2, 3]

ma_liste.reverse()

print(ma_liste)

# affiche [3, 2, 4]

Les structures de contrôle

Structures de décision:

L’instruction if:

if 'b' in 'bonjour':

print ("La lettre b est présente dans le mot bonjour")

if 'z' not in 'bonjour':

print ("La lettre z n'est pas présente dans le mot bonjour")

L’instruction else:

Il est possible d’ajouter un bloc else qui sera exécuté si la condition est évaluée à False :

if a % 2:
 print(a, "est un nombre impair")

else:

print(a, "est un nombre pair")

L’instruction elif:

Si on souhaite représenter plusieurs alternatives, il est possible d’utiliser le mot-clé elif :

expl:

def get_mention(note):

if note < 10:

return "insuffisant"

elif note <= 12:

return "passable"

elif note <= 14:

return "assez bien"

elif note <= 16:

return "bien"

else:

return "trés bien"

Structures itératives:

Les structures itératives permettent de répéter un bloc de code.

L’instruction while:

Avec l’instruction while, le bloc de code associé est répété tant que la condition est vraie.

expl:

reponse = None

while reponse != "oui":

reponse = input("Voulez-vous arrêter ? (oui/non) ")

=>Si la condition n’est jamais fausse, le bloc se répète à l’infini.

expl:

while True:

print("ceci va continuer encore et encore...")

L’instruction for:

L’instruction for permet de parcourir (itérer) tous les éléments * d’une liste.

ma_liste = ["premier", "deuxième", "troisième"]

for element in ma_liste:

print(element)

La fonction range:

La fonction range permet de parcourir une liste de nombres. La méthode accepte :

un paramètre pour indiquer la borne supérieure (en commençant la liste à 0 et sans inclure la borne
supérieure)

expl1:

for i in range(5):

print(i)

# Affiche

# 0

# 1

# 2

# 3

# 4

expl2:

deux paramètres pour indiquer l’intervalle avec le début et la fin (exclue)

for i in range(3, 5):

print(i)
# Affiche

# 3

# 4

trois paramètres pour indiquer l’intervalle avec le début, la fin (exclue) et le pas d’incrément entre
chaque valeur

expl3:

for i in range(1, 20, 2):

print(i)

# Affiche

# 1

# 3

# 5

# 7

# 9

# 11

# 13

# 15

# 17

# 19

Il est possible de donner un pas négatif pour obtenir une suite décroissante :

expl4:

for i in range(5, 0, -1):

print(i)

# Affiche

# 5

# 4
# 3

# 2

# 1

Interrompre un bloc d’itération:

Il est possible d’utiliser les mots-clés break et continue pour interrompre l’exécution d’un bloc
d’itération.

break
interrompt immédiatement le bloc et le flot d’exécution sort de la boucle et reprend après le bloc.

continue
Structure itérative avec else:

expl:

for i in range(10):

if input("choisissez-vous le nombre %d ? (oui/non) " % i) == "oui":

break

else:

print("il fallait choisir un nombre... dommage")

Les modules:
La bibliothèque standard Python:

La bibliothèque standard Python contient déjà beaucoup de modules. La liste ci-dessous énumère les
modules les plus utiles à connaître pour débuter en Python :
Importer un module:

=>import sys

print([Link])

Importer directement un nom:

=>from sys import version

print(version)

Note:

Si vous souhaitez importer plusieurs noms du même module, vous pouvez utiliser une seule instruction
from ... import en séparant les noms par une virgule :

=>from sys import version, platform, exit

=> from math import *

exemple:

from math import *

v = factorial(5)

f = floor(10.25)

l = log(2)

print(v, f, l)

# Affiche 120 10 0.6931471805599453

Créer un module à partir d’un fichier:

Chemin des modules:

=>import sys

print([Link])

subprocess — Gestion de sous-processus

La bibliothèque subprocess en Python est utilisée pour exécuter des commandes système à partir de
votre programme Python. Elle vous permet d'interagir avec le système d'exploitation, de lancer des
processus externes, d'exécuter des commandes shell, de rediriger les entrées/sorties et de récupérer les
résultats. Voici quelques exemples d'utilisation de la bibliothèque subprocess :

1. **[Link]** :*******

`[Link]` est une fonction qui remplace les fonctions obsolètes `[Link]` et
`subprocess.check_call`. Elle exécute une commande et attend que le processus se termine. Vous
pouvez spécifier divers paramètres, comme les arguments de la commande, la capture de la sortie,
l'encodage, etc.

expl:

result = [Link](["ls", "-l"], capture_output=True, text=True)

grep_result = [Link](["grep", "python"], input=[Link], capture_output=True, text=True)

print(grep_result.stdout)

2. **[Link]** :

`[Link]` est une classe qui vous permet de lancer des processus en arrière-plan. Cela
vous offre un contrôle plus fin sur la communication avec le processus. Vous pouvez rediriger les
entrées/sorties, obtenir le code de sortie, etc.

3. **subprocess.check_output** :******

`subprocess.check_output` est une fonction qui exécute une commande et renvoie la sortie
résultante sous forme de bytes. Si la commande échoue, elle lève une exception.

4. **[Link]** :

`[Link]` est un objet spécial qui peut être utilisé pour rediriger l'entrée/sortie d'un
processus. Par exemple, vous pouvez l'utiliser pour capturer la sortie d'un processus ou pour fournir une
entrée à un processus.

5. **[Link]** :

`[Link]` est utilisé pour rediriger la sortie standard (stdout) vers le même flux que la
sortie d'erreur standard (stderr). Cela peut être utile pour capturer à la fois la sortie standard et la sortie
d'erreur.

Le module OS

Le module "os" en Python est utilisé pour interagir avec le système d'exploitation sous-jacent, ce qui
vous permet de manipuler des fichiers, des répertoires et d'autres aspects du système de fichiers. Il
fournit des fonctions pour effectuer des opérations courantes telles que la création, la suppression et la
modification de fichiers et de répertoires, ainsi que pour obtenir des informations sur le système
d'exploitation.

1. **[Link](path='.')** : Cette fonction renvoie une liste des noms de fichiers et de répertoires dans le
chemin spécifié. Si aucun chemin n'est donné, elle renvoie la liste des éléments du répertoire de travail
actuel.

2. **[Link](path)** et **[Link](path)** : Ces fonctions créent un nouveau répertoire. `mkdir`

crée uniquement le répertoire final spécifié, tandis que `makedirs` crée également tous les répertoires
intermédiaires si nécessaire.

3. **[Link](path)** et **[Link](path)** : Ces fonctions suppriment un fichier.

4. **[Link](path)** et **[Link](path)** : Ces fonctions suppriment un répertoire. `rmdir`
supprime uniquement un répertoire vide, tandis que `removedirs` supprime également les répertoires
parents vides si nécessaire.

5. **[Link](src, dst)** : Cette fonction renomme (déplace) un fichier ou un répertoire de `src` à

`dst`.

6. **[Link]** : Ce sous-module fournit des fonctions pour travailler avec les chemins de fichiers et les
noms de fichiers de manière portable entre les différents systèmes d'exploitation. Par exemple,
`[Link]()` combine des éléments de chemin pour créer un chemin valide sur le système
d'exploitation actuel, et `[Link]()` vérifie si un chemin existe.

7. **[Link](command)** : Cette fonction exécute la commande spécifiée dans un sous-shell

système.

Le module sys

Le module `sys` est un module en Python qui fournit un accès à certaines fonctionnalités spécifiques du
système. Il permet d'interagir avec l'interpréteur Python et d'accéder à des fonctionnalités liées au
système d'exploitation. Voici une explication des sous-modules et des principales fonctions du module
`sys` :

1. `[Link]` : Cette liste contient les arguments de la ligne de commande passés au script Python. Le
premier élément de la liste est le nom du script lui-même.

2. `[Link]([status])` : Cette fonction permet de quitter le programme en cours d'exécution. Si un

argument `status` est fourni, il s'agit d'un code de sortie qui est renvoyé à l'environnement d'exécution.

3. `[Link]` : C'est un dictionnaire qui contient les modules déjà importés. Les clés sont les noms
des modules et les valeurs sont les objets de module correspondants.

4. `[Link]` : Cette liste contient les chemins de recherche pour les modules. Lorsqu'un module est
importé, Python recherche dans ces chemins pour trouver le fichier correspondant.

5. `[Link]`, `[Link]`, `[Link]` : Ce sont des objets de flux standard pour l'entrée, la sortie et les
messages d'erreur respectivement. Vous pouvez les rediriger pour changer où les données sont lues ou
écrites.

6. `[Link]` et `sys.version_info` : `[Link]` est une chaîne de caractères qui indique la version de
Python. `sys.version_info` est un tuple qui contient des informations détaillées sur la version de Python,
telles que le numéro majeur, mineur, de micro-version, le statut de développement, etc.

7. `[Link](object[, default])` : Cette fonction retourne la taille en octets de l'objet passé en

argument. Si l'objet ne prend pas en charge la fonction `__sizeof__()`, elle renverra une valeur par
défaut spécifiée.

module getopt

Il semble que vous fassiez référence au module `getopt` en Python, qui est utilisé pour analyser les
arguments de ligne de commande. Cependant, à ma connaissance, le module `getopt` ne contient pas
de sous-modules spécifiques. Au lieu de cela, il fournit des fonctions et des classes pour vous aider à
gérer les options de ligne de commande.

1. **[Link](args, shortopts, longopts=[])** : Cette fonction est utilisée pour analyser les
arguments de ligne de commande. `args` est la liste des arguments à analyser, `shortopts` est une
chaîne contenant les spécifications des options courtes (comme `"hvo:"`) et `longopts` est une liste de
spécifications d'options longues (comme `["help", "version", "output="]`).

- `args` : Liste des arguments à analyser, généralement `[Link][1:]`.

- `shortopts` : Chaîne contenant les options courtes. Les options qui prennent un argument sont
suivies d'un `:` (comme `"o:"` signifie que l'option `-o` prend un argument).

- `longopts` : Liste d'options longues. Les options longues prennent un argument s'ils sont suivis d'un
`=`.

La fonction renvoie une paire `(opts, args)` où `opts` est la liste des options et arguments analysés,
et `args` sont les arguments non analysés.

2. **[Link]** : Une exception qui est levée lorsque des erreurs se produisent lors de
l'analyse des arguments de ligne de commande.

Module argparse

`argparse` est une bibliothèque Python intégrée qui facilite la création de interfaces en ligne de
commande avec des options et des arguments. Cette bibliothèque permet de gérer les arguments
passés à un script en définissant des arguments, des options et des sous-commandes. Voici une
explication des principaux sous-modules et concepts de `argparse` :

1. **[Link]** : C'est la classe principale de `argparse`. Elle permet de créer un

analyseur d'arguments en ligne de commande en spécifiant les arguments et options attendus.

2. **Positional Arguments** : Ce sont les arguments qui sont passés sans nom, généralement en tant
qu'éléments de la ligne de commande. Par exemple : `python [Link] arg1 arg2`.

3. **Optional Arguments** : Ce sont les options qui sont précédées par un ou deux tirets. Elles peuvent
être spécifiées de manière facultative. Par exemple : `python [Link] --option valeur`.

4. **Sub-commands** : `argparse` permet de créer des sous-commandes pour organiser les

fonctionnalités d'un script en plusieurs parties. Par exemple, si vous avez un script pour gérer des
opérations mathématiques, vous pourriez avoir des sous-commandes comme `add`, `subtract`,
`multiply`, etc.

5. **[Link]** : Une classe de formatage des messages d'aide qui

affiche également les valeurs par défaut des arguments.

6. **[Link]** : Un type d'argument personnalisé qui accepte les noms de fichiers et les
ouvre automatiquement.

7. **[Link]** : Une classe de base pour définir des actions personnalisées pour les arguments.
Cela peut être utile pour effectuer des validations ou des traitements spécifiques.

8. **[Link]** : Une classe de formatage d'aide qui affiche des noms

d'arguments personnalisés (métavar) dans les messages d'aide.

9. **[Link]** : C'est un objet qui stocke les valeurs des arguments parseés. Les valeurs
sont accessibles en tant qu'attributs de cet objet.

10. **[Link]** : Une classe de formatage d'aide qui préserve la mise

en forme des descriptions, utile pour afficher des blocs de texte en mode verbatim.

11. **[Link]** : Une constante spéciale que vous pouvez utiliser pour indiquer que le
reste de la ligne de commande doit être interprété comme des arguments, même si certains ont déjà
été interprétés.

12. **[Link]** : Une constante que vous pouvez utiliser pour indiquer que l'argument ou
l'option doit être omis de l'aide affichée.

13. **[Link]** : Un type d'argument personnalisé qui restreint les valeurs acceptables à un
ensemble de choix.

14. **[Link]** : Une constante que vous pouvez utiliser pour indiquer qu'un argument est
obligatoire.

et les sous-commandes.

exemple:

parser = [Link](description="Perform arithmetic operations on numbers.")

subparsers = parser.add_subparsers(title="subcommands", dest="operation")

args = parser.parse_args()
Module re

Il semble que vous parlez des sous-modules de l'expression régulière (regex en anglais, ou RE). Les
expressions régulières sont des séquences de caractères qui forment un motif de recherche. Elles sont
utilisées pour effectuer des opérations de recherche et de manipulation de texte de manière avancée.
Les sous-modules (ou fonctions) d'une bibliothèque ou d'un langage de programmation qui prend en
charge les expressions régulières sont utilisés pour effectuer diverses opérations liées aux motifs de
recherche. Voici une explication générale des principaux sous-modules couramment trouvés dans les
bibliothèques d'expressions régulières :

1. **[Link]()** : Cette fonction permet de compiler une expression régulière en un objet de

modèle, ce qui accélère les opérations de recherche et d'appariement en réutilisant le modèle compilé.

2. **[Link]()** : Cette fonction tente de rechercher le motif au début de la chaîne. Si le motif est
trouvé au début de la chaîne, elle renvoie un objet de correspondance, sinon elle renvoie None.

3. **[Link]()** : Cette fonction recherche le motif dans toute la chaîne et renvoie le premier résultat
de correspondance trouvé. Elle ne recherche que la première occurrence du motif.

4. **[Link]()** : Cette fonction recherche toutes les occurrences du motif dans la chaîne et renvoie
les résultats sous forme de liste.

5. **[Link]()** : Similaire à `[Link]()`, mais renvoie un itérable d'objets de correspondance plutôt

qu'une liste. Utile pour traiter chaque correspondance séparément.

6. **[Link]()** : Cette fonction est utilisée pour remplacer toutes les occurrences d'un motif par une
autre chaîne dans une chaîne donnée.

7. **[Link]()** : Cette fonction divise la chaîne en fonction des occurrences du motif et renvoie une
liste de sous-chaînes.

8. **[Link]()** : Cette méthode est appelée sur un objet de correspondance renvoyé par une fonction
de recherche. Elle renvoie la sous-chaîne correspondante.

9. **[Link]()** : Cette méthode renvoie un tuple contenant toutes les sous-chaînes

correspondantes, utile lorsque des groupes de capture sont utilisés dans le motif.

exemple:

text = "Le numéro de téléphone de support est le 123-456-789."

# Recherche d'un numéro de téléphone

pattern = r'\d{3}-\d{3}-\d{3}'

match = [Link](pattern, text)

if match:

print("Numéro de téléphone trouvé :", [Link]())

# Recherche de tous les numéros de téléphone

phone_numbers = [Link](pattern, text)

print("Tous les numéros de téléphone :", phone_numbers)

# Remplacement des numéros de téléphone

modified_text = [Link](pattern, "XXX-XXX-XXX", text)

print("Texte modifié :", modified_text)

Module glob:

Il semble que vous parliez de la fonction `glob` en Python, qui est utilisée pour rechercher des chemins
de fichiers correspondant à un modèle de nom de fichier en utilisant des motifs de caractères spéciaux.
Cela peut être utile pour travailler avec plusieurs fichiers dans un répertoire, par exemple lors du
traitement de données ou du chargement de fichiers.

1. **`[Link]`** : C'est la fonction principale que vous utiliserez généralement. Elle prend un modèle
de nom de fichier (pattern) en tant qu'argument et renvoie une liste de chemins de fichiers
correspondant à ce modèle dans le répertoire actuel.

Exemple :

import glob

files = [Link]('*.txt') # Recherche de tous les fichiers avec l'extension .txt dans le répertoire
actuel

print(files)

2. **`[Link]`** : Cette fonction fonctionne de manière similaire à `[Link]`, mais elle renvoie un
itérable (générateur) plutôt qu'une liste. Cela peut être plus efficace en termes de mémoire pour traiter
de grands ensembles de fichiers.

Exemple :

import glob

file_iterator = [Link]('/chemin/vers/répertoire/*.csv') # Itérable des fichiers CSV dans le

répertoire spécifié

for file in file_iterator:

print(file)

3. **`glob.glob1(dirname, pattern)`** : Cette fonction renvoie une liste des noms de fichiers
correspondant au modèle donné dans le répertoire spécifié (dirname).

import glob

files = glob.glob1('/chemin/vers/répertoire', '*.jpg') # Recherche de fichiers JPG dans le répertoire

spécifié

print(files)

4. **`glob.glob2(dirname, pattern)`** : Cette fonction renvoie une liste de paires (nom de fichier,
attributs du fichier) correspondant au modèle donné dans le répertoire spécifié.

Exemple :

import glob

file_attributes = glob.glob2('/chemin/vers/répertoire', '*.png') # Recherche de fichiers PNG et de

leurs attributs

print(file_attributes)

5. **`glob.glob0(dirname, basename)`** : Cette fonction renvoie le nom de fichier correspondant au

modèle donné dans le répertoire spécifié. Elle est moins couramment utilisée.

Exemple :

import glob

filename = glob.glob0('/chemin/vers/répertoire', '[Link]') # Recherche du fichier

"[Link]" dans le répertoire

print(filename)

Module fnmatch

`fnmatch` est un module de la bibliothèque standard de Python qui permet de réaliser des
correspondances de motifs (pattern matching) en utilisant des modèles de type "glob". Ces modèles
glob sont souvent utilisés pour faire correspondre des noms de fichiers ou de répertoires en fonction de
certains motifs.

1. `[Link](filename, pattern)` :
 Cette fonction vérifie si un nom de fichier (`filename`) correspond à un modèle (`pattern`) donné. Le
modèle peut contenir des caractères spéciaux comme `*` (correspond à n'importe quelle séquence de
caractères) et `?` (correspond à un seul caractère).

expl:

import fnmatch

filename = "[Link]"

pattern = "*.txt"

if [Link](filename, pattern):

print(f"{filename} correspond au modèle {pattern}.")

else:

print(f"{filename} ne correspond pas au modèle {pattern}.")

Module shlex

`shlex` est un module en Python qui fournit des outils pour l'analyse syntaxique de lignes de commande
shell, c'est-à-dire la découpe de chaînes de caractères en "tokens" selon les règles du shell. Cela peut
être utile lorsque vous travaillez avec des commandes shell dans votre code Python, en vous assurant
que les arguments et les options sont correctement séparés.

1. `[Link](s)`: Cette fonction prend une chaîne de caractères `s` en entrée et retourne une version
de la chaîne correctement échappée pour être utilisée comme argument dans une ligne de commande
shell. Cela évite les problèmes liés aux caractères spéciaux.

2. `[Link](s, comments=False, posix=True)`: Cette fonction prend une ligne de commande shell `s` en
entrée et retourne une liste de "tokens" en utilisant l'analyseur de lignes de commande shell. Les
options `comments` et `posix` contrôlent la gestion des commentaires et le comportement conforme
aux normes POSIX, respectivement.

3. `[Link](lst)`: Cette fonction fait l'opération inverse de `[Link]()`. Elle prend une liste de
"tokens" et renvoie une chaîne de caractères qui, lorsqu'elle est passée à l'interpréteur de commandes,
reconstitue la ligne de commande d'origine.

4. `[Link](instream=None, infile=None, posix=False)`: Cette classe fournit une interface plus

avancée pour analyser des chaînes de caractères en utilisant une instance d'analyseur. Elle prend en
charge des opérations plus sophistiquées telles que la possibilité de spécifier un flux d'entrée ou un
fichier d'entrée pour l'analyse.

Traitement des fichiers:

La manipulation de fichiers en Python est une tâche courante et importante dans le développement de
programmes. Vous pouvez utiliser les fonctions et méthodes intégrées pour ouvrir, lire, écrire et fermer
des fichiers. Voici un aperçu des opérations de base pour manipuler des fichiers en Python :

Ouvrir un fichier :

Pour ouvrir un fichier, vous pouvez utiliser la fonction `open()` en spécifiant le chemin du fichier et le
mode d'ouverture. Les modes courants sont :

- `'r'` : lecture (par défaut)

- `'w'` : écriture (crée un fichier s'il n'existe pas, écrase le contenu s'il existe)

- `'a'` : ajout (écriture à la fin du fichier)

- `'x'` : création (erreur si le fichier existe déjà)

- `'b'` : mode binaire (par exemple, `'rb'` pour lecture binaire)

Exemple :

fichier = open('mon_fichier.txt', 'r')

Lire le contenu d'un fichier :

Pour lire le contenu d'un fichier, vous pouvez utiliser les méthodes `read()`, `readline()`, ou `readlines()`.

- `read()` : lit tout le contenu du fichier.

- `readline()` : lit une ligne à la fois.

- `readlines()` : lit toutes les lignes et les renvoie sous forme de liste.

Exemples :

contenu = [Link]()

ligne = [Link]()

lignes = [Link]()

create file :

f=open("file .txt","x")

Delete file :

[Link]("")

Delete folder :
[Link]("")

Ecrire dans un fichier :

Pour écrire dans un fichier, utilisez la méthode `write()`.

Exemple :

fichier = open('mon_fichier.txt', 'w')

[Link]("Ceci est un exemple d'écriture dans un fichier.")

[Link]() # N'oubliez pas de fermer le fichier après l'écriture.

Fermer un fichier :

Il est important de fermer un fichier après l'avoir manipulé en utilisant la méthode `close()` pour libérer
les ressources.

Exemple :

[Link]()

Utilisation avec `with` (context manager) :

Une meilleure pratique consiste à utiliser le bloc `with` pour manipuler des fichiers, car cela garantit que
le fichier est correctement fermé même en cas d'exception

Exemple :

with open('mon_fichier.txt', 'r') as fichier:

contenu = [Link]()

# Effectuez vos opérations sur le contenu ici

file existe :

en python : if [Link](file_path):

liste d'un file :

en python :files = [Link]("/script/file")

file empty :

en python :if [Link](file_path):

difference entre :

TabError: inconsistent use of tabs and spaces in indentation

IndentationError: unindent does not match any outer indentation level