Initiation à Python

Jusqu'ici, nous avons essentiellement travaillé avec des chiffres qui sont des types de données relativement simples. Nous sommes parfois passés par le texte, mais sans rentrer dans le détail de sa manipulation. Tout cela est un peu limitatif et il sera souvent nécessaire de pouvoir associer plusieurs données et de garder leur relation. Certains types de données permettent de décrire de réelles structures et d'associer ainsi les différents éléments qui les composent de façon permanente ou temporaire. Parmi celle-ci, notons les chaînes de caractères justement, mais aussi les listes et les tuples qui sont un cas particulier de liste, ou encore les dictionnaires qui en sont une complexification. Enfin, les classes seront une variante étendue de ce principe, mais nous ne les verrons pas encore.

Pour connaître le type d'une donnée, vous pouvez à tout moment utiliser type(). Ainsi si vous avez une variable i avec la valeur 12, vous pourrez savoir si elle est de type str ou int :

i = 12
type(i)

Affiche : <type 'int'>,

alors que :

i = "12"
type (i)

Affiche : <type 'str'>.

Les chaînes de caractères sont des suites de lettres. Les mots sont le type de chaîne de caractères le plus naturel. On peut donc considérer qu'avec Python, les mots sont de simples suites de lettres analysées et rendues une à une. Le mot n'est que cet ensemble de lettres mises les unes à la suite des autres, comme les maillons d'une chaîne.
Voici un exemple de chaîne :

phrase = "je suis une chaîne de caractères"

globalement, toute valeur affectée à une variable entre guillemets est comprise par Python comme une chaîne de caractères, même si ce sont des chiffres qui sont entre les guillemets.
Pour changer un type il faudra utiliser une déclaration associée, déjà mentionnée :
str() pour l'utiliser en chaîne et int() pour l'utiliser comme un entier.
Ainsi si :

i = 12
type(i)

> <type 'int'>

en faisant

str(i)
type(i)

> <type 'int'>

On voit bien que i n'a pas changé de type, alors que :

n = str(i)
type(n)

> <type 'str'>

affecte le type à une nouvelle variable et évite alors toute confusion.

Nous nous attarderons un peu sur le type string. En effet, la manipulation de chiffres avec les langages de programmation ne pose en général pas d'autres difficultés que les compétences mathématiques de l'auteur. Le texte, en comparaison, peut sembler d'un fonctionnement un peu étrange.

Le terme chaîne déjà peut surprendre et pourtant il exprime bien la réalité des choses : il s'agit d'une suite de lettres comme des maillons sont les éléments d'une chaîne métallique. Cela induit plusieurs choses qui rendent le texte « informatique » un peu différent de celui du quotidien :

• lorsque nous parlons, notre expression est fluide et continue, nous ne parlons pas lettre par lettre ;
• lorsque nous parlons, nous utilisons des structures grammaticales (sujet, verbes, compléments…) dont aucun logiciel n'a nativement connaissance. Le mot lui-même est quelque chose de difficilement repérable.

Tout cela induit des difficultés qui ne sont pas insurmontables, mais qui demandent un peu de démonstration parce que le texte est souvent un élément très important d'un projet informatique.

Allons donc petit à petit dans les détails :

texte = "Mon texte pour commencer"
print texte

> Mon texte pour commencer

IV-B-1. Écrire avec des guillemets▲

texte = Mon texte pour commencer

  File "<stdin>", line 1
    texte = Mon texte pour commencer 
SyntaxError: invalid syntax

texte = "L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné."

  File "<stdin>", line 1
    texte = "L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné."
                                            ^
SyntaxError: invalid syntax

IV-B-2. Utiliser des guillemets simples▲

texte = 'Mon texte "essai" pour commencer'

texte = 'L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné.'

  File "<stdin>", line 1
    texte = 'L'ouvreuse m'a dit : "Donnez-moi votre ticket." Je le lui ai donné.'
                      ^
SyntaxError: invalid syntax

IV-B-3. Échapper les caractères avec \▲

texte = "L'ouvreuse m'a dit : \"Donnez-moi votre ticket.\" Je le lui ai donné."

IV-B-4. Les caractères spéciaux▲

print chr(102)

print chr(255)

print chr(196)

print unichr(255)

print unichr(196)

texte = "L'ouvreuse m'a dit : \n\t\"Donnez-moi votre ticket.\" \nJe le lui ai donné."
print texte

>
L'ouvreuse m'a dit :
    "Donnez-moi votre ticket."
Je le lui ai donné.

IV-B-5. Agir sur le texte▲

cherche = texte.upper()
print cherche

cherche = texte.lower()
print cherche

texte = "L'ouvreuse m'a dit : \"Donnez-moi votre ticket.\" Je le lui ai donné."
texte.find("ticket")

texte.find("billet")

texte.find("don")

texte.find("Don")

print texte.replace("ticket","billet")

texte = "L'ouvreuse m'a dit : \"Donnez-moi votre ticket.\" Je le lui ai donné ce ticket."
print texte.replace("ticket","billet")

texte = "M,Alphonse,1932"
print texte.split(",")

Les listes et les tuples sont de simples suites d'éléments indexés. Dans les listes ou dans les tuples, les éléments qui se suivent ne sont pas nécessairement de même type. Alors que dans une chaîne de caractères, tout élément est compris comme une lettre, dans une liste, un élément chiffre (int) peut suivre un élément chaîne de caractères (str)…
Il existe deux façons de déclarer une liste :

• soit en créant une liste d'emblée, vide ou non :

    liste1 = []
    liste2 = [1,2,3]
    type(liste1)

> <type 'list'>

    type(liste2)

> <type 'list'>

• soit en typant la variable :

    liste3 = list()
    type(liste3)

> <type 'list'>

Le tuple héritera des mêmes procédés :

    tuple1 = ()
    tuple2 = (1,2,3)
    tuple3 = tuple()
    type(tuple1)

> <type 'tuple'>

    type(tuple2)

> <type 'tuple'>

    type(tuple3)

> <type 'tuple'>

La seule différence visible entre un tuple et une liste consiste dans l'utilisation de crochets dans le cas de la liste et de la parenthèse dans le cas du tuple. Au niveau de l'usage, nous verrons bientôt que la liste est modifiable alors que le tuple est prévu comme un élément figé dont les valeurs ne peuvent être modifiées.

Enfin, parmi les structures de données fondamentales en Python, on notera les dictionnaires : ce sont des listes un peu plus complexes, en ce que chacun des éléments qui les compose est au moins composé de deux membres, l'un étant la clé, l'autre la valeur, le tout embrassé par des accolades { }. La clé est la valeur sont associées par un ":" et les membres se suivent, séparés par des virgules comme dans des listes. L'utilisation d'un dictionnaire est en particulier utile lorsque les clés sont des mots qui permettent ainsi d'avoir une approche sémantique des données :

dictionnaire1 = {}
dictionnaire2 = {'nom':'Descartes','prenom':'René'}
dictionnaire3 = dict()
type(dictionnaire1)

> <type 'dict'>

type(dictionnaire2)

> <type 'dict'>

type(dictionnaire3)

> <type 'dict'>

Ainsi, en imaginant deux variables différentes elles peuvent être représentées sous les formes :

• chaînes de caractères :

nom = "Descartes"
prenom = "René"

dans ce cas, rien n'associe informatiquement les deux variables, seul le développeur connaît la relation implicite que le nom entretien avec le prénom.

• liste ou tuples :

personne = ["Descartes","René"]

dans ce cas, les deux valeurs sont associées dans un ensemble qui peut être signifiant, mais la nature des éléments n'est pas mentionnée. Cela peut être trompeur dans des cas comme :

personne = ["David","Vincent"]

Comment savoir lequel est le nom et lequel le prénom :

personne1 = {'nom':'Descartes','prenom':'René'}

qui enlève toute confusion possible quels que soient les noms et prénoms.
Les dictionnaires permettent de nombreuses autres applications grâce à des spécificités que nous traiterons ultérieurement, comme les classes, lorsque nous aurons avancé sur notre connaissance et compréhension des mécanismes de Python.  

Connaître l'existence de ces structures ne suffit pas, il faut aussi pouvoir les manipuler. Alors que dans le cas des entiers (int) la manipulation se concentrait sur des opérations mathématiques, ces structures nouvelles étant une façon d'associer des éléments par ailleurs séparés ou compris comme tels, la plupart des procédés seront relatifs à la manipulation des éléments. L'ajout de données est le plus simple.

La sélection des éléments est évidemment fondamentale, soit pour extraire la donnée et l'exploiter dans un nouveau contexte, soit pour la modifier.

Elle peut se faire de deux façons : soit par la position des éléments plutôt utilisée pour les chaînes et listes, soit par la valeur.

IV-F-1. Sélection par position (index)▲

phrase = "Je pense donc je suis."
print phrase

print phrase[1]

print phrase[0]

liste1 = ("René", "Descartes")
print liste1[1]

tuple1 = ["René","Descartes"]
print tuple1[1]

liste1=("Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire")
liste1.index('Voltaire')

dictionnaire1={'nom':'Descartes','prenom':'René'}
print dictionnaire1['nom']

dictionnaire1.get('prenom')

nom = "Descartes"
if "cartes" in nom:
    print "Descartes est de la famille des cartomanciens"
else:
    print "Descartes aurait dû s'appeler Descartes"

liste1=("Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire")
if "Voltaire" in liste1:
    print "Voltaire est un philosophe"

Dans le cas des chaînes surtout, mais quelquefois aussi des listes et tuples, il est parfois utile de sélectionner plusieurs éléments. Quand il s'agit de chaînes, cela est évident si on souhaite extraire plusieurs lettres faisant sens ensemble, comme un mot, par exemple. Dans le cas des listes et des tuples, cela se fera surtout sentir dans le cas de réaffectation, ou de suppression.
On pourra connaître la longueur de la structure en ayant recours à len().

phrase = "Je pense donc je suis"
len(phrase)

> 21

liste1("René","Descartes")
len(liste1)

> 2

Cela fonctionne aussi, de la même façon avec les tuples et les dictionnaires.
Ensuite et dans tous les cas, la longueur d'une sélection sera définie par les indices de début et fin de la sélection, séparé par un ":". Ainsi :

phrase = "Je pense donc je suis"
print phrase[3:8]

Affiche : > pense

N'oubliez pas que les indices commencent à 0 !
Lorsque l'on veut sélectionner à partir du début on écrira simplement :

print phrase[:8]

> Je pense

Lorsque l'on souhaite sélectionner les derniers éléments, les choses se compliquent un peu puisqu'il faut connaître la quantité d'éléments. Ainsi on pourrait faire :

liste4=("René","Descartes","Méditations Métaphysiques")
longueur = len(liste4)
print liste4[1:longueur]

> ('Descartes', 'Méditations métaphysiques')

Remarquez ici deux choses. Premièrement la spécificité du traitement des accents, et ensuite que le résultat est rendu sous forme de liste.
On pourra abréger en notant :

liste4 = ("René","Descartes","Méditations métaphysiques")
print liste4[1:len(liste4)]

L'objectif des structures de données est d'organiser le contenu pour y avoir ensuite accès de façon facilitée, et avec des outils qui permettent de les exploiter simplement selon des critères spécifiques. Il est en particulier régulièrement nécessaire de parcourir les éléments de la structure pour en extraire les valeurs ou faire une recherche.

Ici rien de bien nouveau, nous nous contenterons de montrer comment les boucles déjà vues s'adaptent à ces formes nouvelles.

IV-H-1. While▲

phrase = "Je pense donc je suis"
i=0
while i < len(phrase):
    print (phrase[i])
    i+=1

liste4 = ("René","Descartes","Méditations métaphysiques")
i=0
while i < len(liste4):
    print (liste4[i])
    i+=1

IV-H-2. For▲

for element in liste4:
    print(element)

> René
> Descartes
> Méditations Métaphysiques

i=0
while i < len(phrase):
     print(phrase[i])
     i+=2

>
 J
 
 e
 s
 
 o
 c
 j
 
 u
 s

IV-H-3. range()▲

liste1=("Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire")
for n in (range(3,6)):
    print liste1[n]

>
Montesquieu
Diderot
Rousseau

for n in range(0,7,2):
     print liste1[n]

>
Descartes
Montaigne
Diderot
Voltaire

IV-H-4. Parcours de dictionnaires▲

dictionnaire1={'nom':'Descartes','prenom':'René','ecrit':'Meditations Métaphysiques'}
for cle, valeur in dictionnaire1.items():
    print cle, " ", valeur

>
ecrit   Meditations Métaphysiques
nom   Descartes
prenom   René

for cle in dictionnaire1.keys()

for valeur in dictionnaire1.values()

Pour ajouter des éléments à un ensemble structuré, les procédés pourront varier. En ce qui concerne les tuples, rien ne sera possible puisqu'ils sont immuables.
Pour ajouter un élément dans une liste, la méthode employée sera dépendante de la position souhaitée. Pour positionner le nouvel élément en fin de liste, on utilisera la méthode append alors que pour insérer à un emplacement particulier, insert sera préféré.

liste1=['Rene','Descartes']
liste1.append('Philosophe')
print liste1

> ['Rene', 'Descartes', 'Philosophe']

liste1.insert(2,'France')
print liste1

['Rene', 'Descartes', 'France', 'Philosophe']

En ce qui concerne les dictionnaires, il suffira d'affecter une nouvelle clé et une nouvelle valeur en utilisant la clé comme indice :

dictionnaire1['pays']="France"

ou par la position :

dictionnaire1[2]="France"

Ensuite, il arrive régulièrement qu'il y ait plusieurs éléments à ajouter et que ces éléments proviennent éventuellement d'une autre variable de même type ou non. Si les types sont différents, une boucle pourra permettre l'opération, mais dans le cas ou les types sont identiques, une simple concaténation va suffire : la concaténation sur une simple opération de mise à la suite de deux éléments. La concaténation a déjà été entrevue avec la fonction print et les chaînes de caractères :

citation1 = "je pense"
citation2 = "je suis"
print citation1 + ", donc " + citation2

> je pense, donc je suis

Dans le cas des listes, il est possible d'utiliser la même opération :

liste1 = ['Rene', 'Descartes', 'France', 'Philosophe']
liste2 = ['Discours de la Méthode','Principes de la philosophie']
liste1 + liste2

> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Methode', 'Principes de la philosophie']

Pour concaténer les deux sans passer par une opération, la méthode extend fera parfaitement l'affaire :

liste1 = ['Rene', 'Descartes', 'France', 'Philosophe']
liste2 = ['Discours de la Méthode','Principes de la philosophie']
liste1.extend(liste2)
print liste1

> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']

La suppression d'éléments n'est pas l'opération la plus courante, l'ajout et l'affectation de nouvelles valeurs seront bien plus utilisées. Il n'est cependant pas inutile de savoir comment faire pour limiter la recherche et, éventuellement, accélérer les manipulations, boucles…
En ce qui concerne les listes, la suppression se fera par la position de l'élément, son indice :

print liste1

> ['Rene', 'Descartes', 'France', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']

del liste1[2]
print liste1

> ['Rene', 'Descartes', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']

Il est possible de supprimer plusieurs éléments en une seule opération à l'aide d'une plage de sélection :

del liste1[2:4]

soit par sa valeur avec la méthode remove à laquelle on passera la valeur à supprimer :

liste1.remove('Descartes')
print liste1

> ['Rene', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']

Dans le cas des dictionnaires, en plus de pouvoir réutiliser del comme pour les listes, on retrouve la sempiternelle attention aux clés et aux valeurs :

• clear() videra complètement le dictionnaire ;
• pop(cle) supprime la clé mentionnée ;
• popitem() supprimera la paire clé:valeur.

dictionnaire1={"nom":"Descartes","Prenom":"René","Pays":"France"}
del dictionnaire1['nom']
print dictionnaire1

> {'Prenom': 'René', 'Pays': 'France'}

Ici l'ensemble clé:valeur est purement et simplement supprimé. Ce ne sera pas tout à fait le cas avec pop qui renverra la valeur associée à la clé au moment de la suppression.

dictionnaire1={"nom":"Descartes","Prenom":"René","Pays":"France"}
dictionnaire1.pop('nom')

> 'Descartes'

print dictionnaire1

{'Prenom': 'René', 'Pays': 'France'}

Ces renvois pourront être utiles dans certains cas, associés à des fonctions que nous verrons prochainement.
Enfin popitem renvoie la paire clé:valeur sous forme de tuple au moment de la sélection. La paire supprimée est la première du dictionnaire. Cette forme de suppression, surtout utile dans les boucles, évitera les doublons, mais ouvrira le risque des pertes.

L'affectation est une opération souvent effectuée en création. Les modes d'affectation par défaut ont été vus en début de section sur les types structurés. La plupart du temps, il suffira de donner l'indice et de mentionner la nouvelle valeur à lui donner :

liste1=['René', 'Philosophe', 'Discours de la Méthode', 'Principes de la philosophie']
liste1[2]="Discours de la méthode"
print liste1

> ['René', 'Philosophe', 'Discours de la méthode', 'Principes de la philosophie']

Au sujet des dictionnaires, il suffit de sélectionner par la clé est de modifier la valeur :

dictionnaire1={"nom":"Descartes","Prenom":"René","Pays":"France"}
dictionnaire1['Pays']='Suède'
print dictionnaire1

> {'nom': 'Descartes', 'Prenom': 'René', 'Pays': 'Suède'}

Enfin, en ce qui concerne les chaînes, il faudra effectuer un remplacement d'une portion de la chaîne par une autre en la réaffectant ou en l'enregistrant dans une nouvelle chaîne :

chaine1 = "Bonjour"
chaine1.replace("jour", "soir")
print chaine1

> Bonsoir

Il est parfois important de changer l'ordre des éléments. Cela peut être pratique pour des classements ou mettre en relation deux séquences. sort() va faire ce travail très simplement :

liste1 = [5,10,3,7]
liste1.sort()
print liste1

> [3, 5, 7, 10]

Cela marche aussi avec les éléments textuels de la liste :

liste1 = ["Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire"]
liste1.sort()
print liste1

> ['Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']

En revanche, une fois encore mais de façon plus étonnante, cela ne pourra s'appliquer aux tuples, ni aux chaînes d'ailleurs :

nom = "cedric"
nom.sort()

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  AttributeError: 'str' object has no attribute 'sort'

Si la liste contient des éléments de type int ou float et des éléments str, alors les éléments de type str sont placés à la fin alors que la suite est bien ordonnée en ce qui concerne les nombres quelque soit leur type.

liste1 = ["Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire"]
liste2 = [5,10,7,3]
liste1 = liste1+liste2
liste1.sort()
print liste1

> [3, 5, 7, 10, 'Descartes', 'Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']

liste3 = [1.5, 3.5, 6.2, 10.5]
liste1 = liste1+liste3
liste1.sort()
print liste1

> [1.5, 3, 3.5, 5, 6.2, 7, 10, 10.5, 'Descartes', 'Descartes', 'Diderot', 'Erasme', 'Montaigne', 'Montesquieu', 'Rousseau', 'Voltaire']

Avec les dictionnaires, les choses se gâtent un peu. Que trier ? Les clés, les valeurs ? En utilisant la fonction sorted, on obtient un premier résultat.

dictionnaire2 = {'nom':'Descartes','prenom':'René','age':'?'}
dictionnaire2

> {'nom': 'Descartes', 'age': '?', 'prenom': 'Ren\xc3\xa9'}

sorted(dictionnaire2)

> ['age', 'nom', 'prenom']

J'ai souvent vu des personnes effectuant un tri pour rapprocher les éléments similaires et éventuellement trouver des doublons, comme on le ferait en cliquant sur les colonnes dans un navigateur de fichiers. Pour trouver des éléments similaires, il y a bien plus simple, rapide et fiable, count(). 

nom = "cedric"
nom.count('c')

> 2

ou sur des listes :

liste1=["Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire"]
liste1.count('Descartes')

> 1

liste1.append('Descartes')
liste1.count('Descartes')

> 2

On trie aussi souvent pour connaître la plus petite et la plus grande valeur. Il est alors possible d'utiliser les fonctions de bases min() et max() :

liste2 = [5,10,7,3]
min(liste2)

> 3

max(liste2)

> 10

et même d'en effectuer la somme avec sum() ce qui évite parfois d'avoir recours à des procédés plus longs et complexes :

liste2 = [5,10,7,3]
sum(liste2)

> 25

min() et max() fonctionnent aussi sur les chaînes et les éléments textuels :

nom = "cedric"
min(nom)

> 'c'

max(nom)

> 'r'

liste1=["Descartes","Erasme","Montaigne","Montesquieu","Diderot","Rousseau","Voltaire"]
max(liste1)

> 'Voltaire'