Introduction au langage Python

Introduction

Suite au test re gravité réalisé avec pyxel : une autre activité sous capytal, reprennat ce thème avec le module P5.

Activité d899-3344809

Structures de données

Il est parfois utile de pouvoir rassembler plusieurs informations sous une forme unique (à l'aide d'une seule variable en informatique). Par exemple : On peut définir de telles structures avec des crochets [], des accolades {} ou des parenthèses () et en séparant les valeurs par des virgules ,.
>>> chemin = ["1ère droite", "Tout droit", "Tout droit", "2ème droite", "1ère droite"]
>>> voyelle = {'A', 'E', 'I', 'O', 'U', 'Y'}
>>> notes = {'DS1' : 12, 'DS2' : 11, 'DS3' : 13}
>>> A = (3,-1)
>>> B = (5,-2,3)
Elles se différencient par leurs caractéristiques :

Liste Une liste est une structure de données indexée par des indices entiers consécutifs commençant à 0, ordonnée par ces indices et mutable.

Elle est définie en python à l'aide de crochets : ma_liste = [2, 4, 6]


indice012
valeur246

Par comparaison,

Il existe bien d'autres structures. Par exemple, un tableau est une structure de données mutable indexée et ordonnée comme une liste, mais dont on impose à chaque élément d'être de même type et dont on ne peut pas changer la taille.

Exercice Quelles sont les caractéristiques de la structure de donnée : chaine de caractères ?

Une chaine de caractères est une structure de données indexée, ordonnée, non mutable (comme un tuple) dont chaque valeur est un caractère.

Parties d'une liste

Partons de :
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']

C'est à dire :

Indices 0 1 2 3 4 5 6 7
'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h'
Tranches 0 1 2 3 4 5 6 7 8

On peut lire une valeur d'une liste, ou en extraire une sous-liste, comme on le fait pour un caractère d'une chaine :

>>> liste[3]
'd'
>>> liste[2:5] 
['c', 'd', 'e']

On peut se servir de la même notation pour modifier une partie de la liste :

Indices 0 1 2 3 4 5 6 7
'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h'
>>> liste[5] = 'z'  # liste[5] se comporte comme une variable
>>> liste
['a', 'b', 'c', 'd', 'e', 'z', 'g', 'h']
'a' 'b' 'c' 'd' 'e' 'z' 'g' 'h'
Tranches 0 1 2 3 4 5 6 7 8
>>> liste[0:5] = ['x', 'y']  # remplacer
>>> liste
['x', 'y', 'z', 'g', 'h']
'x' 'y' 'z' 'g' 'h'
Tranches 0 1 2 3 4 5
>>> liste[3:5] = []  # supprimer
>>> liste
['x', 'y', 'z']
'x' 'y' 'z'
Tranches 0 1 2 3
>>> liste[2:2] = ['et']  # insérer
>>> liste
['x', 'y', 'et', 'z']

Exercice Quelle(s) commande(s) permetent d'échanger la première et la dernière valeur d'un tableau ?

Par exemple :

>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> tmp = liste[0]
>>> liste[0] = liste[len(liste)-1]
>>> liste[len(liste)-1] = tmp

On peut simplifier, python acceptant des indices négatifs :

Indices 0 1 2 3 4 5 6 7
Indices -8 -7 -6 -5 -4 -3 -2 -1
'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h'
>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> tmp = liste[0]
>>> liste[0] = liste[-1]
>>> liste[-1] = tmp

Par affectation parallèle :

>>> liste = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
>>> liste[0], liste[-1] = liste[-1], liste[0]

Opérateurs

L'utilisation de fonctions et d'opérateurs se fait également comme avec les chaines de caractères :

>>> len(['a', 'b', 'c', 'b'])  # Longueur
4
>>> 'b' in ['a', 'b', 'c', 'b']  # Appartenance
True
>>> ['a', 'c'] + ['y', 'z']  # Concaténation
['a', 'c', 'y', 'z']
>>> ['t', 'o'] * 2
['t', 'o', 't', 'o']

Exercice Réécrire la fonction suivante, sans utiliser in.

def appartient(valeur, liste):
    """ Renvoie True ou False si valeur est un élément de liste ou non. """
    return valeur in liste

En passant toutes les valeurs en revue :

def appartient(valeur, liste):
    """ Renvoie True ou False si valeur est un élément de liste ou non. """
    app = False
    i = 0
    while i<len(liste) :
        app = app or liste[i]==valeur
        i = i + 1
    return app

Si on cherche à s'arrêter dès qu'on trouve la valeur :

def appartient(valeur, liste):
    """ Renvoie True ou False si valeur est un élément de liste ou non. """
    app = False
    i = 0
    while i<len(liste) and not app:
        app = app or liste[i]==valeur
        i = i + 1
    return app

Que l'on peut encore réduire :

def appartient(valeur, liste):
    """ Renvoie True ou False si valeur est un élément de liste ou non. """
    i = 0
    while i<len(liste) and liste[i]!=valeur:
        i = i + 1
    return i<len(liste)

Méthodes

L'utilisation de la notation liste[i:j] n'étant pas très explicite, on préfère utiliser les méthodes suivantes pour ajouter ou supprimer une valeur :

>>> liste=['a', 'b', 'c', 'd']
>>> liste.append('c')  # ajoute en fin de liste
>>> liste
['a', 'b', 'c', 'd', 'c']
>>> liste.insert(1,'à')  # insère à l'indice donné
>>> liste
['a', 'à', 'b', 'c', 'd', 'c']
>>> liste.remove('c')  # supprime la première occurrence
>>> liste
['a', 'à', 'b', 'd', 'c']
>>> liste.pop(2)  # extrait la valeur à l'indice donné
'b'
>>> liste
['a', 'à', 'd', 'c']

Utiliser la fonction help sur une liste permet d'avoir l'ensemble des méthodes disponibles.

Par exemple :

 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |
 |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
 |      order of two equal elements is maintained).
 |
 |      If a key function is given, apply it once to each list item and sort them,
 |      ascending or descending, according to their function values.
 |
 |      The reverse flag can be set to sort in descending order.
>>> liste = ['b', 'c', 'b', 'a']
>>> liste.sort()
>>> liste
['a', 'b', 'b', 'c']

Exercice Écrire une fonction qui demande un mot à l'utilisateur, en boucle, jusqu'à ce que l'utilisateur entre le mot FIN, et qui renvoie la liste de tous les mots entrés (sauf le mot FIN).

def input_mots():
    """ Demande et renvoie une liste de mots. """
    mots = []
    mot = input('Entrer un mot : ')
    while mot != 'FIN':
        mots.append(mot)
        mot = input('Entrer un autre mot : ')
    return mots
>>> input_mots()
Entrer un mot : moi
Entrer un autre mot : toi
Entrer un autre mot : elle
Entrer un autre mot : FIN
['moi', 'toi', 'elle']

Conversion listes / chaines de caractères

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']
>>> 'Hello world'.split(' ')
['Hello', 'world']
>>> str(['1', '2', '3'])
"['1', '2', '3']"
>>> ' ; '.join(['1', '2', '3'])
'1 ; 2 ; 3'

Exercice Écrire la fonction qui prend une date au format 'dd/mm/aaaa' et qui renvoie 'dd mois aaaa', avec le mois en toute lettre, sans le premier '0' éventuel du jour et en appelant '1er' le premier jour '01'.

def jour(data):
    """ data est 'dd/mm/aaaa', et la fonction renvoie 'dd mois aaaa' """
    mois = ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'aout', 'septembre', 'octobre', 'novembre', 'décembre']
    liste = data.split('/')  # liste est de la forme ['dd', 'mm', 'aaaa']
    if liste[0][0] == '0':  # si le premier 'd' de 'dd' est '0' 
        liste[0] = liste[0][1]  # alors on ne garde que le second 'd' 
        if liste[0] == '1' :
            liste[0] = '1er'
    liste[1] = int(liste[1])  # On va se servir de int('mm') comme indice
    liste[1] = mois[liste[1]-1]  # Le n-ième mois est d'indice n-1
    return ' '.join(liste)
>>> jour('01/01/2024')
'1er janvier 2024'

Pour s'entraîner

Exercice Regarder la documentation des méthodes index , count et reverse puis écrire des fonctions avec les mêmes spécifications.

Navigation