Révision Informatique, Concours MP-PC-T 2020 1 Révision Informatique, Concours MP-PC-T 2020 2

III Opérateurs

Description Opérateurs Exemples/Remarques

I Introduction Affectation v = valeur x = 5

v1=v2=v3= valeur x = y= z = t = 5
Python est un langage de programmation multi-paradigmes (procédural, orienté objet et fonctionnel) et v1,v2,v3=valeur1,valeur2,valeur3 x, y, z = 1, '2', 5
dynamiquement typé. Sa version standard est libre et est disponible sur le site officiel de Python « python.org ».
Parenthèses () (x+y)*2 #donne 6
La version Pyton3.X est adoptée par le programme officiel du cycle préparatoire. Cette version inclut un grand
nombre de modules pré-programmés fournis d’office, tels que math, cmath, random, etc., mais n'inclut pas les Opérations arithmétiques
modules tels que numpy, scipy et matplotlib qu'il faut importer explicitement au besoin. Un module regroupe des Puissance x**y # ou pow(x,y) 1j**2 #donne -1+0j
ensembles de variables et de fonctions apparentées, que l’on appelle également bibliothèque. Signes +;-
Anaconda est une solution comportant l’interpréteur Python livré avec plusieurs environnements de développement x*y ;x / y # produit et 4/2 #donne
Opérateurs multiplicatifs
intégrés (IDLE, spyder, Jupyter) et inclut une panoplie de modules (numpy, scipy et matplotlib) mais qui nécessite division réelle de x par y 2.0(float)
beaucoup de ressources. x//y ; x%y #quotient et 4//2# donne 2 (int)
reste de division entière de x 4%2 # donne 0
par y
Opérateurs additifs x+y ; x -y

Opérateurs relationnels
II Variable et affectation
Comparaison d’identité is
Une variable est une référence associée à un objet déjà créé en mémoire. Elle n'a pas de type et n'est pas déclarée.
is not
Toute variable doit être affectée avant son utilisation. L'identificateur (nom) de la variable ne peut contenir que des
caractères alphanumériques et le caractère '_' et ne débutant pas par un chiffre. Comparaison de valeur x==y ; x!=y 2!=5 # donne True
2==5 # donne False
Comparaison riche < ; > ; <= ; >=
L’affectation permet d’associer un nom à un objet (instance d'une classe) en mémoire :
Opérateurs logiques
>>> nom = objet nom id(nom)== id(nom1) Produisent un booléen and ; or ; not
Objet
ou bien (bool)
Ainsi une affectation de la forme : nom is nom1
nom1 Classe de l’objet Opérateurs avec assignation
>>> nom1 = nom
référence le même objet avec autre nom (nom1). Produisent le même x += y # x = x + y
type(nom)
résultat que l'affectation x -= y # x = x  y
du résultat de l'opération x *= y # x = x * y
effectuée
x /= y # x = x / y
x //= y # x = x // y
On obtient le type d'un objet à l'aide de la fonction type(objet) et son adresse mémoire désignant son identité à
l'aide de id(objet). x %= y # x = x % y
x **= y # x = x ** y

IV Classes élémentaires
Les classes élémentaires sont immuables (non modifiables). Les opérations appliquées aux instances de ces classes
génèrent de nouvelles instances comme le montre l'exemple suivant :

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 3 Révision Informatique, Concours MP-PC-T 2020 4

>>> x=5
VI Structures de contrôle
>>> id(x)
2053437424 Un bloc de code est un groupe d’instructions Python indentées précédées par ":". Un bloc peut en inclure d'autres.
>>> x+=1 # x référence une nouvelle instance
>>> id(x) Description Syntaxe Exemples
2053437440
Structure conditionnelle
Permet de conditionner if cond : #maximum de 3 entiers x, y, z
Classes élémentaires Description Exemples / Remarques bloc1 if x > y and x >z :
l'exécution d'un ou plusieurs
NoneType Classe de l’objet None (objet type(None) # donne NoneType
blocs d’instructions, mais un elif cond2 : print(x)
n'ayant pas de valeur) seul est exécuté. bloc2 elif y > z:
Bool Booléens type(True) # donne bool … print(y)
bool(20) # donne True else : else :
True et False sont les seules
bool(0) # donne False blocn print(z)
instances de cette classe.
x=y=2; x==y # donne True
Boucle conditionnelle
x,y=1,2; x==y # donne False
y=2 ; type(y) # donne Int Permet d’exécuter un bloc while cond_exécution : #pgcd de x et y
Int Entiers relatifs (Z)
x = int('52') # x prend 52 tant que la condition bloc while x % y != 0 :
int(22.5) # donne 22 d'exécution de la boucle est x, y = y, x % y
y=3.5 ; type(y) #donne Float
à True. print(y)
Float Nombres flottants (IR )
x = float('22.2')#x prend 22.2 La condition est toujours
x = -1e33 #x prend -1e+33 testée avant l’exécution du
z = 3+1j #ou z = complex(3,1)
bloc de la boucle.
Complex Nombres complexes (C)
Permet d’exécuter un bloc while True : #saisie d’une voyelle
type(z) # donne Complex
jusqu’à ce que la condition bloc while True:
complex(5) # donne(5+0j)
z.real # donne 3.0 (float)
d’arrêt devienne True. La if cond_arrêt : v=input('saisir une voyelle:')
condition d’arrêt est break if v in ['a','e','i','o','u','y']:
z.imag # donne 1.0 (float)
toujours testée après break
z.conjugate() # donne 3-1j l’exécution du bloc de la
Remarque boucle.
bool (x) # retourne False si l'évaluation de x est nulle et True autrement Boucle NON conditionnelle
int(x) # retourne un entier si x est un nombre ou une chaine de caractère contenant Permet d’exécuter le bloc for v in itérable: #calcul du produit des éléments d’une
un nombre entier. bloc liste
pour chaque élément v de
float(x) # retourne un réel si x est un nombre ou une chaine de caractère contenant l’itérable. Un itérable est une p = 1
un nombre réel. collection d’objets (voir for v in [1,8,7]:
section VII sur les itérables). p*=v
complex(x,y) # retourne un nombre complex formé par la partie réelle x et la partie
imaginaire y. Expression conditionnelle
Python offre la possibilité de expr1 if cond1 else #maximum de 2 valeurs x ,y
former des expressions dont expr2 m = x if x > y else y
V Opérations d'entrée/sortie l’évaluation est soumise à
une condition. Le résultat #les éléments négatifs de L1 sont
Description Syntaxe Exemples est l’évaluation de remplacés par 0 dans L2 (voir
print(expr1, … , exprn) print('bienvenue à la formation') expression1 si la condition l’itérable liste dans la section VII)
Sortie
est True, et celle de L1=[-1,0,5,3]
Entrée nom = input() >>> nom= input('votre nom svp: ') expression2 sinon. expr1 if cond1 else L2=[0 if x<0 else x for x in L]
nom = input("message") votre nom svp: Foulen Cette construction ne permet expr2 if cond2 else
Input prend (optionnel) et
>>> print('Bonjour',nom) pas l’utilisation du mot expr3 x=int(input("?"))
retourne une chaîne de
caractères Bonjour Foulen réservé elif mais on peut ">0" if x>0 else "<0" if x<0 else "=0"
emboîter deux expressions
conditionnelles.

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 5 Révision Informatique, Concours MP-PC-T 2020 6

VII.2 Les séquences

Les itérables ordonnés, appelés encore séquences (tuple, liste et chaîne), conservent l’ordre dans lequel les
VII Classes itérables
éléments ont été créés. Ainsi, chaque élément d’une séquence possède un indice indiquant sa position relative
Les classes itérables ou conteneurs permettent de conserver une collection d’objets. Ces classes peuvent se ramifier par rapport aux autres éléments. Les indices commencent à partir de 0 pour un parcours de la gauche vers la
selon deux critères : droite.

 La mutabilité : classes modifiables (list, set, dict) et classes non modifiables (range, str et tuple). Un intervalle défini par range, également considéré comme une séquence, est un itérable ou conteneur formé
 L’ordre : classes ordonnées appelées encore séquences (str, tuple, list, range) et classes non ordonnées (set par une succession d’entiers.
et dict).
range(debut, fin, pas) génère l’intervalle [debut, fin [ par pas entier relatif égal à pas.

VII.1 Opérations communes aux itérables VII.2.1 Opérations communes aux séquences
Le tableau suivant présente quelques opérations communes applicables aux instances des itérables. Le tableau suivant liste quelques opérations communes à toutes les séquences.

Description Syntaxe Exemples / Remarques Description Syntaxe Exemples / Remarques

Taille d’un itérable len(iter) lst = [1,2,5]
Indexage simple s[i] s = 'python'
len(lst) #donne 3
avec 0 ≤ 𝑖 ≤ 𝑙𝑒𝑛(𝑠) − 1 ou s[0] #donne 'p'
Test d’appartenance d’un x in iter 5 in (1,5,[1,3]) # donne True s[len(s)-1] #ou s[-1] donne'n'
−𝑙𝑒𝑛(𝑠) ≤ 𝑖 ≤ −1
élément x à un itérable x not in iter 3 not in (1,5,[1,3]) # donne True s[len(s)] # IndexError
"li b" in "ali baba" # donne True
Morcelage (Slicing) # fin non inclus s = 'python'
"Ali" in "ali baba" # donne False s[dep:fin:pas]
s[ ::-1] # donne 'nohtyp'
Somme des éléments d’un sum(iter) sum([1,5,2,10]) # donne 18 #pas par défaut égal à 1 s[ :2] # donne 'py'
itérable (itérable de valeurs s[dep:fin]
s[2:] # donne 'thon'
numériques uniquement). #du début avec pas=1
s[ :fin] s[::2] # donne 'pto'
Valeur maximale/ minimale max(iter) max([1,5,2,10]) # donne 10
min(iter) l = (1+3j,2+5j,11j); max(l)# Error #jusqu'à la fin avec pas=1
TypeError pour un itérable s[dep :]
comportant des objets non min(1,5,2,10) # donne 1
comparables Concaténation s1 + s2 [1,2] + [3] # donne [1,2,3]

sorted(iter) d = {'med':10, 'ali':20, 'lilia':5} (1,2) + (3,) # donne (1,2,3)

Tri d’un itérable d’objets
comparables (TypeError si sorted(d) # donne ['ali', 'lilia', 'med' + 'ali'# donne 'medali'
l’itérable comporte un objet 'med']
Répétition n * s # ou bien s * n [0] * 3 # donne [0,0,0]
non comparable) sorted(d, reverse = True) # donne
l'ordre inverse['med', 'lilia', 'ali'] avec n entier Naturel (1,2) * 2 # donne (1,2,1,2)
Renvoie une liste contenant
les éléments dans l’ordre. 'bon' * 2 # donne 'bonbon'

Parcours d’un itérable for item in iter : lst = [1,2,5] Comptage du nombre s.count(item) lst = [0,1,0,1,1,1]
#opérations for e in lst: d’occurrences lst.count(1) # donne 4
manipulant item print(e) ch ="ali baba"
Énumération des éléments enumerate(iter) ch = "cem" ch.count("a") # donne 3
d’un itérable enumerate(iter, for i, v in enumerate(ch): # première occurrence lst.index(0) # donne 0
Retour de l’index d’un
start_index) s.index(item)
print(i, v) item lst.index(0,1)# donne 2
# donne en sortie # à partir de start
0 c Déclenche ValueError si lst.index(5) # ValueError
s.index(item, start)
1 e item not in s.
2 m Parcours d’un itérable for ind in range(len(iter)): lst = [1,2,5]
indexé #opérations manipulant for i in range(len(lst)):
iter[ind]
print(lst[i])

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 7 Révision Informatique, Concours MP-PC-T 2020 8

VII.2.2 La classe str VII.2.3 La classe list

Une chaîne est une séquence non modifiable et ordonnée de caractères. Le tableau suivant résume les Une liste est une séquence, ordonnée et modifiable, d’éléments éventuellement hétérogènes séparés par une
principales opérations applicables aux chaînes. virgule et délimitée par une paire de crochets.
Le tableau suivant résume les principales fonctions/méthodes applicables aux listes.
Description Syntaxe Exemples / Remarques
Création d’une chaîne de #chaîne simple: s = "bonsoir" # ou encore Description Syntaxe Exemples
caractères ("…" ,'…') s = 'bonsoir' Création d’une liste vide L=[ ] #ou L=[1, 'python', True, 1+1j]
#chaîne multilignes: s1="""chaîne L=list( )
(""" … """ ,''' …''') multi-
lignes""" Création d’une liste à L=list(itérable) list('ABCA') # donne ['A','B','C','A']
#équivalente à partir d’un itérable list({3, 'A',4}) # donne [3,4,'A']
s1 = 'chaîne\nmulti-\nlignes' list((2,2,(1,2)))# donne [ 2,2,(1,2)]
Retour d’une chaîne en Ch.lower ( ) Ch='fG15Z' list({2 :45, 'x':[1,2]}# donne [2,'x']
minuscule identique à Ch Ch.lower( ) # donne 'fg15z' list(145)# TypeError
Retour d’une chaîne en Ch.upper ( ) Ch='fG15Z' L.append (objet) L.append(2020) ; L
Ajout d’un objet à la fin
majuscule identique à Ch Ch.upper ( ) # 'FG15Z' d’une liste #donne [1, 'python', True, (1+1j), 2020]
Retour d’une liste des sous- Ch.split(sep) Ch='Epsilon 2018/2019' #remplissage d'une liste par n chaînes
chaînes en utilisant un séparateur Ch.split( ) # donne lst = list()
sep ['Epsilon', '2018/2019']
for i in range(n):
Ch.split('0') # donne [Epsilon
Par défaut, le séparateur est le 2', '18/2', '19'] x = input("donner l[{}]:".format(i))
caractère espace lst.append(x)
Retour d’une chaîne identique à Ch.strip(sep) Ch="*la chaîne*"
Ajout d’un objet x dans L L.insert(i,x) L.insert(-1 ,'concours') ; L # donne
Ch en supprimant les Ch.strip('*') [1,'python',True,(1+1j),'concours',2020]
à l’indice i
occurrences d’un séparateur sep # donne 'la chaîne'
du début et de la fin si elles Suppression de la première L.remove(x) L.remove(1+1j) ; L # donne
existent. Par défaut sep est occurrence d’un l'objet x [1, 'python', True, 'concours', 2020]
l'espace. dans L
Retour d’une chaîne de Sep.join(itérable) L=['abc','12','azer'] ValueError si x not in L.
caractères résultante de la '/'.join(L) L.extend(t) L.extend({-1,2}) ; L # donne
Ajout d’éléments de
concaténation par sep des # donne 'abc/12/azer' l’itérable t à la fin de L [1,'python',True,'concours',2020,2,-1]
chaînes de l’itérable ' '.join(L)
Suppression et retour du L.pop() L.pop() # donne -1
TypeError est généré si l’itérable # donne 'abc 12 azer'
dernier élément de L L # donne
contient un objet qui n'est pas de [1,'python',True,'concours',2020,2]
type str.
Suppression et retour de L.pop(i) L.pop(2) # donne True
Retour d’une chaîne de Ch.format(paramètres) Ch = 'Epsilon {}/{}' l’élément d’indice i de la L # donne
caractères en remplaçant chaque Ch.format(2019,2020) liste L [1, 'python', 'concours', 2020, 2]
‘{}’ par les paramètres passés à # donne 'Epsilon 2019/2020'
la méthode (objets de classes
quelconques).
Retour de l’Unicode (entier) du ord(caractère) ord ('A') # 65 VII.2.4 La classe tuple
caractère passé en paramètre ord('a') # 97
Un tuple est une séquence, ordonnée et non modifiable, d’éléments éventuellement hétérogènes séparés par
Retour du caractère associé à la chr(entier) chr(65) # donne 'A' une virgule. Le tableau suivant résume les principales fonctions/méthodes applicables aux tuples :
valeur UNICODE passée chr(10) # donne '\n'
paramètre.

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 9 Révision Informatique, Concours MP-PC-T 2020 10

Description Syntaxe Exemples

Création d’un tuple vide t=( ) #t=tuple( ) VII.3.2 La classe dict
Création d’un tuple d’un t=objet , T=255,
Un dictionnaire est une structure modifiable et non ordonnée d'associations (clé : valeur). Les clés sont
seul objet (singleton) T # donne (255,)
impérativement des objets non modifiables. L'utilisation de listes, de dictionnaires ou d'ensembles comme
T1=[12,5],1
clé déclenche une erreur. Les valeurs sont des objets de classes quelconques.
T1 #donne ([12,5], 1)
Création d’un tuple à L=tuple(itérable) tuple({3,'A',4}) # donne (3,'A',4)
Description Syntaxe Exemples / Remarques
partir d’un itérable tuple((2,2,(1,2))) # donne (2,2,(1,2))
Création d’un d = dict()
dictionnaire vide d = {}
VII.3 Les itérables non ordonnés Création d’un d= dict(iter) t = [(5,2), "ab", [1,2] ]
dictionnaire à partir d’un d={c1:v1 , …, cn:vn} dict(t) #donne {1:2, 5:2, 'a':'b'}
VII.3.1 La classe set itérable de couples ou d = {'a': 3, 'b': 5, 4j: 33}
directement
Un ensemble est une collection d'éléments distincts non ordonnés et encadrés par des accolades. La classe
Test d’appartenance k in d 33 in d # donne False
set représente la notion d’ensemble en mathématique. Un ensemble doit impérativement comporter des
d’une clé k à un k not in d 'a' in d # donne True
éléments non modifiables. La création d'ensembles de listes, de dictionnaires ou d'ensembles déclenche une dictionnaire d
erreur. Le tableau suivant résume les principales fonctions/méthodes applicables aux ensembles. d = {'a': 3, 'b': 5, 4j: 33}
Accès à une entrée du d[k]
dictionnaire d d.get(k) d['a'] # donne 3
Description Syntaxe Exemples/ Remarques d.get(k, vdef) d['c'] # donne KeyError
Création d’un s = set() d.get('c') # None
ensemble vide NB : s={} ne crée pas un d.get('c', 0) #0
ensemble
Mise à jour / insertion d[k] = val d = {}
Création d’ensemble à s = set(iter) s = set("010101")
d’une entrée dans le d.update({k :val}) d['a'] = 33 # insertion
partir d’un itérable iter s={e0, …,en} s # donne {'0','1'}
dictionnaire d d # donne {'a' :33}
ou avec les délimiteurs s = set(3.25) # TypeError
d['a'] = 22 # mise à jour
Ajout d’un objet s.add(obj) s = set()
d # donne {'a':22}
s.add(5) ; s # donne {5}
Copie de dictionnaire d.copy() d = {1:2}
s.add("eps"); s #donne{5,“eps”}
d1 = d.copy()
s.add([1,2,3]) #TypeError
d[1] = {2} ; d1 # donne {1:{2}}
Suppression d’un objet s.discard(x) s = {1,7,2} ; s.remove(1) d # donne {1:2}
s.remove(x) s # donne {2,7} Suppression d’une d.pop(k) d = {1:2, 'a':10}
s-= {obj} s.remove(5) # KeyError entrée de à partir de sa del d[k] del d[1]; d # donne {'a':10}
s -= {2} ; s # donne {7} clé d.pop('a') # donne la valeur 10
Union : s1 U s2 s1 | s2 s = {1,2} | {2,3} d # donne {}
s1.union(s2) s # donne {1,2,3} Parcours des clés d’un for k in d: d = {1:2, 'a':10}
Intersection : s1 ∩ s2 s1 & s2 s = {1,2} & {2,3} dictionnaire traitements for k in d:
s1.intersection(s2) s # donne {2} #ou encore print(k)
Différence : s1 \ s2 s1 – s2 s = {1,2} – {2,3} for k in d.keys()
s1.difference(s2) s # donne {1} traitements
Différence Symétrique s1 ^ s2 s = {1,2}^{2,3} Parcours des valeurs for v in d.values(): for v in d.values():
s1 ∆ s2 s1.symmetric_difference(s2) s # donne {1,3} d’un dictionnaire traitements print(v)

Inclusion : s1 ⊂ s2 s1 <= s2 {1,2} <= {1,2,5}# donne True Parcours des couples for k, v in d.items(): for k, v in d.items():
{1,2} <= {1,2} # donne True clé, valeur d’un traitement print(k,v)
Inclusion stricte : s1 < s2 {1,2} < {1,2,5} # donne True dictionnaire
s1 ⊊ s2 s1.issuperset(s2) {1,2} < {1,2} # donne False

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 11 Révision Informatique, Concours MP-PC-T 2020 12

VIII Construction des itérables en compréhension VIII.3 Ensembles en compréhension

La construction des itérables en compréhension permet de générer des conteneurs de façon concise et élégante. On set(expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n )
peut créer des listes en compréhension, des tuples en compréhension, des ensembles en compréhension et des
ou encore
dictionnaires en compréhension à l'aide du constructeur de la classe ou les délimiteurs des itérables mutables.
{ expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n}
VIII.1 Listes en compréhension
Exemple
[expression for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n ]
>>> e={(x,y) for x in range(5) if x%2 for y in range(5) if y%2==0 }
ou encore # ou bien e=set((x,y) for x in range(5) if x%2 for y in range(5) if y%2==0)
list(expression for indice_1 in iterable_1 if condition_1 … >>> e
for indice_n in iterable_n if condition_n ) {(1, 2), (3, 2), (3, 0), (1, 4), (1, 0), (3, 4)}

- Les conditions if sont facultatives (conditions de filtrage).

- L’ordre d’imbrication des boucles est de la gauche vers la droite. VIII.4 Dictionnaires en compréhension
- On peut utiliser le constructeur list à la place des délimiteurs.
- expression peut elle même être un itérable en compréhension. {cle: valeur for indice_1 in iterable_1 if condition_1 …
for indice_n in iterable_n if condition_n }
Exemples ou encore
>>> L= [ i for i in range(1, 21, 2) ] ; L
dict((cle,valeur) for indice_1 in iterable_1 if condition_1 …
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19] for indice_n in iterable_n if condition_n)
>>> L=[ (i,j) for i in range(1,3) for j in range(1,4) ] ; L Exemple:
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)] >>>d={ x:y for x in range(10) if x%2 for y in range(10) if y%2==0}
>>> L=[i*j for i in range(1,5) for j in range(1,5) ] ; L #ou bien d=dict((x,y) for x in range(10) if x%2 for y in range(10) if y%2==0)
[1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16] >>>d
>>> L=[(i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0]; L {1: 8, 3: 8, 9: 8, 5: 8, 7: 8}

[(1, 1), (1, 3), (3, 1), (3, 3)]

>>>[[(100*i+j)//2 if j%2==0 else 100*i+j for j in range(1,i+1)] for i in
range(1,5)] IX Import de bibliothèques ou modules
[[101], [201, 101], [301, 151, 303], [401, 201, 403, 202]]
Il y a trois manières d’import de modules :

 1ère manière d’import :

 Import du module désigné par nom_module mais pas les fonctions qui y sont contenues :
VIII.2 Tuples en compréhension import nom_module
tuple( expression for indice_1 in iterable_1 if condition_1 … Exemples : import math # import du module math
for indice_n in iterable_n if condition_n )
import random # import du module random
Attention : sans le constructeur tuple, la construction en compréhension produit un générateur et non pas
un tuple.  L’appel de chaque fonction du module se fait par :
nom_module.fonction(…)
Exemple
Exemples : math.ceil(7.8989) # partie entière supérieure qui est 8
tuple((i,j) for i in range(1,5) if i%2 for j in range(1,5) if (i+j)%2==0 )
((1, 1), (1, 3), (3, 1), (3, 3)) random.randint(0,10) # retourne un entier aléatoire entre 0 et 10

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 13 Révision Informatique, Concours MP-PC-T 2020 14

 2ème manière d’import :

 Utilisation d’un alias :
Description Syntaxe Exemples(s) / Remarques
import nom_module as alias
Définition d’une fonction où les def nom_f(paramètres) : #fonction avec paramètres
Exemple : import math as m paramètres sont optionnels corps de nom_f def f(x,y) :
import math
 L’appel de chaque fonction du module se fait par :
return x**2 + math.sin(y)
alias.fonction(…) #fonction sans paramètres
Exemple : m.sqrt(4)# retourne la racine carrée de 4 : 2.0 def g():
whileTrue:
 3ème manière : s = input("donner une
chaîne alphabétique : ")
 Accès direct à toutes les fonctions du module par :
if s.isalpha():
from nom_module import * return s
Exemple : from math import * Appel d’une fonction : #arguments positionnels
nom_f(arguments) print(f(3,2))
 Accès direct à une ou quelques fonctions du module par : - Arguments positionnels
nom_f(n_arg1=v1 , …,
- Arguments nommés (ordre
from nom_module import nom_fonc1,…,nom_foncp arguments n'a plus d'importance) n_argp=vp) #arguments nommés
r = f(y = 2, x = 3)
Exemple : from math import pi,sqrt,ceil Les paramètres nommés doivent
apparaître à la fin
Dans les deux cas, l’appel de chaque fonction du module se fait directement par son nom : nom_fonction(…)
Retour d’une fonction return expression #Définition
Exemple : sqrt(5) #donne 2.23606797749979 L’instruction return permet de #Une fonction sans def f(x) :
retourner un résultat à l’appelant return retourne l’objet if x >0 :
None
d’une fonction. return x**0.5
Cette instruction engendre la #Appel
sortie immédiate du code de la print(f(4)) # affiche 2.0
fonction et le retour vers print(f(-4)) # affiche None
X Les sous-programmes l'appelant.
Paramètres optionnels def f(x,y,z=val_def) : # cette déclaration génère
corps de f SyntaxError
Les paramètres optionnels sont
Une fonction est un bloc d’instructions indentées (corps de la fonction) destiné à réaliser une opération. Elle peut associés à une valeur par défaut def h(x, y = 5, t) :
recevoir des paramètres et renvoie éventuellement un résultat. L’appel d’une fonction Python retourne toujours un (évaluée une seule fois au moment corps
objet, par défaut None. Dans le corps de la fonction ce retour est spécifié à l’aide de l’instruction return. de la définition de la fonction).
Si l’argument associé au # déclaration de f
Le tableau suivant résume les concepts de base associés aux fonctions Python. paramètre n’est pas indiqué lors de def f(x, y = 6) :
l’appel, Python utilise la valeur return x + y
par défaut pour substituer le
paramètre optionnel. #Appel de f
Les paramètres optionnels doivent print(f(1,3)) # affiche 4
apparaître à la fin de la séquence print(f(3)) # affiche 9
des paramètres.

Fonctions lambda lambda paramètres : f = lambda x : x**2

résultat #équivalente à
Elle permet de créer une
def f(x) :
expression de type fonction.
return x**2

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 15 Révision Informatique, Concours MP-PC-T 2020 16

XI Gestion des exceptions

Fonctions /Méthodes Description/Exemples
Les exceptions sont des objets spéciaux permettant de représenter une erreur d’exécution dans un script Python. Il
existe plusieurs types d’erreurs : TypeError, ValueError, IndexError. Ces derniers sont des classes Python f=open(nom_du_fichier,'r') Ouvre le fichier nom_de_fichier (donné sous la forme d’une
héritant toutes de la classe de base Exception permettant de représenter une Erreur quelconque. La table suivante chaîne de caractères indiquant son emplacement) en lecture ( r
résume les opérations de gestion d’erreur. comme read). Le fichier doit exister et seule la lecture est
autorisée. L'ouverture d'un fichier inexistant génère une erreur.
L'utilisation de la clause try … except est indiquée pour gérer cette
Description Syntaxe Exemple(s) / Remarque(s) situation.
Déclencher une raise Exception(" message ") raise Exception() f=open(nom_du_fichier,'w') Ouvre le fichier nom_de_fichier en écriture (w comme write). Si
exception le fichier n’existe pas, il est créé, sinon il est écrasé. f est le fichier
if cond_erreur : logique associé au fichier physique donné par nom_du_fichier.
Prévoir une f=open(nom_du_fichier,'a') Ouvre le fichier nom_de_fichier en ajout (a comme append).
exception raise Exception("message" )
Identique au mode 'w', sauf que si le fichier existe, il n’est pas
ou bien
écrasé et l'ajout se fait en fin du fichier.
assert not cond_erreur, f.close() Ferme un fichier ouvert par la fonction open.
"message" f.read() Fournit l'intégralité du contenu du fichier sous forme de chaîne de
try : #saisie d’un entier positif (avec caractères (à ne réserver qu’aux fichiers de taille raisonnable).
Intercepter une f.readlines()
bloc gestion d’erreur) Fournit la totalité du contenu du fichier sous forme d’une liste de
exception
except : def f(): chaînes de caractères.
while True: Le caractère de saut de ligne '\n' présent à la fin de chaque chaîne
bloc_cas_erreur
try:
indique la fin de chaque ligne.
else : f.readline() Fournit la ligne courante sous forme d’une chaîne de caractères et
bloc_cas_pas_erreur x=int(input('x'))
place le curseur sur la ligne suivante. Elle renvoie la chaîne vide
finally : except: si fin du fichier.
bloc_tous_les_cas print ('erreur') f.write(s) Écrit la chaîne s à partir de la position courante du fichier.
else: f.writelines(T) Écrit l’ensemble des éléments de T dans le fichier f comme des
if x>0: T doit être une chaîne de sous chaînes ou lignes successives. Le caractère de saut de ligne '\n' présent à la
return x un itérable de chaînes fin de chaque chaîne indique la fin de chaque ligne.
Parcours d'un fichier
Parcourir un fichier ouvert en lecture se try:
fait comme le parcours d'un itérable : f = open("nomf.txt","r")
parcourir ses lignes avec une boucle for except:
XII Gestion des fichiers sans passer par readlines.
print(" fichier introuvable !")
for ligne in f :
Un fichier est une collection d’informations, généralement structurées d’une manière ou d’une autre, placées sur else:
[instructions]
une mémoire de masse. for ligne in f:
print(ligne)
f.close()
XII.1 Fichiers textes
Un fichier texte contient une succession de caractères séquentiels. Lors de l’ouverture d’un fichier texte, un On n'est jamais à l'abri d'une erreur quand on manipule des fichiers et qu'on oublie de les fermer. Le mot réservé
encodeur assure la conversion des octets lus/écris en lettres UNICODE. Voici les principales fonctions/méthodes
with du langage python, permet d'éviter cette situation et dont voici sa syntaxe générale :
pour le traitement des fichiers.
with open (mon_fichier, mode) as variable :
# Opérations de manipulation du fichier

L'exemple précédent s'écrit alors :

try:
with open ('fp.txt','r') as f :
for ligne in f:
print(ligne)
except:
print(" fichier introuvable !")

Notions de base : Rappel Notions de base : Rappel

 Révision Informatique, Concours MP-PC-T 2020 17 Révision Informatique, Concours MP-PC-T 2020 18

XII.2 Fichiers binaires XIV Complexité algorithmique

Dans un fichier binaire les informations sont transférées de la RAM vers le support de stockage sans aucun
formatage (aucun encodeur n’est utilisé). Pour les fichiers binaires, le mode d’ouverture est suffixé par 'b' : XIV.1 Calcul du coût
'wb', 'rb' et 'ab'. La manipulation d'un fichier binaire n'est pas une fin en soi et cela ne présente aucun
intérêt pour l'utilisateur. L'intérêt à ce niveau est de pouvoir utiliser le module pickle permettant de Le temps d’exécution d’un programme dépend fortement de la machine qui l’exécute, du langage dans lequel il
est écrit et de l’algorithme sous-jacent. Pour des données de grandes tailles, l’algorithme est la cause
sérialiser/désérialiser des objets (entier, réel, chaîne, liste, dictionnaire, etc.) dans leur format et non pas sous
déterminante du temps d’exécution d’un programme. Des méthodes rationnelles permettent de calculer le coût
forme de suite de caractères.
d’un programme exprimé en nombre d’opérations élémentaires exécutées par la machine afin d’obtenir le
Sérialiser un objet, à l'aide de la méthode dump, consiste à le transformer en une suite d’octets afin de pouvoir résultat final. Généralement, ce nombre est fonction de la taille n des données à traiter.
le stocker dans un fichier binaire. Désérialiser, à l'aide de la méthode load, consiste à récupérer les objets dans Le coût se calcule comme suit :
leur format initial.  Coût d’une opération élémentaire op = 1.
>>>import pickle  Coût d'une séquence de k instructions p_1 ; p_2 ; … p_k = ∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒑𝒊 ) .
>>>pickle.dump(objet, fichier_binaire)
 Coût d'une structure conditionnelle simple if c: p else : q <= coût(c) + max(coût(q),coût(p)).
>>>objet = pickle.load(fichier_binaire)
 Coût d'une structure conditionnelle complète if c_1: p_1 elif c_2 : p_2 … elif c_i : p_i … else : p_k+1
Remarque : load génère une erreur si plus d'objets à lire, l'utilisation du try … except s'impose.
= (∑𝒌𝒊 𝟏 𝒄𝒐û𝒕(𝒄𝒊 )) + 𝐦𝐚𝐱 𝒄𝒐û𝒕(𝒑𝒊 ).
𝟏 𝒊 𝒌 𝟏
 Coût d'une boucle for i in iterable : p_i = ∑ ∈ é 𝑐𝑜û𝑡(𝑝𝑖)
XIII La récursivité
 Coût d'une boucle while c : p est le plus difficile à exprimer (nombre d'itérations non connu à priori)
Une fonction récursive est une fonction dont le corps contient un ou plusieurs appels à elle-même. majorer le nombre de répétitions => NombreRépétitions*( 𝑐𝑜û𝑡(𝑐)+ 𝑐𝑜û𝑡(𝑝))+1* 𝑐𝑜û𝑡(𝑐)
Un traitement récursif nécessite de déterminer :
 le cas trivial ou encore le cas d'arrêt Exemple : Calcul xn
 le traitement récurrent et de s'assurer que ce dernier atteindra le cas d'arrêt (terminaison). - Approche naïve :
Dans le tableau suivant, on donne deux exemples de problèmes résolus de façon récursive. def puiss1(x,n):
r = 1 #1 affectation
Problème Démarche Solution récursive for i in range(n): # n affectations
def factorielle(n): r*= x # 1 affectation + 1 multiplication
Calcul de la On raisonne par récurrence sur n if n<=1:
factorielle de n return r # 1 retour
 Cas trivial : 0 ! = 1 return 1 #cas trivial
𝒏 else:
𝒏! = 𝒊  𝑛! = 𝑛 × (𝑛 − 1)! return n*factorielle(n-1) Le Coût total = f(n) = 2n + 2.
𝒊 𝟏 - Exponentiation rapide :
Tri Fusion Le tri fusion est un tri récursif qui def fusion_Rec(L1,L2): def puiss2(x,n):
applique le principe "diviser pour if L1==[]: r= 1 # 1 affectation
régner". return L2 u= x # 1 affectation
Pour une liste L, le principe du tri fusion if L2==[]: while n != 0: # (int(log2(n)) + 1) comparaisons
est le suivant : return L1 if n % 2 == 1: #2 = modulo + comparaison
 si L est de taille 1, elle est triée et on if L1[0]<L2[0]: r*= u #2 = multiplication + affectation
la retourne (cas trivial) ; return [L1[0]]+fusion_Rec(L1[1:],L2) u*= u #2 = multiplication + affectation
 sinon on divise L en deux sous-listes else: n//= 2 #2 = division + affectation
L1 et L2 presque égales ( return [L2[0]]+fusion_Rec(L1,L2[1:]) return r #1 retour
L1[0:len(L)//2] et L2[len(L)//2:
len(L)] ) : def tri_fusion_Rec(L): Le Coût total = f(n) = 9 E[log2(n)]+ 3.
 on applique récursivement if len(L)<=1:
l’algorithme de tri par fusion à L1 return L
puis à L2 L1=[L[x] for x in range (len(L)//2)]
 on fusionne les L1 et L2 triées. (La L2=[L[x] for x in range (len(L)//2,
fusion est également effectuée de len(L))]
manière récursive où le cas trivial Return fusion_Rec(tri_fusion_Rec(L1,
est l'épuisement de l'une des 2 listes tri_fusion_Rec(L2))
et on retourne l'autre).

Notions de base : Rappel Notions de base : Rappel

Révision Informatique, Concours MP-PC-T 2020 19 Révision Informatique, Concours MP-PC-T 2020 20

XIV.2 Complexité asymptotique

La complexité asymptotique consiste à estimer l’ordre de grandeur du nombre d’opérations effectuées par un
Bibliographie et Netographie
programme sans effectuer un décomptage minutieux. Cette complexité est exprimée en Grand-O (notation de
Landau).
Soit f, g : ℕ → ℝ∗ deux fonctions. 𝑓(𝑛) est dite 𝑂(𝑔(𝑛)) ⇔ 𝑓 est dominée par 𝑔 quand 𝑛 → +∞.
Ouvrages
• 𝑓(𝑛) est 𝑂(𝑔(𝑛)) et 𝑐 une constante, alors :
 𝑐 + 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)). Learning Python, Mark Lutz, Edition O’Reilly, Juin 2013, ISBN: 9781449355722.
 𝑐 𝑓(𝑛) est aussi 𝑂(𝑔(𝑛)).
Informatique pour tous en classes préparatoires aux grandes écoles, Benjamin Wack & al., Edition Eyrolles,
 Les facteurs constants sont ignorés dans le calcul de la complexité asymptotique.
Août 2013, ISBN: 978-2-212-13700-2.
• 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)) est 𝑓 (𝑛) est 𝑂(𝑔 (𝑛)), alors :
 𝑓 (𝑛) + 𝑓 (𝑛) est 𝑂 𝑔 (𝑛) + 𝑔 (𝑛) . Supports de Cours
 𝑓 (𝑛)𝑓 (𝑛) est 𝑂(𝑔 (𝑛)𝑔 (𝑛)).
• 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)) et 𝑓 (𝑛) est 𝑂 𝑓 (𝑛) , alors : Support de Cours de H.Filali et H.Bouzidi, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIM,
 𝑓 (𝑛) est 𝑂(𝑓 (𝑛)). Année universitaire 2019-2020.

Support de Cours de Laila Hammami pour 1ère année préparatoire sections MP-PC-T, IPEIN, Année
XIV.3 Classes de complexité asymptotique universitaire 2019-2020.

Support de Cours de W.Meftah, Rappel, pour 2ème année préparatoire sections MP-PC-T, IPEIS, Année
Nom de la classe Complexité Exemples
universitaire 2019-2020.
Constante 𝑂(1)  Accès à un élément d’une liste l[i].
 Additionner multiplier un nombre constant d’objets.
Logarithmique 𝑂(log(𝑛))  Recherche dichotomique 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Méthode de bissectrices pour trouver le zéro d’une fonction Sites Web :
𝑛= .
 Exponentiation rapide. https://www.python-course.eu/
 Trouver l’écriture d’un entier n dans une base b.
https://www.ics.uci.edu/~brgallar/index.html
Linéaire 𝑂(𝑛)  Trouver le maximum/minimum d’une liste 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tester l’appartenance d’un élément dans une liste 𝑛 =
𝑙𝑒𝑛(𝑙𝑠𝑡).
 Produit scalaire de deux vecteurs.
Quasilinéaire 𝑂(𝑛 log (𝑛))  Trier une liste lst.sort() : 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Tri fusion / Tri rapide
Quadratique 𝑂(𝑛 )  Tri par sélection/insertion/bulles 𝑛 = 𝑙𝑒𝑛(𝑙𝑠𝑡).
 Remplissage d’une matrice carrée.
 Somme de deux matrices carrées
Polynomiale 𝑂(𝑛 ) 𝑜ù 𝑝 ≥ 2  Multiplication de deux matrices 𝑂(𝑛 ).
 Réduction de Gauss.
 Inversion d’une matrice.
Exponentielle 𝑂(𝑐 ) 𝑜ù 𝑐 > 1  Trouver tous les sous-ensembles d’un ensemble de taille n.
 Trouver un mot de basse de taille n par brute force.
 Afficher toutes les valeurs binaires qui s’écrivent sur n bits.
Factorielle 𝑂(𝑛!)  Résoudre le problème du voyageur du commerce (avec n =
nombre de villes) par brute force.
 Trier une liste de taille n par brute force.
Exemples :
 4 𝑛 + 100000000 est 𝑂(𝑛).  2 +𝑛 est 𝑂(2 ).
 100 𝑛 + 𝑛 + 300000 𝑛 est 𝑂(𝑛 ).  2 + 𝑛! est 𝑂(𝑛!).

Notions de base : Rappel Notions de base : Rappel