Les fonctions en Python Hiver 2018 - UNIVERSITÉ DE SHERBROOKE DÉPARTEMENT D'INFORMATIQUE - Université de Sherbrooke

La page est créée Corinne Charrier
 
CONTINUER À LIRE
UNIVERSITÉ DE SHERBROOKE
                                 DÉPARTEMENT D’INFORMATIQUE

                                                    IFT 211
                                        Les fonctions en Python
                                              Hiver 2018
                      Laboratoire #2      : exercices 1 à 7 (à faire individuellement)
                      Travail pratique #2 : à faire en équipe

Le but de ce laboratoire est de vous familiariser avec la programmation, principalement celle reliée à l’utili-
sation des fonctions.
Ce laboratoire et le devoir devront être complétés avant le 2 février 2018 à 23h59

Exercice 1 : Corrigez les erreurs
    Pour les programmes pgm1.py à pgm3.py fournis sur la page WEB pour le laboratoire, déterminez
quelles sont les erreurs présentes dans le programme et corrigez-les.
Exercice 2 : Le quotient et le reste
   Complétez le programme «quotientReste.py». en y implantant une fonction qui reçoit en entrée
deux nombres entiers et qui retourne le quotient et le reste de la division du premier nombre par le second.
Exercice 3 : Calcul de trajectoire
     Écrivez une fonction qui calcule la durée du trajet d’un projectile et son altitude au dessus du sol lorsqu’il
atteint la cible. Le programme prend donc en entrée l’angle du tir (en degrés), la distance de la cible et la
vitesse du projectile au départ. Intégrez votre fonction dans le programme «trajectoire.py». Utilisez
la fonction math.radians(angle) pour convertir les angles de degré à radian.
                                                                  distance
            Formule pour la durée du trajet : duree =
                                                            vitesse × cos(radian)

                                                                                          g × duree2
           Formule pour l’altitude : altitude = vitesse × sin(radian) × duree −
                                                                                               2
Exercice 4 : Volume d’une sphère
    Écrivez une fonction qui calcule le volume d’une sphère de rayon réel donné. Écrivez aussi le programme
principal qui lit le rayon, utilise cette fonction pour calculer le volume et affiche le volume. Ce programme
devra obligatoirement porter le nom de sphere.py.

Exercice 5 : Utilisation de fonctions
     Compléter le programme liste.py afin qu’il lise la liste des valeur contenues dans le fichier test_liste
et affiche les valeurs minimale et maximale, ainsi que la liste triée. Utiliser la fonction fournie dans le fichier
pour lire la liste dans le fichier. Il est important d’afficher seulement les résultats et dans l’ordre spécifié
(aucun texte accompagnateur dans le print ni dans le input).
    En Python, il est existe les fonctions min, max et sorted qui permettent de manipuler les listes.

                                                        1
Exercice 6 : Utilisation de la fonction MAP
     Compléter le programme encode.py et écrire le programme decode.py. Le programme encode.py
doit lire une chaîne de caractères en entrée et utiliser la fonction Map pour encoder cette chaîne selon le
code de César. Le code de César est une méthode d’encryptage simple qui consiste à remplacer chaque
caractère d’un texte par le caractère qui se situe trois positions plus loin dans l’alphabet. Par exemple, toutes
les lettres "b" du texte deviendront des "e". Pour les besoins de cet exercice, additionnez seulement 3 à la
valeur numérique de chaque caractère.
     Le programme decode.py doit lire une chaîne de caractères encodées selon le code de César et utiliser
la fonction Map pour décoder cette chaîne.
    Les fonctions suivantes sont fournies dans le fichier encode.py :
   — La fonction « ord » de Python permet d’obtenir la valeur numérique d’un caractère.
   — La fonction « chr » de Python permet de convertir une valeur numérique en caractère.
   — La fonction suivante permet d’encoder un caractère : def f(x) : return (chr(ord(x)+3))
   — La fonction suivante permet de transformer une liste « l », retournée par Map, en une chaîne de
     caractères : def toString(l) : return "".join(l)
   Utilisez la fonction map pour produire la liste des caractères encodées (ou décodées) et la fonction
toString pour reproduire la chaîne de caractères finale à partie de la liste.

Exercice 7 : Utilisation des fonctions MAP et Reduce
    Écrire un programme qui implante et affiche le résultat de l’opération suivante :
    C = 3A + B
    considérant que A et B sont deux vecteurs tel que A = [1,2,3,4,5,6,7,8,9] et B = [9,8,7,6,5,4,3,2,1]. Votre
programme devra ensuite afficher la somme du vecteur résultant.
    Ce programme devra obligatoirement porter le nom de vecteur.py.

Travail pratique #2 : Empreinte de carbone
Le travail peut être fait en équipe de deux personnes.
Le travail est à remettre le 2 février 2018 avant 23h59.

    L’ancien parti au pouvoir au Canada n’était pas réputé pour être pro-environnement. On lui reprochait
en particulier de ne pas investir suffisamment pour sensibiliser les canadiens aux problèmes environnemen-
taux reliés à leur style de vie. Afin d’améliorer les choses, le gouvernement canadien actuel a besoin d’un
logiciel qui peut aider la population à calculer son empreinte de carbone, à partir de quelques informations
sommaires.
    L’empreinte de carbone est la quantité totale de CO2 qu’une personne, par ses actions en matière de
consommation, dégage dans l’atmosphère chaque année. Au Canada, plus de 700 millions de tonnes de
CO2 sont émises annuellement, et cela depuis plus de 15 ans. Ceci implique une moyenne rapide de 24
tonnes de CO2 produites indirectement par habitant au Canada. Par contre, un individu est habituellement

                                                       2
responsable de la production directe d’au moins 5 tonnes de CO2 annuellement, à travers ses choix de
consommation. Ceux-ci se placent habituellement dans quatre catégories : habitation, transport, nourriture
et déchets.
   1. Émissions de CO2 reliées au transport

      Quatre moyens de transports produisant des émissions de CO2 sont communément utilisés par les
      canadiens : la voiture, l’autobus, l’avion et le train.
      Pour calculer les émissions dues à une voiture, il faut connaître le taux de consommation d’essence
      du véhicule (litres par 100 km), ainsi que la distance parcourue par l’individu à l’aide de ce moyen de
      transport dans la dernière année. Une fois ces valeurs connues, on peut calculer la quantité émise en
      sachant qu’un litre d’essence produit 5.2 lbs de CO2 . De plus, être propriétaire d’une voiture implique
      sa construction, son éventuelle destruction, ainsi que l’ensemble des réparations qu’elle subira, tout
      ceci étant indépendant de sa consommation en essence. On estime donc qu’être propriétaire d’une
      voiture implique l’émission indirecte d’au moins 2000 lbs de CO2 par année pour ces raisons.
      Les autres moyens de transports ayant une consommation plus difficile à suivre pour un individu
      spécifique, on peut utiliser une moyenne de production de CO2 par km par individu pour chacun :
      0,25 lbs/km en avion ; 0,105 lbs/km en train et 0,126 lbs/km en autobus.
   2. Émissions de CO2 reliées à l’habitation

      Cette quantité se calcule en combinant les émissions résultant de la consommation d’électricité en
      KWh ainsi que de la consommation de gaz naturel en litres, si l’habitation utilise le chauffage au gaz.
      Ces quantités sont habituellement calculées au mois sur les factures des compagnies d’électricité et
      de gaz. Les émissions de CO2 résultant de la consommation d’un KWh d’électricité dépendent des
      centrales électriques qui la produisent, certaines sont plus efficaces que d’autres. Afin de simplifier le
      calcul, on peut utiliser une moyenne nationale de 2,3 lbs de CO2 par KWh. Pour le gaz naturel, si on
      assume que le volume de gaz est mesuré à température et pression normales de 15 degrés celsius et
      101 Kilopascals de pression, un litre de gaz naturel produit 0,004 lbs de CO2 .
      Finalement, il ne faut pas négliger le fait que la plupart des gens n’habitent pas seuls, cette quantité
      de CO2 est donc seulement valable pour le nombre de personnes partageant la demeure ; il serait
      approprié de diviser les émissions entre les personnes.
   3. Émissions de CO2 reliées à la nourriture

      Il est difficile de calculer la quantité de CO2 dégagée par la consommation de nourriture de façon pré-
      cise sans avoir une grande quantité d’information sur les habitudes alimentaires du sujet, c’est-à-dire,
      la quantité de chacun des produits consommés et leur empreinte de carbone spécifique. Cependant, on
      peut s’en tenir à faire la différence entre de la nourriture produite localement et de la nourriture qui a
      dû être importée. En effet, pour une quantité de nourriture équivalente, les produits locaux entraînent
      environ 50% des émissions de CO2 provenant de produits importés, à cause du coût du transport.
      Si on fait la moyenne des émissions pour les aliments importés courants, on obtient des émissions
      de CO2 de 3000 lbs par an, si on consomme 1 lb de nourriture par jour. Cette valeur tient compte
      de l’énergie dépensée pour élever/faire pousser, transformer, empaqueter, transporter, ainsi que faire
      cuire les aliments.

                                                      3
4. Émissions de CO2 reliées aux déchets et au recyclage

      Ici, on peut assumer que chaque livre de déchet implique la production d’une livre de CO2 . Les
      quantités sont plus faciles à mesurer pour une unité d’habitation en entier, on peut donc diviser l’em-
      preinte de carbone provenant des déchets par le nombre d’habitants. Pour tenir compte du recyclage,
      il est plus facile de voir les déchets recyclés comme une proportion des déchets produits au total. Les
      déchets recyclés impliquent une production de CO2 80% inférieure à celle des déchets non-recyclés.
      Par exemple, si un appartement avec quatre habitants produit 6 lbs de déchets par jour, dont 50% sont
      recyclés, on obtiendrait une empreinte de carbone de 3,6 lbs de CO2 par jour pour l’appartement, et
      0,9 lb par personne par jour.

Pour faire le calcul, votre programme doit demander, dans l’ordre, à l’utilisateur les informations suivantes :
  —   Nombre de personnes dans l’habitation ;
  —   Distance parcourue en kilomètres pendant l’année en auto ;
  —   Taux de consommation d’essence de l’auto en litres par 100 km ;
  —   Distance parcourue en kilomètres pendant l’année avion, train et autobus ;
  —   Quantité d’électricité consommée par mois en KWh ;
  —   Volume de gaz naturel consommé par mois en litres ;
  —   Quantité de nourriture locale consommée par jour en livres ;
  —   Quantité de nourriture importée consommée par jour en livres ;
  —   Quantité de déchets produite par jour en livres ;
  —   Pourcentage des déchets qui sont recyclés.

Votre programme :

  — devra bien identifier les constantes.
  — devra afficher la quantité de CO2 émise annuellement en livres.
  — comprendra au moins 6 fonctions en plus de la fonction principale (main), i.e. une pour chaque
    catégorie d’émissions.
  — devra obligatoirement porter le nom de tp2.py.

Un de vos collègues a déjà débuté la programmation de la solution mais a disparu avant de terminer. Il vous
a laissé le code suivant (disponible sous le nom de tp2.py sur le site Web) :
#----------------------------------------------------------------
# nom : calculerEmissionTransport
#
# Fonction qui calcule la quantité de CO2 générée par le transport
#
# Entree : distance parcourue en avion (clavier)
#          distance parcourue en train (clavier)
#          distance parcourue en autobus (clavier)
# Sortie : émissions de CO2 pourle transport
#
# Auteur : inconnu
#-----------------------------------------------------------------

                                                      4
def calculerEmissionTransport():
  EMISSION_CO2_AVION = 0.25
  EMISSION_CO2_TRAIN = 0.105
  EMISSION_CO2_AUTOBUS = 0.126
  #----------------------------------------------
  # Fonction à créer pour calcule le CO2 pour les autos
  #-------------
  emissionsCO2Auto = calculerEmissionVoiture()

  print("Entrez la distance parcourue ")
  distanceParcourueAvion = int(input(" en avion : "))
  distanceParcourueTrain = int(input(" en train : "))
  distanceParcourueAutobus = int(input(" en autobus : "))

  #-----------------------------------------------
  # Calcul d’émissions de CO2 pour chaque type de transport
  # La fonction calculerEmissionsParUnite est à créer
  #--------------------------
  emissionsCO2Avion = calculerEmissionsParUnite(distanceParcourueAvion, EMISSION_CO2_AVION)
  emissionsCO2Train = calculerEmissionsParUnite(distanceParcourueTrain, EMISSION_CO2_TRAIN)
  emissionsCO2Autobus = calculerEmissionsParUnite(distanceParcourueAutobus, EMISSION_CO2_AUTOBUS)

  # Calcul de la quantité totale d’émissions
  emissionsCO2Transport = emissionsCO2Auto + emissionsCO2Avion + emissionsCO2Train   +
      emissionsCO2Autobus
  return emissionsCO2Transport

Voici un exemple d’exécution et de résultats attendus pour ce programme :

                                      Exemple d’exécution

   Entrez le nombre de personnes dans l’habitation   : 1
   Entrez la distance parcourue en voiture pas année : 20000
   Entrez le taux de consommation de la voiture      : 10
   Entrez la distance parcourue :
         - en avion   : 0
         - en train   : 4000
         - en autobus : 3000
   Entrez la consommation :
         - d’électricité en KWh par mois     : 200
         - de gaz naturel en litres par mois : 100
   Entrez la quantité de nourriture consommée :
         - locale   : 6
         - importée : 6
   Entrez la volume de déchets générés       : 6
   Entrez le pourcentage de déchets recyclés : 50

   La quantité de Co2 produite est : 47036.8

                                                   5
Soumission

Soumission du laboratoire 2
  1. Connexion sur Turnin (http ://opus.dinf.usherbrooke.ca)
  2. Soumettre les fichiers pgm1.py à pgm3.py, quotientReste.py, trajectoire.py, encode.py, decode.py,
     vecteur.py, sphere.py et liste.py

Soumission du travail patique 2
  1. Connexion sur Turnin (http ://opus.dinf.usherbrooke.ca)
  2. Soumettre le fichier tp2.py

                                                  6
Vous pouvez aussi lire