Institut Préparatoire des Etudes d’Ingénieurs de Tunis

Année Universitaire 2020/2021

Dr.Afef Ghabri Classes : MP/PC

Résumé Commandes Python

Types de base : entier, flottant, complexe, Variables, mots-clés réservés :

booléen (non modifiables) Les mots-clés ci-contre sont réservés et ne
 int : 267 0 -186 peuvent donc pas être utilisés pour définir
 float : 7.45 0.0 -2.5e-7 (×10 -7) vos propres identifiants (variables, noms de
fonction, classes...)
 complex : 2+6j 1j
 bool : True False False def if raise None del import return True
 str: "Un\nDeux" ' ''document'' ' 'L\'âme' elif in try and else is while as except lambda
ou bien "" (vide) with assert finally nonlocal yield break for
 Nonetype : type(print(2)) not class from or continue global pass

Quelques opérations sur les nombres = Affectation de Variables

 Opérateurs: +, -, *, /, //, %, ** (addition, 1) évaluation de la valeur de l'expression de

soustraction, multiplication, division droite.
réelle, division entière, reste de la
division entière, puissance) 2) affectation dans l'ordre avec les noms de
gauche.
 divmod(7,2) (3,1) division et reste de
☝ Affectation ⇔ association d'un nom une
la division entière
valeur.
 pow(4,3)64 puissance
 abs(-8.2)→8.2 valeur absolue x=1.3+9+cos (y)
 round(6.56,1)→6.6 float arrondi du réel
à 10−1 près a=b=c=0 affectation à la même valeur
 (3+4j).real partie réelle
 (3+4j).imag partie imaginaire y,z,r=3.2,-5.6,0 affectations multiples
 abs(3+4j) module
a,b=b,a échange de valeurs
 (3+4j).conjugate() conjugué
a,*b=seq dépaquetage de séquence
*a,b=seq en élément et liste
Logique Booléenne
x+=6 incrémentation ⇔ x=x+6
 Comparateurs: <, >, <=, >=, ==, !=
x-=4 décrémentation ⇔ x=x-4
 a and b : c’est le et logique : les deux en
(aussi *=,/=, //=, %=, *=, **=)
même temps
 a or b : c’est le ou logique : l’un ou l’autre y=None valeur constante « non défini »
ou les deux
 not a : non logique Utilisation de l’aide
Remarque : il faut que a et b soient booléens
et les résultats de ces opérations sont Commande : help(<identificateur>)
booléens (True ou False) >>>help(abs)

1
 Institut Préparatoire des Etudes d’Ingénieurs de Tunis
Année Universitaire 2020/2021
Dr.Afef Ghabri Classes : MP/PC

Saisie Importation de modules

s = input("Directives:") 1) import nom_module: import math

☝ input retourne toujours une chaîne, la
convertir vers le type désiré
Exemple:
a=float(input("donner un réel"))
ch=str(input("donner une chaîne"))
Affichage
print("v=",8,"cm :",x,",",y+6)
éléments à afficher : valeurs littérales,
variables, expressions
Options de print:
sep=" " séparateur d'éléments, par défaut
espace
end="\n" fin d'affichage par défaut retour à la
ligne
Exemple:
print("le produit de", a, "et",b, ":",a*b)
print("le produit de", a, "et",b, ":",a*b,
sep="\n", end="**")
 toutes les fonctions de ce module
devront être préfixées du nom du module
pour être utilisées : pour utiliser log il
faudra utiliser la fonction math.log
2) les noms des modules peuvent être longs:
on peut leur donner un nom d’usage plus
court en écrivant par exemple : import math
as m, on utilisera m.log
3) from nom_module import *: from math
import*
 les fonctions n’ont pas besoin d’être
préfixées par le nom du module : on
utilisera log directement.
4) from math import nom_fonction : from
math import sqrt, pi
 On peut importer que les fonctions dont
on aura l’usage.

Fonctions de conversion : type(expression)

int("18") → 18 ; int("3f",16) → 63 ; int(18.56) → 18

float("-11.24e8") → -1124000000.0
round(15.54,1)→ 15.5 arrondi à 1 décimale (0 décimale → nb entier)
bool(x) False pour x nul, x cchaîne vide, True pour autres x
bin(2013)'0b11111011101'
oct(2013)'0o3735'
hex(2013)'0x7dd'
str(x)→ "…" ; repr(x)"…"
chr(64)→'@'
ord('@')→64 code ↔ caractère

2
 Institut Préparatoire des Etudes d’Ingénieurs de Tunis
Année Universitaire 2020/2021
Dr.Afef Ghabri Classes : MP/PC

Structure Conditionnelle Structure itérative

 Simple : 1) while condition logique:

bloc d'instructions
if <cond> : 2) for var in <itérable>:
trait1 bloc d'instructions
else: Contrôle de Boucle
trait 2
break sortie immédiate de la boucle.
continue itération suivante.
 Imbriquée : pass ne fait rien, et permet éventuellement de
remplir une obligation syntaxique (Python n’accepte
if <cond> : pas les blocs vides).
if <cond1>:
trait1.1
else:
trait1,2 Séquences d’entiers
else: elif <cond2>:
if <cond2>: trait 2.1 range([début,] fin [,pas]) : début par défaut 0, fin non
trait 2.1 else: compris dans la séquence, pas signé et par défaut 1
else: trait2,2
trait2,2
range(5)→ 0, 1, 2, 3, 4 ; range(2,12,3)→ 2, 5, 8, 11
range(3,8)→ 3, 4, 5, 6, 7 ; range(20,5,-5)→ 20, 15, 10
range(len(seq))→ séquence des index des valeurs dans
seq

>>> a,b=3,12
>>> a+b #15 ☝ range fournit une séquence non modifiable d'entiers
>>> _ #15 construits au besoin
>>> _*3 # 45
>>> del a
_ contient la dernière sortie sur le shell.
del supprime un objet de la mémoire.

3
 Institut Préparatoire des Etudes d’Ingénieurs de Tunis
Année Universitaire 2020/2021
Dr.Afef Ghabri Classes : MP/PC

Types Conteneurs Fonctions de conversion : type(expression)

séquences ordonnées : accès par index, str(x)→ "…" ; repr(x)"…"

valeurs répétables
 Valeurs non modifiables:
 str : "Un\nDeux" ' ''document'' '
'L\'âme' ou bien "" (vide)
 tuple : (1,4,9) 15,"y",9.4 ("mot",)
ou bien () pour vide
 Valeurs modifiables:
 list : [1,8,9] ["x",3,7.9] ["mot"] ou
bien [] pour vide
Indexation conteneurs séquences : pour les
listes, tuples, chaînes de caractères
lst=[10, 20, 30, 40, 50]
index positif 0 1 2 3 4
index négatif -5 -4 -3 -2 -1
 Accès individuel aux éléments par
lst[index] lst[0]→10 ; lst[-1]50
 Accès à des sous-séquences par
lst[tranche début:tranche fin:pas]
lst[:-1]→[10,20,30,40] ; lst[::2]→[10,30,50]
lst[::-1]→[50,40,30,20,10]
lst[1:3]→[20,30] ; lst[:3]→[10,20,30]
lst[1:-1]→[20,30,40] ; lst[::-2]→[50,30,10]
lst[-3:-1]→[30,40] ; lst[3:]→[40,50]
lst[:]→[10,20,30,40,50] : copie indépendante
chr(64)→'@' ord('@')→64 code ↔ caractère
list("abc") → ['a','b','c']
tuple([1,[2,3],"abc"])(1, [2, 3], 'abc')
Opérations sur les chaînes (non modifiables)
s.startswith(prefix[,début[,fin]])
s.endswith(suffix[,début[,fin]]) booléen : test du début et
de fin
s.isalpha() ; s.isdigit() ; s.isalnum() ; s.isspace() ;
s.istitle()booléen : tests sur les catégories de caractères
s.upper() ; s.lower() ; s.capitalize()
s.strip([caractères]) : nettoie le début et la fin de chaîne des
caractères ; par défaut espace
s.split([sep]) : décompose la chaine de mots séparés par la
chaîine sep en une liste de mots ; par défaut le séparateur est
espace
s.join(seq) str : colle les éléments de seq avec séparateur s
s.find(sous-chaine) ; s.rfind(sous-chaine) première
occurrence et dernière occurrence de la sous-chaîne dans
chaîne s
s.replace(ch1,ch2) : remplace ch1 par ch2 dans chaîne s
"modele{} {} {}".format(x,y,r)str : formatage avec
"{sélection:formatage!conversion}"
"{:+2.3f}".format(45.72793)→'+45.728'
"{x!r}".format(x="L'ame")→'"L\'ame"'
Formatage : entiers: b binaire, c caractère, d décimal (défaut),
o octal, x ou X hexa ; flottant: e ou E exponentielle, f ou F
point fixe ; chaine : s
Conversion : s(texte lisible) ou r(représentation littérale)

Opérations de conteneurs séquences ordonnées

reversed(c) → itérateur inversé
c.index(val) → position
c.count(val) → nombre d'occurrences
c*5 → duplication ; c+c2 → concaténation
Copie indépendante avec module copy : import copy
copy.copy(c)→ copie superficielle de la séquence
copy.deepcopy(c)→ copie en profondeur de la séquence

4
 Institut Préparatoire des Etudes d’Ingénieurs de Tunis
Année Universitaire 2020/2021
Dr.Afef Ghabri Classes : MP/PC

Opérations Génériques sur Conteneurs Opérations sur les listes

len(c)→ nombre d'éléments lst[4]=25 ; lst[1:4]=[15,25] : modification

min(c) ; max(c) ; sum(c)
sorted(c)→ list : copie triée
val in c → booléen : opérateur in de test de
présence (not in d'absence)
enumerate(c)→ itérateur sur (index, valeur)
 enumerate () accepte un index de
départ :
for j,elem in enumerate ("trop",5):
print(j,elem)
5 t
6 r
7 o
8 p
lst.append(val) : ajout d'un élément à la fin
lst.extend(seq) ajout d'une séquence d'éléments à la
fin
lst.insert(idx,val) insertion d'un élément à une
position
lst.remove(val) suppression du premier élément de
valeur val
del lst[idx] ou del lst[deb :fin] suppression de
l’élément à une position idx ou bien suppression
d’une tranche
lst.pop([idx])→valeur supprimée & retourne l'item
d'index idx (défaut le dernier)
lst.sort(); lst.reverse() tri / inversion de la liste sur
place
[int(x) for x in ('1','29','-3')] → [1,29,-3] : liste en
compréhension