Les fonctions

Python est livré avec de nombreuses fonctions toute faites. Si nécessaire, vous construirez les vôtres.

Les fonctions livrées avec Python

Liste des fonctions
print() + les plus courantes, par ordre alphabétique : input(), len(), open(), range()

print()

La fonction print() est la fonction la plus connue, car elle est la plus utilisée lors de l'apprentissage. Elle permet d'afficher à l'écran la valeur contenue entre ses parenthèses telle qu'un résultat.

Pour créer une ligne vide, il suffit de rien mettre entre les parenthèses : print()

Pour créer un retour à la ligne dans la string, il suffit d'inclure : \n

a="Les \"zozos\" sont bêtes car ...\nils ne vont pas à l'école."; print(a);

# Ce print() affichera :
Les "zozos" sont bêtes car ...
ils ne vont pas à l'école.

Pour empêcher un retour de ligne, il faut utiliser le paramètre facultatif 'end'.

print("début",end='');print("fin");print("début2",end='---');print("fin2")

# Ces 4 print() affichent les deux lignes suivantes :
débutfin
début2---fin2

Pour inclure un espace entre des mots, il suffit que chaque mot soit un paramètre :

print("bon","jour") # affichera : bon jour

print()

exit()

La fonction exit() est la fonction la plus importante, car elle permet d'arrêter le programme. Elle permet d'afficher à l'écran le message contenu entre ses parenthèses tel qu'un code d'erreur.

exit("FIN DU PROGRAMME !") # Pas d'affichage si le programme est lancé via IDLE (F5)
                           # Affichage s'il est lancé depuis un Terminal

La fonction quit() est identique à exit()

print("FIN DU PROGRAMME !"); exit() # Affichage si le programme est lancé via IDLE (F5) ou depuis un Terminal.
                                    # Pas d'affichage si on double-clique sur le fichier .py

input()

La fonction input() attend que l'utilisateur tape une string et frappe la touche Enter.

Attention. Pour le programme, toute réponse de l'utilisateur est une string.

Pour un nombre décimal, l'utilisateur devra taper un point décimal.
(Le programme devrait replacer toute virgule par un point, avant d'utiliser float() )

Pour affecter un nombre (à une variable), on utilise la fonction int() ou float()

Le texte à afficher avant l'arrêt est l'unique paramètre de cette fonction.

La fonction retourne ce que l'utilisateur à taper.

x=input("Votre prénom : ");
print("Bonjour, "+x);

# Votre prénom : Thibaut
# Bonjour, Thibaut

largeur=float(input("Largeur : "));
longueur=float(input("Longueur : "));
print("Surface = "+str(largeur*longueur));

# Largeur : 2.5   Si une virgule décimale est tapée, un message d'erreur s'affichera.
# Longueur : 3.1  Si une virgule décimale est tapée, ...
# Surface = 7.75  (Le point décimal n'est pas tapé, car la valeur a été calculée.)

largeur=input("Largeur : ")
largeur=largeur.replace(",",".")
largeur=float(largeur)

longueur=float((input("Longeur : ")).replace(",","."))

surface=str(largeur*longueur)
print("Surface = "+surface.replace(".",","));

# Largeur : 2,5   Que l'utilisateur utilise la virgule ou le point (décimal), il n'y aura plus d'erreur ...
# Longueur : 3.1  ... car le programme remplace la virgule par un point.
# Surface = 7,75  Ici, le programme remplace le point par une virgule pour afficher une réponse en français.

Voir aussi : input2()

Les fonctions liées aux nombres

x = min(5, 10, 25); print(x);          # affiche : 5
y = max(5, 10, 25); print(y);          # affiche : 25

x = abs(-7.25); print(x);              # affiche : 7.25
x = pow(10, 3); print(x);              # affiche : 1000

x = round(3.1415926535,4); print(x);   # affiche : 3.1416

Les fonctions ne s'appliquent pas à un objet. Leur nom n'est pas précédé d'un point.

Les fonctions liées aux caractères

print(chr(65))            # affiche : A
print(ord('B'))           # affiche : 66
print(chr(ord('B') + 1))  # affiche : C

Vos fonctions

Une fonction est un bloc d'instructions qui définit, entre parenthèses, aucun, un ou plusieurs paramètres (séparés par une virgule) et qui retourne un résultat ou pas. Le paramètre sera considéré comme une variable (locale). Son type peut être : int, float, str ou list

La fonction doit être déclarée avant d'être utilisée. (Logique !)

Déclarer toutes les fonctions au début du code (après la déclaration de toutes les constantes) est une bonne pratique.

La déclaration d'une fonction est composée de 2 parties obligatoires :

1. Le mot-clé def, suivi d'un espace (au moins), suivi du nom de la fonction, suivi de parenthèses et, finalement suivi du caractère :
2. le bloc de code (idéalement précédé d'une description)

def maFonction():
    """" Description de la fonction
  """"
  bloc_de_code

Le nom d'une fonction respecte les mêmes règles que les variables.

Le nom d'une fonction devrait être composé de moins de 25 caractères.

Pour retourner un résultat, on utilise le mot-cle return.

def maFunction():
  print("Cette définition (déclaration) de fonction ne définit aucun argument et ne retourne rien.")

def estPositif(a):
  # Cette définition de fonction définit un argument et retourne True ou False.
  if(a>0):return True
  else:return False

Une fonction est appelée par son nom. Entre parenthèses, on place un nombre d'expressions égale au nombre de paramètres formels. Ni plus, ni moins.

Attention. Dans le code, la fonction doit être définie avant d'être utilisée.
Conséquence : Le point d'entrée du programme se situe à la fin du code.

print(estPositif(-1));    # affiche : False

Fonction avec deux arguments :

def surfaceRectangle(longueur,largeur):
  print("Surface du rectangle = "+str(longueur*largeur));
  # Rappel : On ne peut pas additionner une string avec un nombre => convertir le nombre avec str()

surfaceRectangle(3.3,2)  # appel de la fonction
                         # affiche : Surface du rectangle = 6.6

La valeur du résultat doit correspondre à l'un des types de variable.

Le nom d'un paramètre formel peut être suivi du signe égal suivi d'une valeur (par défaut).

def maFonction(pays = "Belgique"):
  print("Je suis de " + pays)

maFonction("France")   # affiche : Je suis de France
maFonction()           # affiche : Je suis de Belgique

Appel d'une fonction par une partie de son nom

Pour info (hors cadre de ce mini-cours), l'utilisateur peut choisir la fonction à exécuter.

# En Python, tout est objet. Y compris une variable ou une fonction ...

# Déclarations des fonctions (avant la création du dictionnaire)
def fonction1(): print("Fonction 1")
def fonction2(): print("Fonction 2")

listFct={} # création du dictionnaire
listFct['1'] = fonction1 # fonction1 est le nom d'une fonction préalablement déclarée
listFct['2'] = fonction2 # fonction2 est le nom d'un objet, soit d'une 'référence' dans la mémoire
# (cfr le langage C)

numero = input("Tapez le numéro de la fonction à exécuter : ")
listFct[numero]()

La portée d'une variable

Une variable est déclarée dans une fonction ou hors d'une fonction.

Une variable affectée hors d'une fonction a une portée globale.
Une variable affectée dans une fonction a une portée locale (= elle n'existe plus hors de la fonction).

Une variable locale est aussi connue par toute sous-fonction.

Si une variable créée localement porte le même nom qu'une variable globale, l'accès à la variable globale n'est plus possible.

Pour réaffecter une variable globale ou créer une variable globale au sein d'une fonction elle doit être précédée du mot clé global. La nouvelle affectation sera écrite sur une ligne suivante.

# Déclaration des variables
x = y = z = a = b = "Bonjour"  # affectation de 3 variables globales

# Déclaration des fonctions
def maFonction(): # déclaration d'une fonction

  global x, a, b        # réaffectation d'une variable globale (étape 1)
  x = "Bonsoir"   # réaffectation d'une variable globale (étape 2)
                  # Attention, ne pas coder : global x="Bonsoir"
                  # Ici, global a, b ne sert à rien vu qu'elles ne sont pas réaffectées dans la fonction

  print("La valeur globale de x a été modifiée dans la fonction")

  #print(y)       # la variable globale y ne peut plus être utilisée,
                  # car un nom identique est utilisé dans la fonction

  y = "y = Thibaut"   # y est une (nouvelle) variable locale (valable que dans la fonction)
  print(y)        # affiche : y = Thibaut

  print("z = "+z) # affiche : z = Bonjour

# fin des déclarations de la fonction

# Début du programme
print("Valeur de x, y et z avant l'appel de la fonction")
print(x)          # affiche : Bonjour
print(y)          # affiche : Bonjour
print(z)          # affiche : Bonjour

print("Appel de la fonction")
maFonction()      # appel de la fonction nommée maFonction
                  # affiche : La valeur globale de x a été modifiée dans la fonction
                  # affiche : y = Thibaut
                  # affiche : z = Bonjour

print("Valeur de x, y et z, après appel de la fonction")
print(x)          # affiche : Bonsoir
print(y)          # affiche : Bonjour
print(z)          # affiche : Bonjour

Les modules

import math

print(math.sqrt(64));     # affiche : 8
print(math.sqrt(27));     # affiche : 5.196152422706632
print(math.pi);           # affiche : 3.141592653589793
print(math.ceil(1.4));    # affiche : 2
print(math.floor(1.4));   # affiche : 1

import random

print(random.randrange(1, 10))

import datetime

x = datetime.datetime.now()
print(x)      # affiche (par exemple) 2021-11-26 17:30:38.150331
y=str(x);     # x n'est pas une string ! y est une string
print(y)      # affiche : 2021-11-26 17:30:38.150331
print(y[:10]) # affiche : 2021-11-26

import platform

x = platform.system()
print(x)

# Code pour trouver toutes les URLs d'une page web
import urllib.request # Le module urllib est installé par défaut
import re
f = urllib.request.urlopen('http://pigné.be') # L'URL doit être valide
data = f.read() # f = pointeur; read(2000) limite la lecture aux 2000 premiers octets (précaution)
text = data.decode('utf8') # convertit les octets en caractères (codés en UTF-8)
links = re.findall("href=[\"\'](.*?)[\"\']", text) # expression régulière
print(links)

# Les importations (pour accéder à des fonctions toutes faites) :
import math
import random

# Affectations des constantes :
LIMITE_BASSE=1
LIMITE_HAUTE=6

# Déclaration de vos fonctions :


# Début du code à proprement dit :





# Fin du code
exit("Fin du programme")

Passer un ensemble de valeurs à la fonction

La notion de variable-tableau sera abordé prochainement.

Il est possible de passer un ensemble de valeurs à une fonction, soit via un seul argument soit via plusieurs arguments. Les arguments sont des littéraux, des variables simples (de type int, float ou str) ou d'autres variables-tableau.

Le dernier caractère du nom d'une variable-tableau est, par tradition, "s" (pour indiquer que la variable contient potentiellement plusieurs valeurs).

Un seul paramètre, un seul argument

x=7
valeurs=(2, 3.3, "Thibaut", x) # une variable-tableau de type "tuple"

def maFonction(valeurs): # un seul paramètre
  print(str(valeurs[1]))

maFonction(valeurs) # un seul argument

Il n'est pas obligatoire que les noms de l'argument et du paramètre soient identiques.

Un seul paramètre, plusieurs arguments

Lorsqu'un ensemble de valeurs sont passées à la fonction, on peut préfixer le nom de cette variable-tableau locale par *

x=7

def maFonction2(*valeurs): # un seul paramètre
  print(str(valeurs[2])) # str() est inutile dans CE cas

maFonction2(2, 3.3, "Thibaut", x) # plusieurs arguments

Les strings

De nombreuses fonctions ou méthodes sont applicables aux strings

len()

La longueur d'une string (= son nombre de caractères) est donné par la fonction len().

a="Bonjour"; print(len(a));   # affiche : 7

in

Le mot clé in permet de savoir si une string est dans une string.

a="Bonjour"; print("jour" in a);   # affiche : True

[n]

Une string est un tableau de caractères dont le premier à l'indice 0.

La notion de tableau sera abordée ultérieurement.

a="Bonjour"
print(type(a)) # Affiche : <class 'str'>
print(a[0])    # affiche : B

[:]

Pour obtenir une partie d'une string,
ici,  :

a="Bonjour"
print(a[2:5])     # affiche : njo  (entre le troisième caractère inclu au sixième exclu)
print(a[:3])      # affiche : Bon  (tout ce qui est avant le quatrième, exclu)
print(a[3:])      # affiche : jour (tout ce qui suit le quatrième, inclu)
print(a[:-3])     # affiche : Bonj (tout ce qui est devant, sauf les trois derniers)

C'est l'équivalent de la méthode .substring() en JS.

Les tableaux

Il existe 4 types de variables-tableau (= variable pouvant contenir des variables). Globalemenent, les variables-tableau se comportent de la même façon.

Ces 4 nouveaux types de variable sont :

• Le type list (le plus courant)
• Le type tuple (= list qui ne change plus après sa création)
• Le type set (hors-cadre de ce mini-cours)
• Le type dictionary (hors-cadre de ce mini-cours)

Variable-tableau de type "list"

La variable de type list est une variable qui contient des variables.

Une liste vide est représenté par [].

Chaque élément de cette liste est séparé par une virgule.

Le premier élément a comme indice 0; le second, 1; ...

liste=["abc",2,2,True,3.14,[1,3,5,7,11],False];

Une variable de type list peut contenir des valeurs de tout type, y compris de type list ! De plus, des valeurs de ces éléments peuvent être identiques.

Quelques fonctions (len(variable-tableau, type(variable-tableau, ...)),
méthodes (.insert(), .remove(), .pop(), .append(), .extend(), .clear(), ...),
usages (pour l'extraction de valeurs, la ré-affectation d'un élément, ...),
et instruction (del ...)  :

liste=["abc",2,2,True,3.14,[1,3,5,7,11],False];

# Pour vérifier le type d'une variable
print(type(liste));  # affiche : <class 'list'>

# Pour connaître la taille du tableau (son nombre d'éléments)
print(len(liste));   # affiche : 7

# Attention : La valeur de la dernière borne (indiquée) n'est pas reprise
print(liste[5]);     # affiche : [1, 3, 5, 7, 11]
print(liste[2:5]);   # affiche : [2, True, 3.14]

print(liste[3]);     # affiche : True
print(liste[:3]);    # affiche : ['abc', 2, 2]

# La dernière borne n'est pas indiquée => la dernière valeur est reprise
print(liste[3:]);    # affiche : [True, 3.14, [1, 3, 5, 7, 11], False]

# Pour réaffecter un élément [existant] de la liste :
liste[0]="pomme";
print(liste)    # affiche : ['pomme', 2, 2, True, 3.14, [1, 3, 5, 7, 11], False]

# Si l'élément est inexistant, ce n'est plus une ré-affectation. C'est une erreur.
liste[10]="chocolat";
print(liste)    # affiche ... IndexError: list assignment index out of range

# Pour vérifier l'existence d'une valeur :
if "pomme" in liste:
  print("La string 'pomme' est dans la liste");

# Pour insérer un élément dans la liste, à un index (les autres éléments sont décalés vers la fin) :
liste.insert(2,'banane'); # signifie : insérer à l'index 2, 'banane'
print(liste);    # affiche : ['pomme', 2, 'banane', 2, True, 3.14, [1, 3, 5, 7, 11], False]

# Pour supprimer un élément selon sa valeur (si elle existe) :
liste.remove([1, 3, 5, 7, 11]);
print(liste);    # affiche : ['pomme', 2, 'banane', 2, True, 3.14, False]

# Pour supprimer un élément selon son index (s'il existe) :
liste.pop(2);
print(liste);    # affiche : ['pomme', 2, 2, True, 3.14, False]

# Pour ajouter à la fin de la liste, un élément (ici, 7):
liste.append(7);
print(liste);    # affiche : ['pomme', 2, 2, True, 3.14, False, 7]

# Pour ajouter une liste à une liste :
liste2 = ["cerise","poire"];
liste.extend(liste2);
print(liste);    # affiche : ['pomme', 2, 2, True, 3.14, False, 7, 'cerise', 'poire']

# Pour supprimer le dernier élément :
liste.pop();
print(liste);    # affiche : ['pomme', 2, 2, True, 3.14, False, 7, 'cerise']

# Pour supprimer le premier élément :
del liste[0];
print(liste);    # affiche : [2, 2, True, 3.14, False, 7, 'cerise']

# Pour vider la liste :
liste.clear();
print(liste);    # affiche : []

# Pour supprimer la liste :
del liste;
print(liste);    # affiche un message d'erreur (car la variable n'existe plus)

.split()

La méthode .split() est appliquée à une string. Elle retourne des données au format list. Son paramètre est la string utilisée pour séparer les données.

ligne="Bertrand|Thibaut|Marie"
liste=ligne.split("|")
print(liste)      # affiche : ['Bertrand', 'Thibaut', 'Marie']

Cette méthode est particulièrement utile pour analyser des fichiers CSV.

.join()

La méthode .join() est quasiment l'inverse de la méthode .split(). Appliquée à une list. Elle retourne une string.

mot="secret"
liste=list(mot) # transforme une string en tableau (list)
print(liste)
liste.reverse()
print("".join(liste)) # Affiche : terces

Il existe une façon de "renverser" une string.

txt = "secret"[::-1]
print(txt) # Affiche : terces

.sort()

La méthode .sort() est appliquée à une variable-list et réorganise le contenu de la variable, par ordre croissant.

Si le paramètre est reverse = True, le tri est décroissant

liste=['Bertrand', 'Thibaut', 'Marie']
liste.sort(reverse=True)
print(liste)      # affiche : ['Thibaut', 'Marie', 'Bertrand']

.reverse()

La méthode .reverse() est appliquée à une variable-list et "retourne" contenu de la variable. Le premier élement devient le dernier.

.copy()

La méthode .copy() est appliquée à une variable-list et crée une (vraie) copie la variable.

liste2 = liste1 # liste2 contient une référence => la même liste peut être modifiée de via l'une des deux variables => liste1.pop() == liste2.pop()

+

L'opérateur + permet de joindre deux variables-list.

liste3 = liste1 + liste2

Liste des méthodes liées à une variable-liste

Variable-tableau de type "tuple"

La création d'une list se fait via des crochets.
La création d'un tuple se fait via des parenthèses.

a = [1, 2.2, "Thibaut"] # création d'un tableau de type "list"
b = (1, 2.2, "Thibaut") # création d'un tableau de type "tuple"
print(b[2]) # Affiche : Thibaut
c = () # = tuple vide => len(c) vaut 0
      

"list" ou "tuple" ? Si on sait que les valeurs ne changeront plus, il est préférable de choisir de stocker les valeurs dans une variable-tableau de type "tuple" pour des raisons de vitesse d'exécution.

Un tuple est une list gelée. Une fois créée, ses valeurs ne changent plus. Les méthodes de changement de valeur vue avec la list ne sont pas applicables.

Toutefois, il existe un truc ... Transformer la "tuple" en "list", faire la modification puis transformer la "list" en "tuple".

x = ("apple", "banana", "cherry")
y = list(x)
y[1] = "kiwi"
x = tuple(y)

print(x)    # affiche : ('apple', 'kiwi', 'cherry')
print(x[1]) # affiche : kiwi

La fonction list() retourne une variable-tableau de type list.
La fonction tuple() retourne une variable-tableau de type tuple.

Les fichiers

Pour lire ou écrire dans un fichier, il faut utiliser la fonction open().

Le nom de cette fonction peut dérouter, car il faut "ouvrir" un fichier même pour le créer.

open() .close

open()

La fonction open() dispose de deux arguments. Lors de l'appel de cette fonction, le premier paramètre, obligatoire, est le chemin complet du fichier. Le second paramètre est le type d'action qui sera faite sur le fichier. Cette fonction retourne un objet qui représente un fichier (ou retourne une erreur). Cet objet est souvent affecté à une variable, souvent nommé f (comme dans fichier). Cette variable est alors une variable de type objet.

La notion de variable de type object n'est pas abordée dans le cadre de ce mini-cours. Sachez simplement qu'on peut leur appliquer des méthodes (propres à ce type d'objet). Concernant ce type de variable-objet, les principales méthodes sont : .read(), .readLine et .write(). Certaines méthodes peuvent retourner une string.

f = open("monFichier.txt")
# Le fichier "monFichier.txt" est maintenant prêt pour les méthodes de lecture d'un fichier texte
# Il pourra être lu via les méthodes .read() ou .readLine()

Pour éviter des erreurs, il est préférable d'indiquer l'encodage utilisé par le fichier texte.

f = open("monFichier.txt", encoding='utf-8')

Un chemin complet est un emplacement suivi du nom d'un fichier.

Si le fichier à ouvrir se trouve dans le dossier du programme, ce chemin complet est le nom du fichier (son emplacement ne doit pas être indiqué).

Par exemple, sous Windows et sous Linux, "monFichier.txt"

Si le fichier se trouve dans un sous dossier du programme, ce chemin complet peut être un emplacement relatif suivi du nom du fichier.

La documentation d'un programme est souvent contenue dans l'un de ses sous-dossiers.

Par exemple, sous Windows, "documentation\monFichier.txt"
Par exemple, sous Linux, "documentation/monFichier.txt"

Sous Linux, le caractère qui sépare le nom du dossier de celui du fichier est comme sur internet (/). Sous Windows, c'est l'inverse.

Si le fichier se trouve sur votre ordinateur, ce chemin complet doit être un emplacement absolu.

Par exemple, sous Windows, "C:\\monDossier\monFichier.txt"
Par exemple, sous Linux, "/home/user_name/Bureau/monFichier.txt"

import urllib.request # Le module urllib est installé par défaut
f = urllib.request.urlopen('https://www.mon-site.be/index.htm') # L'URL doit être valide
data = f.read(2000) # f = pointeur; Limite la lecture aux 2000 premiers octets (précaution)
print(data)
""" Exemple d'affichage :
b'<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset="UTF-8" />  \n</head>  \n<body>  \n</body>\n</html>\n'
"""

print(data.decode())
""" Exemple d'affichage :
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
  </head>
  <body>
  </body>
</html>
"""

Le second paramètre (facultatif) de la fonction open() indique le type d'action sur un fichier. Il est indiqué par une ou deux lettres.

Il existe 4 types d'action sur un fichier, indiquée par une lettre différente :

• r (comme dans read) : pour lire, valeur par défaut.
• a (comme dans append) : pour ajouter à la fin du fichier.
• w (comme dans write) : pour écrire (écrasement du fichier existant)
• x : pour créer un fichier vide (erreur s'il existe déjà)

On peut ajouter une lettre pour préciser le type de fichier.

• t (comme dans text) : pour indiquer un fichier texte codé en UTF-8, valeur par défaut.
• b (comme dans binary) : pour indiquer un fichier binaire.

f2 = open("nouveauFichier.txt", "w")
# Le fichier "nouveauFichier.txt" est maintenant prêt pour les méthodes d'écriture d'un fichier texte
# Il pourra être créé par la méthode .write()

Il est possible de travailler sur plusieurs fichiers en même temps. Il existe alors autant de variables (f1, f2, ...) que de fichiers. Il est donc possible de lire une partie d'un fichier (f1) et de l'écrire dans un autre fichier (f2).

Il est même possible de travailler sur le même fichier en mode lecture/écriture (hors cadre de ce mini-cours)

.close

Qui dit ouverture, dit fermeture.

La méthode .close s'applique à une variable-objet qui représente un fichier ouvert. Elle coupe la communication entre le programme et le fichier. Chaque fichier qui ne subira plus d'action devrait être fermé avant la fin du programme. Même si la fin du programme coupe aussi la communication entre le programme et le fichier.

Si la méthode .close n'est pas utilisée, le programme pourrait se terminer avant que l'écriture sur le disque dur soit terminée. De plus, la méthode .close, libère la mémoire (RAM) réquisitionnée pour effectuer les actions et libère le fichier qui devient immédiatement disponible pour d'autres programmes.

Le programme est situé en RAM et donc traite plus d'octets par seconde que le disque dur. S'il se ferme "brutalement" (sans vérifier que les travaux d'écriture sont terminées), le fichier pourrait être incomplet.

with

À la place de la méthode .close, on peut utiliser le mot-clé with. Dans ce cas, vous fermez toujours correctement le fichier, même si une exception est levée. Mais, c'est moins verbeux que d'utiliser les blocs try ... finally.

with open("monFichier.txt") as f:
  read_data = f.read()

Plus d'info

.readline()

La méthode .readLine() permet de lire une ligne. À chaque appel, une nouvelle ligne est lue.

La méthode retourne une string contenant une fin de ligne (\n, sous Windows).

CC="monFichier.txt"   # cc pour chemin complet
f=open(CC)            # ouvre le fichier
print(f.readline())   # affiche la première ligne (si elle existe)
print(f.readline())   # affiche la seconde ligne (si elle existe)
f.close               # ferme le fichier

Il est facile de lire tout un fichier, ligne par ligne, via une boucle for.

CC="monFichier.txt"   # cc pour chemin complet
f=open(CC)            # ouvre le fichier
for x in f:
  print(x)
f.close               # ferme le fichier

La méthode writeline() n'existe pas.

.readlines()

Cette méthode retourne toutes les lignes dans un tableau (ci-dessous, "lines").

with open(CC) as f: lines = f.readlines()

.writelines()

La méthode .writelines() permet d'écrire dans un fichier, un tableau de lignes qui est passé à son unique argument.

Exemple de code pour modifier la première ligne d'un fichier texte :

# Les importations =============================================================
import os; import platform #; import xml.etree.ElementTree as ET
import tkinter as Tk; from tkinter import *; from tkinter import filedialog
from tkinter import simpledialog #; from tkinter import messagebox

# Les déclarations des variables globales pour les fichiers ====================
gPath = os.path.abspath("."); SEP="/"
if platform.system() == "Windows": SEP="\\"#; gPath=os.path.abspath("C:\\Users");
gFileTypes=(('SVG files','*.svg'),('All files','*.*'))

# Choisir un fichier SVG
cc=filedialog.askopenfilename(initialdir=gPath,filetypes=gFileTypes)
if len(cc)<1 : exit("FIN DU PROGRAMME !")

ns=' xmlns="http://www.w3.org/2000/svg"' # ce qu'il faut enlever

with open(cc) as f: lines = f.readlines()
ligne1 = lines[0]; lines[0] = ligne1.replace(ns,'')# OK même si ns n'existe pas
with open(cc, 'w') as f: f.writelines(lines)

.read()

La méthode .read() dispose d'un argument qui permet de préciser le nombre de lettres à lire. Si cette précision n'est pas indiquée, elle retourne tout le contenu.

CC="monFichier.txt" # cc pour chemin complet
f=open(CC)
tout=f.read()       # tout est une string valant tout le contenu du fichier
debut5=f.read(5)    # debut5 est une string valant les 5 premiers caractères
                    # (=> pas nécessairement les 5 premiers octets)
f.close             # ferme le fichier (bonne pratique)

.write()

La méthode .write() permet d'écrire dans un fichier. Elle retourne le nombre de caractères écrits.

Pour remplir le fichier, mieux vaut exécuter le programme en passant par l'interface en lignes de commandes (CLI) :
py programme.py (sous Windows) ou python3 programme.py (sous Linux)

Son comportement variera en fonction de l'objet sur lequel elle est appliquée.

Si le second paramètre de la fonction open() était une string débutant par :

• "a", l'écriture sera ajoutée à la fin du fichier.
  De plus, si le fichier n'existait pas, il sera automatiquement créé.
  La méthode se comportera alors comme si le second paramètre avait été "w"
• "w", l'écriture débutera au début du fichier et écrasera tout le reste.
  De plus, si le fichier n'existait pas, il sera automatiquement créé.

CC="monFichier.txt"   # constante, CC pour chemin complet

f=open(CC,"w")          # ouvre le fichier (en mode écriture)
nb_carac=f.write("été") # nb_carac = 3
f.close                 # ferme le fichier
# taille du fichier = 5 octets

f=open(CC,"a")        # ouvre le fichier (en mode ajout)
f.write("Ceci a été ajouté à la fin du fichier.")
f.close               # ferme le fichier

f=open(CC)            # ouvre le fichier
for x in f:
  print(x)
f.close               # ferme le fichier

f=open(CC,"a")        # ouvre le fichier (en mode "ajout")
f.write("\nCeci est la dernière ligne du fichier.")
f.close               # ferme le fichier

f=open(CC)            # ouvre le fichier
for x in f:
  print(x)
f.close               # ferme le fichier

f=open(CC,"w")        # ouvre le fichier (en mode "écrasement")
f.write("Nouveau contenu.")
f.close               # ferme le fichier

f=open(CC)            # ouvre le fichier
for x in f:
  print(x)
f.close               # ferme le fichier

import os

La gestion des fichiers et de dossiers réclament l'importation du module os.

Code pour lister les noms de fichiers d'un dossier :

import os

path="."        # = emplacement du dossier courant (= contenant le présent programme)
#path="./tmp"   # = sous-dossier /tmp par rapport au dossier courant
# Si le sous-dossier /tmp n'existe pas, un message d'erreur s'affichera.

# Liste des noms de fichiers ayant l'extension ".txt"
for file in os.listdir(path):
    if file.endswith(".txt"):
        print(file)
  

Code pour supprimer un fichier :

import os

CC="monFichier.txt"

if os.path.exists(CC):
  os.remove(CC)
else:
  print("Le fichier '"+CC+"' n'existe pas dans le dossier contenant ce programme.")

La suppression de ce qui n'existe pas provoque une erreur. L'écrasement du contenu d'un fichier par un contenu vide est déjà une forme de suppression.

Code pour renommer un fichier :

os.rename() provoque une erreur si newFilename existe.

if not os.path.exists(newFilename):
  os.rename(oldFilename, newFilename)

Code pour écraser un fichier :

# écrase le fichier temporaire
if os.path.exists(newFilename):
  os.remove(newFilename)               # supprime le fichier existant
  os.rename(oldFilename, newFilename)  # renomme avec le nom du fichier supprimé

Code pour copier plusieurs fichiers dans un autre dossier :

"""Copie tous les fichiers dont le chemin complet est dans un fichier TXT
et qui débutent, par exemple, par "X:/tintin/"
vers le dossier souhaité, par exemple : "X:/milou/"
en respectant l'arborescence. "X:/tintin/a/b/c.txt" vers "X:/milou/a/b/c.txt"

NB : Si le fichier de destination existe déjà, il est écrasé."""

import os; import platform; import shutil
import tkinter # --------------------------
from tkinter import filedialog # ----------
from tkinter import simpledialog
from tkinter import messagebox

gPath = os.path.abspath("."); SEP="/"
if platform.system() == "Windows": SEP="\\"

dossier = filedialog.askdirectory(initialdir=gPath, title="Sélection d'un dossier")
if len(dossier)==0:
  exit("Pas de dossier sélectionné !")
dossier = dossier.replace("/",SEP) # sans slash final

nbFichiersCopied=0
with open(CC_txt) as g:
  tabCC = g.readlines() # À ce stade, tous les chemins sont dans tabCC

  for cc in tabCC :
    src = cc[:-1] # supprime le caractère de fin de ligne

    if not os.path.exists(src):
      print("No exist", src)
      continue

    if src.startswith(debut) :
      dst = dossier + SEP + src[position:]
      head, tail = os.path.split(dst)
      if not os.path.isdir(head): os.makedirs(head)
      try:
        shutil.copy(src,dst)
        nbFichiersCopied+=1
      except:
        print("No copy", src)
    else : print(src)

Si le chemin complet n'est pas précisé, le dossier est celui de l'application (py).
Pour faire une copie dans le même dossier, il faut que les noms diffèrent.

Documentation du module os

Pour lister les sous-dossiers :

import os; import platform; import tkinter as tk; from tkinter import *
from tkinter import filedialog

dossier = os.path.abspath(".")
if platform.system() == "Windows": SEP="\\"#; gPath=os.path.abspath("C:\\Users");

def listDirs(rootdir, exclu = "", withParent = True): #-------------------------
  """
  Fonction (non récursive) qui utilise une boucle WHILE pour lister
  les dossiers-enfants (et petit-enfants)

  :param str rootdir: Chemin complet du dossier (parent)

  Exemple (sous Windows) = X:/dossiers/sous-dossiers   (sans slash final)
  NB : La valeur de "rootdir" provient de "filedialog.askdirectory()"
  => pas de "backslash" => pas X:\dossiers\sous-dossiers

  :param str exclu: String du chemin qui l'exclut

  Exemple : si exclu="zZ", les chemins suivants sont exclus :
  X:\dossiers\zZ\old
  X:\dossiers\sous-dossiers\zZ
  ...

  :param bool withParent : Si False, retourne que les descendants

  Requiert l'importation de : os

  :return: Un tableau contenant la liste des chemins du dossier parent et de
  ses dossiers descendants, utilisant le séparateur de l'OS,
  sans ce séparateur final

  Exemple (sous Windows) :
  X:\dossiers\sous-dossiers\enfant1
  X:\dossiers\sous-dossiers\enfant1\petit-enfant
  ...

  :rtype: list

  2022-11-19 19:27:04
  """

  dossiers = [] # liste des chemins du dossier-parent et de ses descendants
                # (avec le caractère de séparation des noms dépendant de l'OS)

  dossiers.append(rootdir) # ajoute le dossier parent
  i=0 # index en cours

  print("Recherche en cours ... dans :", rootdir,
        " exclure :", exclu,
        " avec parent :", str(withParent))

  if len(exclu)>0:
    while i <len(dossiers):
      x = dossiers[i]#; print(str(i), str(len(dossiers)))
      for file in os.listdir(x):
        d = os.path.join(x, file)
        if os.path.isdir(d):
          if exclu not in d : dossiers.append(d)
      i +=1
  else:
    while i < len(dossiers):
      x = dossiers[i]#; print(str(i), str(len(dossiers)))
      for file in os.listdir(x):
        d = os.path.join(x, file)
        if os.path.isdir(d): dossiers.append(d)
      i +=1

  if not withParent: dossiers.pop(0)

  return dossiers



# ============ Entrée du programme ===================
fP = Tk (); fP.withdraw() # Création de l'interface

dossier = filedialog.askdirectory(initialdir = dossier,
                                  title = "Choisissez le dossier ")
if len(dossier)==0 : exit()
dossier = dossier.replace("/",SEP)

tab1 = listDirs(dossier)              ; print("=", str(len(tab1)), "dossiers\n")
tab2 = listDirs(dossier,"zZ")         ; print("=", str(len(tab2)), "dossiers\n")
tab3 = listDirs(dossier,"zZ", False)  ; print("=", str(len(tab3)), "dossiers\n")

#tab1.sort()
#for x in tab1 : print(x)

fP.destroy()
fP.mainloop()

python-simple.com

try: ... except: ... [else: ...] [finally: ...]

Un programme s'arrête brusquement à la première erreur, sauf si ...

Pour éviter un arrêt brutal et sortir proprement, il faut mettre en place un mécanisme qui, lorsqu'une erreur survient, oblige le programme à suivre une autre voie. L'utilisation systématique d'un tel mécanisme est recommandé lors de l'utilisation de fichiers.

MSG_ERROR="""Message d'erreur à l'attention de l'utilisateur :
Veuillez communiquez les informations ci-dessous à programmeur@....be. D'avance merci.
Nom du programme : monProgram.py
Code de l'erreur : """

errorCode=1233  # -------------------------------------------
try:
  x="Bonjour"
  print(x)

except:
  print(MSG_ERROR+str(errorCode))

errorCode=1234  # -------------------------------------------
try:
  print(y)    # La variable 'y' est utilisée avant sa création !
              # Ceci va provoquer une erreur.
except:
  print(MSG_ERROR+str(errorCode))

On peut aussi imposer une voie à suivre dans tous les cas => finally:

try:
  f = open("monFichier.txt")
  f.write("Bonjour")
except:
  print("Impossible d'écrire dans 'monFichier.txt'")
  # car le mode d'écriture n'a pas été indiqué dans la fonction open()
finally:

  try:
    f.close()  # Fermer un fichier dans tous les cas (= bonne pratique)
  except:
    print("Le fichier n'a pas été fermé, car il n'a pas été ouvert ... car il n'existait pas !")

Les clauses try peuvent s'imbriquer dans toutes les autres clauses (except:, else:, finally:).

Exemple. Connexion à une base de données :

try:
  # Connexion à une base de données
except:
  # Affiche un message en cas de non connexion
else:
  # À ce stade, la connexion est établie
  try:
    # Envoi d'une requête
  except:
    # Affiche un message au cas où la requête échoue, tel que la requête
  else:
    # Récupération de la réponse dans une variable
finally:
  # Fermeture de la connexion

Plus d'info sur la gestion des erreurs.

import subprocess

Pour enregistrer dans un fichier le résultat produit par un exécutable externe.

with open(out,"w") as f:
  subprocess.run([pathTo_dotExe, "-Tsvg", cc], stdout=f)

Où pathTo_dotExe est un string représentant le chemin absolu vers l'exécutable
Où -Tsvg est l'option à passer à l'exécutable externe
Où cc est une string représentant la seconde "option"

Voilà, vous avez acquis les bases.

Maintenant, votre curiosité et votre intérêt vous pousseront à passer à la pratique.

Voici quelques exemples concrets.