Pour aborder ce cours, la première grosse question à se poser est: Qu'est-ce que la programmation et pourquoi apprendre programmer?
La programmation consiste en l'écriture de programmes informatiques, appelés également codes, effectuant chacun un certain résultat. Ce résultat peut être divers. En effet, il peut simplement s'agir d'un nombre affiché par le code, ça peut également être un changement dans un fichier.
Un code consiste en un ensemble d'expressions et de statements:
<expression> <expression> <statement> <expression>
Un statement est un ligne de code ne calculant pas de résultat, à l'inverse d'une expression, qui calcule un résulat.
5 + 5 => expression sin(pi) + cos(pi) => expression affiche 5 => statement verifie 5 > 0 => statement
Chaque programme est écrit dans un langage informatique comprenant un vocabulaire, c'est à dire un ensemble de symboles et de mots clés ayant une action prédéterminée (par exemple en java: while, for, public, void, try, catch, assert,...) et un syntaxe propre au langage.
La programmation est une partie essentielle des sciences informatiques. Elle est présente partout sur un ordinateur, que l'ordinateur soit un ordinateur de bord d'une voiture, un serveur ou un portable, dont voici une courte liste comprenant certaines utilisations de la programmation:
Les exemples ci-dessus ne reprennent qu'une petite partie de ce que l'on peut faire avec la programmation. La programmation comporte d'innombrables applications que vous aborderez au fur et à mesure de votre apprentissage, de la simulation et la modélisation mathématique au machine learning et à l'IA
La fonction print permet d'afficher du texte dans la console.
La syntaxe est très simple, par exemple:
print("Hello World!")
Va imprimer le texte entre guillements (dans ce cas-ci: Hello World!) dans la console. À noter que les guillemets simple et double sont interchangable print('Hello World!') et print("Hello world!") ont le même effet.
Certain charactères doivent être précédés d'un backslash car autrement ils ont un effet spécifique
Il en existe d'autres, mais inutile de les connaître tous par cœur, ceux-ci sont les plus commun et lorsque quelque chose ne s'imprime pas correctement, essayez de mettre un backslash devant, il s'agit peut-être d'un autre charactère avec un effet spécifique. Entrainez vous en essayant d'imprimer dans la console le texte suivant
"Bonjour,Ceci "est" unetabulationMonsieur\Madame\\Au revoir"
# Essayez vous-même !
Il est possible bien sur d'en mettre plusieurs à la suite
print("Hello")
print("World")
print("!")
Auquel cas le résultat de chaque print sera sur une ligne séparée
D'autres possibilitées de la fonction print:
On peut séparer les textes qu'on veut print par des virgules, le résultat est qu'ils seront imprimés séparément avec un espace entre chaque texte:
print("Hello", "World", "!")
On peut changer ce qui est imrpimé à la fin du print. Par défaut il s'agit d'un retour à la ligne, mais on peut mettre autre chose:
print("Hello", end="\t")
print("World", end="!\n")
Voilà, vous conaissez maintenant les bases de la fonction print. Vous verrez plus tard certaines autre fonctionnalitées telles que ".format", mais même sans ça vous découvrirez bien vite à quel point il est pratique de pouvoir imprimer des choses dans la console.
Parfois, les programmeurs souhaites expliquer leur code, ou bien inclure des informations qui ne seront pas exécutées dans leurs fichier de code.
Pour cela, il est possible d'inclure des commentaires.
Il existe deux manières de faire des commentaires.
Tout d'abord les commentaires sur une seule ligne, qui vont transformer tout ce qui les suit dans la ligne en commentaire.
En python, ils commencent par le charactère #
Par exemple:
#commentaire
print("hello") #world
comme vous pouvez le voir, tout ce qui est après le # est ignoré.
Si le # se trouve entre guillemets, il ne commencera pas un commentaire, mais sera considéré comme un charactère comme un autre.
print("dièse: #") # Le # à l'intérieur du print est ignoré car il est entre guillemets
Toutefois bien que très pratique, ce type de commentaires ne transforme qu'une seule ligne en commentaire.
Pour faire un commentaire sur plusieurs lignes, il existe des commentaires multilignes, qui sont entourés de """ (trois guillemets, simple ou double)
Attention, il y a une limitation à ce type de commentaire: Il ne peuvent pas être sur la même ligne que du code.
"""ceci est un commentaire sur plusieurs lignes"""
Vous verrez que parfois ça peut être très sympa d'avoir du code avec des commentaires expliquant son fonctionnement. Les collègues/membres de groupe qui commentent leur code ont tendance à être plus appréciés.
Les operateurs logiques sont commes de operations arithmetic (+,-,*,/), dans le sens ou tu appliques les operateurs et il te calcule un resultat. Dans l'arithmetic on calcule des valeurs commes des nombres (1+1) tant dis que les operateurs logiques evaluent des booléens. Et le resultat est d'une operation logique est lui aussi un booléen.
Un booléen en python s'écrit True et False. True est vrai en anglais et False est faux.
Les operateurs logiques sont and, or, not. - X or Y: OU logique. Si X est True (donc vrai) on evalue le tous en tant que vrai sinon c'est la valeur de Y (soite True ou False). Donc il faut que au moins un des deux soit True pour être True
Les X et Y representent soite True ou False.
print(True and True) print(True or False) print(not True) print(not False or True) print(not (False) or True) print(15 or 16) # ceci provoque une erreur vu que les elements sont des nombres et pas des booléens.
On peut print les évaluations de cet façon. 15 or 16 ne s'effectue pas parcequ'il ne sont pas des booléens et on travaille avec des operateurs logique. print(not False or True) n'a pas le même résultat vu l'ordre des priorités. C'est comme dans les arithmetic ou il faut un certain ordre 1+2*3 equivaut 7 et non 9.
L'ordre de priorité est d'abord les or puis les and et finalement les not.
Ici des tables de vérité afin de mieux comprendre les operateurs logiques.
| Inputs | Output | |||
|---|---|---|---|---|
| X | Y | X or Y | X and Y | not Y |
| False | False | False | False | True |
| True | False | True | False | True |
| False | True | True | False | False |
| True | True | True | True | False |
Après avoir testé des instructions d'une façon linéaire : l'interpréteur exécutait au fur et à mesure le code saisi dans la console. Mais il ya moyen d'enrichir nos programmes en demandant à exécuter certaines instructions dans un cas, et d'autres instructions dans un autre cas.
Dans ce chapitre, nous parlerons des structures conditionnelles, qui vont permettre de réaliser des tests et d'aller plus loin dans la programmation.
Les conditions permettent d'exécuter une ou plusieurs instructions dans un cas, d'autres instructions dans un autre cas.
L'instruction if permet d'exécuter le code se trouvant en dessous de lui si la condition est validée.
La syntaxe de if est :
if condition: # instruction 1 # instruction 2 # ... # instruction N
Vous remarquez que les instructions apparetenant se déclenchant dans le cas où la condition est validée sont toutes indentées d'un cran en plus par rapport à l'indentation du if. Ces éléments d'avantages indentés appartiennent au bloc d'instruction de la condition et ne seront exécutés que si celle-ci est validée. Cela permet notamment de faire la différence entre du code devant s'exécuter dans tous les cas et du code qui ne s'exécutera que si la condition est validée.
Comme on apprend toujours mieux par l'exemple je vous propose d'exécuter le code suivant pour voir ce qu'il print puis de passer la condition de True à False et de relancer l'exécution pour observer le fonctionement de l'instruction.
if True:
print("Je suis dans la condition.")
print("Ceci est un test.")
A présent vous pouvez vous exercer sur une tâche réelle!
if True:
print("Je suis dans la condition.")
print("Ceci est un test.")
A présent vous pouvez vous exercer sur une tâche réelle!
Le mot-clé else, qui signifie « sinon » en anglais, permet de définir une première forme de complément à notre instruction if.
if condition: # instruction 1 else: # instruction 2
Le mot-clé elif,est une contraction de « else if », que l'on peut traduire très littéralement par « sinon si ». Avec celle-ci nous pouvons à présent avoir une forme complète pour nos conditions.
if condition 1: # instruction 1 elif condition 2: # instruction 2 else: # instruction 3
Avec toutes ces informations vous devriez pouvoir vous occuper de l'exercice suivant assez facilement:
Afin de gagner quelques lignes, des aménagements sont possibles:
# instruction 1 if condition else instruction 2
# Essayez vous-même !
En Python comme dans la majorité des langages de programmation, chaque valeur a un certain type. Il est en effet souvent important de savoir différencier un nombre d'un texte par exemple: on ne mélange pas les pommes et les poires...
Pour afficher le type d'une variable, on utilise type():
>>> type(5) <class 'int'> >>> type("hello") <class 'str'>
On peut donc voir que le type de la valeur 5 est int, ce qui signifie que 5 est un entier (integer en Anglais) et que le type de la donnée "hello" est str, une chaine de caractère (string en Anglais).
Évidemment, dépendant des données, ces types seront différents. En voici une liste non-exhaustive:
| Nom du type | Signification | Exemple |
|---|---|---|
| int | Nombre entier (integer en Anglais) | 12 |
| float | Nombre à virgule flottante | 3.14 |
| str | Chaine de caractère (string en Anglais) | "Bonsoir" |
| bool | Booléen (une expression qui est évaluée soit a True, soit à False) | 5 > 18 |
Il s'agit ici de types de données de base, il en existe bien évidemment beaucoup d'autres, certains qui vous seront présentés tout au long de ce cours.
Dans la suite de ce cours, nous utiliserons généralement le nom que Python donne aux types (i.e. on dira que 1 est un int plutôt qu'un entier).
Il est à noter que c'est sur base du type des données que Python peut déterminer si une opération est faisable ou non. En effet:
>>> "Le nombre que je préfère est le " + 5 TypeError: Can't convert 'int' object to str implicitly
Python nous dit en effet qu'on ne peut pas additionner directement un entier et une chaine de caractère. On dit en général que Python est un langage fortement typé, ce qui signifie que les types des données doivent être cohérents pour pouvoir réaliser des opérations sur celles-ci (comme c'est le cas ici).
Il est possible de convertir certaines valeurs d'un type en un autre type. On utilise pour cela le nom du type, suivi de la valeur entre parenthèses.
Par exemple, si on veut transformer l'entier 5 en nombre à virgule (c'est-à-dire 5.0), on fera:
>>> float(5) 5.0
On peut alors facilement faire le calcul qu'on voulait faire précédemment (appelé une concaténation de strings):
>>> "Le nombre que je préfère est le " + str(5) 'Le nombre que je préfère est le 5'
Bien entendu, on ne peut pas faire de conversions insensées, sous peine de provoquer une erreur:
>>> float("Du texte") ValueError: could not convert string to float: 'Du texte'
Jusqu'à maintenant, nous n'avons utilisé Python que pour faire des calculs comme une calculatrice pourrait le faire, et pour afficher les résultats de ces calculs. Cependant, après leur affichages, tous nos résultats sont perdus. Nous allons ici voir comment stocker les résultats de ces calculs (ou d'autres informations): les variables.
Ce concept se retrouve dans énormément de langages de programmation.
Qu'est-ce qu'une variable? Avant toute chose, il faut remettre en contexte certaines choses. Grosso modo, un ordinateur est comme une calculatrice très rapide avec une grande mémoire. On peut voir cette mémoire comme un ensemble de cases qui vont contenir différentes valeurs (qui peuvent varier). Les variables permettent de manipuler une ou plusieurs de ces cases de mémoires, et par conséquent, les valeurs qu'elles contiennent.
Note: ceci est une façon extrêmement simplifiée de voir un ordinateur.
On peut voir une variable comme une étiquette que l'ordinateur colle a une de ces cases de mémoire. De cette façon on pourra facilement demander à l'ordinateur d'y stocker une valeur ou de récupérer la valeur qui y est stockée.
Concrètement, on va créer une variable et lui donner une valeur de la façon suivante: nom_de_variable = valeur. Par exemple:
>>> a = 7
Ici, on a créé une variable appelée a et qui contient la valeur 7. D'un point de vue vocabulaire, on appelle a l'identificateur de la variable, ou plus simplement son nom, et 7 sa valeur. La création d'une variable est appelée une déclaration. Lui donner une valeur est une affectation.
Note: les espaces autour du symbole ``=`` sont facultatifs.
Nous ne sommes maintenant plus obligés de faire des calculs uniquement sur des valeurs en elles-mêmes! Notez qu'on peut rapprocher cela des notations mathématiques. Par exemple, on va ici calculer l'aire d'un rectangle quelles que soient sa largeur et sa hauteur:
>>> # On va d'abord déclarer la largeur et la hauteur >>> largeur = 5.5 >>> hauteur = 3.0 >>> # On calcule ensuite l'aire du rectangle >>> aire = largeur * hauteur
En changeant les valeurs de largeur et hauteur, on peut facilement calculer l'aire de différents rectangles sans avoir à réécrire la formule de l'aire.
Vous pouvez donc voir qu'on déclare et affecte une variable en utilisant le symbole =. On récupère (et utilise) ensuite sa valeur à partir de son nom.
Il est aussi possible d'affecter deux variables en une seule ligne, comme suit:
>>> largeur, hauteur = 5.5, 3.0 # `largeur` vaut 5.5 et `hauteur` 3.0
Bien sûr, si on essaye d'utiliser une variable non-déclarée, une erreur se produit:
>>> # La variable `non_declaree` n'a pas ete declaree >>> a = non_declaree + 1 NameError: name 'non_declaree' is not defined
Comme le mot "variable" nous le dit, il est possible de changer la valeur d'une variable. On appelle cette opération une réaffectation:
>>> # On declare une variable affectee a une certaine valeur >>> hello = "hello" >>> # On reaffecte la variable >>> hello = "bonjour"
Comme pour les données, une variable a (forcément) un type, qui correspond au type de sa valeur. On peut le retrouver exactement comme on l'a fait précédemment:
>>> age = 12 >>> type(age) <class 'int'> >>> hello = "Hi!" >>> type(hello) <class 'str'>
Les opérations entre différentes variables sont soumises aux mêmes règles que pour les valeurs, comme on peut le voir dans cet exemple:
>>> hello = "Hello, " >>> name = "Dave" >>> hello + name 'Hello, Dave' >>> number = 17 >>> hello + number TypeError: Can't convert 'int' object to str implicitly
À noter qu'une réaffectation peut changer le type d'une variable:
>>> var = 6.28 >>> type(var) <class 'float'> >>> var = "slt" >>> type(var) <class 'str'>
Il est évidemment très important de connaitre les règles et conventions qui régissent le monde des variables en Python. Vous ne voudriez pas que votre programme plante parce que vous auriez mal nommé une variable, ou pourrir votre réputation de programmeur en utilisant des noms de variables qui ne sont du gout de personne.
Pour être valide, une variable doit avoir un nom composé uniquement des caractères suivants:
Donc, variable, LOL et youpi_8 sont des noms de variables valides, tandis que 5eme, une variable, ou 5*3 n'en sont pas. Faites-y attention car utiliser un nom de variable invalide peut vous retourner des erreurs difficiles à comprendre:
>>> nom-invalide = 8 SyntaxError: can't assign to operator
Il est à noter qu'on déconseille d'utiliser des lettres accentuées dans vos noms de variables, car cela pourrait poser des problèmes d'encodage sous certains systèmes. En général, il est considéré comme bonne pratique de nommer ses variables en anglais (et donc sans accents).
Python fait aussi la différence entre des lettres majuscules et minuscules: variable, Variable, VARIABLE et VARiable sont donc considérées comme 4 variables différentes.
Il existe également un certain nombre de mots réservés par Python, et qui ne peuvent donc pas être des noms de variables. En voici une liste exhaustive:
| False | await | else | import | pass |
| None | break | except | in | raise |
| True | class | finally | is | return |
| and | continue | for | lambda | try |
| as | def | from | nonlocal | while |
| assert | del | global | not | with |
| async | elif | if | or | yield |
Il est interdit d'utiliser ces mots comme noms de variable. Le faire produira une erreur.
En Python, il existe enfin des conventions par rapport à la façon dont vous nommez vos variables. Cela signifie que vous n'êtes pas obligé de suivre ces conventions (ça ne provoquera pas d'erreur), mais que c'est considéré comme une bonne pratique (ça permettra aux autres de lire votre code plus facilement). Ces conventions s'appliquent quand le nom d'une variable est constituée de plusieurs mots.
Là où d'autres langages utilisent un format qu'on appelle le camelCase (où chaque mot sauf le premier a une majuscule), Python préfère qu'on nomme les variables en utilisant le snake_case (où les mots sont séparés par des underscores et n'ont pas de majuscules).
On nommera donc une variable plutôt my_great_variable que MYGREATVARIABLE ou maSuperVariable.
Vous pouvez lire la PEP8 sur le site officiel de Python (en anglais) pour plus d'informations.
Si on vous demandait d'ajouter 1 à la variable number préalablement déclarée (opération qu'on appelle une incrémentation), vous feriez sans doute ceci:
number = number + 1
Ce genre d'opération se fait très souvent en Python. On a donc créé des opérateurs qui nous permettent de l'écrire plus rapidement. Le code suivant fait la même chose que celui présenté ci-dessus:
number += 1
L'opérateur += permet d'ajouter un certain nombre à la variable. Des opérateurs similaires existent pour d'autres opérations:
| Opération | Opérateur |
|---|---|
| Addition | += |
| Soustraction | -= |
| Multiplication | *= |
| Division | /= |
| Division entière | //= |
| Modulo (reste) | %= |
| Puissance | **= |
De nouveau, les espaces autour de l'opérateur sont facultatifs.
Enregistrer des données est à la base de la programmation.
Dans ce chapitre, nous abordons plusieurs manières d'enregistrer une suite de données dans des variables.
Les chaînes de caractères couramment appelées strings, sont des variables qui contiennent du texte.
x = "Bonjour!"
On les appelles chaînes de caractères en français car on peut accéder à chacune des lettres individuellement. Grâce au '[]' on peut accéder à des lettres de la string, comme dans l'exemple qui suit:
x = "Je préfère Charles à Kim." print(x[1]) print(x[6])
Comme on peut le remarquer, x[1] affiche e. Ce qui nous indique bien que le compte des caractères d'une string commence toujours à 0. Par contre, si vous avez un peu expérimenté, vous avez remarqué qu'on peut aller dans les négatifs. Lorsqu'on va dans les négatif, on boucle sur la string. On a donc: print("ab"[-1]) qui va afficher b.
On peut également sélectionner des parties de string toujours avec les crochets.
x = "Je préfère Kim à Charles." print(x[11:14])
Ici, vous pouvez remarquer que la borne inférieure est comprise mais pas la borne supérieure. De plus, on a quelques cas particuliers qu'on va discuter ensemble:
On peut effectuer des opérations sur les strings. On peut les concaténer (mettre bout à bout) deux strings pour en avoir une nouvelle. On fait cela grâce à l'opération '+'.
print("Coucou" + " " + "Tanguy!")
On peut également comparer deux strings pour savoir si elles sont identique avec l'opérateur == (égal) ou != (différent).
print("Coucou" == "Cou" + "cou")
On peut aussi multiplier une string avec l'opérateur de multiplication:
print(5*"ha")
Voici un exercice pratique pour tester vos connaissance sur ce chapitre:
Les boucles constituent un moyen de répéter un certain nombre de fois des instructions de votre programme. Prenons un exemple simple, même s'il peut sembler un peu fastidieux : écrire un programme affichant la table de multiplication par 7, de 1 * 7 à 10 * 7.
print(" 1 * 7 =", 1 * 7) print(" 2 * 7 =", 2 * 7) print(" 3 * 7 =", 3 * 7) print(" 4 * 7 =", 4 * 7) print(" 5 * 7 =", 5 * 7) print(" 6 * 7 =", 6 * 7) print(" 7 * 7 =", 7 * 7) print(" 8 * 7 =", 8 * 7) print(" 9 * 7 =", 9 * 7) print("10 * 7 =", 10 * 7)
Le code est long alors qu'on se cantonne à 10 éléments, on pourrait vite se retrouver avec des fichiers de plusieurs centaines de lignes qui ne feraient pourtant rien d'intéressant…
Le résultat :
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 8 * 7 = 56 9 * 7 = 63 10 * 7 = 70
Précédemment, vous étiez obligés d'utiliser un compteur afin de modifier les variable sà votre disposition dans votre boucle, avec for vous allez pouvoir le faire plus élégamment.
L'instruction for travaille sur des séquences. Elle est en fait spécialisée dans le parcours d'une séquence de plusieurs données. Retenez juste ça pour le moment, on reviendra sur les séquences par la suite.
La syntaxe de for est :
for element in sequence: # instruction 1 # instruction 2 # ... # instruction N
En attendant que vous voyez les séquences, voilà un petit tuyau pour en générer une: la méthode range
for i in range(1, 11, 2):
print(i)
Vous remarquerez ques i prendra la valeur de un élément sur deux se trouvant entre 1 et 11 (non-inclus, attention aux bornes!) et ce sans qu'on doive l'incrémenter nous-même. Voilà de quoi s'assurer plus clair et élégant. Réessayons un exercice sur les boucles avec un for et un range à présent:
On a vu comment répéter une instructions plusieurs fois grâces aux boucles for et while. Il existe une autre manière pour traverser une liste d'éléments, il s'agit de l'itérateur.
Un itérateur nous donne une fontion 'magique' qui nous permet de parcourir une série d'éléments.
>>> x = iter([0, 2, 4]) >>> next(x) 0 >>> next(x) 2 >>> next(x) 4 >>> next(x) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration
Chaque fois qu'on appelle la méthode next, l'itérateur nous donne l'élément suivant. Si il n'y a plus d'élément, il envoie l'exception StopIteration.
La boucle for peut se servir des itérateurs pour donner les éléments un à un tout comme elle se sert de la méthode range. Mais on peut également utiliser une boucle while pour parcourir tous les éléments avec l'itérateur. Vous pouvez exécuter le code suivant et le modifier pour comprendre ce qu'il se passe.
x = iter([0, 1, 2, 3, 4, 5])
a = True
while(a):
try:
print(next(x))
except StopIteration:
a = False
Voici un exercice pratique pour comprendre comment l'utiliser.
La boucle suivante se retrouve dans la plupart des autres langages de programmation et porte le même nom. Elle permet de répéter un bloc d'instructions tant qu'une condition est vraie (while signifie « tant que » en anglais).
La syntaxe de while est :
while condition: # instruction 1 # instruction 2 # ... # instruction N
A présent voici un code servant à afficher les tables de multiplications. Dans l'exemple de base il s'agit de la table de 7 mais vous êtes libres de jouer avec.
nb = 7 # On garde la variable contenant le nombre dont on veut la table de multiplication
i = 0 # C'est notre variable compteur que nous allons incrémenter dans la boucle
while i < 10: # Tant que i est strictement inférieure à 10
print(i + 1, "*", nb, "=", (i + 1) * nb)
i += 1 # On incrémente i de 1 à chaque tour de boucle
Vous remarquerez l'utilisation d'une variable qui servira de compteur. Celui-ci permet à la fois d'évaluer l'état d'avancement de la boucle mais aussi dans le cas présent de participer au calcul des valeurs.
A présent, voyons un peu ce que vous avez compris en mettant un peu en pratique:
L'un des plus gros points d'attention repose bien entendu sur la condition employée dans la boucle, en fonction de celle-ci vous pourriez vous retrouver avec !6 au lieu !5 par exemple, il est donc important de prêter attention au moment de la définir.
Un autre point intéressant est qu'avec une bonne condition on peut limiter le nombre d'itérations afin d'arriver à une réponse. Il s'agit clairement de faire de l'optimisation de programme (ce qui n'est clairement pas le focus de ce chapitre mais ça méritait d'être noté).
Réessayez avec l'exercice suivant en tentant de réduire votre nombre d'itérations.
Actuellement, tout ce que vous faites imprime du texte dans la console ou sauve des informations dans des variables, mais rien n'est permanent.
Pour stocker des informations de manière permanente et pour pouvoir les récupérer plus tard il faut utiliser des fichiers.
La première chose à faire pour cela est ouvrir le fichier. En effet il n'est pas autorisé d'écrire ou de lire un fichier sans l'avoir ouvert au préalable.
Attention, après avoir ouvert un fichier, il faut le refermer!
Il existe une limite au nombre de fichier qui peuvent être ouvert simultanément, donc oublier de refermer les fichiers fera planter le programme plus tard.
Il y a deux méthodes principales pour ouvrir et fermer un fichier correctement:
with file_object as open("filename.txt"): # your code here # file_object contient le descripteur de fichier # le fichier n'est plus ouvert ici
À l'intérieur du block qui commence avec "with", le fichier "filename.txt" est ouvert et la variable "file_object" contient un objet (on reviendra sur les objets plus tard dans le cours) qui permet de faire des opérations sur le fichier, comme le lire ou écrire dedans.
Cette méthode (avec with) est pratique car il est impossible d'oublier de fermer le fichier. Il se ferme lorsqu'on sort du block d'indentation du with.
L'autre méthode est d'ouvrir et fermer le fichier explicitement.
file = open("filename.png") # n'importe quel type de fichier peut être ouvert, png, txt ou même sans aucune extension #your code here file.close() # le fichier n'est plus ouvert ici
De nouveau le fichier est stocké dans un objet (ici nommé "file").
Les fichiers peuvent être ouvert dans divers modes, dont le mode "read only", le more "write only" etc...
Par défaut, il sont ouvert en mode read only et il est donc impossible d'écrire dedans.
On peut ajouter un paramètre à la fonction "open()" pour changer le mode d'ouverture.
Example:
with file_object as open("filename.txt", "w"): #On a ajouté un "w" dans les paramètres de fonction # your code here # le fichier n'est plus ouvert ici
Le "w" mis comme deuxième paramètre dans la fonction open permet de l'ouvrir en mode "write only"
Les différent modes disponibles sont:
Les modes suivant dépendent de l'emplacement du curseur lorsqu'on ouvre le fichier. Le curseur correspond à l'endroit où on se trouve dans le fichier. Si le curseur est à la fin et qu'on fait un "write" on écrira à la fin du fichier. Les opérations commencent à l'emplacement du curseur.