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 arithmétiques : + , - , * , / , ** , // , %

Opérateurs avec assignation :

Opérateurs logiques (booléens): not, and, or

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.

1
Fonctions intégrées

Nombres Complexes -- Exemple :

x,y=3,4
z=complex(x,y)
# ou bien
t=x+y*1j

r=z.real # r contient la partie réelle de z

i=z.imag # i contient la partie imaginaire de z
c=z.conjugate( ) # c contient le conjugué de z

Importation de modules (différentes syntaxes possibles):

Exemples :
import math
s=math.sqrt(2)

import math as m
s=m.sqrt(2)

2
 from math import *
s=sqrt(2)

from math import sqrt

s=sqrt(2)

Fonctions et constantes du module math :

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

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

3
Structures Itératives
L’instruction while

while (condition ):
traitement

L’instruction for
for compteur in séquence:
traitement
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

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)

4
 • 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 =["Bonjour", "tout", "le", "monde"]
print(" ".join(b))

Résultat
Bonjour tout le monde

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

Résultat
Bonjour---tout---le---monde

5
  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
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é).

6
  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'}

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.

7
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

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

>>> print(invent.values())

dict_values([274, 312, 137])

8
  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

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.
9
  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

>>> '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

10
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'])

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)

11