# data[].attributes.body
DefautlDict : version developpee/amelioree de dict qui evite erreurs quand il n'y a pas existance d'un cle

Exemple :

from collections import DefaultDict

d = defaultdict(list)

d['Key1].append('val1')

print(d['Key1'])

print(d['thingNotInDict'])

Exemple :

from collections import defaultdict

di = defaultdict(lambda: "unknown")

di['nom'] = 'Ismail'

print(di['nom']) # Ismail

print(d['prenom']) # unknown

************ ChainMap : cree une chaine de dictionnaires. Quand tu cherches une cle, il donne prioritee ou premier dictionnaire ou il passe ou deuxieme dictionnaire si le cle n'existe pas dans premier dictionnaire et ainsi de suite

Exemple :

from collections import ChainMap

di1 = {'Nom': "Wick", 'Prenom': "John"}

di2 = {'bornIn': 1994, 'age': 32}

TwoDi = ChainMap(di1, di2)

print(TwoDi['Nom']) # return Wick la valeur du Nom

************ OrderedDict : une version organisee pour conservee l'ordre d'insertion

Exemple :

from collections import OrderedDict

di = OrderedDict()

di['a'] = "pomme"

di['b'] = "bonbon"

di['c'] = 3

print(di)

#Output:{a:"pomme", b:"bonbon", c:3}

}

# data[].attributes.body
ChainMap: c’est un outil en Python qui permet de regrouper plusieurs dictionnaires pour chercher les clés comme s’ils étaient un seul dictionnaire

1. syntaxe:

from collections import ChainMap

cm = ChainMap(dict1, dict2, dict3, ...)

----exemple1 ----

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

# data[].attributes.body
La collection Counter:

Counter est une classe spéciale qui sert à compter combien de fois chaque élément apparaît dans une liste, un texte, etc.

-----syntaxe-----

from collections import Counter

compte = Counter(itérable)

itérable: peut être : une liste, une chaîne, un tuple, etc.

Counter retourne un dictionnaire spécial qui compte les éléments

-----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

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.

-----exemple-----

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})

# data[].attributes.body
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.

-----syntaxe----

from collections import OrderedDict

# Création d’un OrderedDict

mon_dict = OrderedDict()

mon_dict['a'] = 1

mon_dict['b'] = 2

mon_dict['c'] = 3

print(mon_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.

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')])

# data[].attributes.body
1. ChainMap

Définition:

Regroupe plusieurs dictionnaires en une seule vue. Les recherches sont effectuées successivement dans chaque dictionnaire jusqu'à trouver la clé. Idéal pour gérer des configurations hiérarchiques.

Exemple:

python

from collections import ChainMap

d1 = {'a': 1, 'b': 2}

d2 = {'b': 3, 'c': 4}

chain = ChainMap(d1, d2)

print(chain['a']) # Output: 1 (trouvé dans d1)

print(chain['b']) # Output: 2 (première occurrence dans d1)

print(chain['c']) # Output: 4 (trouvé dans d2)

2. Counter

Définition :

Compte automatiquement les occurrences d'éléments dans un itérable (listes, chaînes, etc.). Les éléments deviennent des clés et leurs compteurs des valeurs.

Exemple :

python

from collections import Counter

liste = ['a', 'b', 'a', 'c', 'b', 'a']

compteur = Counter(liste)

print(compteur) # Output: Counter({'a': 3, 'b': 2, 'c': 1})

print(compteur.most_common(1)) # Output: [('a', 3)] (élément le plus fréquent)

3. defaultdict

Définition :

Un dictionnaire qui retourne une valeur par défaut si une clé est absente, évitant les erreurs `KeyError`. La valeur par défaut est définie par une fonction (ex: `int`, `list`).

Exemple :

python

from collections import defaultdict

dd = defaultdict(list) # Valeur par défaut: liste vide

dd['clé1'].append(1) # Pas besoin d'initialiser la clé

print(dd['clé1']) # Output: [1]

print(dd['clé2']) # Output: [] (clé absente → retourne une liste vide)

4. OrderedDict

Définition :

Maintient l'ordre d'insertion des clés (utile avant Python 3.7 où les `dict` standards ne le garantissaient pas). Offre des méthodes spécifiques comme `move_to_end()`.

Exemple :

```python

from collections import OrderedDict

od = OrderedDict()

od['z'] = 1

od['a'] = 2

od['c'] = 3

print(list(od.keys())) # Output: ['z', 'a', 'c'] (ordre d'insertion conservé)

od.move_to_end('z') # Déplace 'z' à la fin

print(list(od.keys())) # Output: ['a', 'c', 'z']

# data[].attributes.body
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 :-------

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

Autres types de valeurs par défaut :

int : 0

float 0.0

str : ' '

list [ ]

set :set()

dict :{ }

-----exemple2-----

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

-----exemple3 -----

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

exercice :

Écrire un programme Python qui compte combien de fois chaque mot apparaît dans une phrase donnée, en utilisant defaultdict(int)

phrase = "chat chien chat oiseau chien chat"

Exemple attendu à la fin:

{

'chat': 3,

'chien': 2,

'oiseau': 1

}