Bienvenue dans notre cours ‘Programmation orientée objet en Python’. Alors, dans cette partie de cours, on va découvrir les collections en python. 

Rappel

Nous avons vu, dans la partie précédente du cours, comment utiliser les listes. En effet, les listes, les dictionnaires, les tuples et les ensembles (set) sont des collections prédéfinies que vous pouvez utiliser pour stocker un ensemble d’objets.

Dans la suite de cette partie, on va traiter les collections qui sont définies dans le module collections de python. Donc, on doit toujours importer la collection du module, avant de pouvoir l’utiliser.

Module collections en python

Le module collections contient des conteneurs de données spécialisés. La liste des conteneurs est la suivante : (lien : https://docs.python.org/3/library/collections.html)

Collection

Rôle

namedtuple

créer des sous-classes de tuple avec des champs nommés

deque

conteneur de type liste avec des ajouts rapides et des pops à chaque extrémité

chainMap

classe de type dict pour créer une vue unique de plusieurs mappages

Counter

sous-classe dict pour compter les objets hachables

OrderedDict

sous-classe dict qui se souvient que les entrées de commande ont été ajoutées

defaultDict

sous-classe dict qui appelle une fonction d’usine pour fournir les valeurs manquantes

UserDict

wrapper autour des objets du dictionnaire pour faciliter le sous-classement des dicts

UserList

wrapper autour des objets de la liste pour faciliter le sous-classement de la liste

UserString

wrapper autour des objets de chaîne pour faciliter le sous-classement de chaîne

Cette partie de cours va décrire les six premières collections qui sont : namedtuple, deque, OrdredDict, defaultDict , Counter et chainMap

La collection namedtuple

Un tuple est une collection immuable de données souvent hétérogène.

Exemple :

t=(11,22)
print(t) #affiche (11, 22)
print(t[0]) #affiche 11
print(t[1]) #affiche22

La classe namedtuple du module collections permet d’ajouter des noms explicites à chaque élément d’un tuple pour rendre ces significations claires dans un programme Python.

Comme les dictionnaires, un tuple nommé (namedtuple) contient des clés qui sont hachées à une valeur particulière. Mais au contraire, il prend en charge à la fois

l’accès à partir de la valeur clé et de l’itération, la fonctionnalité qui manque aux dictionnaires.

Exemple  1 : 

from collections import namedtuple #importation de la classe namedtuple 
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22) # instanciation par position ou en utilisant le nom du champs
print(p[0] + p[1]) # les champs sont accessibles par leurs indexes affiche :33
print(p.x + p.y) # les champs sont accessibles par nom affiche 33
print(p) # lisible dans un style nom=valeur affiche Point(x=11,y=22)

Exemple  2 :

soient deux classes déjà créées : Personne et Stagiaire. On crée un tuple nommé qui contient un tuple de Personnes et un stagiaire : 

from collections import namedtuple #importation de la classe namedtuple 
L= namedtuple('Per_Stg',['Per','Stg'])
l=L((p1,p2),s1)
print("test namedtuple:")
for e in l.Per:
e.AfficherInfos()
l.Stg.AfficherInfos()

Les méthodes intéressantes :

  • asdict() : Convertir une instance en un dictionnaire.  Exemple :
Point = namedtuple ('Point',['x','y'])
p=Point(11,y=22)
print(p._asdict()) # affiche {'x': 11, 'y': 22}
  • _replace(key=args)  : Retourner une nouvelle instance de notre tuple avec une valeur modifiée.

    Exemple :

    Point = namedtuple ('Point',['x','y'])
    p=Point(11,y=22)
    print(p._replace(x=4)) #affiche : Point(x=4, y=22)
  • _mytuple._fields :

    Récupérer les noms des champs de notre tuple. Elle est utile si on veut créer un nouveau tuple avec les champs d’un tuple existant.

    Exemple : 
    Point = namedtuple ('Point',['x','y'])
print(Point._fields) #affiche: (‘x’,’y’)
Color =namedtuple ('Color', 'red’,’green’, blue')
#Créer un nouveau tuple avec les champs de point et de color :
Pixel= namedtuple ('Pixel', Point._fields + Color._fields)
print(Pixel(11,22,128,266,0)) #affiche: Pixel(x=11, y=22, red=128, green=266, blue=0)

La collection deque

deque (Doubly Ended Queue) en Python est implémenté à l’aide du module “collections”. deque est préféré à une liste (list) dans les cas où nous avons besoin d’opérations d’ajout et de suppression plus rapides à partir des deux extrémités du conteneur, car deque fournit une complexité temporelle O(1) pour les opérations d’ajout et de suppression par rapport à la liste qui fournit O(n) complexité temporelle.

Remarque :

La complexité égale à O(1) signifie que le temps nécessaire pour ajouter un élément au début de de liste n’augmentera pas, même si cette liste a des milliers ou des millions d’éléments.

Méthodes intéressantes :

Méthode

Rôle

append(x)

append ajoute une seule valeur du côté droit du deque

appendleft(x)

append ajoute une seule valeur du côté gauche du deque

pop()

Faire sortir une seule valeur du côté droit du deque

popleft()

Faire sortir une seule valeur du côté gauche du deque

clear()

Vider le deque

Exemple :

from collections import deque
favorite_deque = deque(["Sammy", "Jamie", "Mary"])
favorite_deque.appendleft("Alice") #ajout au début de favorite_fish_deque favorite_deque.append("Bob") #ajout à la fin de favorite_fish_deque
print(favorite_deque) #affiche deque(['Alice', 'Sammy', 'Jamie', 'Mary', 'Bob'])
favorite_deque.pop() #affiche Bob
favorite_deque.popleft() #affiche: Alice
print(favorite_deque.clear()) #affiche None

La collection chainMap

Python contient un conteneur appelé “ChainMap” qui encapsule de nombreux dictionnaires dans une seule unité.

Exemple 1 :

from collections
import ChainMap  
d1={'a':1,'b':2} 
d2={'c':3,'d':4} 
d3= {'e':5,'f':6} 
#Définitiond’une ChainMap 
c= ChainMap(d1,d2, d3)  
print(c)
#ChainMap({'a':1,'b': 2}, {'c':3,'d':4}, {'e':5,'f': 6})

Exemple 2 :

from collections import ChainMap
d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
d3 = {'e': 5, 'b': 6}
# Définition d’une ChainMap
c = ChainMap(d1, d2, d3)
print(c) # ChainMap({'a': 1, 'b': 2}, {'c': 3, 'd': 4}, {'e': 5, 'b': 6})
for k, v in c.items(): #parcourir les éléments de c
print(k, v,end= ‘ , ‘) # Résulat : e 5, b 2, c 3, d 4, a 1

La collection Counter

La classe collections.Counter est une sous-classe de dict qui permet de compter des objets hachable. En fait c’est un dictionnaire avec comme clé les éléments et comme valeurs leur nombre.

⇒ class collections.Counter([iterable-or-mapping]) ceci retourne un Counter. L’argument permet de spécifier ce que l’on veut mettre dedans et qui doit être compté.

Exemple : 

from collections import Counter
c = Counter() # compteur vide
print(c)#affiche Counter()
c = Counter('gallahad') #compteur avec un iterable
print(c) #affiche Counter({'a': 3, 'l': 2, 'g': 1, 'h': 1, 'd': 1})
c = Counter({'red': 4, 'blue': 2}) # un compteur avec un mapping
print(c) #affcihe: Counter({'red': 4, 'blue': 2})
c = Counter(cats=4, dogs=8)#un compteur avec key=valeur
print(c) #affiche: Counter({'dogs': 8, 'cats': 4})

Remarque : 

Si on demande une valeur n’étant pas dans notre liste il retourne 0 et non pas KeyError

from collections import Counter
c = Counter(['eggs', 'ham'])
c['bacon’] # clé inconnue, affiche: 0

Méthodes intéressantes :

  • elements () :  retourne une liste de tous les éléments du compteur.

Exemple :

from collections import Counter
c = Counter(a=4, b=2, c=0, d=-2)
sorted(c.elements()) #affiche ['a', 'a', 'a', 'a', 'b', 'b']
  • most_common([n]) :retourne les n éléments les plus présents dans le compteur

    from collections import Counter
    c = Counter(a=4, b=2, c=0, d=-2)
    print(Counter('abracadabra').most_common(3))
    #affiche [('a', 5), ('b', 2), ('r', 2)]

  • substract([iterable or mapping]) : permet de soustraire des éléments d’un compteur. 

    from collections import Counter
    c = Counter(a=4, b=2, c=0, d=-2)
    d = Counter(a=1, b=2, c=3, d=4)
    print(c.subtract(d)) #affcihe Counter({'a': 3, 'b': 0, 'c': -3, 'd': -6})

La collection OrdredDict

Les collections.OrderedDict sont comme les dict. mais ils se rappellent l’ordre d’entrée des valeurs. Si on itère dessus les données seront retournées dans l’ordre d’ajout dans notre dict.

Méthodes intéressantes :

  • popitem(last=True) :  fait sortir une paire clé-valeur de notre dictionnaire et si l’argument last est a ‘True’ alors les pairs seront retournées en LIFO sinon ce sera en FIFO.

  • move_to_end(key, last=True) : permet de déplacer une clé à la fin de notre dictionnaire si last est à True sinon au début de notre dict.

Exemple : 

from collections import OrderedDict
d=OrderedDict()
d['a']=‘1’ #remplir d
d['b']='2'
d['c']='3'
d['d']='4’
d.move_to_end('b’)
print(d) #affiche OrderedDict([('a', '1'), ('c', '3'), ('d', '4'), ('b', '2')])
d.move_to_end('b',last=False)
print(d) #affiche OrderedDict([('b', '2'), ('a', '1'), ('c', '3'), ('d', '4')])
print(d.popitem(True)) #affiche ('d', '4')
print(d) #affiche OrderedDict([('b', '2'), ('a', '1'), ('c', '3')])

La collection defaultDict

defaultdict du module de collections permet de rassembler les informations dans les dictionnaires de manière rapide et concise. defaultdict se comporte différemment d’un dictionnaire ordinaire. Au lieu de soulever une KeyError sur une clé manquante, defaultdict appelle la valeur de remplacement sans argument pour créer un nouvel objet.

Exemple 1 : 

from Collections import defaultdict
my_defaultdict =defaultdict(list)
print(my_defaultdict["missing"]) #affcihe []

Exemple 2 : 

from collections import defaultdict
def default_message():
 return "key is not there"
defaultdcit_obj= defaultdict(default_message)
defaultdcit_obj["key1"]="value1"
defaultdcit_obj["key2"]="value2"
print(defaultdcit_obj["key1"]) #affiche: value1
print(defaultdcit_obj["key2"]) #affiche: value2
print(defaultdcit_obj["key3"]) #affiche: key is not there

Exemple 3 : 

from collections import defaultdict
defaultdcit_obj= defaultdict(lambda: "key is missing") #déclaration d’une fonction lambda pour afficher un message
defaultdcit_obj["key1"]="value1"
defaultdcit_obj["key2"]="value2"
print(defaultdcit_obj["key1"]) #affiche: value1
print(defaultdcit_obj["key2"]) #affiche: value2
print(defaultdcit_obj["key3"]) #appel de la fonction lambda, affiche: key is missing

Exemple 4 : 

Lorsque la classe int est fournie comme fonction par défaut, la valeur par défaut retournée est zéro.

from collections import defaultdict
defaultdcit_obj =defaultdict(int)
defaultdcit_obj["key1"]="value1"
defaultdcit_obj["key2"]="value2"
print(defaultdcit_obj["key1"]) #affiche: value1
print(defaultdcit_obj["key2"]) #affiche: value2
print(defaultdcit_obj["key3"]) #affiche: 0

Vous pouvez suivre notre liste des vidéos sur la programmation orientée objet  sur notre chaine youtube 9raytifclick (Darija: arabe marocaine) : POO en Python

Aussi, si vous voulez commencer l’apprentissage d’un langage de programmation, voilà notre cours : Langage Python Niveau 1 qui sera très utile pour vous (il vous aide à pratiquer tous les éléments de base de la programmation ; vus dans notre cours d’algorithmique).

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *