Programmation en

Python

Oumar Y. MAÏGA
ESEO 2020
Contenu
• Installation de Python et PyCharm
• Variables et types de données
• Listes et fonctions
• Instructions conditionnelles
• Les boucles
• Listes 2D et boucles imbriquées
• Lecture de fichiers, Écrire dans des fichiers
• Modules & Pip
• Classes & Objets
• Fonctions d'objet
• Héritage
Installation de Python
Les bases du langage Python
• Variables et affectations
• Variables d’instances et variables locales
• Les types de données
• Conversion de types de données
• Entrées/Sorties standards
• Opérateurs python
Mots clés
• and def finally in print yield
• as del for is raise
• assert elif from lambda return
• break else global not try
• class except if or while
• continue exec import pass with
Les variables et affections
• Contrairement aux langages de programmation comme le C, C++, Java, C#
etc. Il n’est pas nécessaire de déclarer un type pour les variables
• age=3
• jour=« Vendredi »
• hauteur=12.8
• Pas de point-virgule après une instruction
• On peut affecter une valeur à plusieurs variables en une seule fois
• a=b=c=5
• Afficher les valeurs de a,b et c
• Vous pouvez également assigner plusieurs variables sur la même ligne avec
des valeurs différentes et même des types de données différents:
• a, b, c = 1, 2, "example“
• Afficher les valeurs de a,b et c
Variables d’instances/locales
• En python, chaque variable a un type spécifique, qui déterminerait sa taille
et la disposition de sa mémoire. Le langage python définit 2 types de
variables:
• Les variables d’instances
• les variables d'instance sont déclarées dans un fichier python, mais en dehors de toute méthode,
constructeur ou bloc.
• Une variable d'instance est visible pour toutes les fonctions, constructeurs et blocs, dans le
fichier dans lequel elle est déclarée.
• Les variables locales
• Les variables locales ne sont déclarées que dans des fonctions, des blocs ou des constructeurs.
Ils ne sont créés que lorsque la fonction, le bloc ou le constructeur sont créés, puis détruits dès
la fin de la fonction.
• Vous ne pouvez accéder aux variables locales que dans la fonction, le bloc ou le constructeur
où elles sont déclarées, et elles ne sont pas visibles en dehors.
• Les variables locales n'ont pas de valeur par défaut.
Types de données
• Cinq types de données existent en Python
• Les nombres (number)
• Le type de données « number » stocke des valeurs numériques. Ce type est créé lorsque
vous créez une variable contenant une valeur numérique
• Quatre types de nombres: int, long, float, complex
• Les chaînes de caractères (String)
• Une chaîne est identifiée comme un ensemble continu de caractères placés entre
guillemets. Contrairement à Java, python permet de déclarer des chaînes avec des
guillemets simples (‘ ’) et doubles (“ ”).
• chat = "chat"
• chien = ‘chien’
Les entiers
• Opérations arithmétiques
• 20 + 3 # 23
• 20 - 3 # 17
• 20 * 3 # 60
• 20 ** 3 # 8000
• 20 / 3 # 6 (division entière)
• 20 % 3 # 2 (modulo)
• Les entiers longs
• 2 ** 40 # 1099511627776L
• 3 * 72L # 216L
• Opéerations sur les bases
• 07 + 01 # 8
• oct(7+1) # ’010’ (octal)
• 0x9 + 0x2 # 11
• hex(9+2) # ’0xb’ (hexadécimal)
• int(’10110’, 2) # 22
Les flottants
• Les flottants sont notés avec un « point décimal » ou en notation
exponentielle :
• 2.718
• 3e8
• 6.023e23
• Ils supportent les mêmes opérations que les entiers, sauf :
• 20.0 / 3 # 6.666666666666667
• 20.0 // 3 # 6 (division entière forcée)
• L’import du module « math » autorise toutes les opérations mathématiques
usuelles :
• from math import sin, pi
• print sin(pi/4) # 0.70710678118654746
Les nombres complexes
• Les complexes sont écrits en notation cartésienne, formée de deux
flottants. La partie imaginaire est suffixée par j :
• 1j # 1j
• (2+3j) + (4-7j) # (6-4j)
• (9+5j).real # 9.0
• (9+5j).imag # 5.0
• (abs(3+4j) # 5.0 : module
Chaînes de caractères
• Longueur :
• s = "abcde"
• len(s) # 5
• Concaténation :
• s1 = "abc"
• s2 = "defg"
• s3 = s1 + s2 # ’abcdefg’
• Répétition :
• s4 = "Fi! "
• s5 = s4 * 3 # ’Fi! Fi! Fi! ’
• split() : scinde une chaîne en une liste de mots :
• ’ab*cd’.split(’*’) # [’ab’, ’cd’] (on indique le séparateur)
• join() : concatène une liste de chaînes en une chaîne :
• ’-’.join([’ci’, ’joint’]) # ’ci-joint’
• find() : donne la position d’une sous-chaîne dans la chaîne :
• ’abracadabra’.find(’bra’) # 1 (le premier indice vaut 0)
• count() : donne le nombre de sous-chaînes dans la chaîne :
• ’abracadabra’.count(’bra’) # 2
• lower() : convertit en minuscules :
• ’PETIT’.lower() # ’petit’
• upper() : convertit en majuscules :
• ’grand’.upper() # ’GRAND’
• capitalize() : convertit la première lettre en majuscule :
• ’michelle’.capitalize() # ’Michelle’
• title() : la première lettre de tous les mots en majuscule :
• ’un beau titre !’.title() # ’Un Beau Titre !’
• swapcase() : intervertit les casses :
• ’bOB’.swapcase() # ’Bob’
• strip() : supprime les blancs en début et fin de chaîne :
• ’ Trop de blancs ’.strip() # ’Trop de blancs’
• replace() : remplace une sous-chaîne par une autre :
• ’abracadabra’.replace(’a’, ’o’) # ’obrocodobro’
Indice dans une chaîne
• On indique, entre crochets, la position d’un caractère par un indice qui
commence à 0 :
• s = "abcdefg"
• s[0] # a
• s[2] # c
• s[-1] # g (négatif : on commence par la fin)
• On peut extraire une sous-chaîıne par découpage :
• s[1:3] # ’bc’
• s[3:] # ’defg’
• s[:3] # ’abc’
Formatage
• Les formats permettent de contrôler finement l’affichage :
• n = 100
• print ("%d en base 10 : %d" % (n, n)) # ’100 en base 10 : 100’
• print ("%d en base 8 : %o" % (n, n)) # ’100 en base 8 : 144’
• print ("%d en base 16 : %x" % (n, n)) # ’100 en base 16 : 64’
• pi = 3.1415926535897931
• print ("%4.2f" %(pi))# 3.14
• print ("%.4e" %(pi)) # 3.1415e+000
• print ("%g" %(pi)) # 3.14159
• msg = "Résultat sur %d échantillons : %4.2f" % (n, pi)
• print (msg) # ’Résultat sur 100 échantillons : 3.14’
Principaux formats
• %d : entier signé
• %u : entier non-signé
• %o : un octal non-signé
• %x : un hexadécimal non-signé
• %s : une chaîne de caractères
• %f : un flottant
• %e : un flottant (format exponentiel)
• %g : un flottant (format « optimal » suivant sa longueur)
• On peut aussi contrôler le champ d’affichage : "%7.2f" permet d’´ecrire un
flottant sur 7 caractères dont 2 après le point décimal.
• Les listes (Lists)
• Une liste contient plusieurs éléments séparés par des virgules et entourés de crochets.
• Les listes sont très similaires aux tableaux dans d'autres langages de programmation
tels que java de c #, mais avec une différence majeure; vous pouvez avoir une liste
contenant plusieurs types de données différents, contrairement aux tableaux qui ne
peuvent contenir qu'un seul type de données par tableau.
• Exemple
• firstList = ["first", 2, "third", 4, 5]
• secondList = ["hello", 3, 4, "bye"]
• Tuples
• Un tuple est un type de données similaire aux listes. Les tuples peuvent également
contenir différents types de données, séparés par des virgules. Toutefois, au lieu d'être
mis entre crochets, ils sont entourés de parenthèses (“()”) et ne peuvent pas être mis à
jour. Les tuples peuvent être considérés comme des listes qui ne peuvent être que
lues, contrairement aux listes que vous pouvez aussi lire et écrire.
Fonctions sur les listes
• [Link](element)
• li = [1, 2, 3, 4, 5]
• [Link](6)
• print li # [1, 2, 3, 4, 5, 6]
• [Link](autre_liste)
• li = [1, 2, 3, 4, 5]
• [Link]([6, 7, 8]) # Pour info, équivaut à li += [6, 7, 8]
• print li # [1, 2, 3, 4, 5, 6, 7, 8]
• [Link](valeur)
• li = [1, 2, 3, 4, 5]
• [Link](1)
• print li # [2, 3, 4, 5]
• [Link]()
• li = [1, 2, 3, 4, 5]
• [Link]()
• print li # [5, 4, 3, 2, 1]
• print reversed(li) # [1, 2, 3, 4, 5]
• print li # [5, 4, 3, 2, 1] <-- pas modifié
• [Link]()
• li = [3, 1, 4, 2, 5]
• [Link]()
• print li # [1, 2, 3, 4, 5]
• li = [3, 1, 4, 2, 5]
• print sorted(li) # [1, 2, 3, 4, 5]
• print li # [3, 1, 4, 2, 5] <-- pas modifié
Les compréhensions de liste
• # Affiche les carrés des éléments
• liste = [1, 2, 3, 4, 5, 6, 7]
• print ([x ** 2 for x in liste]) .
• # Affiche les nombres pairs
• print ([x for x in liste if x % 2 == 0])
• # Affiche les carrés pairs (combinaison des deux)
• print ([x ** 2 for x in liste if x ** 2 % 2 == 0]) # ou
• print ([x for x in [a ** 2 for a in liste] if x % 2 == 0])
Les ensembles
• ens1 = set([1, 2, 3, 4, 5, 6])
• ens2 = set([2, 3, 4])
• ens3 = set([6, 7, 8, 9])
• appartenance
• [Link](b)
• #ou
• a & b == a
• Réunion
• [Link](b)
• #ou
• a|b
• Intersection
• [Link](b) #ou
• a&b
• Différence
• [Link](b) #ou
• a-b
• Différence symétrique
• a.symmetric_difference(b) #ou
• a^b
• Transformer un ensemble en liste
• list(ensemble)
• # ens1 = set([1, 2, 3, 4, 5, 6])
• # ens2 = set([2, 3, 4])
• # ens3 = set([6, 7, 8, 9])
• print (ens1 & ens2) # set([2, 3, 4]) car ce sont les seuls à être en même
temps dans ens1 et ens2
• print (ens1 | ens3) # set([1, 2, 3, 4, 5, 6, 7, 8, 9]), les deux réunis
• print (ens1 & ens3) # set([6]), même raison que deux lignes au dessus
• print (ens1 ^ ens3) # set([1, 2, 3, 4, 5, 7, 8, 9]), l'union moins les éléments
communs
• print (ens1 - ens2) # set([1, 5, 6]), on enlève les éléments de ens2
• Dictionnaire (Dictionary)
• Les dictionnaires sont constitués de paires clé-valeur. Un dictionnaire se compose
d'un nom, suivi d'une clé, qui contient alors un certain nombre de valeurs. Une clé est
entourée de crochets ([]), tandis que les valeurs sont entourées d'accolades ({}).
• Un dictionnaire fonctionne de manière similaire à un vrai dictionnaire. Vous pouvez
en quelque sorte penser à une clé comme s'il s'agissait d'un mot, puis à la valeur en
tant que définition du mot ou à la valeur que le mot détient.
• Une clé peut être presque n'importe quel type de données python, mais il s'agit
souvent de mots ou de nombres, tandis que les valeurs détenues par un dictionnaire
peuvent être n'importe quoi.
• Exemple
• dict = {} # dictionnaire vide
• dict[“premier"] = {3}
• dict["second"] = {“je suis la valeur du second"}
Le problèmes des références
• L’opération d’affectation, pose des difficultés de Python.
• i=1
• msg = "Quoi de neuf ?"
• e = 2.718
• Dans l’exemple ci-dessus, l’affectation réalise plusieurs opérations :
• crée et mémorise un nom de variable dans l’espace de noms courant (c’est en
fait une adresse) ;
• lui attribue dynamiquement un type bien déterminé ;
• crée et mémorise une valeur (membre de droite) ;
• établit un lien entre le nom de la variable et l’adresse de la valeur
correspondante.
• Une conséquence de ce mécanisme est que, si un objet modifiable est affecté, tout changement sur
un objet modifiera l’autre :
• fable = [’Je’, ’plie’, ’mais’, ’ne’, ’romps’, ’point’]
• phrase = fable
• fable[4] = ’casse’
• Si l’on désire réaliser une vraie copie d’un objet, on utilise le module copy :
• import copy
• a = [1, 2, 3]
• b = a # une référence
• [Link](4)
• print a # [1, 2, 3, 4]
• c = [Link](a) # une copie de "surface"
• [Link](5)
• print a # [1, 2, 3, 5]
• Dans les rares occasions où l’on veut aussi que chaque élément et attribut de l’objet soit copié
séparément et de façon récursive, on emploie deepcopy().
Entrées/Sorties
Input()/print()
• La fonction print() permet d’afficher à l’écran
• print(age)
• print(jour)
• print(hauteur)
Input()
• L’instruction input() permet se saisir une entrée au clavier. Elle
effectue un typage dynamique. Elle permet également d’afficher une
invite :
• n = input("Entrez un entier : ")
• L’instruction raw_input() force une saisie en mode texte que l’on peut
ensuite transtyper :
• f1 = raw_input("Entrez un flottant : ")
• f1 = float(f1) # transtypage en flottant
• f2 = float(raw_input("Entrez un autre flottant : "))
Les opérateurs en Python
• Opérateurs arithmétiques
• Addition
• Soustraction
• Multiplication
• Division
• Division entière
• Modulo
• Les opérateurs d’affectation
• +=
• -=
• *=
• /=
• %=
Les expressions booléennes
• Deux valeurs possibles : False, True.
• Opérateurs de comparaison : ==, !=, >, >=, <, <=
• 2 > 8 # False
• 2 <= 8 < 15 # True
• Opérateurs logiques (concept de shortcut) : not, or, and
• (3 == 3) or (9 > 24) # True (dès le premier membre)
• (9 > 24) and (3 == 3) # False (dès le premier membre)
• Les opérateurs logiques et de comparaisons sont à valeurs dans False,
True
Classes
• Une classe est un modèle de code extensible utilisé pour créer des
objets. Tout le code que nous avons écrit peut être écrit tel quel, dans
une classe.
• La création de classes nous permet cependant de traiter les variables et
les fonctions de la classe, en tant qu’objets que nous pouvons utiliser
dans d’autres classes et même d’autres scripts python. Cela nous
permet également de créer plusieurs instances des mêmes variables et
fonctions.
Terminologies
• Certains termes que nous pourrions utiliser dans cette section sont
utiles à connaître en matière de programmation orientée objet:
• Méthode: une fonction déclarée dans le corps d'une classe
• Object: Instance d'un type de données défini par une classe. Un objet contient
à la fois des variables et des méthodes.
• Instance: un objet autonome d'une classe. Une instance d'une classe est comme
un clone de celle-ci, identique, mais également indépendante, en termes
d'édition.
Terminologies
• Héritage: L'obtention de variables et de méthodes d'une classe à une
autre.
• Variable de classe: Variable spécifique à la classe, n’est pas copiée
dans les instances
• Variable d'instance: Variable que toutes les instances d'une classe ont
et partagent. Ils sont créés dans une classe, mais en dehors d'une
méthode..
• Variable local: Variable créée dans une méthode et n'appartenant qu'à
une seule instance d'une classe.
Exemple 1
class Personne: # Définition de notre classe Personne
"""Classe définissant une personne caractérisée par :
- son nom
- son prénom
- son âge
- son lieu de résidence"""

def __init__(self): # Notre méthode constructeur

"""Pour l'instant, on ne va définir qu'un seul attribut"""
[Link] = "Dupont"
class Personne:
"""Classe définissant une personne caractérisée par :
- son nom
- son prénom
- son âge
- son lieu de résidence"""
def __init__(self): # Notre méthode constructeur
[Link] = "Dupont"
[Link] = "Jean"
[Link] = 33
self.lieu_residence = "Paris"
Exemple 2
class TableauNoir:
"""Classe définissant une surface sur laquelle on peut écrire,
que l'on peut lire et effacer, par jeu de méthodes. L'attribut modifié
est surface'"""
def __init__(self):
"""Par défaut, notre surface est vide"""
[Link] = ""
def ecrire(self, message_a_ecrire):
"""Méthode permettant d'écrire sur la surface du tableau.
Si la surface n'est pas vide, on saute une ligne avant de rajouter
le message à écrire"""
if [Link] != "":
[Link] += "\n"
[Link] += message_a_ecrire
def lire(self):
"""Cette méthode se charge d'afficher, grâce à print,
la surface du tableau"""
print([Link])
def effacer(self):
"""Cette méthode permet d'effacer la surface du tableau"""
[Link] = ""
Méthodes de classe et méthodes statiques
• Comme on trouve des attributs propres à la classe, on trouve aussi des
méthodes de classe, qui ne travaillent pas sur l'instance self mais sur la
classe même.
• Notre méthode de classe se définit exactement comme une méthode
d'instance, à la différence qu'elle ne prend pas en premier paramètre
self(l'instance de l'objet) mais cls(la classe de l'objet).
• On peut également définir des méthodes statiques.
• Elles sont assez proches des méthodes de classe sauf qu'elles ne prennent
aucun premier paramètre, ni self ni cls.
• Elles travaillent donc indépendamment de toute donnée, aussi bien contenue
dans l'instance de l'objet que dans la classe.
Exemple
class Compteur:
objets_crees = 0 # Le compteur vaut 0 au départ
def __init__(self):
"""À chaque fois qu'on crée un objet, on incrémente le compteur"""
Compteur.objets_crees += 1
def combien(cls):
"""Méthode de classe affichant combien d'objets ont été créés"""
print("Jusqu'à présent, {} objets ont été créés.".format(
cls.objets_crees))
combien = classmethod(combien)
Exemple 2
class Test:
def afficher():
"""Fonction chargée d'afficher quelque chose"""
print("On affiche la même chose.")
print("peu importe les données de l'objet ou de la classe.")
[Link] = staticmethod([Link])
[Link]()
Exemple 3
class Arithmetique:
def addition(x, y):
return x + y
[Link]= staticmethod([Link])
print('La somme est:', [Link](5, 10) )
 Propriétés
class Personne:
def __init__(self, nom, prenom):
"""Constructeur de notre classe"""
[Link] = nom
[Link] = prenom
[Link] = 33
self._lieu_residence = "Paris"
def _get_lieu_residence(self):
"""Méthode qui sera appelée quand on souhaitera accéder en lecture
à l'attribut 'lieu_residence'"""
print("On accède à l'attribut lieu_residence !")
return self._lieu_residence
• def _set_lieu_residence(self, nouvelle_residence):
• """Méthode appelée quand on souhaite modifier le lieu de résidence"""
• print("Attention, il semble que {} déménage à {}.".format( \
• [Link], nouvelle_residence))
• self._lieu_residence = nouvelle_residence
• # On va dire à Python que notre attribut lieu_residence pointe vers une
• # propriété
• lieu_residence = property(_get_lieu_residence, _set_lieu_residence)
Héritage
class ClassA:
def faire(self):
pass
class B(ClassA):
pass
Classe Abstraite
• Les classes abstraites sont des classes qui contiennent une ou plusieurs
méthodes abstraites.
• Une méthode abstraite est une méthode déclarée mais ne contenant
aucune implémentation.
• Les classes abstraites peuvent ne pas être instanciées et nécessitent que
des sous-classes fournissent des implémentations pour les méthodes
abstraites.
• Les sous-classes d'une classe abstraite en Python ne sont pas obligées
d'implémenter les méthodes abstraites de la classe parente.
Exemple
class AbstractClass:
def faire(self):
pass
class B(AbstractClass):
pass
a = AbstractClass()
b = B()
• Il ne s'agit pas d'une classe abstraite, car:
• nous pouvons instancier une instance de A
• nous ne sommes pas obligés d'implémenter faire() dans la définition de la
classe de B
• En fait, Python seul ne fournit pas de classes abstraites. Pourtant,
Python est livré avec un module qui fournit l'infrastructure permettant
de définir les classes de base abstraites (ABC).
Exemple 1
from abc import ABC, abstractmethod
class AbstractClassExample(ABC):
def __init__(self, value):
[Link] = value
super().__init__()
@abstractmethod
def faire(self):
pass
• class MaClasse(AbstractClassExample):
• pass
• x = MaClasse(4) # l’instanciation va provoquer une erreur

• Nous allons le faire correctement dans l'exemple suivant, dans lequel

nous définissons deux classes héritant de notre classe abstraite:
Exemple 2
class MaClasse(AbstractClassExample):
def faire(self):
return [Link] + 42
class MaClasse2(AbstractClassExample):
def faire(self):
return [Link] * 42
x = MaClasse(10)
y = MaClasse2(10)
print([Link]())
print([Link]())
Conditions sur Classes Abstraites
• Une classe dérivée d'une classe abstraite ne peut être instanciée que si
toutes ses méthodes abstraites sont implémentées.
• Vous pouvez penser que les méthodes abstraites ne peuvent pas être
implémentées dans la classe de base abstraite.
• Cette impression est fausse: une méthode abstraite peut avoir une
implémentation dans la classe abstraite! Même s'ils sont implémentés, les
concepteurs de sous-classes seront forcés de remplacer l'implémentation.
Comme dans d'autres cas d'héritage "normal", la méthode abstraite peut être
invoquée avec le mécanisme d'appel super ().
• Cela permet de fournir des fonctionnalités de base dans la méthode abstraite,
qui peuvent être enrichies par la mise en œuvre de sous-classes.
Exemple
from abc import ABC, abstractmethod
class AbstractClassExample(ABC):
@abstractmethod
def faire(self):
print("quelque chose à faire!")

class MaClasse(AbstractClassExample):
def faire(self):
super().faire()
print("Quelque chose de plus à faire")

x = MaClasse()
[Link]()
Exception
• Une exception est une erreur qui survient lors de l'exécution d'un programme.
• La gestion des exceptions est une construction dans certains langages de
programmation pour traiter ou traiter automatiquement les erreurs.
• De nombreux langages de programmation tels que C ++, Objective-C, PHP, Java,
Ruby, Python et bien d'autres ont un support intégré pour la gestion des
exceptions.
• La gestion des erreurs est généralement résolue en sauvegardant l'état d'exécution
au moment où l'erreur s'est produite et en interrompant le flux normal du
programme pour exécuter une fonction spéciale ou un morceau de code, appelé
gestionnaire d'exceptions.
• En fonction du type d'erreur survenue ("division par zéro", "erreur d'ouverture de
fichier", etc.), le gestionnaire d'erreurs peut "corriger" le problème et le
programme peut ensuite être poursuivi avec les données précédemment
sauvegardées.
Exception
• while True:
• try:
• n = input(“entrer un entier: ")
• n = int(n)
• break
• except ValueError:
• print(“Entier invalide! Merci de recommencer ...")
• print(“Saisie Terminée!")
Boucles
Boucle while
n = 100
s=0
counter = 1
while counter <= n:
s = s + counter
counter += 1

print(“somme de 1 à %d: %d" % (n,s))

import random
n = 20
a = int(n * [Link]()) + 1
b=0
while b != a:
b = int(input(“nouveau nombre: "))
if b > 0:
if b > a:
print(“nombre plus grand")
elif b < a:
print(“nombre plus petit")
else:
print(“désolé!")
break
else:
print(“félicitations!")
Boucle for
for <variable> in <sequence>:
<instructions>
else:
<statements>
• n = 100

• sum = 0
• for counter in range(1,n+1):
• sum = sum + counter

• print(“somme de 1 à %d: %d" % (n,sum))

Numpy
• Numpy est la bibliothèque de base pour l'informatique scientifique en
Python.
• Il fournit une implémentation de tableau multidimensionnel et des
outils pour travailler avec ces tableaux.
• python -m pip install numpy
• Autres modules:
• [Link]
• [Link]
Arrays
• Un tableau numpy est une grille de valeurs, toutes du même type, et
est indexé par des entiers non négatifs.
• Le nombre de dimensions est le rang du tableau. la forme d'un tableau
est un vecteur d'entiers donnant la taille du tableau le long de chaque
dimension.
Exemple
import numpy as np
a = [Link]([1, 2, 3]) # Création d’un tableau d’une dimension
print(type(a)) # affiche le type de a "<class '[Link]'>"
print([Link]) # affiche la forme de a"(3,)"
print(a[0], a[1], a[2]) # affiche les éléments de a "1 2 3"
a[0] = 5 # affecte une valeur au 1er élément du tableau
print(a) # affiche a "[5, 2, 3]"
b = [Link]([[1,2,3],[4,5,6]]) # création d’un tableau de deux dimensions
print([Link]) # affiche la forme de b "(2, 3)"
print(b[0, 0], b[0, 1], b[1, 0]) # affiche "1 2 4"
Fonctions de création de tableaux
• import numpy as np
• a = [Link]((2,2)) # Création d’un tableau de zéros
• b = [Link]((1,2)) # Création d’un tableau de 1
• print(b)
• c = [Link]((2,2), 7) # Création d’un tableau constant de 7
• print(c)
• d = [Link](2) # Création d’une matrice identité 2x2
• print(d)
• e = [Link]((2,2)) # Création d’un tableau avec valeurs
aléatoires
• print(e)
Indexation
• import numpy as np
• a = [Link]([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
• b = a[:2, 1:3] # les deux premières lignes de a et de la colonne 1 à 2
• b[0, 0] = 77 # b[0, 0] est la même que a[0, 1]
• print(a[0, 1]) # affiche "77"
import numpy as np
a = [Link]([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
row_r1 = a[1, :]
row_r2 = a[1:2, :]
print(row_r1, row_r1.shape)
print(row_r2, row_r2.shape)
col_r1 = a[:, 1]
col_r2 = a[:, 1:2]
print(col_r1, col_r1.shape)
print(col_r2, col_r2.shape)
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)

print(quicksort([3,6,8,10,1,2,1]))
Lecture et Ecriture dans un Fichier
• La fonction open crée un fichier. Elle renvoie un objet de la classe
TextIoWrapper. Par la suite, on peut utiliser les méthodes de cette
classe pour interagir avec le fichier.
• La méthode close() permet de fermer le fichier
• Exemple
file=open("[Link]","w")
print(file)
<_io.TextIOWrapper name='[Link]' mode='w' encoding='cp1252'>
Lire le contenu d’un fichier
• Pour lire le contenu d’un fichier, on utilise la méthode read() de la
classe TextIoWrapper. Elle renvoie l'intégralité du fichier
• Read () : renvoie tout le contenu du fichier
• readLine():
• Close()
Ecrire dans un fichier
• Pour écrire dans un fichier, il faut d'abord ouvrir le fichier .
• On peut utiliser le mode « w » ou le mode « a ».
• « w » écrase le contenu éventuel du fichier
• « a » ajoute ce que l'on écrit à la fin du fichier.
• Ces deux modes créent le fichier s'il n'existe pas.
• La méthode write() n'accepte en paramètre que des chaînes de
caractères. Si l’on souhaite écrire dans le fichier des nombres, il vous
faudra les convertir en chaîne avant de les écrire et les convertir en
entier après les avoir lus.
Modes d’accès Description
r Ouvre un fichier en lecture seule
rb Ouvre un fichier en lecture seule au format binaire

r+ Ouvre un fichier a la fois en lecture et écriture

rb+ Ouvre un fichier a la fois en lecture et écriture en

format binaire
w Ouvre un fichier en mode ecriture seule
wb Ouvre un fichier en mode ecriture seule au format
binaire
w+ Ouvre un fichier a la fois en écriture et lecture

wb+ Ouvre un fichier a la fois en écriture et lecture au

format binaire
a Ouvre un fichier en mode ajout
ab Ajout au format bianire

a+ À la fois pour l’ajout et la lecture

ab+ À la fois pour l’ajout et la lecture au format binaire

Module os
• Le module os contient beaucoup de fonctions intéressantes pour créer
et supprimer des fichiers et des répertoires.
• [Link](file, flags,mode)
• [Link](fd)
• [Link](args, kwargs)
• [Link](path,mode)
• [Link](path,mode)
Programmation système
• La programmation système est un type de programmation qui vise au
développement de programmes qui font partie du système
d'exploitation d'un ordinateur ou qui en réalisent les fonctions.
Les flux standard
• On distingue trois flux standard :
• L'entrée standard : elle est appelée quand vous utilisez input. C'est elle qui est
utilisée pour demander des informations à l'utilisateur. Par défaut, l'entrée
standard est votre clavier.
• La sortie standard : comme on l'a vu, c'est elle qui est utilisée pour afficher des
messages. Par défaut, elle redirige vers l'écran.
• L'erreur standard : elle est notamment utilisée quand Python vous affiche le
traceback d'une exception. Par défaut, elle redirige également vers votre écran.
Accéder aux flux standard
• On peut accéder aux objets représentant ces flux standard grâce au
module sys qui propose plusieurs fonctions et variables permettant
d'interagir avec le système.
• import sys
• [Link] # L'entrée standard (standard input)
• [Link] # La sortie standard (standard output)
• [Link] # L'erreur standard (standard error)
• [Link]("un test")
Modifier les flux standard
• Vous pouvez modifier [Link], [Link] et [Link].
• Exemple:
• fichier = open('[Link]', 'w')
• [Link] = fichier
• print("Quelque chose...")
• Pour connaître l'emplacement du fichier [Link] qui contient maintenant les sorties,
utilisez le module os et la fonction getcwd (Get Current Working Directory).
• Pour rétablir l'ancienne sortie standard, tapez la ligne :
• [Link] = sys.__stdout__
• Les objets standards sont : sys.__stdin__, sys.__stdout__ et sys.__stderr__.
Les signaux
• Les signaux sont un des moyens dont dispose le système pour
communiquer avec votre programme. Typiquement, si le système doit
arrêter votre programme, il va lui envoyer un signal.
• Les signaux peuvent être interceptés dans votre programme. Cela vous
permet de déclencher une certaine action si le programme doit se
fermer (enregistrer des objets dans des fichiers, fermer les connexions
réseau établies avec des clients, …).
• Les signaux sont également utilisés pour faire communiquer des
programmes entre eux.
Les différents signaux
• Le système dispose de plusieurs signaux génériques qu'il peut envoyer
aux programmes quand cela est nécessaire. Si vous demandez l'arrêt
du programme, un signal particulier lui sera envoyé.
• Pour plus d'informations, consulter la documentation du module
signal.
Intercepter un signal
• On commence d’abord par importer le module signal.
• import signal
• Le signal SIGINT est celui envoyé à l'arrêt du programme.