[Python 3] Méthodes de tri

ARTICLE EN COURS DE CONSTRUCTION

### 2 - TRI - ###

### 2.1 TRI : tuple
aa = (8, 4, 6, 1, 9, 5, 2, 7, 0, 3)
### 2.1.1 TRI : tuple : sorted()
print("### 2.1.1 TRI : tuple : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2 TRI : list à une dimension
aa = [8, 4, 6, 1, 9, 5, 2, 7, 0, 3]
### 2.2.1 TRI : list à une dimension : sorted()
print("### 2.2.1 TRI : list à une dimension : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2.2 TRI : list à une dimension : sort()
print("### 2.2.2 TRI : list à une dimension : sort()")
aa.sort()
print(aa)
print()

### 2.3 TRI : list à plusieurs dimensions
aa = [
("h", "J", 2),
("j", "I", 8),
("a", "G", 4),
("g", "H", 3),
("i", "E", 6),
("b", "D", 5),
("c", "B", 0),
("d", "F", 7),
("f", "C", 1),
("e", "A", 9)
]
### 2.3.1 TRI : list à plusieurs dimensions : sorted()
print("### 2.3 TRI : list à plusieurs dimensions : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.3.2 TRI : list à plusieurs dimensions : lambda
print("### 2.3 TRI : list à plusieurs dimensions : lambda")
xx = sorted(aa, key=lambda x: x[0])
print(*xx)
yy = sorted(aa, key=lambda x: x[1])
print(*yy)
zz = sorted(aa, key=lambda x: x[2])
print(*zz)
print()

### 2.3.3 TRI : list à plusieurs dimensions : itemgetter
aa = [
("abricot ", "catégorie 1 ", "prix 1"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 3"),
("raisin ", "catégorie 1 ", "prix 3"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 2")
]
from operator import itemgetter as ig
print("### 2.3 TRI : list à plusieurs dimensions : itemgetter")
zz = sorted(aa, key=ig(0,1,2))
print(*zz)
zz = sorted(aa, key=ig(1,0,2))

for i, j, k in zz:
print(i, j, k)

print()

### 2.4 TRI : dict
dico = {"Alain": 2, "Bernard": 3, "Christian": 4, "Dominique": 1}

### 2.4.1 TRI : dict : lambda
print("### 2.4.1 TRI : dict : lambda")
aa = dico.items()

zz = sorted(aa, key=lambda x: x[0])
print(*zz)
zz = sorted(aa, key=lambda x: x[1])
print(*zz)
print()

### 2.4.2 TRI : dict : itemgetter
from operator import itemgetter as ig
print("### 2.4.2 TRI : dict : itemgetter")

aa = dico.items()

zz = sorted(aa, key=ig(0))
print(*zz)
zz = sorted(aa, key=ig(1))
print(*zz)
print()

### 2.5 TRI : class
### 2.5.1 TRI : class : list (ou tuple) : attrgetter
class Fruits:
def __init__(self, aa, bb):
self.prod = aa
self.prix = bb

def __repr__(self):
return "\n{} : {}€".format(self.prod, self.prix)

fruits = [
Fruits("poires ", 3),
Fruits("pommes ", 2),
Fruits("oranges", 2),
Fruits("cerises", 4),
Fruits("abricot", 2)
]

from operator import attrgetter as ag
print("### 2.5.1 TRI : class : list (ou tuple) : attrgetter")
zz = sorted(fruits, key=ag("prod", "prix"))
print(*zz)

zz = sorted(fruits, key=ag("prix", "prod"))
print(*zz)
print()

### 2.5.2 TRI : class : dict : attrgetter
dico = {}
dico["poires"] = Fruits("poires ", 3)
dico["pommes"] = Fruits("pommes ", 2)
dico["oranges"] = Fruits("oranges ", 2)
dico["cerises"] = Fruits("cerises ", 4)
dico["abricots"] = Fruits("abricots", 2)

from operator import attrgetter as ag
print("### 2.5.2 TRI : class : dict : attrgetter")

zz = sorted(dico.values(), key=ag("prod", "prix"))
print(*zz)
zz = sorted(dico.values(), key=ag("prix", "prod"))
print(*zz)

[Python 3] Trier un « Dictionnaire »

Dans de nombreux langages informatiques, on retrouve le « Dictionnaire », cette variable un petit peu particulière qui regroupe l’association d’un ensemble de « clés » à leur « valeur », comme un dictionnaire est le regroupement d’un ensemble de mots associés à leur définition.

Je ne m’étendrai pas, ici, sur le fonctionnement du dictionnaire; je rappellerai néanmoins que dans un dictionnaire, chaque clé (le mot) est unique (mais plusieurs clés peuvent avoir la même valeur).

En Python, on remarquera que l’affichage du contenu d’un dictionnaire est aléatoire; ainsi, si j’établis mon dictionnaire dico de la façon suivante et que j’en demande l’affichage par une fonction print()

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
print(dico)

Résultat : {‘un’: 1, ‘quatre’: 4, ‘deux’: 2, ‘zéro’: 0, ‘cinq’: 5, ‘trois’: 3}

je constate que, même si l’affichage n’est pas particulièrement attrayant, les éléments qui composent notre dictionnaire sont présentés de façon erratique.

N’ayant pas la possibilité de modifier l’ordre d’affichage dans un dictionnaire, nous allons contourner ce problème en enregistrant l’ensemble de notre dictionnaire dans une variable que nous appellerons ici mavar

mavar = dico.items()

Notons simplement que pour réussir notre opération, nous devons faire appel à la méthode items().
Ensuite, nous appliquons la méthode sorted() pour effectuer le tri et l’enregistrons dans une variable que nous appelons montri

montri = sorted(mavar, key=lambda x: x[1])

La méthode sorted() appelle tout d’abord l’objet que nous souhaitons trier, à savoir la variable mavar dans laquelle nous avons enregistré l’ensemble des binômes contenus dans notre dictionnaire.

Nous choisissons ensuite, avec la suite key=lambda x: x[1], la « clé » key de notre tri (à ne pas confondre avec les clés du dictionnaire), qui va définir le paramètre de tri (tri par clés du dictionnaire – zéro, un, deux etc… – auquel cas la valeur entre crochets sera x[0], ou par valeurs – 0, 1, 2 – avec x[1]).

A noter que si nous voulions notre affichage dans l’ordre descendant, nous aurions rajouté à notre méthode sorted() la commande reverse=True, comme ceci

montri = sorted(mavar, key=lambda x: x[1], reverse=True)

Pour info : il existe d’autres méthodes pour faire un tri en Python, notamment en faisant appel à la commande itemgetter de la bibliothèque operator.

Il ne nous reste plus qu’à afficher le résultat de notre tri, avec une « liste en intention », par exemple, alternative intéressante à la traditionnelle boucle en for

[print(j, i) for i, j in montri]

Quelques explications concernant cette ligne : rappelons que la variable montri est composée de binômes :
zéro, 0
un, 1
deux, 2…
i et j vont respectivement venir extraire les clés (zéro, un, deux, trois…) et les valeurs (0, 1, 2..).
Notre ligne de code demande donc d’afficher successivement chaque binôme j, i (print(j, i) nous avons inversé l’ordre d’affichage) par l’intermédiaire d’une boucle (for i, j) contenu dans notre objet montri.

Voici le code dans sa totalité :

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
mavar = dico.items()
montri = sorted(mavar, key=lambda x: x[1])
[print(j, i) for i, j in montri]


0 zéro
1 un
2 deux
3 trois
4 quatre
5 cinq

[Python 3] Extraire chaque mot d’une chaine de caractères

Ce second article consacré au langage Python s’adresse aux lecteurs ayant déjà quelques notions de base du langage; je m’efforcerai, néanmoins, de simplifier et d’expliquer au maximum chaque ligne de code. Pour ceux qui ne souhaitent pas s’embarrasser des explications, le script final se trouve à la fin de l’article.

Nous allons voir, ici, comment manipuler les « strings » (chaines de caractères – cdc) afin d’extraire chaque « mot » ( chaque groupe de caractères que nous appellerons ainsi par commodité) d’une cdc et l’enregistrer dans une « liste » (variable pouvant contenir plusieurs valeurs).

Prenons une cdc quelconque constituée de mots et enregistrons la dans une variable que nous appellerons cdc :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

C’est autour des espaces que nous allons articuler notre travail puisque, ce sont finalement, eux qui définissent nos mots.

Commençons donc par compter le nombre d’espaces dans notre cdc :

esp = cdc.count(" ")

Que nous dit cette ligne ?
Dans notre variable cdc, autrement dit dans notre chaine : A8zx 7r:t i 23.54 , compte (.count) le nombre d’espaces (« ») et enregistre ce nombre dans la variable esp

Voyons ce que nous obtenons :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"
esp = cdc.count(" ")
print(esp)

Résultat : 5

Nous avons, effectivement 5 espaces dans notre cdc.
Il va maintenant s’agir de déterminer le début et la fin de chaque mot…
Nous allons le faire en identifiant les index (l’index correspond, ici, au numéro de chaque caractère dans notre cdc, le premier caractère de notre chaine ayant 0 pour index; le second, 1; le troisième, 2 etc..) de la première lettre de notre mot et de l’espace qui le termine.

Puisque, pour chaque mot, nos index vont changer, nous allons donc utiliser des variables pour identifier, pour chaque mot, l’index du début et celui de fin.
Soit deb l’index de début et fin l’index de fin.
L’index du premier caractère du premier mot de notre cdc correspond au premier caractère de notre cdc, il prend donc la valeur 0 :

deb = 0

Pour déterminer l’index du premier espace, nous utilisons un code très proche de celui que nous avons écrit pour compter le nombre d’espaces dans notre cdc :

fin = cdc.index(" ")

Nous avons remplacé la fonction count() par la fonction index(), qui détermine l’index de la première occurrence de la chaine se trouvant entre ses parenthèses, autrement dit, dans notre cas, l’espace.
Faisons un petit test :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"
fin = cdc.index(" ")
print(fin)

4

Le premier espace de notre cdc a 4 pour numéro d’index et se trouve en 5e position.

Il nous faut maintenant créer notre « liste », cette variable particulière qui va accueillir chaque mot de notre cdc. Il nous suffit de nommer notre variable, appelons la maListe par exemple, et de la faire suivre de = []; Python sait ainsi qu’il sagit d’une liste, vide pour l’instant.

maListe = []

Récapitulons : notre premier mot commence avec l’index 0 enregistré dans la variable deb et se termine par l’index 4 de notre premier espace, enregistré dans la variable fin.
Faisons un essai en extrayant le premier mot de notre chaine contenue dans la variable cdc.
Pour faire l’extraction, il suffit de faire suivre la notre cdc de [index du début:index de fin] soit :
A8zx 7r:t i 23.54 [0:4]

Contrôlons :

print("A8zx 7r:t i 23.54 <i1 q+2N"[0:4])

A8zx

Rendons notre code plus lisible et plus adapté à notre projet en remplaçant toutes nos valeurs absolues par des variables :

cdc[deb:fin]

Et puisque nous voulons enregistrer chaque mot dans notre liste pour, éventuellement, pouvoir le rappeler par la suite, nous allons modifier le code comme ceci :

maListe.append(cdc[deb:fin])

Ici, la fonction append() permet d’enregistrer un nouvel élément (l’extraction de notre mot, contenu dans entre les parenthèses) à notre liste maListe.
Bon, voilà pour le principe… maintenant, puisque nous avons plusieurs mots, il va falloir répéter ce principe autant de fois qu’on a de mots par l’intermédiaire d’une boucle.
Tout d’abord, nous allons déterminer le nombre de fois que l’on va répéter l’opération.
Dans notre cas de figure, nous avons 6 mots séparés par 5 espaces… En règle générale, nous aurons un mot de plus que d’espaces, on peut donc dire que notre nombre de mots est égal à notre variable esp + 1. Ecrivons donc notre boucle :

for i in range(0, esp + 1):

Qu’est ce que cela signifie ? traduisons mot à mot…

for : pour
i : i est notre compteur qui s’incrémente à chaque tour de la boucle
in : dans
range : champ
(0, esp + 1) : 0, 6
les 2 points : terminent la ligne et annoncent l(es)’instruction(s) à répéter.

Autrement dit, pour chaque valeur de i (i = 0, i = 1, i = 2…. i = 5; i est bien répété 6 fois entre sa valeur 0 et sa valeur 5 !!!), accomplir la tache d’extraction du mot et l’enregistrer dans la liste maListe.

Affichons les élements de notre liste maListe, à l’aide de la fonction print(),et voyons à quoi ressemble son contenu maintenant :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = cdc.index(" ")
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    print(maListe)

Avant de commenter le résultat, retenons qu’en langage Python, l’intentation (tabulation) a une importance capitale qui contribue à la lisibilité du code : toutes les actions qui doivent être répétées dans la boucle sont écrites en retrait d’une tabulation par rapport à la ligne qui initie notre boucle.

A8zx
A8zx A8zx
A8zx A8zx A8zx
A8zx A8zx A8zx A8zx
A8zx A8zx A8zx A8zx A8zx
A8zx A8zx A8zx A8zx A8zx A8zx

Bon, ce n’est pas encore le résultat espéré mais c’est plutôt encourageant : nous avons 6 lignes qui correspondent aux 6 répétitions de notre boucle, autrement dit, aux 6 mots contenus dans notre cdc; et à chaque nouvelle boucle, nous avons un mot qui s’ajoute aux précédents. Notre boucle fonctionne donc correctement, il va maintenant falloir lui faire extraire chaque mot de la cdc, et non pas répéter le premier mot uniquement.

Comment extraire le second mot ? Pourquoi ne pas amputer notre variable cdc du premier mot et recommencer notre routine ? Remplaçons notre variable cdc par sa nouvelle valeur :

cdc = cdc[fin+1:]

fin+1 (soit l’index 5 à ce niveau de l’opération) correspond à l’index du caractère qui suit notre premier espace (rappelons que la variable fin enregistre l’index de l’espace) donc il s’agit du caractère 7 de notre cdc.
La suite du code entre les crochets ne contient que :, autrement dit, puisqu’on ne spécifie pas l’index de fin, Python enregistre le reste de la cdc jusqu’au dernier caractère.
Contrôlons notre ligne de code :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = cdc.index(" ")
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]
    print(cdc)

7r:t i 23.54 i 23.54 54 1 q+2N
i 23.54
54
1 q+2N
N

Notre premier mot a disparu de notre variable cdc, c’est ce que nous voulions !
Le second mot de la cdc originelle est maintenant devenu le premier.
La boucle ne calcule plus que 5 lignes, ce qui est conforme à nos attentes… les autres lignes sont amputées, à chaque fois, par notre instruction cdc=cdc[fin+1:], qui modifie notre variable cdc.
Tout est normal.
Afin d’extraire notre nouveau « premier » mot, il va falloir recalculer sa variable fin; il s’agit juste de répéter la ligne fin = cdc.index(« »), dans notre boucle… afin que le calcul se refasse automatiquement pour chaque nouveau mot.
Testons :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = cdc.index(" ")
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]
    fin = cdc.index(" ")
    print(cdc)

ERREUR !!!

L’erreur était prévisible, à un moment donné, puisque notre dernier mot n’est pas suivi d’espace.
Python affiche donc un message d’erreur. Comment contourner le problème ? Avec une simple astuce : nous allons vérifier, à chaque fois que notre variable cdc est amputée d’un mot, qu’elle contient toujours au moins un espace et c’est notre fonction cdc.count(« ») qui va nous aider. Nous allons instruire Python au travers d’une « condition »; ajoutons les lignes suivantes à notre code :

    if cdc.count(" ")!=0:
        fin = cdc.index(" ")
    else:
        fin = len(cdc)

Vous noterez, tout d’abord, qu’encore une fois, nous indentons notre code selon le même principe que précédemment, avec notre boucle.
if : si
cdc.count(« ») : nombre d’espaces dans la variable cdc
!= : signifie littéralement différent, autrement dit, si le nombre d’espaces dans la variable cdc est différent de 0, donc tant qu’il y a des espaces, on recalcule la variable fin.
else: : sinon (s’il n’y a plus d’espace)
len(cdc) : len est l’abréaviation de length en anglais, autrement dit, la longueur. Ici, on entend le nombre total de caractères (restant à) de notre variable cdc. Cette information jouera le rôle d’index et définira le dernier caractère de notre dernier mot.

Revoyons la globalité de notre code en respectant l’indentation :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = cdc.index(" ")
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]
    if cdc.count(" ")!=0:
        fin = cdc.index(" ")
    else:
        fin = len(cdc)

et faisons un contrôle, cette fois ci, en bonne et due forme.
Nous allons contrôler toutes les valeurs enregistrées par notre variable maListe.
On appelle chacune d’entre elles par leur numéro d’index.
Dans ce cas précis, l’index ne sera plus la position du caractère dans la cdc mais la position de chaque mot dans la variable maListe.

for j in range(len(maListe)):
    print(maListe[j])

La première ligne incrémente la valeur j de 0 (sous entendu puisque non précisé) à len(maListe), c’est à dire ici le nombre d’éléments contenus dans maListe.
Autrement dit, pour chaque valeur contenue dans maListe à partir de 0, incrémente, à chaque fois j de 1 (
première valeur contenue dans maListe – A8zx – j = 0
deuxième valeur contenue dans maListe – 7r:t – j = 1
etc… ).
la seconde affiche l’élément de maListe dont l’index vaut j
Voici notre code :

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = cdc.index(" ")
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]
    if cdc.count(" ")!=0:
        fin = cdc.index(" ")
    else:
        fin = len(cdc)

for j in range(len(maListe)):
    print(maListe[j])

A8zx
7r:t
i
23.54
<i1
q+2N

Tout semble marcher parfaitement, sauf que…
si nous changeons la valeur de notre variable cdc et lui attribuons une cdc sans espace

cdc = "q+2N"

notre programme va planter ! Puisque le programme ne trouve pas d’espace dans la cdc…
Pour cela nous allons légèrement modifier le début de notre script et notre variable fin en copiant-collant les lignes suivantes :

if cdc.count(" ")!=0:
    fin = cdc.index(" ")
else:
    fin = len(cdc)

à la place de :

fin = len(cdc)

voici, à présent, notre code qui fonctionne, quel que soit l’état de notre variable cdc:

maChaine = cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
if cdc.count(" ")!=0:
    fin = cdc.index(" ")
else:
    fin = len(cdc)
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]
    if cdc.count(" ")!=0:
        fin = cdc.index(" ")
    else:
        fin = len(cdc)

for j in range(len(maListe)):
    print(maListe[j])

Avez vous remarqué que j’ai légèrement modifié la ligne de code contenant ma cdc ?

maChaine = cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

A force d’amputer la variable cdc pour extraire chacun des mots, il ne reste plus de caractère dans ma variable cdc à la fin de mon opération.
En ajoutant maChaine, je conserve ainsi une copie exacte de la chaine initiale.

Nous avons maintenant un code qui marche mais qui ne plaira pas aux puristes :
notre condition

    if cdc.count(" ")!=0:
        fin = cdc.index(" ")
    else:
        fin = len(cdc)

est répétée 2 fois ! même si un simple copier-coller fait l’affaire, le code est lourd… le but du est de le rendre le plus lisible (plus simple ?!) possible… Pour cela, nous allons faire appel à une « fonction ». Le principe d’une fonction est le suivant : on lui envoie des données (ou pas), elle les traite et renvoie un résultat. Ici, nous allons envoyer la variable cdc pour que notre fonction vérifie si elle contient des espaces ou non.
Nous allons rédiger notre fonction en tout début de script.
Chaque fonction commence par la commande def, suivie du nom de la fonction suivie de parenthèses et de :
Nous appellerons notre fonction controle

def controle(zz):

Ici, nous avons inséré une variable, zz, entre les parenthèses de notre fonction afin de lui signifier que nous allons lui envoyer des informations lorsque nous l’appellerons, en l’occurrence, la variable cdc.

def controle(zz):

    if zz.count(" ")!=0:
        return zz.index(" ")
    else:
        return len(zz)

Encore une fois, l’indentation est extrêment importante, ici aussi; l’occulter conduira fatalement à une erreur de traitement.
Cette fonction ressemble sensiblement au code que nous utilisions auparavant pour déterminer la valeur de notre variable fin, à la différence que la variable cdc devient zz et que l’on intègre la commande return à la place de notre variable fin.
La variable cdc est donc remplacée par zz qui représente, dans notre fonction, la valeur qui sera traitée par la fonction.
La commande return se charge ensuite de renvoyer à la variable fin de notre programme principal, le résultat de son traitement.

Il ne nous reste plus qu’à appeler notre fonction depuis notre programme principal en remplaçant, à chaque fois, cettte condition

if cdc.count(" ")!=0:
    fin = cdc.index(" ")
else:
    fin = len(cdc)

par

fin = controle(cdc)

Nous appelons la fonction par son nom. Entre parenthèses, nous lui adressons la variable qui doit être traitée; ensuite la commande return renvoie le résultat du traitement de notre fonction qui est enregistré dans la variable fin.

Voici le code final de notre projet :

def controle(zz):

    if zz.count(" ")!=0:
        return zz.index(" ")
    else:
        return len(zz)

maChaine = cdc = "A8zx 7r:t i 23.54 <i1 q+2N"

esp = cdc.count(" ")
deb = 0
fin = controle(cdc)
maListe = []

for i in range(0, esp + 1):
    maListe.append(cdc[deb:fin])
    cdc=cdc[fin+1:]

    fin = controle(cdc)

for j in range(len(maListe)):
    print(maListe[j])

A8zx
7r:t
i
23.54
<i1
q+2N

Voilà petit exercice qui nous a permis d’aborder certaines des techniques de base en programmation : variables, boucles, conditions, fonctions… gardons, néanmoins, en mémoire que l’on peut souvent améliorer un script comme c’est le cas ici !

Voici un autre script qui donne exactement le même résultat, en utilisant, la fonction split() qui sépare le contenu d’une cdc…

cdc = "A8zx 7r:t i 23.54 <i1 q+2N"
maListe = cdc.split(" ") # la fonction split sépare et enregistre chaque mot de notre cdc dans la liste maListe 

for i in maListe # boucle d'affichage du contenu de la liste maListe
    print(i)

A8zx
7r:t
i
23.54
<i1
q+2N

Voici une autre méthode qui utilise le principe des « listes en intention » pour l’affichage, que je n’aborderai pas ici, et qui présente le même résultat en rendant ce code encore plus minimaliste :

maListe = "A8zx 7r:t i 23.54 <i1 q+2N".split(" ")
[print(i) for i in maListe]

On pourrait encore réduire cet algorithme jusqu’à le faire tenir sur une simple ligne :

[print(i) for i in "A8zx 7r:t i 23.54 <i1 q+2N".split(" ")]

je ne recommande, cependant, pas de contracter un code à l’extrême, car il devient plus difficile à lire et à maintenir par la suite.

Pour terminer, je vous soumets l’écriture, qui selon moi, est la mieux optimisée puique :

  •  nous conservons notre chaine dans sa globalité dans la variable cdc.
  • nous enregistrons efficacement chaque mot dans notre liste maListe en une seule ligne de code.
  • nous affichons le résultat de notre opération d’extraction avec une écriture qui tient sur une seule ligne également.
cdc = "A8zx 7r:t i 23.54 <i1 q+2N"
maListe = cdc.split(" ")
[print(i) for i in maListe]

[Python 3] Affichage : la fonction print()

Ce premier article consacré au langage Python s’attachera à énumérer  les méthodes d’utilisation de la fonction print(); celle-ci permet l’affichage à l’écran des résultats d’une opération effectuée par le programme : il peut s’agir d’une chaine de caractères (cdc), du résultat d’un calcul arithmétique, etc… .

Dans la nouvelle version de Python (Python 3),  print() s’écrit toujours en minuscules et est systématiquement suivi de parenthèses qui renferment l’information à afficher. En règle générale, l’expression contenue entre les parenthèses est :

  1.  Toujours encadrée par des guillemets lorsqu’elle contient des caractères alphabétiques ou des signes autres que des nombres et les opérateurs .(virgule de la décimale qui est un point en Python) + – * /
  2. Encadrée par des guillemets lorsqu’une cdc numérique est considérée comme étant du texte (on n’attend pas le résultat d’un calcul).
  3. Jamais encadrée de guillemets lorsqu’il s’agit de variables (pour lesquelles nous consacrerons un chapitre).
    • affichage d’une cdc
      (le résultat de l’opération sera toujours présenté à la suite du code et sera affiché en violet.)
print("Bonjour")

Résultat : Bonjour

    • affichage d’un nombre
print(-1.5)

-1.5

  • calcul
print(32+7*2)

46

    • variable
      Outil très utilisé en informatique; la variable se charge de stocker une valeur qui pourra changer en cours de route. Ici, nous avons nommé notre variable maVar et lui avons successivement attribuée les valeurs 8, puis 125 puis Marie. En règle générale, une variable doit d’abord être déclarée (on doit lui affecter une valeur, même nulle) avant de pouvoir être utilisée.
maVar=8 #je déclare ma variable 
print(maVar)# je peux maintenant l'utiliser

8

maVar=125
print(maVar)

125

maVar="Marie"
print(maVar)

Marie

REMARQUES :

  1. Le signe # entame un commentaire utile au programmeur mais qui sera ignoré par Python.
  2. Les cdc contenant des caractères alphabétiques sont enregistrées avec des guillemets dans la variable alors que les nombres en sont, ici, exempts.
    • calcul de 2 variables
aa=3
bb=7
print(aa+bb)

10

    • variable de type string (c’est à dire : cdc) intégrée à un texte par des virgules (,)
      On encadre chaque bribe de texte avec des guillemets et on insère nos variables à l’aide de virgules.
monNom="Pierre"

print("Je m'appelle",monNom)
print(monNom,"est parti.")
print("Je m'appelle",monNom,"et j'habite à Paris.")

maSlt="Bonsoir,"
maVille="Lyon"
monAge=25

print(maSlt,"je m'appelle",monNom,", j'habite",maVille,"et j'ai",monAge,"ans.")

Je m’appelle Pierre
Pierre est parti.
Je m’appelle Pierre et j’habite à Paris.
Bonsoir, je m’appelle Pierre , j’habite Lyon et j’ai 25 ans.

REMARQUES :

  1. La virgule crée automatiquement un espace entre le texte et la valeur de la variable.
  2. Une variable n’est précédée d’une virgule que lorsque qu’elle suit un texte et est suivie d’une virgule que si elle précède un texte.
    • variable de type string (c’est à dire : cdc) intégrée à un texte par le signe plus (+)
      On encadre chaque bribe de texte avec des guillemets et on insère nos variables à l’aide du signe plus.

(si la dernière ligne du code ci-dessous n’apparait pas dans sa totalité sur votre écran, cliquez sur le code et maintenez le clic tout en dirigeant la souris vers la gauche.)

monNom="Pierre"

print("Je m'appelle"+monNom)
print(monNom+" est parti.")
print("Je m'appelle"+monNom+"et j'habite à Paris.")

maSlt="Bonsoir,"
maVille="Lyon"
monAge=25

print(maSlt+" je m'appelle "+monNom+", j'habite "+maVille+" et j'ai "+str(monAge)+" ans.")

Je m’appellePierre
Pierre est parti.
Je m’appellePierreet j’habite à Paris.
Bonsoir, je m’appelle Pierre, j’habite Lyon et j’ai 25 ans.

REMARQUES :

  1. Le signe plus ne crée pas automatiquement un espace entre le texte et la valeur de la variable, comme nous le montrent les exemples ci-dessus; il faut, si nécessaire, ajouter l’espace dans le texte qui précède ou qui suit la variable.
  2. La variable monAge, dans le dernier exemple, est incluse dans la fonction str() : il existe plusieurs types de variables (string pour les cdc, integer pour les nombres entiers, float pour les nombres décimaux etc…). Ici, il faut considérer que le signe plus « additionne » des données, or Python n’additionne que des données du même type. str() convertit le nombre entier 25 en une chaine alphanumérique de type texte, autrement dit 25 devient « 25 » et l’addition de cdc devient ainsi possible. Cette notion sera développée dans l’article consacré aux variables.
  3. Il est possible d’utiliser les 2 types de signes dans la même fonction print() pour concaténer (réunir) textes et variables, comme le montre l’exemple ci-dessous :
monObjet ="voiture"
print("La",monObjet+" est rouge.")

La voiture est rouge.

    • fonction format()
      Cette fonction bien pratique s’affranchit des contraintes des guillemets et des signes de concaténation. La fonction format() est introduite par un point juste après le guillemet de fin et encadre l’ensemble des variables utilisées dans le texte. Chaque variable est intégrée aux texte par des accolades et le numéro de l’accolade correspond à l’ordre dans lequel la variable apparait dans la fonction format().
print("{0} a eu {1} ans. On a fêté les {1} ans de {0}." .format("Pierre", 25))

Pierre a eu 25 ans. On a fêté les 25 ans de Pierre.

REMARQUE :

Le numéro de la première accolade est toujours 0

    • concaténation avec le signe %
      Proche de la fonction format(), cette méthode introduit chaque variable dans le texte par le signe % suivi d’une lettre indiquant le type de la variable :
      %s : cdc
      %d : nombre entier
      %f : nombre décimal
      %.Xf : X désignant un nombre entier indiquant le nombre de décimales après la virgule.
      Le signe % derrière le guillemet de fermeture introduit la valeur de chaque variable dans l’ordre d’apparition respectif dans le texte.
monA=12
monB=35.6
monC="abcd"
monD=7.8251896
print("A=%d, B=%f, D=%.3f, C=%s et Z=%f // A=%d " %(monA,monB,monD,monC,483,monA))

A=12, B=35.600000, D=7.825, C=abcd et Z=483.000000 // A=12

Affichage d’une liste (la liste est une variable particulière qui permet d’enregistrer plusieurs valeurs).

maListe=[1,3,5,7,9]
print("ma Liste : %s " %(maListe))

[0, 1, 2, 3, 4]

    • affichage des caractères spéciaux avec le signe : \
      Le signe \ désactive la fonction spéciale de certains caractères spéciaux comme les guillemets et permet ainsi de les afficher dans la fonction print().
print("le mot \"table\" apparait entre guillemets")
print("le mot \\table\\ apparait entre backslashes")

le mot « table » apparait entre guillemets
le mot \table\ apparait entre backslashes

    • le saut de ligne : \n
      La combinaison suivante : \n permet d’effectuer un saut de ligne dans une fonction print().
print("Pierre prend le train \n pour se rendre à Paris.")

Pierre prend le train
pour se rendre à Paris.

    • les tabulations : \t
      La combinaison : \t permet de créer des tabulations dans une fonction print().
aaName="Pierre"
aaDate="01/01/1985"
aaSS="1 85 01 75 136 242 - 34"
print("Name : \t\t\t\t\t%s\nDate de naissance : \t%s\nNuméro de SS : \t\t\t%s"%(aaName, aaDate,aaSS))
#Name : 	            Pierre
#Date de naissance : 	01/01/1985
#Numéro de SS :         1 85 01 75 136 242 - 34

Voici le rendu de la tabulation sur PyCharm (cliquez sur l’image pour l’agrandir) :

Screen Shot 2015-05-19 at 17.05.26

    •  remplacer le saut de ligne de la fonction print()  avec la commande end
      Placé à la fin de la fonction print(), la commande end remplace le retour chariot programmé par défaut. Cette méthode est effective avec les boucles que nous aborderons aussi dans un prochain article. Pour l’exemple, voici une boucle à laquelle nous demandons de répéter 4 fois la fonction print(). Ainsi, au lieu d’afficher 4 fois ok en passant à la ligne à chaque fois, le saut de ligne est, ici remplacé par un espace.
for a in range(4):
    print("ok", end= " ")

ok ok ok ok

    • remplacer la virgule (l’espace) de concaténation avec la commande sep
aa="Jean"
print("Bonjour",aa,".", sep="!¡")

Bonjour!¡Jean!¡.

Tonton, tu m’apprends à programmer ?

Cela faisait 3 ou 4 jours que je m’initiais au (langage) Python lorsque ma petite nièce, sans doute fatiguée de poser ses divisions, s’approcha de moi et me demanda : « qu’es tu fais ? moi aussi je veux apprendre ?! »…

Et c’est ainsi que s’improvisa sa première leçon d’informatique !

Agréablement surpris par son enthousiasme et réfléchissant à la meilleure façon de constituer une source d’information qui lui soit utile et facilement accessible, je me suis dit : et pourquoi pas à partir du blog ?!

Plus question, ici, de VBA; cela fait d’ailleurs tellement longtemps que je n’ai pas ouvert un fichier Excel et que je ne me sens plus qualifié pour en parler.

Les articles qui suivront se voudront être des aide-mémoires pour le langage Python accompagnés de commentaires, sans pour autant entrer dans des détails théoriques ou techniques trop élaborés.
Je n’exclurai cependant pas, de proposer parfois, des scripts plus complexes afin d’étudier certaines notions en profondeur.

Etant, moi-même novice, il est probable que certaines lignes de code ne seront pas optimisées, elles resteront néanmoins exploitables; les conseils et suggestions des experts seront les bienvenus.

Il est assumé que le lecteur a déjà correctement installé la version 3 de Python (https://www.python.org/) ainsi qu’un IDE (environnement de développement intégré); j’utilise personnellement l’IDE PyCharm (https://www.jetbrains.com/pycharm/download/) mais d’autres sont gratuitement disponibles sur internet et de nombreux tutoriels de présentation et d’installation existent pour ceux qui en ressentiraient le besoin.

Et bien, je crois que… y’a plus qu’à !
Et comme dirait ma petite complice : un, deux, trois, feu… partez !