p-uplets, p-uplets nommés

Représentation des données: type construit

Plan

Introduction

Il est bien souvent utile de stocker des données qui sont liées et/ou on ne connait pas le nombre de données à stocker lors de la conception du programme. Par exemple, si vous souhaitez écrire un programme (ou une fonction) qui calcule la moyenne de vos notes, vous ne connaissez pas à l'avance le nombre de notes que vous allez avoir. Vous ne pouvez donc pas utiliser des variables! Et en plus cela pourrait être fastidieux. Imaginez, que vous sachiez qu'il y aura 10 notes....note1=...note2=...bref, fort heureusement il y a des solutions: les listes, les p-uplets, les dictionnaires...

Le p-uplet:

Un tuple (appelé aussi p-uplet) consiste en différentes valeurs séparées par des virgules. Les valeurs peuvent être de différents types mais une fois le tuple défini, ces valeurs sont immuables (on ne pourra pas les changer).

Exemple: tuple1 = 'a', 123 , True
est un tuple qui contient une chaine de caractère, un nombre et un booléen.

On accède aux valeurs du tuple par le biais de l'index, sachant que, tout comme dans les listes, on commence à l'index 0. Ainsi, print( tuple1[0]) affiche 'a'.

A noter qu'une chaine de caractère est un tuple consitué de chacune de ses lettres. t='Je suis un tuple', alors t[0] donne 'J'. On peut aussi convertir en tuple avec tt=tuple(t) ce qui est inutile dans le cas d'une chaine de caractères. Faites print(tt) vous verrez. Notez donc que tuple est une commande qui convertit en tuple.

On peut créer des tuples de tuples:

tuple2= 13, 17

tuple3= (tuple1, tuple2, 'tout ça !')

si l'on veut accéder au 13, il faut taper: print( tuple3[1][0])

On a précisé qu'un tuple est immuable mais il peut contenir des objets muables !

Le code suivant fonctionne car j'ai modifié un élément d'une liste qui se touvait dans le tuple.

t = [1, 2], [3, 4]
t[0][0] = 10

Le 1 est remplacé par 10.

L'exemple tuple1 = 'a', 123 , True est appelé emballage de tuple. Mais l'inverse est aussi possible:

a,b,c= tuple1 donnera 'a' pour a, 123 pour b et True pour c. Cela s'appelle un déballage(disperser) de tuple. On peut aussi disperser un tuple en mettant une * devant son nom

def moyenne2(a,b):
	return((a+b)/2

tuple=(4,6)
#moyenne2(tuple) ne fonctionnera pas
#car la fonction attend 2 variables et pas une seule
#il faut faire
print(moyenne2(*tuple))

Ceci peut servir d'astuce pour permettre à une fonction d'accepter un nombre variable de paramètres. Dans l'exemple suivant, le *args va regrouper tous les paramètres envoyés dans un unique tuple! Par convention le paramètre d'assemblage se nomme args

def printall(*args):
	print(args)

printall("bonjour",3,"toi")
printall("bonjour",3,"toi","encore")

Pour parcourir un tuple deux méthodes

prenoms="bruno","Marie"
for element in prenoms:
	print(element)
for i in range(len(prenoms)):
	print(prenoms[i])

Dans ce cas la première est mieux, vu que l'on a nullement besoin de l'index.

On peut avoir besoin de disperser un tuple si une fonction est prévue pour plusieurs arguments, mais que nous avons ces arguments dans un tuple. Par exemple, imaginons une fonction définie par "def distance(x1,y1,x2,y2)", et on a deux points p1=(p1x,p1y) et p2=p2x,p2y qui sont donc tuples. On peut appeler cette fonction avec: "distance(*p1,*p2)" car *p1 donne p1x,p1y.

 

Les p-uplets nommés

Afin de pouvoir nommer un tuple, il faut tout d'abord importer l'objet namedtuple de la bibliothèque collections avec la commande: from collections import namedtuple.

L'avantage à nommer un tuplet est de lui donner une structure figée et de pouvoir en rappeler les élèments qui le constituent avec un nom plutôt qu'avec un index. Cela peut bien souvent faciliter la compréhension du programme!

Prennons l'exemple classique des coordonnées d'un point dans l'espace. Nous pourrions faire:

A=( 2,3,4)
B= 5,6,7
# notez que les parenthèses ne sont pas indispensables !

pour afficher le x on ferait B[0] ou A[0]. Avec les tuples nommés on pourrait écrire A.x et B.x en ayant préalablement crée l'objet Point ainsi:

from collections import namedtuple
Point = namedtuple('point','x y z' ) # on peut séparer par des espaces ou des virgules</em>
p1=Point(1,2,3)
p2=Point(5,6,7)
print(p1.x)
print(p2.x)
# unpacking = le déballage fonctionne toujours:
x1,y1,z1= p1
 

A noter la notation p1.x, le point entre p1 et x indique l'utilisation de l'objet p1 qui va chercher la variable d'instance x.

Nous verrons tout cela en terminale.

Exercices

  1. En utilisant les tuples pour les coordonnées x,y de points dans un répère du plan, créer une fonction qui calcule la distance entre deux points d'un repère orthonormé.

  2. Avec des tuples de tuples qui contiennent le prénom et l'âge de plusieurs personnes, faire afficher 'bonjour Alim tu as 17 ans', et ainsi de suite pour les autres.

  3. Les commandes sum(tuple),len,min,max donnent respectivement la somme, le nombre d'éléments, le min et le max d'un tuple. Ecrire une fonction qui renvoie le tuple composé du min, max, moyenne.

  4. Comprendre ce que fait le code suivant et corriger tous les problèmes de spécification

    import math
    
     def fonction3(*args):
     	a=0
     	for element in args:
     		a=a+element
     	return(a/len(args))
    
    
     def fonction4(*args):
     	a=fonction3(*args)
     	b=0
     	for element in args:
     		b=b+(element-a)**2
     	return(b/len(args))
    
     def fonction5(*args):
     	return(math.sqrt(fonction4(*args)))
     

 

Android

De la programmation pour pc à la programmation pour téléphone.

A finir

Pas eu le temps de tout faire.....