GLO-190 Introduction à la programmation avec Python

GLO-190 Introduction à la programmation avec Python Énoncés et syntaxe de base Marc Parizeau (automne 2011) Marc Parizeau, Département de génie électrique et de génie informatique

Plan Énoncés séquentiels expressions / affectations appels de fonction Énoncés conditionnels if / elif / else Énoncés répétitifs (boucles) for / else while / else break / continue Complexité algorithmique 2

Énoncés séquentiels Un énoncé se termine normalement par la fin d'une ligne on peut cependant séparer deux énoncés par un «;», mais il ne faut pas en abuser! >>> x = 1; y =2 on peut poursuivre un énoncé sur la ligne suivante lorsqu'on est à l'intérieur d'une paire de parenthèses («()»), de crochets («[]») ou d'accolades («{}») >>> x = [1, 2, 3,... 4, 5, 6,... 7, 8, 9] >>> print("une première chose,",... "une deuxième chose,",... "une troisième chose, etc.") Rappel: on veut limiter la longueur de nos lignes à 79 caractères ou moins! 3

Affectations Une affectation engendre toujours la création d'une référence sur un objet Python créé un nom de variable lors de sa première affectation la variable réfère toujours au dernier objet affecté Il faut toujours affecter une valeur à une variable avant d'utiliser celle-ci dans une expression quelconque >>> print(x) NameError: name 'x' is not defined 4

Les affectations peuvent prendre plusieurs formes plus ou moins complexes >>> spam = 'spam' >>> spam = ham = 'spam' >>> spam, ham = 'yum', 'YUM' >>> spam, ham ('yum', 'YUM') >>> [spam, ham] = 'yum', 'YUM' >>> spam, ham ('yum', 'YUM') >>> a, b, c, d = 'spam' >>> a, b, c, d ('s', 'p', 'a', 'm') >>> a, *b = 'spam' # le * désigne le reste >>> a, b ('s', ['p', 'a', 'm']) 5

Le principe est simple: on peut affecter un «itérable» dans un autre «itérable» chaque élément sera affecté à son correspondant dans la séquence >>> spam = 'spam' >>> a, b = spam[0], spam[1:] >>> a, b ('s', ['p', 'a', 'm']) >>> ((a, b), c) = ('sp', 'am') >>> a, b, c ('s', 'p', 'am') Cas de l'opérateur * >>> a, b = 'spam' ValueError: too many values to unpack >>> a, *b, c = 'spam' >>> a, b, c ('s', ['p', 'a'], 'm') >>> *a, b, c = 'spam' >>> a, b, c (['s', 'p'], 'a', 'm') >>> a, b, c, *d = 'spam' >>> a, b, c, d ('s', 'p', 'a', ['m']) 6

Affectations multiples: attention! >>> a = b = 0 >>> b = b + 1 >>> a, b (0, 1) >>> a = b = [] # a et b sont 2 références # sur le même objet >>> b.append(1) >>> a, b ([1], [1]) Opérateurs augmentés Au lieu d'écrire «b = b+1», on peut aussi écrire «b += 1» x += y x &= y x -= y x = y x *= y x ^= y x /= y x %= y x <<= y x >>= y x **= y x //= y 7

Noms de variable Le premier caractère est une lettre ou «_», les caractères suivants sont des lettres, des chiffres ou «_» «spam», «_spam» et «spam_1» sont légaux, mais pas «1_spam», «spam$», ni «@#!» Les majuscules et les minuscules sont différentes «spam», «Spam», et «SPAM» sont trois variables différentes Les mots réservés suivants ne doivent jamais être utilisés: False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise 8

Conventions Les noms qui débutent et se terminent par, par exemple «name» ont une signification spéciale pour l'interpréteur Python; ne pas les utiliser De même, les noms qui débutent par un seul «_» ne sont pas traités de la même façon que les autres lors de l'importation de modules nous y reviendrons plus loin... 9

Expressions Les expressions sont formées de: constantes variables (expression) expression opérateur expression fonction(expression, expression,...) >>> 1 # constante 1 >>> a # variable a >>> a + 1 # exp op exp >>> (a + 1) # ( exp ) >>> fct(a, b) # appel de la fonction fct 10

Fonction print() Ce qui est entre crochet est optionnel: print([exp1, exp2,...][,sep=' '][,end='\n']) La fonction affiche la valeur des expressions exp1, exp2, etc., énumérées en argument L'argument sep spécifie ce qui doit être affiché entre les valeurs par défaut, c'est un espace L'argument end spécifie ce qui doit être affiché après le dernier objet par défaut, c'est un retour à la ligne 11

print([exp1, exp2,...][, sep=' '][,end='\n']) >>> a = 1; b = 'spam'; c = [3, '4', 'spam'] >>> print() >>> print(a, b, c) 1 spam [3, '4', 'spam'] >>> print(a, b, c, sep='---') 1---spam---[3, '4', 'spam'] >>> print(a, b, c, end='---\n') 1 spam [3, '4', 'spam']--- 12

Quiz Nommez trois façons différentes pour affecter une valeur unique à trois variables différentes? Quel est le résultat de l'affectation suivante? >>> a, b, c, d, *e = 'spam' Quel est le problème potentiel lorsqu'on affecte le même objet à trois variables différentes? Soit la variable x associée à une liste. Quel est le problème avec l'énoncé «x = x.sort()»? 13

Énoncés conditionnels Format général: if <test #1>: <bloc d'énoncés #1> elif <test #2>: <bloc d'énoncés #2>... elif <test #n>: <bloc d'énoncés #n-1> else: <bloc d'énoncés #n> # optionnel # optionnel # optionnel Si le test #1 est vrai, alors le bloc d'énoncés #1 est exécuté, sinon si le test #2 est vrai, alors le bloc d'énoncés #2 est exécuté, sinon si...; autrement, si aucun des tests n'est vrai, alors le block d'énoncés #n est exécuté le nombre de clauses sinon si («elif») n'est pas limité; la clause autrement («else») est unique; ces deux clauses sont optionnelles 14

Un test est une expression booléenne (dont la valeur est «True» ou «False») >>> if True:... print('vrai') >>> else:... print('faux') Un bloc d'énoncés doit être indenté vers la droite d'un nombre fixe de colonnes le nombre d'espaces doit être rigoureusement le même pour tous les énoncés d'un même bloc par convention nous utiliserons 4 espaces 15

Par exemple: >>> print("entrez le jour de la semaine") >>> jour = input() >>> if jour == 'lundi':... act = "dépannage de 16:30 à 17:30" >>> elif jour == 'mardi':... act = "cours de 15:30 à 17:30" >>> elif jour == 'mercredi':... act = "aucune activité" >>> elif jour == 'jeudi':... act = "cours de 10:30 à 12h30\n"... act += "dépannage de 12:30 à 13:30" >>> elif jour == 'vendredi':... act = "dépannage de 13:30 à 16:30" >>> else:... act = "jour inconnu ou invalide!" >>> print("activités du jour:") >>> print(act) 16

Exemples d'exécution >>> ============================= RESTART ============================= >>> Entrez le jour de la semaine lundi Activités du jour: dépannage de 16:30 à 17:30 >>> ============================= RESTART ============================= >>> Entrez le jour de la semaine mardi Activités du jour: cours de 15:30 à 17:30 >>> ============================= RESTART ============================= >>> Entrez le jour de la semaine jeudi Activités du jour: cours de 10:30 à 12h30 dépannage de 12:30 à 13:30 >>> ============================= RESTART ============================= >>> Entrez le jour de la semaine samedi Activités du jour: jour inconnu ou invalide! >>> 17

Usage d'une liste d'activités >>> print("entrez le jour de la semaine") >>> jour = input() >>> act = [] # liste vide >>> if jour == 'lundi':... act.append("dépannage de 16:30 à 17:30") >>> elif jour == 'mardi':... act.append("cours de 15:30 à 17:30") >>> elif jour == 'mercredi':... act.append("aucune activité") >>> elif jour == 'jeudi':... act.append("cours de 10:30 à 12h30")... act.append("dépannage de 12:30 à 13:30") >>> elif jour == 'vendredi':... act.append("dépannage de 13:30 à 16:30") >>> else:... act.append("jour inconnu ou invalide!") >>> print("activités du jour:") >>> print(act) 18

>>> ============================ RESTART ============================ >>> Entrez le jour de la semaine lundi Activités du jour: ['dépannage de 16:30 à 17:30'] >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine mardi Activités du jour: ['cours de 15:30 à 17:30'] >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine mercredi Activités du jour: ['aucune activité'] >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine jeudi Activités du jour: ['cours de 10:30 à 12h30', 'dépannage de 12:30 à 13:30'] >>> 19

Usage d'un dictionnaire >>> print("entrez le jour de la semaine") >>> jour = input() >>> act = {'lundi': "dépannage de 16:30 à 17:30",... 'mardi': "dépannage de 16:30 à 17:30",... 'mercredi': "aucune activité",... 'jeudi': ("cours de 10:30 à 12h30",... "dépannage de 12:30 à 13:30"),... 'vendredi': "dépannage de 13:30 à 16:30"} >>> print("activités du jour:") >>> if act.get(jour):... print(act[jour]) >>> else:... print("jour inconnu ou invalide!") 20

>>> ============================ RESTART ============================ >>> Entrez le jour de la semaine lundi Activités du jour: dépannage de 16:30 à 17:30 >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine mardi Activités du jour: dépannage de 16:30 à 17:30 >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine jeudi Activités du jour: ('cours de 10:30 à 12h30', 'dépannage de 12:30 à 13:30') >>> ============================ RESTART ============================ >>> Entrez le jour de la semaine dimanche Activités du jour: jour inconnu ou invalide! >>> 21

Synthèse Les énoncés s'exécutent normalement du premier au dernier jusqu'à ce que vous précisiez autrement les énoncés conditionnels et répétitifs permettent de modifier le flux d'exécution Les blocs d'énoncés sont détectés automatiquement, basé sur l'indentation Les énoncés composés ont une forme normalisée <en-tête> «:» <bloc d'énoncés indentés> Les lignes blanches, les espaces et les commentaires sont habituellement ignorés par contre, le nombre d'espace en début de ligne détermine l'indentation l'indentation définit les frontières des blocs d'énoncés 22

x = 1 if x: y = 2 if y: print("bloc #2") print("bloc #1") print("bloc #0") Toujours utiliser des espaces pour indenter; jamais des caractères de tabulation il faut configurer adéquatement notre éditeur pour qu'il fasse le travail à notre place on appui sur la touche <tab> et l'éditeur insère le bon nombre d'espaces dans le fichier 23

Expression booléenne Tout nombre non zéro possède une valeur True zéro est équivalent à False Tout contenant (liste, tuple, dictionnaire, fichier, etc.) non vide possède la valeur True un contenant vide est équivalent à False Les opérateurs de comparaison (<, >, <=, >=, ==,!=) retournent soit True, soit False, selon le résultat de la comparaison Les opérateurs logiques and, or et not retournent True ou False selon le résultat de l'opération 24

if / else ternaire Forme: (exp1 if exp2 else exp3) retourne exp1 si exp2 est vrai, autrement exp3 par exemple: a = y if x else z équivalent aux énoncés: if x: a = y else: a = z 25

Quiz Décrivez deux façons de traiter un ensemble de cas? Comment fait-on pour construire une expression qui incorpore une condition? Comment fait-on pour étendre un même énoncé sur plusieurs lignes À quoi correspondent les valeurs True et False? 26

Énoncés répétitifs Deux énoncés possibles: while for Format général du while: while <test>: <bloc d'énoncés #1> else: # optionnel <bloc d'énoncés #2> 27

Par exemple: >>> while True:... print("entrer CTL-C pour m'arrêter!")... Entrer CTL-C pour m'arrêter! Entrer CTL-C pour m'arrêter! Entrer CTL-C pour m'arrêter! etc. >>> x = 'spam' >>> while x:... print(x, end=' ')... x = x[1:]... spam pam am m >>> a = 0; b = 10 >>> while a < b:... print(a, end=' ')... a += 1... 0 1 2 3 4 5 6 7 8 9 28

break / continue On peut utiliser l'énoncé break pour sortir de la boucle avant sa terminaison normale On peut se servir de l'énoncé continue pour passer immédiatement à l'itération suivante de la boucle Format général: while <test1>: <bloc d'énoncés #1> if <test2>: break if <test3>: continue # retourner au test1 <bloc d'énoncés #2> else: <bloc d'énoncés #3> # sortir de la boucle maintenant # exécuté lorsque test1 est faux Lorsque présente, la clause else est toujours exécutée à la fin de la boucle, sauf lorsqu'un break vient interrompre le déroulement normal de celle-ci 29

Par exemple: >>> while True:... nom = input("entrez un nom: ")... if nom == 'stop': break... age = input("entrez votre age: ")... print("bonjour %s!" % nom)... print("votre age au carré est %d"... % age **2)... Entrez un nom: Marc Entrez votre age: 47 Bonjour Marc! Votre age au carré est 2209 Entrez un nom: stop >>> 30

else Test pour vérifier si un nombre est premier (algorithme non optimal) >>> from math import sqrt >>> p = int(sqrt(x)) >>> while p > 1:... if x % p == 0:... print(p, "est un facteur de", x)... break... p -= 1... else:... print(x, "est premier!") 31

Boucle for Forme générale: for <cible> in <itérable>: <bloc d'énoncés #1> if <test>: break # facultatif if <test>: continue # facultatif else: # facultatif <bloc d'énoncés #2> pour chaque objet <cible> contenu dans un <itérable>, exécuter <bloc d'énoncés #1»; à la fin, exécuter <bloc d'énoncés #2> à condition de ne pas être sorti de la boucle avec un «break» le continue met fin à l'itération courante de la boucle le break met fin à la boucle les énoncés continue et break peuvent se trouver n'importe où dans le corp de la boucle 32

Par exemple: >>> for x in ['spam', 'eggs', 'ham']:... print(x, end=' ')... spam eggs ham >>> somme = 0 >>> for x in [1, 2, 3, 4]:... somme = somme + x... >>> somme 10 >>> produit = 1 >>> for x in [1, 2, 3, 4]:... produit *= x... >>> produit 24 33

On peut itérer sur tout ce qu'on veut; par exemple sur des tuples: >>> t = [(1,2), (3,4), (5,6)] >>> for (a,b) in t:... print(a, b)... 1 2 3 4 5 6 On peut aussi itérer sur les clés d'un dictionnaire: >>> d = {'a': 1, 'b': 2, 'c'= 3} >>> for x in d:... print(x, '=>', d[x])... a => 1 b => 2 c => 3 34

Approche équivalente utilisant la fonction items: >>> d = {'a': 1, 'b': 2, 'c'= 3} >>> for (cle,valeur) in d.items():... print(cle, '=>', valeur)... a => 1 b => 2 c => 3 Cas de l'opérateur * >>> l = [(1,2,3,4), (5,6,7), (8,9)] >>> for (a,b,*c) in l:... print(a,b,c)... 1 2 [3, 4] 5 6 [7] 8 9 [] 35

Boucles imbriquées >>> items = ['aaa', 111, (4,5), 2.01] >>> cles = [(4,5), 3.14] >>> for cle in cles:... print('cle', cle, end=' ')... for item in items:... if(item == cle):... print('trouvée')... break... else:... print('non trouvée')... cle (4, 5) trouvée cle 3.14 non trouvée Solution alternative: >>> for cle in cles:... print('cle', cle, end=' ')... if cle in items:... print('trouvée')... else:... print('non trouvée')... cle (4, 5) trouvée! cle 3.14 non trouvée. 36

While vs for? Quand doit-on utiliser la boucle while et quand doit-on utiliser le for? en Python on utilise le plus souvent le for, car il est conceptuellement plus simple et plus direct, lorsqu'on doit itérer sur tous les éléments d'un objet «itérable» (liste, tuple, dictionnaire, etc.) le while sert moins souvent, on l'utilisera dans des cas particuliers, par exemple lorsqu'on doit répéter des traitements sur des objets pour lesquels il n'est pas aisé d'itérer d'une façon régulière (rarement le cas) 37

range([start,]stop[,step]) Fonction qui produit une séquence itérable d'entiers compris dans l'intervalle [start,stop[, en utilisant le pas step par défaut, start = 0 et step = 1 >>> list(range(5)) [0, 1, 2, 3, 4] >>> list(range(-1,5)) [-1, 0, 1, 2, 3, 4] >>> list(range(5, -1, -1)) [5, 4, 3, 2, 1, 0] >>> for i in range(5):... print(i, end=' ')... 0 1 2 3 4 38

zip(*iterable) Reçoit un nombre quelconque d'objets «itérables» et retourne un autre «itérable» dont les éléments correspondent à l'agrégation des éléments des objets reçus >>> x = [1,2,3,4,5] >>> y = [6,7,8,9,0] >>> list(zip(x,y)) [(1, 6), (2, 7), (3, 8), (4, 9), (5, 0)] >>> for (i,j) in zip(x,y):... print(i,'+',j,'=',i+j)... 1 + 6 = 7 2 + 7 = 9 3 + 8 = 11 4 + 9 = 13 5 + 0 = 5 39

Quiz Quelle est la différence fondamentale entre une boucle while et une boucle for? Quelle est la différence entre les énoncés break et continue? Sous quelle condition la clause else d'une boucle est-elle exécutée? En supposant l'existence d'une liste de clés et d'une liste de valeurs, construisez un dictionnaire à l'aide d'une boucle for et de la fonction zip 40

Définition «en compréhension» d'une liste On peut aussi définir une liste en utilisant une expression similaire à l'énoncé for >>> a = [1,2,3,4,5] >>> b = [i+10 for i in a] >>> b [11, 12, 13, 14, 15] Sa forme simple est: [<exp> for <objet> in <itérable>] Nous verrons sa forme générale plus tard... 41

Documentation Les commentaires débutent par «#» tout ce qui suit est ignoré par l'interpréteur sert à documenter un ou plusieurs énoncés dont l'interprétation n'est pas évidente La fonction dir permet d'afficher l'ensemble des attributs associés à un objet: >>> dir([]) [' add ', ' class ', ' contains ', ' delattr ', ' delitem ', ' doc ', ' eq ', ' format ', ' ge ', ' getattribute ', ' getitem ', ' gt ', ' hash ', ' iadd ', ' imul ', ' init ', ' iter ', ' le ', ' len ', ' lt ', ' mul ', ' ne ', ' new ', ' reduce ', ' reduce_ex ', ' repr ', ' reversed ', ' rmul ', ' setattr ', ' setitem ', ' sizeof ', ' str ', ' subclasshook ', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] 42

L'attribut doc est une chaîne de caractères qui documente l'objet C'est ce qu'on appel la «docstring» >>> print([]. doc ) list() -> new empty list list(iterable) -> new list initialized from iterable's items La première string d'un fichier est sa «docstring» Documenter vos fichiers, vos classes et vos fonctions #!/usr/bin/env python # -*- coding: utf-8 -*- """ Description du module """ auteur = "Prénom Nom" date = "aaaa-mm-jj" coequipiers = "Coéquipier 1", "Coéquipier 2" class MaClasse(object): """Description de la classe """ def unefonction(): """Description de la fonction """ 43

Outil PyDoc3 Permet d'inspecter automatiquement tous les attributs d'un objet et d'afficher la documentation associée à ces attributs les classes les fonctions les données La fonction help permet d'afficher la documentation associée à un objet directement dans l'interpréteur Le programme Pydoc3 affiche une interface graphique et permet de consulter la documentation en HTML Si vous documentez adéquatement votre code, vous pourrez vous aussi produire automatiquement une documentation sous forme de pages web 44

Complexité algorithmique Un programme traite habituellement un nombre variable de données L'ordre de la complexité algorithmique indique la façon dont le temps d'exécution croît avec la quantité de données à traiter croissance linéaire O(n) croissance quadratique O(n 2 ) croissance cubique O(n 3 ) etc. 46

Dans le cas linéaire, lorsqu'on double la quantité de données, on double aussi le temps de traitement Dans le cas quadratique, cependant, lorsqu'on double la quantité de données, on quadruple le temps de traitement La notation O(f(n)) spécifie que l'ordre de la complexité se comporte au plus comme une fonction en f(n), où n est la taille du problème (la quantité de données) c'est une borne supérieure sur la complexité on appelle cette notation «Big-O» 47

x 2x 10x 100x O(n) O(n 2 ) O(n 3 ) O(n log n) 1 2 10 100 1 4 100 10000 1 8 1000 1000000 1 ~2.3 ~15 ~200 Croissance du temps de calcul pour une algorithme hypothétique requérant 1 unité de temps pour résoudre un problème de taille x 48

temps O(n 3 ) O(n 2 ) O(n log n) O(n) n 49

Par exemple, un algorithme simple de tri sera O(n 2 ); p. ex. le «tri bulle» Un bon algorithme de tri (comme celui du Python) est O(n log n) dans le pire des cas Problème du «Maximum Subsequence Sum» (MSS) dans une séquence quelconque d'entiers (positifs et négatifs), on veut trouver la sous-séquence dont la somme des éléments est maximum a1 a2 a3 a4... an-3 an-2 i j 50

MSS - algorithme #1 Essayer toutes les sous-séquences: il y en a autant que le nombre de combinaisons de 2 objets choisis parmi n+1 (sans répétition) C(2,n+1) = (n+1) x n / 2 = O(n 2 ) Pour chaque sous-séquence, calculer la somme qui, en moyenne, contient un nombre de termes proportionnel à n Au total, O(n 3 ) opérations sont nécessaires 51

def MSS1(sequence): n = len(sequence) maxsum = 0 for i in range(n): for j in range(i, n): thissum = 0 for k in range(i,j): thissum += sequence[k] if thissum > maxsum: maxsum = thissum return maxsum a1 a2 a3 a4... an-3 an-2 i j 52

MSS - algorithme #2 Soit «Si,j» la somme des termes de la sous-séquence (i,j) Observation: Si,j+1 = Si,j + aj+1 Le calcul de la somme peut donc se faire en temps constant, à condition de mémoriser la somme précédente L algorithme devient quadratique! 53

def MSS2(sequence): n = len(sequence) maxsum = 0 for i in range(n): thissum = 0 for j in range(i, n): thissum += sequence[j] if thissum > maxsum: maxsum = thissum return maxsum a1 a2 a3 a4... an-3 an-2 i j 54

MSS - algorithme #3 Doit-on vraiment considérer toutes les sous-séquences? Observation: une sous-séquence négative ne peut pas précéder la MSS, sinon on l enlèverait!... S < 0 MSS?... i j 55

def MSS3(sequence): n = len(sequence) thissum = maxsum = 0 i = j = 0 while j < n: thissum += sequence[j] if thissum > maxsum: maxsum = thissum elif thissum < 0: i = j + 1 thissum = 0 j += 1 return maxsum a1 a2 a3 a4... an-3 an-2 i j 56

Conclusion L'indentation fait partie intégrante de la syntaxe du python utiliser les espaces pour indenter L'énoncé if / elif / else permet d'exécuter des blocs d'énoncés conditionnellement indenter le bloc d'énoncés ; ne pas oublier le «:» Les énoncés while / for / else permettent de boucler sur un bloc d'énoncés indenter le bloc d'énoncés ; ne pas oublier le «:» utiliser l'énoncé break permet terminer prématurément la boucle; utiliser l'énoncé continue pour passer immédiatement à l'itération suivante 57

Il faut documenter vos programmes chaque fichier chaque classe chaque fonction Le fait d'imbriquer des boucles augmente généralement la complexité algorithmique attention aux complexités quadratique et cubique qui, en pratique, limitent fortement la taille des problèmes pouvant être résolus dans un temps raisonnable 58

Quiz Comment pourrait-on modifier les solutions du problème MSS pour retourner à la fois la valeur de la sousséquence maximum et les indices qui la définissent? comment identifier ces indices? comment retourner trois valeurs au lieu d'une seule? 59