@@ -0,0 +1,108 @@ | |||
Principes fondamentaux | |||
====================== | |||
Définition | |||
---------- | |||
Une liste est une *suite ordonnée* d'éléments. | |||
Créer une liste | |||
--------------- | |||
Avec des crochets: ``[``, ``]``, et les éléments séparés par des virgules:: | |||
liste_vide = [] | |||
trois_entiers = [1, 2, 3] | |||
Listes hétérogènes | |||
------------------ | |||
On peut mettre des types différents dans la même liste:: | |||
ma_liste = [True, 2, "trois"] | |||
On peut aussi mettre des listes dans des listes:: | |||
liste_de_listes = [[1, 2], ["Germaine", "Gertrude"]] | |||
Connaître la taille d'une liste | |||
------------------------------- | |||
Avec ``len()`` - encore une fonction native:: | |||
liste_vide = [] | |||
taille = len(liste_vide) | |||
print(taille) | |||
# affiche: 0 | |||
trois_entiers = [1, 2, 3] | |||
taille = len(trois_entiers) | |||
print(taille) | |||
# affiche: 3 | |||
Concaténation de listes | |||
----------------------- | |||
Avec ``+``:: | |||
prénoms = ["Alice", "Bob"] | |||
prénoms += ["Charlie", "Eve"] | |||
print(prénoms) | |||
# affiche: ['Alice', 'Bob', "Charlie", 'Eve'] | |||
On ne peut concaténer des listes que avec d'autres listes:: | |||
scores = [1, 2, 3] | |||
scores += 4 | |||
# erreur | |||
scores += [4] | |||
print(scores) | |||
# affiche: [1,2,3,4] | |||
Test d'appartenance | |||
------------------- | |||
Avec ``in``:: | |||
prénoms = ["Alice", "Bob"] | |||
print("Alice" in prénoms) | |||
# affiche: True | |||
prénoms = ["Alice", "Bob"] | |||
print("Charlie" in prénoms) | |||
# affiche: False | |||
Modifier une liste | |||
------------------- | |||
Encore une assignation:: | |||
fruits = ["pomme", "orange", "poire"] | |||
fruits[0] = "abricot" | |||
print(fruits) | |||
# affiche: ["abricot", "orange", "poire"] | |||
Indéxer une liste | |||
------------------ | |||
* Avec ``[]`` et un entier | |||
* Les index valides vont de 0 à ``n-1`` où ``n`` est la | |||
taille de la liste:: | |||
fruits = ["pomme", "orange", "poire"] | |||
print(fruits[0]) | |||
# affiche: "pomme" | |||
print(fruits[1]) | |||
# affiche: "orange" | |||
print(list[2]) | |||
# affiche: "poire" | |||
fruits[3] | |||
# erreur: IndexError | |||
@@ -0,0 +1,76 @@ | |||
Itération | |||
========= | |||
Itérer sur les éléments d'une liste | |||
------------------------------------ | |||
Avec les mots-clés ``for`` et `` in``:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
# Chaque élément de la liste est assigné tour à tour | |||
# à la variable 'prénom" | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Bob | |||
Bonjour Charlie | |||
break | |||
----- | |||
Comme pour les boucles `while`, on peut interrompre la boucle `for` avec `break`:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
if prénom == "Bob": | |||
break | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Charlie | |||
continue | |||
-------- | |||
On peut interrompre l'exécution *du bloc courant* (et uniqument le | |||
bloc courant) avec le mot-clé ``continue``:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
if prénom == "Bob": | |||
continue | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Charlie | |||
Indéxer une liste | |||
------------------ | |||
* Avec ``[]`` et un entier | |||
* Les index valides vont de 0 à ``n-1`` où ``n`` est la | |||
taille de la liste:: | |||
fruits = ["pomme", "orange", "poire"] | |||
print(fruits[0]) | |||
# affiche: "pomme" | |||
print(fruits[1]) | |||
# affiche: "orange" | |||
print(list[2]) | |||
# affiche: "poire" | |||
fruits[3] | |||
# erreur: IndexError | |||
@@ -0,0 +1,40 @@ | |||
Relation avec les strings | |||
========================= | |||
Les strings sont aussi des listes (presque). | |||
On peut itérer sur les caractères d'une string:: | |||
for c in "vache": | |||
print(c) | |||
.. code-block: console | |||
v | |||
a | |||
c | |||
h | |||
e | |||
On peut tester si un caractère est présent:: | |||
print("e" in "vache") | |||
# affiche: True | |||
print(x" in "vache") | |||
# affiche: False | |||
Mais on ne peut pas modifier une string:: | |||
prénom = "Charlotte" | |||
l = prénom[0] | |||
print(l) | |||
# affiche: "C" | |||
l = prénom[3] | |||
print(l) | |||
# affiche: "r" | |||
prénom[0] = "X" | |||
# erreur: TypeError |
@@ -0,0 +1,48 @@ | |||
Listes et booléens | |||
================== | |||
Falsy et truthy | |||
---------------- | |||
Si on met une liste vide, ``if`` se comportera comme si on avait mis une valeur fausse, et si | |||
la liste n'est pas vide , ``if`` se comportera comme si on avait mis une valeur vraie.:: | |||
ma_liste = [1, 2, 3] | |||
if ma_liste: | |||
print("ma_liste n'est pas vide") | |||
# affiche: ma_liste n'est pas vide | |||
mon_autre_liste = [] | |||
if not mon_autre_liste: | |||
print("mon_autre_liste est vide") | |||
# affiche: mon_autre_liste est vide | |||
On dit que les listes vides sont *Falsy* et les listes non-vides *Truthy* | |||
Test d'appartenance | |||
------------------- | |||
On peut tester si un élément est dans une liste avec le mot-clé ``in``:: | |||
prénoms = ["Alice", "Bob"] | |||
print("Alice" in prénoms) | |||
# affiche: True | |||
prénoms = ["Alice", "Bob"] | |||
print("Charlie" in prénoms) | |||
# affiche: False | |||
Comparaisons de listes | |||
----------------------- | |||
On peut utiliser l'opérateur ``==`` avec deux listes de part et | |||
d'autres. Les listes seront considérées comme égales si | |||
* Elles ont la même taille | |||
* Tous leurs éléments sont égaux un à un en respectant l'ordre:: | |||
[1] == [2] # False | |||
[1, 2] == [2, 1] # False | |||
[1, 2] == [1, 2] # True | |||
@@ -0,0 +1,50 @@ | |||
Exercice | |||
======== | |||
Le but de l'exercice est d'implémenter le jeu du pendu. | |||
Voila à quoi une session de jeu doit ressembler: | |||
.. code-block:: text | |||
______ | |||
entrer une lettre | |||
e | |||
_____e | |||
entrer une lettre | |||
a | |||
_a___e | |||
entrer une lettre | |||
u | |||
_au__e | |||
entrer une lettre | |||
q | |||
_au__e | |||
entrer une lettre | |||
c | |||
_auc_e | |||
entrer une lettre | |||
h | |||
_auche | |||
entrer une lettre | |||
g | |||
gauche | |||
Gagné | |||
Consignes | |||
--------- | |||
* Télécharger les fichiers ``pendu.py`` et ``mots.txt`` | |||
* S'assurer que le code fonctionne en lançant ``python3 pendu.py`` | |||
* À ce stade, vous devriez constater plusieurs problèmes: | |||
* Au lieu d'avoir un mot au hasard, le mot à deviner est toujours "accord" | |||
* Au lieu d'afficher un indice, le code affiche une liste de tentatives | |||
* Le jeu est impossible à gagner parce que la fonction `a_gagné` renvoie toujours False | |||
Le but de l'exercice est de corriger ces 3 problèmes. | |||
@@ -1,232 +1,14 @@ | |||
Chapitre 6 - Listes | |||
=================== | |||
Définition | |||
---------- | |||
.. toctree:: | |||
:maxdepth: 1 | |||
Une liste est une *suite ordonnée* d'éléments. | |||
./01-bases.rst | |||
./02-iteration.rst | |||
./03-strings.rst | |||
./04-booléens.rst | |||
./05-exercice.rst | |||
Créer une liste | |||
--------------- | |||
Avec des crochets: ``[``, ``]``, et les éléments séparés par des virgules:: | |||
liste_vide = [] | |||
trois_entiers = [1, 2, 3] | |||
Listes hétérogènes | |||
------------------ | |||
On peut mettre des types différents dans la même liste:: | |||
ma_liste = [True, 2, "trois"] | |||
On peut aussi mettre des listes dans des listes:: | |||
liste_de_listes = [[1, 2], ["Germaine", "Gertrude"]] | |||
Connaître la taille d'une liste | |||
------------------------------- | |||
Avec ``len()`` - encore une fonction native:: | |||
liste_vide = [] | |||
taille = len(liste_vide) | |||
print(taille) | |||
# affiche: 0 | |||
trois_entiers = [1, 2, 3] | |||
taille = len(trois_entiers) | |||
print(taille) | |||
# affiche: 3 | |||
Concaténation de listes | |||
----------------------- | |||
Avec ``+``:: | |||
prénoms = ["Alice", "Bob"] | |||
prénoms += ["Charlie", "Eve"] | |||
print(prénoms) | |||
# affiche: ['Alice', 'Bob', "Charlie", 'Eve'] | |||
On ne peut concaténer des listes que avec d'autres listes:: | |||
scores = [1, 2, 3] | |||
scores += 4 | |||
# erreur | |||
scores += [4] | |||
print(scores) | |||
# affiche: [1,2,3,4] | |||
Test d'appartenance | |||
------------------- | |||
Avec ``in``:: | |||
prénoms = ["Alice", "Bob"] | |||
print("Alice" in prénoms) | |||
# affiche: True | |||
prénoms = ["Alice", "Bob"] | |||
print("Charlie" in prénoms) | |||
# affiche: False | |||
Itérer sur les éléments d'une liste | |||
------------------------------------ | |||
Avec les mots-clés ``for`` et `` in``:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
# Chaque élément de la liste est assigné tour à tour | |||
# à la variable 'prénom" | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Bob | |||
Bonjour Charlie | |||
break | |||
----- | |||
Comme pour les boucles `while`, on peut interrompre la boucle `for` avec `break`:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
if prénom == "Bob": | |||
break | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Charlie | |||
continue | |||
-------- | |||
On peut interrompre l'exécution *du bloc courant* (et uniqument le | |||
bloc courant) avec le mot-clé ``continue``:: | |||
prénoms = ["Alice", "Bob", "Charlie"] | |||
for prénom in prénoms: | |||
if prénom == "Bob": | |||
continue | |||
print("Bonjour", prénom) | |||
.. code-block:: text | |||
Bonjour Alice | |||
Bonjour Charlie | |||
Indéxer une liste | |||
------------------ | |||
* Avec ``[]`` et un entier | |||
* Les index valides vont de 0 à ``n-1`` où ``n`` est la | |||
taille de la liste:: | |||
fruits = ["pomme", "orange", "poire"] | |||
print(fruits[0]) | |||
# affiche: "pomme" | |||
print(fruits[1]) | |||
# affiche: "orange" | |||
print(list[2]) | |||
# affiche: "poire" | |||
fruits[3] | |||
# erreur: IndexError | |||
Modifier une liste | |||
------------------- | |||
Encore une assignation:: | |||
fruits = ["pomme", "orange", "poire"] | |||
fruits[0] = "abricot" | |||
print(fruits) | |||
# affiche: ["abricot", "orange", "poire"] | |||
Les strings sont aussi des listes (presque) | |||
-------------------------------------------- | |||
On peut itérer sur les caractères d'une string:: | |||
for c in "vache": | |||
print(c) | |||
.. code-block: console | |||
v | |||
a | |||
c | |||
h | |||
e | |||
On peut tester si un caractère est présent:: | |||
print("e" in "vache") | |||
# affiche: True | |||
print(x" in "vache") | |||
# affiche: False | |||
Mais on ne peut pas modifier une string:: | |||
prénom = "Charlotte" | |||
l = prénom[0] | |||
print(l) | |||
# affiche: "C" | |||
l = prénom[3] | |||
print(l) | |||
# affiche: "r" | |||
prénom[0] = "X" | |||
# erreur: TypeError | |||
Falsy et truthy | |||
---------------- | |||
En réalité on peut mettre autre chose qu'une comparaison ou une variable booléenne après le if. | |||
Si on met une liste vide, ``if`` se comportera comme si on avait mis une valeur fausse, et si | |||
la liste n'est pas vide , ``if`` se comportera comme si on avait mis une valeur vraie.:: | |||
ma_liste = [1, 2, 3] | |||
if ma_liste: | |||
print("ma_liste n'est pas vide") | |||
# affiche: ma_liste n'est pas vide | |||
mon_autre_liste = [] | |||
if not mon_autre_liste: | |||
print("mon_autre_liste est vide") | |||
# affiche: mon_autre_liste est vide | |||
On dit que les listes vides sont *Falsy* et les listes non-vides *Truthy* | |||
Comparaisons de listes | |||
----------------------- | |||
On peut utiliser l'opérateur ``==`` avec deux listes de part et | |||
d'autres. Les listes seront considérées comme égales si | |||
* Elles ont la même taille | |||
* Tous leurs éléments sont égaux un à un en respectant l'ordre:: | |||
[1] == [2] # False | |||
[1, 2] == [2, 1] # False | |||
[1, 2] == [1, 2] # True |
@@ -0,0 +1,241 @@ | |||
accord | |||
affaire | |||
agent | |||
aide | |||
amour | |||
appel | |||
arbre | |||
argent | |||
arme | |||
attention | |||
avenir | |||
avion | |||
avis | |||
balle | |||
bateau | |||
besoin | |||
bois | |||
bonheur | |||
bonjour | |||
bord | |||
bouche | |||
boulot | |||
bout | |||
bras | |||
bruit | |||
bureau | |||
camp | |||
capitaine | |||
carte | |||
cause | |||
chambre | |||
chance | |||
chat | |||
chef | |||
chemin | |||
cheval | |||
cheveu | |||
chien | |||
choix | |||
chose | |||
ciel | |||
classe | |||
client | |||
coin | |||
colonel | |||
compte | |||
confiance | |||
copain | |||
corps | |||
couleur | |||
coup | |||
cour | |||
courant | |||
cours | |||
cuisine | |||
dame | |||
dent | |||
dieu | |||
docteur | |||
doigt | |||
dollar | |||
doute | |||
droit | |||
droite | |||
effet | |||
endroit | |||
enfant | |||
ennemi | |||
envie | |||
erreur | |||
escalier | |||
esprit | |||
exemple | |||
face | |||
faim | |||
fait | |||
famille | |||
faute | |||
femme | |||
fille | |||
film | |||
fils | |||
fleur | |||
flic | |||
fois | |||
fond | |||
force | |||
forme | |||
front | |||
garde | |||
gars | |||
gauche | |||
genre | |||
gens | |||
geste | |||
gosse | |||
gouvernement | |||
grand | |||
groupe | |||
guerre | |||
gueule | |||
habitude | |||
haut | |||
heure | |||
histoire | |||
homme | |||
honneur | |||
image | |||
impression | |||
instant | |||
jambe | |||
jardin | |||
joie | |||
jour | |||
journal | |||
langue | |||
lettre | |||
lieu | |||
ligne | |||
livre | |||
long | |||
madame | |||
main | |||
maison | |||
maman | |||
marche | |||
mari | |||
mariage | |||
matin | |||
merci | |||
merde | |||
milieu | |||
million | |||
minute | |||
mois | |||
moment | |||
monde | |||
monsieur | |||
mort | |||
mouvement | |||
moyen | |||
musique | |||
noir | |||
nouveau | |||
nuit | |||
odeur | |||
oeil | |||
oiseau | |||
ombre | |||
oncle | |||
ordre | |||
oreille | |||
paix | |||
papa | |||
papier | |||
parent | |||
parole | |||
part | |||
partie | |||
passage | |||
patron | |||
pays | |||
peau | |||
peine | |||
personne | |||
petit | |||
peuple | |||
peur | |||
photo | |||
pied | |||
pierre | |||
place | |||
plaisir | |||
plan | |||
poche | |||
point | |||
police | |||
porte | |||
pouvoir | |||
premier | |||
prince | |||
prison | |||
prix | |||
professeur | |||
propos | |||
putain | |||
quartier | |||
question | |||
raison | |||
rapport | |||
regard | |||
reste | |||
retard | |||
retour | |||
revoir | |||
robe | |||
route | |||
salle | |||
salut | |||
sang | |||
seconde | |||
secret | |||
seigneur | |||
semaine | |||
sens | |||
sentiment | |||
service | |||
seul | |||
signe | |||
silence | |||
situation | |||
soeur | |||
soir | |||
soldat | |||
soleil | |||
sorte | |||
sourire | |||
souvenir | |||
suite | |||
sujet | |||
table | |||
temps | |||
terre | |||
tour | |||
tout | |||
train | |||
travail | |||
travers | |||
trou | |||
truc | |||
type | |||
vent | |||
ventre | |||
verre | |||
vieux | |||
village | |||
ville | |||
visage | |||
voiture | |||
voix | |||
voyage |
@@ -0,0 +1,50 @@ | |||
import random | |||
def lire_mots(): | |||
fichier = open("mots.txt") | |||
contenu = fichier.read() | |||
fichier.close() | |||
mots = contenu.splitlines() | |||
return mots | |||
def choisir_mot_au_hasard(mots): | |||
taille = len(mots) | |||
index = random.randint(0, taille) | |||
return mots[0] | |||
def jouer(): | |||
mots = lire_mots() | |||
mot = choisir_mot_au_hasard(mots) | |||
# pour débugger, il faudra enlever cet | |||
# appel à print une fois le code terminé | |||
print("Le mot à deviner est", mot) | |||
tentatives = [] | |||
while True: | |||
afficher_indice(mot, tentatives) | |||
lettre = demander_lettre() | |||
if lettre not in tentatives: | |||
tentatives += [lettre] | |||
if a_gagné(mot, tentatives): | |||
print(mot) | |||
print("Gagné") | |||
break | |||
def a_gagné(mot, tentatives): | |||
return False | |||
def demander_lettre(): | |||
print("entrer une lettre") | |||
lettre = input() | |||
return lettre | |||
def afficher_indice(mot, tentatives): | |||
print("tentatives", tentatives) | |||
jouer() |