Types et Valeurs Construits

Rappels élémentaires de programmation

Notion de variable et affectation

Une variable est comme une boîte, possédant un nom, dans laquelle on va pouvoir ranger des informations de différents types (entier, flottant, caractères, booléen, liste...). On dit que l'on affecte une valeur à une variable.
Concrètement, on fait ce que l'on appelle une affectation.
En programmation, elle est représentée par le symbole =, on a donc le schéma : variable = valeur :

a = 5
bonjour = "bonjour"
vrai = True

Ici, la variable a contient la valeur 5, la variable bonjour contient la chaine de caractères "bonjour", et la variable vrai contient le booléen True.

Condition

Une condition est une structure de programmation permettant d'exécuter un code, ou bien un autre, suivant si la condition donnée est respectée ou non. Elle est représentée par ce schéma :

if condition est vraie :
    #code à exécuter si c'est vrai
else : #sinon
    #code à exécuter si la condition est fausse

Les conditions sont donc des tests à effectuer suivant les opérateurs suivants :

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

Exemple :

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

Boucle

Les boucles sont une manière en programmation de répéter des instructions sans avoir à les écrire plusieurs fois de suite.
Il en existe 2 sortes :

Boucle FOR

Boucle dite bornée, on commence à un début définit, et on s'arrête à une fin, également définie.
On utilise le schéma suivant :

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

• for : mot-clé indiquant que l'on écrit une boucle ;
• i : variable "compteur", elle contient la valeur de début au commencement de la boucle, et s'incrémente de 1 dès qu'un tour de boucle se termine, jusqu'à prendre la valeur de fin-1 ;
• in range(debut,fin) : indique que i va avoir des valeurs comprises dans l'intervalle allant de la valeur de début, à la valeur de fin.

Exemple :

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

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

Boucle WHILE

Boucle dite non bornée: les instructions de la boucle vont se répéter tant que la condition de la boucle n'est pas respectée.
On utilise le schéma suivant :

while condition non respectée :
    #instructions se répètent

Exemple :

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

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

La condition à respecter pour que la boucle s'arrête est que a ne doit pas dépasser 5. Quand a contient 5, la boucle s'arrête.

Boucle infinie

Il faut bien faire attention, lorsque l'on utilise la boucle while, a modifier dans la boucle la variable de la condition.
Si on oublie de la modifier, on peut créer des boucles infinies.

Les types construits

Les types construits sont représentés par des structures de données. C'est, comme son nom l'indique, une structure contenant plusieurs valeurs. On stocke cette structure dans une variable.
On pourra y retrouver des entiers, des chaînes de caractères, des booléens ... Bref, tout type utilisé en programmation.

Structures utilisées

Nous nous focaliserons sur 3 structures distinctes : les listes, les tuples et les dictionnaires.

Les listes

Une liste est une structure de données dite linéaire, chaque élément la comportant est rangée à une position spécifique, appelée indice.

Les différents usages des listes :

Création

On définit une liste grâce aux opérateurs [ ], que l'on stocke dans une variable. Cette liste peut être vide, ou remplie :

Accès aux éléments

On accède aux éléments d'une liste grâce à un indice, qui est un entier. L'indice correspond à la position d'un élément dans la liste.

Premier indice

Le premier indice est toujours la valeur 0.

Pour accéder à un élément d'une liste, il faut mettre la variable de la liste, suivie d'un indice entre crochets :

On peut également accéder à une sous-liste de la liste principale en mettant [début:fin]. début correspond au premier indice que l'on prend, et fin au dernier indice exclu. Si début n'est pas précisé, on prendra le tout premier indice. Si fin n'est pas précisé, on prendra jusqu'au dernier indice.

Méthodes

Les listes sont des objets, et possèdent un ensemble de méthodes permettant d'effectuer diverses manipulations sur celles-ci :
append(element) : ajoute element dans la liste.
pop() : supprime et retourne le dernier élément de la liste. Il est possible de mettre un indice en paramètre.
remove(element) : supprime element de la liste, si celui-ci existe.
len(liste) : retourne la taille de la liste en paramètre.

Parcours

Il existe 2 façons distinctes de parcourir une liste : soit par itérateur, soit par élément.

Itérateur :

On utilise une variable qui va s'incrémenter à chaque tour de boucle, et on se sert de cette variable comme indice pour la liste.
Quand on souhaite parcourir une liste, on utilise (presque) tout le temps les méthodes range(len(liste)) pour parcourir l'entièreté de la liste. Ce qui donnerait :

Exécution :

Convention

On appelle par défaut le variant de la boucle i.

Élément :

On utilise une variable qui, à chaque tour de boucle, devient un élément de la liste.
On utilise une boucle for, ainsi que le mot-clé in :

Exécution :

Les tuples

Un tuple est une structure représentée par les symboles ( ).
A contrario des listes, un tuple est une structure IMMUABLE, cela signifie que l'on ne peut pas modifier ses valeurs. Par contre, on peut y accéder grâce aux [ ] avec des indices, comme les listes.

Cette structure est principalement utilisée lorsque l'on souhaite stocker un ensemble de valeurs dont on sait qu'elles ne changeront jamais.

Exemple :

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

On crée 2 points (dont les coordonnées ne doivent pas être modifiées), puis on crée le point au milieu des 2, en utilisant les coordonnées des 2 premiers points.

Les dictionnaires

Un dictionnaire est une structure de données dans laquelle on associe une clé à une valeur.
Une clé est un élément unique qui peut être de tout type de base (entier, chaine de caractères, caractère) et permet de retrouver la valeur qui lui est associée, un peu comme un dictionnaire papier qui nous permet de retrouver la définition d'un mot à partir de ce mot !

Valeurs d'un dictionnaire

Les valeurs d'un dictionnaire peuvent être de tout type. On pourra y mettre des entiers, des booléens, des objets, des listes, des dictionnaires ...
Cependant, il ne peut y avoir qu'une seule valeur associée à une clé. Si l'on souhaite mettre plusieurs valeurs pour une clé, il faudra mettre toutes ces valeurs dans une liste par exemple.

Les différents usages des dictionnaires :

Création

On définit un dictionnaire grâce aux opérateurs { }, que l'on stocke dans une variable. Ce dictionnaire peut être vide, ou rempli en écrivant dans les accolades cle1 : valeur1, cle2 : valeur2 ... :

dico1 = {}
dico2 = {cle1 : valeur1, cle2 : valeur2}

Ajouter un élément

On peut ajouter des clés et valeurs dans un dictionnaire sans utiliser de méthodes comme les listes. Il suffit d'écrire :

mon_dico[nouvelle_cle] = nouvelle_valeur

mon_dico est le dictionnaire dans lequel on souhaite ajouter de nouveaux éléments ;
nouvelle_cle est la nouvelle clé que je souhaite ajouter ;
nouvelle_valeur est la nouvelle valeur que je souhaite ajouter.

Accès aux valeurs

On accède aux valeurs d'un dictionnaire grâce à ses clés que l'on précise entre crochets.

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

On accède dans le premier print à la valeur de la clé a, ce qui donne 1.
Dans le second, on accède à la valeur de la clé 5 qui est une liste, et on accède au 2ème élément de cette liste, ce qui donne 3.

Modifier une valeur

Les clés d'un dictionnaire ne sont pas modifiables. Par contre, les valeurs associées aux clés peuvent être modifiées, en remplaçant par exemple la valeur d'une clé par une autre :

dico = {'cle1' : 3, 'cle2' : ['test']}

dico['cle2'] = 1

Ici, la nouvelle valeur associée à cle2 sera 1 ; ['test'] a été remplacé.

Parcours

Il existe 3 façons distinctes de parcourir un dictionnaire : par clés, par valeurs, ou bien en parcourant les 2.

Par clés :

Un dictionnaire possède une méthode appelée keys() qui permet de donner une liste contenant les clés du dictionnaire. Ainsi une boucle for donnerait :

dico = {'cle1' : 3, 'cle2' : ['test']}

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

La variable cles devient à chaque itération le contenu des clés du dictionnaire.
A la première itération, cles vaut cle1, puis à la seconde, cle2.

Par valeurs :

De la même manière que pour les clés, il existe une méthode values() permettant d'obtenir une liste des valeurs du dictionnaires, que l'on peut parcourir de la même façon :

dico = {'cle1' : 3, 'cle2' : ['test']}

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

La variable valeurs devient à chaque itération le contenu des valeurs du dictionnaire.
A la première itération, valeurs vaut 3, puis à la seconde, ['test'].

En parcourant les 2 :

Pour finir, il existe une troisième méthode permettant de parcourir clés et valeurs en même temps : items(). Il faudra, lors de la boucle, préciser 2 variables :

dico = {'cle1' : 3, 'cle2' : ['test']}

for cles, valeurs in dico.items() :
    print(cles, valeurs)

Comme pour les exemples précédents, cles et valeurs auront à chaque itération la clé et sa valeur associée.