Cours Python 1
Cours Python 1
Cours Python 1
1
Présentation de Python
Développé en 1989 par Guido van
RossumOpen sourcePortable (Windows,
linux Mac OS)Orienté
objetDynamiqueExtensibleSupport pour
l'intégration d'autre langage
2
Présentation de Python
Présentation de Python
Il existe 2 techniques pour effectuer la
traduction en langage machine mon code
source:
Interprétation: inconvénient lent!!!
Compilation: Rapide, inconvénient compilation
3
Présentation de Python
4
Présentation de Python
Que peut-on faire avec Python?
Web:
Django, Zope, Plone,...
Bases de données:
MySQL, PostgrSQL,Oracle,...
Gui:
Gtk+,Qt, Tcl/Tk, WxWidgets…
Représentation graphique:
gnuplot,matplotlib,VTK
Calcul scientifique:
numpy, scipy, sage,... 5
Présentation de Python
Pourquoi Python pour le calcul ?
Peut être appris en quelques jours
Permet de faire des tests rapides
Alternative à Matlab, Octave, Scilab
Parallélisation
Multiplateforme
Facilement interfaçable avec des
librairies(Fortran, C/C++) de calcul
scientifique
6
Les types et les opérations de
base
Entiers(32 bits)
Entiers longs
Réels (64 bits)
Complexe: 3+4j, ou 3+5J
Booléens ( True, False)
7
Les types et les opérations
de base
Affectation:
>>> i=3 # i vaut 3
>>>a, pi=True,
>>>k=r=2.15
Affichage dans l'interpréteur
>>> I
3
>>> print (i)
8
Les types et opérations de
base
Opérateurs +,-,*,/,%,//
Puissance **
Comparaison: ==, is, !=, is not, >,<,>=,<=
Opérateurs bitwise: & ,|,<<,>>
Opérateurs logique: or,and, not
9
Les types et les opérations
de base
Les listes
Initialisation: [ ],list(),[1, 2,3,4], ['point','triangle',6],
range(10), range(2,10,2) Concaténation
In [18]: sept_zeros=[0]*7;sept_zeros
Out[18]: [0, 0, 0, 0, 0, 0, 0]
In [20]: L1,L2=[1,2,3],[4,5]
In [21]: L1+L2
Out[21]: [1, 2, 3, 4, 5]
Une liste est une séquence comme pour une chaîne de
caractère
10
Les types et les opérations de base
ATTENTION !!!!!
In [22]: L=['Dans','python','tout','est','objet’]
In [23]: T=L
In [24]: T[4] ='bon’
In [25]: T
Out[25]: ['Dans', 'python', 'tout', 'est', 'bon’]
In [26]: L
Out[26]: ['Dans', 'python', 'tout', 'est','bon’]
In [27]: L=T[:]
In [28]: L[4]='objet’
In [29]: T;L
Out[29]: ['Dans', 'python', 'tout', 'est', 'bon’]
Out[29]: ['Dans', 'python', 'tout', 'est', 'objet'] 11
Les types et les opérations de base
Une liste à ses propres méthodes help(list)
len(L) : taille de la liste
L.sort() : trier la liste
L.append() ajout element en fin de,liste
L.reverse(): inversion de la liste
L.index() recher elt dans L
L.remove(): retirer element
L.pop() ajout en fin de liste
12
Les types et les opérations
de base
Les tuples
Initialisation:(),tuple(),(1,) 'a','b','c’, ('a','b','c’)
Concaténation
>>>(1,2)*3
>>> (1,2,1,2,1,2)
In [1]: t1,t2=(1,2,3),(4,5)
In [2]: t1+t2
Out[2]: (1, 2, 3, 4, 5)
Un tuple est aussi une séquence.
13
Les types et les opérations de base
Opération sur un tuple
Un tuple n'est pas modifiable
In [3]: t='a','b','c','d’
In [4]: t[0]='alpha’
TypeError Traceback (most recent call last)
TypeError: 'tuple' object does not support item assignment
In [6]: t=('alpha',)+t[1:]
In [7]: t
Out[7]: ('alpha', 'b', 'c', 'd’)
Mais un objet modifiable dans un tuple peut l'être
In[8]: t=(1,2,[3,4],6)
In[9]:t[2][0]=1;t
Out[9]: (1,2,[1,4],6) 14
Les types ete les opérations de base
Les dictionnaires:
Initialisation {}, dict(), {'point':1,'ligne’:2}
Un dictionnaire est constitué de clés et de valeurs
Pas de concaténation possible
Ajout d une clé ou modif d'une valeur
>>> dic['triangle’]=3
>>> dic
{'ligne': 2, 'triangle': 3, 'point': 1}
>>> dic['point’]=3
{'ligne': 2, 'triangle': 3, 'point': 3}
15
Les types et ls opérations de base
Dictionnaire a ses propres méthodes:
len(dic): taille du dictionnaire
Dico.keys renvoie les clés
Dic.value renvoie les valeurs
Dic.has_key renvoie True si clé presente
Dic.get donne valeur de la clé si elle existe
sinon une valeur par défaut
16
Structure de contrôle
Structure if
a = 200
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
17
L’iNDENTATION:
Python s'appuie sur l'indentation (espace
blanc au début d'une ligne) pour
RECONNAITRE les blocs dans le code.
D'autres langages de programmation
utilisent souvent des accolades à cette fin.
18
Exemple
l’instruction “if”, sans indentation (générera
une erreur):
a = 33
b = 200
if b> a:
print ("b is greater than a") # vous obtiendrez
une erreur
19
Elif :
Le mot-clé elif est une façon python de dire "si
les conditions précédentes n'étaient pas vraies,
alors essayez cette condition".
Exemple:
a = 33
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
20
Else: Le mot-clé else attrape tout ce qui n'est pas
intercepté par les conditions précédentes.
Example:
a = 200
b = 33
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
21
Vous pouvez également avoir un else sans
elif: Exemple
a = 200
b = 33
if b > a:
print("b is greater than a")
else:
print("b is not greater than a")
22
Si vous n'avez qu'une seule instruction à
exécuter, vous pouvez la placer sur la
même ligne que l'instruction if.
Exemple:
if a > b: print("a is greater than b")
23
Si vous n'avez qu'une seule instruction à
exécuter, une pour if et une pour else, vous
pouvez tout mettre sur la même ligne:
Exemple:
a = 2
b = 330
print("A") if a > b else print("B")
24
Vous pouvez également avoir plusieurs instructions
else sur la même ligne.
Exemple:
a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")
25
Structure iterative: while
Avec la boucle while, nous pouvons
exécuter un ensemble d'instructions tant
qu'une condition est vraie.
Exemple: afficher i tant que i est inférieur à
6:
i=1
while i < 6:
print(i)
i += 1
26
La boucle while nécessite que les
variables pertinentes soient prêtes, dans
cet exemple, nous devons définir une
variable d'indexation, i, que nous
initialisons à 1.
27
L’instruction break:
Avec l'instruction break, nous pouvons arrêter la
boucle même si la condition while est vraie:
Exemple Quittez la boucle lorsque i est 3:
i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1
28
L’instruction continue:
Avec l'instruction continue, nous pouvons arrêter
l'itération en cours et continuer avec la suivante:
Exemple Passez à l'itération suivante si i vaut 3:
i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)
29
L’instruction else:
Avec l'instruction else, nous pouvons exécuter
un bloc de code une fois lorsque la condition
n'est plus vraie: Exemple Afficher un message
une fois que la condition est fausse:
i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")
30
Structure repetitive: boucle for
Une boucle « for » est utilisée pour itérer
sur une séquence (c'est-à-dire une liste, un
tuple, un dictionnaire, un ensemble ou une
chaîne).
Cela ressemble moins au mot-clé « for »
dans d'autres langages de programmation,
et fonctionne plus comme une méthode
d'itération que l'on trouve dans d'autres
langages de programmation orientés objet.
31
Avec la boucle for, nous pouvons exécuter
un ensemble d'instructions, une fois pour
chaque élément d'une liste, d'un tuple, d'un
ensemble, etc.
Exemple: Afficher chaque fruit dans une
liste de fruits.
fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
32
La boucle for ne nécessite pas de variable
d'indexation à définir au préalable.
Boucle sur une chaîne:
Même les chaînes sont des objets itérables,
elles contiennent une séquence de
caractères:
Exemple Parcourez les lettres du mot
«banane»:
for x in "banana":
print(x)
33
L’instruction break:
Avec l'instruction break, nous pouvons
arrêter la boucle avant qu'elle n'ait parcouru
tous les éléments: Exemple Quittez la
boucle lorsque x est "banane":
fruits = ["apple", "banana", "cherry"]
for x in fruits:
print(x)
if x == "banana":
break
34
Exemple: Quittez la boucle lorsque x est
"banana", mais cette fois la pause vient
avant l’affichage:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
if x == "banana":
break
print(x)
35
L’instructon continue :
Avec l'instruction continue, nous pouvons
arrêter l'itération actuelle de la boucle et
continuer avec la suivante:
Exemple: N’afficher pas “banana”:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
if x == "banana":
continue
print(x)
36
La fonction range ():
Pour parcourir un ensemble de code un
certain nombre de fois, nous pouvons
utiliser la fonction range (), La fonction
range () renvoie une séquence de
nombres, commençant par 0 par défaut et
incrémentée de 1 (par défaut), et se
termine à un nombre spécifié.
37
Example
Utiliser la fonction range() :
for x in range(6):
print(x)
Notez que range (6) ne correspond pas aux
valeurs de 0 à 6, mais aux valeurs de 0 à 5.
La fonction range () par défaut à 0 comme
valeur de départ, cependant il est possible
de spécifier la valeur de départ en ajoutant
un paramètre: range (2, 6), ce qui signifie
des valeurs de 2 à 6 (mais pas 6):
38
Exemple:
Utilisation du paramètre de démarrage:
for x in range(2, 6):
print(x)
40
for x in range(6):
print(x)
else:
print("Finally finished!")
41
Exemple: Sortez de la boucle lorsque x vaut
3 et voyez ce qui se passe avec le bloc else:
for x in range(6):
if x == 3: break
print(x)
else:
print("Finally finished!")
42
Boucles imbriquées
Une boucle imbriquée est une boucle à
l'intérieur d'une boucle. La "boucle interne"
sera exécutée une fois pour chaque itération
de la "boucle externe": Exemple Affichez
chaque adjectif pour chaque fruit:
adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]
for x in adj:
for y in fruits:
print(x, y)
43
Fonction python
Une fonction est un bloc de code qui ne
s'exécute que lorsqu'elle est appelée.
Vous pouvez transmettre des données,
appelées paramètres, à une fonction. Une
fonction peut renvoyer des données en
conséquence.
44
Créer une fonction En Python:
une fonction est définie à l'aide du mot-clé
def: Exemple
def my_function():
print("Hello from a function")
my_function() 45
Arguments :
Les informations peuvent être transmises
aux fonctions en tant qu'arguments. Les
arguments sont spécifiés après le nom de
la fonction, entre parenthèses. Vous
pouvez ajouter autant d'arguments que
vous le souhaitez, séparez-les simplement
par une virgule. L'exemple suivant a une
fonction avec un argument (fname).
Lorsque la fonction est appelée, nous
transmettons un prénom, qui est utilisé à
l'intérieur de la fonction pour afficher le nom
complet: Exemple 46
def my_function(fname):
print(fname + " Refsnes")
my_function("Emil")
my_function("Tobias")
my_function("Linus")
47
Nombre d'arguments
Par défaut, une fonction doit être appelée
avec le nombre correct d'arguments. Cela
signifie que si votre fonction attend 2
arguments, vous devez appeler la fonction
avec 2 arguments, pas plus, ni moins.
48
Exemple Cette fonction attend 2
arguments et obtient 2 arguments:
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil", "Refsnes")
49
Si vous essayez d'appeler la fonction avec
1 ou 3 arguments, vous obtiendrez une
erreur: Exemple Cette fonction attend 2
arguments, mais n'en obtient que 1:
def my_function(fname, lname):
print(fname + " " + lname)
my_function("Emil")
50
Nombre arbitraire d’Arguments, *
args
Si vous ne savez pas combien d'arguments
seront passés à votre fonction, ajoutez un *
avant le nom du paramètre dans la
définition de la fonction. De cette façon, la
fonction recevra un tuple d'arguments et
pourra accéder aux éléments en
conséquence: Exemple Si le nombre
d'arguments est inconnu, ajoutez un * avant
le nom du paramètre:
51
def my_function(*kids):
print("The youngest child is " + kids[2])
my_function("Emil", "Tobias", "Linus")
52
Les arguments arbitraires sont souvent
raccourcis en * args dans les
documentations Python.
Vous pouvez également envoyer des
arguments avec la syntaxe
clé = valeur.
53
Exemple:
def my_function(child3, child2, child1):
print("The youngest child is " + child3)
54
Nombre arbitraire d’Arguments
clés, ** kwargs
Si vous ne savez pas combien d'arguments
clés seront passés à votre fonction, ajoutez
deux astérisques: ** avant le nom du
paramètre dans la définition de la fonction. De
cette façon, la fonction recevra un dictionnaire
d'arguments et pourra accéder aux éléments
en conséquence:
55
Exemple Si le nombre d'arguments clés est
inconnu, ajoutez un double ** avant le nom du
paramètre:
def my_function(**kid):
print("His last name is " + kid["lname"])
56
Valeur de paramètre par défaut
L'exemple suivant montre comment utiliser
une valeur de paramètre par défaut. Si
nous appelons la fonction sans argument,
elle utilise la valeur par défaut:
57
Exemple
def my_function(country = "Norway"):
print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
58
Passer une liste comme
argument
Vous pouvez envoyer n'importe quel type
d'argument de données à une fonction
(chaîne, nombre, liste, dictionnaire, etc.), et
il sera traité comme le même type de
données à l'intérieur de la fonction. Par
exemple. si vous envoyez une liste en
argument, ce sera toujours une liste
lorsqu'elle atteindra la fonction
59
Exemple:
def my_function(food):
for x in food:
print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)
60
Valeurs de retour
Pour laisser une fonction renvoyer une valeur,
utilisez l'instruction return:
Exemple:
def my_function(x):
return 5 * x
print(my_function(3))
print(my_function(5))
print(my_function(9))
61
récursivité
Python accepte également la récursivité des
fonctions, ce qui signifie qu'une fonction
définie peut s'appeler elle-même. La
récursivité est un concept mathématique et de
programmation courant. Cela signifie qu'une
fonction s'appelle elle-même. Cela a
l'avantage de signifier que vous pouvez
parcourir les données pour atteindre un
résultat..
62
Le développeur doit être très prudent avec
la récursivité car il peut être assez facile
de glisser dans l'écriture d'une fonction qui
ne se termine jamais, ou qui utilise des
quantités excessives de mémoire ou de
puissance de processeur. Cependant,
lorsqu'elle est écrite correctement, la
récursivité peut être une approche très
efficace et mathématiquement élégante de
la programmation.
63
Dans cet exemple, somme_recursive ()
est une fonction que nous avons définie
pour s'appeler elle-même. Nous utilisons
la variable n comme données, qui
décrémente (-1) après chaque étape. La
récursivité se termine lorsque la condition
n'est pas supérieure à 0 (c'est-à-dire
lorsqu'elle vaut 0).
64
Pour un nouveau développeur, cela peut
prendre un certain temps pour
comprendre comment cela fonctionne
exactement, le meilleur moyen de le
savoir est de le tester et de le modifier.
65
Exemple:
def somme_recursive(n):
if(n > 0):
resultat = n + somme_recursive(n - 1)
print(resultat)
else:
resultat = 0
return resultat
67
Syntaxe:
lambda arguments : expression
L'expression est exécutée et le résultat
est retourné:
Exemple
Ajoutez 10 à l'argument a et renvoyez le
résultat:
x = lambda a : a + 10
print(x(5))
68
Les fonctions Lambda peuvent accepter
n'importe quel nombre d'arguments:
Exemple
Multipliez l'argument a par l'argument b et
renvoyez le résultat:
x = lambda a, b : a * b
print(x(5, 6))
Exemple
def myfunc(n):
return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))
71
Classes et objets Python
73
Créer un objet
Nous pouvons maintenant utiliser la classe
nommée MyClass pour créer des objets:
Exemple
Créez un objet nommé p1 et affichez la
valeur de x:
p1 = MyClass()
print(p1.x)
74
La fonction __init __ ()
Les exemples ci-dessus sont des classes
et des objets dans leur forme la plus
simple et ne sont pas vraiment utiles dans
les applications réelles.
75
Toutes les classes ont une fonction appelée
__init __ (), qui est toujours exécutée
lorsque la classe est lancée.
76
Exemple
Créez une classe nommée Person,
utilisez la fonction __init __ () pour
attribuer des valeurs pour le nom et l'âge:
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p1 = Person("John", 36)
print(p1.name)
print(p1.age) 77
Remarque: Le paramètre self est une
référence à l'instance actuelle de la classe
et est utilisé pour accéder aux variables
appartenant à la classe.
78
Exemple:
Utilisez les mots nomobjet et abc au lieu de
self:
class Person:
def __init__(nomobject, name, age):
nomobject.name = name
nomobject.age = age
def myfunc(abc):
print("Hello my name is " + abc.name)
p1 = Person("John", 36)
p1.myfunc() 79
Modifier les propriétés de l'objet
Exemple
Définissez l'âge de p1 sur 40:
p1.age = 40
80
Supprimer les propriétés de
l'objet
Vous pouvez supprimer les propriétés des
objets à l'aide du mot-clé del:
Exemple
Supprimez la propriété age de l'objet p1:
del p1.age
81
Supprimer des objets
Exemple
Supprimez l'objet p1:
del p1
82
Héritage
L'héritage nous permet de définir une classe qui
hérite de toutes les méthodes et propriétés d'une
autre classe.
83
Créer une classe parent
N'importe quelle classe peut être une classe
parente, donc la syntaxe est la même que
pour créer n'importe quelle autre classe:
Exemple
Créez une classe nommée Person, avec les
propriétés firstname et lastname, et une
méthode printname:
84
class Person:
def __init__(self, fname, lname):
self.firstname = fname
self.lastname = lname
def printname(self):
print(self.firstname, self.lastname)
x = Person("John", "Doe")
x.printname() 85
Créer une classe enfant
Pour créer une classe qui hérite de la
fonctionnalité d'une autre classe, envoyez la
classe parente en tant que paramètre lors de
la création de la classe enfant:
Exemple
Créez une classe nommée Student, qui
héritera des propriétés et méthodes de la
classe Person:
86
class Student(Person):
pass
87
Exemple
Utilisez la classe Student pour créer un
objet, puis exécutez la méthode printname:
x = Student("Mike", "Olsen")
x.printname()
88
Ajouter la fonction __init __ ()
Jusqu'à présent, nous avons créé une
classe enfant qui hérite des propriétés et des
méthodes de son parent.
90
Lorsque vous ajoutez la fonction __init __ (),
la classe enfant n'héritera plus de la fonction
__init __ () du parent.
92
Utilisez la fonction super ()
Python a également une fonction super () qui
fera en sorte que la classe enfant hérite de
toutes les méthodes et propriétés de son
parent:
Exemple:
class Student(Person):
def __init__(self, fname, lname):
super().__init__(fname, lname)
93
En utilisant la fonction super (), vous n'avez pas à
utiliser le nom de l'élément parent, il héritera
automatiquement des méthodes et propriétés de son
parent.
Exemple
Ajoutez un paramètre d'année et passez
l'année correcte lors de la création d'objets:
95
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
x = Student("Mike", "Olsen", 2019)
96
Ajouter des méthodes
Exemple
Ajoutez une méthode appelée bienvenue dans la
classe Student:
class Student(Person):
def __init__(self, fname, lname, year):
super().__init__(fname, lname)
self.graduationyear = year
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to
the class of” , self.graduationyear)
97
Si vous ajoutez une méthode dans la
classe enfant avec le même nom qu'une
fonction de la classe parent, l'héritage de la
méthode parent sera remplacé.
98