Tuples
- Les tuples sont utilisés pour stocker plusieurs éléments dans une seule variable.
- Un tuple est une collection ordonnée et inchangeable. Leurs éléments sont écrits entre parenthèses.
- Créez un tuple
# exemple d’un tuple
tuple0 = () # tuple vide
tuple0 = (12, 32, 98)
print(tuple0)
# exemple 2: tuple avec différent types de données——————–
objectif_smart= (« spécifique », « mesurable », « atteignable », »réalisable »,
« temporel », 1, 2, 3, 4, 5, True )
print(objectif_smart)
Éléments de tuple
- Les éléments de tuple sont ordonnés, non modifiables et autorisent les valeurs en double. Ils sont indexés, le premier élément à l’index [0], le deuxième élément à l’index [1] etc.
- On peut accéder à un élément en utilisant son index.
- On peut accéder aux éléments d’un tuple en se référant au numéro d’index, entre crochets.
- L‘indexation négative signifie commencer par la fin: -1 fait référence au dernier élément, -2 fait référence à l’avant-dernier élément, etc.
Exemple :
tuple2=(« objectif ») # N’est pas un tuple
print(type(tuple2))
tuple = (« smart »,)
print(« tuple avec un seul élément: », tuple)
smart = (« S », « M », « A », « R », « T », « T »)
print(smart[1]) # afficher le deuxième élément
print(smart[-1]) # afficher le dernier élément
Plage d’index (tranchage)
- Nous pouvons spécifier une plage d’index en spécifiant où commencer et où terminer la plage.
- Lors de la spécification d’une plage, la valeur de retour sera un nouveau tuple avec les éléments spécifiés.
Exemple : Renvoyer les 1er, 2ème, 3ème et 4ème éléments
tuple_smart = (« S », « M », « A », « R », « T », « T »)
print(tuple_smart[1:5]) # afficher le 1er jusqu’à le 4eme élément
Chercher un élément
- Déterminer si un élément spécifié est présent dans un tuple, pour ce faire utilisez le mot in clé.
Exemple : Vérifiez si « R » est présent dans le tuple.
tuple_smart = (« S », « M », « A », « R », « T », « T »)
print(tuple_smart[1:5]) # afficher le 1er jusqu’à le 4eme élément
tuple_smart = (« S », « M », « A », « R », « T »)
if « R » in tuple_smart:
print(« Oui, R existe dans le tuple_smart »)
unpacking un tuple
Lorsque nous créons un tuple, nous lui attribuons normalement des valeurs. C’est ce qu’on appelle « emballer » un tuple.
En Python, il est possible d’extraire les valeurs dans des variables. C’est ce qu’on appelle le « déballage » ;
Exemple :
#—-Extraire les valeurs dans des variables—-
objectif_smart= (« specific », « mesurable », « atteinable »,« réalisable »,
« temporel » )
S, M, A, R, T = objectif_smart
print(S, M, A, R, T)
Joindre deux tuples
- Pour joindre deux tuples ou plus, nous pouvons utiliser l’opérateur +.
Exemple :
# joindre deux tuples—————
tuple_1 = (0, 1, 2, 3, 4, 5)
tuple_2 = (6, 7, 8, 9)
tuple_3 = tuple_1 + tuple_2
Multiplier les tuples
Pour multiplier le contenu d’un tuple un certain nombre de fois, utiliser l’opérateur *,
Exemple :
# multiplier les tuples—————
tuple_1 = (0, 1, 2, 3, 4, 5)*2
print(tuple_1)
Sets
Ensembles (Sets)
- Les ensembles sont utilisés pour stocker plusieurs éléments dans une seule variable.
- Un ensemble est une collection non ordonnée, non modifiable et non indexée. Les ensembles sont écrits avec des accolades.
- Les ensembles ne peuvent pas avoir deux éléments avec la même valeur.
Remarque : les éléments de l’ensemble ne sont pas modifiables, mais on peut supprimer des éléments et en ajouter de nouveaux.
Créer un ensemble
# Exemple1: Set d’entiers
set_0 = {10, 20, 30, 40}
print(set_0)
# Exemple2 : Set avec différents types de données
set1 = {3.14, « rayon », (15, 20)}
print(set1)
#quelques opérations sur les « Set » (add, update)
set_3 = {60, 30, 40, 70}
set_3.add(50)
print(set_3)
set_3.update([100, 200])
print(set_3)
Supprimer des éléments d’un ensemble
Un élément particulier peut être supprimé d’un ensemble à l’aide des méthodes discard() et remove().
La seule différence entre les deux est que la méthode discard() laisse un ensemble inchangé si l’élément n’est pas présent dans l’ensemble.
La méthode remove() lèvera une erreur dans une telle condition (si l’élément n’existe pas dans l’ensemble).
Exemple:
#—-méthodes: remove(), discard()…
set_4 = {20,30,50,80,70}
set_4.remove(20)
print(set_4)
set_4.discard(80)
print(set_4)
Dictionnaires
- Un dictionnaire est une collection d’éléments non ordonnés. Chaque élément d’un dictionnaire à une paire « clé/valeur » .
- Les dictionnaires sont optimisés pour récupérer des valeurs lorsque la clé est connue.
Création d’un dictionnaire
Créer un dictionnaire consiste à placer des éléments entre des accolades {} séparées par des virgules.
- Un élément a une clé « key » et une valeur « value » correspondante qui est exprimé sous la forme d’une paire (clé : valeur) et peut être référencé à l’aide du nom de la clé.
- Alors que les valeurs peuvent être de n’importe quel type de données et peuvent se répéter, les clés doivent être de type immuable ( string , number ou tuple avec des éléments immuables) et doivent être uniques.
Exemple : Créer et afficher un dictionnaire
#===Créer dictionnaires ======
my_dict = {} # dictionnaire vide
my_dict = {
1:« S »,
2: « M »,
3: « A »,
4: « R »,
5: « T »}
print(« my_dict : », my_dict)
my_dict0 = {
« S »: « Specific »,
« M »: « Meaueable »,
« A »: « Ateinable »,
« R »: « Realistic »,
« T »: « Temporal »}
print(« my_dict0 : « , my_dict0)
#***dictionnaire contenant un mixage de données****
my_dict1 = {1: ‘objectifs’, 2:[« S », « M », « A », « R », « T »], « decision »:True}
print(my_dict1)
Accéder à un élément d’un dictionnaire
- Il suffit d’indiquer le numéro de l’élément entre les crochets;
Exemple : afficher la valeur de l’élément 1
my_dict1 = {1: ‘objectifs’, 2: [« S », « M », « A », « R », « T »], « decision »:True}
print(my_dict1)
# afficher la valeur de l’élément 1
print(my_dict1[1])
Modifier et ajouter des éléments
- Les dictionnaires sont modifiables, ce qui signifie que nous pouvons modifier, ajouter ou supprimer des éléments après la création du dictionnaire.
- Nous pouvons ajouter de nouveaux éléments ou modifier la valeur d’éléments existants à l’aide d’un opérateur d’affectation.
- Si la clé est déjà présente, la valeur existante est mise à jour. Si la clé n’est pas présente, une nouvelle paire (clé : valeur) est ajoutée au dictionnaire.
Exemple :
Supprimer des éléments
- Nous pouvons supprimer un élément dans un dictionnaire en utilisant la méthode pop(). Cette méthode supprime un élément avec le key fourni et renvoie le value.
- La méthode popitem() peut être utilisée pour supprimer et renvoyer une paire (key, value) d’éléments arbitraires du dictionnaire.
- Tous les éléments peuvent être supprimés à la fois, en utilisant la méthode clear() .
- Nous pouvons également utiliser le mot-clé del pour supprimer des éléments individuels ou le dictionnaire entièrement.
Exemple :
Doublons non autorisés
- Un dictionnaire est une collection ordonnée*, modifiable et qui n’autorise pas les doublons.
- Les dictionnaires ne peuvent pas avoir deux éléments avec la même clé.
Exemple : Les valeurs en double écraseront les valeurs existantes.
my_dict1 = {
1: ‘objectifs’,
2: [« S », « M », « A », « R », « T »],
« decision »: False,
« decision »: True,
« plan »: « d’action »
}
print(my_dict1)
Types de données
- Les valeurs des éléments du dictionnaire peuvent être de n’importe quel type de données.
- Nous pouvons accéder aux éléments d’un dictionnaire en se référant à son nom de clé, entre crochets.
- Il existe également une méthode appelée get() qui nous donnera le même résultat ;
Exemple : Obtenir la valeur de la clé 1
my_dict1 = {
1: ‘objectifs’,
2: [« S », « M », « A », « R », « T »],
« decision »: False,
« decision »: True,
« plan »: « d’action »
}
# afficher la valeur de la clé 1 +++++++++
x = my_dict1[1]
print(x)
Exemple : Obtenir la valeur de la clé 2
y = my_dict1.get(2)
print(y)
Les méthodes values(), items(), dict() et copy()
- La méthode values() retourne une liste de toutes les valeurs du dictionnaire.
La méthode items() renverra chaque élément d’un dictionnaire, sous forme de tuples dans une liste.
- Faire une copie d’un dictionnaire avec la fonction « dict() ».
- Faites une copie d’un dictionnaire avec la méthode « copy() »,
Exemple : Obtenir la valeur de la clé 1
z = my_dict1.values()
print(z)
# résultat : dict_values([‘objectifs’, [‘S’, ‘M’, ‘A’, ‘R’, ‘T’], True, « d’action »])
Exemple : Obtenir la valeur de la clé 2
y = my_dict1.get(2)
print(y)
Exemple : Obtenir une liste des paires (clé : valeur).
# méthode item()
x = my_dict1.items()
print(« x = « , x)
Exemple :
#copier un dictionnaire -méthode 1-
u = dict(my_dict1)
print(« u = « , u)
Exemple:
#copier un dictionnaire -méthode 2-
d = my_dict1.copy()
print(« d = « , d)