Python Types de donnees
Un article de Mangue.org, l'encyclopéde libre.
Le langage Python va nous permettre de combiner des types simples comme des entiers avec des types plus évolués comme des listes ou des dictionnaires. Dans ce cours, nous allons essayer de voir les différents types et comprendre comment s'en servir.
| Sommaire |
Les entiers
Les entiers peuvent être courts (par défaut) ou longs (longueur illimitée). La déclaration d'un long, se fera en ajoutant un L à la fin du nombre (555555555555L).
Les opérations sur les grands entiers sont l'une des grandes qualités du langage.
Les entiers en octales et hexadécimales sont aussi reconnus.
>>> 0x3f #entier en héxa 63 >>> 077 #entier en octale 63 >>>
Les réels
Les réels se déclarent de la manière suivant :
>>> x=1.3 >>> print x 1.3 >>> x=1.0 >>> print x 1.0 >>> x=float() >>> print x 0.0 >>>
Les réels permettent aussi d'utiliser des exposants sous la forme :
>>> 3E2 300.0 >>> 3e2 300.0 >>> 3e-2 0.029999999999999999 >>>
Opérateurs des types numériques
Plusieurs opérations sont possibles, et c'est à force de manipulation que nous pourrons les utiliser au mieux.
| Opérateur | Description |
| x or y | ou logique |
| x and y | négation logique |
| not x | négation logique |
| <, <=, >, >=, ==, <>, != | opérateurs de comparaison |
| is, is not | test d'identité |
| in, not in | appartenance à une séquence |
| x|y | ou bits-à-bits |
| x^y | ou exclusif bits-à-bits |
| x&y | et bits-à-bits |
| x<<y,x>>y | décalage de x par y bits |
| x+y,x-y | addition ou concaténation / soustraction |
| x*y | multiplication ou répétition |
| x/y,x%y | division / reste de la division (modulo) |
| -x | négation unaire |
| Danger |
| En cas de mélange de types numériques pendant une opération, le résultat sera du type le plus complexe des opérandes. |
>>> 1/2 0 >>> 1.0/2 0.5 >>>
Le type chaîne
Le type caractère n'existe pas par rapport à d'autres langages(C). la chaîne de caractères est une séquence de caractères non modifiable directement :
>>> var="bongour" >>> print var bongour >>> var[3]=j Traceback (most recent call last): File "<stdin>", line 1, in ? NameError: name 'j' is not defined >>> var=var[0:3]+"j"+var[4:] >>> print var bonjour >>>
Les chaînes peuvent être déclarées avec un simple guillemet :
>>> d='bonjour' >>> print d bonjour >>>
Ils peuvent aussi être avec un double guillemet, cela est utile quand nous pouvons avoir une apostrophe dans le texte rentré :
>>> d='bonjour'
>>> print d
bonjour
>>> d="bonjour"
>>> print d
bonjour
>>> d="aujourd'hui"
>>> print d
aujourd'hui
>>> d='aujourd'hui'
File "<stdin>", line 1
d='aujourd'hui'
^
SyntaxError: invalid syntax
>>>
L'emploi de triple guillemet est possible si nous voulons rentrer un texte sur plusieurs lignes :
>>> d="""ma chaîne ... est sur plusieurs ... lignes""" >>> print d ma chaîne est sur plusieurs lignes >>>
| Astuce |
| >>> d'aujourd\'hui' >>> print d aujourd'hui >>> Ici, l'apostrophe n'est pas une fin de chaîne mais bien une apostrophe dans un texte. |
Quelques opérations sur les chaînes
Le type string, 'str', comme dans beaucoup de langage est très souvent utiliser. Il faut savoir les manipuler et pour cela voici un petit tableau :
| Opérateur | Description |
| s1= | chaîne vide |
| s2="l'apostrophe" | utilisation des guillemets |
| bloc="""possibilité de retour chariot """ | bloc a triple guillemets |
| s1+s2 , s2*3 | concaténation , répétition |
| s2[i] , s2[i:j], len(s2) | indice, extraction , longueur |
| "Hello %s" % "World" | formatage de chaîne |
| for x in s2 , 'o' in s2 | itération , appartenance |
Formatage de chaîne => %
Nous pourrons utiliser le % comme suit :
>>> print "c'est le numéro %d qui a gagne la course et les %f euros" %(28,2000) c'est le numero 28 qui a gagne la course et les 2000.000000 euros >>>
avec les différents formats suivants :
| Opérateur | Description |
| %c | format caractère |
| %d | format entier |
| %i | format entier (effet semblable à d) |
| %f | format décimal (virgule flottante) |
| %e | format de notation scientifique |
| %E | idem |
| %g | utilise %f ou %e, selon la longueur de la valeur décimale |
| %G | utilise %f ou %E, selon la longueur du résultat |
| %o | format octal |
| %s | format chaîne ou autres objets |
| %u | format entier non signé |
| %X | format hexadécimal (majuscule) |
| %x | format hexadécimal (minuscule) |
Donc nous pouvons bien comprendre le schéma suivant
Emploi de plusieurs valeurs dans un chaîne
Les tuples
Les tuples sont des collections de valeurs, non modifiable directement :
>>> x=(1,2) >>> x[0] 1 >>> x[0]=2 Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: object doesn't support item assignment >>> x=(2,x[1]) >>> print x (2, 2) >>>
Ils peuvent être très pratique dans la sauvegarde de données, car ils peuvent contenir n'importe quel genre d'objet et ne sont pas modifiables en affectation, ce qui permet d'intégrer une certaine intégrité ou rigueur :
>>> tuples=(0,3.14,'Bonjour') >>>
Quelques opérations sur les tuples
| Opération | Description |
| ( ) | Un tuple vide |
| n1=(0,) | Un tuple à un élément |
| n2=(0,1,2,3) | Un tuple à quatre éléments |
| n2=0,1,2,3 | Pareil qu'au dessus |
| n3=('abc',('def','ghi')) | Tuples avec inclusion |
| t[i], n3[i][j] | Indicage |
| n1[i:j] | extraction |
| len(n1) | longueur |
| n1+n2 | concaténation |
| n2*3 | répétition |
| for x in n2 | parcours |
| 3 in n2 | appartenance |
Les listes
La seule différence que nous pouvons trouver avec les tuples c'est le fait que les listes sont modifiables directement avec l'indexation :
>>> L=[2,2,3,4] >>> print L [2, 2, 3, 4] >>> L[0]=1 >>> print L [1, 2, 3, 4] >>>
Quelques opérations sur les listes
Le type liste est trouvé dans des langages, comme le SML, mais le langage Python permet une utilisation très facile.
| Opération | Description |
| L1=[] | Une liste vide |
| L2=[0,1,2,3] | Une liste à 4 éléments |
| L3=['abc,['def','ghi']] | Inclusion |
| L2[i], L3[i][j] | Indicage |
| n1[i:j] | extraction |
| len(L1) | longueur |
| L1+L2 | concaténation |
| L2*3 | répétition |
| for x in L2 | parcours |
| 3 in L2 | appartenance |
| L2.append(4) | ajout |
| L2.sort() | tri |
| L2.index(n) | recherche n dans liste |
| L2.reverse() | inversion |
| del L2[k] , L2[i:j]=[] | effacement |
| L2[i]=1 | affectation par indice |
| L2[i:j]=[4,5,6] | affectation par tranche |
| range(n) | Liste de n entiers |
Les dictionnaires
Le dictionnaire est la représentation d'une liste mais indexé pour une recherche ultra rapide suivant la valeur d'indexe passé. Les valeurs ne peuvent être atteinte qu'en donnant la clé d'indexation. Un exemple va nous éclairer sur son mécanisme :
>>> dico={1:'monpremier',2:'mondeuxieme',4:'montroisieme'}
>>> dico[1]
'monpremier'
>>> dico[3] #erreur car la clé '3' n'existe pas, il ne vas pas chercher le troisième
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 3
>>> dico[4] #va chercher la valeur représenté par la clé et non le quatrième
'montroisieme'
>>>
Nous pouvons affecté un dictionnaire selon le même mécanisme :
>>> dico={'notemax':10,'notemin':0}
>>> dico['notemax']
10
>>> dico[1] #erreur car pas de clé nommé '1'
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: 1
>>> dico['notemax']=20 #affectation car clé présente
>>> print dico
{'notemax': 20, 'notemin': 0}
>>> dico['moyenne']=10 #ajout car clé non présente
>>> print dico
{'notemax': 20, 'moyenne': 10, 'notemin': 0}
>>>
Quelques opérations sur les dictionnaires
Les dictionnaires sont très utile pour représenté des données et un avantage est leur coût au niveau complexité en temps. Comme le dictionnaire est indexé en clé, ce coût sera en O(1) (coût constant).
| Opération | Description |
| d1={} | dictionnaire vide |
| d2={'one' : 1, 'two' : 2} | Un dictionnaireà deux élément |
| d3={'count':{'one' : 1, 'two' : 2}} | Inclusion |
| d2['one'] , d3['count']['one'] | Indicage |
| d2.has_keys('one') | extraction |
| d2.keys() | Liste des clefs |
| d2.values() | Liste des valeurs |
| len(d1) | Longueur |
| d2[cle]=[nouveau] | affectation |
| del d2[cle] | suppression |
Le dictionnaire nous permet aussi, tout comme les listes et les tuples, l'inclusion. Le fait d'inclure un dictionnaire dans un autre dictionnaire nous fera réfléchir sur la méthode d'indexation :
>>> table={
... 'eleve1' : { 'note' : { 'matiere1' : 20 , 'matiere2' : 17 },'absence':10},
... 'eleve2' : { 'note' : { 'matiere1' : 17 , 'matiere2' : 20 },'retard':10}
... }
>>> table['eleve1']['note']
{'matiere1': 20, 'matiere2': 17}
>>> table['eleve1']['note']['matiere1']
20
>>> table['eleve1']['note']['matiere1']==table['eleve2']['note']['matiere2']
1
>>> table['eleve1']['note']['matiere1']==table['eleve2']['note']['matiere1']
0
>>> table['eleve1']['absence']
10
>>> table['eleve2']['absence]
Traceback (most recent call last):
File "<stdin>", line 1, in ?
KeyError: absence
>>>
