[PDF] Formation générale pour apprendre à utiliser Python | Cours informatique

(1)

Chapitre 11 : Introduction `

a Python

Alexandre Blondin Massé Département d’informatique Université du Québec à Montréal

22 novembre 2016

Construction et maintenance de logiciels INF3135

(2)

Table des mati`

eres

1. Introduction

2. Types de base

3. Structures de contrˆole et fonctions 4. Structures de donn´ees

5. Fichiers textes 6. Objets et modules

(3)

Pr´

esentation g´

en´

erale

I Con¸cu vers la fin des ann´ees 80;

I Créé par Guido Van Rossum, surnommédictateur bienveillant pour la vie;

I Les deux versions les plus utilis´ees sont 2.7,3.4et3.5 :

I La version2.7 ne sera plus supportéeaprès 2020; I Il est donc préférable, lorsque possible, d’utiliser

directement les versions3.4+;

I C’est la version 3.4 qui sera utilis´ee dans ce

cours.

I En 2014, Python aurait surpass´e Javacomme langage

(4)

Particularit´

es

I Traditionnellement d´ecrit comme un langage de script;

I Typagedynamique;

I Fortement orient´e-objet;

I Supporte partiellement le paradigme fonctionnel;

I Très près du pseudocode(c’est-à-dire de l’anglais);

I Langage interprété(par opposition à compilé);

I Peut être compilévers C pour gagner en efficacité, via le

(5)

Philosophie

I Le style de programmation est fondamental (on utilise l’adjectif pythonic).

I L’idiomatiqueest importante :

“There should be one — and preferably only one — obvious way to do it.”

I Une liste de 20 principes, appelésZen of Python, décrit la philosophie derrière ce langage;

I Le d´eveloppement du langage est r´egi par un processus

appel´e Python Enhancement Proposal (PEP)(aucun

(6)

Particularit´

es

I Toute variable est un objets, mˆeme les types de base;

I L’indentationest cruciale pour lacompilation;

I La syntaxe minimisel’emploi decaract`eres superflus :

I Pas de points-virgules;

I Pas d’accolades pour les blocs; I Pas de parenth`eses superflues, etc.

I On ned´eclare jamais le type d’une variable, celui-ci est

inf´er´e(typage dynamique);

I En revanche, le typage estfort (op´erationsinterdites

entre types non compatibles).

(7)

Biblioth`

eque standard

Une grandeforce de Python et l’ampleur de sabiblioth`eque

standard(batteries included) :

I Base de donn´ees relationnelles;

I Arithm´etique desgrands nombres;

I Nombres al´eatoires;

I Expressions r´eguli`eres;

I Interfacesgraphiques;

(8)

Fonctionnement

Il y a essentiellementdeux fa¸consd’utiliser Python :

1. Directement dans l’interpr´eteur(taper quit() pour

quitter l’interpr´eteur) :

2. En ex´ecutant unprogramme, via la commande

(9)

Table des mati`

eres

1. Introduction

2. Types de base

(10)

Types num´

eriques (1/2)

I Quatre types num´eriques :

I Lesentiers (int);

I Lesflottants (float);

I Lesfractionnaires (Fraction), pour repr´esenter les

nombresrationnels;

I _Les_d´_ecimaux ₍Decimal).

I Les op´erationsstandards sont disponibles : +, -, *, /, % # arithmetique de base

** # exponentiation

// # division entiere

I x / y retourne toujours unflottant, alors que x // y

(11)

Types num´

eriques (2/2)

>>> 3 + 5 8

>>> 3 / 5 # La division est fractionnaire

0.6

>>> 3 // 5 # Division entiere

0

>>> 2 ** 5 # Exponentiation

(12)

Le type None

I Le type None est utilis´e pour repr´esenter les valeurs nulles;

I Semblable `a null en Java et NULL en C.

>>> None

>>> x = None

>>> if x is None: print ’x is None’ x is None

(13)

Bool´

eens

I Les valeurs r´eserv´ees sont True ouFalse.

I Les op´erateurs sont desmotset non des symboles, comme

||,&&, etc. >>> True and False False >>> x = 2 >>> y = 3 >>> x + y == 5 True >>> x + y == 5 and x - y == -1 True >>> not x == 3 True

(14)

Chaˆınes de caract`

eres

I Pas de type char! Seulement le type string;

I On peut utiliser les apostrophes ou lesguillemets pour

repr´esenter des chaˆınes : >>> ’une chaine’ ’une chaine’ >>> ’attention a l\’apostrophe’ "attention a l’apostrophe" >>> "attention a l’apostrophe" "attention a l’apostrophe"

>>> ’Il repondit: "Je ne sais pas".’ ’Il repondit: "Je ne sais pas".’

I Pour laisser tels quels les caractères protégés (escaped), on préfixe avec r:

>>> r’Les caractere \n et \b sont speciaux’ # Noter le r au debut

’Les caractere \\n et \\b sont speciaux’

>>> print(r’Les caractere \n et \b sont speciaux’)

(15)

Chaˆınes multilignes

I Pour les chaˆınes sur plusieurs lignes: >>> print("""\

Usage: ./tp1 [OPTIONS]

-h --help Affiche l’aide

-v --verbose Affiche une trace de l’execution -o <fichier> Ecrit le resultat dans <fichier> """) # Pratique pour les menus d’aide, long textes, etc.

I Le r´esultat est alors

Usage: ./tp1 [OPTIONS]

-h --help Affiche l’aide

-v --verbose Affiche une trace de l’execution

-o <fichier> Ecrit le resultat dans <fichier>

I Peut être combiné avec le préfixer s’il y a des caractères \

(16)

Op´

erations sur les chaˆınes (1/5)

I Les chaˆınes de caract`eres sontimmuables;

I On accède au i-èmecaractère des avec la notations[i];

I On peut accéder au i-ème caractère à partir de ladroite

en utilisant des indicesn´egatifs: >>> s = ’python’

>>> s[0] # Les indices commencent a zero

’p’ >>> s[1] ’y’ >>> s[-1] # Le dernier caractere ’n’ >>> s[-2] # L’avant-dernier caractere ’o’ >>> s[-0] # Attention -0 = 0 ! ’p’ >>> s[10] # Erreur d’indice

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

(17)

Op´

erations sur les chaˆınes (2/5)

I On peut r´ecup´erer une sous-chaˆıneavec la notation

s[i:j] (i estinclus, j estexclu) : >>> s = ’python’

>>> s[2:4] # le 2-ieme caractere est inclus, le 4e exclu

’th’

>>> s[:3] # Si on omet i, on commence a 0

’pyt’

>>> s[1:] # Si on omet j, on va jusqu’a la fin

’ython’

>>> s[:-1] # On peut utiliser les indices negatifs

’pytho’

I Pour r´ep´eter plusieurs foisune chaˆıne >>> 2 * ’tou’

’toutou’

I Pour obtenir la longueurd’une chaˆıne :

>>> len(’python’) 6

(18)

Op´

erations sur les chaˆınes (3/5)

I La concat´enation(+) et la substitution(%) sont tr`es utiles :

>>> ’le langage’ + ’ python’ ’le langage python’

>>> x = 3 >>> y = 4

>>> ’x = %s et y = %s’ % (3, 4)

’x = 3 et y = 4’

>>> x = 4

>>> obj = ’objet’ if x < 2 else ’objets’

>>> ’il y a %s %s’ % (x, obj)

(19)

Op´

erations sur les chaˆınes (4/5)

I Equivalent de´ StringTokenizeren Java :

>>> s = ’montreal:quebec:canada’

>>> s.split(’:’)

>>> [’montreal’, ’quebec’, ’canada’]

I L’op´eration joinest aussi tr`es utile : >>> mots = [’montreal’, ’quebec’, ’canada’] >>> ’:’.join(mots)

(20)

Op´

erations sur les chaˆınes (5/5)

Plusieurs autres fonctions :

I s.lower() : transforme s en minuscules;

I s.isnumeric(): est-ce que s est un nombre?

I s.index(t) : retourne le premier indice o`u t apparaˆıt dans s;

I s.count(t) : combien de fois est-ce que t apparaˆıt dans s;

I s.endswith(t): est-ce que s termine par t? Voirici pour plus de d´etails.

(21)

Table des mati`

eres

1. Introduction 2. Types de base

3. Structures de contrˆole et fonctions

4. Structures de donn´ees 5. Fichiers textes

(22)

Structures conditionnelles

I On utilise les mots r´eserv´esif,elif etelse;

I L’indentationest primordiale(on sugg`erequatre espaces, pas detabulation);

I On ne met pas de parenth`eses ni d’accolades.

I On doit terminer la condition avec le caract`ere :;

I On utilise les op´erateurs bool´eens and,oretnot. if prix >= 100:

print("Rabais de 20%") elif prix >= 50 and prix < 100:

print("Rabais de 10%") elif prix >= 0:

print("Aucun rabais.") else:

(23)

Boucles while

I Comme dans la plupart des langages de programmation, on

peut ´ecrire des boucles tant que:

i = 10 while i > 0:

print i i -= 1

I Les bouclesdo-whilen’existent pas, mais on peut les

simuler en utilisant le mot r´eserv´ebreak : while True:

choix = saisir_choix() if est_valide(choix): break

I Le mot continueest aussi disponible, si on souhaite

(24)

Boucles for

I Ce sont les boucles les plus courantes;

I Nous verrons un peu plus loin qu’elles sont utilis´ees pour parcourir les structures de donn´eesclassiques;

I Par exemple, pour parcourir les ´el´ements d’une liste: for fruit in [’pomme’, ’banane’, ’fraise’]:

print(fruit)

I On peut parcourir les lettres d’une chaˆıne : for lettre in ’python’:

print(lettre)

# Affiche p y t h o n

I Aussi utilis´e en conjonction avecrange : for i in range(5):

print(i)

(25)

La fonction range

I En fait, range(start, end, step)d´esigne une suite

de nombres qui commence `a start, qui ne d´epasse pas

end et qui fait des bonds destep.

I Exemples :

>>> list(range(5))

[0, 1, 2, 3, 4] # On note que 5 est exclu

>>> list(range(1,4)) [1, 2, 3]

>>> list(range(10,30,5)) # Par bond de 5, 30 exclu

[10, 15, 20, 25]

>>> list(range(30,0,-5)) # Par bond de -5

[30, 25, 20, 15, 10, 5]

>>> list(range(0,30,-5)) # Peut retourner une liste vide

(26)

Fonctions

I On déclare une fonction à l’aide du mot réservé def;

I L’indentationd´etermine le d´ebut et la fin de la fonction;

I On utilise returnpour retourner une valeur :

def fibonacci(n):

if n == 0 or n == 1: return 1

else:

return fibonacci(n - 1) + fibonacci(n - 2)

I On appellela fonction comme `a l’habitude : print(’fibonacci(8) = %s’ % fibonacci(8))

(27)

Fonctions anonymes

I On peut construire une fonction anonyme `a l’aide du mot

r´eserv´elambda :

carre = lambda x: x * x

est_pair = lambda n: n % 2 == 0

I Ensuite, on appelle la fonction comme d’habitude;

I Souvent utilis´e en conjonction avec les fonctions max,min

etsort.

>>> maj = lambda s: s.upper() >>> maj(’roi’)

>>> ’ROI’

>>> mots = [’Banane’, ’fraise’, ’Fruit’, ’celeri’, ’Tomate’

]

>>> mots.sort(key=maj) >>> mots

(28)

Table des mati`

eres

3. Structures de contrˆole et fonctions

4. Structures de donn´ees

(29)

Structures de donn´

ees disponibles

Python offre directement lesstructures de donn´ees

classiques:

I Les tuples(immuables);

I Les listes(mutables);

I Les ensembles:

I set (mutables);

I frozenset (immuables);

(30)

Les tuples

I Permettent de regrouper plusieursobjets;

I On utilise des parenth`esespour les d´elimiter : (1, 2, 3)

(’INF3135’, ’Construction et maintenance...’, ’Lundi’, 3)

I On accède au i-èmeélément de tavec la notationt[i];

I On peutconcat´ener des tuples avec l’op´erateur+;

I Pratique pour des fonctions qui retournent plusieurs

valeurs :

def bornes(intervalle):

return (min(intervalle), max(intervalle))

I Essentiellement comme des listes, sauf que les tuples sont

(31)

Les listes

I Comme les tuples, mais mutables;

I Sans doute la structure de donn´ees laplus utilis´ee;

I On utilise des crochetspour les d´elimiter : [1, 2, 3]

[’INF3135’, ’Construction et maintenance...’, ’Lundi’, 3]

I On accède au i-èmeélément de tavec la notationt[i];

I On peutconcat´ener des listes avec l’op´erateur+;

I On peut extraire une sous-liste`a l’aide de la notation

(32)

Fonctions sur les listes

Plusieurs fonctions naturelles :

I L.append, pour ajouter un élément à la fin de la liste L;

I L.extend(M), pour ajouter les éléments de la liste M à la fin de la liste L;

I L.pop(i), pour supprimer et retourner le i-ème élément de L;

I L.sort(), pour trier la liste;

I L.reverse(), pour renverser la liste;

I L.count(x), pour compter le nombre de fois que x apparaˆıt dans L, etc.

(33)

La compr´

ehension de liste

I Extrˆemementutile etpuissante;

I Permet de définir deslistes sans avoir à insérer les ´

el´ementsun par un:

>>> print([i**2 for i in range(8)]) [0, 1, 4, 9, 16, 25, 36, 49]

>>> print([i**2 for i in range(8) if i % 2 == 0]) [0, 4, 16, 36]

>>> print([fibonacci(i) for i in range(10)]) [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

>>> print([[i*j for i in range(4)] for j in range(3)]) [[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]]

I Permet d’´eviter d’´ecrire du code tel que

resultat = [] for i in range(8):

if i % 2 == 0:

(34)

Parcours d’une liste

I On utilise le mot r´eserv´e for :

categories = [’verbe’, ’nom’, ’adjectif’, ’adverbe’] for categorie in categories:

print(categorie)

I Eviter l’expression´ range(len(...)) :

categories = [’verbe’, ’nom’, ’adjectif’, ’adverbe’] for i in range(len(categories)):

print(categories[i])

I Si l’indice est important, faire plutˆot

categories = [’verbe’, ’nom’, ’adjectif’, ’adverbe’] for (i,categorie) in enumerate(categories):

print("La categorie #%s est %s" % (i, categorie))

# Resultat

# La categorie #0 est verbe # La categorie #1 est nom # La categorie #2 est adjectif # La categorie #3 est adverbe

(35)

Les ensembles

I Lorsqu’on souhaite ´eliminer les doublons, on utilise les

ensembles;

I S’ils sont modifiables, on utiliseset();

I Parfois, il faut utiliser des ensemblesnon modifiables, et on utilise plutˆotfrozenset().

I Ils offrent plusieurs fonctionssimilaires aux listes;

I Exemple :

>>> mots = [’banane’, ’fraise’, ’pomme’, ’orange’]

>>> lettres = set([lettre for mot in mots for lettre in mot]) >>> lettres {’b’, ’r’, ’g’, ’p’, ’o’, ’m’, ’n’, ’f’, ’e’, ’a’, ’i’, ’s’} >>> len(lettres) 12 >>> sorted(lettres) [’a’, ’b’, ’e’, ’f’, ’g’, ’i’, ’m’, ’n’, ’o’, ’p’, ’r’, ’s’]

(36)

Op´

erations sur les ensembles

I Les op´erationsensemblistessont disponibles : >>> a = set(’fromage’) >>> b = set(’bleu’) >>> a | b >>> {’b’, ’g’, ’r’, ’u’, ’o’, ’m’, ’l’, ’a’, ’f’, ’e’} >>> a & b >>> {’e’} >>> a ˆ b >>> {’b’, ’r’, ’g’, ’u’, ’o’, ’m’, ’l’, ’a’, ’f’} >>> a - b >>> {’g’, ’r’, ’o’, ’m’, ’a’, ’f’}

I On peut aussi d´efinir un ensemble parcompr´ehension : >>> {x for x in ’abracadabra’ if x not in ’abc’}

(37)

Les dictionnaires

I Ce sont des tableaux associatifs;

I Ils permettent de mettre en relation des cl´esavec des

valeurs;

I Les cl´es doivent ˆetre immuables :

I Listes → Tuples;

I set → frozenset.

I Extrˆemementpratiques;

(38)

Op´

erations sur les dictionnaires

>>> infos = {’cours’: ’construction et maintenance’, ’sigle’: ’

inf3135’} >>> infos[’cours’] ’construction et maintenance’ >>> infos[’sigle’] ’inf3135’ >>> ’sigle’ in infos True

>>> list(infos.keys()) [’cours’, ’sigle’] >>> list(infos.values())

[’construction et maintenance’, ’inf3135’]

>>> text = ’un tres long texte avec des informations...’ >>> freq = {lettre: text.count(lettre) for lettre in set(text)

if lettre >= ’a’ and lettre <= ’z’} >>> freq

>>> {’v’: 1, ’i’: 2, ’c’: 1, ’g’: 1, ’r’: 2, ’f’: 1, ’u’: 1, ’o

’: 3, ’d’: 1, ’m’: 1, ’s’: 3, ’n’: 4, ’l’: 1, ’a’: 2, ’e’: 5, ’x’: 1, ’t’: 4}

(39)

Parcourir un dictionnaire

I On parcourt les paires cl´e/valeur`a l’aide d’une boucle

for :

text = ’un tres long texte avec des informations...’

frequences = {lettre: text.count(lettre)\

for lettre in set(text)\

if lettre >= ’a’ and lettre <= ’z’}

for (lettre, freq) in frequences.items():

print(’La lettre %s apparait %s fois’ % (lettre, freq))

I R´esultat :

La lettre v apparait 1 fois La lettre i apparait 2 fois La lettre c apparait 1 fois

...

La lettre e apparait 5 fois La lettre x apparait 1 fois La lettre t apparait 4 fois

(40)

Table des mati`

eres

5. Fichiers textes

(41)

Lecture ligne par ligne

I Extrêmementcourt à écrire :

with open(’countryInfo.txt’, ’r’) as input_file:

for line in input_file:

print(line)

o`u

I ’countryInfo.txt’est le nom fichier qu’on lit;

I ’r’ pr´ecise que le mode est lecture;

I input file est la variable du fichier;

I line prend la valeur de chaque ligne du fichier, une par une, incluant le\nfinal.

(42)

´

Ecriture dans un fichier

I Pour ´ecrire ligne par ligne, on utilise la fonction write:

with open(’resultat.txt’, ’w’) as output_file:

output_file.write(’Une ligne\n’)

output_file.write(’Une autre ligne\n’)

o`u

I ’resultat.txt’ est le fichier dans lequel on ´ecrit;

I ’w’ pr´ecise que le mode est ´ecriture;

I output file est la variable du fichier;

I Il ne faut pas oublier le caract`ere\npour changer de

ligne.

I Ici aussi, lafermeturedu fichier est gérée par le mot réservéwith.

(43)

Table des mati`

eres

5. Fichiers textes

(44)

Classes et objets

I Comme plusieurs langages, Python estorient´e-objet;

I H´eritage;

I H´eritage multiple comme enC++, par opposition `a Java;

I Polymorphisme;

I Surcharge desop´erateurs; I Pas de notionspriv´e/public.

I La mémoire est gérée par un ramasse-miettes(garbage collector), donc pas besoin dedestructeur;

(45)

Exemple

classVecteur(object):

def __init__(self, x,y, z):

r""" Constructeur """ self.x = x self.y = y self.z = z

def __repr__(self):

r"""

Representation d’un vecteur par une chaine de caracteres """

return’(%s, %s, %s)’ % (self.x, self.y, self.z) def __add__(self, other):

r"""

Addition de deux vecteurs """

returnVecteur(self.x + other.x,\

self.y + other.y,\ self.z + other.z) u= Vecteur(1, -1, 3) v= Vecteur(2, 4, -1) print(u) print(v) print(u +v)

(46)

Modules (1/2)

I Un module est simplement unfichier Python;

I Il peut regrouper plusieurs classes,fonctions, etc.

I Premi`ere fa¸con d’importer le module vecteur :

I import vecteur : ensuite, toute valeur est acc´ed´e avec la notation vecteur.<valeur>;

I Autrement dit, unespace de nom (namespace) est

(47)

Modules (2/2)

I Deuxi`emefa¸con d’importer le module vecteur :

I _{On peut ´}_{egalement importer seulement une} _classe_ou

une fonction d’un module;

I Par exemple,from vecteur import Vecteur

importe la classeVecteur, qui sera accessible sans utiliser le pr´efixe vecteur.

I La formulationfrom vecteur import * importetous

les objets et toutesles classes;

I Elle est cependant `a proscrirepour des raisons de

(48)

Le module random

# Choix d’un element aleatoire dans une liste

>>> import random

>>> echantillon = [’verbe’, ’adjectif’, ’nom’] >>> random.choice(echantillon)

’nom’

>>> random.choice(echantillon)

’adjectif’

’verbe’

# Generation d’une liste d’entiers aleatoires

>>> [random.randint(100, 200) for _ in range(20)]

[163, 152, 179, 138, 199, 170, 122, 164, 110, 104, 108, 193, 114, 110, 194, 182, 159, 153, 185, 188]

# Alternativement, on pourrait importer avec #

# from random import choice, randint

#

(49)

Exemple de script Python

#!/opt/local/bin/python

import sys

input_filename = sys.argv[1]

basename = input_filename[:-4]

in_solution = False

output_file = open(input_filename, ’r’) for line in output_file: