Menu

P11: Initiation à la programmation

03/09/18: P11/CM

Programme = suite d'actions à exécuter en suivant un ordre.
ex: Le matin, je me lève, petit déjeuner, jouer aux jv = programme = planning qu'un ordi va suivre.

L'ordi ne parle ni français ni anglais. Il parle binaire (en 0 et 1).
Il faut automatiser le processus de traduction humain-ordi = langage de programmation.
ex: Assembleur, Cobol/Fortran (cartes perforées), C++/Java/C#, Python.

Ecrire une suite d'instructions (=code source) → traduction en binaire (=compilation)
programme = expliquer en détail sous forme de texte = décomposer en petites actions simples
ex: s'habiller est vague; choisir ses habits, les enfiler, etc...

ex: chercher racines polynômes: chercher discriminant. 3 cas possibles.
-calculer une info, stocker une info, tester les infos et réagir en fonction, résultat.

Python → app web, dev jv, IA, calcul scient.

analyse complète: réfléchir, pas se lancer toute de suite dans le codage
résoudre à la main avec exs concrets
Identifier infos nécessaires. ex: rayon d'une cercle pour périmètre

2 modes: -interactif (console)
-script (code, programme)

-écrire programme (extension .py) (notepad, vi, Kate, Atom,...)
-lancer exécution
-analyser les erreurs (débogage)
-tester en identifiant l'ensemble des possibilités

sauvegarder le résultat (Δ...), une "boite" = variable
nom/identifiant: age_du_capitaine, nomPersonne... EXPLICITE
valeur: 18, "Capitaine Crochet"

Initialiser variable: =
age_du_capitaine = 18; nomPersonne = "Capitaine Crochet"

CONVENTION DE NOMMAGE:
-nom explicite
-mots séparés par des "_" OU majuscules
-1er caractère minuscule

afficher valeur, mot-clé: print

différentes types:
-nombres (entiers (int, -1), réels (float, 3.14) et complexes)
-chaînes de caractère (mots)
-booléen (true/false)
-...

différentes opérations:
-pour les nombres: addition/soustraction/multiplication/division
-pour les entiers: division entière (//) et modulo (%). 15 = 6 * 2 + 3, 2 = // et 3 = %
-pour les strings: juxtaposition de deux mots
-pour les booléens: and (et, vrai si toutes les expressions sont vraies), or (ou, vrai si au moins une expression vraie), not (pas, négation)

04/09/18: P11/CM

Commentaires: # (une seule ligne) ou """ (plusieurs lignes), non interprété, information additionnelle
Lié au problème résolu ou informations sur le programme (auteurs/version)

Remarques générales:
-longueur: ligne de code max: 79 caractères
-lignes vides pour séparer blocs logiques de code, avec parcimonie
-fichiers.py enregistrés en UTF-8 (donc pas de caractères spéciaux ou accentués)
-noms de variable commencent par des lettres minuscules
-20 lignes de codes maximum
-espace: PAS après "(" et PAS avant "(", PAS avant "(" lors d'un appel de fonction
-espace: avant et après "=" et opérations arithmétiques ("+","-","/","*",...), sauf pour faire ressortir les priorités des opérateurs

Lire une entrée saisie: input()
Il arrête l'exécution du programme et attends que l'utilisateur saisisse un texte qui peut ensuite être stocké dans une variable
Il faut préciser le type (int,float,bool), string par défaut
(input() est importé via AlgoPy, ne pas oublier la ligne de code "from AlgoPy import *")
Utilisation: var = input(commentaire,type)
var: variable stockante, commentaire: commentaire ajouté lors du prompt, type: type attendu

Exo: Calcule et affiche le total à payer pour un produit en n exemplaires d'un produit avec une remise de 10% et un taux de TVA de 20%

    #Infos indispensables
    prixObjet = input("Prix de l'objet à l'unité: ",float)
    nbObjet = input("Nombre d'objets: ",int)
    
    #Calcul
    totalHT = prixObjet * nbObjet
    totalTTC = totalHT * 1.2
    totalApresRemise = totalTTC * 0.9
    
    #Affichage
    print("Il faut payer",totalApresRemise)
    

Chaines de caractères
symboles → valeur binaire en octet par convention
ASCII: execmpe de codification

On distingue:
-les caractères (char), placés entre '. ex: 'A','5',','...
-les chaines de caractères (str), placés entre ". ex: "Bonjour","A",",","" (chaine vide)
concaténer deux chaines: +

04/09/18: P11/TD

Différents types:
-nombres: int (entier) et float (réels)
-booléen: true/false
-caractères: str (chaine), char (caractère seul)

Différentes opérations:
-chiffres: addition (+), soustraction (-), multiplication (*), division (/), entiers seulement: division entière (//), modulo (%)
-booléen: and (vrai si toutes les expressions sont vraies), or (vrai si au moins une expression est vraie), not (négation)
-str: concaténation (+)

Différentes fonctions:
-print(x): affiche x
-input(str,type): affiche un commentaire str et renvoie la valeur entrée de type type

Programme calculant l'âge de quelqu'un en 2018 en fonction de l'année de naissance

Information nécessaire: année de naissance
Exemple: 2000. 2018 - 2000 = 18. J'ai 18 ans.
Calcul à faire: 2018 - age

    #Programme qui affiche l'age en 2018
    #Auteur:
    #locale:
    # annee_naissance:int:annee de naissance
    # age:int:age en 2018
    
    #Saisie de l'annee de naissance
    anneeNaissance = input("En quelle annee etes-vous ne ?",int)
    
    #Calculer l'age
    age = 2018 - anneeNaissance
    
    #Afficher l'age
    print("Vous avez",age,"ans.")
    

Différents types:
Ecrire un programme qui demande à l'utilisateur d'entrer la longueur et la largeur d'un champ et qui en affiche le périmetre et la surface
Infos indispensables: longueur et largeur
Exemple: longueur: 3, largeur: 4, perimetre = 2*(3+4) = 14, surface = 3*4 = 12
Calcul: 2*(longueur+largeur), surface: longueur*largeur

    #Programme calculant le perimetre et la surface d'un champ
    #Auteur: 
    #locale:
    # longueur:float:longueur du champ
    # largeur:float:largeur du champ
    # perimetre:float:perimetre du champ
    # surface:float:surface du champ
    
    #Saisie des informations: longueur et largeur
    longueur = input("Longueur du champ: ",float)
    largeur = input("Largeur du champ: ",float)
    
    #Calcul du perimetre et la surface
    perimetre = 2*(longueur*largeur)
    surface = longueur*largeur
    
    #Afficher le perimetre et la surface
    print("Perimetre du champ:",perimetre)
    print("Surface du champ:",surface)
    

moyenne.py:

    #Programme qui calcule la moyenne en fonction des notes et les coefficients
    #Auteur:
    #locale:
    # note1:float:Première note
    # coeff1:float:Coefficient de la premiere note
    # note2:float:Deuxième note
    # coeff2:float:Coefficient de la deuxieme note
    # moyNorm:float:Moyenne normale
    # moyPond:float:Moyenne ponderee
    
    #Saisie des variables
    note1 = input("Premiere note: ",float)
    coeff1 = input("Coefficient de la premiere note: ",float)
    note2 = input("Deuxieme note: ",float)
    coeff2 = input("Coefficient de la deuxieme note: ",float)
    
    #Calcul des moyennes
    moyNorm = (note1+note2)/2
    moyPond = (note1*coeff1+note2*coeff2)/(coeff1+coeff2)
    
    #Affichage des moyennes
    print("Moyenne normale:",moyNorm)
    print("Moyenne ponderee:",moyPond)
    

imc.py:

    #Programme qui calcule l'IMC
    #Auteur:
    #locale:
    # taille:float:taille de la personne en m
    # pds:float:poids de la personne en kg
    # imc:float:IMC de la personne
      
    #Saisie des variables
    taille = input("Taille en m: ",float)
    pds = input("Poids en kg: ",float)
    
    #Calcul de l'IMC
    imc = pds/(taille*taille)
    
    #Affichage de l'IMC
    print("IMC:",imc)
    

06/09/18: P11/CM

Fonction => même séquence d'intruction utilisée à plusieurs reprises
plusieurs types de sous-programme:
-fonction: calcul d'une seule info (ex: cos())
-procédure d'affichage: pas de calcul, affichage uniquement (ex: print())
-...

mise en place:
-identifier le résultat que l'on souhaite trouver
-éléments indispensables pour y arriver: les paramètres de fonction
-différentes étapes pour transférer les données en résultat
=> chaque étape est une fonction intermédiaire
ex: A la caisse du McDo:
-résultat: prix à payer
-paramètres: prix du sandwich, prix de la boisson, prix du dessert

fonction Python:

    def nomFonction(listeParametres):
      bloc instruction
      return resultat
    

ex: fonction faireAppel() pour faire l'appel (appeler un par un chaque élève...)

def = instruction = se finir par ":". INDENTER (tabulation/espace)
convention de nommage: nom explicite, commence par minuscule.
Ne pas utiliser les mots réservés et aucun caractère spécial ou accentué
Les paramètres spécifient quelles infos il faut fournir en argument (il est possible qu'il n'y ai pas besoin d'arguments)
Une fonction s'utilise comme une instruction quelconque.
appel de fonction: nom de fonction suivi de "(" et ")"

commetaire fonction appelé en-tête: commente le fonctionnement de la fonction (pour être utilisée par d'autres personnes)
plusieurs infos:
-nom, type de retour, description brève
-détail des paramètres: nom, type, description
-détail du retour: type et description
-détail des variables locales: nom, type et description

Les paramètres sont préfixés par p pour les différencier des var locales
Ainsi, on voit qu'il est NON-MODIFIABLE

Les instructions s'exécutent les uns après les autres

if: instruction conditionnelle = "si"
n'effectue l'action que si la condition est vérifiée.
Utilisation: mot réservé if + (condition) + :

    if(condition):
      #bloc d'instruction
    

else = "sinon"
n'effectue l'action que si la condition du if est fausse
utilisation:

    if(condition):
      #instructions à exécuter si if est vrai
    else:
      #instructions à exécuter si if est faux
    

sinon on peut utiliser "pass" si aucune instruction suplémentaire doit être exécutée

elif = else if = "sinon si"
utilisation:

    if(condition1):
      #instructions à exécuter si condition1 est vrai même si condition2 l'est aussi
    elif(condition2):
      #instructions à exécuter si condition1 est faux mais que condition2 est vrai
    else:
      #instructions à exécuter si aucune des deux conditions n'est vraie
    

comparateurs:
- >, < (inégalité stricte)
- >=, <= (inégalité ou égalité)
- == égalité (/!\ DOUBLE == ! Le simple = est pour l'affectation)
- != (différent de)
Valides pour tout les types

Combiner: and, or...

    if(age < 18 or age > 65):
      print("Vous bénéficiez de tarifs réduits")
    else:
      print("Vous payez plein tarif")
    
La fonction str permet de convertir un nombre en une chaine, pour pouvoir l'afficher.

Opératons sur string:
-connaitre la longueur: (.size())
-récupérer un caractère à une position précise (.get(position))
-extraire une partie de la chaine (.substring(premierCaractere,nbCaractereAExtraire))
-ajouter un caractère (.add(chaineCaractere))
-vérifier si une chaine est vide (.isEmpty())
méthode pour les strings: string.operation()
Les opérations ne modifient en aucun cas le string.

07/09/18: P11/TD

en-tête fonction:

    """maFonction(paramA,paramB):fonct:typeRenvoye:description
    parametres:
      paramA:typeParamA:description
      paramB:typeParamB:description
    retour:
      nomRetour:typeRenvoye:description
    locales:
      nomLocale1:typeLocale:description
      .
      .
      .
    """
    

et sur l'en-tête générale:
nomFonction:fonct:typeRenvoye:description

imc.py:

    """Programme qui calcule l'IMC
    Auteur:
    locales:
      calcIMC:fonct:float:calcule l'IMC
      taille:float:taille de la personne en m
      pds:float:poids de la personne en kg
      imc:float:imc de la personne en kg
    """
    def calcIMC(taille,pds):
      """calcIMC:fonct:float:calcule l'IMC
      parametres:
        taille:float:taille de la personne en m
        pds:float:poids de la personne en kg
      retour:
        (anonyme):float:imc de la personne
      """
      return pds/(taille*taille)
      
    #Saisie
    taille = input("Taille en m: ",float)
    pds = input("Poids en kg: ",float)
    
    #Calcul
    imc = calcIMC(taille,pds)
    
    #Affichage
    print("IMC:",imc)
    

longueur_chaine.py:

    """Programme qui indique la longueur d'une chaine
    Auteur:
    locales:
      string:str:chaine a tester
      nbCarac:int:nombre de caracteres
    """
    
    #Saisie
    string = input("Chaine: ",str)
    
    #Calcul
    nbCarac = string.size()
    
    #Affichage
    print("Cette chaine a",nbCarac,"caracteres.")
    

concatener.py:

    """Programme qui concatene deux chaines
    Auteur:
    locales:
      str1:str:Premiere chaine
      str2:str:Deuxieme chaine
    """
    
    #Saisie
    str1 = input("Premiere chaine: ",str)
    str2 = input("Deuxieme chaine: ",str)
    
    #Calcul
    str1 += str2
    
    #Affichage
    print(str1)
    

verbe.py:

    verbe = input("Verbe: ",str)
    radical = verbe.substring(0,verbe.size())
    premSing = radical + "e"
    deuxSing = radical + "es"
    troiSing = premSing
    premPlur = radical + "ons"
    deuxPlur = radical + "ez"
    troiPlur = radical + ent"
    

majeur.py:

    age = input("Quel age avez-vous ? ",int)
    
    if(age < 0 or age > 130):
      print("Cet age est impossible.")
    elif(age < 18):
      print("Vous etes mineur.")
    else:
      print("Vous etes majeur.")
    

10/09/18: P11/CM

La répétition: while et for

while: se répète tant que la condition est valide
utilisation: while condition:

randint génère aléatoirement un nombre entier entre 2 bornes comprises

for: permet une itération un nombre connu de fois
utilisation: for i in range(min,max) (note: max exclus)
i est incrément avec un pas de pas_increment (1 par défaut)
Tant que i < max, le bloc est executé et i est à nouveau incrémenté

Utilisation de range:
-range(n): de 0 à n-1 (n étant exclu) avec un pas de 1
-range(ninf,nsup): de ninf à nsup-1 avec un pas de 1
-range(ninf,nsup,pas): de ninf à nsup-1 avec un pas de pas

for → traitement répétitif avec comptage, on connait le nombre d'itérations
while → lorsque le nombre d'itération inconnue (si la variable de condition est modifié dans le bloc conditionnel)