Introduction au langage Python

Construire une liste

On peut générer une liste de lettres à partir d'une chaine de caractères, car ce sont des structures semblables (indexées, ordonnées...) :

>>> list('aeiou')
['a', 'e', 'i', 'o', 'u']

Pour générer une séquence d'entiers, il existe une fonction dédiée : range

Avec un seul argument entier, elle génère les entiers entre 0 inclus et cet entier exclu.

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Avec 2 arguments entiers, elle génère les entiers entre le premier inclus et le second exclu.

>>> list(range(5,10))
[5, 6, 7, 8, 9]

Avec 3 arguments entiers, le troisième impose l'intervalle entre chaque entier généré.

>>> list(range(5,10,2))
[5, 7, 9]

Exercice Construire les listes suivantes à l'aide des fonctions list et range.

>>> list(range(...))
[0, 3, 6, 9, 12, 15, 18]
>>> list(range(...))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Même si elle commence à 0, il faut l'indiquer pour avoir accès au troisième paramètre.

>>> list(range(0,20,3))
[0, 3, 6, 9, 12, 15, 18]

On peut utiliser des entiers négatifs.

>>> list(range(9,-1,-1))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Exercice Construire la liste des indices d'une liste donnée :

>>> lettres = list('Bonjour')
>>> ...
[0, 1, 2, 3, 4, 5, 6]
>>> lettres = list('Bonjour')
>>> list(range(len(lettres)))
[0, 1, 2, 3, 4, 5, 6]

Lire chaque valeur d'une liste

Si l'on souhaite lire, une par une, chaque valeur d'une liste, on peut utiliser une boucle, comme vue précédemment :

liste = ['Ligne 1', 'Ligne 2', 'Ligne 3']
i = 0
while i<len(liste) :
    print(liste[i])
    i = i+1

Comme c'est une opération très souvent utilisée, il existe une autre boucle, dédiée à cette usage : la boucle pour.

for valeur in ['Ligne 1', 'Ligne 2', 'Ligne 3'] :
    print(valeur)

Exercice Écrire une fonction de paramètre un entier et qui renvoie la liste des carrés parfaits compris entre 0 (inclus) et cet entier (exclu).

def carre(n):
    """ renvoie la liste des carrés parfaits entre 0 et n (exclu). """
    liste = []
    for valeur in range(n):  # Pas besoin de la fonction list ici
        liste.append(valeur**2)
    return liste

assert carre(3)==[0, 1, 4], "carre(3) doit renvoyer [0, 1, 4]"

Exercice Écrire une fonction qui calcule la moyenne des valeurs (supposées numériques) d’une liste.

>>> moyenne([10, 11, 12, 16])
12.25
def moyenne(liste):
    """ Renvoie la moyenne des valeurs de liste """
    somme = 0
    for valeur in liste :
        somme = somme + valeur
    return somme/len(liste)

Modifier chaque valeur d'une liste

Si l'on souhaite modifier, une par une, chaque valeur d'une liste, il suffit de la parcourir à partir de sa liste d'indices :

liste = ['Ligne 1', 'Ligne 2', 'Ligne 3']
for indice in range(len(liste)) :  
    liste[indice] = 'Ligne modifiée '+str(indice)

Exercice Écrire une fonction qui remplace chaque valeur entière d'une liste passée en paramètre, par son carré.

def carre(liste):
    """ Passe toutes les valeurs de liste au carré. """
    for i in range(len(liste)):
        liste[i] = liste[i]**2

Il faut faire très attention à ce genre de fonction. Comme il n'y a aucun retour, il semble que rien ne se soit passé, mais les valeurs de la liste auront bel et bien été modifiées !

On ne peut, normalement, pas modifier la valeur d'une variable définie en dehors d'une fonction :

a = [1, 2, 3]
                
def test(x):
    """ Les paramètres sont modifiables : pas les arguments. """
    # b = a  # ERREUR : a n'existe pas dans la fonction 
    a = [0]  # CORRECT : mais rien à voir avec le a extérieur à la fonction
    x = [0]  # CORRECT : mais ne change pas la variable a de l'appel

test(a)  
print(a)  # Affiche [1, 2, 3] : la fonction n'a rien changé.

Mais quand il s'agit d'une structure de données, comme une liste, le paramètre peut être utilisé pour obtenir la variable correspondante à une de ses données. Cette variable est alors modifiable, ce qui modifie bien quelque chose à l'extérieur de la fonction. 

a = [1, 2, 3]
                
def test(x):
    """ Les paramètres sont modifiables : pas les arguments. """
    x[0] = 7  # CORRECT : x permet d'accéder à la variable x[0]

test(a)
print(a)  # Affiche [7, 2, 3] (La fonction a bien modifié a)

Boucles bornées

On utilise une boucle bornée, quand on sait d'avance combien d'itérations sont à faire (tout un tableau, toutes les lettres d'une chaine de caractères, toutes les lignes d'un fichier ...). En python la boucle for permet de le faire en fournissant directement l'objet sur lequel itérer:

for element in iterateur:
    traitement(element)

En l'absence de structure de donnée, on utilise la fonction range pour numéroter chaque itération.

for i in range(5):  # i est souvent utilisé pour "indice"
    itération_numero(i)   # Exécuté 5 fois (i = 0, 1, 2, 3 puis 4)

Exercice Écrire une fonction, de paramètre une chaine de caractères, qui renvoie la même chaine de caractères dans laquelle chaque voyelle a été remplacée par une étoile.

>>> etoilev('minuscule')
'm*n*sc*l*'
def etoilev(mot):
    """ renvoie une chaine de caractère, copie de mot,
    dans laquelle chaque voyelle a été remplacée par une étoile. """
    voyelle = set('aeiouy')  # list('aeiouy') aussi bien
    reponse = ''
    for lettre in mot :
        if lettre in voyelle :
            lettre = '*'     # Peut être dangereux
        reponse = reponse + lettre
    return reponse

assert etoilev('minuscule')=='m*n*sc*l*', 'minuscule ne passe pas'

Pour s'entraîner

Exercice Écrire des fonctions permettant d’afficher les triangles d’étoiles suivants (de paramètre le nombre de lignes). 
  1. >>> triangle_gauche(7)
*
**
***
****
*****
******
*******
  2. >>> triangle_droite(3)
  *
 **
***
  3. >>> triangle_centre(5)
    *
   ***
  *****
 *******
*********
  4. >>> triangle_noel(6)
     *
    * *
   * * *
  * * * *
 * * * * *
* * * * * *
Exercice En lien : une feuille d'exercice à destination des première en NSI.
Exercice À partir des données ci-dessous, programmer le jeu du pendu. 
from random import choice
# Mots trouvés sur https://www.carredebaudouin.fr/mot-complique-pendu/
MOT = ['ACAJOU', 'ALEPHS', 'AZIMUT', 'BASSON', 'BURINE', 'CAIMAN', 'CERCLE', 
       'COCCYX', 'CORNEE', 'FAUCON', 'GOSPEL', 'GUENON', 'HORMIS', 'MENTHE', 
       'MULARD', 'NOTAIS', 'NOUAIS', 'PAGINE', 'PONTIL', 'SABORD', 'SEISME', 
       'WHISKY', 'YANKEE', 'ZIPPER']

def pendu(etape):
    return [r"""





───────""",r"""
   │
   │
   │
   │
   │
───┴───
""",r"""   ┌───
   │
   │
   │
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │
   │
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │   │
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │  /│
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │  /│\
   │
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │  /│\
   │  /
   │
───┴───""",r"""   ┌───┐
   │   │
   │   O
   │  /│\
   │  / \
   │
───┴───"""][etape]

# Tests :
print(choice(MOT))
print(pendu(5))

Navigation