This shows you the differences between two versions of the page.
sde:laboratoare:02 [2020/02/23 19:58] diana.ghindaoanu |
— (current) | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | ====== TP 2 - Python ====== | ||
- | |||
- | ===== Objectifs du laboratoire ===== | ||
- | |||
- | Le TP vise à vous familiariser avec le langage de programmation Python: | ||
- | |||
- | * Définir des variables | ||
- | * Se familiariser avec les structures de données | ||
- | * Utiliser des structures répétitives et fonctions | ||
- | * Créer des classes et des objets | ||
- | |||
- | |||
- | ===== Support de laboratoire ===== | ||
- | |||
- | * [[http://www.learnpython.org/]] | ||
- | * [[https://www.codecademy.com/learn/python]] | ||
- | * [[http://www.tutorialspoint.com/python/]] | ||
- | |||
- | ===== Paquets requis ====== | ||
- | |||
- | Pour pouvoir exécuter des programmes en Python 3, il faut installer les paquets nécessaires. Si vous ne les avez pas installés pendant le TP passé, il faudra exécuter la commande suivante dans le terminal: | ||
- | |||
- | <code bash> | ||
- | student@sde:~$ sudo apt-get install python3 python3-pip | ||
- | </code> | ||
- | |||
- | ===== Installer des modules ===== | ||
- | |||
- | <code bash> | ||
- | python3 -m pip install cowsay | ||
- | </code> | ||
- | |||
- | ===== Programmes en Python ===== | ||
- | Chaque fichier contenant du code source en Python aura l'extension **.py** et il sera exécuté dans le terminal caractéristique pour python3 avec la commande: | ||
- | |||
- | <code python> | ||
- | python3 index.py | ||
- | </code> | ||
- | |||
- | <note warning> | ||
- | La plupart des langages de programmation tels que C,C++,Java, utilisent les accolades {} pour définir les blocs de code. Contrairement à cette convention, Python utilise **l'indentation** pour séparer les différentes séquences. | ||
- | |||
- | Un bloc de code (corps d'une fonction, contenu d'une boucle) commence avec la première ligne indentée et se finit lorsqu'on arrive à la première ligne qui ne respecte plus l'indentation. L'indentation doit etre consistente à l'intérieur d'un certain bloc. | ||
- | |||
- | En général, on préfère un TAB pour l'indentation: | ||
- | |||
- | <code python> | ||
- | for i in range(1,11): | ||
- | print(i) | ||
- | if i == 5: | ||
- | break | ||
- | </code> | ||
- | </note> | ||
- | |||
- | ===== Variables ===== | ||
- | Contrairement aux autres langages de programmation, en Python il ne faut pas déclarer les variables ou leur type avant de les utiliser. De ce point de vue, Python fait partie de la catégorie des langages de programmation dynamiquement typés, où le type des variables n'est interpété qu'au moment de l'exécution. | ||
- | |||
- | === Variables numériques === | ||
- | |||
- | Python supporte 2 types numériques: entiers et réels. | ||
- | |||
- | <code python> | ||
- | # Syntaxe pour déclarer un numéro entier: | ||
- | myInt = 7 | ||
- | |||
- | # Syntaxe pour déclarer un numéro réel: | ||
- | myFloat = 7.0 | ||
- | myFloat = float(7) | ||
- | </code> | ||
- | |||
- | === Variables pour des chaînes de caractères === | ||
- | |||
- | <code python> | ||
- | myString = 'hello' | ||
- | myString = "hello" | ||
- | </code> | ||
- | |||
- | On peut réaliser l'attribution des valeurs aux plusieurs variables simultanément, mais sans mélanger les valeurs numériques avec les strings: | ||
- | |||
- | <code python> | ||
- | # Instructions valides | ||
- | a, b = 1, 2 | ||
- | suma = a + b | ||
- | </code> | ||
- | |||
- | <code python> | ||
- | # Instructions valides | ||
- | hello = "hello" | ||
- | world = "world" | ||
- | message = hello + " " + world | ||
- | </code> | ||
- | |||
- | <code python> | ||
- | # Cela ne va pas fonctionner | ||
- | |||
- | one = 1 | ||
- | two = 2 | ||
- | three = 3 | ||
- | hello = "hello" | ||
- | |||
- | print (one + two + three + hello) | ||
- | </code> | ||
- | |||
- | <note tip> | ||
- | Pour pouvoir afficher le résultat de la concaténation précédente, on peuq utiliser la fonction //str//, qui réalise la conversion des variables numériques dans des variables de type string: | ||
- | |||
- | <code python> | ||
- | one = 1 | ||
- | two = 2 | ||
- | three = 3 | ||
- | hello = "hello" | ||
- | |||
- | print ( str(one) + str(two) + str(three) + hello ) | ||
- | </code> | ||
- | |||
- | </note> | ||
- | |||
- | ===== Structures de données ===== | ||
- | |||
- | === Listes === | ||
- | |||
- | Les listes sont similaires aux arrays ou, plus simplement, aux ensembles. Elles peuvent contenire n'importe quel type de variables et le nombre des éléments n'est pas limité. Les listes peuvent être itérées de manière très simple, comme dans l'exemple suivant: | ||
- | |||
- | <code python> | ||
- | # Déclaration de la liste | ||
- | |||
- | mylist = [] | ||
- | |||
- | # Insertion des éléments | ||
- | |||
- | mylist.append(1) | ||
- | mylist.append(2) | ||
- | mylist.append(3) | ||
- | |||
- | # On affiche chaque élément | ||
- | |||
- | print( mylist[0] ) | ||
- | print( mylist[1] ) | ||
- | print( mylist[2] ) | ||
- | |||
- | # Output | ||
- | 1 | ||
- | 2 | ||
- | 3 | ||
- | </code> | ||
- | |||
- | <note> | ||
- | Comme dans tous les autres langages de programmation, les éléments d'une liste sont indexés en commençant par 0. | ||
- | </note> | ||
- | |||
- | |||
- | == Fonctions prédéfinies pour la gestion des listes == | ||
- | * **cmp( listName1, listName2)** -> comparer les éléments des 2 listes | ||
- | * **len( listName ) ** -> numéro des éléments de la liste | ||
- | * **max( listName )** -> l'élément ayant la valeur maximale | ||
- | * **min( listName )** -> l'élément ayant la valeur minimale | ||
- | |||
- | == Méthodes prédéfinies pour la gestion des listes == | ||
- | * **listName.append( element )** -> insérer un élément a la fin de la liste | ||
- | * **listName.count( element )** -> nombre d'occurrences de l'élément dans la liste | ||
- | * **listName.index( element )** -> index de la première occurrence de l'élément dans la liste | ||
- | * **listName.insert( index, element )** -> insertion de l'élément à l'index indiqué dans la liste | ||
- | * **listName.pop()** -> supprime et renvoie le dernier élément de la liste | ||
- | * **listName.remove( element )** -> supprime le dernier élément de la liste | ||
- | * **listName.reverse()** -> inverser l'ordre des éléments dans la liste | ||
- | * **istName.sort( [function] )** -> trier les éléments de la liste selon la fonction indiquée | ||
- | |||
- | === Dictionnaires === | ||
- | |||
- | Un dictionnaire est une structure de données, similaire aux vecteurs ou aux listes, mais fonctionne avec des valeurs et des clés au lieu des indices. Chaque valeur stockée dans un dictionnaire peut être accessible à l'aide d'une clé, représentée par n'importe quel type d'objet (une chaîne, un nombre, une liste, etc.), au lieu d'utiliser un index pour l'adresser. | ||
- | |||
- | Par exemple, les dictionnaires peuvent être utiles pour implémenter des bases de données. Supposons que nous ayons une base de données d'étudiants et que nous devons retenir la spécialisation pour laquelle chacun d'entre eux a opté. | ||
- | |||
- | **Déclarer un dictionnaire** | ||
- | |||
- | <code python> | ||
- | specialisation = {} | ||
- | |||
- | specialisation["Ana"] = "Informatique" | ||
- | specialisation["Radu"] = "Electronique" | ||
- | </code> | ||
- | |||
- | Ou bien | ||
- | <code python> | ||
- | specialisation = { | ||
- | "Ana": "Informatique", | ||
- | "Radu": "Electronique" | ||
- | } | ||
- | </code> | ||
- | |||
- | **Parcourir les éléments d'un dictionnaire** | ||
- | |||
- | <code python> | ||
- | for nom, spec in specialisation.iteritems(): | ||
- | print "Le nom de l'optionel ou %s a été répartisé est: %s" % (nom, spec) | ||
- | </code> | ||
- | |||
- | ** Eliminer des valeurs d'un dictionnaire** | ||
- | |||
- | <code python> | ||
- | del optionalRepartizare["Ana"] | ||
- | |||
- | # ou | ||
- | |||
- | optionalRepartizare.pop("Ana") | ||
- | </code> | ||
- | |||
- | ** Propriétés des clés dans un dictionnaire ** | ||
- | |||
- | Dans un dictionnaire, on n'a pas de restrictions pour les valeurs, mais les clés doivent etre uniques. Au cas ou on ne respecte pas cette propriété et on a 2 entrées ayant la meme clé, seulement le dernier enregistrement va rester valide. | ||
- | Par exemple, pout la suivante séquence de code: | ||
- | |||
- | <code python> | ||
- | age = { | ||
- | "Ana" : 14, | ||
- | "Ioana" : 13, | ||
- | "Ana" : 16, | ||
- | "Ioana" : 22, | ||
- | "Ana" : 11 | ||
- | } | ||
- | |||
- | print "Ana a %d années et Ioana a (de) %d années." % (age["Ana"], age["Ioana"]) | ||
- | |||
- | </code> | ||
- | |||
- | on va afficher le message suivant: "Ana a 11 années et Ioana a 22 années." | ||
- | |||
- | |||
- | == Fonctions utiles pour les dictionnaires == | ||
- | |||
- | * **cmp(dictionarUnu, dictionarDoi)** -> comparer les éléments des 2 dictionnaires | ||
- | * **len(numeDictionar)** -> numéro des éléments d'un dictionnaire | ||
- | * **str(numeDictionar)** -> génère une version facile a afficher du dictionnaire | ||
- | |||
- | == Méthodes utiles pour les dictionnaires == | ||
- | |||
- | * **numeDictionar.clear()** -> éliminer toutes les éléments du dictionnaire | ||
- | * **numeDictionar.copy()** -> retourne une copie du dictionnaire | ||
- | * **numeDictionar.get(key, default=None)** -> la valeur contenue dans le dictionnaire pour la cle "key", ou la valeur "default" sinon | ||
- | * **numeDictionar.has_key(key)** -> "true" s'il y a un enregistrement avec la clé indiquée et "false" sinon | ||
- | * ** numeDictionar.items() ** -> une liste avec toutes les paires du type (clé, valeur) qui se trouvent dans le dictionnaire | ||
- | * **numeDictionar.keys()** -> liste des clés | ||
- | * **dictionar1.update(dictionar2)** -> ajoute le contenu du dictionnaire //dictionar2// dans le dictionnaire //dictionar1// | ||
- | * **numeDictionar.values()** -> liste avec toutes les valeurs stockées dans le dictionnaire | ||
- | |||
- | ===== La structure de décision "if" ====== | ||
- | |||
- | <code python> | ||
- | # Décision simple | ||
- | |||
- | a = 33 | ||
- | b = 200 | ||
- | if b > a: | ||
- | print("b is greater than a") | ||
- | </code> | ||
- | |||
- | <code python> | ||
- | # Utiliser elif pour ajouter une condition supplémentaire | ||
- | |||
- | a = 33 | ||
- | b = 33 | ||
- | if b > a: | ||
- | print("b is greater than a") | ||
- | elif a == b: | ||
- | print("a and b are equal") | ||
- | </code> | ||
- | |||
- | <code python> | ||
- | # Le mot clé else prend tout ce qui n'a pas été inclus avant | ||
- | |||
- | 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") | ||
- | </code> | ||
- | |||
- | <code python> | ||
- | # Else sans elif | ||
- | |||
- | a = 200 | ||
- | b = 33 | ||
- | if b > a: | ||
- | print("b is greater than a") | ||
- | else: | ||
- | print("b is not greater than a") | ||
- | </code> | ||
- | |||
- | ===== Les structures répétitives ===== | ||
- | |||
- | === La boucle "for" === | ||
- | |||
- | <code python> | ||
- | listaDeNume = ["Ana", "Maria", "Ioana", "Irina", "Andreea", "Cristina"] | ||
- | |||
- | for nume in listaDeNume: | ||
- | print nume | ||
- | </code> | ||
- | |||
- | En Python, l'indice du pas ou l'on se trouve a chaque moment lorsqu'on parcourt une séquence n'est pas visible. Cependant, il y a une méthode pour compter les pas: la fonction **enumerate**: | ||
- | |||
- | <code python> | ||
- | cours= [ "Analyse", "SdE", "ALF"] | ||
- | |||
- | |||
- | for index, hobby in enumerate(cours): | ||
- | print index, hobby | ||
- | |||
- | # Output: | ||
- | 0 Analyse | ||
- | 1 SdE | ||
- | 2 ALF | ||
- | </code> | ||
- | |||
- | Une autre fonctionnalité est l'utilitaire **zip**, qui permet de parcourir 2 listes simultanément: | ||
- | |||
- | <code python> | ||
- | lista1 = [ 3, 9, 17, 15, 19] | ||
- | lista2 = [ 2, 4, 30, 24, 3] | ||
- | |||
- | for a, b in zip( lista1, lista2 ): | ||
- | if a > b: | ||
- | print a | ||
- | else: | ||
- | print b | ||
- | |||
- | # Output: | ||
- | |||
- | 3 | ||
- | 9 | ||
- | 30 | ||
- | 24 | ||
- | 19 | ||
- | </code> | ||
- | |||
- | Une autre particularité du langage Python est le fait qu'on peut appliquer la condition //"else"// aussi pour la boucle //"for"//. Dans ce cas, la branche "else" sera executée après la boucle "for", si et seulement si à l'intérieur de "for" on n'a pas une déclaration de type "break". | ||
- | Par exemple: | ||
- | |||
- | <code python> | ||
- | listeAnimaux = [ "loup", "lapin", "lion", "ours" ] | ||
- | |||
- | for i in listeAnimaux: | ||
- | print i | ||
- | if i == "lapin" | ||
- | print "Le lapin n'est pas sauvage" | ||
- | break | ||
- | else: | ||
- | print "Tous les animaux!" | ||
- | |||
- | # Output | ||
- | loup | ||
- | lapin | ||
- | Le lapin n est pas sauvage | ||
- | |||
- | #Si on execute la sequence suivante: | ||
- | for i in listeAnimaux: | ||
- | print i | ||
- | if i == "lapin" | ||
- | print "Le lapin n'est pas sauvage" | ||
- | else: | ||
- | print "Tous les animaux!" | ||
- | |||
- | # Output | ||
- | loup | ||
- | lapin | ||
- | Le lapin n est pas sauvage | ||
- | lion | ||
- | ours | ||
- | Tous les animaux! | ||
- | </code> | ||
- | |||
- | === La boucle "while" === | ||
- | |||
- | <code python> | ||
- | #Afficher les chiffres de 0 a 9 | ||
- | |||
- | count = 0 | ||
- | |||
- | while count < 10: | ||
- | print count | ||
- | count = count + 1 | ||
- | </code> | ||
- | |||
- | Comme pour la boucle "for" on a aussi la possiblité d'appliquer la condition "else" a la boucle "while". La différence est que le bloc "else" sera exécuté chaque fois que la condition de la structure répétitive sera évaluée comme fausse: | ||
- | |||
- | <code python> | ||
- | print "Dévinez de numéro de l'intervalle [ 1, 10 ]" | ||
- | |||
- | monNr = 7 | ||
- | votreNr = 0 | ||
- | |||
- | while votreNr!= monNr: | ||
- | votreNr = int( raw_input("Choisissez. ") ) | ||
- | else: | ||
- | print "Félicitations!" | ||
- | </code> | ||
- | |||
- | === Déclarations "break" et "continue" === | ||
- | |||
- | L'instruction //"break"// est utilisée pour sortir d'une structure répétitive, en étant une alternative pour la condition de sortie. Par exemple, on peut afficher les numéros de 0 a 9 de la facon suivante: | ||
- | |||
- | <code python> | ||
- | count = 0 | ||
- | |||
- | while True: | ||
- | print count | ||
- | count = count + 1 | ||
- | if count > 10: | ||
- | break | ||
- | </code> | ||
- | |||
- | La déclaration //"continue"// est utilisée pour ignorer un bloc d'instructions. Par exemple, on peut l'utiliser pour afficher les nombres pairs de 0 a 20: | ||
- | |||
- | <code python> | ||
- | number = 0 | ||
- | |||
- | while number < 21: | ||
- | if number % 2 == 1 | ||
- | continue | ||
- | print number | ||
- | </code> | ||
- | |||
- | ===== Fonctions ===== | ||
- | |||
- | === Déclaration === | ||
- | |||
- | <code python> | ||
- | def myFunction(): | ||
- | print "Welcome" | ||
- | |||
- | # ou | ||
- | |||
- | def simpleSum( a, b ): | ||
- | return a + b | ||
- | </code> | ||
- | |||
- | === Appel === | ||
- | <code python> | ||
- | myFunction() | ||
- | |||
- | # ou | ||
- | |||
- | first = 1 | ||
- | second = 1 | ||
- | sum = simpleSum( first, second ) | ||
- | print sum | ||
- | |||
- | print simpleSum( first, second ) | ||
- | </code> | ||
- | |||
- | |||
- | ===== Classes et Objets ===== | ||
- | |||
- | On appelle **objet** une encapsulation de variables et fonctions dans une seule entité, tandis qu'une **classe** représente un modèle pour la création des objets. Donc, in objet prend ses données d'une classe. | ||
- | |||
- | <code python> | ||
- | # Classe simple | ||
- | |||
- | class MaClasse: | ||
- | variable = "Bonjour" | ||
- | |||
- | def maFonction(self): | ||
- | print "Bonjour de l'autre part!" | ||
- | |||
- | |||
- | # Association classe objet | ||
- | monObjet = MaClasse() | ||
- | |||
- | |||
- | # Afficher le contenu de la variable de MaClasse | ||
- | print monObjet.variable | ||
- | |||
- | # Appeler la fonction maFonction, qui va afficher sur l'écran le message "Bonjour de l'autre part!" | ||
- | monObjet.maFonction() | ||
- | </code> | ||
- | |||
- | Le nombre d'objets qu'on peut créer a partir d'une classe n'est pas limité, tous les objets en héritant touts les particularités de la classe (variables et fonctions). Cependant, chaque objet contient des copies indépendantes des variables définies a l'interieur de la classe. Donc, si on crée unnouvel objet de la classe mere, on peut modifier son contenu sans affecter la definition initiale de la classe: | ||
- | |||
- | <code python> | ||
- | |||
- | class MaClasse: | ||
- | variable = "Bonjour" | ||
- | |||
- | def maFonction(self): | ||
- | print "Bonjour de l'autre part!" | ||
- | |||
- | monObjet1 = MaClasse() | ||
- | monObjet2 = MaClasse() | ||
- | |||
- | monObjet2.variable = "au revoir" | ||
- | |||
- | print monObjet1.variable | ||
- | print monObjet2.variable | ||
- | |||
- | #Output | ||
- | bonjour | ||
- | au revoir | ||
- | </code> | ||
- | |||
- | ====== Fonctions mathématiques ===== | ||
- | |||
- | <note warning> | ||
- | Pour pouvoir utiliser des fonctions qui exécutent des opérations mathématiques en Python, il faut importer et utiliser le module **math**. | ||
- | |||
- | <code python> | ||
- | import math | ||
- | </code> | ||
- | </note> | ||
- | |||
- | <note tip> | ||
- | Chaque fonction de la bibliotheque math sera appelée de la façon suivante: | ||
- | |||
- | <code python> | ||
- | math.functionName( params ) | ||
- | </code> | ||
- | |||
- | Quelques fonctions élémentaires de ce type sont: **floor**, **ceil**, **pow**, **sqrt**. | ||
- | </note> | ||
- | |||
- | <note tip> | ||
- | Il y a aussi des fonctions prédéfinies qui ne doivent pas être importées d'un module auxiliaire. Elles sont appelées comme il suit: | ||
- | |||
- | <code python> | ||
- | functionName( params ) | ||
- | </code> | ||
- | |||
- | Quelques exemple de cette catégires sont: **abs**, **round**, **sum**. | ||
- | </note> | ||
- | |||
- | <note important> | ||
- | Une liste complète des fonctions mathématiques de Python peut être trouvée [[https://docs.python.org/2/library/math.html|ici]]. | ||
- | </note> | ||
- | |||
- | ===== Exercices ===== | ||
- | |||
- | - Créez 3 variables de types différents, comme il suit: | ||
- | - une variable "int", qui va recevoir la valeur 20 | ||
- | - une variable "float", ayant la valeur 10 | ||
- | - une variable "string", qui va retenir la chaîne "python" | ||
- | |||
- | - En utilisant la fonction [[https://docs.python.org/2/library/functions.html#type|type]], déterminez le types des variables suivantes: | ||
- | - var1 = 2 | ||
- | - var2 = 5.6 | ||
- | - var3 = "Python" | ||
- | - Créez une liste avec les noms des filles ou des garçons de votre groupe. Le noms peuvent ne pas etre distincts. Résolvez les demandes suivantes: | ||
- | - Triez la liste des films | ||
- | - En utilisant une liste auxiliare, déterminez le numéro d'occurrences de chaque nom | ||
- | - Déterminez le nom qui a le numéro d'occurences maximal dans la liste initiale | ||
- | - Déterminez le nom qui a le numéro d'occurences minimal dans la liste initiale | ||
- | - Inversez l'ordre des éléments dans la liste initiale | ||
- | - A l'aide d'un dictionnaire, créez une base de données pour retenir quelques noms et numéros de téléphone de vos camarades. | ||
- | - Ecrives un programme qui va afficher sur l'écran tous les nombres pairs divisibles par 7 qui sont dans l'intervalle [0,3463]. Utilisez la fonctions [[http://www.learnpython.org/en/Loops|xrange]]. | ||
- | - Modifiez le code de l'exercice précédent de manière qu'au moment d'apparition du premier multiple de 123, l'algorithme s'arrête. | ||
- | - Créez une classe nommée "Employé" qui contienne les variables: "nom", "prénom", "age", "téléphone", "responsabilités" //(liste)//, et une fonction appellée "motto", qui va afficher le motto d'un employé. Créez 3 objets associés à la classe Employé et affichez leurs données. | ||
- | |||