Python : Mon application destinée aux jardiniers

Edit du 03/ 04/2017

Je viens de déposer la totalité du code source sur Framagit : 

https://framagit.org/Ordinosor/mon-jardin/tree/master

Bonjour, Continuer à lire … « Python : Mon application destinée aux jardiniers »

Python: Les booléens

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

Aujourd’hui, je vais vous parler des booléens. Les booléens sont des êtres farouches qui vivent au fin fond des forêts binaires recouvrant la terre sacrée du Grand Python Digital. Très difficiles à observer dans leur milieu naturel, bla, bla, bla… Continuer à lire … « Python: Les booléens »

Half life 2 – Violation Dubstep Remix

Bonjour,

Aujourd’hui, scoop! Dans le Nord de l’Allemagne, il pleut! Alors du coup, j’en profite pour ranger l’indescriptible foutoir qui me sert de bureau et pour me donner du coeur à l’ouvrage, j’écoute ce morceau en boucle:

Tiens, d’ailleurs, c’est l’occasion de vous expliquer comment intégrer une vidéo Youtube en la démarrant ET en l’interrompant à un moment précis. En effet, cette vidéo dure plus d’une heure et je souhaitais seulement vous faire découvrir ce morceau: Half life 2 – Violation Dubstep Remix.

Eh bien figurez-vous que c’est d’une simplissime facilitude. Lors de l’intégration, il suffit de rajouter ce petit bout de code en jaune:

integ

La vidéo démarre donc à la 90ème seconde  (1’30) et s’interrompt à la 265ème seconde (4′ 25).

Ne me remerciez pas.

Python: Les ensembles (sets et frozensets)

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

Aujourd’hui, nous allons aborder une notion moins connue du langage Python, à savoir les ensembles (sets et frozensets). Continuer à lire … « Python: Les ensembles (sets et frozensets) »

Python: Les dictionnaires

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

J’habite en Allemagne et l’idiome guttural de ce pays n’est pas ma langue maternelle. Par conséquent, lorsqu’un mot me manque, je consulte un dictionnaire. Je me rends directement à l’emplacement précis du mot français, par exemple Ambulance, et ce mot français est comme une clé qui me donne accès à la valeur correspondante dans la langue de Rammstein :

Ambulance : Krankenwagen

Figurez-vous qu’il existe exactement le même procédé en Python et c’est bien plus pratique qu’une liste. Les dictionnaires sont la solution idéale pour réaliser un test d’appartenance et en extraire une valeur.

dico
Ne jamais laver un dictionnaire à 60°!

Limitation des listes

Le problème des listes, c’est qu’il s’agit d’une séquence d’objets indicés, c’est-à dire que pour avoir accès à un élément précis, il faut connaitre son indice :

mots_fr = ["Ambulance", "Hôpital","Infirmière"]
mots_allemands = ["Krankenwagen", "Krankenhaus","Krankenschwester"]

Par exemple, je sais que l’indice d’Infirmière est le nombre entier 2. Je consulte la liste allemande. Que trouve-t-on à l’indice 2? Krankenschwester.

Pas très pratique tout ça! En plus, est-ce que je suis sûr que les traductions sont rangées dans le bon ordre. Est-ce que le mot allemand qui est à l’indice 1 (Krankenhaus) correspond bien au mot français au même indice (Hôpital)? Si ça se trouve, c’est tout dans le désordre!

Pour éviter ce genre de désagréments, on pourrait alors imaginer une liste de listes contenant des paires mot_allemand – mot_français:

dictionnaire = [["Ambulance", "Krankenwagen"], ["Hôpital", "Krankenhaus"],["Infirmière", "Krankenschwester"], [(...), (...)]]

Et pour trouver la traduction, on pourrait utiliser ce code:

dictionnaire =[["Ambulance", "Krankenwagen"], ["Hôpital", "Krankenhaus"],["Infirmière", "Krankenschwester"]]
for i, element in enumerate (dictionnaire):
    if "Hôpital" in dictionnaire[i]:
        print(dictionnaire[i][1])

Résultat: « Krankenhaus »

« Ça marche, Ordinosor! On l’a, notre dictionnaire français-allemand ».

Ne t’emballe pas, jeune fou! je te rappelle que les listes sont des séquences. Cela signifie que pour faire un test d’appartenance, elles sont parcourues de l’indice 0 jusqu’à l’indice de l’élément recherché. En clair, si tu cherches la traduction de zygomatique qui se trouve à la fin du dictionnaire, il va falloir que tu tournes toutes les pages une par une et que tu lises tous les mots un par un! Tu n’as pas le choix, ton dictionnaire est une liste.

Tu sais quoi? On va se donner rendez-vous en 2025. Tu m’apporteras ta traduction. Allez vas-y, tourne les pages!

Bon… en attendant, entrons dans le vif du sujet.

Définition et déclaration d’un dictionnaire

Définition

Un dictionnaire est un ensemble dont les éléments sont des paires clé-valeur . Au niveau syntaxique, un dictionnaire est contenu entre deux accolades. Les éléments sont séparés par des virgules tandis que les paires clé-valeur sont séparées par deux points. Voici ce que ça donne:

nom_du_dictionnaire = {clé : valeur, clé : valeur, clé : valeur, (…) : (…)}

Un dictionnaire est modifiable et les valeurs peuvent être n’importe quel objet (immuable ou modifiable, il n’y a aucune restriction) mais les clés doivent absolument être des objets immuables (string, nombre entier, nombre décimal, tuple). Si la clé est un tuple, celui-ci ne doit contenir que des éléments immuables. Par exemple, ce genre de clé ([0, 1], [2, 3]) qui est un tuple contenant des listes modifiables va lever une exception (erreur):

TypeError: unhashable type: ‘list’

Déclarer un dictionnaire

  • Pour déclarer un dictionnaire, on utilise des accolades :
dictionnaire = {} # dictionnaire vide
  • Je viens de créer un dictionnaire vide mais je peux très bien créer un dictionnaire et y placer des éléments dès sa déclaration :
capitales = {"France":"Paris", "Allemagne" : "Berlin"}

Dans cet exemple, « France » est une clé tandis que « Paris » est une valeur.

  • Il existe une autre méthode pour créer un dictionnaire. Elle consiste à créer une liste de tuples que l’on transforme en dictionnaire grâce au constructeur dict().
liste_capitales = [("France","Paris"), ("Allemagne","Berlin")]
capitales = dict(liste_capitales)
print(capitales)

Résultat : {‘Allemagne’: ‘Berlin’, ‘France’: ‘Paris’}

  • Il n’est pas possible de dupliquer une clé. Si on le fait, ce sera la dernière valeur entrée pour cette clé qui sera prise en compte.
capitales = {"France":"Paris", "Allemagne" : "Berlin", "France" : "Marseille"}
print(capitales)

Résultat: {‘Allemagne’: ‘Berlin’, ‘France’: ‘Marseille’}

Ajouter un élément (paire clé-valeur)

Si je veux rajouter un élément, c’est très simple, je créé une nouvelle paire clé-valeur. La clé  est contenue entre des crochets et la valeur se trouve à la droite du signe d’affectation. La syntaxe est donc la suivante :

nom_du_dico[clé] = valeur

capitales['Islande'] = "Reykjavik"
print(capitales)

Résultat : {‘Allemagne’: ‘Berlin’, ‘Islande’: ‘Reykjavik’, ‘France’: ‘Paris’}

Diantre! Les éléments ne sont plus dans le même ordre? Comment se fait-ce?

Ça n’a aucune espèce d’importance. L’ordre est aléatoire car un dictionnaire n’est pas une séquence, c’est une implémentation de tables de hachage. Pour retrouver une valeur, nous avons seulement besoin de connaître sa clé.

Accéder à une valeur

Voici comment on accède à une valeur:

capitales = {'Allemagne': 'Berlin', 'Islande': 'Reykjavik', 'France': 'Paris'}
result = capitales["Allemagne"] #Je stocke le résultat dans une variable.
print(result)

Résultat : « Berlin »

C’est simple et instantané! Le programme n’a pas besoin de parcourir le dictionnaire du début à la fin. Grâce à la clé (« Allemagne »), Python est en mesure de se rendre directement à la « page » souhaitée pour trouver la valeur et renvoyer cette dernière. Que le dictionnaire contienne dix éléments ou cinq cent millions, la vitesse d’exécution sera de toute façon identique!

Et si j’utilise une clé qui n’est pas dans le dictionnaire, Python lève une exception (erreur):

result = capitales["Syldavie"]
print(result)

KeyError: ‘Syldavie’

La méthode get() comme test d’appartenance

Pour contourner cette exception et éviter d’avoir un message d’erreur qui stoppe le programme, il suffit d’utiliser la méthode get() en lui passant deux arguments : la clé et le résultat renvoyé au cas où la clé serait absente du dictionnaire. Reprenons le code précédent :

result = capitales.get("Syldavie", "Non répertorié.")
print(result)

Résultat : Non répertorié.

Tester l’appartenance avec l’instruction in

Il est possible de tester l’appartenance d’une clé à un dictionnaire grâce à la puissante instruction in.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
if "Islande" in capitales:
    print(capitales["Islande"])

Résultat : Reykjavik

Je précise que l’instruction in ne teste que l’appartenance des clés et non pas l’appartenance des valeurs.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
if "Reykjavik" in capitales:
    print("Test d'appartenance réussi")
else:
    print("Cette clé est absente du dictionnaire")

Résultat: Cette clé est absente du dictionnaire

Mettre à jour une valeur

Si on souhaite mettre à jour une valeur, c’est fort simple. Voici comment on procède:

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
capitales["France"] = "Marseille"
print(capitales)

Résultat: {‘France’: ‘Marseille’, ‘Allemagne’: ‘Berlin’, ‘Islande’: ‘Reykjavik’}

Utiliser un tuple comme clé

C’est tout à fait possible, à la condition que le tuple ne contienne que des objets immuables. Quant à la valeur, elle peut être constituée par n’importe quel objet donc une liste ne pose aucun problème.

Dès lors, on peut très bien imaginer un dictionnaire avec en guise de clés, des tuples contenant les noms de capitales et les noms de pays et en guise de valeurs, des listes contenant la latitude et la longitude.

coords = {("Paris","France"):["48° 51′ N", "2° 21′ E"], ("Berlin","Allemagne"): ["52° 31′ N", "13° 24′ O"]}
result = coords[("Paris", "France")]
print(result)

Résultat : [’48° 51′ N’, ‘2° 21′ E’]

code_dict
Visualisation du code avec Pythontutor

Supprimer un élément grâce à l’instruction del

Nous avons vu comment rajouter un élément dans un dictionnaire. C’est d’une simplicité enfantine. Pas besoin de faire appel à la méthode append().

Pour supprimer un élément, on utilise l’instruction del. En fait, on supprime la clé et par conséquent, la valeur qui lui est associée.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
del capitales["Allemagne"]
print(capitales)

Résultat : {‘France’: ‘Paris’, ‘Islande’: ‘Reykjavik’}

Supprimer tout le dictionnaire grâce à l’instruction del

Notez bien que l’instruction del permet également de supprimer tout le dictionnaire. Il suffit pour cela, de ne pas lui passer de clé entre crochets.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
del capitales
print(capitales)

NameError: name ‘capitales’ is not defined

Ce message d’erreur nous confirme que le dictionnaire n’existe plus.

Utiliser la fonction intégrée len()

On peut également utiliser la fonction intégrée len() pour connaître le nombre de paires clé-valeur contenues dans un dictionnaire.

capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
print(len(capitales))

Résultat: 3

Aperçu de quelques méthodes associées aux dictionnaires

  • dict.clear() supprime tous les éléments d’un dictionnaire. En clair, il le vide.
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
capitales.clear() # Vide le dictionnaire
print(capitales)

Résultat: {}

  • dict.items() retourne toutes les paires clé-valeur sous la forme d’une liste de tuples
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.items()
print(result)

Résultat: dict_items([(‘Islande’, ‘Reykjavik’), (‘France’, ‘Paris’), (‘Allemagne’, ‘Berlin’)])

  • dict.keys() retourne toutes les clés du dictionnaire sous la forme d’une liste
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.keys()
print(result)

Résultat: dict_keys([‘Islande’, ‘Allemagne’, ‘France’])

  • dict.values() retourne toutes les valeur du dictionnaire sous la forme d’une liste
capitales = {"France":"Paris", "Allemagne" : "Berlin","Islande": "Reykjavik"}
result = capitales.values()
print(result)

Résultat: dict_values([‘Berlin’, ‘Reykjavik’, ‘Paris’])

Conclusion

Un dictionnaire est un ensemble non ordonné de paires clé-valeur. Chaque clé donne accès à la valeur qui lui est associée. Plus puissant qu’une liste, Un dictionnaire est idéal pour réaliser un test d’appartenance. En effet, comme il s’agit d’une implémentation de table de hachage et non pas d’une séquence, la vitesse d’exécution du test d’appartenance n’est pas liée au nombre d’éléments que le dictionnaire contient.

Il existe des compréhensions de dictionnaire qui feront l’objet d’un chapitre ultérieur.

#Primtux, une distribution Linux destinée aux élèves du primaire.

Bonjour

Il y a quelques jours, j’ai découvert Primtux, une distribution Linux « développée (je cite) par une petite équipe de professeurs des écoles et de passionnés de l’informatique dans le milieu éducatif. »

Ce diaporama nécessite JavaScript.

Je trouve que c’est une belle initiative. Ludique et éducative à la fois, elle s’adresse aux élèves scolarisés dans l’enseignement primaire. Je l’ai testée en démo dans une machine virtuelle. Elle contient entre autres, une version LibreOffice avec un design beaucoup plus coloré. Cette version offre par exemple la possibilité de coloriser les syllabes d’un mot ou de les souligner, de mettre en évidence les liaisons obligatoires, les lettres muettes, les phonèmes etc…

Au passage, il y a une magnifique faute d’orthographe avec l’onglet aggrandir l’image (oui vous avez bien lu! Avec deux g). Les professeurs des écoles ne l’ont pas remarquée. Carton rouge! Vous me recopierez  cent fois :

« Oh! la! la! Qu’est-ce qu’il aggrandit? Sa lui fait quel âge maintenant? Céding! On voit pas le tant passé! »

C’est le résultat de la méthode globale ou de la méthode syllabique?

Il y a trois niveaux :

  • Mini (pour les 3 – 5 ans)
  • Super (pour les 6-7 ans)
  • Maxi (pour les 8 – 10 ans)

Les niveaux Super et Maxi bénéficient d’un accès internet restreint c’est-à dire qu’il est inutile de taper ebay.fr dans la barre de recherche. Vous obtiendrez un message vous signifiant que l’accès à ce site est interdit. Le moteur de recherche est Qwant Junior.

On trouve également une multitude de petits jeux éducatifs pour assimiler des notions de français, mathématiques, géométrie etc… Voici un aperçu dans la vidéo mise en ligne sur le site officiel.

Il s’agit en tout cas d’une bien belle initiative qui permet à des élèves du primaire de découvrir l’univers Linux. À adopter!

Python: Les tuples

Pour une lecture plus agréable (page plus large), je vous invite à cliquer sur ce lien et à lire ce chapitre dans la rubrique consacrée au langage Python.

Un tuple est un ensemble d’éléments comparable aux listes mais qui, une fois déclaré, ne peut plus être modifié. Il s’agit donc d’une séquence immuable d’objets indicés qui peuvent être des nombres entiers ou décimaux, des chaînes de caractères, des listes, des tuples etc…

tuple_tulipes
Tuple de tulipes

Syntaxe et déclaration

D’un point de vue syntaxique, un tuple est un ensemble d’éléments séparés par des virgules. Cet ensemble d’éléments est entouré de parenthèses mais ce n’est pas une obligation. Cela permet toutefois d’améliorer la lisibilité du code.

Déclarons un tuple :

tuple_1 = (8, "Solange", 5.3)

J’aurais très bien pu écrire :

tuple_1 = 8, "Solange", 5.3

Cela revient au même sauf que c’est moins lisible.

print(type(tuple_1))

<class ‘tuple’>

Sans le savoir, nous avons déjà rencontré des tuples, notamment lorsque nous avons fait des affectations multiples :

a, b = 5, 6

Cette instruction d’affectation correspond à :

(a, b) = (5, 6)

Si nous souhaitons déclarer un tuple ne contenant qu’une seule valeur, il faut absolument que cette dernière soit suivie d’une virgule. En outre, il est vivement conseillé de l’inclure entre parenthèses.

c = (9,)

print(type(c))

<class ‘tuple’>

Si nous oublions la virgule (et malgré la présence de parenthèses), le type de la variable ne sera pas un tuple :

c = (9)

print(type(c))

<class ‘int’>

Utilité d’un tuple par rapport à une liste

Comme nous l’avons vu plus haut, il permet de faire des affectations multiples.

a, b = 5, 6

Le tuple permet également de renvoyer plusieurs valeurs lors d’un appel de fonction.

def information_personne(prenom, nom, age) :
    "Traitement des informations transmises"
    prenom = prenom.capitalize() # Première lettre en majuscule.
    nom = nom.upper() # remplace toutes les minuscules en majuscules
    age = int(age)
    return prenom, nom, age # Tuple sans parenthèses

p = input("Entrez votre prénom: ")
n = input("Entrez votre nom: ")
a = input("Entrez votre âge: ")

prenom, nom, age = information_personne(p, n, a) # Affectation multiple
print("Prénom:", prenom + '\n' + "Nom:", nom + '\n' + "Âge:", age)

Entrez votre prénom: alphonsine
Entrez votre nom: Chafouin
Entrez votre âge: 92

Résultat:

Prénom: Alphonsine
Nom: CHAFOUIN
Âge: 92

Un tuple est « protégé en écriture ».

Vous allez me dire que dans le code ci-dessus, nous pouvons obtenir le même résultat en renvoyant une liste (return [prenom, nom, age]). Mais l’avantage d’un tuple, c’est qu’il s’agit d’une séquence non modifiable (immuable) donc protégée en écriture. Nous sommes sûrs que les données transmises par la fonction input() ne seront pas modifiées en cours d’exécution par un autre programme. Dans le code ci-dessus, je n’ai aucun moyen de modifier les informations transmises.

Par contre, dans le code ci-dessous où je renvoie une liste, je peux modifier les données transmises et rajeunir Mamie Alphonsine!

def information_personne(prenom, nom, age) :
    "Traitement des informations transmises"
    prenom = prenom.capitalize() # Première lettre en majuscule.
    nom = nom.upper() # remplace toutes les minuscules en majuscules
    age = int(age)
    return [prenom, nom, age] # liste

p = input("Entrez votre prénom: ")
n = input("Entrez votre nom: ")
a = input("Entrez votre âge: ")

identification = information_personne(p, n, a) #Liste
identification[2] = '45' # Je modifie l'âge
print("Prénom:", identification[0] + '\n' + "Nom:", identification[1] + '\n' + "Âge:", identification[2])

Entrez votre prénom: alphonsine
Entrez votre nom: Chafouin
Entrez votre âge: 92

Prénom: Alphonsine
Nom: CHAFOUIN
Âge: 45

Un tuple est moins gourmand en ressources système qu’une liste.

Il a besoin de moins de mémoire et il s’exécute plus rapidement.

Opérations sur les tuples

Il n’existe pas de méthodes associées aux tuples

Les tuples sont des séquences non modifiables donc il n’est pas possible d’utiliser les méthodes remove()  ou append() par exemple.

Il n’est pas possible également d’utiliser l’opérateur [] pour insérer ou remplacer un élément :

tuple_1 = (5, 2, 25, 56)
tuple_1[2] = 23
print(tuple_1)

TypeError: ‘tuple’ object does not support item assignment.

L’instruction in

Mais il est possible d’utiliser l’instruction in pour faire un test d’appartenance

tuple_1 = (5, 2, 25, 56)
print(2 in tuple_1)

Résultat: True

La fonction intégrée len()

Il est également possible d’utiliser la fonction intégrée len() pour déterminer la longueur d’un tuple.

tuple_1 = (5, 2, 25, 56)
print(len(tuple_1))

Résultat : 4

La boucle for et la compréhension de liste

Tout comme les chaînes de caractères ou les listes, les tuples peuvent être parcourus par une boucle for ou une compréhension de liste. Dans ce dernier cas, le résultat obtenu est toujours une liste.

Concaténation et multiplication

Nous pouvons créer un nouveau tuple par concaténation ou par multiplication

tuple_1 = (5, 2, 25, 56)
tuple_2 = ("Jacky", "Hervé")
tuple_3 = tuple_1 + tuple_2
print(tuple_3)

Résultat: (5, 2, 25, 56, « Jacky », « Hervé »)

tuple_prenoms = ("Jacky", "Hervé")
tuple_prenoms = tuple_prenoms * 3
print(tuple_prenoms)

Résultat: (‘Jacky’, ‘Hervé’, ‘Jacky’, ‘Hervé’, ‘Jacky’, ‘Hervé’)

Dans ce dernier exemple, certains vont me dire: « Mais Ordinosor! Tu nous a dit qu’un tuple n’était pas modifiable et tu viens juste de modifier tuple_prenoms! »

Faux! Je n’ai appliqué aucune méthode de modification sur tuple_prenoms. J’ai seulement écrasé la valeur contenue dans la variable qui porte le nom de tuple_prenoms en lui affectant une nouvelle valeur.

Conclusion

Les tuples sont des séquences non modifiables qui s’avèrent bien utiles pour protéger en écriture des données transmises. En outre, ils sont moins gourmands en ressource système et sont traités plus rapidement.

Puisqu’il est immuable, il est possible d’utiliser un tuple comme clé de dictionnaire mais à la seule condition que le tuple ne contienne que des éléments non modifiables! Du reste, ce sera l’objet du prochain chapitre.