Introduction à Python

Commençons par lancer l’interpréteur Python que nous avons installé lors du chapitre précédant:

(workshops) ~$ python
Python 3.5.2+ (...)
Type "copyright", "credits" or "license" for more information.

>>>

Avant d’entrer python, nous entrions nos commandes sur la ligne de commande du système d’exploitation.

L’invite de ligne de commande (aussi appelée “prompt”) était ~$. Une fois la commande python entrée, l’invite de commande a changé et est désormais >>>. Cela signifie qu’à partir de maintenant, nous devons uniquement utiliser des commandes du langage Python.

Les commandes telles que cd ou mkdir ne fonctionneront pas. Il est temps d’apprendre un nouveau langage !

Nous ne taperons pas les signes >>> (de la même manière que pour ~$), l’interpréteur python le fera pour nous.

Commençons par additionner deux nombres:

>>> 2 + 2
4

Python est une super calculatrice:

>>> 6 * 7
42
>>> 1252 - 38 * 6
1024
>>> (3 - 5) * 7
-14
>>> 21 / 7
3.0
>>> 3**2
9
>>> 5 / 2
2.5

Faites bien attention lorsque vous entrez des nombres à virgules, utilisez des points comme séparateurs, et non pas des virgules. Les virgules nous seront utiles plus tard, pour définir des tuple, mais nous y reviendrons.

Le temps des présentations

Chaînes de caractères (Strings)

Les nombres ne sont pas suffisants pour communiquer de manière efficace, nous avons donc besoin d’utiliser des chaînes de caractères (aussi appelées strings).

Voici quelques exemples:

>>> "Bonjour tout le monde"
'Bonjour tout le monde'
>>> 'Foo Bar'
'Foo Bar'
>>> "Rock 'n' Roll"
"Rock 'n' Roll"
>>> 'Mon nom est "Camille"'
'Mon nom est "Camille"'

Vous pouvez également ajouter (on dit également concaténer) deux chaînes l’une à l’autre:

>>> 'Mon nom est ' + '"Camille"'
'Mon nom est "Camille"'

Ou elles peuvent être aussi multipliés par des nombres:

>>> 'oui ' * 3
'oui oui oui '

Une chaîne de caractères doit toujours commencer et se terminer par le même caractère. Il peut s’agir d’un guillemet simple ('), ou d’un guillemet double ("). Cela n’a aucun effet sur la valeur de la chaîne de caractères. Par exemple, si nous entrons "Batman", nous créons une chaîne de caractères Batman, les guillemets ne font pas partie de la chaîne de caractères, ils sont là uniquement pour indiquer qu’il s’agit d’une chaîne de caractères (string) (malheureusement, Python n’est pas suffisamment brillant pour se rendre compte de ça lui-même).

Afficher les chaînes de caractères

Mais, comment afficher ces chaînes de caractères d’une manière lisible ? Il est possible de le faire en utilisant la fonction print().

>>> print("Bonjour tout le monde !")
Bonjour tout le monde !

Il est aussi possible d’afficher différentes chaînes de caractères sur une même ligne, sans avoir à les ajouter l’une à l’autre. Elles seront séparées par des espaces:

>>> print("Bonjour, mon nom est", "Camille")
Bonjour, mon nom est Camille

La fonction print() peut être utilisée de différentes manières, puisqu’elle peut écrire à peu près n’importe quoi. Pour l’instant, le seul type de valeurs que nous connaissons sont les nombres:

>>> print(1)
1
>>> print(1, 2, 3)
1 2 3
>>> print("2 + 2 =", 2 + 2)
2 + 2 = 4

Et voilà, nous avons terminé d’utiliser la console interactive de Python pour l’instant. Pour sortir, entrez quit():

>>> quit()

Ou tapez Ctrl+D pour Linux ou Ctrl+Z pour Windows.

Fichiers de code source Python

Jusqu’à présent nous avons exécuté du code dans l’invite de commande interactive dans laquelle nous récupérons une réponse immédiate à nos commandes. C’est un bon moyen d’apprendre et d’expérimenter les éléments du langage. C’est pourquoi on y retourne.

Notre premier programme pourrait ressembler à ça:

print("Hi, my name is Lucas")

Enregistrez ce programme dans un fichier appelé visitingcard.py, et lancez-le depuis l’invite de commande python visitingcard.py:

(workshops) ~$ python visitingcard.py
Hi, my name is Lucas
(workshops) ~$

Un même programme peut contenir plusieurs commandes, chacune devant être sur une ligne séparée, par exemple:

print("Hi,")
print()

print("my name is Lucas")

print()
print("Bye.")

Nous pouvons ajouter des lignes vides où nous le souhaitons dans le fichier visitingcard.py pour améliorer la lisibilité. Ici, nous avons séparé l’entête du message d’avec son contenu et d’avec sa fin.

Envoyer du Morse grâce à Python

Essayons de créer un programme simple permettant d’envoyer des signaux en Morse.

En cas d’urgence et de panique liée à cet ordinateur, vous pouvez avoir besoin d’envoyer un signal de détresse.

Le signal de détresse, S.O.S (Save Our Soul) est en effet le signal le plus connu pour communiquer sa situation critique par la lumière ou par le son.

Il est utilisé par les bateaux et par les naufragé•e•s en situation de détresse.

Nous allons pour notre part commencer à afficher des signaux morse depuis le terminal. En commencant par notre fameux signal de détresse S.O.S.

Pour écrire un S.O.S en morse :

S.O.S va se traduire en morse par (... --- ...) soit 3 signaux courts suivis de 3 signaux longs.

Le S est donc égal à ... et le O à ---

Nous connaissons déjà la fonction print() (pour afficher des choses).

Nous allons donc créer un ‘’‘programme’‘’ qui stocke les deux lettres et leur équivalent en morse dans des ‘’‘variables’‘’.

Pour commencer, créez un fichier morse.py puis écrivez à l’intérieur le programme suivant :

print("... --- ...")

Lancez votre programme comme ceci:

$ python morse.py

Vous obtenez:

... --- ...

Comme vous le voyez notre programme a besoin de quelques améliorations :

Si quelqu’un souhaite envoyer un autre message que “S.O.S”, nous devons modifier le fichier morse.py.

Programmer c’est l’art de résoudre les problèmes, alors mettons nous au travail !

Cela va nous donner l’occasion d’apprendre de nouvelles fonctionnalités de Python.

Variables

Pour commencer nous aimerions bien rendre notre programme plus lisible, pour permettre au lecteur de savoir immédiatement quel code morse correspond à quelle lettre (... correspond à “S” et --- correspond à “O”).

C’est pourquoi nous donnons des noms à ces valeurs:

s = "..."
o = "---"
print(s, o, s)

Le résultat n’a pas changé:

... --- ...

Note

On utilise l’opérateur + qui sert à concaténer (coller) deux chaines de caractères entre elles. Tapez par exemple dans votre console Python:

>>> "Bonjour" + " a tous et a toutes"
'Bonjour a tous et a toutes'

Pour mieux comprendre le fonctionnement des variables, revenons à l’invité de commande (aussi nommée “console”) Python et essayons d’en créer quelques-unes :

>>> x = 42
>>> PI = 3.1415
>>> name = "Amelia"
>>> print("Quelques valeurs:", x, PI, name)
Quelques valeurs: 42 3.1415 Amelia

Une variable peut être vue comme une boite portant une étiquette :

• Elle contient quelque chose (on dit que la variable contient une valeur)
• Elle a un nom (comme l’inscription sur l’étiquette de la boite)

Deux variables (ayant des noms différent) peuvent contenir la même valeur :

>>> y = x
>>> print(x, y)
42 42

Ici les deux variables ont pour noms y et x (se sont les étiquettes sur les boites) et elles contiennent la même valeur : 42

On peut également modifier la valeur d’une variable (changer le contenu de la boite). La nouvelle valeur n’a pas besoin d’être du même type (nombre entier, nombre décimal, texte ...) que la précédente :

>>> x = 13
>>> print(x)
13
>>> x = "Scarab"
>>> print(x)
Scarab

Les variables sont indépendantes les unes des autres. Si on modifie la valeur de x, la valeur de y reste la même :

>>> print(y)
42

Nous pouvons également mettre le résultat de calculs ou d’opérations dans des variables et utiliser ensuite ces variables comme alias de la valeur dans d’autres calculs.

>>> s = "..."
>>> o = "---"
>>> aidez_moi = s + o + s
>>> print(aidez_moi)
...---...

À noter qu’une fois que la valeur est calculée, elle n’est pas modifiée :

>>> s = "@"
>>> print(aidez_moi)
...---...

Sauf si on demande à Python de la recalculer :

>>> aidez_moi = s + o + s
>>> print(aidez_moi)
@---@

Il est grand temps d’ajouter quelques commentaires à notre programme afin de faciliter la compréhension pour les lecteurs-trices (dont nous faisons partie).

Les commentaires nous permettent de rajouter du texte dans notre code Python. Les commentaires seront simplement ignorés par l’interpréteur Python lors de l’exécution du code.

En Python, un commentaire est tout ce qui se trouve entre un caractère # et la fin de la ligne:

# Code Morse du "S"
s = "..."

# Code Morse du "O"
o = "---"

aidez_moi = s + o + s # Code Morse pour "S.O.S"
print(aidez_moi)

Les fonctions

Notre programme n’est pas trop mal, mais si l’utilisateur-trice souhaite pouvoir envoyer plusieurs S.O.S, ou bien réutiliser ce bout de programme sans dupliquer trop de lignes, il va falloir empaqueter notre fonctionnalité dans ce qu’on appelle : une fonction.

Une fonction, c’est un mini moteur, un groupe d’instructions qui prend des données en entrée, execute les instructions (calcule) en utilisant (ou pas) les données en entrée et renvoie (ou pas) un résultat en sortie.

En Python, on définie une fonction comme suit:

def nom_de_la_fonction(argument1, argument2):
    # les instructions à executer
    # les instructions peuvent utiliser les arguments
    # pour retourner un résultat il faut utiliser le mot clef "return"
    # Si la fonction ne retourne rien, "return" est optionel
    return 42

Pour executer cette fonction (on dit “appeller” la fonction):

nom_de_la_fonction(argument1, argument2)

Pour récupérer la valeur de retour (résultat, sortie) de la fonction dans une variable:

ma_variable = nom_de_la_fonction(argument1, argument2)

Notre première fonction va se contenter d’imprimer notre signal de détresse.

On crée donc la fonction et on l’appelle à la fin du fichier:

def print_sos():
    s = "..."
    o = "---"
    print(s + o + s)

print_sos()

Note

On remarque qu’ici notre fonction ne prend aucun argument et ne renvoie aucune valeur (pas de mot clef return).

J’ai maintenant une fonction toute simple que je peux appeler à plusieurs reprises juste en duplicant l’appelle print_sos().

On peut aussi vouloir découper le signal et signifier que notre mot est terminé On va donc ajouter une nouvelle variable “stop” pour découper le mot et ainsi savoir quand le mot est terminé:

def print_sos():
    s = "..."
    o = "---"
    stop = "|"
    print(s + o + s + stop)

print_sos()

On peut encore simplifier notre code en remarquant que s contient 3 points et o contient 3 tirets. Il se trouve qu’on peut dupliquer une chaine de caractères en utilisant la syntaxe suivante:

>>> "hello" * 2
'hellohello'

On peut donc obtenir "..." en faisant "." * 3:

def print_sos():
    s = "." * 3
    o = "-" * 3
    stop = "|"
    print(s + o + s + stop)

print_sos()

Si maintenant on veut afficher plusieurs SOS, on peut écrire autant de fois que nécessaire print_sos() à la fin du fichier. Mais les informaticien•ne•s sont flemmard•e•s et la machine est là pour nous éviter de refaire la même chose et faire le travail répétitif et ennuyeux.

On a besoin de dire à la machine combien de fois on veut imprimer notre SOS. On va donc modifier la fonction et lui passer le nombre de fois que l’on veut imprimer le signal S.O.S en argument:

def print_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    print((s + o + s + stop) * nb)

print_sos(3)

Ce qui donne:

$ python morse.py
...---...|...---...|...---...|

Pour qu’on puisse mieux lire les différents S.O.S et visualiser la fin de la phrase on va lui ajouter un retour à la ligne (\n):

def print_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    print((s + o + s + stop + "\n") * nb)

print_sos(3)

Ce qui donne lorsqu’on execute morse.py:

$ python morse.py
...---...|
...---...|
...---...|

On a donc une fonction qui prend en entrée le nombre de fois que l’on veut emettre le signal SOS.

Pour l’instant elle ne se contente que d’afficher.

Si on veut rendre ce programme encore plus facile à utiliser, imaginons par exemple que nous ayons un robot qui transforme le . et le - en sons différents, ou une machine qui allume et éteigne une lampe plus ou moins longtemps ; on peut vouloir que cette fonction retourne la chaine de caractère du message à transmettre sans l’afficher dans le terminal.

On pourra ensuite mettre cette chaine dans une variable et la passer en argument à une autre fonction dont le rôle sera d’émettre du son ou d’allumer une lampe.

On va donc demander à la fonction de retourner (via return) le message morse et donc on va changer le nom de la fonction de print_sos à emit_sos:

def emit_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    return (s + o + s + stop) * nb

emit_sos(5)

Cette fois-ci lorsqu’on execute notre programme, plus rien n’est affiché.

Mais rassurez-vous, on peut toujours vérifier que cela fonctionne en modifiant la dernière ligne en:

print(emit_sos(5))

En effet, emit_sos() retourne une chaine de caractère que print() va afficher.

On a donc créé une fonction réutilisable, et que l’on peut greffer à d’autre comme par exemple emettre un son

play(emit_sos(5))

ou encore allumer et éteindre un phare

flash(emit_sos(5))

Mais avant de gérer les phares et cassez les oreilles des autres, nous allons plutôt interagir avec notre machine à S.O.S et nous familiariser avec elle.

Un peu d’interactivité avec l’utilisateur•trice serait le bienvenu, par exemple demander à l’utilisateur•trice de rentrer au clavier le nombre de fois qu’il faut afficher le SOS.

Nous allons utiliser la fonction input() de Python 3.

La fonction input() laisse l’utilisateur•trice taper un message (terminé par l’appui sur la touche Entrée) puis retourne la chaine de caractère qui a été tapée:

>>> input()
Bonjour à toutes et à tous
'Bonjour à toutes et à tous'

Le résultat peut bien sûr être stocké dans une variable afin de l’utiliser par la suite:

>>> message = input()
Ceci est un test
>>> print("Vous avez tapé : " + message)
Vous avez tapé : Ceci est un test

Essayons maintenant de l’intégrer à notre machine à SOS:

def emit_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    return (s + o + s + stop) * nb

print("Entrez le nombre de S.O.S que vous voulez: ")
nb_sos = input()
print(emit_sos(nb_sos))

Voici ce que le programme donne une fois executé:

$ python morse.py
Entrez le nombre de S.O.S que vous voulez:
5
Traceback (most recent call last):
  File "morse.py", line 9, in <module>
    print(emit_sos(nb_sos))
  File "morse.py", line 5, in emit_sos
    return (s + o + s + stop) * nb
TypeError: can't multiply sequence by non-int of type 'str'

Ceci est une erreur Python (on dit une exception). L’erreur vient du fait que la fonction input() retourne une chaine de caractères et non pas un nombre entier. En Python, "5" est différent de 5, le premier est une chaine de caractères et le deuxième est un entier:

>>> type("5")
<class 'str'>
>>> type(5)
<class 'int'>

Note

La fonction type() permet d’afficher le type d’une expression.

Pour convertir notre chaîne de caractères en entier, nous allons utiliser la fonction int():

>>> a = "5"
>>> a
'5'
>>> int(a)
5

Voici le code corrigé:

def emit_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    return (s + o + s + stop) * nb

print("Entrez le nombre de S.O.S que vous voulez: ")
nb_sos = int(input())
print(emit_sos(nb_sos))

Une fois lancé:

$ python morse.py
Entrez le nombre de S.O.S que vous voulez:
5
...---...|...---...|...---...|...---...|...---...|

Les conditions

En avant vers notre prochaine problématique.

Maintenant on a une machine à émettre des S.O.S autant de fois qu’on le désire. Mais il faut faire attention, trop de S.O.S pour faire imploser le bateau ou faire sauter l’élecricité ou encore simplement rendre fou le capitaine.

On va donc prévenir le lanceur de S.O.S s’il dépasse la limite autorisée. On va modifier notre fichier morse.py pour ajouter des précautions d’usage:

def emit_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    return (s + o + s + stop) * nb

print("Entrez le nombre de S.O.S que vous voulez: ")

nb_sos = int(input())
# Et maintenant nous allons vérifier que
# l'utilisateur n'abuse pas en nombre de sos
# si ... alors
if nb_sos == 0:
    print("Pas de S.O.S pour toi donc.")
# ou si ... alors
elif nb_sos > 10:
    print("Trop de SOS ! Stoppez ça s'il vous plait ! " +
          "Vous allez casser la machine !")
# sinon alors
else:
    print(emit_sos(nb_sos))

Maintenant l’utilisateur a peut être VRAIMENT un problème, il faut quand même envoyer un signal. On va donc quand même envoyer le signal mais en respectant la limite:

# si ... alors
if nb_sos == 0:
    print("Pas de S.O.S pour toi donc.")
# ou si ... alors
elif nb_sos > 10:
    print("Trop de SOS ! Stoppez ça s'il vous plait ! " +
          "Vous allez casser la machine ! Relais de 10 S.O.S")
    print(emit_sos(10))
# sinon alors
else:
    print(emit_sos(nb_sos))

L’utilisateur de la machine à S.O.S maintenant qu’il est prevenu peu informer de l’urgence de sa situtation en fonction du nombre de S.O.S qu’il envoie:

Nombre de S.O.S	Type de Signal	Signification
< 5	Avarie mineure	on rentre au port rapidemment
5 – 12	Avarie moyenne	patrouille de reconnaissance demandée
≥ 12	Avarie majeure	envoi immédiat des forces d’interventions

Exercice : Ecrire une fonction qui va afficher le type de signal en fonction du nombre de S.O.S envoyé (n’oubliez pas de prendre en compte s’il n’y a pas de signal)

Pour aller plus loin

Quand l’utilisateur demande plus de 10 S.O.S, vous pouvez avoir envie de lui redemander le nombre de S.O.S à envoyer. Pour cela, on peut créer une fonction pour lui redemander à l’infini tant qu’il ou elle ne respecte pas la règle maximale de 10 S.O.S :

def emit_sos(nb):
    s = "." * 3
    o = "-" * 3
    stop = "|"
    return (s + o + s + stop) * nb


def ask_for_sos():
    print("Combien de S.O.S voulez-vous ?")

    nb_sos = int(input())

    # Et maintenant nous allons vérifier que l'utilisateur n'abuse pas en nombre de sos
    if nb_sos == 0:
        print("Pas de S.O.S pour toi donc.")
    # ou si ... alors
    elif nb_sos > 10:
        print("Trop de SOS ! Stoppez ça s'il vous plait ! " +
              "Choisissez un nb en 1 et 10!")
        ask_for_sos()
    # sinon alors
    else:
        print(emit_sos(nb_sos))

ask_for_sos()

Conditions : vrai ou faux

La première chose dont nous n’avons pas encore parlé sont les conditions. Pour les nombres, cela fonctionne exactement comme en mathématiques :

>>> 2 > 1
True
>>> 1 == 2
False
>>> 1 == 1.0
True
>>> 10 >= 10
True
>>> 13 <= 1 + 3
False
>>> -1 != 0
True

Le résultat d’une condition est toujours True ou False. On peut utiliser les opérateurs and et or pour construire des conditions plus complexes:

>>> x = 5
>>> x < 10
True
>>> 2 * x > x
True
>>> (x < 10) and (2 * x > x)
True
>>> (x != 5) and (x != 4)
False
>>> (x != 5) and (x != 4) or (x == 5)
True

Indentation

Une deuxième chose à laquelle il faut faire attention en Python, c’est l’indentation du code.

Ouvrez l’interpreteur Python et entrez une combinaison simple, par exemple:

>>> if 2 > 1:
...

Pour l’instant rien ne se passe, comme le montrent les points ... à la place des habituels chevrons >>>. Python s’attend à ce que nous donnions des instructions complémentaires qui devront être exécutées si la condition 2 > 1 s’avère vraie. Essayons d’afficher “OK”:

>>> if 2 > 1:
... print("OK")
  File "<stdin>", line 2
    print("OK")
        ^
IndentationError: expected an indented block

Apparemment, ça n’a pas très bien fonctionné. En fait Python doit savoir si l’instruction que nous avons entrée est une instruction à exécuter uniquement si la condition est vraie ou si c’est une instruction à exécuter sans qu’elle ne soit affectée par la condition.

C’est pourquoi nous devons indenter notre code:

>>> if 2 > 1:
...  print("OK")
...
OK

Tout ce que vous devez faire c’est ajouter un espace ou une tabulation avant votre instruction pour dire qu’elle fait partie des instructions dépendantes du if. Attention, toute les lignes a exécuter dans le if doivent être indentées de la même manière:

>>> if -1 < 0:
...  print("A")
...   print("B")
  File "<stdin>", line 3
    print("B")
    ^
IndentationError: unexpected indent

>>> if -1 < 0:
...     print("A")
...   print("B")
  File "<stdin>", line 3
    print("B")
            ^
IndentationError: unindent does not match any outer indentation level

>>> if -1 < 0:
...   print("A")
...   print("B")
...
A
B

Pour éviter la confusion, la plupart des développeurs Python se sont mis d’accord pour toujours utiliser quatre espaces pour chaque niveau d’indentation. Nous allons nous aussi adopter cette convention:

>>> if 2 > 1:
...     if 3 > 2:
...         print("OK")
...     else:
...         print("ECHEC")
...     print("FAIT")
OK
FAIT

Et si ce n’est pas le cas ?

On pourrait se débrouiller pour écrire un programme en utilisant uniquement des if

if nb_sos < 5:
    print("Avarie Mineure")
if nb_sos >= 5:
    if nb_sos < 12:
        print("Avarie Moyenne")
if nb_sos >= 12:
    print("Avarie Majeure")

Mais en fait, on peut aussi utiliser else et elif, afin de ne pas avoir à répéter les conditions similaires et améliorer la lisibilité du code. Dans des programmes plus compliqués, il n’est parfois pas évident de reconnaître que la condition lue est la condition inverse de la précédente.

En utilisant else , nous avons la garantie que les instructions données seront exécutées seulement si les instructions données après le if n’ont pas été exécutées:

if nb_sos < 5:
    print("Avarie Mineure")
else:
    # Si votre programme exécute ces instructions alors vous êtes
    # certains que nb_sos >= 5 !
    if nb_sos < 12:
        print("Avarie Moyenne")
    else:
        # Ici vous pouvez être certains que nb_sos >= 12
        # nous n'avons donc pas à le vérifier.
        print("Avarie Majeure")

Regardez bien attentivement la manière dont le code est indenté. À chaque utilisation de else, un niveau d’indentation a été ajouté à chaque niveau du code. C’est très ennuyeux d’avoir à lire du code avec de nombreux niveaux d’indentation.

C’est pourquoi les développeurs Python on ajouté un troisième mot clé, elif, qui permet de vérifier directement une autre condition.

if n < 1:
    # Si n est inférieur à un.
    print("inferieur à un")
elif n < 2:
    # Si est supérieur ou égal à un, et inférieur à deux.
    print("entre un (compris) et deux")
elif n < 3:
    # Si n est supérieur ou égal à un,
    # que n est supérieur ou égal à deux,
    # et que n est inférieur à 3
    print("entre deux et trois")
else:
    # Si aucune des conditions précédentes n'est vérifiée
    print("supérieur ou égal à trois")

Tuples

Nous savons déjà que nous pouvons concaténer des chaînes de caractères, les multiplier par des nombres, vous allez voir qu’on peut aussi les formater. Tout d’abord, nous avons besoin de découvrir un nouveau type de données (en plus des strings et des nombres, int et float, que nous connaissons déjà).

Rappelez-vous, je vous disais que nous ne pouvions pas utiliser les virgules dans les nombres car nous en aurions besoin par la suite pour définir les tuples. Nous y voici

>>> 1, 2, 3
(1, 2, 3)
>>> ("Ala", 15)
('Ala', 15)
>>> x = 1,5
>>> print(x)
(1, 5)

Un tuple n’est ni plus ni moins qu’une valeur contenant un groupe de valeurs. Les valeurs que nous souhaitons grouper doivent être séparées par des virgules. L’ensemble peut-être entouré de parenthèses pour rendre plus explicite le fait qu’il s’agisse bien d’un groupe, mais ce n’est pas obligatoire. Sauf pour le cas d’un groupe vide (aussi bizarre que cela puisse paraître).

>>> ()
()

Il est possible de combiner des tuples:

>>> names = ("Pauline", "Dupontel")
>>> details = (27, 1.70)
>>> names + details
('Pauline', 'Dupontel', 27, 1.7)

Un tuple peut aussi contenir un autre tuple, par exemple un point sur une carte peut-être groupé comme ceci:

>>> point = ("Pizzeria", (long, lat))

Avec long et lat des coordonnées géographiques.

On peut ensuite se référer aux valeurs d’un groupe en utilisant leurs positions (en commençant à zéro):

>>> p = (10, 15)
>>> p[0]  # première valeur
10
>>> p[1]  # deuxième valeur
15

En résumé

Dans ce chapitre nous avons appris les bases de la syntaxe Python. Nous avons découvert comment afficher des nombres entiers et décimaux, des chaînes de caractères et nous avons découvert les tuples.

Nous avons appris à utiliser la fonction print(), qui affiche des informations à l’utilisateur et la fonction input(), qui permet de lire les entrées de ce dernier.

Nous avons vu comment l’identation pouvait être importante, notamment lors de l’utilisation des instructions if, else et elif.

Nous avons réalisé notre premier programme dans un fichier que nous pouvons lancer.

Notre programme pose quelques questions à l’utilisateur, calcule des informations et présente les résultats dans une forme utile à l’utilisateur.

Ça fait finalement beaucoup de choses pour un premier programme. Nous avons encore pas mal de travail mais vous pouvez être fier de ce que vous avez fait jusqu’à présent !