Types construits

Les types de données dits « simples » sont :

  • int (nombres entiers) ;
  • float (nombres flottants) ;
  • bool (booléens) ;
  • str (chaîne de caractères).

Ces types simples ne sont plus suffisants si nous avons besoin de garder en mémoire un grand nombre de valeurs.

Exemple : pour mémoriser 100 nombres, il n’est pas raisonnable de les mémoriser chacun dans une variable différente :

a1 = 12
a2 = 54
a3 = -9
...

comment accéder  au ième nombre ? si je supprime le nième, quel rang aura le pième ? comment les trier ? comment rechercher une valeur  en particulier ?

 

D’autre part,  si l’on souhaite manipuler des valeurs au sein d’une unique entité, il faudrait pouvoir les regrouper.

Exemple : pour représenter les coordonnées d’un unique point dans l’espace, il faut trois valeurs (x, y, z) de type float, il faudrait les regrouper dans un unique « conteneur ».

 

L’objectif est donc de construire un type de données capable de contenir plusieurs valeurs.

 

Ceci amène à la construction d’objets conteneurs capables de contenir plusieurs objets, simples ou eux-même construits.

 

Les tuples

 

Un p-uplet (type tuple), est une suite ordonnée d’éléments qui peuvent être chacun de n’importe quel type.

Création d’un p-uplet

Pour créer un p-uplet non vide, on écrit des valeurs séparées par des virgules. Par exemple :

  • t = "a","b","c", 3 ou bien t = ("a", "b", "c", 3) pour un tuple à 4 éléments ;
  • t = "a", ou bien t = ("a",) pour un tuple à 1 éléments (attention à la virgule) ;
  • t = () pour un tuple à 0 éléments (ici, pas de virgule, mais des parenthèses obligatoires).

Pour écrire un p-uplet qui contient un n-uplet, l’utilisation de parenthèses est nécessaire. Voici un exemple avec un tuple à 2 éléments dont le second est lui-même un tuple : t = 3, ("a","b","c")

Remarque : en général, les parenthèses sont obligatoires dès que l’écriture d’un p-uplet est contenue dans une expression plus longue. Dans tous les cas, les parenthèses peuvent améliorer la lisibilité.

 

Opérations

Nous avons deux opérateurs de concaténation qui s’utilisent comme avec les chaînes de caractères, ce sont les opérateurs + et *. De nouveaux p-uplets sont créés.

>>> t1 = "a", "b"
>>> t2 = "c", "d"

>>> t1 + t2
('a','b','c','d')

>>> 3 * t1
('a','b','a','b','a','b')

 

Appartenance

Pour tester l’appartenance d’un élément à un tuple, on utilise l’opérateur in :

>>> t = "a", "b", "c"
>>> "a" in t
True

>>> "d" in t
False

 

Utilisation des indices

Les indices permettent d’accéder aux différents éléments d’un tuple. Pour accéder à un élément d’indice i d’un tuple t, la syntaxe est t[i]. L’indice i peut prendre les valeurs entières de 0 à n−1n est la longueur du tuple. Cette longueur s’obtient avec la fonction len() :

>>> t ="a", 1,"b", 2,"c", 3

>>> len(t)
6

>>> t[2]
'b'

Les éléments d’un tuple ne sont pas modifiables par une affectation de la forme t[i] = valeur. Cela provoque une erreur.

  La notation est celle utilisée avec les suites en mathématiques (\(u_0,u_1,u_2,…\)) : les indices commencent à 0.

Par exemple le troisième élément a pour indice 2.

Le dernier élément d’un tuple t  a pour indice len(t)-1. On accède ainsi au dernier élément avec t[len(t)-1]  qui peut s’abréger en t[-1].

>>> t = "a", 1, "b", 2, "c", 3
>>> t[-1]
3

>>> t[-2]
'c'

  Exemple avec des tuples emboîtés (un tuple contenant des tuples) :

>>> t = ("a", "b"), ("c", "d")
>>> t[1][0]
'c'

Explication : t[1] est le tuple ("c", "d") et "c"  est l’élément d’indice 0 de ce tuple.    

 

Affectation multiple

Prenons pour exemple l’affectation a, b, c = 1, 2, 3. Ceci signifie que le tuple (a, b, c) prend pour valeur le tuple (1, 2, 3), autrement dit, les valeurs respectives des variables a, b et c sont 1, 2 et 3. En particulier, l’instruction a, b = b, a permet d’échanger les valeurs des deux variables a et b. Les valeurs des éléments d’un tuple peuvent ainsi être stockées dans des variables.

>>> t = 1, 2, 3
>>> a, b, c = t
>>> b
2

  Cette syntaxe s’utilise souvent avec une fonction qui renvoie un tuple. Voici un exemple avec une fonction qui calcule et renvoie les longueurs des trois côtés d’un triangle ABC. La fonction prend en paramètres trois p-uplets représentant les coordonnées des trois points.

from math import sqrt

def longueurs(A,B, C):
   xA,yA = A
   xB,yB = B
   xC,yC = C
   dAB= sqrt((xB - xA) ** 2 + (yB - yA) ** 2)
   dBC= sqrt((xC - xB) ** 2 + (yC - yB) ** 2)
   dAC= sqrt((xC - xA) ** 2 + (yC - yA) ** 2)
   return dAB, dBC, dAC

La fonction étant définie, nous l’utilisons dans l’interpréteur :

>>> M = (3.4, 7.8)
>>> N = (5, 1.6)
>>> P = (-3.8, 4.3)
>>> dMN, dNP, dMP = longueurs(M, N, P)
>>> dMN
6.4031242374328485

 

Les listes

 

 

 

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.