Une liste se déclare avec des crochets et on accède à une donnée par son indice.
>>> langages = ["python", "C#","java","C++"]
>>> print(langages[1])
C#list.append(val) → Ajoute la valeur à la fin de la liste
list.insert(index, val) → Ajoute la valeur à l'index indiqué
list.extend(liste) → Ajoute les éléments d'une liste à la liste
list.remove(val) → Supprime le premier élément de la liste égal à val. Si l'élément n'existe pas, une exception ValueError est levée
list.clear(val) → Supprime tous les éléments de la liste
list.pop(index (optionnel)) → Supprime l'élément à l'index indiqué. Sans indication, supprime le dernier élément.
list.index(val) → Renvoi l'index correspondant à la valeur donnée
list.count(val) → Renvoi le nombre d'éléments correspondants à val
list.sort() → Trie la liste
list.reverse() → Inverse l'ordre des éléments de la liste
Pour parcourir une liste il suffit d'écrire une boucle for var in list :
>>> langages = ["python", "C#","java","C++"]
>>> for prog in langages:
>>> print(prog, "est cool")
python est cool
C# est cool
java est cool
C++ est coolLes tuples ressemblent à des listes mais ne sont pas modifiables après leur création. Ils sont définis avec des parenthèses :
>>> tup = (1,2,3)
>>> tup
(1, 2, 3)Comme pour les listes, on peut accéder à un élément par son indice :
>>> tup[1]
2Les tuples servent principalement à attribuer plusieurs valeurs :
####EXEMPLE 1#######
>>> tup = (1,2,3)
>>> a,b,c = tup
>>> a
1
>>> b
2
>>> c
3
####EXEMPLE 2#######
>>> a, b = 1, 2 #dans ce cas, les parenthèses ne sont pas obligatoires
>>> a
1
>>> b
2
####EXEMPLE 3#######
def example():
return 1,2 #ceci est un tuple
tup = example()
a, b = example()
>>> tup
(1, 2)
>>> a
1
>>> b
2Les dictionnaires permettent eux aussi de rassembler des éléments mais sont identifiés par une clé au lieu d'un indice, et vont permettre de traiter beaucoup plus d'informations qu'une liste. Un dictionnaire se déclare avec des accolades.
dictio = {"title": "Modèles de voitures", "SUV": ["CX-5","C-HR","Duster"], "4x4": ["Q5","Tucson","Macan"]}
Note : Les éléments entre crochets sont des listes. Il est possible de déclarer des listes dans un dictionnaire, et même des dictionnaires dans un dictionnaire, un dictionnaire dans une liste, ...
Dans cet exemple nous avons trois clés : “title”, “SUV” et “4x4”.
Pour ajouter un élément au dictionnaire, on attribue une clé entre crochets puis une valeur.
>>> dictio["citadine"] = "C3"
>>> print(dictio)
{'title': 'Modèles de voitures', 'SUV': ['CX-5', 'C-HR', 'Duster'], '4x4': ['Q5', 'Tucson', 'Macan'], 'citadine': 'C3'}Pour connaître le titre nous appelons le dictionnaire avec la clé entre crochets :
>>> dictio["title"]
'Modèles de voitures'Pour accéder à une valeur d'une liste, il suffit d'indiquer l'indice en fonction de la clé :
>>> dictio["SUV"][1]
'C-HR'Pour parcourir l'ensemble du dictionnaire on utilise la méthode items().
for cars in dictio.items():
print(cars)
('title', 'Modèles de voitures')
('SUV', ['CX-5', 'C-HR', 'Duster'])
('4x4', ['Q5', 'Tucson', 'Macan'])
('citadine', 'C3')On reconnait ici une forme de tuple ! On peut donc aussi attribuer 2 variables à la place de cars pour dissocier la clé et la valeur :
for car_type, models in dictio.items():
if car_type != "title": #Pour exclure l'élément "title"
print("Modeles de ",car_type," : ",models)
Modeles de SUV : ['CX-5', 'C-HR', 'Duster']
Modeles de 4x4 : ['Q5', 'Tucson', 'Macan']
Modeles de citadine : C3
Le format json n'est rien d'autre qu'un dictionnaire. Pour lire un fichier json il suffira alors de le charger et nous obtiendrons le même dictionnaire que nous avions créé.
Contenu du fichier “voitures.json” :
{
"title": "Modeles de voitures",
"SUV":
[
"CX-5","C-HR","Duster"
],
"4x4":
[
"Q5","Tucson","Macan"
]
}On importe ce fichier et le convertit en dictionnaire :
import json
with open('voitures.json') as file: #Fonctionne pour tout type de fichier.
data = json.load(file) #On attribue le contenu du fichier au dictionnaire "data"
>>> data
{'title': 'Modeles de voitures', 'SUV': ['CX-5', 'C-HR', 'Duster'], '4x4': ['Q5', 'Tucson', 'Macan']}Options d'ouvertures de fichiers :
| ‘r’ | Ouvre en lecture seule |
| ‘w’ | Ouvre en écriture, en effaçant le contenu du fichier |
| ‘x’ | Ouvre en création exclusive. Échoue si le fichier existe déjà |
| ‘a’ | Ouvre en écriture, en ajoutant le contenu à la fin (append) |
Pour ouvrir un fichier on utilise la méthode “open” et on spécifie l'option souhaitée.
file = open('test.txt','r')
[...]
file.close()Avec cette méthode il est nécessaire de fermer le fichier avec close(). En cas de problème pendant l’exécution du code, les modifications ne seront pas prises en compte et le fichier ne sera plus utilisable par la suite du script.
Une méthode plus fiable, plus sécurisée sera donc d'utiliser open() avec with. Le fichier sera automatiquement fermé.
with open('test.txt','r') as file:
[...]
Attention : On voit les deux points à la fin de la ligne. Cela implique donc d'indenter les lignes suivantes.
Info : Pour donner le chemin vers le fichier il faut des “ / “ et non des ” \ ". Ex : C:/mondossier/monfichier
Pour lire un fichier texte, on l'ouvre bien entendu avec l'option ‘r’, puis on peut :
with open('test.txt','r') as file:
print(file.read())
ligne 1
ligne 2
ligne 3Le premier readline() lira la première ligne, le deuxième la deuxième ligne, etc…
with open('test.txt','r') as file:
print(file.readline())
print(file.readline())
ligne 1
ligne 2Avec cette méthode, il faut répéter readline() autant de fois qu'il y a de lignes. La méthode la plus efficace sera d'utiliser une boucle for :
with open('test.txt','r') as file:
for ligne in file:
print(ligne)
ligne 1
ligne 2
ligne 3with open('test.txt','r') as file:
print(file.readlines())
['banane\n', 'fraise\n', 'chocolat'] #Les \n indiquent des retours à la ligne
Enfin, pour écrire dans un fichier texte, on utilise write().
with open('test.txt','a') as file:
file.write("\nligne 4")