Lien vers l'activité : Tableaux (bilan)
Dernière modif. : 29 03 2024
Un string est une séquence ordonnée composée de caractères indexables par un numéro.
Avec Python, le string est *implémenté via le type natif est str qui est immuable.
1
2 | a = "bonjour"
b = 'bonjour !'
|
On utilise la fonction native len.
1
2
3
4 | a = "bonjour"
nbr_a = len(a) # Contient 7
b = 'bonjour !'
nbr_b = len(b) # Contient 9
|
On utilise le nom du string, un crochet d'ouverture, le numéro d'index et un crochet de fermeture.
1
2
3
4
5
6 | a = "bonjour"
n0 = a[0] # La variable contient le 'b' initial
n1 = a[1] # La variable contient 'o'
n2 = a[2] # La variable contient 'n'
n6 = a[6] # La variable contient le 'r' final
nf = a[-1] # La variable contient le 'r' final
|
Il suffit de lire les éléments de l'index 0 jusqu'à l'index "longueur-1".
1
2
3
4
5 | a = 'bonjour'
longueur = len(a)
for index in range(longueur) :
print(a[index], end="-")
|
La variable de boucle index va prendre successivement les valeurs
0 1 2 ect et cela va provoquer l'affichage suivant :b-o-n-j-o-u-r-Plus "clair" que la précédente mais on perd la connaissance de l'index du caractère en cours.
1
2
3 | mot = "bonjour"
for caractere in mot :
print(caractere, end='-')
|
La variable caractere va prendre successivement les valeurs 'b', puis 'o', puis 'n' ...
En Python, le string est immuable ou non mutable : on ne peut pas modifier les caractères après création du string. Le code suivant provoquerait une erreur :
1
2 | a = "bonjour"
a[0] = "B"
|
Si on veut modifier un string, on ne peut pas réellement le faire : il faut récréer un string et écraser l'ancienne variable par une variable ayant le même nom.
Exemple avec un code qui transforme les o en X en créant par concaténation un nouveau string. Il ne s'agit donc pas réellement d'une modification : la variable mot de la ligne 7 est bien une nouvelle variable car son ID-mémoire n'est pas celui de la variable de la ligne 1.
1
2
3
4
5
6
7 | mot = 'bonjour'
temp = ""
for carac in mot :
if carac == 'o' :
carac = 'X'
temp = temp + carac
mot = temp
|
Une fonction ne peut donc pas modifier un string : elle ne peut que renvoyer un nouveau string. Cette réponse pourra éventuellement écraser l'ancienne variable.
Un tableau (statique) est une structure de données ayant les propriétés suivantes :
Avec Python, les tableaux sont implémentés via le type natif list qui est muable.
Voici deux exemples :
>>> tab1 = ['a', 'b', 'c']
>>> tab2 = [45, 78, 128]
>>> tab1
['a', 'b', 'c']
Nous utilisons ici le type natif list pour implémenter les tableaux en Python.
On utilise la fonction native len.
On utilise le nom de la variable suivi de crochets contenant le numéro d'index voulu. Exemple :
>>> tab1[0]
'a'
>>> tab1[2]
'c'
Python : les numéros d'index négatifs font référence aux derniers éléments :
>>> tab1[-1]
'c'
>>> tab[-2]
'b'
Il faut utiliser cette façon de faire si vous voulez MODIFIER le tableau ou si vous avez besoin de connaître les numéros d'index des éléments.
1
2
3
4
5 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
nbr = len(notes)
for index in range(nbr) :
print(notes[index])
|
On obtient successivement 15 puis 18...
Attention : plus "clair" mais ne permet pas la modification des éléments du tableau.
1
2
3
4 | notes = [15, 18, 8, 10, 12, 15, 20, 5, 12, 17, 12, 10, 18, 4]
for element in notes :
print(element)
|
En Python, les tableaux sont mutables ou muables : on peut modifier le contenu d'une case sans modifier l'ID-mémoire du tableau.
>>> tab1 = [45,28,89]
>>> tab1[0] = 1000
>>> tab1
[1000, 28, 89]
Depuis un tableau de base : on peut déclarer un nouveau tableau en définissant ses éléments à l'aide des éléments d'une autre structure indexable, comme un autre tableau de base par exemple.
1
2 | base = [1, 2, 5]
nouveau = [element*10 for element in base]
|
Le tableau nouveau va alors contenir [10, 20, 50].
On peut également créer un nouveau tableau simplement à partir d'une succession numérique qu'on peut créer à l'aide d'un in range :
1 | nouveau = [x*10 for x in range(5)]
|
Le tableau nouveau va alors contenir [0, 10, 20, 30, 40].
Enfin, on peut même utiliser des tests pour savoir si on agit sur l'élément ou pas :
1
2 | base = [12, 8, 1, 3, 3, 17, 8]
nouveau = [note for note in base if note > 10]
|
Le tableau nouveau va alors contenir [12, 17].
Le p-upletI est une structure ordonnée d'élements
Dans Python, les p-uplets sont implémentés via le type natif tuple qui est immutable.
On utilise les parenthèses comme élément de déclaration et on utilise les virgules pour séparer les éléments.
>>> exemple = ('Ananas' , 50)
>>> exemple
('Ananas', 50)
>>> type(exemple)
<class 'tuple'>
Tuple ne comportant qu'un élément : rajoutez bien la virgule même si vous n'avez qu'un élément.
>>> bon_exemple = ('Ananas' ,)
>>> bon_exemple
('Ananas', )
>>> type(bon_exemple)
<class 'tuple'>
>>> mauvais_exemple = ('Bananes')
>>> mauvais_exemple
'Bananes'
>>> type(mauvais_exemple)
<class 'str'>
On utilise la fonction native len.
On utilise les crochets et le numéro d'index comme avec les strings et les tableaux.
>>> exemple = ('Ananas' , 50)
>>> exemple[0]
'Bananes'
>>> exemple[1]
50
Comme avec les deux structures précédentes : deux façons de faire mais on perd la valeur de l'index avec le FOR nominatif.
Avec Python, le type natif tuple est immuable / non mutalbe : on peut pas peut modifier le contenu d'un tuple après création. Comme avec le string, on peut par contre écraser l'ancienne variable par une variable qui porte le même nom.
L'un des intérêts des tuples est lié à la capacité de renvoyer plusieurs variables via le return. On peut se passer des parenthèses autant dans le return qu'à la réception.
Néanmoins, autant les mettre, cela montre explicitement la nature du tuple qu'on envoie ou qu'on reçoit.
Exemple :
1
2
3
4 | def test() :
return (50,100)
x,y = test()
|
str tente de transformer les données fournies en une stringlist tente de transformer les données fournies en un tableau (list)tuple tente de transformer les données fournies en un p-uplet (tuple)La transformation de string en tableau en utilisant un élément séparateur est possible avec la méthode des strings nommée split. Très pratique pour créer un tableau à partir d'un fichier texte.
>>> phrase = "Voici un exemple de phrase, il permet de compter les mots."
>>> mots = phrase.split()
>>> mots
['Voici', 'un', 'exemple', 'de', 'phrase,', 'il', 'permet', 'de', 'compter', 'les', 'mots.']
>>> nbr_mots = len(mots)
>>> nbr_mots
La version encapsulée dans une fonction : une tâche = une fonction.
Et du coup, nous pouvons en faire une fonction :
1
2
3
4 | |
On peut tester si un élément est présent dans un string, un tableau ou un tuple avec le mot-clé in.
>>> tableau = [12, 5, 18]
>>> 5 in tableau
True
>>> 6 in tableau
False
>>> nuplet = ("alors", "ça", "va", "?")
>>> "ça" in nuplet
True
>>> "ca" in nuplet
False
>>> chaine = "Alors, ça va ?"
>>> "Alors" in chaine
>>> "Bonjour" in chaine
False