Python

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

  Et Python ???

 Avantages:Interpréteur permettant de
tester n'importe quel petit bout de code
 Compilation transparente
 Inconvénients:Peut être lent

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)

La fonction range () incrémente par défaut la

séquence de 1, mais il est possible de
spécifier la valeur d'incrément en ajoutant un
troisième paramètre: range (2, 30, 3):
Exemple Incrémentez la séquence de 3 (la
valeur par défaut est 1):
39
 for x in range(2, 30, 3):
  print(x)

 Else dans la boucle For :

 Le mot clé else dans une boucle for spécifie
un bloc de code à exécuter lorsque la
boucle est terminée: Exemple afficher tous
les nombres de 0 à 5 et aficcher un
message lorsque la boucle est terminée:

40
 for x in range(6):
  print(x)
else:
  print("Finally finished!")

 Remarque: Le bloc else ne sera PAS

exécuté si la boucle est arrêtée par une
instruction break.

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") 

 Pour appeler une fonction, utilisez le nom de

la fonction suivi de parenthèses: 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.

 De cette façon, l'ordre des arguments n'a

pas d'importance.

53
 Exemple:
 def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2

= "Tobias", child3 = "Linus")

 L’expression Arguments clés est souvent

abrégée en kwargs dans les
documentations Python.

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"])

my_function(fname = "Tobias", lname = "Refsnes")

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

print("\n\n Resultas Exemple Recursivite ")

somme_recursive(6)
66