Python-Structures de données
Les types de données
On peut utiliser la fonction type() pour déterminer le type d'une entité.>>>type(3.5)
< class 'float' >
Python permet de manipuler deux catégories de types:
- Les types simples: les entiers, les réels, les nombres complexes et les booléen.
- Les types structurés appelés aussi conteneurs(chaine,liste,tuples,tableaux) et (ensemble, dictionnaire).
Type entier (int)
>>>5
5
nombre avec des opérateurs mathématiques
>>> 5+6
11
Le type réel (float)
>>>5.23 * 6.1
31.9030000000000002
>>>5.5 +5.5
11.0
Le type complexe (complex)
(1+2j)
>>>a=1+2j
>>>a.real #partie réelle
1.0
>>>a.imag #partie imaginaire
2.0
>>>a.conjugate() #conjugué
(1-2j)
Le type booléen (bool)
>>>True
True
>>>"True"
'True'
>>> 5 == 5
True
>>> 7>10
False
opérations de base
Opérateurs addition, soustraction, multiplication et division
+, -, *, /, %, //
Opérateurs puissance, valeur absolue, ...
**, pow, abs, ...
Opérateurs de comparaisons
==, is, !=, is not, >, >=, <, <=
Opérateurs bitwise
&, ^ , |, <<, >>
Opérateurs logiques
or, and, not
Conversion de types
>>>str(5)
'5'
>>>str5.6)
‘5.6’
>>>str(True)
'True'
>>>int("3")
3
>>>int("5.6") ==>erreur
>>>float("5.6")
5.6
>>>bool("True")
True
random
import random
dmg = random.randrange(valeur_min,valeur_max)
eval("5+3")==>8
eval(print("hello")) ===> hello
Les conteneurs:
Python permet de regrouper un ensemble de données de même type ou de type différents à l'intérieur de structures de données spéciales appelées conteneurs. Il existe deux catégories de conteneur:-Les conteneurs séquentiels: (liste, tuple et chaines de caractères) les éléments sont rangés en utilisant un index(commençant de 0)
-Les conteneurs à accès directs:(Dictionnaires et ensembles)
Les conteneurs mutables:liste, tableau, ensemble,dictionnaire
Les conteneurs immutables:chaine de caractère, tuple
Les conteneurs séquentiels:
Une chaine de caractère est une séquence de caractères encadrés par des côtes '' ou des guillemets ""
>>> "5"+"6"
‘56'
>>> "je suis une chaine"
'je suis une chaine'
>>> 'je suis une chaine'
'je suis une chaine'
>>> "j'ai bien compris"
"j'ai bien compris"
>>> 'J\'ai toujours la meme chose'
"J'ai toujours la meme chose"
>>> """je suis
... une chaine
... sur plusieurs
... lignes ... """
'je suis\nune chaine\nsur plusieurs\nlignes ... '
>>> s = 'i vaut'
>>> i = 1
>>> print (s + ' ' + str(i) )
i vaut 1
>>> print ('*-'*5 )
*-*-*-*-*-
Accès au caractères:
>>> "bonjour"[0] #première lettre de la chaine
'b'
>>> "bonjour"[3];
'j'
>>>"bonjour"[-1] #dernière lettre de la chaine
'r'
Sous-chaine:
début:fin:pas
>>> "bonjour"[3:5] #caractères commence de l'indice 3 jusqu'a 5(non inclu)
'jo'
>>> "bonjour"[:] #copie toute la chaine aussi [::]
'bonjour'
>>> "bonjour"[2:]; "bonjour"[:3] #de caractère d'indice 2 jusqu'a la fin de la chaine
'njour'
'bon'
>>>"bonjour"[:3]
'bon'
>>>"bonjour"[1:-1]
'onjou'
>>> 'bonjour'[-1::-1] #commence de dernier caractère avec un pas=-1 au début de la chaine
'ruojnob'
>>>ch='bonjour'
>>>ch[0]='B' # ERREUR le type chaine est immutable(inchangeable)
Remarque:
La modification directe d'un caractère (ou une partie de la chaine) n'est pas permise en python
pour palier à ce problème, on peut créer une nouvelle chaine comportant les modifications:
>>>ch2='B'+ch[1:]
>>>ch2
'Bonjour'
ch='bonjour'
* Taille de la chaine: >>>len(ch) donne 7
* test d'appartenance: >>>'j' in ch donne True >>>'j' not in ch donne Flase
* Concaténation : ch+' tout le monde'
* répétition: ch*2 donne 'bonjourbonjour'
* Recherche de la position d'un élément: ch.index('j') donne 3
* Calcule le nombre d'occurence:ch.count('o') donne 2
https://developers.google.com/edu/python/strings
* test de la nature d'une chaine: alphabétique(isalpha), numérique(isdigit), espace(isspace) ou alphanumérique(isalnum)
>>>ch1='1234';ch2='abc';s3=' '
>>>ch1.isdigit() donne True
>>>ch2.isalpha() donne True
>>>ch3.isspace() donne True
>>>ch4="Python3"
>>>ch4.alnum() donne True
*Conversion majuscule/minuscule: ch2.upper() donne 'ABC' 'PYTHON'.lower() donne 'python'
*Commence avec/se termine avec: >>>'Python'.startswith('Py') donne True 'Python'.endswith('n') donne True
*Eliminer les espaces à droite et à gauche: avec la commande strip:
>>>' Python '.strip()
'Python'
*Décomposition: commande split: décompose une chaine en utilisant un caractère ou une sous chaine comme séparateur. Le résultat est toujours une liste:
>>> 'mot1 mot2 mot3'.split()
['mot1','mot2','mot3']
>>> 'mot1 mot2 mot3'.split('m')
['', 'ot1 ','ot2 ','ot1']
>>> ch ="Bonjour monde"
>>>print(ch)
Bonjour monde
>>>ch=ch.split(" ")[0]
>>>print(ch)
Bonjour
*coller plusieurs chaines: commande join: oppération réciproque de split:
>>>' '.join(['mot1','mot2','mot3'])
'mot1 mot2 mot3'
>>>'-'.join(['mot1','mot2','mot3'])
'mot1-mot2-mot3'
*Recherche d'une sous chaine dans une autre chaine: commande find:
>>>s='python est un langage orienté objet'
>>>s.find('python')
0
>>>s.find('python',10) #on commence la recherche à partir de l'indice 10
-1
-1 indique que la sous chaine 'python' n'existe pas dans la chaine s
*Remplacer une sous chaine par une autre: commande replace:
>>>s='python est un langage objet'
>>>s.replace('objet','orienté objet')
'python est un langage orienté objet'
*Affichage formaté: commande format: Syntaxe:chaine.format(parametres):
>>>for i in range(4):
print('L[{}]:?'.format(i))
L[0]:?
L[1]:?
L[2]:?
L[3]:?
>>>print('{0:d}={0:b} en binaire'.format(4))
4=100 en binaire
>>>print('{0}/{1}={2:.3f}'.format(456,87,456/87)) #.3f = précision de 3 chiffres
456/87=5.241
>>> c=[4,5,6]
>>>c
[4,5,6]
>>>["Movie", "Musique", "games"]
['Movie', 'Musique', 'games']
>>>["Movie", "Musique", "games"][0]
'Movie'
>>>print ("I like "+["Movie", "Musique", "games"][1])
I like Musique
>>>print ("I like ",["Movie", 6, "games"][1])
I like 6
Commandes spécifiques aux listes
Création:
*liste vide:>>>L=[] ou >>>L=List() >>>L donne []
*Commande list:
>>>L=list(range(5));L donne [0,1,2,3,4]
*avec les []: >>>L=[4,-5,'a',True]
* Liste en compréhension:
Il existe des astuces python qui permettent d' optimiser le code . Une de ces astuces est la compréhension de liste ( ou Liste en compréhension ou list comprehension ). L'idée est simple: simplifier le code pour le rendre plus lisible et donc plus rapide à écrire et plus simple à maintenir.
http://apprendre-python.com/page-comprehension-list-listes-python-cours-debutants~
Syntaxe
new_list = [function(item) for item in list if condition(item)]
>>>L=[x for x in range(20) if x%7==1]
[1,8,15]
>>>L=[x+y for x in range(5) for y in range(4)]
*Par conversion:
>>>ch='bonjour';L=liste(ch);L #conversion d'une chaine en liste
['b','o','n','j','o','u','r']
>>>t=(1,2,3);L=list(t);L #conversion d'un tuple en liste
['1','2','3']
Modification
On utilise l'opérateur d'affectation =*d'un élément:
>>>L=list(range(4));L
[0,1,2,3]
>>>L[0]='w';L
['w',1,2,3]
*d'un slice:
>>>L[2:]=[44,55];L
['w',1,44,55]
Ajout
*d'un élément à la fin :on utilise la commande append>>>L.append('xxxx');L
['w',1,44,55,'xxxx']
*d'un slice:avec la commande extend
>>>L.extend([True,False]);L
['w',1,44,55,'xxxx',True,False]
>>>L.extend((1,2));L
['w',1,44,55,'xxxx',True,False,1,2]
>>>L.extend('abc');L
['w',1,44,55,'xxxx',True,False,1,2,'a','b','c']
*Insertion:avec la commande insert
>>>L
[1,2,3,4]
>>>L.insert(2,456);L
[1,2,456,3,4]
Suppression
*d'un élément:trois possibilités:del,remove et pop>>>L=[1,2,3,4]
>>>del L[0];L # supprime L[0]
>>>[2,3,4]
>>>L.remove(4)# supprime l'élément 4 de L
>>>[2,3]
>>>L.pop()#supprime le dernier élément de L
>>>[2]
*d'un slice:
>>>L=list(range(15));L
>>>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>>del L[0:4];L
[4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>>del L[0::2];L
[5, 7, 9, 11, 13]
Copie
*Copie normale:avec la commande copy>>>L=[1,2,3]
>>>from copy import copy
>>>A=L
>>>B=copy(L)
>>>id(L);id(A);id(B) # B est une copie mais A est un autre nom de L
44265064
44265064
44227400
>>>L[1]='x';L;A;B #A change (il s'agit de la même variable), B reste inchangé
[1,'x',3]
[1,'x',3]
[1,2,3]
*copie profonde: avec la commande deepcopy
deepcopy crée une nouvelle référence sur tous les éléments et les sous éléments de la liste
>>>from copy import copy,deepcopy
>>>L=[[1,2], 4,5]
>>>A=copy(L)
>>>B=deepcopy(L)
>>>id(L[0]);id(A[0]);id(B[0])
51305736
51305736
51376648
>>>A[0][0]=0;L;A
[[0,2], 4,5]
[[0,2], 4,5]
Tri
*avec la commande sort>>>L=[4,5,1,6]
>>>L.sort(); L
[1,4,5,6]
Inversion
*avec la commande reverse>>>L.reverse()
>>>L
[4,5,4,1]
Commandes spécifiques aux tuples
Création:
*Tuples vides:>>>t=()
>>>type(t)
class 'tuple'
>>>t=tuple();t
()
*Création directe avec les():
>>>t=(1,2,3)
>>>t=1,2,3
>>>type(t)
type 'tuple'
*Création avec la commande tuple:
>>>t=tuple(range(5));t
(0,1,2,3,4)
*Création par conversion:
>>>L=[1,2,3];t=tuple(L)
>>>t
(1,2,3)
*en compréhension:
>>>t=tuple(i for i in range 12) if i%3==0)
>>>t
(0,3,6,9)
modification
Les tuples sont non modifiables, toute tentative de mise à jour déclanche une erreur.>>>t=(1,2,3)
>>>t[1] =4
TypeError: 'tuple' object does not support item assignment
>>>del t[0]
TypeError: 'tuple' object doesn't support item deletion
Ajout d'un élément:
>>>t=t+(1,);t(1,2,3,1)
-On écrase l'ancien tuple avec le résultat de la concaténation de t avec le tuple(1,)
-(1,)est un tuple composé d'un seul élément, la virgule est obligatoire.
Les tableaux sont des conteneurs qui ne peuvent être utilisés que si le module numpy est installé et chargé. Python autorise les types suivants pour les tableaux:
entier,réel, booléen et nombre complexe.
Les tableaux sont des conteneurs séquentiels (ordonnés) et modifiable (mutables).
Les tableaux à une dimension:
Création:
*Création directe:
>>>from numpy import *
>>>a=array([4,3,6])
>>>a
array([4,3,6])
*tableau vide:
>>>e=empty(3)
>>>e
array([4.23e-32,0.,0.])
*Des zéros partout:
>>>z=zeros(4);z
array([0.,0.,0.,0.])
*Des uns partout:
>>>z=ones(4);z
array([1.,1.,1.,1.])
*Création par à partir d'un intervalle:
>>>a=arange(7) # arange= array range
>>>a
array([0, 1, 2, 3, 4, 5, 6])
>>>a=arange(2.);a
array([0., 1.])
>>>a=arange(1,10,2);a
array([1, 3, 5, 7, 9])
>>>a=arange(0.,1.,.25);a
array([0., 0.25, 0.5, 0.75])
Accès:
même système d'indexation que les listes
>>>a
array([0,1,2,3,4,5,6])
>>>a[0];a[size(a)-1]
0
6
>>>a[-1];a[-size(a)]
6
0
>>>a[:4]
array([0,1,2,3])
>>>a[3:]
array([3,4,5,6])
>>>a[1::2]
array([1,3,5])
Ajout d'un élément:
>>>a
array([0,1,2])
>>>append(a,20)
array([0,1,2,20])
Modification
>>>a[0]=9
>>>a
array([9,1,2])
Les tableaux à deux dimensions:
Création:
>>>a=array([[1,2,3],[5,6,4]]) #array([[ligne1],[ligne2]])
>>>a
array([[1,2,3],
[5,6,4]])
Les opérations communes sur un conteneur séquentiel
*Taille : len(C)>>>len("Hello")
5
lengeur d’un tableau
>>>len [1,2,6,3,4]
5
>>>len["hello","Nick"]
2
*Accès à un élément: C[index de l'élément] : les index permis sont compris entre 0 et len(c)-1 pour un parcours de gauche à droite et entre -1 et -len(c) pour un parcours de droite à gauche.
*Accès à une partie des éléments: c[i:j] : renvoie un conteneur constitué des éléments se trouvant entre la position i et la position j-1.
-c[:i] : renvoie la sous liste constituée des éléments d'indices compris entre 0 et i-1
-c[i:] : renvoie la sous liste constituée des éléments d'indices compris entre i et len(c)-1
-c[::] : renvoie toute la liste
-c[::-1] : inverse la liste des éléments
*Accès à une partie des éléments avec la notion de pas:c[i:j:k]: renvoie un conteneur stockant les éléments entre les deux positions i et j-1 en effectuant des saut d'amplitude k
*test d'appartenance: x in c
*test de non appartenance : x not in c
*concaténation: l'opérateur + permet de coller les éléments de deux ou plusieurs conteneurs.
>>>c+c
[4,5,6,4,5,6]
*Répétition: c*n : l'opérateur * permet de créer de créer un conteneur contenant n copies de c
*Recherche de la position d'un élément: c.index(x)
*Calcul de nombre d'occurrence d'un élément: c.count(x)
*Minimum et maximum: min(c), max(c)
>>>sorted ([5,50,2,4])
[2,4,5,50]
>>>sorted(["Z","N","A","B"])
['A', 'B', 'N', 'Z']
>>>sorted(["B", "A","o","z","c", 5, 2.3]) ==>erreur
>>>sorted(["B", "A","o","z","c", "5", "2.3"])
['2.3', '5', 'A', 'B', 'c', 'o', 'z']
Les conteneurs à accès directs:
- Ensemble vide: >>>s=set() >>>s donne set() ou >>>s={}
- la commande set: >>>s=set(range(4)) >>>s donne {0,1,2,3}
- >>>s={3,3,5} >>>s donne {3,5}
- >>>s={x+2 for x in range(5)} s={2,3,4,5,6}
dictionnaire
>>>{"name" :"Nick", "age":27 , "Hobby" :"code"}
{'name': 'Nick', 'age': 27, 'Hobby': 'code'}
>>>{"name" :"Nick", "age":27 , "Hobby" :"code"}["name"]
‘Nick'
>>>{"name" :"Nick", "age":27 , "Hobby" :"code"}["age"]
27