----------------------------------------------------------------
Structures de données en Python
----------------------------------------------------------------
Remarque :
	float :  
		0.3-0.1 != 0.2 !!!
		avec fraction, ça marche 
		from fractions import Fraction
		Fraction(3,10) - Fraction(1,10) vaut Fraction (1, 5) 

----------------------------------------------------------------		
Chaines de caractères : str()
	a='bacon'
	Immuable : non modifiable
	concaténation : +
	slice : [:]
	a.replace('c', 'll') : retourne 'ballon'
	t="voici du texte qu'on peut spliter"
	t2=t.split() : ['voici', 'du', 'texte', "qu'on", 'peut', 'spliter']
	'-'.joint(t2) : "voici-du-texte-qu'on-peut-spliter"

----------------------------------------------------------------
Liste : [,] list()
	l=[4, 2, 3]
	Collection extensible, réductible, ordonnée (triable)
	Données modifiables, doublons possibles, hétérogénéité possible.
	=> modifiable , ordonné, avec doublon
	Optimisé pour accès, mais pas l''appartenance, ni la suppresion.
	if l: # vrai si l non vide
	l[0] # le premier 
	l[1] # vaut 2
	len, min, max, sum # (si possible)
	append(), pop(), insert(), clear(), remove(), sort(), reverse() # modifie l
	l.append(1) # [4, 2, 3, 1] - pas d'update, pas de add
	sorted(l) # retourne une liste : [1, 2, 3, 4] -  l non modifié
	l.sort() # retourne rien, l modifié, trié : [1, 2, 3, 4]
	del l[0] # l modifié : [2, 3, 4]
	slice[:]
	a=b.copy() # équivalent à a=b[:]
	'-'.join(l)
	appartenance : x in l1
	non appartenance : x not in l1
	union : l1+l2 : union
	intersection [x for x in l1 if x in l2]
	différence [x for x in l1 if x not in l2]

----------------------------------------------------------------
Tuple : (,) tuple()
	t=(1, 2, 3)
	Collection non extensible, non réductible, ordonnée (triable)
	Données non modifiables, doublons possibles, hétérogénéité possible.
	=> non modifiable , ordonné, avec doublon
	Optimisé pour accès, mais pas l''appartenance. Suppresion impossible.
	tout ce qu''on fait sur une liste sans la modifier, on peut le faire sur un tuple
	# tuple unpacking
	(a,b)=[3,4] #donne les valeurs 3 et 4 à a et b
	a, b = 3, 4 # idem sans parenthèses et tuple à droite 
	a,b=b,a #inversion en 1 ligne!

----------------------------------------------------------------
Dictionnaire : {'':,'':,} dict()
	d={'H':(1,1), 'He':(2,4), 'Li': (3,7) }
	Collection extensible, réductible, non ordonnée (non triable)
	Données : couples clé-valeur
		clé non modifiable, doublon impossible, type string ou int homogène
		valeur modifiables, doublons possibles, hétérogénéité possible.
	Utilise une table de hashage : optimisé pour l''appartenance, l''accès et la suppression.
	=> clé-valeur, modifiable , ordonné, sans doublon sur la clé 
	Accès par index : d['He'] vaut (2,4)
	d[key]=value
	if d: # vrai si d non vide
	d.keys(), d.values(), d.items()
	for k in d
	for k in d.keys() # équivaut à for k in d
	for v in d.values()
	for k, v, in d.items()
	list(d.keys()), list(d.values()), list(d.items()) # pour avoir des listes
	list(d.keys())[0] # la première clé
	list(d.values())[0] # la première value
	list(d.items())[0]  # le premier item : un tuple 
	key in d # vrai si key in d
	d.clear(), d.update({:}), del(d[key]), 
	min(d), max(d) # key min et max
	pas : append(), pop(), add(), insert(), remove(), sort(), [:]

----------------------------------------------------------------
Ensemble : {,} set()
	s={1, 2, 3}
	Collection extensible, réductible, non ordonnée (non triable)
	Données non modifiables, doublons impossibles, hétérogénéité possible.
	=> modifiable , non ordonné, sans doublon
	Utilise une table de hashage : optimisé pour l''appartenance et la suppression.
	Pas d''accès par index.
	if s: # vrai si s non vide
	list(s)[0] # le premier élément de la liste 
	2 in s: True. for e in s: print(e) # 1 2 3
	add(), pop(), clear(), remove(), update()
	pas : append(), insert(), sort(), [:], del()
	s1.union(s2) : s1 | s2
	s1.intersection(s2) : s1 & s2
	s1.difference(s2) : {x for x in s1 if x not in s2}

#----------------------------------------------------------------
# Annexes : 
#
# Exemples de mesure de durée de in, add, del sur list, dict et set

import time
import random

nb_elts = 1_000_000
elt_test = 987_654

l=[x for x in range(nb_elts)]
random.shuffle(l)
s=set(l)
d={str(l[x]):l[x] for x in range(nb_elts)}

#----------------------------------------------------------------
# appartenance ((list, dict, set) (in, in, in))
debut = time.time()
in_l = elt_test in l
fin = time.time()
print(f"{elt_test} dans la liste: {in_l} - durée: {fin-debut:.7f}")

debut = time.time()
in_d = str(elt_test) in d
fin = time.time()
print(f"{elt_test} dans le dico : {in_d} - durée: {fin-debut:.7f}")

debut = time.time()
in_s = elt_test in s
fin = time.time()
print(f"{elt_test} dans le set  : {in_s} - durée: {fin-debut:.7f}")

#----------------------------------------------------------------
# accès ((list, dict, set) (l[], d[key], list(s)[]))
debut = time.time()
value = l[elt_test]
fin = time.time()
print(f"      l[{elt_test}] = {value} - durée: {fin-debut:.7f}")

debut = time.time()
value = d[str(elt_test)]
fin = time.time()
print(f"      d[{elt_test}] = {value} - durée: {fin-debut:.7f}")

debut = time.time()
value = list(s)[elt_test]
fin = time.time()
print(f"list(s)[{elt_test}] = {value} - durée: {fin-debut:.7f}")

#----------------------------------------------------------------
# ajout ((list, dict, set) (append, update, update))
value = len(l)+1

debut = time.time()
l.append(value)
fin = time.time()
in_l = value in l
print(f"{value} ajouté dans liste: {in_l} - durée: {fin-debut:.7f}")

debut = time.time()
d.update({str(value):value})
fin = time.time()
in_d = str(value) in d
print(f"{value} ajouté dans dico : {in_d} - durée: {fin-debut:.7f}")

debut = time.time()
s.update({value})
fin = time.time()
in_s = value in s
print(f"{value} ajouté dans set  : {in_s} - durée: {fin-debut:.7f}")

#----------------------------------------------------------------
# suppression ((list, dict, set) (remove, del, remove))
debut = time.time()
l.remove(elt_test)
fin = time.time()
in_l = elt_test not in l
print(f"{elt_test} supprimé ds liste: {in_l} - durée: {fin-debut:.7f}")

debut = time.time()
del(d[str(elt_test)])
fin = time.time()
in_d = elt_test not in d
print(f"{elt_test} supprimé du dico : {in_d} - durée: {fin-debut:.7f}")

debut = time.time()
s.remove(elt_test)
fin = time.time()
in_s = elt_test not in s
print(f"{elt_test} supprimé du set  : {in_s} - durée: {fin-debut:.7f}")