Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
Download
28 views
Tweet
Share
Share
Kernel: Python 3 (Ubuntu Linux)

Le conteneur de type list

0. Prérequis : tuple

Un tuple (n-uplet en français) est une séquence d'éléments de type quelconque, non mutable, séparés par des virgules et mis entre parenthèse.

t=(1,2,'d')

Principale utilité

Dans une fonction, return ne renvoie qu'un objet. Un tuple contenant différents objets sera renvoyé avec return, contournant ainsi cette limitation.

Complément

Les tuples ne sont pas explicitement au programme, vous pouvez vous en passer en première lecture.

L'utilisation de tuples accélère le traitement des données par rapport à une liste mais n'accepte pas de modification.

1. Structure de liste

l=['a', 3, 2.1, [True,False]]
type(l)
list

Double indexation des éléments d'une liste

image.png

l[0]
'a'
l[-1]
[True, False]
l[-2]
2.1

On peut aussi afficher le contenu de la liste simplement :

print(*l)
a 3 2.1 [True, False]

2. Definition d'une liste

  • Directement :

l=[1,2,3]

  • Par conversion :

l=list((1,2,3))

l=list("Hello")
l
['H', 'e', 'l', 'l', 'o']

  • Initialisation puis extension :

l=[]
l.append(1)
l.append(2)
l.append(3)
l
[1, 2, 3]

  • Initialisation à 0 (par exemple), pour une liste de longueur n :

n=10
l=n*[0]
l
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

  • En compréhension :

l=[i for i in range (1,4)]
l
[1, 2, 3]
texte="Des capacités pythoniques !"
l=[el for el in texte]
print(l)
['D', 'e', 's', ' ', 'c', 'a', 'p', 'a', 'c', 'i', 't', 'é', 's', ' ', 'p', 'y', 't', 'h', 'o', 'n', 'i', 'q', 'u', 'e', 's', ' ', '!'] 
l=[i for i in range(100) if (i%7==0 or str(i)[-1]=='7')]
l
[0, 7, 14, 17, 21, 27, 28, 35, 37, 42, 47, 49, 56, 57, 63, 67, 70, 77, 84, 87, 91, 97, 98]

3. Slicing

l=[i for i in range(21)]
l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l[5:15]
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
l[3:len(l)]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l[3:]
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l[:10]+l[10:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
l[0:10:2]
[0, 2, 4, 6, 8]
l[1::2]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
l[-1:-len(l)-1:-1]
[20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

4. Parcours des éléments de la liste

Pour une utilisation sans volonté de modifier les valeurs de la liste

Deux méthodes sont possibles :

  • Parcours des éléments indexés

  • Parcours des éléments sans référence aux index

Exemple : Calcul de la somme des termes de la liste

somme=0
for i in range(len(l)):
    somme+=l[i]
somme
210
somme=0
for el in l:
    somme+=el
somme

Pour une modification de la liste elle-même

Une seule méthode possible :

  • Parcours des éléments indexés

Exemple : Mettre au carré chacun des termes de la liste

for el in l:
    el=el**2
l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
for i in range(len(l)):
    l[i]**=2
l
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400]

5. Liste : un objet mutable

Ajout d'un élément

l=[1,2,3]
l.append(4)
l

Retrait d'un élément

l.pop()

Modification

l[0]=4
l

Concaténation de liste

2 méthodes :

  • Utiliser le symbole de l'addition.

C'est la plus mauvaise solution, car le coût temporel est de la taille de la liste finale. En d'autres termes, cette méthode recopie la totalité des deux listes dans un autre endroit de la mémoire de l'ordinateur, ce qui coûte n opérations élémentaires si la liste finale contient n termes.

  • Utiliser la méthode .extend

Cela ne coute en temps que len (l2) opérations élémentaires.

l=[1,2,3]
l2=[4,5,6]
l.extend(l2)
l

Inversion

l.reverse()
l

Trier la liste par ordre croissant

l.sort()
l

Copie par valeur ou par référence

l=[1,2,3]
l2=l
l

l2[0]=4
l

l=[1,2,3]
l2=list(l)

l2[0]=4
l

l=[1,2,3]
l2=l[:]

6. Passage par référence d'une liste comme argument d'une fonction

Exemple :

def function(l,n):
    n=4
    l[0]=n*l[0]

n=8
l=[1,2,3]
function(l,n)
print(l)
print(n)

Tout n'est pas si simple ... !

def function(l,n):
    l=[3,2,1]
    n=4
    l[0]=n*l[0]
    return l

n=8
l=[1,2,3]
print(function(l,n))
print(l)
print(n)

Un objet mutable est passé par référence dans une fonction : une modification dans la fonction affecte la liste à l'extérieur

Un objet non mutable (type : int, float, bool, tuple, String) sera passé par valeur : les modifications (en réalité, les redéfinitions), restent confinées à l'intérieur de la fonction

7. Quelques algorithmes (traduits en python) au programme

La somme des termes d'une liste

  • Python : sum(l)

  • Nous : ...

def somme(l):
    s=0
    for el in l:
        s+=el
    return (s,len(l))
l=[1,2,3]
somme(l)[1]
3

La moyenne des termes d'une liste

  • Python : non disponible

  • Nous : ...

def moyenne(l):
    return somme(l)/len(l)

La variance

  • Python : non disponible

  • Nous : ...

def variance(l):
    m=moyenne(l)
    carre=[el**2 for el in l]
    return moyenne(carre)-moyenne(l)**2

def variance(l):
    v=0
    m=moyenne(l)
    for el in l:
        v+=(el-m)**2
    return v/len(l)

Minimum

  • Python : min(l)

  • Nous : ...

def minimum(tab):
    
    m=tab[0]
    for el in tab:
        if el<m:
            m=el
    return m

def minimum(tab):
    
    m=tab[0]
    for i in range(1,len(tab)):
        if tab[i]<m:
            m=tab[i]
    return m

Recherche d'un élément dans une liste

Il est courant de répondre à la question "Cet élément appartient-il à cette liste ?

  • Python : x in tab

  • Nous : ...

def rechercheElement(tab,x):
    for i in range(len(tab)):
        if tab[i]==x:
            return True
    return False

def rechercheElement(tab,x):
    for el in tab:
        if el==x:
            return True
    return False

On peut aussi répondre à la question de la position à laquelle on trouve cet élément, avec pour convention le renvoi de -1 si l'élément n'existe pas dans la liste.

  • Python : tab.index(x)

  • Nous : ...

def recherchePositionElement(tab,x):
    for i in range(len(tab)):
        if tab[i]==x:
            return(i)
    return(-1)

Enfin, on peut vouloir compter les occurences de l'élément dans la liste :

  • Python : tab.count(x)

  • Nous : ...

def rechercheNbElement(tab,x):
    n=0
    for el in tab:
        if el==x:
            n+=1
    return n