0.resume de Python - Sup

CPGE-MP-PSI Programmation Python Résumé de SUP
Langage Python
1. Introduction
Python, comme la majorité des langages dit de script, peut être utilisé aussi bien en modeinteractif qu’en
mode script / programme.Dans le premier cas, il y a un dialogue entre l’utilisateur et l’interprète : les
commandes entréespar l’utilisateur sont évaluées au fur et à mesure. Pour une utilisation en mode script les
instructions à évaluer par l’interprète sont sauvegardées dans les fichiers l’extension .py
2. Calcul avec python :

>>>a=10 # affectation de la valeur 10 à la variable a
>>> a, b, c=2 , 4, ’abc’ # affectation au même temps les valeurs 2, 4et ‘abc’ aux variables a, b et c
Les opérateurs mathématiques et logiques:
opérateur signification Exemple Résultat
Les opérateurs mathématiques
= affectation x= 41 x prend la valeur 41
+ addition x= 41+25 x prend le résultat de l’addition 41+25 =66
- soustraction x= 41-25 x prend le résultat de la soustraction 41-25 =16
* multiplication x= 5*12 x prend le résultat de la multiplication …………=…..
** puissance x=5**3 x prend le résultat de 5 à la puissance 3= …………..
/ Division réelle x=14/3 x prend le résultat de la division réelle ……………..
// Division entière x=14//3 x prend le résultat de la division entière …………….
% Reste de la division x=14%3 x prend le reste de la division de 14 par 3 =………..
Les opérateurs logiques
== Egalité x= (2==6) x vaut ……………………………
> Supérieur x= (2>6) x vaut ……………………………
>= Supérieur ou égale x= (2>=6) x vaut ……………………………
< inférieur x= (2<6) x vaut ……………………………
<= Inférieur ou égale x= (2<=6) x vaut ……………………………
!= différent x= (2 !=6) x vaut ……………………………
not négation x= not (2==6) x vaut ……………………………
or Ou logique x= (2==6) or (1>-5) x vaut ……………………………
and Et logique x= (2==6) and (1>-5) x vaut ……………………………
3. Commentaires : Comme dans la majorité des langages de script, les commentaires Python sont définis à
l’aide du caractère #. Le # introduit un commentaire jusqu’à la fin de la ligne. Il ne faut pas hésiter à
commenter le code. Le listing suivant présente une ligne de commentaire en Python.
>>> # ceci est un commentaire
>>>print('’il s'agit d'un commentaire en python’') #ceci est un commentaire

Il s'agit d'un commentaire en python
4. Les entrées Sorties (Lecture /Ecriture) :

4.1 Ecriture : La fonctionprint
Pour afficher une variable ou un message on utilise la fonction print :
>>>a=10
>>>print(a)
10
>>>print(" a = ",a)
a =10
>>>print(" a vaut",a, "et son double vaut",2*a)
a vaut 10 et son double vaut 20
A.LAGRIOUI Page1/26
4.2 Lecture : La fonction input

La plupart des scripts élaborés nécessitent à un moment ou l'autre une intervention de l'utilisateur
(entrée d'un paramètre). La méthode la plus simple consiste à employer la fonction
intégrée input(). Cette fonction provoque une interruption dans le programme courant.
L'utilisateur est invité à entrer une valeurau clavier et à terminer avec <Enter>.
prenom=input("Entrez votre prénom : ")

print("Bonjour,", prenom)
n=int(input("Veuillez entrer un nombre positif quelconque : "))
print("Le carré de", n, "vaut", n**2)
Remarque : La fonction input() renvoie toujours, à partir de la version 3 du python, une chaine de
caractères ( chaine numérique ou alphabétique ou alphanumérique).Pour lire un entier ou un réel, on
doit transtyper la valeur lue au clavier par la fonction input().
# x est traitée comme une chaine de caractères
# x est traitée comme un entier

5. Variables
5.1 Définition :
Une variable est une zone mémoire dans laquelle on stocke une valeur; cette variable est définie par un nom.
Les noms de variables sont des noms que vous choisissez. Ce sont des suites de lettres (non accentuées) ou de
chiﬀres. Le premier caractère est obligatoirement une lettre. (Le caractère _ est considéré comme une lettre).
Python distingue les minuscules des majuscules.
5.2 Noms de variables et mots réservés :
Un nom de variable ne peut pas être un mot réservé du langage :
and Assert break class continue def del elif else except
exec Finally for from global if import in is lambda
not Or pass print raise return try while yield
5.3 Type de variable
Le type d’une variable correspond à la nature de celle-ci.
Les 5 types principaux dont nous aurons besoin sont :lesentiers (int) ,lesﬂottants(float), les chaines de
caractères(str) , les booléens(bool)etlescomplexes(omplex).
5.4 Déclaration et assignation
En python, la déclaration d’une variable et son assignation (c.à.d. la première valeur que l’on va stocker
dedans) se fait en même temps.
>>> a=10 # 10 est une valeur entière
>>> a
10
A.LAGRIOUI Page2/26
Dans cet exemple, nous avons stocké un entier dans la variable a, mais il est tout a fait possible de stocker des
réels ,des chaines de caractères, des complexes ou même de booléens :
>>> a=3.28 # 3.28 est une valeur réelle

>>> a
3.28
>>> a="bonjour" # ‘bonjour’ est une chaine de caractères
>>> a
'bonjour'
>>>a=2+3j #j est l’opérateur du complexe
>>>a
(2+3j)
5.5 La fonction type
La fonction type permet de retourner le type d’une variable
Syntaxe : type(nom_de_lavariable)
Exemples :
>>> a=10 >>> a=[] Remarque : pour supprimer une variable de
>>> type(a) >>> type(a) la mémoire on utilise la fonction del.
<class 'int'> <class 'list'>
>>> a=10.0 >>> a={} >>> del(a)
>>> type(a) >>> type(a) >>>print(a)
<class 'float'> <class 'dict'> Traceback (most recent call last):
>>> a="bonjour"
>>> a=() File "<pyshell#113>", line 1, in <module>
>>> type(a)
<class 'str'> >>> type(a) print(a)
>>>a=(5==5) <class 'tuple'> NameError: name 'a' is not defined
type(a) >>> a={1,2,3}
<class 'bool'> >>> type(a)
>>> a=10-12j <class 'set'>
>>> type(a)
<class 'complex'>
6. Les tests et les boucles :

6.1. Les tests :l’instruction if … else ….. ou if …..elif…..else
Syntaxe1: syntaxe2 :
>>>if condition1:
>>>if condition1: Action1 si condition1 vraie
Action1 si condition vraie Action2 si condition1 vraie
Action2 si condition vraie ………………...
………………... elif condition2: # si condition1 fausse
else: Action1 si condition2vraie
Action1 si condition fausse Action2 si condition2 vraie
Action2 si condition fausse ………………….
…………………. else :
Action1 si condition2 fausse
Exemple : >>> a =10 Action2 si condition2 fausse
>>>if a >0 : ………………….
... print("a est positif")
... elif a <0 :
... print("a est négatif")
... else:
... print("a est nul")
...
A.LAGRIOUI Page3/26
Exercices :
Exercice1 : Lire les 3 réels a, b et c puis Résoudre l’équation ax2+bx+c=0
Exercice2 : Ecrire un programme qui lit trois variables et retourne leur max.
6.2. Les boucles :
La boucle while :
L’instruction while (“tant que”, en français) permet d’exécuter une boucle tant qu’une condition est vraie.
Syntaxe : variable=VI # la variable prend une valeur initiale (VI)
WhileVariable différente d’une valeur finale (VF) : # tant que la condition est vraie
Instruction1 # exécution de l’instruction 1
Iinstruction2 # exécution de l’instruction 2
……………………….. #exécution de l’instruction n
Incrémentation/décrémentation # variable= ± pas (recherche de condition)
Rque : si VI>VF on décrémente sinon on incrémente

Exemple : A compléter
valeur de i avant la boucle : ……….
i=1 # i vaut 1 la valeur initiale(VI)=1 valeur de i dans la boucle : ……….
print("valeur de i avant la boucle : ",i) valeur de i dans la boucle : ……….
whilei<=5: #ici la valeur finale (VF)=10 valeur de i dans la boucle : ……….
print("valeur de i dans la boucle : ",i) valeur de i dans la boucle : ……….
i=i+1 # on incrémente i d’un pas de 1 valeur de i dans la boucle : ……….
print("valeur de i après la boucle : ",i)
valeur de i après la boucle : ……….
Un exemple de calcul d’intérêts composés:
taux=0.03
capital=1000.0
annee=2022
whileannee<2030:
annee=annee+1
capital=capital* (1+taux)
print(annee, capital)
La boucle For : On est souvent amené à faire des boucles pour énumérer les éléments d’une liste ou d’une
séquence itérable:
Syntaxes : for Variable in sequence :
for Variable in range(VI,VF,pas) :
Instruction1 # exécution de l’instruction 1 Instruction1 # exécution de l’instruction 1

Iinstruction2 # exécution de l’instruction 2 Iinstruction2 # exécution de l’instruction 2
……………………… # exécution de l’instruction n
Si VI<VF : le pas est positif sinon le pas est négatif ………………… # exécution de l’instruction n
Exemples :
A.LAGRIOUI Page4/26
1. Lire un entier n puis calculer et afficher la somme ∑ = 0 + 1 + 2 + ⋯…
2. Lire un entier n puis calculer et afficher le factoriel de n ( n !=1*2*3*…….n )
3. Lire un entier n puis chercher et afficher le plus petit entier m tel que : ∑ ≥
4. Lire deux entiers a et b puis chercher et afficher leur plus grand commun diviseur.
5. Ecrire un programme en python qui affiche les termes de la suite définie par :
U0=1, u1=1 ; un=2* un-1+3*un-2 ;
5.3 Les instructions break et continue
Il est possible de sortir d’une boucle avec l’instruction break. Cette instruction est très pratique pour
tester une condition d’arrêt qui dépend d’une valeur entrée. Par exemple:
somme=0
whileTrue:
n=int(input("Entrez un nombre (0 pour arrêter): "))
ifn==0:
break
somme=somme+n
print("La somme des nombres est",somme)
Ce qui donne à l’écran :
Entrez un nombre (0 pour arrêter): 12

Entrez un nombre (0 pour arrêter): -10
La somme des nombres est 27
La fonction continue : retourne directement au début de la boucle, ce qui permet d'éviter des tests de
condition inutiles Exécution
nb=9
Exemple : Entrer 0, 1, 2 ou 3 ? : 1
while nb!=0:
Choix un
nb=input("Entrer 0 , 1, 2 ou 3? : ")
Entrer 0, 1, 2 ou 3? : 2
if nb==1:
Choix deux
print ("Choix un");
Entrer 0, 1, 2 ou 3? : 3
continue
Choix tois
if nb==2:
Entrer 0, 1, 2 ou 3? : 1
print ("Choix deux");
Choix un
continue
Entrer 0, 1, 2 ou 3? : 0
if nb==3:
print ("Choix trois")
7. La programmation modulaire : Les fonctions
Une fonction est un sous programme qui réalise une certaine tâche.
Une fonction est composée de trois grandes parties :
 Son nom qui permet d'y faire appel et l’identifier des autres fonctions.
 Ses arguments qui permettent de spécifier des données à lui transmettre.
 Sa sortie, c'est-à-dire ce qu'elle retourne comme résultat.
A.LAGRIOUI Page5/26
Son nom et ses arguments forment ce que l'on appelle la signature d'une fonction. Deux fonctions seront
différenciées par l'interpréteur à partir du moment où elles ne possèdent pas la même signature.
Une procédure est une fonction qui ne retourne rien.
Dans la pratique, les fonctions et les procédures s'appellent exactement de la même manière ! La seule
différence réside effectivement dans le fait que les procédures ne renvoient pas de résultats et ne servent
donc qu'à effectuer une suite d'instructions. Ensuite, nous avons vu que pour faire appel à une fonction, il
faut écrire quelque chose du genre :
>>>variable = fonction(argument1, argument2, ...) # la fonction doit retourner un résultat

>>>fonction(argument1, argument2, ...) # la fonction ne retourne rien
Exemple :
définition appel exécution
Les fonctions avec des arguments ayant des valeurs par défaut
Reprenons la fonction puissance :
Si la valeur du 2ème paramètre est manquée la fonction

prend la valeur par défaut qui est 2
Arguments anonymes :
La syntaxe est particulièrement simple. En fait, on va préciser une séquence (liste, tuple ou chaîne de caractères)
comme argument. Le fait que cet argument doive être une séquence se précise par l'utilisation de l'opérateur '*'
juste avant le nom de l'argument :
A.LAGRIOUI Page6/26
1er appel 2ème Appel
3ème Appel :
Remarquez bien la présence de l’étoile *
Si on oublie cette étoile la fonction considère la séquence

‘’ahmed MP 1 ‘’ comme un seul paramètre.
Arguments avec clé :
Si on veut associer une clé à chacun des arguments qu’on donne en supplément à une fonction, il va falloir
utiliser un dictionnaire (voir paragraphe 8.5 page ……….). Et ceci, c'est l'opérateur '**' qui sera utilisé.
1er Appel
2ème Appel
Une autre façon d’appeler la fonction : remarquez la présence du double étoiles ** et le mot dict.
A.LAGRIOUI Page7/26
Documenter une fonction : Une dernière chose très importante est la documentation de la fonction. On va
commencer à documenter notre code pour le rendre plus compréhensible et exploitable par d'autres personnes.
Pour cela, c'est très simple, il suffit de placer immédiatement sous la ligne de définition de notre fonction, une
chaîne de caractères entre triple 'quote' (""" chaine""") qui sera considérée comme un commentaire.
Appel :
7.3 Les Fonctions récursives :
Une fonction peut appeler une autre fonction. Un c as particulier elle peut appeler elle-même.
Récurrenceen mathématique : Nousallonscommencerparl'exempledelasuite numérique,(Un)définiepour ∈

ℕ par :
= ∗ +
 est appelé une suite récurrente.

= 2*(2*(. . . (2* + 3) . . .) + 3) + 3
 La conception d'une fonction récursive n'est pas éloignée du principe de démonstration par récurrence :
 Leprincipededémonstration par récurrence est le suivant:
1- On démontre d'une part que la suite satisfait une telle propriété (croissante,
décroissante,....) pour le cas de base
2- D'autre part, on suppose que cette propriété est valide pour et on démontre que cela
implique que la suite satisfait aussi cette propriété pour tout n > 0.
A.LAGRIOUI Page8/26
Définition d'algorithme récursif
Fonction récursive :
Une fonction est dite récursive si elle s'appelle elle-même au cours de son exécution.
Avantages de la récursivité :
 La récursivité permet d'exprimer d'une manière élégante la solution de plusieurs problèmes:

- Récurrences mathématiquesclassiques
- Tour d'Hanoï
- Trirapide,trifusion,...
- Recherchedichotomique,...
 La récursivité est particulièrement adaptée lorsqu'elleest appliquée à unestructurerécursive.
 Leslistesetlesarbrespeuvent êtrevus commedesstructures récursives.
Comment écrireunefonctionrécursive?
Principe
 L'idée de base pour l’écriture d'une fonction récursive consiste à
définirtoutd'abordlemodèlemathématiquedelafonctionderécurrence.
 Dans ce modèle mathématique ilfaut déterminer la condition d'arrêtpourassurerlaterminaisonde
l'algorithme.
Exemple :Nouspouvonsdoncdéfinirlafonctionfactorielledelamanièresuivante:
1 si n=0
n! 
 n * ( n  1) ! s in o n
 n!=n*(n-1)! : Représentelarelationde récurrence.

 0!=1 : représentelavaleurdelaterminaisondel'algorithme.
Le code en Python
Méthode itérative Méthode récursive
def fact_Iter(n): def fact_Rec(n):
f=1 ifn==0:
foriinrange(2,n+1): return1
f=f*i else:
return f returnn* fact_Rec(n-1)
La récursivité multiple
Définition:
Une récursivité est multiple s’il ya plusieurs appels récursifs à une fonction P dans le corps d'une
fonction récursive P.
0 si n=0

Exemple1:suitedeFibonacci Fn  1 si n =1
 F +F
 n1 n 2 si n  2
Questions:
1. Ecrirelecodedelafonction récursiveFibo_Re quiretournelavaleurde .
2. Donnerlatrace d'exécutionpourcalculer
A.LAGRIOUI Page9/26
Exemple2:Calculdecombinaison
0 si p=0
p
C  1
n si n =p
C p +C p 1 sinon
 n 1 n 1
Questions:
1. Ecrirelecodedecettefonction récursive.
2. Donnerlatrace d'exécutionpourcalculer
La récursivité imbriquée
Définition:
Une récursivité estdite imbriquéesiunefonction récursive P contientunappel imbriqué.
Exemple:Lafonctiond'ACKERMANN
 p 1 si n=0

Ack (n, p)  Ack(n-1,1) si n >0 et p=0

Ack  n-1, Ack  n, p-1  sinon
Questions:
1. CalculeralamainAck(1,0); Ack(2,0) et Ack(3,0):
2. Ecrirelecodedecettefonction récursive.
3. Donnerlatraced'exécutionpourcalculer Ack(3 , 2)
Larécursivitémutuelle
Définition :
Une récursivité estmutuelleoucroiséequandunefonction P appelleuneautrefonction Q qui
déclencheunappel récursif à P
Remarque:
Lasituationestobligatoirementsymétrique,puisque Q déclencheraunappelde P,quidéclencherait à
sontourunappelde Q.
Exemple:Laparité d'unentiernatureln
True si n=0  False si n=0
pair (n)   et impair (n)  
impair (n  1) sinon  pair (n  1) sinon
Questions:
1. Ecrirelecodedelafonction récursivepair(n);
2. Ecrirelecodedelafonction récursiveimpair(n);
3. Donnerlatrace d'exécutionpourcalculer pair (6)
4. Donnerlatrace d'exécutionpourcalculer impair (8)
8. Structures de base
8.1. Les listes
8.1.1. Définition
Une liste est une structure de données de types différents
A.LAGRIOUI Page10/26
8.1.2. Création
Pour créer une liste, on utilise des crochets :

>>>L1=[] # première façon de créer une liste vide
>>>L2=list() # une autre façon de créer une liste vide
>>>L3=[1,2,5,3,2,1,5,2] #création d’une liste des entiers
>>>L4 =list((1,2,5,3,2,1,5,2)) #une autre façon de créer d’une liste d’entiers
8.1.3. La taille d’une liste : la fonction len()
>>>len(L4)
8
8.1.4. Elémentset indice :
NB : On se souviendra que le premier élément d'une liste est l'élément d’indice 0.

Or en python le premier élément d’une liste a aussi un indice négatif qui = -len(liste)
élément 2 4 6 8 10 12 14 16
L3 0 1 2 3 4 5 6 7
indice
-8 -7 -6 -5 -4 -3 -2 -1
8.1.5. Accès aux éléments d’une liste :
>>>L4[0]>>> L3[-len(L4)]>>>L[-5]
1 2 3
On peut accéder à un élément avec sa position, et le modifier :
>>>L=[4,5,12.0,’a’,’abc’] Par contre si la liste est vide on ne peut pas lui

>>>L
affecter une valeur dans une position quelconque :
[4,5,12.0,’a’,’abc’]
Exemple : L1=[]
>>>L[0]
4 L1[0]=12 ; # refusé par l’interpréteur
>>>L[0] = 7 On écrit : L1.append(12)
>>> L
[7,5,12.0,’a’,’abc’]
8.1.6. Accès au dernier élément de la liste :
On peut atteindre le dernier élément de L :

>>> n = len(L)
>>>print L[n-1]
'abc'
Tranche d’une liste : On peut extraire facilement des éléments d'une liste :
>>> L = [12, 20, 32, 14, 25, 6, 17, 8, 9]

>>>L[3:6] donne [14, 25, 6]
>>>L[3:] donne [14, 25, 6, 17, 8, 9] #de l’indice 3 à la fin de la liste
>>>L[:5] donne [12, 20, 32, 14, 25] # de l’indice 0 à l’indice 4 (5-1)
>>>L[3:6 :3] donne [14] #de l’indice 3 à l’indice 5 (6-1) avec un pas=3
8.1.7. Les méthodes d’une liste
Une fois définie, une liste possède un ensemble de méthodes :
*Autres méthodes de création des listes : Les listes de compréhension :
Exemple :
>>> L=[i for i in range(10) ]donne L=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> L1=[ 2*x**2-3*x+2 for x in range(10)]donne L1=[2, 1, 4, 11, 22, 37, 56, 79, 106, 137]
Les listes à plusieurs dimensions :
>>> L=[[1,2,3,4,5],[11,22,33,44,55],[10,20,30,40,50]]
>>> L
[[1, 2, 3, 4, 5], [11, 22, 33, 44, 55], [10, 20, 30, 40, 50]]
>>>L[0][0]
1
>>>L[0][3]
4
>>>L[2][3]
40
>>>L[2][:]
[10, 20, 30, 40, 50]
>>>L[:][1]
[11, 22, 33, 44, 55]
>>>L[:][0]
[1, 2, 3, 4, 5]
Les liste de compréhension à plusieurs dimensions :
8.2. Les ensembles ou set

Un ensemble en python est semblable à une liste mais ne peut pas contenir des doublons c.à.d ne
contient que des éléments distincts.
Déclaration :
Les méthodes d’un ensemble :
Add : Ajouter un élément à l’ensemble :

>>>E.add(25)
>>> E
{8, 4, 5, 7, 12, 25}
8.3. Les tuples
Python propose un type de données appelé tuple, qui est assez semblable à une liste mais qui n'est
pas modifiable. Du point de vue de la syntaxe, un tuple est une collection d'éléments séparés par des
virgules :>>> T=(4,12,8,25)
>>> T
(4, 12, 8, 25)
>>> type(T)
<class 'tuple'>
Les méthodes d’un tuple :
Le tuple ne contient que deux méthodes count et index.

Accès aux éléments d’une liste
>>>T[0]>>> T[:4]>>> T[1:3]>>> T[2:]>>> T[2:4:3]
4(4, 12, 8, 25)(12, 8)(8, 25)(8,)
Modifier les éléments d’un tuple :
>>>T[0]=20 # on ne peut pas modifier un tuple
Traceback (most recent call last):
File "<pyshell#178>", line 1, in <module>
T[0]=20
TypeError: 'tuple' object does not support item assignment
8.4. Les dictionnaires
8.4.1. Définition
Après avoir étudié les séquences avec les listes, les ensembles, les tuples et les chaînes, nous allons nous
intéresser à un autre type de données : les types associatifs. En Python, il n'existe qu'un seul type associatif
appelé dictionnaire.
8.4.2. Déclaration
Syntaxe générale :
d1={clé1 :val1, clé2 :val2, clé3 :val3, …….}

d2=dict(zip([clé1, clé2,clé3,….],[val1, val2, val3,….]))
modifier les éléments d’un dictionnaire
d1[clé4]=val4
d2[clé4]=val4
exemple :
8.4.3. Modifier les éléments d’un dictionnaire :
8.4.4. Les méthodes d’un dictionnaire
Values : retourner la liste des valeurs d’un dictionnaire
keys : retourner la liste des clés d’un dictionnaire
Pop : supprimer et retourner une valeur d’un dictionnaire en précisant son clé.
Exercice:
1. Ecrire un programme qui lit une chaine de caractère et construit un dictionnaire contenant en clé les
caractères de la chaine et en valeur leur fréquence d’apparition dans la chaine
2. Ecrire un programme qui lit un dictionnaire et qui inverse leurs clés avec leurs valeurs. C.à.d dans le
nouveau dictionnaire les clés seront les valeurs de l’ancien dictionnaire et les valeurs seront les clés de
l’ancien.
8.5. Les chaines de caractères :
8.5.1. Définition
Une chaine de caractères contenant un ensemble de caractères délimités par :
Des guillemets simples : chaine1=’Bonjour’ #chaine sur une seule ligne
Des guillemets simples : chaine1=’’Bonjour’’ #chaine sur une seule ligne
Des guillemets simples : chaine1=’’’’’’Bonjour
Tout le monde ‘’ ‘’ ‘’ #chaine sur plusieurs lignes
8.5.2. Accès aux caractères d’une chaine :

>>> S1='Bonjour' >>> S2="Bonjour" >>> S3="""Bonjour
>>> S1[0] >>> S2[0] tout le monde"""
'B' 'B' >>> S3[0]
>>> S1[2] >>> S2[2] 'B'
'n' 'n' >>> S3[4]
>>> S1[1:] >>> S2[3:5] 'o'
'onjour' 'jo' >>> S3[2:]
>>> S1[:3] >>> S2[::2] 'njour\ntout le monde'
'Bon' 'Bnor' >>> S3[:7]
>>> S1[2:5] 'Bonjour'
'njo' >>> S3[3:9:2]
>>> S1[::2] 'ju\n'
'Bnor' >>> S3[2:11:3]
'nut'
Caractère d'échappement
Le symbole \ est spécial : il permet de transformer le caractère suivant :
 \n est un saut de ligne

 \t est une tabulation
 \b est un « backspace »
 \a est un « bip »
 \' est un « ' », mais il ne ferme pas la chaine de caractères
 \" est un « " », mais il ne ferme pas la chaine de caractères
 \\ est un « \ »
Si on veut que le symbole \ reste simplement un \ dans une chaîne, on peut utiliser une chaîne « brute
» ("raw string") en préfixant le premier guillemet avec un r :
s = r"Ceci est une chaîne de caractères\nsur une seule ligne"
8.5.3. 6.3.3 les méthodes d’une chaine de caractères
Une méthode est une fonction qu’on peut appliquer sur chaine :
Pour afficher les méthodes d’une chaine, il suffit d’écrire la chaine suivie d’un point.
L’exemple suivant montre les méthodes de la chaine S3 définie ci haut.
Méthode
Split() : découpe une chaine en une liste S= ‘’Bonjour tout le monde ‘’
de mots LS=S.split() donne LS=[‘Bonjour’,’tout’,’l’ , ‘monde’]
Join(liste de chaines) : concatène une >>> S1="-"
liste de chaine en chaine unique >>> S="Bonjour Tout Le Monde"
>>> S3=S1.join(S)
>>> print(S3) B-o-n-j-o-u-r- -T-o-u-t- -L-e- -M-o-n-d-e
>>> S4=S1.join(['Bonjour','tout','le','monde'])
>>>print(S4) Bonjour-tout-le-monde
>>>S5= «’’ ‘’.join(['Bonjour','tout','le','monde'])
>>>print(S5) Bonjour tout le monde
Find(sous chaine) : donne la position >>> f=S.find('tout')
d’une sous chaine dans une chaine >>> f donne -1 # la sous chaine n’existe pas
>>> f=S.find('Tout')>>>print(f) donne 8
Count(sous chaine) : donne le nombre le >>> f=S.count('tout')
nombre d’apparition d’une sous chaine >>> f donne 0 # la sous chaine n’existe pas
dans une chaine >>> f=S.count('Tout') >>>print(f) donne 1
Lower() : convertit une chaine en >>>print(S) donne Bonjour Tout Le Monde
miniscule >>>Sm=S.lower()
>>>print(Sm) bonjour tout le monde
upper() : convertit une chaine en >>>Sm=S.upper()
mijuscule >>>print(Sm) bonjour tout le monde
capitalize() : convertit le 1ere lettre d’une >>> SM=S.upper()
chaine en mijuscule. >>>print(SM) donne BONJOUR TOUT LE MONDE
title() : convertit tous les 1er lettres des >>> t=S.title()
mots d’une chaine en mijuscule. >>>print(t) donne Bonjour Tout Le Monde
Swapcase() : intervertit les lettres >>> tt=t.swapcase()
majuscules et miniscules >>>print(tt) donne bONJOURtOUTlEmONDE
Strip() : supprime les espaces blancs en >>>ss=’’ bonjour tout le monde’’
début en en fin de la chaine >>>sss=ss.strip() donne ‘’bonjour tout le monde’’
Replace() : remplace une sous chaine par >>> s1=S.replace('Tout Le Monde','la compagnie')
une autre >>>print(s1) donne Bonjour la compagnie
Index(sous chaine) : retourne la position >>> S="Bonjour"
de la sous chaine dans une chaine >>>S.index('j')
3
>>>S.index('njour')
2
Center(nombre) : centrer la chaine sur >>>print(S.center(40))
nombre caractères Bonjour
40 caractères
Format() : remplace un format dans une >>> s1="Voici {0}chaîne à {1} trous."
chaine >>>print(s1)
Voici {0}chaîne à {1} trous.
>>>print(s1.format("une " , 2))
Voici une chaîne à 2 trous.
>>>print("a{0}cada{0}".format("bra"))
abracadabra
Les fonctions isupper() et islower() : >>> print(s1.isupper())
Testent si une sous chaine est majuscule False
ou minuscule >>> print(s1.islower())
False
>>> print("BONJOUR".isupper())
True
7.7 Les Tableaux et les matrices

Nous allons voir comment créer des tableaux avec la fonction array() de NumPy. Ces tableaux pourront
être utilisés comme des vecteurs ou des matrices grâce à des fonctions de NumPy.Les fonctions
(dot(), det(),inv(), eig(), ….etc.) permettent de réaliser des calculs matriciels utilisés en algèbre linéaire.
>>> import numpy as np
7.7.1 Les Tableaux à une ou plusieurs dimension : np.array()

Pour créer des tableaux, nous allons utiliser la fonction array() de la bibliothèque numpy.
7.7.1.1 Tableaux monodimensionnels (1D)

Pour créer un tableau 1D, il suffit de passer une liste de nombres en argument de array(). Un liste est
constituée de nombres séparés par des virgules et entourés de crochets ([ ]).
>>>T=array([4,7,9])
>>>T
array([4, 7, 9])
>>>print(T)
[4 7 9]
Pour connaître le type du résultat de array(), on peut utiliser la fonction type().
>>>type(a)
<type 'numpy.ndarray'>
On constate que ce type est issu du package numpy. Ce type est différent de celui d’une liste.
>>>type([4,7,9])
<type 'list'>
7.7.1.2 Tableaux bidimensionnels (2D) :

Pour créer un tableau 2D, il faut transmettre à array() une liste de listes grâce à des crochets imbriqués.
>>>T=array([[1,2,3],[4,5,6]])
>>>T
array([[1, 2, 3],
[4, 5, 6]])
La fonction size() : La fonction size() renvoie le nombre d’éléments du tableau.

>>>T1 = array([2,5,6,8])
>>>size(T1)
4
>>>T2 = array([[1, 2, 3],
[4, 5, 6]])
>>>size(T2)
6
La fonction shape()
La fonction shape() (forme, en anglais) renvoie la taille du tableau.
>>>T1=array([2,5,6,8])
>>>shape(T1)
(4,)
>>>T2=array([[1,2,3],
[4, 5, 6]])
>>>shape(T2)
(2, 3)
On distingue bien ici que T1 et T2 correspondent à des tableaux 1D et 2D, respectivement.
Produit terme à terme

Il est possible de réaliser un produit terme à terme grâce à l’opérateur *. Il faut dans ce cas que les
deux tableaux aient la même taille.
>>>T1 = array([[1, 2, 3],
[4, 5, 6]])
>>>T2 = array([[2, 1, 3],
[3, 2, 1]])
>>>T1*T2
array([[ 2, 2, 9],
[12, 10, 6]])
Comme tout objet structure en python un tableau quelque soit en une seule ou plusieurs dimensions
possède un ensemble de méthodes :
Supprimer des lignes et des colonnes
delete(a,k,axis=0) suppriment la k-ième ligne de la matrice a ( axis=0)
delete(a,k,axis=1) suppriment la k-ième colonne de a ( axis=1)
On peut également supprimer plusieurs colonnes (ou lignes) à la fois. Voici quelques exemples :
Produit matriciel - dot()
Un tableau peut jouer le rôle d’une matrice si on lui applique une opération de calcul matriciel. Par
exemple, la fonction dot() permet de réaliser le produit matriciel.
>>>T1=array([[1,2,3],
[4, 5, 6]])
>>>T2=array([[4],
[2],
[1]])
>>>dot(T1,T2)
array([[11],
[32]])
Le produit d’une matrice de taille n x m par une matrice m x p donne une matrice n x p.
Algèbre linéaire
Déterminant - det()
>>> a = array([[1, 2],
[3, 4]])
>>>np.linalg.det(a)
-2.0
Inverse - inv()
>>>a = array([[1, 3, 3],
[1, 4, 3],
[1, 3, 4]])
>>>np.linalg.inv(a)
array([[ 7., -3., -3.],
[-1., 1., 0.],
[-1., 0., 1.]])
Valeurs propres et vecteurs propres - eig()

>>>A = array([[ 1, 1, -2 ], [-1, 2, 1], [0, 1, -1]])
>>>A
array([[ 1, 1, -2],
[-1, 2, 1],
[ 0, 1, -1]])
>>>D, V = np.linalg.eig(A)
>>>D
array([ 2., 1., -1.])
>>>V
array([[ 3.01511345e-01, -8.01783726e-01, 7.07106781e-01],
[ 9.04534034e-01, -5.34522484e-01, -3.52543159e-16],
[ 3.01511345e-01, -2.67261242e-01, 7.07106781e-01]])
Les colonnes de V sont les vecteurs propres de A associés aux valeurs propres qui apparaissent dans D.
Exercice : Vérifier que les colonnes de V sont bien des vecteurs propres de A
Changement de la taille d’un tableau
Il est possible de changer la taille d’un tableau en utilisant l’attribut shape de ce tableau.
>>>u = arange(1,16)
>>>u
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
>>>shape(u)
(15,)
>>>u.shape = (3,5)
>>>u
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
>>>shape(u)
(3, 5)
Attention si on écrit :
u1=u.reshape(3,5) on aura
>>>u1
array([[ 1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
Alors que le tableau u reste inchangé :
>>>u
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
Matplotlib : Tracés en 2D et 3D avec Python
Matplotlib est probablement le package Python le plus utilisé pour la représentation de

graphiques scientifiques en 2D et en 3D.
Les options sont très nombreuses et nous n'en présenterons que quelques unes, les plus utiles.
Pour plus de détail, voir http://matplotlib.org/
Pour utiliser matplotlib, la façon la plus simple est d'importer le module pylab. De façon
simplifiée, ce module import à la fois matplotlibet numpy.
In [2]:frompylabimport*
Mais on peut seulement importer le module matplotlib.pyplot, traditionnelement sous le
nom plt (la façon la plus propre):
In [3]:importmatplotlib.pyplotasplt
Un graphique simple :
D’une manière générale les fonctions plt.plotattendent des vecteur/matrice, bref des
tableaux de points du plan. Selon les options, ces points du plan sont reliés entre eux de façon
ordonnée par des segments : le résultat est une courbe.
Commençons par la fonction sinus.
importmatplotlib.pyplotasplt
importnumpyasnp
x=np.linspace(-5,5,100)
plt.plot(x,np.sin(x)) # on utilise la fonction sinus de Numpy
plt.ylabel('fonction sinus')
plt.xlabel("axe des abcisses")
plt.show()
Il est possible de jouer avec les

menus dans le bas de cette fenêtre :
zoomer, déplacer la figure, etc et
surtout sauvegarder dans un
format PNG, PDF, EPS, etc.
Plusieurs courbes :
On peut bien sûr tracer plusieurs courbes sur un même graphique.
In [5]:
importnumpyasnp
x=np.linspace(0, 2*pi, 30)
y1 =np.cos(x)
y2 =np.sin(x)
plt.plot(x, y1,label=’cos’)
plt.plot(x, y2,label=’sin’)
plt.legend(loc='upper center')
plt.grid()#pour afficher la grille d’un graphe

plt.show()
On peut, pour chacune des courbes, préciser la couleur et lui affecter une légende.
plt.plot(x, y1, color='red', label ='cos')
plt.plot(x, y2, color='blue', label ='sin')
Matplotlib est fournie avec un jeu de paramètres par défaut qui permet de personnaliser toute
sorte de propriétés. Vous pouvez contrôler les réglages par défaut de (presque) toutes les
propriétés : taille du graphique, résolution en points par pouce (dpi), épaisseur du trait,
couleurs, styles, vues, repères, grilles, textes, polices de caractères, etc.
Ci-dessous, quelques exemples de réglages que l'on peut modifier:

In [7]:
importnumpyasnp
# on crée un graphique de 8x6 pouces
# avec une résolution de 160 points par pouce
plt.figure(figsize=(8,6), dpi=160)
X =np.linspace(-np.pi, np.pi, 500)
C,S=np.cos(X), np.sin(X)
X2 =np.linspace(-np.pi, np.pi, 50)
C2 =np.cos(2*X2)
# on trace la fonction cosinus en bleu avec un trait plein de 1,5 pixel
d'épaisseur et des tirets
plt.plot(X, C, color="blue", linewidth=1.5, linestyle="--", label ='cos(x)')
# on trace la fonction sinus en vert avec un trait plein de 3 pixels d'épaisseur
et des points-tirets
plt.plot(X, S, color="green", linewidth=3, linestyle="-.", label ='sin(x)')
# on trace la dernière fonction en rouge, avec des marqueurs
plt.plot(X2, C2, marker='o', color='red', linestyle='-', label ='cos(2x)')
# limites de l'axe (O,x) des abscisses
plt.xlim(-4.0,4.0)
# graduations de l'axe (O,x) des abscisses avec du joli texte
plt.xticks([-np.pi, -np.pi/2, 0, np.pi/2, np.pi],
[r'$-\pi$', r'$-\pi/2$', r'$0$', r'$+\pi/2$', r'$+\pi$'])
# limites de l'axe (O,y) des ordonnées
plt.ylim(-1.0,1.0)
# graduations de l'axe (O,y) des ordonnées
plt.yticks(np.linspace(-1,1,5))
# la légende, en haut à gauche
plt.legend(loc='upperleft')
# on enregistre le graphique avec une résolution de 72 points par pouce
# plt.savefig("exercice.png",dpi=72)
# on affiche le résultat à l'écran
plt.show()
Subplots
Un système de sous-figures permet de juxtaposer différents graphiques.
Dans la commande plt.subplot(a,b,c),les argumentssont a= nbre de lignes,

b=nbre de colonnes, et c=numéro de la figure (le nombre de lignes multiplié par le
nombre de colonnes devant être supérieur ou égal au nombre de figures).
Ensuite matplotlib place les figures au fur et à mesure dans le sens des lignes.
In [8]:
importnumpyasnp
deff(t):
returnnp.exp(-t) *np.cos(2*np.pi*t)
t1 =np.arange(0.0, 5.1, 0.1)

t2 =np.arange(0.0, 5.02, 0.02)
plt.figure(1, figsize= (12,10))
plt.subplot(2, 2, 1)
plt.plot(t1, f(t1), color='red', marker ='v', linestyle='None')
plt.plot(t2, f(t2), color='green')
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.plot(t2, np.sin(2*np.pi*t2), 'b-')
plt.plot(t2, np.sin(2*np.pi*t2)+np.sin(2*np.pi*t2), 'g')
plt.show()
Plusieurs graphiques
On peut tracer plusieurs graphiques sur des fenêtres séparées.
importnumpyasnp plt.figure(2) )
importmatplotlib.pyplotasplt plt plt.plot(t, U(t,10),), label
label="$Q=10$")
t=np.linspace(0,10,400) ) plt.xlim(0, 10) )
defU(t,Q): plt.xlabel("$t \,(s)$"
,(s)$", fontsize=16)
returnnp.exp(-2/Q*t)*cos(2* 2*pi*t) plt.ylim(-1, 1) )
plt.figure(1) ) plt.ylabel("$U \,(V)$"
,(V)$", fontsize=16)
plt.plot(t, U(t,2), label="$Q=2$" "$Q=2$") plt.legend()
legend()
plt.title("Figure 1") ) plt.show()
Dans l'exemple ci-dessus,

dessus, les instructions données après le code plt.figure(2) ne seront
valables que pour celle-ci:
ci: les axes ne sont annotés, la légende n’est placée et les échelles ne
sont respectées que pour la figure 2.
3.Tracer en 3D en python
importnumpyasnp
from mpl_toolkits.mplot3d import axes3d # Fonction pour la 3D
# Tableau pour les 3 axes
# Création d'un tableau de 100 points
#entre -4*pi et 4*pi
theta = np.linspace(-4*np.pi, 4*np.pi, 100)
z=np.linspace(-2, 2, 100)
r= z**2 + 1
x = r * np.sin(theta) # Création du tableau
de l'axe x
y = r * np.cos(theta) # Création du tableau
de l'axe y
# Tracé du résultat en 3D
fig = plt.figure()
ax =fig.gca(projection='3d')#Affichage en 3D
ax.plot(x, y, z, 'r',label='Courbe') # Tracé de la courbe 3D
plt.title("Courbe 3D")
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.tight_layout()
plt.show()

0.resume de Python - Sup

Transféré par

Droits d'auteur :

Formats disponibles

0.resume de Python - Sup

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

0.resume de Python - Sup

Transféré par

Droits d'auteur :

Formats disponibles

CPGE-MP-PSI Programmation Python Résumé de SUP

2. Calcul avec python :

>>>print('’il s'agit d'un commentaire en python’') #ceci est un commentaire

4. Les entrées Sorties (Lecture /Ecriture) :

4.2 Lecture : La fonction input

prenom=input("Entrez votre prénom : ")

# x est traitée comme une chaine de caractères

# x est traitée comme un entier

5.2 Noms de variables et mots réservés :

Un nom de variable ne peut pas être un mot réservé du langage :

>>> a=3.28 # 3.28 est une valeur réelle

6. Les tests et les boucles :

Exercice1 : Lire les 3 réels a, b et c puis Résoudre l’équation ax2+bx+c=0

6.2. Les boucles :

Syntaxe : variable=VI # la variable prend une valeur initiale (VI)

Instruction1 # exécution de l’instruction 1

Iinstruction2 # exécution de l’instruction 2

……………………….. #exécution de l’instruction n

Incrémentation/décrémentation # variable= ± pas (recherche de condition)

Rque : si VI>VF on décrémente sinon on incrémente

Instruction1 # exécution de l’instruction 1 Instruction1 # exécution de l’instruction 1

Entrez un nombre (0 pour arrêter): 12

7. La programmation modulaire : Les fonctions

Une procédure est une fonction qui ne retourne rien.

>>>variable = fonction(argument1, argument2, ...) # la fonction doit retourner un résultat

Reprenons la fonction puissance :

Si la valeur du 2ème paramètre est manquée la fonction

1er appel 2ème Appel

Remarquez bien la présence de l’étoile *

Si on oublie cette étoile la fonction considère la séquence

Arguments avec clé :

7.3 Les Fonctions récursives :

Récurrenceen mathématique : Nousallonscommencerparl'exempledelasuite numérique,(Un)définiepour ∈

 est appelé une suite récurrente.

 La récursivité permet d'exprimer d'une manière élégante la solution de plusieurs problèmes:

 n!=n*(n-1)! : Représentelarelationde récurrence.

Pour créer une liste, on utilise des crochets :

NB : On se souviendra que le premier élément d'une liste est l'élément d’indice 0.

>>>L=[4,5,12.0,’a’,’abc’] Par contre si la liste est vide on ne peut pas lui

On peut atteindre le dernier élément de L :

>>> L = [12, 20, 32, 14, 25, 6, 17, 8, 9]

*Autres méthodes de création des listes : Les listes de compréhension :

Les listes à plusieurs dimensions :

8.2. Les ensembles ou set

Add : Ajouter un élément à l’ensemble :

8.3. Les tuples

Le tuple ne contient que deux méthodes count et index.

d1={clé1 :val1, clé2 :val2, clé3 :val3, …….}

8.4.3. Modifier les éléments d’un dictionnaire :

8.4.4. Les méthodes d’un dictionnaire

keys : retourner la liste des clés d’un dictionnaire

8.5.2. Accès aux caractères d’une chaine :

Le symbole \ est spécial : il permet de transformer le caractère suivant :

 \n est un saut de ligne

s = r"Ceci est une chaîne de caractères\nsur une seule ligne"

8.5.3. 6.3.3 les méthodes d’une chaine de caractères

L’exemple suivant montre les méthodes de la chaine S3 définie ci haut.

7.7 Les Tableaux et les matrices

>>> import numpy as np