"""

help for file

a help texte

"""

import claudecnx.useIt2021_01 as go # module externe de claudecnx; namespace = go

import itertools # module interne, voir <class 'generator'>

Aide sur un fichier.py

appel avec:

help("fichier") # aide sur le "fichier.py"

"""

module externe de claudecnx

D:\\python\\ExemplesPython\\use_it\\go_2021_01.py

Python 3 suppose que votre code source - c'est-à-dire chaque fichier .py -

est encodé en UTF-8 par défaut

"""

import os # module interne; os.system("pause")

import collections.abc # module interne, collections.abc.Iterable

Aide sur un fichier.py importé
comme namespace nommé go par exemple

help(go)

ou directement sur le fichier

help("claudecnx.useIt2021_01") # aide sur un fichier.py contenu dans un sous-dossier

def isIterable(elt): # indique si un elt est iterable, enumerable; as booleen

    """

    help() pour isIterable() hors de ce module: help(go.isIterable) # go as namespace

    :param elt: indique si un elt est iterable, enumerable; as booleen True or False

    import collections.abc # module interne, collections.abc.Iterable

    """

    if isinstance(elt, collections.abc.Iterable):

Aide sur une fonction

Aide sur une fonction dans le fichier importé comme namespace

help(go.isIterable)

 ou directement depuis le fichier

help("claudecnx.useIt2021_01.isIterable") # aide sur une fonction contenue dans le sous-dossier

Dans le code du fichier faire

help(isIterable) # depuis le code source du fichier contenant la fonction

help("essai05_iterator_generator") # aide sur un fichier, ici essai05_iterator_generator.py

help("claudecnx.useIt2021_01") # aide sur un fichier.py contenu dans un sous-dossier

help(go.isIterable) # aide sur la fonction isIterable du namespace go

help(go) # aide sur le namespace nommé go

help("claudecnx.useIt2021_01.isIterable") # aide sur une fonction contenue dans le sous-dossier

help(isIterable) # depuis le code source du fichier contenant la fonction

"""
help for file "test_help.py"
a help texte
"""

import claudecnx.useIt2021_01 as go # module externe de claudecnx; namespace = go

def myf02(): # pour exemple
    """
    ceci est l'aide de myf02()
    """
    a=5
    return a

help(myf02) # depuis le code du fichier

tab = [1, 2, 3, 4, 5, 6, 7]
print("valeur de tab ", go.strc(tab) )
print()

help("test_help") # aide sur un fichier, ici test_help.py

help("claudecnx.useIt2021_01") # aide sur un fichier.py contenu dans un sous-dossier

help(go.isIterable) # aide sur la fonction isIterable du namespace go

help(go) # aide sur le namespace nommé go

help("claudecnx.useIt2021_01.isIterable") # aide sur une fonction contenue dans le sous-dossier

"""
return(distance,angle,TX)
distance,angle,TX=data(distance,angle,TX)
print("la distance est : ",distance,".")
print(" l angle est : ",angle,".")
"""

""" Module additionnel en Python

ajoute la fonction tableAddition(n, max)

ou n est le nombre dont on souhaite voir la table d'addition

max est la valeur à ajouter à n, par défaut de 1 à 10, peut être omis

ajoute la fonction tableMultiplication(n, max)

ou n est le nombre dont on souhaite voir la table de multiplication

max est la valeur à multiplier à n, par défaut de 1 à 10, peut être omis

encodage utf-8

"""

# -*- coding: utf-8 -*-

import os

def tableAddition(nb, max=10):

    """Fonction affichant la table d'addition de nb de

    nb + 1 jusqu'à nb + max

        par défaut max vaut ici 10

        """

    i = 0

    while i < max:

        print(nb, "+", i + 1, "=", (i + 1) + nb)

        i += 1

# test de la fonction tableAddition en local

if __name__ == "__main__":

    tableAddition(4)

    os.system("pause")

def tableMultiplication(nb, max=10):

    """Fonction affichant la table de multiplication de nb

    nb * 1 jusqu'à nb * max

        par défaut max vaut ici 10

        """

    i = 0

    while i < max:

        print(nb, "*", i + 1, "=", (i + 1) * nb)

        i += 1

# test de la fonction tableMultiplication en local

if __name__ == "__main__":

    tableMultiplication(4)

    os.system("pause")          

""" fichiers de biblio Python dans un sous-dossier

ajoute la table de soustraction

tableSoustraction(nb, max=10)

où n est le nombre à soustraire

max la valeur à soustraire de nb

encodage utf-8

"""

# -*- coding: utf-8 -*-

import os # import des fonctions de la bibliothèque python Operating System intégrée à Python

#import random # import fonctions hasard, aléatoire, intégrée à Python

#import math # import fonctions mathématique intégrée à Python

# votre code ici

def tableSoustraction(nb, max=10):

    """Fonction affichant la table de sosutraction de nb

    nb - 1 jusqu'à nb - max

    par défaut max vaut ici 10

    """

    i = 0

    while i < max:

        print(nb, "-", i + 1, "=", nb - (i + 1) )

        i += 1

# test de la fonction tableSoustraction en local

if __name__ == "__main__":

    tableSoustraction(4)

    os.system("pause")

""" Gestion des caractères accentués sous Python

sous python3

encodage utf-8

par défaut

"""

# -*- coding: utf-8 -*-

import os # import des fonctions de la bibliothèque python Operating System intégrée à Python

# votre code ici

print("pour gérer les caractères accentués sous Python")

print(" # -*- coding: utf-8 -*- ")

os.system("pause") # propose une pause et demande d'appuyer sur n'importe qu'elle touche pour poursuivre.

############ convert list to str

tab = [1, 2, 3, 4, 5, 6] # as list, type() renvoie list
strTab = strC(tab)

separateur = ", "
chaine = separateur.join(str(e) for e in tab) # fonctionne aussi bien avec les int que les str
print(strTab, " converted in str " + chaine) # 1, 2, 3, 4, 5, 6

# ou encore

chaine = "%s" % tab               # les crochets apparaissent dans la chaine de caractères
print(strTab, " converted in str 2nd méthode " + chaine) # [1, 2, 3, 4, 5, 6]

########## Conversion list <=> str
print("### Conversion list <==> str")

chaine = "Olivier:ENGEL:Strasbourg"
print("chaine à convertir ", chaine)

arr = list(chaine)
print("avec arr = list(chaine) str =>list ", strC(arr) ) # convert str to list
print("arr = list(chaine) fonctionne mais ce n'est pas la bonne méthode car on ne peut pas définir de séparateur!")

arr = [i for i in chaine if i!=" "]
print("avec [i for i in chaine if i!=' '] ", strC(arr) )
print(" cette méthode ne spécifie pas de séparateur, i!=' ' permet de supprimer les espaces ")

separateur = ":" # c'est le séparateur présent dans chaine!
arr = chaine.split(separateur) # Transformer une string en liste
print("avec chaine.split(separateur) str => list ", strC(arr) ) # convert str to list ['Olivier', 'ENGEL', 'Strasbourg']

separateur = ":" # c'est le séparateur qui sera appliqué dans chaine
chaine = separateur.join(str(e) for e in arr) # convert list to string
print("avec chaine = separateur.join(str(e) for e in arr) list => str ", chaine) # convert list to str 'Olivier:ENGEL:Strasbourg'

print(" avec '%s' % arr list =>str ", "%s" % arr ) # convert list to str

tab = [1, 2, 3, 4, 5, 6] # as list, type() renvoie list
strTab = strC(tab)
print(strTab)

for x in tab:
    print("for x in tab: ", x)

animaux = ['girafe', 'tigre', 'singe', 'souris']
chaine = strC(animaux)
print("animaux = ", chaine)

for animal in animaux[1:3]:
    print("for animal in animaux[1:3]: ", animal)

1.     #tigre
2.     #singe

for i in range(4):
    print("for i in range(4): ", animaux[i])

1.     #girafe
2.     #tigre
3.     #singe
4.     #souris

for i in range(0,3):
    print("for i in range(0,3): ", animaux[i])

1.     #girafe
2.     #tigre
3.     #singe

for i, animal in enumerate(animaux):
    print( "L'animal {} est un(e) {}".format(i, animal) )

1.     #L'animal 0 est un(e) girafe
2.     #L'animal 1 est un(e) tigre
3.     #L'animal 2 est un(e) singe
4.     #L'animal 3 est un(e) souris

 ################### Inversion du contenu d'un list

print("###### Inversion du contenu d'un list")
tab = [1, 2, 3, 4, 5, 6] # as list, type() renvoie list
strTab = strC(tab)
print("valeur initiale de tab ", strTab)

tab2 = list( reversed(tab) ) # inversion avec création d'une nouvelle liste - <class 'list_reverseiterator'>
print(" avec list( reversed(tab) ", strC(tab2), " la valeur de tab est conservée", strC(tab) ) # [6, 5, 4, 3, 2, 1] est de type list_reverseiterator - iterable? True

# ou encore
tab2 = tab[::-1]
print(" avec tab[::-1] ", strC( tab2), " la valeur de tab est conservée ", strC( tab) )

# ou encore
tab.reverse()
print(" autre méthode avec tab.reverse() ",  strC( tab ), " la valeur de tab est modifiée et tab.reverse() retourne none" ) # tab est modifié

 ########## lier 2 itérables
print("Lier 2 itérables")

tab3 = list(zip('AZERTY', (100, 300, 600))) # lier deux itérables
print( strC(tab3) ) # [('A', 100), ('Z', 300), ('E', 600)] est de type list - iterable? True
print( isWhat( zip('AZERTY', (100, 300, 600)) ) ) # est de type zip - iterable? True

############ trier un list

print(" Trier un list")

tab = ["b", "1", "3", "abc", "2", "a", "c", "ab", "bc"]
print("valeur initiale de tab ", strC(tab) )

tab5 = sorted( tab )    # tri et génère une nouvelle liste
print("avec sorted( tab )  ", strC(tab5), "la valeur de tab n'est pas modifiée ", strC(tab) )   # ['1', '2', '3', 'a', 'ab', 'abc', 'b', 'bc', 'c']
# tous les types doivent être identiques
# TypeError: '<' not supported between instances of 'int' and 'str'

a = tab.sort()   #  tri et modifie la list
print("avec tab.sort() ", strC(tab), " la valeur de tab est modifiée")   # ['1', '2', '3', 'a', 'ab', 'abc', 'b', 'bc', 'c']
print( type(a) ) # <class 'NoneType'>

########### accès aux elt du list

print("accés aux elt du list")

tab = ["b", "1", "3", "abc", "2", "a", "c", "ab", "bc"]
print("valeur initiale de tab ", strC(tab) )

print("avec tab[1] ", strC( tab[1] ) ) # l'index 1 soit la valeur "1"

print("avec tab[-1] ",   strC( tab[-1] )  ) # renvoie la dernière occurence, ici "bc"; -2 l'avant-dernière valeur; etc... 

print("avec tab[:] ",  strC( tab[:] )  ) # Affiche toutes les occurences: ["b", "1", "3", "abc", "2", "a", "c", "ab", "bc"] 

print("avec tab[2:4] ",   strC( tab[2:4] ) ) # affiche les elt entre les index 2 inclus et 4 exclu (index 3 inclu donc); ['3', 'abc']

print("avec tab[:4] ", strC( tab[:4] ) ) # de l'index 0 à 3 inclus ['b', '1', '3', 'abc'], soit les 4 premières valeurs

print("avec tab[4:] ", strC( tab[4:] ) ) # de l'index 4 inclu juqu'à la fin du list; les 4 premières valeurs sont ignorées; ['2', 'a', 'c', 'ab', 'bc']

############# ajout d'elt dans un object list

print("#### ajout d'elt dans un object list")

tab = [1, 2, 3, 4, 5, 6] #
strTab = strC(tab)
print("valeur initiale de tab ", strC(tab) )

tab.append("fin")     # ajoute un elt à la fin
print("avec tab.append('fin') ",  strC(tab))    # [1, 2, 3, 4, 5, 6, 'fin'] 

tab.insert(0,'debut')     # ajoute "debut" à la position 0, soit en début du list
print("avec tab.insert(0,'debut') ", strC(tab) ) # ['debut', 1, 2, 3, 4, 5, 6, 'fin'] 

tab.insert(2,'c')     # ajoute "c" à l'index 2, soit en 3ième position
print("avec tab.insert(2,'c') ", strC(tab) ) # ['debut', 1, 'c', 2, 3, 4, 5, 6, 'fin'] 

tab.insert(tab.index('c')+1,'d')    # insère à la position index de la valeur +1
print("avec tab.insert(tab.index('c')+1,'d')  ", strC(tab) )   # ['debut', 1, 'c', 'd', 2, 3, 4, 5, 6, 'fin']

####### somme multiplication

print("## somme multiplication ")

x = [1, 2, 3, 4]
y = [4, 5, 1, 0]
print("x initial ", strC(x) )
print("y initial ", strC(Y) ) 

x.extend(y) # ajouter, concatener, agrandir une liste avec une autre liste
print("avec x.extend(y) ", strC(x) ) # [1, 2, 3, 4, 4, 5, 1, 0]

z = x + y  # ajouter, concatener, agrandir une liste avec une autre liste
print("avec x+y ", strC(z) ) # [1, 2, 3, 4, 4, 5, 1, 0]

x = [1, 2]
print("x initial ", strC(x) )
z = x*5 # Vous pouvez même mutiplier une liste:
print("avec x*5 ", strC(z) ) # [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

############# supprimer un elt

print("#### supprimer un elt")

tab = ['debut', 1, 'c', 'd', 2, 3, 4, 5, 6, 'fin']
print("valeur initiale de tab ", strC(tab) )

tab.remove("d")   # supprime la première valeur "d" rencontrée
print("avec tab.remove('d') ", strC(tab) )    # ['debut', 1, 'c', 2, 3, 4, 5, 6, 'fin'] 

del tab[2]    # supprime l'élément situé à l'index 2 (3ième position donc)
print("avec del tab[2] ", strC(tab) )    # ['debut', 1, 2, 3, 4, 5, 6, 'fin']

######## les ensembles (set) Union, Intersection, Différence OU exclusif
print("#### les ensembles  (set) Union, Intersection, Différence OU exclusif")

tab1 = [1, 2, 3, 4, 5, 6, "a", "b", "c"]
tab2 = [2, 3, 4, "a", "b"]
tab3 = [6, 7, 8, 9, "a"]

#convert object list en object set
ens1 = set(tab1)
ens2 = set(tab2)
ens3 = set(tab3)

print("avec ens1 & ens2 ", strC( ens1 & ens2 ) ) # {2, 3, 4, 'b', 'a'} Intersection, car ce sont les seuls à être en même temps dans ens1 et ens2

print("avec ens1 | ens3 ", strC( ens1 | ens3 ) ) # {1, 2, 3, 4, 5, 6, 'c', 7, 8, 9, 'b', 'a'}, les deux réunis, Union, OU Inclusif

print("avec ens1 & ens3 ", strC( ens1 & ens3 ) ) # {6, 'a'}, même raison que deux lignes au dessus

print("avec ens1 ^ ens3 ", strC( ens1 ^ ens3 ) ) # {1, 2, 3, 4, 5, 7, 8, 9, 'c', 'b'}, OU Exclusif, l'union moins les éléments communs

print("avec ens1 - ens2 ", strC( ens1 - ens2 ) ) # {1, 'c', 5, 6}, on enlève les éléments de ens2, Différence

######### convert object set en object list

ens = ens1 & ens2 # for test
print ("avec ens = ens1 & ens2 ",  isWhat( ens ) )
tab = list(ens)
print("avec list(ens) ", isWhat(tab) )

########### Multiplexage object list
print("### Multiplexage object list")

from itertools import product

tab1 = ['a', 'b']
tab2 = ['c', 'd', 2]
print("valeur initiale de tab1 ", strC(tab1) )
print("valeur initiale de tab2 ", strC(tab2) )

tab3 = list( product(tab1, tab2) ) # afficher tous les cas possibles d'une liste elle-même composée de liste; Multiplexage
print("avec list( product(tab1, tab2) ) ", strC(tab3) ) # [('a', 'c'), ('a', 'd'), ('a', 2), ('b', 'c'), ('b', 'd'), ('b', 2)]

 ############## vérifier l'existence d'une valeur
print("#### vérifier l'existence d'une valeur")

tab = ["b", "a", "3", "abc", "2", "a", "c", "a", "bc"]
print("valeur initiale de tab ", strC(tab) )

print( tab.count("a") ) # connaitre le nombre d'occurences d'une valeur dans une liste; donc il existe

print( "a" in tab ) # savoir si un élément est dans une liste; renvoie True or False

print( tab.index("a") ) # position de la valeur "a" dans le list; première occurrence rencontrée

############### identifiant de l'object list
print("##### identifiant de l'object list")

tab = ["b", "a", "3", "abc", "2", "a", "c", "a", "bc"]
print("valeur initiale de tab ", strC(tab) )

print( id(tab) ) # identificateur unique de l'object tab: 2293464768768

############## nbr d'elts, de valeurs dans un object list
print("#### nbr d'elts, de valeurs dans un object list")

tab = ["b", "a", "3", "abc", "2", "a", "c", "a", "bc"]
print("valeur initiale de tab ", strC(tab) )

n= len(tab) # nombre d'éléments dans tab
print(n)

########### copier un object list
print("### copier un object list")

tab = ["b", "a", "3", "abc", "2", "a", "c", "a", "bc"]
print("valeur initiale de tab ", strC(tab) )

tab8 = tab # copy tab dans tab8 - c'est une copie dépendante
print("avec tab8 = tab ",strC(tab8) ) # ['b', 'a', '3', 'abc', '2', 'a', 'c', 'a', 'bc']
tab8[0] = "debut"
print("tab8[0] = 'debut', modifie tab ", strC(tab) ) #  tab a également était modifié
tab[-1] = "fin"
print("tab[-1] = 'fin' modifie tab8 ", strC(tab8) )

tab9 = tab[:] # copy indépendante de liste dans liste9
print("avec tab9 = tab[:] ", strC(tab9) ) # ['d', 1, 2, 3, 4]
tab9[0] = "d"
print("tab9[0] = 'd' ne modifie pas tab ", strC(tab) )

import copy # module interne - copie indépendante
tab10 = copy.deepcopy(tab) # Pour des données plus complexes, vous pouvez utiliser la fonction deepcopy du module copy
print("avec tab10 = copy.deepcopy(tab) ", strC(tab10) ) # ['d', 1, 2, 3, 4]
tab10[0] = "d"
print("tab10[0] = 'd' ne modifie pas tab ", strC(tab) )

########### générer rapidement un list
print("### générer rapidement un list")

r = range(10) # La fonction range génère une liste composée d'une simple suite arithmétique.
# r est de type range
tab = list(r) # convert object range en object list
print("avec tab = list( range(10) ) ", strC(tab) ) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print("avec [0] * 5 ", strC([0] * 5 ) ) # [0, 0, 0, 0, 0]

# fonctions communes pour applicatif avec map ou filter ou reduce

def carre(x):
    return x ** 2 # x ** 2 = x puissance 2

def carreOptionnel(x, opt=1): return x ** 2 # x ** 2 = x puissance 2; opt est optionnel de sorte que carreOptionnel(7) fonctionnera

def petit_carre(x): return x ** 2 < 16 # nombres dont les carrés sont inférieurs à 16.

def puissance(x, exponent): return x ** exponent

def pair(x): return not bool(x % 2)

def addition(x, y): return x + y

def produit(x, y): return x * y

def appcarre(element, liste): return liste + [element ** 2] # ne fonctionne pas avec reduce en Python version 3

########### fonction qui exécute une autre fonction

print("### fonction qui exécute une autre fonction")

def appliquer_fonction(fonc, valeur):
    return fonc(valeur) # On utilise la fonction callback fonc avec comme paramètre valeur.

print( appliquer_fonction(carre, 3, 2) ) # Affiche 9, c'est à dire mettre_au_carre(3)
# Python ne fait pas de différence entre une variable et une fonction, comme javascript

########### fonction qui exécute une autre fonction

print("### fonction qui exécute une autre fonction")

def appliquer_fonction(fonc, valeur, opt=1):
    return fonc(valeur, opt) # On utilise la fonction callback fonc avec comme paramètre valeur.

print( appliquer_fonction(carreOptionnel, 3, 2) ) # Affiche 9, c'est à dire mettre_au_carre(3)

print( appliquer_fonction(addition, 5, 8) )  # affiche 13

########### fonction prototype de map
def mapProto(callback, liste): # équivallent à map()
    nouvelle_liste = []
    for element in liste:
       nouvelle_liste.append(callback(element))
    return nouvelle_liste

############ fonction prototype de filter
def filterProto(callback, liste): # équivallent à filter
    nouvelle_liste = []
    for element in liste:
       if callback(element): nouvelle_liste.append(element)
    return nouvelle_liste

########### fonction prototype de reduce
def reduceProto(callback, liste, valeur_initiale):
    if liste == []: return valeur_initiale
    else: return callback(liste[0], my_reduce(callback, liste[1:], valeur_initiale))

########## application de map

tab = [1, 2, 3, 4, 5]
print("valeur de tab ", strC(tab) )

a_map = map(carre, tab)  # Affiche [1, 4, 9, 16, 25], c'est à dire le carré de chaque élément
print("avec map(carre, tab) ", strC(a_map) ) # ecrit Object map, pas de détails des données
print( isWhat( a_map) )

print("avec map(pair, tab) ", strC( map(pair, tab) ) ) # Affiche [False, True, False, True, False], c'est à dire si le nombre est pair.

print("avec mapProto(carre, tab) ", strC( mapProto(carre, tab) ) ) # Affiche [1, 4, 9, 16, 25], c'est à dire le carré de chaque élément

print("avec mapProto(pair, tab) ", strC( mapProto(pair, tab) ) ) # Affiche [False, True, False, True, False], c'est à dire si le nombre est pair.

########### application de filter
print("### application de filter")

tab = [1, 2, 3, 4, 5]
print("valeur de tab ", strC(tab) )

a_filter = filter(petit_carre, tab)  # Affiche [1, 2, 3], c'est à dire les nombres dont les carrés sont inférieurs à 16.
print("avec filter(petit_carre, tab) ", strC(a_filter) )
print( isWhat(a_filter) )

print("avec filter(pair, tab) ", strC( filter(pair, tab) ) ) # Affiche [2, 4], c'est à dire les nombres pairs de la liste.

print("avec filterProto(petit_carre, tab) ", strC( filterProto(petit_carre, tab) ) ) # Affiche [1, 2, 3], c'est à dire les nombres dont les carrés sont inférieurs à 16.

print("avec filterProto(pair, tab) ", strC( filterProto(pair, tab) ) ) # Affiche [2, 4], c'est à dire les nombres pairs de la liste.

########## application de reduce
print("### application de reduce")

from functools import reduce # pour python 3
from six.moves import reduce

tab = [1, 2, 3]
print("valeur de tab ", strC(tab) )

print("avec reduce(addition, tab, 0) ",  strC( reduce(addition, tab, 0) ) ) # Équivaut à ((0 + 1) + 2) + 3

print("reduce(produit, tab, 1) ", strC( reduce(produit, tab, 1) ) ) # Équivaut à ((1 * 1) * 2) * 3

# print( reduce(appcarre, [1, 2, 3], []) ) # Équivaut à map(carre, [1, 2, 3]) ;)
# TypeError: unsupported operand type(s) for ** or pow(): 'list' and 'int'

print("avec reduceProto(addition, tab, 0) ", strC( reduceProto(addition, tab, 0) ) ) # Équivaut à ((0 + 1) + 2) + 3   => 6

print("avec reduceProto(produit, tab, 1) ", strC( reduceProto(produit, tab, 1) ) ) # Équivaut à ((1 * 1) * 2) * 3   => 6

print("avec reduceProto(appcarre, tab, []) ", strC( reduceProto(appcarre, tab, []) ) ) # Équivaut à map(carre, [1, 2, 3]) ;)   => [9, 4, 1]
print("cette dernière expession fonctionne avec reduceProto() mais pas avec reduce")
print(" avec reduce nous obtenons: # TypeError: unsupported operand type(s) for ** or pow(): 'list' and 'int'")

print( isWhat( reduce(addition, tab, 0) ) )
print("reduce ne renvoie pas de type reduce comme map ou filter, mais renvoie le type du rsultat calculé!")

########### utilisation des list comprehensions avec les object list
"""Les compréhensions de liste (list comprehensions en anglais)
sont des outils très puissants
permettant d'utiliser map et filter (vues au dessus)
avec une syntaxe plus proche de celle habituelle en Python.
De plus, elles permettent de combiner un map et un filter en même temps
"""

print("### utilisation des list comprehensions avec les object list")

tab = [1, 2, 3, 4, 5, 6, 7]
print("valeur de tab ", strC(tab) )

print("Affiche les carrés des éléments")
print(" [x ** 2 for x in tab] ")
print( [x ** 2 for x in tab] ) # Équivaut à notre map, en plus lisible et plus simple :) .
# [1, 4, 9, 16, 25, 36, 49]

print("Affiche les nombres pairs")
print(" [x for x in tab if x % 2 == 0] ")
print( [x for x in tab if x % 2 == 0] ) # Plus simple que filter, également :)
# [2, 4, 6]

print("Affiche les carrés des nombres pairs (combinaison des deux)")
print(" print( [x ** 2 for x in tab if x ** 2 % 2 == 0] ) ")
print( [x ** 2 for x in tab if x ** 2 % 2 == 0] )# [4, 16, 36] ou
print(" [x for x in [a ** 2 for a in tab] if x % 2 == 0] ")
print( [x for x in [a ** 2 for a in tab] if x % 2 == 0] ) # [4, 16, 36]

"""

tester les list [a, b]

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

import copy # module interne; copy.deepcopy()

obj01 = [1, 2, 3, 2.5, "a", "per"]

obj02 = [1, 2, 3, 2.5]

obj03 = ["a", "per"]

"""

all()

"""

print(" all() ")

bValeur = all(obj01)

print( bValeur ) # True

"""

all()

returns True if all elements of the set are true (or if the set is empty).

"""

"""

any()

"""

print(" any() ")

bValeur = any( obj01 )

print( bValeur ) # True

"""

any()

Returns True if any element of the set is true. If the set is empty, returns False.

"""

"""

enumerate()

"""

print(" enumerate() ")

obj = enumerate(obj01)

print( type(obj) ) # <class 'enumerate'>

print( go.typeIs(obj) ) # enumerate

print( go.isWhat(obj) ) # {} est de type enumerate - iterable? True

print( go.strc(obj) ) # {}

obj04 = copy.deepcopy(obj)

print( type(obj) ) # <class 'enumerate'>

print( obj ) # <enumerate object at 0x00000242929B5DC0>

print("enumerate as dict ", dict(obj04) ) # {0: 1, 1: 2, 2: 3, 3: 'per', 4: 'a'}; vide obj02

obj04 = copy.deepcopy(obj)

print("enumerate as list ", list(obj04) ) # [(0, 1), (1, 2), (2, 3), (3, 'a'), (4, 'per')];

# l'ordre reste aléatoire, vide obj

"""

enumerate()

Returns an enumerate object. It contains the index and value for all the items of the set as a pair.

attention l'application de list() ou dict() sur cet object enumerate vide cet objet

il faut donc utiliser copy.deepcopy() pour obtenir une copie indépendante de l'objet enumerate

need to import:

import copy # module interne; copy.deepcopy()

"""

"""

len() nombre d'éléments dans un object

"""

print(" len() nombre d'éléments dans un object")

print( len(obj01) ) #

"""

len()

Returns the length (the number of items) in the set.

"""

"""

max() le plus grand item

"""

print("max() le plus grand item")

print( max(obj02) ) # 3

print( max(obj03) ) # "per"

try:

    print( max(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

max()

Returns the largest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

min() le plus petit item

"""

print("min() le plus petit item")

print( min(obj02) ) # 1

print( min(obj03) ) # "a"

try:

    print( min(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

min()

Returns the smallest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

sorted()

"""

print(" sorted()")

list02 = sorted( obj02 )

print( list02 ) # [1, 2, 2.5, 3]

list03 = sorted( obj03 )

print( list03 ) # ['a', 'per']

try:

    print( sorted(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sorted()

Returns a new sorted list from elements in the set(does not sort the set itself).

on ne peut pas mélanger des str avec des int ou float

"""

"""

sum()

"""

print(" sum() ")

valeur02 = sum( obj02 )

print( valeur02 ) # 8.5

try:

    print( sum(obj03) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

try:

    print( sum(obj01) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sum()

Returns the sum of all elements in the set.

on ne peut pas mélanger des str avec des int ou float; error

ne sait pas faire une somme de str; error

"""

"""

source inspiration

https://www.programiz.com/python-programming/set

"""

"""

tester les tuple

tuple object n'est pas modifiable, immutable

"""

# import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

tp01 = (3, 4, 7)

"""

print( type(tp01) ) # <class 'tuple'>

print( go.typeIs(tp01) ) # tuple

print( go.isWhat(tp01) ) # (3,4,7) est de type tuple - iterable? True

print( go.strc(tp01) ) # (3,4,7)

"""

print()

"""

Créer un tuple - formes d'écriture

"""

print("Créer un tuple #formes d'écriture")

tp01 = (3, 4, 7)

tp02 = ()

tp03 = 1, 2, 3 # parenthèses non obligatoires, mais conseillées

a, b  = 100, 200 # affectation multiple

print( type( (a, b) ) ) # <class 'tuple'>

tp04 = (a, b)

print ( type(tp04) ) # <class 'tuple'>

tp05 = tuple(("apple", "banana", "cherry")) # tuple() Constructor - note the double round-brackets

tp06 = ("abc", 34, True, 40.25, "chaine") # tuple with strings, integers, float and boolean

print()

"""

Récupérer, obtenir les valeurs du tuple

"""

tp01 = (10, 20)

x, y = tp01 # renvoie le couple x, y qui contient les valeurs respectives du tuple

print(x)

print(y)

print()

"""

Créer une fonction qui renvoie un tuple

"""

print("Créer une fonction qui renvoie un tuple")

# Il suffit d’indiquer ce tuple après return.

def test01():

    return 3, 4 # retourne plusieurs valeurs  as tuple lors de l'appel d'une fonction

a, b = test01() # a et b contiennent les valeurs du tupe (a, b) retourné par la fonction tes01()

print(a)

print(b)

print()

"""

Parcourir, Itérer sur les éléments d’un tuple

"""

print("Itérer sur les éléments d’un tuple")

tp02 = (1,2,3,4,5,6)

for i in tp02:

    print(i)

"""

Itérer sur les éléments d’un tuple

1

2

3

4

5

6

"""

print()

"""

Obtenir la valeur d’un élément du tuple

"""

print("Obtenir la valeur d’un élément du tuple")

print( tp02[2] ) # 3 on peut accèder à la valeur d'un élément du tuple via son indice; indice = 0 => premier elt du tuple

print()

"""

Créer un tuple avec un seul élément

"""

print("Créer un tuple qui contient un seul élément ")

tp03 = (5,) # il faut mettre la virgule après ce seul et unique argument

print( type(tp03) ) # <class 'tuple'>

"""

Récupérer, Obtenir la valeur d'un tuple à 1 seul élément

"""

print("Récupérer la valeur dans un tuple à 1 seul élément")

valeur = tp03[0] # avec son indice; comme un seul elt, indice = 0

print( valeur ) # 5

valeur, = tp03

print( valeur ) # 5

list01 = [5]

v, = list01 # fonctionne aussi pour les list

print ( v ) # 5

print( type(v) ) # <class 'int'>

print( type(v,) ) # <class 'int'>

print()

"""

Nombre d'éléments dans un tuple

"""

print("Nombre d'éléments dans un tuple")

print( len( tp02) ) # 6

"""

source inspiration

https://courspython.com/tuple.html

"""

"""

tester les tuple (a, b)

tuple object n'est pas modifiable, immutable

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

import copy # module interne; copy.deepcopy()

obj01 = (1, 2, 3, 2.5, "a", "per")

obj02 = (1, 2, 3, 2.5)

obj03 = ("a", "per")

"""

all()

"""

print(" all() ")

bValeur = all(obj01)

print( bValeur ) # True

"""

all()

returns True if all elements of the set are true (or if the set is empty).

"""

"""

any()

"""

print(" any() ")

bValeur = any( obj01 )

print( bValeur ) # True

"""

any()

Returns True if any element of the set is true. If the set is empty, returns False.

"""

"""

enumerate()

"""

print(" enumerate() ")

obj = enumerate(obj01)

print( type(obj) ) # <class 'enumerate'>

print( go.typeIs(obj) ) # enumerate

print( go.isWhat(obj) ) # {} est de type enumerate - iterable? True

print( go.strc(obj) ) # {}

obj04 = copy.deepcopy(obj)

print( type(obj) ) # <class 'enumerate'>

print( obj ) # <enumerate object at 0x00000242929B5DC0>

print("enumerate as dict ", dict(obj04) ) # {0: 1, 1: 2, 2: 3, 3: 'per', 4: 'a'}; vide obj02

obj04 = copy.deepcopy(obj)

print("enumerate as list ", list(obj04) ) # [(0, 1), (1, 2), (2, 3), (3, 'a'), (4, 'per')];

# l'ordre reste aléatoire, vide obj

"""

enumerate()

Returns an enumerate object. It contains the index and value for all the items of the set as a pair.

attention l'application de list() ou dict() sur cet object enumerate vide cet objet

il faut donc utiliser copy.deepcopy() pour obtenir une copie indépendante de l'objet enumerate

need to import:

import copy # module interne; copy.deepcopy()

"""

"""

len() nombre d'éléments dans un object

"""

print(" len() nombre d'éléments dans un object")

print( len(obj01) ) #

"""

len()

Returns the length (the number of items) in the set.

"""

"""

max() le plus grand item

"""

print("max() le plus grand item")

print( max(obj02) ) # 3

print( max(obj03) ) # "per"

try:

    print( max(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

max()

Returns the largest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

min() le plus petit item

"""

print("min() le plus petit item")

print( min(obj02) ) # 1

print( min(obj03) ) # "a"

try:

    print( min(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

min()

Returns the smallest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

sorted()

"""

print(" sorted()")

list02 = sorted( obj02 )

print( list02 ) # [1, 2, 2.5, 3]

list03 = sorted( obj03 )

print( list03 ) # ['a', 'per']

try:

    print( sorted(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sorted()

Returns a new sorted list from elements in the set(does not sort the set itself).

on ne peut pas mélanger des str avec des int ou float

"""

"""

sum()

"""

print(" sum() ")

valeur02 = sum( obj02 )

print( valeur02 ) # 8.5

try:

    print( sum(obj03) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

try:

    print( sum(obj01) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sum()

Returns the sum of all elements in the purple

on ne peut pas mélanger des str avec des int ou float; error

ne sait pas faire une somme de str; error

"""

"""

source inspiration

https://www.programiz.com/python-programming/set

"""

"""

tester les set {a, b}

set object n'est pas modifiable, immutable, unchangeable

Once a set is created, you cannot change its items, but you can add new items

set object n'est pas ordonné, on ne sait pas dans quel ordre apparaissent les éléments

set object Duplicates Not Allowed, conséquence du fait que set n'est pas modifiable

pas de doublons, chaque valeur est unique

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

import copy # module interne; copy.deepcopy()

set01 = {"pomme", "banane", "cerise"}

"""

print( type(set01) ) # <class 'set'>

print( go.typeIs(set01) ) # set

print( go.isWhat(set01) ) # {'pomme', 'cerise', 'banane'} est de type set - iterable? True

print( go.strc(set01) ) # {'pomme', 'cerise', 'banane'}

"""

"""

Créer un set

"""

print("Créer un set")

set01 = {"abc", 34, True, 40.25, "male", ("a", "b"), "chaine"}# les set acceptent de multiples types de données

# list, dict ne sont pas admis comme elt dans un set

print(set01)

set02 = set(("apple", "banana", "cherry")) # set() Constructor - note the double round-brackets

print(set02)

set03 = set([1, 2, 3, 2]) # création depuis un list, transforme list en set

print(set03) # {1, 2, 3} les valeurs dupliquées sont ignorées

dict04 = {} # dict vide, ce n'est pas un set

print( type(set04) ) # <class 'dict'>

set05 = set() # set vide

print( type(set05) ) # <class 'set'>

"""

Longueur d'un set, nombre d'éléments

"""

print("Longueur d'un set, nombre d'éléments")

print( len(set02) )

"""

Duplicates Not Allowed unicité, unique

"""

print("Duplicates elt Not Allowed")

set03 = {"apple", "banana", "cherry"}

set03 = {"apple", "banana", "cherry", "apple"}

print( set03 ) # {'cherry', 'apple', 'banana'}; apple n'apparaît qu'une seule fois

print( len(set03) ) # 3

"""

dans un set chaque elt est unique et ne peut pas être dupliqué

toutefois cela ne génère pas d'erreur

mais l'elt dupliqué n'apparaît qu'une seule fois

de même l'elt dupliqué n'est pris qu'une seule fois en compte pour la longueur du set

"""

"""

ajouter des elt

"""

print("ajouter des elt")

set01 = { "a", "b"}

set01.add("c") # {'c', 'a', 'b'}

print( set01 )

list01 = [2, 3, 4]

set01.update( list01 )

print( set01) # {2, 3, 4, 'c', 'a', 'b'}

set02 = {10, 11, 12}

list02 = [20, 21,22]

set01.update( list02, set02 )

print( set01 ) # {2, 3, 4, 10, 11, 12, 20, 21, 22, 'c', 'a', 'b'}

"""

2 méthodes pour ajouter des elt

add() ajoute un seul elt

add()

Adds an element to the set

update() ajoute plusieurs elt simultanéments

update()

Updates the set with the union of itself and others

"""

"""

Supprimer retirer des elt

"""

print("Supprimer retirer des elt")

set01 = {1, 2, 3, 4, 5, 6, "a"}

valeur = 4

set01.discard(valeur) # discard() supprime une valeur

print( set01) # {1, 2, 3, 5, 6}

print ( set01.discard("b") ) # ne provoque pas d'erreur si valeur n'existe pas!

"""

discard()

Removes an element from the set if it is a member.

(Do nothing if the element is not in set); not raises a KeyError

"""

valeur = 2

set01.remove(valeur) # remove() supprime une valeur

print( set01 ) # {1, 3, 5, 6}

"""

remove()

Removes an element from the set.

If the element is not a member, raises a KeyError

"""

try:

    print( set01.remove("b") ) # provoque une erreur si elt n'existe pas

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) # Something is not defined 'b'  

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

clear() supprime tous les elts

"""

set01.clear() # clear() supprime tous les elts

print( set01 ) # set()

"""

clear()

Removes all elements from the set

"""

set01 = {"a", 1, 2, 3, "b"}

valeur = set01.pop() # supprime un elt de manière aléatoire et retourne sa valeur

print( valeur ) # 1

print( set01 ) # {2, 3, 'a', 'b'}

"""

Résumé pour suppr elt in a set

• set01.discard("b")  # ne provoque pas d'erreur si valeur n'existe pas!
• set01.remove(valeur) # provoque une erreur si valeur n'existe pas
• set01.clear() # clear() supprime tous les elts
• valeur = set01.pop() # supprime un elt de manière aléatoire et retourne sa valeur

"""

"""

Union de set()

"""

print("Union de set()")

set01 = {1,2,3}

set02 = {3,4,5}

set03 = set01 | set02

print( set03 ) # {1, 2, 3, 4, 5}

set04 = set01.union(set02)

print( set04 ) # {1, 2, 3, 4, 5}

"""

union()

Returns the union of sets in a new set

"""

set08 = {1,2,3}

set09 = {3,4,5}

set08.update( set09 )

print("union with update() ", set08 ) # {1, 2, 3, 4, 5}

"""

Updates the set with the union of itself and others

"""

"""

Intersection  de  set()

"""

print("Intersection  de  set()")

set01 = {1,2,3}

set02 = {3,4,5}

set03 = set01 & set02

print( set03 ) # {3}

set04 = set01.intersection(set02)

print( set04 ) # {3}

"""

intersection()

Returns the intersection of two sets as a new set

"""

set08 = {1,2,3}

set09 = {3,4,5}

set08.intersection_update( set09 ) # {3}

print("intersection_update() with update() ", set08 )

"""

Updates the set with the intersection of itself and another

"""

"""

Difference de  set()

"""

print("Difference de  set()")

set01 = {1,2,3}

set02 = {3,4,5}

set03 = set01-set02 # elt dans set01 seulement et non compris dans set02

print( set03 ) # {1, 2}

set04 = set01.difference(set02)

print( set04 ) # {1, 2}

"""

difference()

Returns the difference of two or more sets as a new set

"""

set08 = {1,2,3}

set09 = {3,4,5}

set08.difference_update( set09 ) # {1, 2}

print("difference_update() with update() ", set08 )

"""

difference_update()

Removes all elements of another set from this set

"""

"""

Symmetric Difference de set()

"""

print(" Symmetric Difference de set()")

set01 = {1,2,3}

set02 = {3,4,5}

set03 = set01^set02

print( set03 ) # {1, 2, 4, 5}

set04 = set01.symmetric_difference(set02)

print( set04 ) # {1, 2, 4, 5}

"""

Symmetric Difference de A et B est un set()

constitué des elements de  A et B mais pas des éléments commun à A et B

(excluding the intersection).

"""

set08 = {1,2,3}

set09 = {3,4,5}

set08.symmetric_difference_update( set09 )

print("difference_update() with update() ", set08 ) # {1, 2, 4, 5}

"""

symmetric_difference_update()

Updates a set with the symmetric difference of itself and another

"""

"""

Copie d'un set()

"""

print("Copie d'un set()")

set01 = {1,2,3}

set02 = set01.copy() # copie indépendante du set()

set01.add("a")

print( set01 ) # {'a', 1, 2, 3}

print( set02 ) # {1, 2, 3}

"""

copy()

Returns a copy of the set

"""

"""

isdisjoint()

"""

print("isdisjoint()")

set01 = {1,2,3}

set02 = {3,4,5}

boolValeur = set01.isdisjoint( set02 )

print ( boolValeur ) # False

"""

isdisjoint()

Returns True if two sets have a null intersection

"""         

"""

issubset()

"""

print("issubset() ")

set01 = {1, 2, 3, 4, 5, 6}

set02 = {3, 4, 5}

boolValeur = set02.issubset(set01)

print(boolValeur) # True; set02 est inclus dans set01

"""

issubset()

Returns True if another set contains this set

"""

"""

issuperset()

"""

print("issuperset()")

set01 = {1, 2, 3, 4, 5, 6}

set02 = {3, 4, 5}

boolValeur = set01.issuperset( set02 )

print( boolValeur ) # True, set01 contient set02

"""

issuperset()

Returns True if this set contains another set

"""

"""

Contient elt, ne contient pas

"""

print("Contient elt")

set01 = {"a", "b", "c"}

print( "b" in set01 ) # True contient elt

print("d" in set01 ) # False

set02 = set("apple")

print('a' in set02) # True

print('p'  in set02) # True

print('p' not in set02) # False, ne contient pas

"""

parcourir un set

"""

print("parcourir un set")

set01 = {1, 2, 3, 4, 5, 6, "a", "per"}

for elt in set01:

    print(elt)

"""

parcourir un set

1

2

3

4

5

6

per

a

"""

"""source inspiration

https://www.w3schools.com/python/python_sets.asp

https://www.programiz.com/python-programming/set

"""

"""

tester les set {a, b}

set object n'est pas modifiable, immutable, unchangeable

Once a set is created, you cannot change its items, but you can add new items

set object n'est pas ordonné, on ne sait pas dans quel ordre apparaissent les éléments

set object Duplicates Not Allowed, conséquence du fait que set n'est pas modifiable

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

import copy # module interne; copy.deepcopy()

"""

all()

"""

print(" all() ")

set01 = {1, 2, 3, 4, 5, 6, "a", "per"}

bValeur = all(set01)

print( bValeur ) # True

"""

all()

returns True if all elements of the set are true (or if the set is empty).

"""

"""

any()

"""

print(" any() ")

set01 = {1, 2, 3, 4, 5, 6, "a", "per"}

bValeur = any( set01 )

print( bValeur ) # True

"""

any()

Returns True if any element of the set is true. If the set is empty, returns False.

"""

"""

enumerate()

"""

print(" enumerate() ")

set01 = {1, 2, 3, "a", "per"}

obj = enumerate(set01)

print( type(obj) ) # <class 'enumerate'>

print( go.typeIs(obj) ) # enumerate

print( go.isWhat(obj) ) # {} est de type enumerate - iterable? True

print( go.strc(obj) ) # {}

obj02 = copy.deepcopy(obj)

print( type(obj) ) # <class 'enumerate'>

print( obj ) # <enumerate object at 0x00000242929B5DC0>

print( dict(obj02) ) # {0: 1, 1: 2, 2: 3, 3: 'per', 4: 'a'}; vide obj02

obj02 = copy.deepcopy(obj)

print( list(obj02) ) # [(0, 1), (1, 2), (2, 3), (3, 'a'), (4, 'per')];

# l'ordre reste aléatoire, vide obj

"""

enumerate()

Returns an enumerate object. It contains the index and value for all the items of the set as a pair.

attention l'application de list() ou dict() sur cet object enumerate vide cet objet

il faut donc utiliser copy.deepcopy() pour obtenir une copie indépendante de l'objet enumerate

need to import:

import copy # module interne; copy.deepcopy()

"""

"""

len() nombre d'éléments dans un object

"""

print(" len() nombre d'éléments dans un object")

set01 = {1, 2, 3, "a", "per"}

print( len(set01) ) #

"""

len()

Returns the length (the number of items) in the set.

"""

"""

max() le plus grand item

"""

print("max() le plus grand item")

set01 = {1, 2, 3, "a", "per"}

set02 = {1, 2, 3, 2.5}

set03 = {"a", "per"}

print( max(set02) ) # 3

print( max(set03) ) # "per"

try:

    print( max(set01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

max()

Returns the largest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

min() le plus petit item

"""

print("min() le plus petit item")

set01 = {1, 2, 3, "a", "per"}

set02 = {1, 2, 3, 2.5}

set03 = {"a", "per"}

print( min(set02) ) # 1

print( min(set03) ) # "a"

try:

    print( min(set01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

min()

Returns the smallest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

sorted()

"""

print(" sorted()")

set01 = {1, 2, 3, 2.5, "a", "per"}

set02 = {1, 2, 3, 2.5}

set03 = {"a", "per"}

list02 = sorted( set02 ) # retourne un object list

print( list02 ) # [1, 2, 2.5, 3]

list03 = sorted( set03 )

print( list03 ) # ['a', 'per']

try:

    print( sorted(set01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sorted()

Returns a new sorted list from elements in the set(does not sort the set itself).

on ne peut pas mélanger des str avec des int ou float

"""

"""

sum()

"""

print(" sum() ")

set01 = {1, 2, 3, 2.5, "a", "per"}

set02 = {1, 2, 3, 2.5}

set03 = {"a", "per"}

valeur02 = sum( set02 )

print( valeur02 ) # 8.5

try:

    print( sum(set03) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

try:

    print( sum(set01) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sum()

Returns the sum of all elements in the set.

on ne peut pas mélanger des str avec des int ou float; error

ne sait pas faire une somme de str; error

"""

"""

source inspiration

https://www.programiz.com/python-programming/set

"""

"""
tester les dictionnaires
"""
import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

dico01 = {"Mammifère marin": "Baleine", "Oiseau": "Aigle", "Poisson": "Requin"}

"""
print( type(dico01) ) # <class 'dict'>
print( go.typeIs(dico01) ) # dict
print( go.isWhat(dico01) ) # {'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'} est de type dict - iterable? True
print( go.strc(dico01) ) # {'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}
"""

print()
print("Parcourir un dictionnaire")

for i in dico01.items():
    print(i)
"""
Parcourir un dictionnaire
('Mammifère marin', 'Baleine')
('Oiseau', 'Aigle')
('Poisson', 'Requin')
"""

print("Parcourir dict avec cle et valeur")
for key, value in dico01.items():
    print("la cle est: ", key, "associée à la valeur ", value)
"""
Parcourir dict avec cle et valeur
la cle est:  Mammifère marin associée à la valeur  Baleine
la cle est:  Oiseau associée à la valeur  Aigle
la cle est:  Poisson associée à la valeur  Requin
"""

print()
print("Ajouter une paire à dict")

dico01["Serpent"] = "Cobra" # ajoute la paire Serpent, Cobra
print ( "%s" % dico01 ) # dict  as str
"""
Ajouter une paire à dict
{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin', 'Serpent': 'Cobra'}
"""

print()
print("Créer un dict vide, y ajouter des paires, méthode avec {}")

# Créer un dict vide, y ajouter des paires, méthode avec {}

dico02 = {} # dict vide
dico02["Mammifere"] = "Chien"
print ( "%s" % dico02 ) # dict  as str
"""
Créer un dict vide, y ajouter des paires
{'Mammifere': 'Chien'}
"""

print("Créer un dict vide, y ajouter des paires, méthode avec dict()")

# Créer un dict vide, y ajouter des paires, méthode avec dict()

dico03 = dict() # new dict vide
dico02["Mammifere"] = "Chien"
print ( "%s" % dico03 ) # dict as str
"""
Créer un dict vide, y ajouter des paires
{'Mammifere': 'Chien'}
"""

print()
print("récupérer une valeur dans un dict")

print( dico01["Serpent"] ) # Cobra

print("récupérer une valeur dans un dict")

print( dico01.get("Serpent") ) # Cobra

print()
print("vérifier la présence d'une clé dans un dict")

# print( dico01.hasKey("Serpent") ) # ne fonctionne plus sous Python3

print( 'Serpent' in dico01 )  # True

print()
print("Convertir dict en list")

list01 = list( dico01.items() )

print( list01)

"""
Convertir dict en list
[('Mammifère marin', 'Baleine'), ('Oiseau', 'Aigle'), ('Poisson', 'Requin'), ('Serpent', 'Cobra')]
"""

print("supprimer une entrée dans un dict")

del dico01["Serpent"]

print ( "%s" % dico01 ) # dict as str

"""
supprimer une entrée dans un dict
{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}
"""

print("Récupérer les clés d'un dict")

for cle in dico01.keys():

    print(cle)

"""
récupérer les clés d'un dict
Mammifère marin
Oiseau
Poisson
"""

print("Récupérer les valeurs d'un dict")

for valeur in dico01.values():

    print(valeur)

"""

récupérer les valeurs d'un dict

Baleine

Aigle

Requin

"""

print("Récupérer les clés et les valeurs d'un dict")

for cle,valeur in dico01.items():

    print( cle, valeur )

"""

récupérer les clés et les valeurs d'un dict

Mammifère marin Baleine

Oiseau Aigle

Poisson Requin

"""

print("Utiliser des tuples comme clé dans un dict")

dico04 = {}

dico04[(3, 2)]=12

dico04[(4, 5)]=13

print( dico04 )

print("utile dans l'utilisation de coordonnées ! ")

"""

utiliser des tuples comme clé dans un dict

{(3, 2): 12, (4, 5): 13}

"""

print("Créer une copie indépendante d'un dict")

dico05 = dico01.copy()

dico01["Oiseau"] = "Faucon"

print(dico05)

print(dico01)

"""

créer une copie indépendante d'un dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}

{'Mammifère marin': 'Baleine', 'Oiseau': 'Faucon', 'Poisson': 'Requin'}

"""

dico01.update(dico02)

print(dico01)

"""

 fusionner des dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Faucon', 'Poisson': 'Requin', 'Mammifere': 'Chien'}

"""

print("Compter les nombre d'éléments, de paires, dans un dict")

print( len(dico01) ) # 4 paires après le update

"""

tester les dictionnaires

"""

 import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

 dico01 = {"Mammifère marin": "Baleine", "Oiseau": "Aigle", "Poisson": "Requin"}

 """

print( type(dico01) ) # <class 'dict'>

print( go.typeIs(dico01) ) # dict

print( go.isWhat(dico01) ) # {'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'} est de type dict - iterable? True

print( go.strc(dico01) ) # {'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}

"""

 print()

print("Parcourir un dictionnaire")

for i in dico01.items():

    print(i)

"""

Parcourir un dictionnaire

('Mammifère marin', 'Baleine')

('Oiseau', 'Aigle')

('Poisson', 'Requin')

"""

print("Parcourir dict avec cle et valeur")

for key, value in dico01.items():

    print("la cle est: ", key, "associée à la valeur ", value)

"""

Parcourir dict avec cle et valeur

la cle est:  Mammifère marin associée à la valeur  Baleine

la cle est:  Oiseau associée à la valeur  Aigle

la cle est:  Poisson associée à la valeur  Requin

"""

 print()

print("Ajouter une paire à dict")

dico01["Serpent"] = "Cobra" # ajoute la paire Serpent, Cobra

print ( "%s" % dico01 ) # dict as str

"""

Ajouter une paire à dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin', 'Serpent': 'Cobra'}

"""

 print()

print("Créer un dict vide, y ajouter des paires, méthode avec {}")

dico02 = {} # dict vide

dico02["Mammifere"] = "Chien"

print ( "%s" % dico02 ) # dict as str

"""

Créer un dict vide, y ajouter des paires

{'Mammifere': 'Chien'}

"""

print("Créer un dict vide, y ajouter des paires, méthode avec dict()")

dico03 = dict() # new dict vide

dico02["Mammifere"] = "Chien"

print ( "%s" % dico03 ) # dict as str

"""

Créer un dict vide, y ajouter des paires

{'Mammifere': 'Chien'}

"""

 print()

print("récupérer une valeur dans un dict")

print( dico01["Serpent"] ) # Cobra

print("récupérer une valeur dans un dict")

print( dico01.get("Serpent") ) # Cobra

print()

print("vérifier la présence d'une clé dans un dict")

# print( dico01.hasKey("Serpent") ) # ne fonctionne plus sous Python3

print( 'Serpent' in dico01 )  # True

print()

print("Convertir dict en list")

list01 = list( dico01.items() )

print( list01)

"""

Convertir dict en list

[('Mammifère marin', 'Baleine'), ('Oiseau', 'Aigle'), ('Poisson', 'Requin'), ('Serpent', 'Cobra')]

"""

 print()

print("supprimer une entrée dans un dict")

del dico01["Serpent"]

print ( "%s" % dico01 ) # dict as str

"""

supprimer une entrée dans un dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}

"""

 print()

print("récupérer les clés d'un dict")

for cle in dico01.keys():

    print(cle)

"""

récupérer les clés d'un dict

Mammifère marin

Oiseau

Poisson

"""

print()

print("récupérer les valeurs d'un dict")

for valeur in dico01.values():

    print(valeur)

"""

récupérer les valeurs d'un dict

Baleine

Aigle

Requin

"""

print()

print("récupérer les clés et les valeurs d'un dict")

for cle,valeur in dico01.items():

    print( cle, valeur )

"""

récupérer les clés et les valeurs d'un dict

Mammifère marin Baleine

Oiseau Aigle

Poisson Requin

"""

print()

print("utiliser des tuples comme clé dans un dict")

dico04 = {}

dico04[(3, 2)]=12

dico04[(4, 5)]=13

print( dico04 )

print("utile dans l'utilisation de coordonnées ! ")

"""

utiliser des tuples comme clé dans un dict

{(3, 2): 12, (4, 5): 13}

"""

print()

print("créer une copie indépendante d'un dict")

dico05 = dico01.copy()

dico01["Oiseau"] = "Faucon"

print(dico05)

print(dico01)

"""

créer une copie indépendante d'un dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Aigle', 'Poisson': 'Requin'}

{'Mammifère marin': 'Baleine', 'Oiseau': 'Faucon', 'Poisson': 'Requin'}

"""

print()

print(" fusionner des dict")

dico01.update(dico02)

print(dico01)

"""

 fusionner des dict

{'Mammifère marin': 'Baleine', 'Oiseau': 'Faucon', 'Poisson': 'Requin', 'Mammifere': 'Chien'}

"""

print()

print("Compter les nombre d'éléments, de paires, dans un dict")

print( len(dico01) ) # 4 paires après le update

"""

tester les dictionnaires {"key": "valeur"}

les fonctions communes ci-dessous s'appliquent sur key uniquement

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

import copy # module interne; copy.deepcopy()

obj01 = {0:1, 1:2, 2:3, 3:2.5, 4:"a", 5:"per"}

obj02 = {0:1, 1:2, 2:3, 3:2.5}

obj03 = {4:"a", 5:"per"}

"""

all()

"""

print(" all() ")

bValeur = all(obj01)

print( bValeur ) # false

"""

all()

returns True if all elements of the set are true (or if the set is empty).

"""

"""

any()

"""

print(" any() ")

bValeur = any( obj01 )

print( bValeur ) # True

"""

any()

Returns True if any element of the set is true. If the set is empty, returns False.

"""

"""

enumerate()

"""

print(" enumerate() ")

obj = enumerate(obj01)

print( type(obj) ) # <class 'enumerate'>

print( go.typeIs(obj) ) # enumerate

print( go.isWhat(obj) ) # {} est de type enumerate - iterable? True

print( go.strc(obj) ) # {}

obj04 = copy.deepcopy(obj)

print( type(obj) ) # <class 'enumerate'>

print( obj ) # <enumerate object at 0x00000242929B5DC0>

print("enumerate as dict ", dict(obj04) ) # {0: 1, 1: 2, 2: 3, 3: 'per', 4: 'a'}; vide obj02

obj04 = copy.deepcopy(obj)

print("enumerate as list ", list(obj04) ) # [(0, 1), (1, 2), (2, 3), (3, 'a'), (4, 'per')];

# l'ordre reste aléatoire, vide obj

"""

enumerate()

Returns an enumerate object. It contains the index and value for all the items of the set as a pair.

attention l'application de list() ou dict() sur cet object enumerate vide cet objet

il faut donc utiliser copy.deepcopy() pour obtenir une copie indépendante de l'objet enumerate

need to import:

import copy # module interne; copy.deepcopy()

"""

"""

len() nombre d'éléments dans un object

"""

print(" len() nombre d'éléments dans un object")

print( len(obj01) ) #

"""

len()

Returns the length (the number of items) in the set.

"""

"""

max() le plus grand item

"""

print("max() le plus grand item")

print( max(obj02) ) # 3

print( max(obj03) ) # "per"

try:

    print( max(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

max()

Returns the largest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

min() le plus petit item

"""

print("min() le plus petit item")

print( min(obj02) ) # 1

print( min(obj03) ) # "a"

try:

    print( min(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

min()

Returns the smallest item in the set.

on ne peut pas mélanger des str avec des int

"""

"""

sorted()

"""

print(" sorted()")

list02 = sorted( obj02 )

print( list02 ) # [1, 2, 2.5, 3]

list03 = sorted( obj03 )

print( list03 ) # ['a', 'per']

try:

    print( sorted(obj01) ) # Something is not defined '>' not supported between instances of 'str' and 'int'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sorted()

Returns a new sorted list from elements in the set(does not sort the set itself).

on ne peut pas mélanger des str avec des int ou float

"""

"""

sum()

"""

print(" sum() ")

valeur02 = sum( obj02 )

print( valeur02 ) # 8.5

try:

    print( sum(obj03) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

try:

    print( sum(obj01) ) # Something is not defined '>' Something is not defined unsupported operand type(s) for +: 'float' and 'str'

except ZeroDivisionError as err:

    print('Handling ZeroDivisionError error:', err)

except StopIteration as err:

    print('Handling StopIteration error: ', err)

except (RuntimeError, TypeError, ValueError, NameError, KeyError) as err:

    print("Something is not defined", err) #

except:

    print("Something else went wrong")

finally:

    pass

    # print("The 'try except' is finished")

"""

sum()

Returns the sum of all elements in the set.

on ne peut pas mélanger des str avec des int ou float; error

ne sait pas faire une somme de str; error

"""

"""

source inspiration

https://www.programiz.com/python-programming/set

"""

"""

convertir les principaux type entre eux

list tuple set dict

"""

import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

#import copy # module interne; copy.deepcopy()

import itertools # convertir  en dict si data not paires

list01 = [3, 4, 5, "a", "l"]

tp01 = (1, 2, 3, "a", "tp")

set01= {1, 2, 3, "a", "s"}

dict01={"name": "briardind", "firstname":"claude", "age":75}

# convertir to list

print("convert to list")

print("tuple to list ", list(tp01), " ", tp01 ) # tuple to list  [1, 2, 3, 'a', 'tp']   (1, 2, 3, 'a', 'tp')

print("set to list ", list(set01), " ", set01 ) # set to list  [1, 2, 3, 'a', 's']   {1, 2, 3, 'a', 's'}

print("dict to list ", list(dict01), " ", dict01 ) # dict to list  ['name', 'firstname', 'age']   {'name': 'briardind', 'firstname': 'claude', 'age': 75}

# convert to tuple

print("convert to tuple")

print("list to tuple ", tuple(list01), " " , list01) # list to tuple  (3, 4, 5, 'a', 'l')   [3, 4, 5, 'a', 'l']

print("set to tuple ", tuple(set01), " " , set01) # set to tuple  (1, 2, 3, 'a', 's')   {1, 2, 3, 'a', 's'}

print("dict to tuple ", tuple(dict01), " " , dict01) # dict to tuple  ('name', 'firstname', 'age')   {'name': 'briardind', 'firstname': 'claude', 'age': 75}

# convert to set

print("convert to set")

print("list to set ", set(list01), " " , list01) # list to set  {3, 4, 5, 'l', 'a'}   [3, 4, 5, 'a', 'l']

print("tuple to set ", set(tp01), " " , tp01) # tuple to set  {1, 2, 3, 'tp', 'a'}   (1, 2, 3, 'a', 'tp')

print("dict to set ", set(dict01), " " , dict01) # dict to set  {'name', 'age', 'firstname'}   {'name': 'briardind', 'firstname': 'claude', 'age': 75}

# convert to dict

#print("list to dict ", dict(list01), " " , list01) # TypeError: cannot convert dictionary update sequence element #0 to a sequence

# print("tuple to dict ", dict(tp01), " " , tp01) # TypeError: cannot convert dictionary update sequence element #0 to a sequence

# print("set to dict ", dict(set01), " " , dict01) # TypeError: cannot convert dictionary update sequence element #0 to a sequence

# convert to dict: cas de data non appairée

print()

print("convert to dict")

print()

# convert list to dict

print("convert list to dict")

iter01 = iter(list01) # converting list to iterable to avoid repetition

dict_object01 = itertools.zip_longest(iter01, iter01, fillvalue=None) # converting the plain_list to dict

dict01 = dict(dict_object01) # convert the zip_longest object to dict using `dict`

print("list to dict converted ",dict01, " " , list01) # list to dict converted  {3: 4, 5: 'a', 'l': None}   [3, 4, 5, 'a', 'l']

# convert tuple to dict

print("convert tuple to dict")

iter01 = iter(tp01) # converting list to iterable to avoid repetition

dict_object01 = itertools.zip_longest(iter01, iter01, fillvalue=None) # converting the plain_list to dict

dict01 = dict(dict_object01) # convert the zip_longest object to dict using `dict`

print("tuple to dict converted ",dict01, " " , tp01) # tuple to dict converted  {1: 2, 3: 'a', 'tp': None}   (1, 2, 3, 'a', 'tp')

# convert set to dict

print ("convert set to dict")

iter01 = iter(set01) # converting list to iterable to avoid repetition

dict_object01 = itertools.zip_longest(iter01, iter01, fillvalue=None) # converting the plain_list to dict

dict01 = dict(dict_object01) # convert the zip_longest object to dict using `dict`

print("set to dict converted ", dict01, " " , set01) # set to dict converted  {1: 2, 3: 's', 'a': None}   {1, 2, 3, 's', 'a'}

# convert to dict: cas des paires; fonctionne avec [paires] (paires) {paire}

print()

print("cas des paires; fonctionne avec [paires] (paires) {paire}")

print(" avec les paires la fonction dict() fonctionne!")

list_of_tuples01 = [('a', 'A'), ('b', 'B'), ('c', 'C')]

dict01 = dict(list_of_tuples01)

print("convert list of tuple to dict ", dict01, " " , list_of_tuples01)

# convert list of tuple to dict  {'a': 'A', 'b': 'B', 'c': 'C'}   [('a', 'A'), ('b', 'B'), ('c', 'C')]

list_of_list01 = [['a', 'A'], ['b', 'B'], ['c', 'C']]

dict01 = dict(list_of_list01)

print("convert list of list to dict ", dict01, " " , list_of_list01)

# convert list of list to dict  {'a': 'A', 'b': 'B', 'c': 'C'}   [['a', 'A'], ['b', 'B'], ['c', 'C']]

list_of_set01 = [{'a', 'A'}, {'b', 'B'}, {'c', 'C'}]

dict01 = dict(list_of_set01)

print("convert list of set to dict ", dict01, " " , list_of_set01)

# convert list of set to dict  {'A': 'a', 'B': 'b', 'C': 'c'}   [{'A', 'a'}, {'B', 'b'}, {'C', 'c'}]

def myfonction():
    print("un texte")

def myfonction():

    """
    texte d'aide sur mafonction(); sera renvoyé par help()
    """

    print("Bonjour")

def mafonction(valeur1, valeur2):
    mysomme = valeur1 + valeur2
    return mysomme

calcul = mafonction(1, 3)

def mafonction(valeur1, valeur2 = 5):
    mysomme = valeur1 + valeur2
    return mysomme

calcul = mafonction(2) # renvoie 2+5 = 7
calcul = mafonction(2,8) # renvoie 2+8=10

print()
print("avec splat et accès aux paramètres via leur indice")

def somme(*args):
    s=0
    for n in args:
        s += n
    print( "Somme : ", s)
    print("nombre de variables transmises : ", len(args) ) # nombre total d'arguments reçus
    valeur0 = args[0] # on accède via un indice de 0 à n-1 où n=len(args)
    valeur = valeur0+1
    return valeur

somme(1,2)
somme(1,2,3,4)
somme(30,100,2)

x= [1,2,3]
chiffre = somme(*x) # passage d'un list comme arguments de fonction
print("chiffre = ", chiffre)

def pgcd(*n): # calucl du Plus Grand Commun dénominateur
    def _pgcd(a,b):
        while b!=0:
            a,b = b,a%b
        return a
    p = _pgcd(n[0],n[1])
    for x in n[2:]:
        p = _pgcd(p,x)
    return p

print("PGCD = ", pgcd(165,515,225,65)) # Plus Grand Commun dénominateur

print()
print("avec double splat")

def myf04(**kwargs):
    for i, j in kwargs.items():
        print(i, j)
    # valeur = valeur1 +3 # ne fonctionne pas, valeur1 is not defined
    # il faut écrire
    valeur = kwargs["valeur1"] # accès à une valeur via sa key
    return valeur

chiffre = myf04(prenom="Pierre", age=29, sport="trail", valeur1 = 10)
print("chiffre= ", chiffre)

def myf05(**p): # écrit a, b, c
    for key,value in p.items():
        print('{} -> {}'.format(key,value))
    #d = c+1 # NameError: name 'c' is not defined, ne fonctionne pas
    # il faut écrire
    my = p["c"] # accès à une valeur via sa key
    return my

valeur = myf05(a = 1, b = 2, c = 5)
print("valeur: ", valeur)

def myf07(**kwargs):
    for cle, valeur in kwargs.items():
        print("l'élément de clé", cle, "vaut", valeur )
    valeur = kwargs["camion"] # accès au contenu,  à la valeur, de "camion"
    return valeur    

myDict = {"voiture": "Renault", "camion": "Berliet"}
valeur = myf07(**myDict) # transmission d'un object dictionnaire comme arguments
print("valeur pour ['camion']", valeur)

print()
print("mélange de splat et double splat et accès aux paramètres via leur key")

def myf06(*args , **kwargs): # mélange de splat et double splat
    for i in args:
        print(i)
    for key,value in kwargs.items():
        print('{} -> {}'.format(key,value))
    print("nombre de variable key, item: ", len(kwargs) ) # nombre de vriables transmises en double splat
    valeurC = kwargs["c"]
    valeur = valeurC +1
    return valeur

chiffre = myf06(48 , 52 , 63 , a = 1, b = 2, c = 5)
print("chiffre = ", chiffre)

def mydata(valeur1, valeur2):
    distance = valeur1 + valeur2
    angle = valeur1/valeur2
    TX = valeur1*valeur2
    return(distance,angle,TX)

distance,angle,TX = mydata(distance,angle,TX) # appel de la fonction

# exploitation des résultats
print("la distance est : ",distance,".")
print(" l'angle est : ",angle,".")

"""
tester les fonctions
"""
# import claudecnx.useIt2021_01 as go # module externe claudecnx as namespace go

print()
print("fonctions avec paramètres")

def myf01(a, b=10):
    print("b=10 est pré défini donc optionnel: ", b)
    s= a+b
    return s

print( myf01(2) )
print( myf01(4,7) )

print()
print("fonction avec aide intégrée")

def myf02(): # pour exemple
    """
    ceci est l'aide de myf02()
    """
    a=5
    return a

help(myf02)

print()
print("fonction avec retour multiple de données")

def myf03(a, b):
    s = a+b
    p = a*b
    return(s, p) # retourne 2 variables

somme, produit = myf03(4, 6)
print("somme= ", somme, " produit = ",produit)

print()
print(" fonctions avec nombre variable d'arguments")

### fonctions avec nombre d'arguments variables
# https://www.mathweb.fr/euclide/2019/04/13/python-et-fonction-a-nombre-variable-darguments/
# https://riptutorial.com/fr/python/example/932/definir-une-fonction-avec-un-nombre-arbitraire-d-arguments

print()
print("avec splat et accès aux paramètres via leur indice")

def somme(*args):
    s=0
    for n in args:
        s += n
    print( "Somme : ", s)
    print("nombre de variables transmises : ", len(args) )
    valeur0 = args[0]
    valeur = valeur0+1
    return valeur

somme(1,2)
somme(1,2,3,4)
somme(30,100,2)

x= [1,2,3]
chiffre = somme(*x) # passage d'un object list comme arguments dans une simple splat
print("chiffre = ", chiffre)

def pgcd(*n): # calucl du Plus Grand Commun dénominateur
    def _pgcd(a,b):
        while b!=0:
            a,b = b,a%b
        return a
    p = _pgcd(n[0],n[1])
    for x in n[2:]:
        p = _pgcd(p,x)
    return p

print("PGCD = ", pgcd(165,515,225,65)) # Plus Grand Commun dénominateur

print()
print("avec double splat")

def myf04(**kwargs):
    for i, j in kwargs.items():
        print(i, j)
    # valeur = valeur1 +3 # ne fonctionne pas, valeur1 is not defined
    # il faut écrire
    valeur = kwargs["valeur1"]
    return valeur

chiffre = myf04(prenom="Pierre", age=29, sport="trail", valeur1 = 10)
print("chiffre= ", chiffre)

def myf05(**p): # écrit a, b, c
    for key,value in p.items():
        print('{} -> {}'.format(key,value))
    #d = c+1 # NameError: name 'c' is not defined, ne fonctionne pas
    # il faut écrire
    my = p["c"]
    return my

valeur = myf05(a = 1, b = 2, c = 5)
print("valeur: ", valeur)

def myf07(**kwargs):
    for cle, valeur in kwargs.items():
        print("l'élément de clé", cle, "vaut", valeur)
    valeur = kwargs["camion"]
    return valeur

myDict = {"voiture": "Renault", "camion": "Berliet"}
valeur = myf07(**myDict) # passage d'un object dict comme arguments pour double splat
print("valeur pour ['camion']", valeur)

print()
print("mélange de splat et double splat et accès aux paramètres via leur key")

def myf06(*args , **kwargs): # mélange de splat et double splat
    for i in args:
        print(i)
    for key,value in kwargs.items():
        print('{} -> {}'.format(key,value))
    print("nombre de variable key, item: ", len(kwargs) )
    valeurC = kwargs["c"]
    valeur = valeurC +1
    return valeur

chiffre = myf06(48 , 52 , 63 , a = 1, b = 2, c = 5)
print("chiffre = ", chiffre)