Types et Valeurs Construits

Rappels élémentaires de programmation

Notion de variable et affectation

Une variable est comme une boîte identifiée par un nom dans laquelle on stocke une information de différents types (entier, flottant, chaîne de caractères, booléen, liste...).
On affecte une valeur à une variable via une opération appelée affectation.

Schéma

variable = valeur

Exemple

a = 5
bonjour = "bonjour"
vrai = True

Ici, la variable a contient la valeur 5, bonjour contient la chaîne "bonjour", et vrai contient le booléen True.

Variable

Une variable peut contenir différents types de données, et sa valeur peut changer au cours du programme.

Condition

Une condition permet d'exécuter un bloc de code uniquement si une expression est vraie, sinon un autre bloc peut s'exécuter.
Cette notion est directement liée à l'algèbre booléenne vue précédemment, où les conditions représentent des expressions logiques évaluées à True ou False.

Schéma

if condition:
    # code si condition vraie
else:
    # code sinon

Exemple

age = 17
if age >= 18:
    print("Je suis majeur")
else:
    print("Je suis mineur")

Les conditions utilisent des opérateurs de comparaison et logiques :

Opérateur	Signification
<	strictement inférieur
<=	inférieur ou égal
>	strictement supérieur
>=	supérieur ou égal
==	égal
!=	différent
and	condition1 ET condition2
or	condition1 OU condition2
not	condition NE DOIT PAS être respectée

Astuce

Les opérateurs and, or et not permettent de combiner ou inverser des conditions pour créer des tests complexes.

Boucle

Les boucles permettent de répéter des instructions plusieurs fois sans les réécrire.

Types de boucles

• Boucle FOR : répétition bornée avec un nombre défini d'itérations.
• Boucle WHILE : répétition tant qu'une condition est vraie.

Boucle FOR

Une boucle for répète un bloc de code un nombre défini de fois, avec un compteur qui s'incrémente à chaque tour.

for i in range(debut, fin):
    # instructions à répéter

• i est la variable compteur qui prend successivement les valeurs de debut à fin - 1.

Exemple :

for i in range(0, 5):
    print(i)

# sortie : 0, 1, 2, 3, 4

Boucle WHILE

Une boucle while répète un bloc tant qu'une condition est vraie.

while condition:
    # instructions à répéter

Exemple :

a = 0
while a < 5:
    print(a)
    a += 1

# sortie : 0, 1, 2, 3, 4

Boucle infinie

Ne pas oublier de modifier la variable testée dans la condition d'une boucle while, sinon la boucle tournera indéfiniment.

Exemple d'une boucle infinie :

while True:
    print("Cette boucle ne s'arrête jamais")

Les types construits

Un type construit est une structure qui regroupe plusieurs valeurs dans une seule variable.
Ces structures permettent de stocker et manipuler des collections de données.

Structures principales étudiées

Nous étudierons trois structures fondamentales : les listes, les tuples et les dictionnaires.

Les listes

Une liste est une collection ordonnée d'éléments, chaque élément étant accessible via un indice (position).

Indices

Les indices commencent toujours à 0 pour le premier élément.

Usages des listes :

Création

On crée une liste avec des crochets [ ]. Elle peut être vide ou contenir des éléments :

ma_liste_vide = []
ma_liste = [1, 2, 3, "texte", True]

Accès aux éléments

On accède à un élément via son indice entre crochets :

ma_liste = [10, 20, 30]
print(ma_liste[0])  # affiche 10

On peut aussi accéder à une sous-liste avec la syntaxe [début:fin], où fin est exclu :

ma_liste = [10, 20, 30, 40, 50]
print(ma_liste[1:4])  # affiche [20, 30, 40]

Si début ou fin sont omis, la tranche prend respectivement depuis le début ou jusqu'à la fin de la liste.

Méthodes utiles

Les listes possèdent des méthodes pratiques :

• append(element) : ajoute un élément à la fin.
• pop() : retire et retourne le dernier élément (ou celui à un indice donné).
• remove(element) : supprime la première occurrence de l'élément.
• len(liste) : retourne la taille de la liste.

Exemples :

ma_liste = [1, 2, 3]
ma_liste.append(4)  # ajoute 4 à la fin
print(ma_liste)  # sortie : [1, 2, 3, 4]

dernier = ma_liste.pop()  # retire et retourne le dernier élément
print(dernier)  # sortie : 4
print(ma_liste)  # sortie : [1, 2, 3]

ma_liste.remove(2)  # supprime la première occurrence de 2
print(ma_liste)  # sortie : [1, 3]

taille = len(ma_liste)  # taille de la liste
print(taille)  # sortie : 2

Parcours

Deux façons de parcourir une liste :

• Par indices (itérateur) :

for i in range(len(ma_liste)):
    print(ma_liste[i])

Exemple avec sortie :

ma_liste = ['a', 'b', 'c']
for i in range(len(ma_liste)):
    print(ma_liste[i])

# sortie :
# a
# b
# c

• Par éléments :

for element in ma_liste:
    print(element)

Exemple avec sortie :

ma_liste = ['a', 'b', 'c']
for element in ma_liste:
    print(element)

# sortie :
# a
# b
# c

Les tuples

Un tuple est similaire à une liste, mais immuable : on ne peut pas modifier ses éléments après création.
Il est défini par des parenthèses ( ).

Utilité

Les tuples sont utiles pour stocker des données fixes, comme des coordonnées ou des constantes.

Exemple :

point1 = (3, 4)
point2 = (6, 1)
milieu = ((point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2)

On accède aux éléments avec des indices, comme pour les listes.

Les dictionnaires

Un dictionnaire associe une clé unique à une valeur.
Les clés peuvent être de types simples (entier, chaîne, etc.) et servent à retrouver leur valeur associée.

Valeurs multiples

Pour associer plusieurs valeurs à une clé, on peut utiliser une liste comme valeur.

Usages des dictionnaires :

Création

On crée un dictionnaire avec des accolades {} :

dico_vide = {}
dico = {"a": 1, "b": 2}

Ajouter un élément

On ajoute ou modifie une paire clé-valeur par :

dico["nouvelle_cle"] = nouvelle_valeur

Accès aux valeurs

On accède à une valeur via sa clé :

print(dico["a"])  # affiche 1

On peut accéder à des valeurs complexes, comme des listes :

dico = {5: ["a", 3]}
print(dico[5][1])  # affiche 3

Modifier une valeur

Les clés ne sont pas modifiables, mais les valeurs associées peuvent être remplacées :

dico = {'cle1': 3, 'cle2': ['test']}
dico['cle2'] = 1  # remplace la liste par 1

Parcours

Trois façons de parcourir un dictionnaire :

• Par clés :

for cle in dico.keys():
    print(cle)

Exemple avec sortie :

dico = {'a': 1, 'b': 2}
for cle in dico.keys():
    print(cle)

# sortie :
# a
# b

• Par valeurs :

for valeur in dico.values():
    print(valeur)

Exemple avec sortie :

dico = {'a': 1, 'b': 2}
for valeur in dico.values():
    print(valeur)

# sortie :
# 1
# 2

• Par clé et valeur :

for cle, valeur in dico.items():
    print(cle, valeur)

Exemple avec sortie :

dico = {'a': 1, 'b': 2}
for cle, valeur in dico.items():
    print(cle, valeur)

# sortie :
# a 1
# b 2