Algorithmique et programmation en Python

Pour toute remarque sur le document ou suggestion de correction vous pouvez écrire à l'auteur à l'adresse:

roland_tc@protonmail.com

Contact :

1. Algorithmique et programmation

2. Variables numériques & Opérations

3. L'entrée des valeurs par l'utilisateur

4. L'affichage à l'écran

5. L'instruction conditionnelle if

6. La boucle bornée for

7. La boucle non bornée while

8. Les Fonctions

9. Les listes et les chaînes

10. Les fichiers

Au programme :

1. Algorithme et programmation

Un algorithme est une suite d’instructions qui s’enchaînent dans un ordre déterminé et qui font intervenir la plupart du temps des variables.

Il peut s’écrire en langage naturel ou en langage informatique.

Programmer un algorithme consiste à l’écrire dans un langage informatique, ici Python, il devient alors un programme
(on parle aussi de script).

Lorsque l’on écrit du code informatique, il est important de le commenter afin de le rendre plus compréhensible pour les autres et pour soi-même. Les commentaires ne sont pas interprétés par Python et commence par un dièse.

# un commentaire en Python

2. Variables numériques & Opérations

Une variable est comme une petite boite dans laquelle on peut stocker des données, nombre, chaîne de caractères, valeur entrée par l’utilisateur...

A chaque donnée est associé un nom et un type.

Le nom permet de désigner la donnée et le type permet de préciser la nature de cette donnée, ce qui détermine les opérations que l’on peut lui appliquer.

Les variables qui stockent des valeurs numériques sont appelées variables numériques. Pour stocker une valeur dans une variable, on écrit une instruction d’affectation.

nom_de_la_variable = valeur

Affectation en Python :

On affecte la valeur 7,5 à la variable longueur.

longueur = 7.5

Un nom de variable ne doit pas contenir d’espace. Il est composé de lettres, de chiffres (pas en première position) et on utilise le tiret du bas (underscore) pour remplacer les espaces.

>>> a = 22
>>> b = 7
>>> a + b
29
>>> a - b
15
>>> a*b
154
>>> a/b
3.142857142857143
>>> a**4                  # puissance entière
234256
>>> from math import sqrt # importe la fonction racine carrée 
>>> sqrt(a)
4.69041575982343
>>> a//b                  # quotient entier
3
>>> a%b                   # reste de la division euclidienne
1

Opérations avec les variables numériques :

3. L’entrée des valeurs par l’utilisateur

Souvent lors de la conception d’un programme, on écrit des instructions qui invitent l’utilisateur à entrer des données.

Dans l’exemple ci-dessous la fonction input() affiche le message "Entrer le nombre de boules dans l’urne :".

Par défaut cette fonction renvoie une chaîne de caractère (même si l’utilisateur a saisi un nombre entier).

On utilise la fonction int() pour que la valeur affectée à la variable n soit bien un nombre entier.

n = int(input("Entrer le nombre de boules dans l'urne :"))

Dans l’exemple ci-dessous la fonction float() va convertir la valeur saisie par l’utilisateur en un nombre réel.

x = float(input("Entrer l'abscisse du point A :"))

4. L’affichage à l’écran

La fonction print() permet d’afficher à l’écran un message ou la valeur stockée dans une variable.

Exemples.

Affichage de la valeur stockée dans une variable :

nombre = 4
print(nombre)      # affiche 4

Affichage d’une chaîne de caractères : On utilise indifféremment des guillemets simples ou doubles.

print("nombre")    # affiche nombre
print('nombre')    # affiche nombre

Le caractère spécial \n correspond à un retour à la ligne :

print("Une liste :\n* item 1\n* item 2") # affiche Une liste:
                                         #         * item 1
                                         #         * item 2

Affichage d’une chaîne de caractères et de la valeur affectée à une variable :

distance = 8
print('la distance est égale à ', distance) 
# affiche la distance est égale à 8

5. L’instruction conditionnelle if

Il n’est pas rare d’avoir à écrire dans un algorithme une instruction du type :

si CONDITION alors INSTRUCTION1 sinon INSTRUCTION2

if condition(s):
    instruction1(s)
else:
    instruction2(s)

Syntaxe en Python :

Pour délimiter les blocs d’instructions Python utilise les : et l’indentation (décalage du retour à la ligne vers la droite).
Les mots clés utilisés sont if, else et elif (contraction de else if).

Exemples :

Dans l’exemple ci-dessous, on teste la condition x > 0.

Si cette condition est vérifiée, le message s’affiche et si ce n’est pas le cas, il ne se passe rien.

x = float(input("Entrer un nombre x :"))
if x > 0:
    print(x, " est un nombre strictement positif.")

Dans l’exemple ci-dessous, on teste toujours la condition x > 0. Si cette condition n’est pas vérifiée, le programme affiche à présent le deuxième message

x = float(input("Entrer un nombre x :"))
if x > 0:
    print(x, " est un nombre strictement positif.")
else:
    print(x, " est un nombre négatif.")

Ici on teste une deuxième condition x < 0. Si les deux conditions ne sont pas vérifiées, le programme affiche le troisième message:

x = float(input("Entrer un nombre x :"))
if x > 0:
    print(x, " est un nombre strictement positif.")
elif x < 0:
    print(x, " est un nombre strictement négatif.")
else:
    print("x est égal à 0.")

Les conditions x > 0 et x < 0 sont des booléens, si elles sont vérifiées elles renvoient True et dans le cas contraire elles renvoient False.

Opérateurs de comparaison :

2 == 2     # True     == est le signe égal en Python
4 != 2     # True     != est le signe "est différent de" 
4 > 2      # True
4 < 2      # False
4 > 4      # False
4 >= 4     # True
4 <= 2     # False

Opérateurs logiques and et or :

a = True
b = False

a and a     # True
a and b     # False
b and a     # False
b and b     # False
a or a      # True
a or b      # True
b or a      # True
b or b      # False

6. La boucle bornée for

Lorsque l’on souhaite répéter une ou plusieurs instruction(s) un nombre défini de fois, c’est à dire connu à l’avance, on utilise une boucle for.

for variable in range():
    instruction(s)

Syntaxe en Python :

La fonction range() définit le nombre de passages dans la boucle et comme pour une instruction conditionnelle, le bloc d’instruction(s) est délimité par les : et l’indentation.

Soit n, m et k des nombres entiers :

range(n) : fait prendre à la variable les valeurs entières de 0 à n − 1 (n valeurs).
range(n, m) : fait prendre à la variable les valeurs entières de n à m − 1 (m − n valeurs).
range(n, m, k) : fait prendre à la variable les valeurs entières de n à m − 1 avec un pas de k.

Exemples :

for i in range(3):
    print(i)     # affiche 0
                 #         1
                 #         2

for i in range(21, 25):
    print(i)     # affiche 21
                 #         22
                 #         23
                 #         24

for i in range(7, 20, 3):
    print(i)     # affiche 7
                 # 10
                 # 13
                 # 16
                 # 19

Afficher sur la même ligne dans une boucle :

for i in range(3):
    print(i, end=" ")     # affiche 0 1 2

for i in range(3):
    print(i, end=", ")     # affiche 0, 1, 2,

En prenant un pas négatif on peut boucler dans l'autre sens :

for i in range(0, -10, -2):
    print(i)

# 0
# -2
# -4
# -6
# -8

for i in range(10, -1, -1):
    print(i, end="  ")

# Affiche 10  9  8  7  6  5  4  3  2  1  0

7. La boucle non bornée while

Lorsque l’on souhaite répéter une ou plusieurs instruction(s) un nombre inconnu de fois, on utilise une boucle while. Elle est parcourue tant qu’une condition est vérifiée. Le bloc d’instruction(s) est également délimité par les : et l’indentation.

while condition:
    instruction(s)

Syntaxe en Python :

Exemple de boucle while :

i = 0
while i < 10:
    print("Je ne bavarde pas en classe")
    i += 1

# Affiche:
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe
# Je ne bavarde pas en classe

Attention à la boucle infinie !

i = 11
while i != 10:
    print("Je ne bavarde pas en classe")
    i += 1    # La valeur n'atteindra jamais 10...

8. Les fonctions

Une fonction est une suite d'instructions que l'on peut appeler par son nom. Elle prend zéro, un ou plusieurs paramètres en entrée et elle renvoie un résultat, éventuellement suite à un calcul.

Parfois la fonction ne renvoie pas de résultats. Dans ce cas on par le de procédure.

Exemple de fonction:

def indique_mon_age():
    return 32

# Appel
print(indique_mon_age())

# Affiche 32

Pour créer une fonction en python en utilise le mot clé def, suivi du nom de la fonction, puis entre parenthèses on met les paramètres éventuels de la fonction séparés par des virgules. A la fin on met les deux points (:)

Pour déclarer qu'un code appartient au corps de la fonction on utilise l'indentation (décalage du code à droite).

Si la fonction renvoie un résultat on le retourne à l'aide du mot clé return. Sinon on peut se contenter d'un print (optionnel)

def carre(a):    # Définition de la fonction
    return a*a    # Résultat de notre calcul
    # Indentation : "décalage à droite" de notre code

# Plus d'indentation on est "à l'extérieur"
# On peut donc tester notre fonction
print(carre(2))

Autres exemples de fonctions

Utiliser return (pour retourner un résultat) peut servir à stocker la valeur calculée par notre fonction dans une variable...

# Calcul de Valeur Absolue
def valeurAbsolue(n):
    if n>=0:
        return n
    else:
        return -n    

# Calcul de puissance
def puissance(x, n):
    return x ** n    # Rappel: ** exprime la puissance

nombre = int(input("Entrez un nombre"))   # J'entre -27
nombre = valeurAbsoule(nombre)   # Le nombre devient 27 
nombre_au_cube = puissance(nombre,3)    # 27**3

print(nombre_au_cube)    # Affiche 19683

Exemple:

Selon la formule mathématique : (a+b)(a-b) = a² - b².

Illustrons ce calcul à travers plusieurs fonctions intermédiaires:

Une fonction a_plus_b qui additionne ses deux paramètres
Une fonction a_moins_b qui soustrait ses deux paramètres
Une fonction a_carre_moins_b_carre qui se sert des deux fonctions précédentes.

def a_plus_b(a, b):
    return a + b

def a_moins_b(a, b):
    return a - b

u = a_plus_b(5,2)    # u est égal à 7
v = a_moins_b(5,2)    # v est égal à 3

print(u,v,sep=" ") # Affiche 7 3

Une fois qu'on a crée notre fonction on s'en sert...

Attention: on ne peut se servir que des lettres de l'alphabet, des chiffres et de l'underscore (_) pour nommer une fonction. De plus, le nom ne peut commencer que par une lettre. C'est comme avec les variables

def a_plus_b(a, b):
    return a + b  # (a+b)

def a_moins_b(a, b):
    return a - b  # (a-b)

# On se sert des deux fonctions précédentes
def a_carre_moins_b_carre(a, b):
    return a_plus_b(a,b) * a_moins_b(a,b)  # (a+b)(a-b)

resultat = a_carre_moins_b_carre(4,2)
print(resultat)    # Affiche 12

9. Listes et chaines

Les listes sont des tableaux dans lesquels on peut mettre plusieurs valeurs. Les valeurs sont séparées par des virgules. Toutes les valeurs de la liste sont comprises entre un crochet ouvrant et un crochet fermant.

1. Créer une liste vide

liste = []

liste = [1,2,3]

2. Créer une liste avec plusieurs valeurs

On peut ajouter des éléments à la fin de la liste grâce à la fonction append

liste = []
liste.append(1)
liste.append("yes")

print(liste)    # Affiche [1, "yes"]

On voit qu'il est possible de mélanger des éléments de types différents. On peut même faire rentrer une liste dans une liste.

3. Afficher les items d'une liste ou d'une chaîne

liste = ["e","p","s"]
print(liste[0])    # Affiche e

chaine = "abc"
print(chaine[0])    # Affiche a

On accède aux sous éléments d'une liste et d'une chaîne de la

même façon. Mais si les listes peuvent être modifiées, les chaînes ne peuvent pas.

3. Afficher les items d'une liste ou d'une chaîne

On accède aux éléments d'une liste (ou d'une chaine) grâce aux crochets. Les nombres entre les crochets, qui suivent le nom de la liste, expriment l'indice de la valeur à afficher.

liste = ["e","p","s"]
print(liste[2])    # Affiche s

liste[2] = "z"    # On change le 3ème élément

print(liste[2])    # Affiche z

chaine = "abc"
print(chaine[2])    # Affiche c

chaine[2] = "z"    # ERREUR !! On ne peut pas modifier

4. Supprimer les éléments d'une liste

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

del liste[1]    # 2ème élément on compte à partir de 0!

print(liste)    # Affiche ['a','c']

On peut supprimer un élément par sa valeur. Pour ça on utilise remove():

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

liste.remove("a")    # Ne marche que pour le 1er "a"...

print(liste)    # Affiche ['b','c']

5. Compter le nombre d'éléments (liste et chaines)

Pour compter le nombre d'éléments d'une liste on utilise la fonction pédefinie len():

liste = [1,2,3,5,10]
print(len(liste))    # Affiche 5

chaine = "Bonjour tout le monde !"
print(len(chaine))    # Affiche 23

6. Manipuler les listes et les chaînes

Voici quelques astuces pour manipuler les listes et les chaînes:

liste = [1, 10, 100, 250, 500]
print( liste[0] )    # Affiche 1

print( liste[-1] )    # Seulement le dernier élément
500

print( liste[-3:] ) # Les trois derniers
# [100, 250, 500]

liste[2:4] = [69, 70] # On peut même modifier !
print(liste)    # [1, 10, 69, 70, 500]

liste = [1, 10, 100, 250, 500]
print( liste[-2] )    # Seulement l'avant dernier: 250

print( liste[-2:] )    # A PARTIR de l'avant dernier
# [250, 500]

print( liste[1:3] )    # indice de 1(inclus) à 3(exclu)
# [10,100]

# ASTUCE liste[:4] c'est pareil que liste[0:4] ...

print( liste[:4] ) # indice de 0(inclus) à 4(exclu)
# [1, 10, 100, 250]

print( liste[0:4] ) # indice de 0(inclus) à 4(exclu)
# [1, 10, 100, 250]

# ASTUCE liste[2:] c'est pareil que liste[2:len(liste)]
print( liste[2:] )    # indice 2 jusqu'à la fin
# [100, 250, 500]

7. Copier une liste

Il existe deux manières de copier les listes. La plus simple fait appel à l'affectation (=) mais elle a l'inconvénient de propager toute modification de la copie sur l'ancienne liste...

liste = ["one","two","three","four","five"]

liste2 = liste # liste2 copie les valeurs de liste

liste2.remove("one") # On enlève "one" dans liste2

print(liste)  # En imprimant liste...
#
# Affiche ["two","free","for","five"] 
#
# On se rend compte que liste a perdu le même élément !

8. Copie disjointe d'une liste

Si on veut faire deux copies disjointes de la liste, on utilise l'une des notations qu'on a mise au point dans le chapitre sur la modification des listes, c'est-à-dire [:] :

print(liste)
# Affiche
# ["two","three","four","five"]

L3 = liste[:] # L3 Copie liste du 1er indice au dernier

print(L3)
# Affiche
# ["two","three","four","five"]

del L3[3] # Efface le 4ème élément de L3 ("five")
print(liste) # Affiche ["two", "three", "four", "five"]
print(L3) # Affiche ["two", "three", "four"]

9. Boucler sur les listes

Dans la boucle for... range associée à une liste et utilisée dans l'exemple ci-dessous, la variable i représente les indices de la liste. Chacun des liste[i] représente la valeur stockée pour chacun des indices (on commence à 0) :

liste = [1, 10, 100, 250, 500]

for i in range(len(liste)):
    print(i, liste[i], sep=" : ")

# Affiche chaque valeur de la liste accompagnée
# de son indice, séparés par  " : "

# 0 : 1
# 1 : 10
# 2 : 100
# 3 : 250
# 4 : 500

10. Deuxième boucle sur les listes

Lorsqu'on veut parcourir une liste (ou une chaîne de caractères) on peut se demander s'il est toujours utile d'accéder à l'indice des éléments...

Si ça n'est pas le cas on peut utiliser la boucle for pour boucler directement sur les valeurs de la liste et pas sur les indices, voici comment faire:

liste = [1, 10, 100, 250, 500]

for v in liste:
    print(v, end=" ")

# Pas de recours à range(len(...))
# On affiche directement les valeurs. Pas besoin d'indices !
# 1 10 100 250 500

11. Boucler sur les chaines

Les boucles sur les chaines obéissent au même principe:

chaine = "hello world!"
for lettre in chaine:
    print(lettre)

# Affiche chacune des lettres une par une - sans indices
# h
# e
# l
# l
# o
#
# w
# o
# r
# l
# d
# !

12. Transformer une liste en string

Pour "casser" une chaîne de caractères, c'est-à-dire pour la transformer en liste, on utilise une fonction prédéfinie:

La fonction split

Cette fonction s'utilise de la manière suivante:

ma_chaine = "Roger:DURAND:Strasbourg"
print(ma_chaine.split(":"))
# Affiche ['Roger', 'DURAND', 'Strasbourg']

ma_chaine2 = "Roger;DUPONT;Bordeaux"
print(ma_chaine2.split(";"))
# Affiche ['Roger', 'DUPOND', 'Bordeaux']

13. Trouver un item dans une liste

Le mot-clé de Python, in est très pratique pour tester si un élément appartient à une liste ou non :

On renvoie True si l'élément est dans la liste, False sinon.

Dans la console python, vous pouvez effectuer les tests suivants (attention ne recopiez pas ">>>" ce marquage est automatique et signifie que vous parlez à la console Python) :

>>> liste = [1,2,3,5,10]
>>> 3 in liste
True
>>> 11 in liste
False

10. Les fichiers

De nos jours la plupart des données avec lesquelles nous travaillons sont sous forme de fichiers (textes, documents, mp3, etc...), il est donc important de savoir manipuler ce format.

Les fichiers en Python sont lus lignes par lignes (ou caractères par caractères), en partant du début vers la fin.

De nombreuses techniques de manipulation existent...

1. Fichiers textes: introduction

Un fichier texte est un fichier qui peut être ouvert avec un éditeur de texte (par exemple avec le bloc notes de Windows). Les données stockées dans le fichier sont converties en chaînes de caractères pour être exploitées.

 f = open('Chemin_vers_fichier',mode)

Le premier argument est une chaîne de caractères contenant un chemin absolu ou relatif vers le fichier. Le second argument est aussi une chaine de caractères qui indique la manière dont le fichier va être utilisé.

2. Chemin absolu

Quand on décrit une cible (un fichier ou un répertoire) sous la forme d'un chemin absolu, on décrit la suite des répertoires menant au fichier, depuis le répertoire racine. Sous Windows, pour le répertoire racine on partira du nom de volume (C:\,D:\…).

Sous les systèmes Unix, ce sera depuis (/).

Par exemple, sous Windows, si on a un fichier nommé fic.txt, contenu dans un dossier test, lui-même présent sur le disque C:, le chemin absolu menant à notre fichier sera C:\test\fic.txt.

3. Chemin relatif

Quand on décrit la position d'un fichier grâce à un chemin relatif, cela veut dire que l'on tient compte du dossier dans lequel on se trouve actuellement.

Ainsi, si on se trouve dans le dossier C:\test et que l'on souhaite accéder au fichier fic.txt contenu dans ce même dossier, le chemin relatif menant à ce fichier sera tout simplement fic.txt.

Maintenant, si on se trouve dans C:, notre chemin relatif sera test\fic.txt.

4. Ouverture d'un fichier

Tout d'abord il faut ouvrir le fichier en Python. Pour ce faire, on utilise la fonction open. Elle prend deux paramètres:

Le chemin absolu ou relatif menant au fichier à ouvrir;
Le mode d'ouverture du fichier.

Les deux paramètres sont sous forme de chaînes de caractères. Voici les principaux modes:

'r': Ouverture en lecture (read).
'w': Ouverture en écriture (write). Le précédent contenu du fichier est écrasé. Si le fichier n'existe pas il est crée.
'a': Ouverture en ajout (append). On écrit à la fin du fichier sans écraser l'ancien contenu. Si le fichier n'existe pas il est crée.
'r+': Ouverture en lecture/ecriture.

5. Ouverture d'un fichier (2)

Dans l'exemple qui suit, le chemin relatif d'accès au fichier est représenté par le nom du fichier lui-même. On suppose donc qu'il est exactement dans le même dossier que celui où tourne le programme Python:

# Ouverture en lecture
mon_fichier = open("mon_fichier.txt","r")

# Ouverture en écriture
f = open("testFichier.txt","w")

# Ouverture en ajout
file = open("essai.txt","a")

Dans l'exemple ci-dessus: mon_fichier, f et file sont appelés descripteur de fichiers. Ce sont des intermédiaires qui servent à la manipulation du fichier que l'on vient d'ouvrir.

6. Fermeture d'un fichier

Pour fermer un fichier préalablement ouvert avec open, on utilise la fonction close. Attention, la fonction s'applique sur le descripteur de fichier précédemment crée ( séparé par un (.) ).

# Ouverture en lecture
mon_fichier = open("mon_fichier.txt","r")

# Fermeture
mon_fichier.close()

Tout l'intérêt consiste à faire des opérations entre l'ouverture et la fermeture mais vous êtes obligé de fermer le fichier sinon vos modifications ne sont pas prises en compte...

7. Ecriture dans un fichier

Ecrire dans un fichier se fait avec la méthode write appliquée au descripteur de fichier. Il prend en paramètres la chaîne à écrire. La fonction retourne une valeur qui est le nombre de caractères (ou d'octets ajoutés):

f = open("test.txt","w")
f.write("Chaine à ajouter\n")

# Ouvrez le fichier et...
# vous verrez la chaine apparaître

8. Lecture d'un fichier

La lecture se fait toujours à partir de la position courante.

Trois méthodes pour lire dans un fichier:

f.read(taille) lit et retourne taille caractères (octets), sous la forme d'une chaîne si le fichier est un fichier texte; f.read() (sans paramètres) lit retourne tout le contenu du fichier.
f.readline() retourne toute la ligne courante (fin de ligne incluse)
f.readlines() retourne le reste du fichier sous la forme d'une liste contenant un élément par ligne du fichier.

Si la fin du fichier est atteinte, il n'y a pas d'erreur. La chaine retournée par read et readline sera juste vide. La liste retournée par readlines sera juste vide.

Remarque: La chaine vide est identifiée par "" ou '' en Python et la liste vide par []

9. Exemples de lecture de fichier

On utilise la méthode readline pour lire une ligne du fichier ou pour lire les lignes du fichier une par une:

f = open('testFichier.txt', 'r')
# On lit la première ligne
ligne = f.readline()

# On teste si la fin du fichier est atteinte
while ligne != '':
    # On affiche la dernière ligne lue
    print(ligne)
    # On lit la suivante
    ligne = f.readline()
f.close()

10. Exemples de lecture de fichier (2)

On utilise readlines pour stocker toutes les lignes de notre fichier dans un tableau:

f = open('testFichier.txt', 'r')
# Lecture de toutes les lignes du fichier...
# ...et stockage de ces lignes dans un tableau
lignes = f.readlines()

f.close()

# On affiche la quatrième ligne du fichier
print(lignes[3])

10. Exemples de lecture de fichier (3)

On utilise read pour lire le fichier caractères par caractères ou alors pour tout lire d'un coup:

# Exemple 1: Compter le nombre de a dans un fichier
compteur = 0
f = open("test.txt", "r")
caractere = f.read(1)  # On lit un caractère
while caractere != '':  # Tant qu'on est pas à la fin
    if caractere == "a":  # Si le caractère c'est a
        compteur += 1  # On compte un de plus
    caractere = f.read(1)  # On lit le suivant

f.close()
print("Le nombre de 'a' dans le fichier est égal à: ", a)

# Exemple 2: Afficher tout le fichier
file = open("newfile.txt", "r")
text = file.read()
print(text)
file.close()

11. Jouons avec les fichiers

Quelques codes pour bien comprendre les manipulations de fichiers:

f = open("fichier.ext", "w") # Ouvre en écriture
f.write("bonjour")    # Ecrit bonjour dedans
f.close()    # Ferme le fichier
f = open("fichier.ext", "r") # Ouvre en lecture
f.read(3) # Lit les 3 premiers caractères: "bon"
a = f.read(4) 
# Lit les 4 caractères suivants "jour" 
# ET  les stocke dans une variable nommée a
f.close()    # Ferme le fichier
print(a)    # Affiche le résultat final

# Affiche "jour"

12. Jouons avec les fichiers (2)

Un dernier code pour bien comprendre les manipulations de fichiers:

f = open("test.ext","w")
f.write("une ligne\n")  # \n sert à sauter la ligne..
f.write("Une autre ligne\n")
f.write("unE dernière ligne\n")
f.write("en fait non\n")
f.close()

f = open("test.ext", "r+")  # Mode lecture/ecriture
f.readline()  # On lit toute la ligne
f.read(5)  # On lit 5 caractères
f.readline() # On lit le reste de la ligne
a = f.read(3)
# On lit 3 caractères qu'on stocke dans variable a
print(a)
# Affiche... :-) ?
f.close()