Résumé : Introduction au Langage Python -- Exemples

Affectation (ou assignation) signe égale ( = )

n =7 # définir n et lui donner la valeur 7
msg = "Quoi de neuf ?" # affecter la valeur "Quoi de neuf ?" à msg
pi = 3.14159 # assigner sa valeur à la variable pi
Le typage des variables sous Python est un typage dynamique

Afficher la valeur d’une variable

À l’intérieur d’un programme, il faut toujours utiliser la fonction print() :
print(n)
print(msg)

Affectations multiples
x=y=7
a, msg = 4, "Quoi de neuf ?"

Opérateurs : + , - , * , / , ** , //
Affichage : la fonction print()
L’argument « sep » permet de remplacer le séparateur par défaut (l’espace) par un autre caractère quelconque (ou
même par aucun caractère):
print("Bonjour", "à", "tous", sep ="*")
résultat :Bonjour*à*tous

L’argument « end » sert à remplacer le saut à la ligne terminal avec l’argument « end » :

n =0
while n<6:
print("abc", end ="")
n = n+1

résultat : abcabcabcabcabcabc

Interaction avec l’utilisateur : la fonction input()

prenom = input("Entrez votre prénom : ")
print("Bonjour,", prenom)
La fonction input() renvoie toujours une chaîne de caractères.

Structures Conditionnelles
if (condition 1):
traitement1
[elif (condition2) :
traitement2
else:
traitement3]

1
Opérateurs de comparaison
x == y # x est égal à y
x != y # x est différent de y
x>y # x est plus grand que y
x<y # x est plus petit que y
x >= y # x est plus grand que, ou égal à y
x <= y # x est plus petit que, ou égal à y

Structures Itératives
L’instruction while

while (condition ):
traitement1

L’instruction for
for (compteur in séquence):
traitement1
Exemples :

nom ="Cléopâtre"
for car in nom:
print(car + ' *', end =' ')

Résultat
C*l*é*o*p*â*t*r*e*

nom ="Cléopâtre"
for i in range(0,len(nom)):
print(nom[i] + ' *', end =' ')

Résultat
C*l*é*o*p*â*t*r*e*

La fonction range()
range(stop)
range(start, stop[, step])

Les chaînes de caractères

ch = "Christine"
print(ch[0], ch[3], ch[5])
 Indexage
Sous Python, les éléments d’une séquence sont toujours indicés (ou numérotés) de la même manière, c’est-à-dire à
partir de zéro.
nom = 'Cédric'
print(nom[1], nom[3], nom[5])

Résultat
érc

2
Pour désigner l’emplacement d’un caractère par rapport à la fin de la chaîne, il suffit d’utiliser des indices négatifs
: -1 désignera le dernier caractère :
print(nom[-1], nom[-2], nom[-4], nom[-6])

Résultat
cidC

• Longueur d’une chaîne, fonction intégrée len() :

len(ch)
• Convertir en nombre véritable une chaîne de caractères qui représente un nombre.
ch = '8647'
n = int(ch)

ch = '8647.26'
m = float(ch)
 Extraction de fragments de chaînes : slicing (« découpage en tranches »)
chaine[start : stop : step]
ch = "Juliette"
print(ch[0:3])

résultat
Jul

print(ch[:3]) # les 3 premiers caractères

print(ch[3:]) # tout ce qui suit les 3 premiers caractères

 Concaténation avec l’opérateur +

 Répétition avec l’opérateur *
 Appartenance d’un élément à une séquence : l’instruction in
 Les chaînes sont des séquences non modifiables
 Les chaînes sont comparables à travers les opérateurs de comparaison
 Fonctions prédéfinies sur les chaines:
 La fonction ord(ch) retourne la valeur de l’identifiant numérique correspondant à ce caractère.
 La fonction chr(num) retourne le caractère typographique dont l’identifiant est égal à num.
 Les chaînes sont des objets (Quelques méthodes) :
 split() : convertit une chaîne en une liste de sous-chaînes. On peut choisir le caractère séparateur en le
fournissant comme argument, sinon c’est un espace par défaut :
c4 ="Cet exemple, parmi d'autres, peut encore servir"
c4.split(",")
résultat
['Cet exemple', " parmi d'autres", ' peut encore servir']
 join(liste) : rassemble une liste de chaînes en une seule la chaîne à laquelle on applique cette méthode
est celle qui servira de séparateur (un ou plusieurs caractères) ; l’argument transmis est la liste des
chaînes à rassembler :
b =["Bête", "à", "manger", "du", "foin"]
print(" ".join(b))

3
 Résultat
Bête à manger du foin

print("---".join(b))

Résultat
Bête---à---manger---du---foin
 ch.find(sch) : retourne la position d’une sous-chaîne sch dans la chaîne ch :

 ch.count(sch) : retourne le nombre de sous-chaînes sch dans la chaîne ch :

 ch.lower() : retourne la conversion de la chaîne ch en minuscules :
 ch.upper() : retourne la conversion de la chaîne ch en majuscules :
 ch.title() : retourne la conversion en majuscule de l’initiale de chaque mot de la chaîne ch

 ch.capitalize() : variante de la précédente. Convertit en majuscule seulement la première lettre de la

chaîne :
 ch.swapcase() : convertit toutes les majuscules de ch en minuscules, et vice-versa :
 ch.strip() : enlève les espaces éventuels au début et à la fin de la chaîne :
 ch.replace(c1, c2) : remplace tous les caractères c1 par des caractères c2 dans la chaîne ch:
 ch.index(car) : retrouve l’indice (index) de la première occurrence du caractère car dans la chaîne ch :

Les listes
Sous Python, on peut définir une liste comme une collection d’éléments hétérogènes séparés par des virgules, l’ensemble étant
enfermé dans des crochets.
jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
 Accès à un élément
print(jour[2])

 La fonction intégrée len() s’applique et retourne le nombre d’éléments présents dans la liste :
print(len(jour))
 La fonction intégrée del() permet de supprimer d’une liste un élément quelconque (à partir de son index) :
del(jour[4])

 Ajout d’un élément à la fin d’une liste

jour.append('samedi')
 Indexages, extraction, taille, concaténation, répétition: même syntaxe que pour les chaines de
caractères
 Les listes sont modifiables
 Les listes sont des objets (Quelques méthodes) :
nombres = [17, 38, 10, 25, 72]
nombres.sort() # trier la liste
nombres.append(12) # ajouter un élément à la fin
nombres.reverse() # inverser l'ordre des éléments
nombres.index(17) # retrouver l'index d'un élément

4
nombres.remove(38) # enlever (effacer) un élément

la différence entre la méthode remove() et l’instruction del : del travaille avec un index ou une tranche d’ index,
tandis que remove() recherche une valeur (si plusieurs éléments de la liste possèdent la même valeur, seul le
premier est effacé).

 Les listes en compréhension

squares = [x**2 for x in range(10)]

l’instruction précédente permet de créer une liste de carrés. Elle est équivalente à
squares = []

for x in range(10):

squares.append(x**2)

Les tuples
Les tuples sont assez semblable à une liste mais qui, comme les chaînes, ne sont pas modifiables.
Du point de vue de la syntaxe, un tuple est une collection d’éléments séparés par des virgules :

tup = ('a', 'b', 'c', 'd', 'e' )

Les opérations que l’on peut effectuer sur des tuples sont syntaxiquement similaires à celles que l’on effectue sur
les listes, si ce n’est que les tuples ne sont pas modifiables.

Les dictionnaires
Les dictionnaires constituent un autre type composite. Ils ressemblent aux listes dans une certaine mesure (ils sont
modifiables comme elles), mais ce ne sont pas des séquences. Les éléments que nous allons y enregistrer ne
seront pas disposés dans un ordre immuable. En revanche, nous pourrons accéder à n’ importe lequel d’entre
eux à l’aide d’un index spécifique que l’on appellera une clé , laquelle pourra être alphabétique, numérique, ou
même d’un type composite sous certaines conditions.

Comme dans une liste, les éléments mémorisés dans un dictionnaire peuvent être de n’importe quel type. Ils
peuvent être des valeurs numériques, des chaînes, des listes, des tuples, des dictionnaires, et même aussi des
fonctions, des classes...

 Création d’un dictionnaire

Exemple1 : création d’un dictionnaire de langue, pour la traduction de termes informatiques anglais en
français.

Puisque le type dictionnaire est un type modifiable, nous pouvons commencer par créer un dictionnaire vide, puis
le remplir petit à petit. Du point de vue de la syntaxe, on reconnaît un dictionnaire au fait que ses éléments sont
enfermés dans une paire d’accolades. Un dictionnaire vide sera donc noté { } :

dico = {}
dico['computer'] = 'ordinateur'
dico['mouse'] ='souris'
dico['keyboard'] ='clavier'
print(dico)

{'computer': 'ordinateur', 'keyboard': 'clavier', 'mouse': 'souris'}

5
Un dictionnaire apparaît sous la forme d’une série d’éléments séparés par des virgules, le tout étant enfermé entre
deux accolades. Chacun de ces éléments est lui-même constitué d’une paire d’objets : un index et une valeur,
séparés par un double point.

Dans un dictionnaire, les index s’appellent des clés, et les éléments peuvent donc s’appeler des paires clé-valeur.

Exemple2 :

Soit un dictionnaire, destiné à contenir l’inventaire d’un stock de fruits. Les index (ou clés) seront les noms des
fruits, et les valeurs seront les masses de ces fruits répertoriées dans le stock (les valeurs sont donc des données
de type numérique).

invent = {'pommes': 430, 'bananes': 312, 'oranges' : 274, 'poires' : 137}

print(invent)

{'oranges': 274, 'pommes': 430, 'bananes': 312, 'poires': 137}

 Opérations sur les dictionnaires :

 Suppression d’un élément : instruction intégrée del

del invent['pommes']

 Nombre d’éléments : fonction intégrée len()

print(len(invent))

 Test d’appartenance : L’instruction in est utilisable avec les dictionnaires. Elle permet de
savoir si un dictionnaire comprend une clé bien déterminée :

if "pommes" in invent:

print("Nous avons des pommes")

else:

print("Pas de pommes. Sorry")

résultat : Pas de pommes. Sorry

Les dictionnaires sont des objets ( Méthodes spécifiques) :

 La méthode keys() renvoie la séquence des clés utilisées dans le dictionnaire.

>>> print(dico.keys())

dict_keys(['computer', 'mouse', 'keyboard'])

>>> for k in dico.keys():

print("clé :", k, " --- valeur :", dico[k])

clé : computer --- valeur : ordinateur

clé : mouse --- valeur : souris

clé : keyboard --- valeur : clavier

6
  La méthode values() renvoie la séquence des valeurs mémorisées dans le dictionnaire :

>>> print(invent.values())

dict_values([274, 312, 137])

 La méthode items() extrait du dictionnaire une séquence équivalente de tuples :

>>> invent.items()

dict_items([('poires', 137), ('bananes', 312), ('oranges', 274)])

 Parcours d’un dictionnaire

La boucle for peut être utilisée pour traiter successivement tous les éléments contenus dans un dictionnaire, mais
attention :

 au cours de l’itération, ce sont les clés utilisées dans le dictionnaire qui seront successivement affectées à la
variable de travail, et non les valeurs ;

 l’ordre dans lequel les éléments seront extraits est imprévisible (puisqu’un dictionnaire n’est pas une séquence).

Exemple 1 :

invent ={"oranges":274, "poires":137, "bananes":312}

for clef in invent:

print(clef)

résultat :

poires
bananes
oranges

Pour effectuer un traitement sur les valeurs, il suffit alors de les récupérer à partir de la clé correspondante :

for clef in invent:

print(clef, invent[clef])

résultat :

poires 137
bananes 312
oranges 274

7
Exemple 2 :

for clef, valeur in invent.items():

print(clef, valeur)

résultat :

poires 137
bananes 312
oranges 274

Dans cet exemple, la méthode items() appliquée au dictionnaire invent renvoie une séquence de tuples (clef,
valeur). Le parcours effectué sur cette liste à l’aide de la boucle for permet d’examiner chacun de ces tuples un
par un.

 Les clés ne sont pas nécessairement des chaînes de caractères

 Les dictionnaires ne sont pas des séquences

print(arb[1:3])

***** Erreur : TypeError: unhashable type *****

Les ensembles (set)

Un ensemble est une collection non ordonnée (donc sans numérotage), sans élément dupliqué. Ce n’est pas une
séquence.

On les note comme en maths avec des accolades {...}. Les éléments sont de types quelconques. Exemples : {5,3,-
8,2} {'o','e','y','u','a','i'} {5,'abc',(3,-2),7.4}

Les éléments d'un ensemble ne sont pas numérotés. On ne peut pas utiliser une notation s[i] comme pour les
séquences. L'opérateur in permet de savoir si un objet appartient à un ensemble ou non.

Note: pour créer un set vide il faut utiliser set(), et non pas {}; cette dernière crée un dictionnaire vide.

Exemples :

>>> e={'ab',1,15,'r'} # crée un ensemble en extension

>>> e

{1, 'r', 'ab', 15}

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']

>>> fruit = set(basket) # crée un ensemble sans duplication

>>> fruit

set(['orange', 'pear', 'apple', 'banana'])

>>> 'orange' in fruit

True

8
>>> 'crabgrass' in fruit

False

>>> a = set('abracadabra')

>>> b = set('alacazam')

>>> a # lettres uniques dans a

set(['a', 'r', 'b', 'c', 'd'])

>>> a - b # lettres dans a et as dans b

set(['r', 'd', 'b'])

>>> a | b # lettres dans a ou b

set(['a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'])

>>> a & b # lettres dans a et b

set(['a', 'c'])

>>> a ^ b # lettres dans a ou b mais as dans les deux

set(['r', 'd', 'b', 'm', 'z', 'l'])

La fonction intégrée len() est utilisable avec un ensemble : elle en renvoie le nombre d’éléments. La méthode
remove() peut aussi être utilisée pour supprimer un élément de l’ensemble.

 Il est possible d'obtenir un élément d'un ensemble E et de le supprimer en même temps avec la méthode
pop().
>>> E = {5,2,3,1}
>>>print(E) #Un ensemble paraît être trié en interne
{1, 2,3,5}
>>> x = E.pop()
>>> (x, E)
(1, {2,3,5})

donc un ensemble est mutable (modifiable)

 Il est possible d’ajoute un élément à un ensemble E avec la méthode E.add(valeur)

>>> E = {5,3,2,1}
>>> E.add(8)
>>> E
{8,1,2,3,5}

 Comme pour les listes en compréhension, les sets en compréhension sont supportés:

Exemple
>>> a = {x for x in 'abracadabra' if x not in 'abc'}

>>> a

set(['r', 'd'])

9
Les fonctions en Python
 Définir une fonction par « def »
def nomDeLaFonction(liste de paramètres):
...
bloc d'instructions (avec ou sans instruction return)
...

 Définir une fonction par « lambda »

Python permet une syntaxe qui permet de définir des mini-fonctions d’une ligne. Ces fonctions
dites lambda peuvent être employées partout où une fonction est nécessaire.
Exemple

g = lambda x: x*2
g(3)

ou

(lambda x: x*2)(3)

 Gestion des erreurs à l’exécution

Les exceptions sont les opérations qu’effectue un interpréteur ou un compilateur lorsqu’une erreur est détectée au
cours de l’exécution d’un programme. En règle générale, l’exécution du programme est alors interrompue, et un
message d’erreur plus ou moins explicite est affiché.
Exemple :
>>> print(55/0)
ZeroDivisionError: int division or modulo by zero

Dans de nombreux cas, il est possible de prévoir à l’avance certaines des erreurs qui risquent de se produire à tel
ou tel endroit du programme et d’inclure à cet endroit des instructions particulières, qui seront activées
seulement si ces erreurs se produisent. Dans les langages de niveau élevé comme Python, il est également
possible d’associer un mécanisme de surveillance à tout un ensemble d’instructions, et donc de simplifier le traitement
des erreurs qui peuvent se produire dans n’importe laquelle de ces instructions.
Un mécanisme de ce type s’appelle en général mécanisme de traitement des exceptions. Celui de Python utilise
l’ensemble d’instructions try - except – else, qui permettent d’intercepter une erreur et d’exécuter une portion
de script spécifique de cette erreur. Il fonctionne comme suit.
Le bloc d’instructions qui suit directement une instruction try est exécuté par Python sous réserve. Si une erreur
survient pendant l’exécution de l’une de ces instructions, alors Python annule cette instruction fautive et exécute
à sa place le code inclus dans le bloc qui suit l’instruction except. Si aucune erreur ne s’est produite dans les
instructions qui suivent try, alors c’est le bloc qui suit l’instruction else qui est exécuté (si cette instruction est
présente). Dans tous les cas, l’exécution du programme peut se poursuivre ensuite avec les instructions
ultérieures.

Exemple :
filename = input("Veuillez entrer un nom de fichier : ")
try:
f = open(filename, "r")
except:
print("Le fichier", filename, "est introuvable")

10
Si nous estimons que ce genre de test est susceptible de rendre service à plusieurs endroits d’un programme,
nous pouvons aussi l’inclure dans une fonction :
def existe(fname):
try:
f = open(fname,'r')
f.close()
return 1
except:
return 0

filename = input("Veuillez entrer le nom du fichier : ")

if existe(filename):
print("Ce fichier existe bel et bien.")
else:
print("Le fichier", filename, "est introuvable.")

Il est également possible de faire suivre l’instruction try de plusieurs blocs except , chacun d’entre eux traitant un
type d’erreur spécifique…

11