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
 Python Lambda
 Une fonction lambda est une petite fonction
anonyme.

 Une fonction lambda peut prendre n'importe

quel nombre d'arguments, mais ne peut
avoir qu'une seule expression.

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 :Additionner les arguments a, b et c et

renvoyez le résultat:
 x = lambda a, b, c : a + b + c
print(x(5, 6, 2)) 69
Pourquoi utiliser les fonctions
Lambda?
 La puissance des fonctions lambda est
mieux exploitée lorsque vous les utilisez
comme fonction anonyme dans une autre
fonction.
 Supposons que vous ayez une définition de
fonction qui prend un argument, et cet
argument sera multiplié par un nombre
inconnu:
 def myfunc(n):
  return lambda a : a * n
70
 Utilisez cette définition de fonction pour
créer une fonction qui double toujours le
nombre que vous envoyez:

 Exemple
 def myfunc(n):
  return lambda a : a * n

mydoubler = myfunc(2)

print(mydoubler(11))
71
Classes et objets Python

 Python est un langage de programmation

orienté objet.

 Presque tout en Python est un objet, avec

ses propriétés et ses méthodes.

 Une classe est comme un constructeur

d'objet, ou un "plan" pour créer des objets.
72
 Créer une classe
 Pour créer une classe, utilisez le mot clé
class:
 Exemple
 Créez une classe nommée MyClass, avec
une propriété nommée x:
 class MyClass:
  x = 5

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.

 Pour comprendre la signification des

classes, nous devons comprendre la
fonction intégrée __init __ ().

75
 Toutes les classes ont une fonction appelée
__init __ (), qui est toujours exécutée
lorsque la classe est lancée.

 Utilisez la fonction __init __ () pour attribuer

des valeurs aux propriétés de l'objet ou à
d'autres opérations nécessaires lors de la
création de l'objet:

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.

 Il n'a pas besoin d'être nommé self, vous

pouvez l'appeler comme vous le souhaitez,
mais il doit être le premier paramètre de
toute fonction de 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

 Vous pouvez modifier les propriétés

d'objets comme celui-ci:

 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

 Vous pouvez supprimer des objets en

utilisant le mot-clé del:

 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.

 La classe parente est la classe héritée,

également appelée classe de base.

 La classe enfant est la classe qui hérite d'une

autre classe, également appelée classe dérivée.

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)

#Use the Person class to create an object,

and then execute the printname method:

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

 Remarque: utilisez le mot-clé pass lorsque

vous ne souhaitez pas ajouter d'autres
propriétés ou méthodes à la classe.

 Désormais, la classe Student a les mêmes

propriétés et méthodes que la classe
Person.

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.

 Nous voulons ajouter la fonction __init __ ()

à la classe enfant (au lieu du mot-clé pass).

 Remarque: La fonction __init __ () est

appelée automatiquement chaque fois que la
classe est utilisée pour créer un nouvel objet
89
 Exemple
 Ajoutez la fonction __init __ () à la classe
Student:
 class Student(Person):
  def __init__(self, fname, lname):
    #add properties etc.

90
 Lorsque vous ajoutez la fonction __init __ (),
la classe enfant n'héritera plus de la fonction
__init __ () du parent.

 Remarque: la fonction __init __ () de l'enfant

remplace l'héritage de la fonction __init __ ()
du parent.

 Pour conserver l'héritage de la fonction __init

__ () du parent, ajoutez un appel à la fonction
__init __ () du parent:
91
 Exemple:
 class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

 Nous avons maintenant ajouté avec succès la

fonction __init __ (), et conservé l'héritage de la
classe parente, et nous sommes prêts à ajouter
des fonctionnalités dans la fonction __init __ ().

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.

 Ajouter des propriétés:

Exemple
 Ajoutez une propriété appelée graduationyear à la
classe Student:
 class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)
    self.graduationyear = 2019 94
 Dans l'exemple ci-dessous, l'année 2019
doit être une variable et passée dans la
classe Student lors de la création d'objets
Student. Pour ce faire, ajoutez un autre
paramètre dans la fonction __init __ ():

 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
  Modules Python

 Qu'est-ce qu'un module?

 Considérez qu'un module est identique à
une bibliothèque de codes.

 Un fichier contenant un ensemble de

fonctions que vous souhaitez inclure dans
votre application.

99
Créer un module
 Pour créer un module, enregistrez
simplement le code souhaité dans un
fichier avec l'extension de fichier .py:

 Exemple
 Enregistrez ce code dans un fichier nommé
mymodule.py

 def greeting(name):
  print("Hello, " + name) 100
 Utiliser un module
 Nous pouvons maintenant utiliser le module
que nous venons de créer, en utilisant
l'instruction import:
 Exemple
 Importez le module nommé mymodule et
appelez la fonction de salutation:

 import mymodule

 mymodule.greeting("Jonathan") 101
 Variables dans le module

 Le module peut contenir des fonctions,

comme déjà décrit, mais aussi des
variables de tous types (tableaux,
dictionnaires, objets etc):

 Exemple
 Enregistrez ce code dans le fichier
mymodule.py

102
 person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
}
 Exemple
 Importez le module nommé mymodule et
accédez au dictionnaire person1:
 import mymodule

a = mymodule.person1["age"]
print(a) 103
 Nommer un module:
 Vous pouvez nommer le fichier du module
comme vous le souhaitez, mais il doit
avoir l'extension de fichier .py

 Renommer un module:
 Vous pouvez créer un alias lorsque vous
importez un module, en utilisant le mot-clé
as:

104
 Exemple
 Créez un alias pour mymodule appelé mx:
 import mymodule as mx

a = mx.person1["age"]
print(a)

105
Modules intégrés
 Il existe plusieurs modules intégrés dans
Python, que vous pouvez importer quand
vous le souhaitez.
 Exemple
 Importez et utilisez le module de plateforme:
 import platform

x = platform.system()
print(x)
106
Utilisation de la fonction dir ()
 Il existe une fonction intégrée pour lister tous
les noms de fonctions (ou noms de
variables) dans un module. La fonction dir ():

 Exemple:
 Répertoriez tous les noms définis
appartenant au module de la plateforme:
 import platform

x = dir(platform)
print(x) 107
Importer depuis le module
 Vous pouvez choisir d'importer
uniquement les pièces d'un module, en
utilisant le mot-clé from.
 Exemple
 Le module nommé mymodule a une
fonction et un dictionnaire:

108
 def greeting(name):
  print("Hello, " + name)

person1 = {
  "name": "John",
  "age": 36,
  "country": "Norway"
}

109
 Exemple
 Importez uniquement le dictionnaire
person1 du module:
 from mymodule import person1

print (person1["age"])

110
Fonctions mathématiques
intégrées

 Les fonctions min () et max () peuvent être

utilisées pour trouver la valeur la plus basse
ou la plus élevée dans un itérable:
 Exemple
 x = min(5, 10, 25)
y = max(5, 10, 25)

print(x)
print(y) 111
 La fonction abs () renvoie la valeur absolue
(positive) du nombre spécifié:
 Exemple:
 x = abs(-7.25)
print(x)
 La fonction pow (x, y) renvoie la valeur de x à la
puissance de y.
 Exemple
 Renvoie la valeur de 4 à la puissance de 3
(identique à 4 * 4 * 4):
 x = pow(4, 3)

112
Le module math

 Python a également un module intégré

appelé math, qui étend la liste des
fonctions mathématiques.
 Pour l'utiliser, vous devez importer le
module mathématique:

113
 Import math
 Lorsque vous avez importé le module math,
vous pouvez commencer à utiliser les
méthodes et les constantes du module.

 La méthode math.sqrt () par exemple,

retourne la racine carrée d'un nombre:
 import math

x = math.sqrt(64)
print(x)
114
 La méthode math.ceil () arrondit un reel vers
le haut à son entier le plus proche, et la
méthode math.floor () arrondit un reel vers le
bas à son entier le plus proche, et renvoie le
résultat:
 Exemple
 import math

x = math.ceil(1.4)
y = math.floor(1.4)

print(x) # returns 2
print(y) # returns 1 115
 La constante math.pi, renvoie la valeur de
PI (3.14 ...):

 Exemple:
 import math

x = math.pi

print(x)

116
 JSON Python
 JSON est une syntaxe de stockage et d'échange de
données.
 JSON est du texte, écrit avec la notation d'objet
JavaScript.
 JSON en Python:
 Python a un package intégré appelé json, qui peut
être utilisé pour travailler avec des données JSON.
 Exemple
 Importez le module json:
 import json

117
JSON - Convertir JSON en
Python
 Si vous avez une chaîne JSON, vous
pouvez l'analyser à l'aide de la méthode
json.loads ().
 Le résultat sera un dictionnaire Python.
 Exemple
 Convertir de JSON vers Python:

118
 import json

# some JSON:
x =  '{ "name":"John", "age":30, "city":"New
York"}'

# parse x:
y = json.loads(x)

# the result is a Python dictionary:

print(y["age"])

119
 Convertir de Python vers JSON
 Si vous avez un objet Python, vous pouvez
le convertir en chaîne JSON à l'aide de la
méthode json.dumps ().

 Exemple
 Convertir de Python vers JSON:

120
 import json

# a Python object (dict):
x={
  "name": "John",
  "age": 30,
  "city": "New York"
}

# convert into JSON:

y = json.dumps(x)

# the result is a JSON string:

print(y)

121
 Vous pouvez convertir des objets Python
des types suivants en chaînes JSON:
 dict
 list
 tuple
 string
 int
 float
 True
 False
 None
122
 Exemple
 Convertissez les objets Python en chaînes JSON
et imprimez les valeurs:
 import json
print(json.dumps({"name": "John", "age": 30}))
print(json.dumps(["apple", "bananas"]))
print(json.dumps(("apple", "bananas")))
print(json.dumps("hello"))
print(json.dumps(42))
print(json.dumps(31.76))
print(json.dumps(True))
print(json.dumps(False))
print(json.dumps(None))

123
 Lorsque vous convertissez de Python en
JSON, les objets Python sont convertis en
l'équivalent JSON (JavaScript):

124
Python JSON

dict Object

list Array

tuple Array

str String

int Number

float Number

True true

False false

None null

125
 Exemple
 Convertir un objet Python contenant tous
les types de données légales:

126
 import json

x={
  "name": "John",
  "age": 30,
  "married": True,
  "divorced": False,
  "children": ("Ann","Billy"),
  "pets": None,
  "cars": [
    {"model": "BMW 230", "mpg": 27.5},
    {"model": "Ford Edge", "mpg": 24.1}
 ]
}
print(json.dumps(x))

127
 Formater le résultat
 L'exemple ci-dessus imprime une chaîne
JSON, mais elle n'est pas très facile à lire,
sans retrait ni saut de ligne.

 La méthode json.dumps () a des paramètres

pour faciliter la lecture du résultat:
 Exemple
 Utilisez le paramètre indent pour définir le
nombre de retraits:
 json.dumps(x, indent=4)

128
Vous pouvez également définir les séparateurs, la
valeur par défaut est (", ", ": "), ce qui signifie utilise
une virgule et un espace pour séparer chaque
objet, et un deux-points et un espace pour séparer
les clés des valeurs:
Exemple
Utilisez le paramètre separators pour modifier le
séparateur par défaut:
json.dumps(x, indent=4, separators=(". ", " = "))

129
 ordonnner le résultat

 La méthode json.dumps () a des paramètres

pour ordonner les clés dans le résultat:

 Exemple
 Utilisez le paramètre sort_keys pour
spécifier si le résultat doit être trié ou non:

 json.dumps(x, indent=4, sort_keys=True)

130
 Python RegEx: expression
régulière
 Un RegEx, ou expression régulière, est une
séquence de caractères qui forme un modèle
de recherche.
 RegEx peut être utilisé pour vérifier si une
chaîne contient le modèle de recherche
spécifié.
 Module RegEx
 Python a un package intégré appelé re, qui
peut être utilisé pour travailler avec des
expressions régulières. 131
 Une fois que vous avez importé le module re,
vous pouvez commencer à utiliser des
expressions régulières:

 Exemple
 Recherchez la chaîne pour voir si elle
commence par "The" et se termine par "Spain":
 import re

txt = "The rain in Spain"

x = re.search("^The.*Spain$", txt)

132
 Fonctions RegEx
 Le module re propose un ensemble de
fonctions qui nous permettent de
rechercher une chaîne pour une
correspondance:

133
Function Description

findall Renvoie une liste contenant toutes les correspondances

search Renvoie un objet Match s'il y a une correspondance n'importe où dans

la chaîne

split Renvoie une liste dans laquelle la chaîne a été divisée à chaque
correspondance

sub Remplace une ou plusieurs correspondances par une chaîne

134
Métacaractères

 Les métacaractères sont des caractères

avec une signification particulière:

135
Carateres Description Exemple

[] Un ensemble de caracteres "[a-m]"

\ Signale une séquence spéciale "\d"

. Tout caractere (sauf retour a la ligne) "he..o"

^ Commence par "^hello"

$ Se termine par "world$"

* Au moins une occurence "aix*"

+ Au moins deux occurrences "aix+"

{} Le nombre excat d’occurrences "al{2}"

| Conitent l’un ou l’autre "falls|stays"

() Capture and group   136

Séquences spéciales

 Une séquence spéciale est un \ suivi de

l'un des caractères de la liste ci-dessous et
a une signification particulière:

137
Character Description Example

\A Returns a match if the specified characters are at the beginning of the string "\AThe"

\b Returns a match where the specified characters are at the beginning or at the end of a word r"\bain"
(the "r" in the beginning is making sure that the string is being treated as a "raw string") r"ain\b"

\B Returns a match where the specified characters are present, but NOT at the beginning (or at the r"\Bain"
end) of a word r"ain\B"
(the "r" in the beginning is making sure that the string is being treated as a "raw string")

\d Returns a match where the string contains digits (numbers from 0-9) "\d"

\D Returns a match where the string DOES NOT contain digits "\D"

\s Returns a match where the string contains a white space character "\s"

\S Returns a match where the string DOES NOT contain a white space character "\S"

\w Returns a match where the string contains any word characters (characters from a to Z, digits "\w"
from 0-9, and the underscore _ character)

\W Returns a match where the string DOES NOT contain any word characters "\W"

\Z Returns a match if the specified characters are at the end of the string "Spain\Z"
138
Ensembles

 Un ensemble est un ensemble de

caractères à l'intérieur d'une paire de
crochets [] avec une signification
particulière:

139
Set Description

[arn] Returns a match where one of the specified characters (a, r, or n) are present

[a-n] Returns a match for any lower case character, alphabetically betweena and n

[^arn] Returns a match for any character EXCEPT a, r, and n

[0123] Returns a match where any of the specified digits (0, 1, 2, or 3) are present

[0-9] Returns a match for any digit between 0 and 9

[0-5][0-9] Returns a match for any two-digit numbers from 00 and 59

[a-zA-Z] Returns a match for any character alphabetically between a and z, lower case OR upper case

[+] In sets, +, *, ., |, (), $,{} has no special meaning, so [+]means: return a match for any + character in

the string

140
La fonction findall ()
 La fonction findall () renvoie une liste
contenant toutes les correspondances.
 Exemple
 Afficher une liste de tous les matchs:
 import re

txt = "The rain in Spain"

x = re.findall("ai", txt)
print(x)
141
 La liste contient les correspondances dans
l'ordre où elles sont trouvées.
 Si aucune correspondance n'est trouvée,
une liste vide est renvoyée:
 Exemple
 Renvoie une liste vide si aucune
correspondance n'a été trouvée:
 import re

txt = "The rain in Spain"

x = re.findall("Portugal", txt)
print(x) 142
La fonction search ()
 La fonction search () recherche dans la
chaîne une correspondance et renvoie un
objet Match s'il existe une
correspondance.

 S'il y a plus d'une correspondance, seule

la première occurrence de la
correspondance sera renvoyée:

143
 Exemple
 Recherchez le premier caractère d'espace
blanc dans la chaîne:
 import re

txt = "The rain in Spain"

x = re.search("\s", txt)

print("The first white-space character is

located in position:", x.start())

144
 Si aucune correspondance n'est trouvée, la
valeur None est renvoyée:

 Exemple
 Effectuez une recherche qui ne renvoie
aucune correspondance:
 import re

txt = "The rain in Spain"

x = re.search("Portugal", txt)
print(x)
145
La fonction split ()
 La fonction split () renvoie une liste dans
laquelle la chaîne a été fractionnée à
chaque correspondance:
 Exemple
 Fractionner à chaque caractère d'espace
blanc:
 import re

txt = "The rain in Spain"

x = re.split("\s", txt)
print(x) 146
 Vous pouvez contrôler le nombre
d'occurrences en spécifiant le paramètre
maxsplit:

 Exemple
 Divisez la chaîne uniquement à la
première occurrence:
 import re

txt = "The rain in Spain"

x = re.split("\s", txt, 1)
print(x) 147
La fonction sub ()
 La fonction sub () remplace les
correspondances par le texte de votre choix:
 Exemple
 Remplacez chaque caractère d'espace blanc
par le chiffre 9:
 import re

txt = "The rain in Spain"

x = re.sub("\s", "9", txt)
print(x)

148
 Vous pouvez contrôler le nombre de
remplacements en spécifiant le paramètre
count:

 Exemple
 Remplacez les 2 premières occurrences:
 import re

txt = "The rain in Spain"

x = re.sub("\s", "9", txt, 2)
print(x)
149
Match Object

 Un match objet est un objet contenant des

informations sur la recherche et le résultat.

 Remarque: S'il n'y a pas de

correspondance, la valeur None sera
renvoyée à la place de l'objet Match.

150
 Exemple
 Faites une recherche qui retournera un
objet de correspondance:
 import re

txt = "The rain in Spain"

x = re.search("ai", txt)
print(x) #this will print an object

151
 L'objet Match possède des propriétés et des
méthodes utilisées pour récupérer des
informations sur la recherche et le résultat:

 .span () renvoie un tuple contenant les

positions de début et de fin de la
correspondance.
 .string renvoie la chaîne passée dans la
fonction
 .group () retourne la partie de la chaîne où il
y avait une correspondance
152
 Exemple
 Imprimez la position (position de début et
de fin) de la première occurrence de
correspondance.
 L'expression régulière recherche tous les
mots commençant par un «S» majuscule:
 import re

txt = "The rain in Spain"

x = re.search(r"\bS\w+", txt)
print(x.span())
153
 Exemple
 Imprimez la chaîne passée dans la
fonction:

 import re

txt = "The rain in Spain"

x = re.search(r"\bS\w+", txt)
print(x.string)

154
 Exemple
 Imprimez la partie de la chaîne où il y avait
une correspondance.

 L'expression régulière recherche tous les

mots commençant par un «S» majuscule:
 import re

txt = "The rain in Spain"

x = re.search(r"\bS\w+", txt)
print(x.group()) 155
Gerer les exceptions:
Python Try Except
 Le bloc try vous permet de tester un bloc de
code pour les erreurs.

 Le bloc except vous permet de gérer l'erreur.

 Le bloc finally vous permet d'exécuter du code,

quel que soit le résultat des blocs try et except.

156
 Lorsqu'une erreur se produit, ou une
exception comme nous l'appelons, Python
s'arrête normalement et génère un message
d'erreur.

 Ces exceptions peuvent être gérées à l'aide

de l'instruction try:

157
 Exemple
 Le bloc try générera une exception, car x
n'est pas défini:
 try:
  print(x)
except:
  print("An exception occurred")

158
 Puisque le bloc try déclenche une erreur, le
bloc except sera exécuté.

 Sans le bloc try, le programme plantera et

générera une erreur:

 Exemple
 Cette instruction générera une erreur, car x
n'est pas défini:
 print(x)
159
 Plusieurs exceptions
 Vous pouvez définir autant de blocs
d'exceptions que vous le souhaitez, par ex. si
vous souhaitez exécuter un bloc de code
spécial pour un type d'erreur particulier:

 Exemple
 Imprimez un message si le bloc try
déclenche une NameError et un autre pour
d'autres erreurs:

160
 try:
  print(x)
except NameError:
  print("Variable x is not defined")
except:
  print("Something else went wrong")

161
LE BLOC ELSE

Vous pouvez utiliser le mot-clé else pour définir un bloc

de code à exécuter si aucune erreur n'a été générée:

Exemple
Dans cet exemple, le bloc try ne génère aucune erreur:

162
 try:
  print("Hello")
except:
  print("Something went wrong")
else:
  print("Nothing went wrong")

163
Le bloc Finally
 Le bloc finally, s'il est spécifié, sera exécuté
indépendamment du fait que le bloc try lève une
erreur ou non.
 Exemple
 try:
  print(x)
except:
  print("Something went wrong")
finally:
  print("The 'try except' is finished")

164
 Ceci peut être utile pour fermer des objets et
nettoyer des ressources:
 Exemple
 Essayez d'ouvrir et d'écrire dans un fichier qui n'est
pas accessible en écriture:
 try:
  f = open("demofile.txt")
  f.write("Lorum Ipsum")
except:
  print("Something went wrong when writing to the
file")
finally:
  f.close()
 Le programme peut continuer sans laisser l'objet
fichier ouvert. 165
generer une exception
 En tant que développeur Python, vous
pouvez choisir de generer une exception si
une condition se produit.

 Pour generer (ou lever) une exception,

utilisez le mot clé rise.

 Exemple
 Relevez une erreur et arrêtez le programme
si x est inférieur à 0:
166
 x = -1

if x < 0:
  raise Exception("Sorry, no numbers below
zero")
 Le mot clé rise est utilisé pour déclencher
une exception.

 Vous pouvez définir le type d'erreur à

signaler et le texte à imprimer à l'utilisateur.
167
 Exemple
 Déclenchez un TypeError si x n'est pas un
entier:
 x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allo
wed")

168
Entrée utilisateur Python: Input
 Python permet l'entrée de l'utilisateur.

 Cela signifie que nous pouvons demander à l'utilisateur une entrée.

 La méthode est un peu différente dans Python 3.6 et Python 2.7.

 Python 3.6 utilise la méthode input ().

 Python 2.7 utilise la méthode raw_input ().

 L'exemple suivant demande le nom d'utilisateur, et lorsque vous

avez entré le nom d'utilisateur, il est imprimé à l'écran:

169
Python 3.6

 username = input("Enter username:")

print("Username is: " + username)

 Python 2.7

 username = raw_input("Enter username:")

print("Username is: " + username)

170
Formatage de chaîne Python
 Pour nous assurer qu'une chaîne s'affichera
comme prévu, nous pouvons formater le résultat
avec la méthode format ().

 Format de chaîne ()
 La méthode format () vous permet de formater
des parties sélectionnées d'une chaîne.

 Parfois, il y a des parties d'un texte que vous ne

contrôlez pas, peut-être proviennent-elles d'une
base de données ou d'une entrée utilisateur?
171
 Pour contrôler ces valeurs, ajoutez des
espaces réservés (accolades {}) dans le
texte et exécutez les valeurs via la
méthode format ():
 Exemple
 Ajoutez un espace réservé où vous
souhaitez afficher le prix:
 price = 49
txt = "The price is {} dollars"
print(txt.format(price))

172
 Vous pouvez ajouter des paramètres entre
les accolades pour spécifier comment
convertir la valeur:

 Exemple
 Formatez le prix à afficher sous forme de
nombre avec deux décimales:
 txt = "The price is {:.2f} dollars"

173
 Valeurs multiples

 Si vous souhaitez utiliser plus de valeurs,

ajoutez simplement plus de valeurs à la
méthode format ():
 print(txt.format(price, itemno, count))

Et ajoutez d'autres espaces réservés:

 Exemple

174
 quantity = 3
itemno = 567
price = 49
myorder = "I want {} pieces of item number
{} for {:.2f} dollars."
print(myorder.format(quantity, itemno,
price))

175
 Numéros d'index
 Vous pouvez utiliser des numéros d'index
(un nombre entre les accolades {0}) pour
vous assurer que les valeurs sont placées
dans les espaces réservés appropriés:

 Exemple

176
 quantity = 3
itemno = 567
price = 49
myorder = "I want {0} pieces of item
number {1} for {2:.2f} dollars."
print(myorder.format(quantity, itemno,
price))

177
 De plus, si vous souhaitez faire référence à
la même valeur plusieurs fois, utilisez le
numéro d'index:

 Exemple
 age = 36
name = "John"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))

178
Index nommés
 Vous pouvez également utiliser des index
nommés en entrant un nom entre accolades
{carname}, mais vous devez ensuite utiliser
des noms lorsque vous passez les valeurs
de paramètre txt.format (carname = "Ford"):
 Exemple:
 myorder = "I have a {carname}, it is a
{model}."
print(myorder.format(carname = "Ford",
model = "Mustang"))
179
Gestion des fichiers
 La gestion des fichiers est une partie
importante de toute application Web.

 Python a plusieurs fonctions pour créer,

lire, mettre à jour et supprimer des fichiers.

180
 La fonction clé pour travailler avec des
fichiers en Python est la fonction open ().

 La fonction open () prend deux

paramètres; nom de fichier et mode.

 Il existe quatre méthodes (modes)

différentes pour ouvrir un fichier:

181
 "r" - Read - Default value. Opens a file for
reading, error if the file does not exist
 "a" - Append - Opens a file for appending,
creates the file if it does not exist
 "w" - Write - Opens a file for writing,
creates the file if it does not exist
 "x" - Create - Creates the specified file,
returns an error if the file exists

182
 De plus, vous pouvez spécifier si le fichier
doit être traité en mode binaire ou texte

 "t" - Text - Default value. Text mode

 "b" - Binary - Binary mode (e.g. images)

183
Syntaxe

 Pour ouvrir un fichier en lecture, il suffit de

spécifier le nom du fichier:
 f = open("demofile.txt")
 The code above is the same as:
 f = open("demofile.txt", "rt")


184
 Comme "r" pour lecture et "t" pour texte sont
les valeurs par défaut, vous n'avez pas
besoin de les spécifier.
 Vous pouvez renvoyer une ligne en utilisant
la méthode readline ():
 Exemple
 Lisez une ligne du fichier:

 f = open("demofile.txt", "r")
print(f.readline())
185
 En appelant readline () deux fois, vous
pouvez lire les deux premières lignes:
 Exemple
 Lisez deux lignes du fichier:

 f = open("demofile.txt", "r")
print(f.readline())
print(f.readline())

186
 En parcourant les lignes du fichier, vous
pouvez lire l'intégralité du fichier, ligne par
ligne:

 Exemple
 Parcourez le fichier ligne par ligne:

 f = open("demofile.txt", "r")
for x in f:
  print(x)

187
 Fermer les fichiers
 Il est recommandé de toujours fermer le
fichier lorsque vous en avez terminé.

 Exemple
 Fermez le fichier lorsque vous en avez
terminé:
 f = open("demofile.txt", "r")
print(f.readline())
f.close()
188
Écrire sur un fichier
 Écrire dans un fichier existant
 Pour écrire dans un fichier existant, vous
devez ajouter un paramètre à la fonction
open ():

 "a" - Ajouter - ajoutera à la fin du fichier

 "w" - Ecrire - écrasera tout contenu

existant 189
 Exemple
 Ouvrez le fichier "demofile2.txt" et ajoutez le
contenu au fichier:

 f = open("demofile2.txt", "a")
f.write("Now the file has more content!")
f.close()

#open and read the file after the appending:

f = open("demofile2.txt", "r")
print(f.read())
190
 Exemple
 Ouvrez le fichier "demofile3.txt" et écrasez le
contenu:
 f = open("demofile3.txt", "w")
f.write("Woops! I have deleted the content!")
f.close()

#open and read the file after the appending:

f = open("demofile3.txt", "r")
print(f.read())

191
 Remarque: la méthode "w" écrasera tout le
fichier.

192
Créer un nouveau fichier
 Pour créer un nouveau fichier en Python, utilisez
la méthode open (), avec l'un des paramètres
suivants:

 "x" - Créer - crée un fichier, renvoie une erreur si

le fichier existe

 "a" - Ajouter - créera un fichier si le fichier spécifié

n'existe pas

 "w" - Ecriture - créera un fichier si le fichier spécifié

n'existe pas 193
 Exemple
 Créez un fichier appelé "myfile.txt":
 f = open("myfile.txt", "x")

 Résultat: un nouveau fichier vide est créé!

 Exemple
 Créez un nouveau fichier s'il n'existe pas:
 f = open("myfile.txt", "w")


194
Supprimer un fichier
 Pour supprimer un fichier, vous devez
importer le module OS et exécuter sa
fonction os.remove ():

 Exemple
 Supprimez le fichier "demofile.txt":
 import os
os.remove("demofile.txt")

195
 Vérifiez si le fichier existe
 Pour éviter d'avoir une erreur, vous pouvez vérifier
si le fichier existe avant d'essayer de le supprimer:

 Exemple
 Vérifiez si le fichier existe, puis supprimez-le:

 import os
if os.path.exists("demofile.txt"):
  os.remove("demofile.txt")
else:
  print("The file does not exist")
196
Supprimer le dossier

 Pour supprimer un dossier entier, utilisez la

méthode os.rmdir ():

 Exemple:
 Supprimez le dossier "myfolder":
 import os
os.rmdir("myfolder")

197
Introduction à Numpy
 Qu'est-ce que NumPy?
 NumPy est une bibliothèque Python utilisée pour
travailler avec des tableaux.

 Il a également des fonctions pour travailler dans

le domaine de l'algèbre linéaire, de la
transformée de Fourier et des matrices.

 .

198
 NumPy a été créé en 2005 par Travis
Oliphant. C'est un projet open source et
vous pouvez l'utiliser librement.

199
Pourquoi utiliser NumPy?
 En Python, nous avons des listes qui
servent à des tableaux, mais elles sont
lentes à traiter.

 NumPy vise à fournir un objet de type

tableau jusqu'à 50 fois plus rapide que les
listes Python traditionnelles.

200
 L'objet tableau dans NumPy s'appelle
ndarray, il fournit de nombreuses fonctions
de support qui facilitent le travail avec
ndarray.

 Les tableaux sont très fréquemment utilizes

en “data science”, où la vitesse et les
ressources sont très importantes.

201
Pourquoi NumPy est-il plus
rapide que les listes?
 Les tableaux NumPy sont stockés à un
endroit continu de la mémoire
contrairement aux listes, de sorte que les
accès et les manipulations se font très
efficacement.

 Ce comportement est appelé localité de

référence en informatique.

202
 C'est la raison principale pour laquelle
NumPy est plus rapide que les listes. Il est
également optimisé pour fonctionner avec
les dernières architectures CPU.

203
Dans quelle langue NumPy est-
il écrit?

 NumPy est une bibliothèque Python et est

écrite partiellement en Python, mais la
plupart des parties qui nécessitent un
calcul rapide sont écrites en C ou C ++.

204
 Importation NumPy
 Une fois NumPy installé, importez-le dans
vos applications en ajoutant le mot-clé
import:
 importer numpy
 Maintenant NumPy est importé et prêt à
être utilisé.
 Exemple
 import numpy 

arr = numpy.array([1, 2, 3, 4, 5]) 

print(arr)
205
 NumPy as np
 NumPy est généralement importé sous
l'alias np.
 Exemple

 import numpy as np 

arr = np.array([1, 2, 3, 4, 5]) 

print(arr)

206
 Créer un NumPy ndarray
 NumPy est utilisé pour travailler avec des tableaux.
L'objet tableau dans NumPy est appelé ndarray.
 Nous pouvons créer un objet ndarray NumPy en
utilisant la fonction array ().
 Exemple
 import numpy as np 

arr = np.array([1, 2, 3, 4, 5])

print(arr)

print(type(arr))

207
 Pour créer un ndarray, nous pouvons passer
une liste, un tuple ou tout autre objet de type
tableau dans la méthode array (), et il sera
converti en un ndarray:

 Exemple
 Utilisez un tuple pour créer un tableau NumPy:
 import numpy as np 

arr = np.array((1, 2, 3, 4, 5))
print(arr)

208
 Dimensions dans les tableaux
 Une dimension dans les tableaux est un
niveau de profondeur de tableau (tableaux
imbriqués).

 tableau imbriqué: sont des tableaux qui ont

des tableaux comme éléments.

 Tableaux 0-D
 Les tableaux 0-D, ou scalaires, sont les
éléments d'un tableau. Chaque valeur d'un
tableau est un tableau 0-D. 209
 Exemple
 Créer un tableau 0-D avec la valeur 42
 import numpy as np

arr = np.array(42)

print(arr)

210
Tableaux 1-D
 Un tableau qui a des tableaux 0-D comme
éléments est appelé tableau unidimensionnel ou
1-D.
 Ce sont les tableaux les plus courants et les plus
basiques.
 Exemple
 Créez un tableau 1-D contenant les valeurs
1,2,3,4,5:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print(arr) 211
 Tableaux 2-D
 Un tableau qui a des tableaux 1-D comme
éléments est appelé un tableau 2-D.

 Ceux-ci sont souvent utilisés pour représenter

des matrices ou des tenseurs de second ordre.

 NumPy a tout un sous-module dédié aux

opérations matricielles appelé numpy.mat

212
 Exemple
 Créez un tableau 2D contenant deux
tableaux avec les valeurs 1,2,3 et 4,5,6:
 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

print(arr)

213
Tableaux 3-D
 Un tableau qui a des tableaux 2-D
(matrices) comme éléments est appelé
tableau 3-D.

 Ceux-ci sont souvent utilisés pour

représenter un tenseur du 3ème ordre.

214
 Exemple
 Créez un tableau 3D avec deux tableaux 2D,
contenant tous deux deux tableaux avec les
valeurs 1,2,3 et 4,5,6:

 import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3],

[4, 5, 6]]])

print(arr)
215
Vérifier le nombre de
dimensions?
 NumPy Arrays fournit l'attribut ndim qui
renvoie un entier qui nous indique le
nombre de dimensions du tableau.

 Exemple
 Vérifiez le nombre de dimensions des
tableaux:

216
 import numpy as np

a = np.array(42)
b = np.array([1, 2, 3, 4, 5])
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[[1, 2, 3], [4, 5, 6]], [[1, 2, 3],
[4, 5, 6]]])

print(a.ndim) 
print(b.ndim) 
print(c.ndim) 
print(d.ndim)
217
Tableaux dimensionnels
supérieurs
 Un tableau peut avoir n'importe quel
nombre de dimensions.
 Lorsque le tableau est créé, vous pouvez
définir le nombre de dimensions à l'aide de
l'argument ndmin.
 Exemple
 Créez un tableau avec 5 dimensions et
vérifiez qu'il a 5 dimensions:
218
 import numpy as np

arr = np.array([1, 2, 3, 4], ndmin=5)

print(arr)
print('number of dimensions :', arr.ndim)

 Dans ce tableau, la dimension la plus

interne (5ème dim) a 4 éléments, la 4ème
dim a 1 élément qui est le vecteur, la 3ème
dim a 1 élément qui est la matrice avec le
vecteur, la 2ème dim a 1 élément qui est
un tableau 3D et Le 1er dim a 1 élément
qui est un tableau 4D. 219
 Indexation des tableaux NumPy
Accéder aux éléments
L'indexation de tableau équivaut à accéder à
un élément de tableau.
Vous pouvez accéder à un élément de
tableau en vous référant à son numéro d'index.
Les indices des tableaux NumPy
commencent par 0, ce qui signifie que le
premier élément a l’indice 0 et le second
l’indice 1, etc.

220
 Exemple
 Obtenir le premier élément du tableau
suivant:
 import numpy as np

arr = np.array([1, 2, 3, 4])

print(arr[0])

221
 Exemple
 Récupérez les troisième et quatrième
éléments du tableau suivant et ajoutez-les.
 import numpy as np

arr = np.array([1, 2, 3, 4])

print(arr[2] + arr[3])

222
Accèder aux tableaux 2D
 Pour accéder aux éléments des tableaux 2D, nous
pouvons utiliser des entiers séparés par des virgules
représentant la dimension et l'index de l'élément.

 Exemple
 Accédez au 2ème élément de la 1ère dim:
 import numpy as np

arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print('2nd element on 1st dim: ', arr[0, 1])

223
Accéder aux tableaux 3-D

 Pour accéder aux éléments des tableaux 3-D, nous pouvons utiliser des
entiers séparés par des virgules représentant les dimensions et l'index
de l'élément.

 Exemple
 Accédez au troisième élément du deuxième tableau du premier tableau:
 import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

print(arr[0, 1, 2])

224
 Exemple expliqué
 arr [0, 1, 2] imprime la valeur 6.
 Et c'est pourquoi:
 Le premier nombre représente la première dimension, qui contient deux tableaux:
 [[1, 2, 3], [4, 5, 6]]
 et:
 [[7, 8, 9], [10, 11, 12]]
 Puisque nous avons sélectionné 0, nous nous retrouvons avec le premier tableau:
 [[1, 2, 3], [4, 5, 6]]
 Le deuxième nombre représente la deuxième dimension, qui contient également deux tableaux:
 [1, 2, 3]
 et:
 [4, 5, 6]
 Puisque nous avons sélectionné 1, nous nous retrouvons avec le deuxième tableau:
 [4, 5, 6]
 Le troisième nombre représente la troisième dimension, qui contient trois valeurs:
 4
 5
 6
 Puisque nous avons sélectionné 2, nous nous retrouvons avec la troisième valeur:
 6

225
Indexation négative
 Utilisez l'indexation négative pour accéder à un
tableau depuis la fin.

 Exemple
 Imprimez le dernier élément du 2ème dim:
 import numpy as np

arr = np.array([[1,2,3,4,5], [6,7,8,9,10]])

print('Last element from 2nd dim: ', arr[1, -1])

226
 Accès par Tranche
 Tableaux de découpage
 Le découpage en python signifie prendre des éléments
d'un index donné à un autre index donné.
 Nous passons slice au lieu d'index comme ceci:
 [start: end].
 Nous pouvons également définir l'étape, comme ceci:
[start: end: step].
 Si nous ne précisons pas, “start” est considéré comme 0
 Si nous ne précisons pas “fin” : sa longueur est celle du
tableau dans cette dimension

 Si nous ne passons pas “step”, c'est considéré comme 1

227
 Exemple
 Découpez les éléments de l'index 1 à l'index 5 dans le
tableau suivant:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[1:5])
 Exemple
 Découpez les éléments de l'index 4 à la fin du tableau:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])
print(arr[4:])

228
 Exemple
 Découpez les éléments du début à l'index
4 (non inclus):
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

print(arr[:4])

229
 Tranchage négatif
 Utilisez l'opérateur moins pour faire référence à
un index à partir de la fin:

 Exemple
 Tranche de l'index 3 de la fin à l'index 1 de la fin:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

print(arr[-3:-1])

230
 Step
 Utilisez la valeur de “step” pour déterminer le pas du
tranchage:

 Exemple
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

print(arr[1:5:2])
 print(arr[::2])

231
Tranchage de Tableaux 2D
 Exemple
 À partir du deuxième élément, découpez
les éléments de l'index 1 à l'index 4 (non
inclus):
 import numpy as np

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

print(arr[1, 1:4])

232
 Exemple
 À partir des deux éléments, renvoyez
l'index 2:
 import numpy as np

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

print(arr[0:2, 2])

233
 Exemple
 Des deux éléments, découpe de l'index 1 à
l'index 4 (non inclus), cela renverra un
tableau 2D:
 import numpy as np

arr = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])

print(arr[0:2, 1:4])

234
 Types de données NumPy
 Par défaut, Python a ces types de données:

 strings - utilisées pour représenter des données textuelles,

le texte est placé entre guillemets. par exemple. "A B C D”

 integer - utilisé pour représenter des nombres entiers. par

exemple. -1, -2, -3
 float - utilisé pour représenter des nombres réels. par
exemple. 1,2, 42,42
 boolean - utilisé pour représenter True ou False.

 complexe - utilisé pour représenter des nombres

complexes. par exemple. 1,0 + 2,0j, 1,5 + 2,5j 235
 NumPy a quelques types de données
supplémentaires et fait référence à des
types de données avec un caractère,
comme i pour les entiers, u pour les entiers
non signés, etc.

 Vous trouverez ci-dessous une liste de tous

les types de données dans NumPy et les
caractères utilisés pour les représenter.

236
 i - integer
 b - boolean
 u - unsigned integer
 f - float
 c - complex float
 m - timedelta
 M - datetime
 O - object
 S - string
 U - unicode string
 V - fixed chunk of memory for other type ( void )

237
 Vérification du type de données d’un tableau
 L'objet tableau NumPy a une propriété appelée
dtype qui renvoie le type de données du tableau:

 Exemple
 Obtenez le type de données d'un objet tableau:
 import numpy as np

arr = np.array([1, 2, 3, 4])

print(arr.dtype)

238
 Exemple
 Obtenez le type de données d'un tableau
contenant des chaînes:
 import numpy as np

arr = np.array(['apple', 'banana', 'cherry'])

print(arr.dtype)

239
Création de tableaux avec un
type de données défini
 Nous utilisons la fonction array () pour
créer des tableaux, cette fonction peut
prendre un argument optionnel: dtype qui
nous permet de définir le type de données
attendu des éléments du tableau:

240
 Exemple
 Créez un tableau avec un de type de
données chaîne de caracteres:
 import numpy as np

arr = np.array([1, 2, 3, 4], dtype='S')

print(arr)
print(arr.dtype)

241
Et si une valeur ne peut pas
être convertie?
 Si on a un type est donné dans lequel les éléments ne
peuvent pas être convertis, NumPy lèvera une ValueError.
 Exemple
 Une chaîne non entière comme 'a' ne peut pas être
convertie en entier (provoquera une erreur):

 import numpy as np

arr = np.array(['a', '2', '3'], dtype='i')

242
 Conversion du type de données sur des
tableaux existants
 La meilleure façon de changer le type de données d'un
tableau existant est de faire une copie du tableau avec la
méthode astype ().

 La fonction astype () crée une copie du tableau et vous

permet de spécifier le type de données en tant que
paramètre.
 Le type de données peut être spécifié à l'aide d'une
chaîne, comme «f» pour float, «i» pour entier, etc. ou vous
pouvez utiliser le type de données directement comme
float pour float et int pour integer.

243
 Exemple
 Changez le type de données de float en entier
en utilisant 'i' comme valeur de paramètre:
 import numpy as np

arr = np.array([1.1, 2.1, 3.1])

newarr = arr.astype('i')

print(newarr)
print(newarr.dtype)

244
 Exemple
 Changez le type de données de float en
entier en utilisant int comme valeur de
paramètre:
 import numpy as np

arr = np.array([1.1, 2.1, 3.1])

newarr = arr.astype(int)

print(newarr)
print(newarr.dtype) 245
 Exemple
 Changez le type de données d'entier en booléen:

 import numpy as np

arr = np.array([1, 0, 3])

newarr = arr.astype(bool)

print(newarr)
print(newarr.dtype)

246
NumPy Array Copy vs View
 La différence entre copy et view
 La principale différence entre une copie et une vue
d'un tableau est que la copie est un nouveau tableau
et que la vue n'est qu'une vue du tableau d'origine.

 La copie possède les données et toute modification

apportée à la copie n'affectera pas le tableaud'origine
et toutes les modifications apportées au tableau
d'origine n'affecteront pas la copie.

247
 La vue n'est pas propriétaire des données
et toutes les modifications apportées à la
vue affecteront le tableau d'origine et toutes
les modifications apportées au tableau
d'origine affecteront la vue.

248
 COPIE:
 Exemple
 Faites une copie, modifiez le tableau d'origine et
affichez les deux tableaux:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5])
x = arr.copy()
arr[0] = 42

print(arr) 
print(x)

249
 VUE:
 Exemple
 Créez une vue, modifiez le tableau d'origine et
affichez les deux tableaux:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
arr[0] = 42

print(arr) 
print(x)

250
 Apportez des modifications à la vue:
 Exemple
 Créez une vue, modifiez la vue et affichez les deux
tableaux:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5])
x = arr.view()
x[0] = 31

print(arr) 
print(x)

251
Vérifier si un tableau possède
ses données
 Comme mentionné ci-dessus, les copies possèdent
les données et les vues ne sont pas propriétaires des
données, mais comment pouvons-nous vérifier cela?

 Chaque tableau NumPy a la base d'attributs qui

renvoie None si le tableau possède les données.

 Sinon, l'attribut de base fait référence à l'objet

d'origine.

252
 Exemple
 Imprimez la valeur de l'attribut de base pour vérifier
si un tableau possède ses données ou non:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5])

x = arr.copy()
y = arr.view()

print(x.base)
print(y.base)

253
Taille des tableaux NumPy

 La taille d'un tableau est le nombre

d'éléments dans chaque dimension.

 Les tableaux NumPy ont un attribut appelé

shape qui renvoie un tuple avec chaque
index ayant le nombre d'éléments
correspondants.

254
 Exemple
 Imprimez la taille d'un tableau 2D:

 import numpy as np

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

print(arr.shape)
 L'exemple ci-dessus renvoie (2, 4), ce qui
signifie que le tableau a 2 dimensions et que
chaque dimension a 4 éléments.

255
 Exemple
 Créez un tableau avec 5 dimensions en
utilisant ndmin en utilisant un vecteur avec les
valeurs 1,2,3,4 et vérifiez que la dernière
dimension a la valeur 4:
 import numpy as np

arr = np.array([1, 2, 3, 4], ndmin=5)

print(arr)
print('shape of array :', arr.shape)

256
 Que représente le tuple?
 Les nombres entiers à chaque index
indiquent le nombre d'éléments de la
dimension correspondante.

 Dans l'exemple ci-dessus à l'index-4, nous

avons la valeur 4, nous pouvons donc dire
que la 5ème (4 + 1 ème) dimension a 4
éléments.

257
Remodelage (reshape) NumPy
 Remodeler les tableaux
 Remodeler signifie changer la forme d'un tableau.

 La forme (taille) d'un tableau est le nombre d'éléments

dans chaque dimension.

 En remodelant, nous pouvons ajouter ou supprimer des

dimensions ou modifier le nombre d'éléments dans
chaque dimension.

258
Remodeler de 1-D à 2-D
 Exemple
 Convertissez le tableau 1-D suivant avec 12 éléments en
un tableau 2-D.

 La dimension la plus externe aura 4 tableaux, chacun avec

3 éléments:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(4, 3)

print(newarr)
259
Remodeler de 1-D à 3-D
 Exemple
 Convertissez le tableau 1-D suivant avec 12 éléments en un tableau
3-D.

 La dimension la plus externe aura 2 tableaux qui contiennent 3

tableaux, chacun avec 2 éléments:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

newarr = arr.reshape(2, 3, 2)

print(newarr)

260
Pouvons-nous remodeler dans
n'importe quelle forme?

 Oui, tant que les éléments nécessaires au

remodelage sont égaux dans les deux formes.

 Nous pouvons remodeler un tableau 1D de 8

éléments en 4 éléments dans un tableau 2D de
2 lignes, mais nous ne pouvons pas le
remodeler en un tableau 2D de 3 éléments et 3
lignes car cela nécessiterait 3x3 = 9 éléments.

261
 Exemple
 Essayez de convertir un tableau 1D avec 8
éléments en un tableau 2D avec 3 éléments
dans chaque dimension (provoquera une erreur):
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

newarr = arr.reshape(3, 3)

print(newarr)

262
Renvoyer une copie ou une
vue?
 Exemple
 Vérifiez si le tableau renvoyé est une copie ou
une vue:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

print(arr.reshape(2, 4).base)

263
 L'exemple ci-dessus renvoie le tableau
d'origine, il s'agit donc d'une vue.

264
Dimension inconnue
 Vous êtes autorisé à avoir une dimension
"inconnue".

 Cela signifie que vous n'avez pas à

spécifier un nombre exact pour l'une des
dimensions dans la méthode de
remodelage.

 Passez -1 comme valeur et NumPy

calculera ce nombre pour vous. 265
 Exemple
 Convertissez un tableau 1D avec 8 éléments en un
tableau 3D avec 2x2 éléments:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

newarr = arr.reshape(2, 2, -1)

print(newarr)

 Remarque: nous ne pouvons pas passer -1 à plus

d'une dimension.

266
L'aplatissement d'un tableau

 L'aplatissement d'un tableau signifie

convertir un tableau multidimensionnel en
un tableau 1D.

 Nous pouvons utiliser reshape (-1) pour ce

faire.

267
 Exemple
 Convertissez le tableau en un tableau 1D:

 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

newarr = arr.reshape(-1)

print(newarr)

268
 Remarque: Il existe de nombreuses
fonctions pour changer les formes des
tableaux dans numpy flatten, ravel et
aussi pour réorganiser les éléments rot90,
flip, fliplr, flipud etc. Celles-ci relèvent de
la section Intermédiaire à Avancé de
numpy.

269
Itération tableau NumPy
 Tableaux itératifs
 Itérer signifie parcourir les éléments un par un.

 Comme nous traitons des tableaux

multidimensionnels dans numpy, nous pouvons le
faire en utilisant la boucle for basique de python.

 Si nous itérons sur un tableau 1-D, il passera par

chaque élément un par un.

270
 Exemple
 Itérez sur les éléments du tableau 1-D
suivant:

 import numpy as np

arr = np.array([1, 2, 3])

for x in arr:
  print(x)

271
 Itération tableau 2D

 Dans un tableau 2-D, il parcourra toutes les lignes.

 Exemple
 Itérez sur les éléments du tableau 2-D suivant:
 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

for x in arr:
  print(x)
272
 Si nous itérons sur un tableau n-D, il
passera par la n-1ème dimension une par
une.

 Pour renvoyer les valeurs réelles, les

scalaires, nous devons itérer les tableaux
dans chaque dimension.

273
 Exemple
 Itérez sur chaque élément scalaire du
tableau 2-D:
 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])

for x in arr:
  for y in x:
    print(y)

274
 itération tableau 3-D
 Dans un tableau 3-D, il passera par tous les
tableaux 2-D.

 Exemple
 Itérez sur les éléments du tableau 3-D suivant:
 import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]],

[[7, 8, 9], [10, 11, 12]]])

for x in arr:
  print(x) 275
 Pour renvoyer les valeurs réelles, les scalaires,
nous devons itérer les tableaux dans chaque
dimension.
 Exemple
 Itérer jusqu'aux scalaires:
 import numpy as np

arr = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

for x in arr:
  for y in x:
    for z in y:
      print(z)

276
Itérer des tableaux avec nditer ()
 La fonction nditer () est une fonction d'aide qui peut
être utilisée depuis des itérations très basiques à
très avancées. Il résout certains problèmes de base
auxquels nous sommes confrontés dans l'itération,
passons en revue avec des exemples.

 Itération sur chaque élément scalaire

 Dans les boucles for basiques, en parcourant
chaque scalaire d'un tableau, nous devons utiliser
n boucles for, ce qui peut être difficile à écrire pour
les tableaux avec une dimensionnalité très élevée.

277
 Exemple
 Parcourez le tableau 3-D suivant:
 import numpy as np

arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])

for x in np.nditer(arr):
  print(x)

278
itération avec différents types de
données
 Nous pouvons utiliser l'argument op_dtypes et lui
passer le type de données attendu pour changer le
type de données des éléments lors de l'itération.

 NumPy ne change pas le type de données de

l'élément en place (où l'élément est dans le tableau)
donc il a besoin d'un autre espace pour effectuer
cette action, cet espace supplémentaire est appelé
buffer, et afin de l'activer dans nditer () nous passer
des flags = [‘buffered'].

279
 Exemple
 Parcourez le tableau sous forme de
chaîne:
 import numpy as np

arr = np.array([1, 2, 3])

for x in np.nditer(arr, flags=['buffered'],
op_dtypes=['S']):
  print(x)

280
Itération avec une taille de pas
différente
 Nous pouvons utiliser le filtrage et suivi d'une itération.

 Exemple
 Parcourez chaque élément scalaire du tableau 2D en
sautant 1 élément:
 import numpy as np

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

for x in np.nditer(arr[:, ::2]):
  print(x)

281
Itération énumérée à l'aide de
ndenumerate ()
 L'énumération signifie mentionner le numéro
de séquence de quelque chose un par un.

 Parfois, nous avons besoin de l'index

correspondant de l'élément lors de
l'itération, la méthode ndenumerate () peut
être utilisée pour ces cas d'utilisation.

282
 Exemple
 Énumérer les éléments de tableaux 1D
suivants:
 import numpy as np

arr = np.array([1, 2, 3])

for idx, x in np.ndenumerate(arr):
  print(idx, x)

283
 Exemple
 Énumérer les éléments suivants du tableau
2D:
 import numpy as np

arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])

for idx, x in np.ndenumerate(arr):
  print(idx, x)

284
Fusion de tableaux numpy
 fusionner signifie placer le contenu de deux tableaux ou
plus dans un seul tableau.

 En SQL, nous joignons des tables en fonction d'une clé,

tandis que dans NumPy, nous joignons des tableaux par
axes.

 Nous passons une séquence de tableaux que nous voulons

joindre à la fonction concatenate (), avec l'axe. Si l'axe n'est
pas explicitement passé, il est considéré comme 0.

285
 Exemple
 Joindre deux tableaux:
 import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.concatenate((arr1, arr2))

print(arr)

286
 Exemple
 Joindre deux tableaux 2D le long de lignes (axe =
1):
 import numpy as np

arr1 = np.array([[1, 2], [3, 4]])

arr2 = np.array([[5, 6], [7, 8]])

arr = np.concatenate((arr1, arr2), axis=1)

print(arr)

287
 L'empilement
 Joindre des tableaux à l'aide des fonctions de Stack

 L'empilement est identique à la concaténation, la seule différence

est que l'empilement est effectué le long d'un nouvel axe.

 On peut concaténer deux tableaux 1-D le long du deuxième axe

ce qui aboutirait à les placer l'un sur l'autre, c'est-à-dire.
empilement.

 Nous passons une séquence de tableaux que nous voulons

joindre à la méthode stack () avec l'axe. Si l'axe n'est pas
explicitement passé, il est considéré comme 0.

288
 Exemple

 import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.stack((arr1, arr2), axis=1)

print(arr)

289
 Empilement le long des lignes
 NumPy fournit une fonction d'assistance: hstack () pour
empiler le long des lignes.

 Exemple
 import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.hstack((arr1, arr2))

print(arr)

290
 Empilement le long des colonnes
 NumPy fournit une fonction d'assistance: vstack () pour
empiler le long des colonnes.

 Exemple
 import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.vstack((arr1, arr2))

print(arr)

291
 Empilement le long de la hauteur (profondeur)
 NumPy fournit une fonction d'assistance: dstack () pour
empiler le long de la hauteur, qui est la même que la
profondeur.
 import numpy as np

arr1 = np.array([1, 2, 3])

arr2 = np.array([4, 5, 6])

arr = np.dstack((arr1, arr2))

print(arr)

292
Scission des tableaux NumPy
 Le fractionnement est une opération inverse de la
jonction.

 La jonction fusionne plusieurs tableaux en un seul et le

fractionnement divise un tableau en plusieurs.

 Nous utilisons array_split () pour diviser les tableaux,

nous lui passons le tableau que nous voulons diviser et le
nombre de divisions.

293
 Exemple
 Divisez le tableau en 3 parties:

 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 3)

print(newarr)
 Remarque: la valeur de retour est un tableau contenant
trois tableaux.

 .

294
 Si le tableau contient moins d'éléments que
nécessaire, il s'ajustera à partir de la fin en
consequence
 Example
 Split the array in 4 parts:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 4)

print(newarr)

295
 Remarque: Nous avons également la
méthode split () disponible mais elle
n'ajustera pas les éléments lorsque les
éléments sont moins dans le tableau
source pour le fractionnement comme dans
l'exemple ci-dessus, array_split ()
fonctionnait correctement mais split ()
échouerait.

296
Diviser en tableaux
 La valeur de retour de la méthode array_split () est un
tableau contenant chacun des fragments sous forme de
tableau.

 Si vous divisez un tableau en 3 tableaux, vous pouvez y

accéder à partir du résultat comme n'importe quel
élément du tableau:

297
 Exemple
 Accédez aux tableaux divisés:

 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6])

newarr = np.array_split(arr, 3)

print(newarr[0])
print(newarr[1])
print(newarr[2])

298
Division de tableaux 2D

 Utilisez la même syntaxe lors du

fractionnement de tableaux 2D.

 Utilisez la méthode array_split (),

transmettez le tableau que vous souhaitez
fractionner et le nombre de fractionnements
que vous souhaitez effectuer.

299
 Exemple
 Divisez le tableau 2-D en trois tableaux 2-D.

 import numpy as np

arr = np.array([[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]])

newarr = np.array_split(arr, 3)

print(newarr)

300
 L'exemple ci-dessus renvoie trois tableaux
2D.

 Regardons un autre exemple, cette fois,

chaque élément des tableaux 2-D contient
3 éléments.

 Exemple
 Divisez le tableau 2-D en trois tableaux2-D.

301
 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9],

[10, 11, 12], [13, 14, 15], [16, 17, 18]])

newarr = np.array_split(arr, 3)

print(newarr)

302
 L'exemple ci-dessus renvoie trois tableaux
2D.

 De plus, vous pouvez spécifier l'axe autour

duquel vous souhaitez effectuer le
fractionnement.

 L'exemple ci-dessous renvoie également

trois tableaux 2D, mais ils sont répartis le
long de la ligne (axe = 1).

303
 Exemple
 Divisez le tableau 2-D en trois tableaux 2-D le long
des lignes.

 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9],

[10, 11, 12], [13, 14, 15], [16, 17, 18]])

newarr = np.array_split(arr, 3, axis=1)

print(newarr)

304
 Une autre solution consiste à utiliser hsplit () à l'opposé
de hstack ()

 Exemple
 Utilisez la méthode hsplit () pour diviser le tableau 2-D
en trois tableaux 2-D le long de lignes.
 import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12],

[13, 14, 15], [16, 17, 18]])

newarr = np.hsplit(arr, 3)

print(newarr)

305
 Remarque: des alternatives similaires à
vstack () et dstack () sont disponibles
comme vsplit () et dsplit ().

306
Recherche dans un tableau
Numpy
 Vous pouvez rechercher dans un tableau
une certaine valeur et renvoyer les index
qui obtiennent une correspondance.

 Pour rechercher sur un tableau, utilisez la

méthode where ().

307
 Exemple
 Recherchez les index dont la valeur est 4:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 4, 4])

x = np.where(arr == 4)

print(x)
 L'exemple ci-dessus renverra un tuple: (array ([3, 5, 6],)

 Ce qui signifie que la valeur 4 est présente aux index 3,

5 et 6.

308
 Exemple
 Trouvez les index où les valeurs sont
paires:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

x = np.where(arr%2 == 0)

print(x)

309
 Exemple
 Trouvez les index où les valeurs sont
impaires:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])

x = np.where(arr%2 == 1)

print(x)

310
 Recherche triée
 Il existe une méthode appelée
searchsorted () qui effectue une recherche
binaire dans le tableau et renvoie l'index où
la valeur spécifiée serait insérée pour
maintenir l'ordre de recherche.

 La méthode searchsorted () est supposée

être utilisée sur des tableaux triés.

311
 Exemple
 Trouvez les index où la valeur 7 doit être
insérée:
 import numpy as np

arr = np.array([6, 7, 8, 9])

x = np.searchsorted(arr, 7)

print(x)

312
 Exemple expliqué: Le numéro 7 doit être
inséré sur l'index 1 pour conserver l'ordre de
tri.

 La méthode démarre la recherche à partir de

la gauche et retourne le premier index où le
nombre 7 n'est pas plus grand que la valeur
suivante.

313
 Recherche depuis le côté droit
 Par défaut, l'index le plus à gauche est renvoyé, mais
nous pouvons donner side = 'right' pour renvoyer l'index
le plus à droite à la place.
 Exemple
 Trouvez les index où la valeur 7 doit être insérée, en
commençant par la droite:
 import numpy as np

arr = np.array([6, 7, 8, 9])

x = np.searchsorted(arr, 7, side='right')

print(x)

314
 Exemple expliqué: Le numéro 7 doit être
inséré sur l'index 2 pour conserver l'ordre
de tri.

 La méthode démarre la recherche à partir

de la droite et renvoie le premier index où le
nombre 7 n'est plus inférieur à la valeur
suivante.

315
Valeurs multiples
 Pour rechercher plusieurs valeurs, utilisez un tableau avec
les valeurs spécifiées.
 Exemple
 Recherchez les index dans lesquels les valeurs 2, 4 et 6
doivent être insérées:
 import numpy as np

arr = np.array([1, 3, 5, 7])

x = np.searchsorted(arr, [2, 4, 6])

print(x)

316
 La valeur de retour est un tableau: [1 2 3]
contenant les trois index où 2, 4, 6 seraient
insérés dans le tableau d'origine pour
maintenir l'ordre.

317
 Tri des tableaux Numpy
 Le tri signifie placer les éléments dans une
séquence ordonnée.

 Une séquence ordonnée est toute séquence

dont l'ordre correspond aux éléments, comme
numérique ou alphabétique, croissant ou
décroissant.

 L'objet NumPy ndarray a une fonction appelée

sort (), qui triera un tableau spécifié.

318
 Exemple
 Trier le tableau:
 import numpy as np

arr = np.array([3, 2, 0, 1])

print(np.sort(arr))

 Remarque: cette méthode renvoie une copie du

tableau, laissant le tableau d'origine inchangé.

319
 Vous pouvez également trier des tableaux
de chaînes ou tout autre type de données:
 Exemple
 Triez le tableau par ordre alphabétique:
 import numpy as np

arr = np.array(['banana', 'cherry', 'apple'])

print(np.sort(arr))

320
 Exemple
 Trier un tableau booléen:
 import numpy as np

arr = np.array([True, False, True])

print(np.sort(arr))

321
 Tri d'un tableau 2D
 Si vous utilisez la méthode sort () sur un tableau 2D,
les deux tableaux seront triés:

 Exemple
 Sort a un tableau 2-D:

 import numpy as np

arr = np.array([[3, 2, 4], [5, 0, 1]])

print(np.sort(arr))

322
Filtrage des tableaux
 Extraire certains éléments d'un tableau existant et en
créer un nouveau s'appelle le filtrage.
 Dans NumPy, vous filtrez un tableau à l'aide d'une liste
d'index booléenne.

 Une liste d'index booléen est une liste de booléens

correspondant aux index du tableau.

 Si la valeur d'un index est True, cet élément est

contenu dans le tableau filtré, si la valeur de cet index
est False, cet élément est exclu du tableau filtré.

323
 Exemple
 Créez un tableau à partir des éléments d'index 0 et
2:
 import numpy as np

arr = np.array([41, 42, 43, 44])

x = [True, False, True, False]

newarr = arr[x]

print(newarr)

324
 L'exemple ci-dessus retournera [41, 43],
pourquoi?

 Étant donné que le nouveau filtre contient

uniquement les valeurs pour lesquelles le
tableau de filtres avait la valeur True, dans
ce cas, les index 0 et 2.

325
 Création de la matrice de filtres
 Dans l'exemple ci-dessus, nous avons
codé en dur les valeurs True et False, mais
l'utilisation courante consiste à créer un
tableau de filtres basé sur des conditions.

 Exemple
 Créez un tableau de filtres qui ne renverra
que des valeurs supérieures à 42:

326
 import numpy as np

arr = np.array([41, 42, 43, 44])

# Create an empty list

filter_arr = []

# go through each element in arr

for element in arr:
  # if the element is higher than 42, set the value to True, otherwise False:
  if element > 42:
    filter_arr.append(True)
  else:
    filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

327
 Exemple
 Créez un tableau de filtres qui ne renverra
que les éléments pairs du tableau
d'origine:

328
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

# Create an empty list

filter_arr = []

# go through each element in arr

for element in arr:
  # if the element is completely divisble by 2, set the value to True,
otherwise False
  if element % 2 == 0:
    filter_arr.append(True)
  else:
    filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

329
 Création d'un filtre directement à partir
d'un tableau
 L'exemple ci-dessus est une tâche assez
courante dans NumPy et NumPy fournit un
bon moyen de s'y attaquer.

 Nous pouvons directement remplacer le

tableau au lieu de la variable itérable dans
notre condition et cela fonctionnera
exactement comme nous l'attendons.

330
 Exemple
 Créez un tableau de filtres qui ne renverra que
des valeurs supérieures à 42:
 import numpy as np

arr = np.array([41, 42, 43, 44])

filter_arr = arr > 42

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

331
 Exemple
 Créez un tableau de filtres qui ne renverra que les
éléments pairs du tableau d'origine:
 import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7])

filter_arr = arr % 2 == 0

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

332