Révisions : programmation en langage python

Révisions : programmation en langage python
Retrouvez tout le cours de première année (et plus) sur le site :
http://pcsi.kleber.free.fr/IPT/index.html
1. Modules
Les modules sont des bibliothèques de programmes. Exemples :
math module de fonctions mathématiques usuelles (qui ne figurent pas dans le noyau python)
numpy module de programmes pour calculs numériques sur des tableaux
pyplot module de programmes pour représentations graphiques, sous-module de matplotlib
pylab module de programmes pour représentations graphiques (quasi-équivalent de pyplot)
Importation d’un module :
import math
Pour obtenir de l’aide sur un module importé (ou sur une fonction quelconque en général) :
help(math)
Pour utiliser une fonction du module importé :
math.sin(1.3)
Utilisation d’un alias :
import math as m
m.sin(1.3)
On peut simplifier l’appel des fonctions (ou n’importer qu’une seule fonction) :
from math import * (from math import sin)
sin(1.3)
Mais dans ce cas il faut faire attention aux fonctions portant les mêmes noms en provenance de modules
différents : le dernier import écrase le précédent…
2. Les types python
a) Types d’objets simples
Type entier : pas de limitation de taille
type(25) int
Opérations sur les entiers :
2+3 2-3 abs(-3) 2*3
2**3 25//3 25%3 divmod(25,3)
Type flottant
type(25.0) float
3e4 # notation exponentielle
Opérations sur les réels : comme sur les entiers sauf pour la division.
1/3 # précision finie d’une quinzaine de décimales

Type booléen
type(3>5) bool
Deux valeurs possibles :
True False
Opérations sur les booléens :
- opérateurs logiques
not and or
- opérateurs de comparaison
== # égal à
!= # différent de
< > <= >= # relation d’ordre
Type complexe : la partie imaginaire est suffixée par j
type(5+3j) complex
(3+4j).real # real est un attribut du complexe (sa partie réelle)
(3+4j).imag
(3+4j).conjugate() # conjugate est une méthode de l’objet de type (ou de classe) complex
abs(3+4j) # la fonction abs calcule le module du complexe
Type chaine de caractère : une chaine de caractères s’écrit entre guillemets 'chaine' ou "chaine"
type("chaine") str
Opérations élémentaires :
len("chaine de caractères") 20
"chaine "+"de "+"caractères" "chaine de caractères" # concaténation
Extraction de caractères (ils sont numérotés à partir de zéro) :
"chaine de caractères"[2] 'a'
"chaine de caractères"[2:4] 'ai'
"chaine de caractères"[-1] 's' # on compte à l’envers
b) Types de conteneurs
Type n-uplet (tuple en anglais) : Il s’agit d’une suite d’éléments de types quelconques encadrés par ()
type((1,3,'a')) tuple
() (1,) (5,3)
Un tuple est non mutable, les opérations possibles sont limitées à :
t=(1,’a’,False)
t[0] t[-1] # accès aux éléments
t[2:3] t[1:3] # extraction de sous-tuples
len(t)
t+t # concaténation

Type liste : Il s’agit d’une suite d’éléments de types quelconques encadrés par []
type([True,5,4,5]) list
Une liste est un objet mutable, on peut en modifier le nombre et la valeur de ses éléments.
Opérations sur les listes :
L=[12.0,"aa",2,3,5] # affectation
len(L)
L[0] L[1:3] # accès aux éléments et extraction de sous-listes
L+[True,"bon"] # concaténation
L.append(50) # insère 50 à la fin de la liste L, L est modifiée
L.insert(2, 60) # insère 60 en position 2 à la liste L, L est modifiée
L.pop(3) # renvoie L[3] et le supprime dans L, L est modifiée
del(L[0:3]) # supprime la tranche d’éléments d’index de 0 à 2, L est modifiée
G=L.copy() # copie la liste L et l'affecte à G
L[i]=x # l'élément d'indice i est remplacé par x, L est modifié
L[i:j+1]=t # la tranche d'éléments d'indice i à j est remplacée par t, L est modifiée
L[i:j+1] # construit une nouvelle liste avec les éléments d'indice compris entre i et j
L.count(x) # compte le nombre d'occurrences de x dans L
L.reverse() # renverse L en place, L est modifiée
Type ensemble : Il s’agit d’un ensemble d’éléments de types quelconques encadrés par {}
type({2,'a',9}) set
Par définition il n’y a pas deux éléments identiques dans un ensemble ! Opérations sur les ensembles :
s={1,2,3,4}
len(s) # cardinal de s
s.add(x) # insère la valeur de x en modifiant s
s.remove(x) # supprime la valeur de x en modifiant s
3 in s # test d'appartenance
s.union({7,8},{'a','b'}) # retourne un nouvel ensemble réunion de s et des arguments
s.intersection({1,5},{1,8}) # retourne un nouvel ensemble intersection de s et des arguments
s.copy() # construit un nouvel ensemble contenant les mêmes éléments que s
Type tableau numpy (numpy.ndarray)
On peut construire des tableaux à partir de listes Python avec numpy.array :
import numpy as np
type(np.array([1,2,3]) np.ndarray
Les objets sont convertis en un type commun, tous les éléments sont de même type.
a=np.array([1,2.0,3]) array([1.,2.,3.])
len(a) 3
Un tableau numpy est un objet mutable.
a[1]=6
a array([1.,6.,3.])
Outils de construction de tableaux :
a=np. arange(1,3)
a array([1,2,3])
np.arange(1,10,2) array([1,3,5,7,9]) # construit un tableau d'entiers entre 1 et 9
# de pas 2
np.linspace(0,1,5) array([0, 0.25, 0.5, 0.75, 1. ]) # construit un tableau de 5 points répartis
# uniformément entre 0 et 1

Outils de construction de matrices :
a=np.ones((2,3)) array([[ 1., 1., 1.],
[ 1., 1., 1.]]) # construit une matrice de 1 de taille 2-3
b=np.zeros((2,3)) array([[ 0., 0., 0.],
[ 0., 0., 0.]]) # construit un tableau de 0 de taille 2-3
Calculs sur les tableaux :
t=np.linspace(0,1,50)
C=np.cos(t) # calcule un tableau dont les éléments sont les cosinus des éléments de t
S=np.sin(t)
Différences entre tableau numpy et liste python :
• Tous les éléments d’un tableau numpy sont de même type, ce n’est pas nécessaire pour une liste.
• + est l’opérateur de concaténation sur deux listes (pas nécessairement de même dimension), c’est un
opérateur d’addition des éléments qui se correspondent sur deux tableaux numpy de même dimension.
• On peut effectuer directement la transformation de tous les éléments d’un tableau numpy par une fonction
numpy sans passer par une affectation sur chaque élément dans une boucle (cf dernier exemple). Cela
simplifie beaucoup l’écriture des calculs sur les tableaux (vecteurs, matrices).
• On peut extraire un élément d’une matrice
,
i j
M
par M[i,j] ou M[i][j] pour un tableau numpy, mais seulement
par M[i][j] pour une liste.
• L’affichage d’un tableau numpy représentant une matrice est plus lisible que celui de la liste correspondante.
3. Conversion de type
float(2) float('1.2')
int(2.1) int('256')
str(2) bool('True')
list('Bonjour') list((1,5,True)) tuple([1,5,2])
Tableau_numpy=numpy.array([2,3,5])
list(Tableau_numpy)
4. Variables et affectation
Une variable est un nom associé à l'adresse mémoire d'une donnée. Exemple :
25
←
donnée
a ----------> 01100101
variable
ր
տ
adresse
Lors d’une affectation variable=valeur, on associe à la variable l’adresse de la valeur.
a=12
b=a
a=13
print(a)
print(b)
Un objet de type simple est non mutable. Une deuxième affectation fait pointer la variable vers une autre
adresse.
Les tuples et les chaines sont également des objets non mutables : on ne peut pas changer la valeur d’un élément
d’un tuple ou d’une chaine (ne supportent pas l’affectation).
Par contre les listes, les ensembles, les tableaux numpy sont mutables.
Affectation multiple, échange de variables :
x,y=10,11
x,y=y,x

5. Instructions conditionnelles
La structure d’une instruction conditionnelle est la suivante :
if condition1 :
instructions1
elif condition2 :
instructions2
else :
instructions3
6. Boucles inconditionnelles
Une boucle inconditionnelle est un bloc d’instructions répétées un nombre déterminé de fois. Exemples :
for element in range(i,j,h) : # element prend toutes les valeurs entières entre i et j avec un pas h
instructions
for element in conteneur : # element prend toutes les valeurs dans un conteneur
instructions # conteneur peut être une chaine, un tuple, une liste, un ensemble…
7. Boucles conditionnelles
La structure d’une boucle conditionnelle est :
while condition :
instructions
Exemple :
a=0
while a<7 :
a=a+1
print(a)
8. Fonctions ou procédures
La structure d’une fonction ou procédure est la suivante :
def <nom>(arg1,arg2,...) :
instructions
Exemple :
def f(x) :
if x>0 :
return x+3
else :
None
On peut aussi utiliser la mini syntaxe sur une ligne avec le mot clé lambda :
f=lambda a,b,c : a+10*b+10*10*c