Annonce

Réduire
Aucune annonce.

Les fonctions et procédures - COURS N°5

Réduire
Ceci est une discussion importante.
X
X
 
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Tutoriel Les fonctions et procédures - COURS N°5

    Bonjour,

    À savoir : Ce tutoriel risque d'être modifié, changé de place, voir même supprimé selon les décisions de l'équipe hackademics. Sa présence, est dû aux attentes des membres du forum participant au cours Python.

    Tout conseils, modifications à votre demande, sera envoyé par MP.

    PROBLÉMATIQUE

    Écrire une fonction PGCD permettant de retourner la valeur du plus grand diviseur de deux entiers naturels.

    Algorithme:

    Code:
    a,b : deux nombres
    Répéter tant que a et b sont différents :
      si le plus grand est a :
        les deux nombres deviennent a−b et b
      sinon (b est donc le plus grand) :
        les deux nombres deviennent a et b−a
    le pgcd est a
    QU'EST-CE QU'UNE FONCTION?

    Une fonction dans un programme est une étape utile à la résolution de votre problème.
    Elle peut ou non retourner une valeur.

    Si elle retourne une valeur on appelle cela une fonction
    Sinon se sera une procédure

    Python ne fait pas de réelle différence entre fonction et procédure, nous en resterons donc dans notre vocabulaire pythonien à fonction.

    Pour cela un plan s'impose
    1. Quand utiliser une fonction?
    2. Syntaxe
    3. Retourner un objet (entiers, chaîne de caractères, ...)
    4. Exécution d'une fonction
    5. Le pgcd et sa fonction



    I) QUAND UTILISER UNE FONCTION?
    1. Quand le problème devient difficile à résoudre (besoin de découper en étape la résolution du problème).
    2. Quand le code devient long, plus d'une page de code sans fonction, commence à rendre le code difficile à lire.
    3. Quand une tâche du code se répète plusieurs fois.



    II) SYNTAXE

    On utilise le mot clé def pour déclarer une fonction.
    Comme pour une boucle for ou while, la fonction est un bloc, elle se termine par ':' et une indentation.

    Deux types de syntaxe:
    • Sans paramètre
    • Avec paramètres


    Sans paramètre

    Code:
    def ma_fonction():
        # suite
    Avec paramètres

    Code:
    def ma_fonction(param_1, param_2, ...):
        # suite
    III) RETOURNER UN OBJET

    Pour retourner un objet (quelque-soit le type), on utilise le mot clé return en fin de fonction.

    Code:
    def ma_fonction():
        # suite
        return valeur
    Exemple :

    Créer une fonction retournant le carré d'un entier

    Code:
    def carre(a):
        """retourne le carre d'un entier"""
        return a * a
    IV) EXÉCUTION D'UNE FONCTION

    Simplement en lui demandant d'afficher avec print ou en enregistrant la valeur dans une variable.

    Code:
    def carre(a):
        """retourne le carre d'un entier"""
        return a * a
    
    square = carre(5) # enregistre 25 dans la variable square
    
    # ou
    
    print(carre(5)) # affiche 25
    V) LE PGCD ET SA FONCTION

    Comme vous le savez python regorge d'énormément de fonctions déjà pré-implantés dans sa bibliothèque standard pour nous simplifier la résolution de problèmes.
    Le PGCD ne fait pas exception à la règle, une fonction existe et se trouve dans le module fractions et se nomme gcd.

    Son utilisation est simple...

    Code:
    from fractions import gcd
    print(gcd(54, 46))
    Ce que je demande est de créer votre propre fonction pgcd connaissant l'algorithme écrit en début de cours.

    Sa structure syntaxique sera la suivante :

    Code:
    def pgcd(a, b):
        # suite
        return ...
    EXERCICES

    1) Résoudre le problème donné (PGCD)
    2) Créer une fonction is_anagram prenant en paramètres string_1 et string_2 et permettant de savoir si ces deux chaînes de caractères sont des anagrammes.

    Si se sont des anagrammes, la fonction retournera un booléen (True)
    Sinon la fonction retournera un autre booléen (False)

    Aide à la résolution:

    a) Python respecte la casse (minuscules et majuscules sont différenciées)
    b) Les deux chaînes doivent être de la même longueur

    3) Un des plus anciens systèmes de cryptographie (aisément déchiffrable) consiste à décaler les lettres d’un message pour le rendre illisible. Ainsi, les A deviennent des B, les B des C, etc. Ecrivez un code python qui demande une phrase à l’utilisateur et qui la code selon ce principe.

    Code:
    def crypt(string_1):
        # suite
    Ecrire sa fonction de décryptage.

    Aide à la résolution :

    a) Des lettres représentent en code ascii, des nombres entiers, comme par exemple 'A' vaudra en code ascii 65
    Pour cela on peut utiliser la fonction ord(letter)
    Code:
    >>> ord('A')
    65
    b) Ajouter 1 à chaque lettre codée en ascii
    c) L'inverse de la fonction ord() est chr()
    Dernière modification par fred, 09 mai 2013, 16h13.

  • #2
    Pour le premier exercice, j'ai suivit à la lettre ton Algorithme, ce qui donne :

    Code:
    def pgcd(a,b):
    
        while a != b :
            if (a>b):
                return a-b and b
            else:
                return a and (b-a)
    Voici pour le second exercice.
    Code:
    def is_anagram(string_1, string_2) :
        c1 = sorted(list(string_1.lower()))
        c2 = sorted(list(string_2.lower()))
        if (c1 == c2):
            return True
        else:
            return False 
    
    print (is_anagram('DreAmuS', 'DreAmuS'))
    print (is_anagram('DreAmuS', 'fred'))
    
    """ le résultat nous donne un true dans le premier print et un false dans le second """
    Je regarderais à résoudre les autres plus tard, suivant mon planning. Encore merci pour ces tutoriels.

    Commentaire


    • #3
      j'ai suivit à la lettre ton Algorithme, ce qui donne
      Sur le coup là je crois que non, relis bien l'algorithme, je ne dis en aucun cas, on retourne (a-b) et b ou a et (b-a)

      Commentaire


      • #4
        Effectivement, j'ai lu un peut trop vite ce matin à 5h du mat. Je ne devais pas être bien réveillé.

        Voici la rectification.

        Code:
        a = 56
        b = 42
        def pgcd(a,b):
        
            while a != b :
                if (a>b):
                    a = (a-b)
                            
                else:
                    b = (b-a)
        
        
        pgcd = a
        print (pgcd)
        Je planche sur le crypt dans la soirée. Merci de m'avoir signaler mon erreur.

        Commentaire


        • #5
          Ce n'est toujours pas correct, tu as testé ?

          Au final une fois que la boucle est terminé, les modifications sur a sont telles que a sera le PGCD, ok, mais il faut le retourner...

          Code:
          pgcd = a
          print (pgcd)
          Là tu dis simplement, pgcd = 56, afficher 56... et en plus tu écrases le nom de la fonction pgcd par une valeur.

          Essayes de pas aller trop vite et testes tes codes, sinon tu feras les choses à moitié

          Commentaire


          • #6
            Sincèrement, je ne comprends pas l'algorithme, désolé. J'ai tourné et retourné le problème dans tous les sens (sans chercher sur google), j'essais de le trouver par moi même avec tes données, mais rien n'y fait.

            Voici ma dernière conclusion qui pourtant suis ton algo à la lettre, ensuite si tu le comprends à ta manière, il m'est difficile de décerner les nuances.

            Code:
            a = 56 # 2 nombres entiers
            b = 42
            def pgcd(a,b): # la fonction posée
            
                while a != b :# tant que a différents de b
                    if (a>b): # si a est le plus grand
                        a,b = (a-b),b # a devient (a-b) et b reste le même
                        return pgcd (a,b) # je retourne la fonction
                              
                    else: # sinon si b est le plus grand
                        a,b = a,(b-a) # a reste le même mais cette fois b devient (b-a)
                        return pgcd (a,b) # je retourne aussi pgcd
            Voila, si tu lis c'est exactement l'algo traduit en code. Par contre, il ne fonctionne pas. Ou je ne vois pas la solution où comme je te dit l'algo est faux. Je ne sais pas quoi te dire de plus à part inventer ou prendre une solution toute prête sur google et faire un copier/coller.

            Merci de m'apporter les réponses, car la je rame et ça m'énerve.

            Commentaire


            • #7
              Si ça l'était ça fonctionnerait très bien

              Voici une correction.

              Code:
              def pgcd(a, b):
                  while a != b: # tant que a et b différent
                      if a > b:
                          a -= b # a devient a-b et b reste b
                      elif a < b:
                          b -= a # b devient b-a et a reste a
                  return a # le pgcd est a
              
              print(pgcd(56, 42)) # retourne 14, la fraction 56/42 se simplifie par 
                                  # (56/14) / (42/14) soit 4/3
              Dernière modification par fred, 27 septembre 2015, 15h35.

              Commentaire


              • #8
                Franchement, je dit bravo. Avec la solution c'est beaucoup plus facile je l'accorde. Je n'avais absolument pas pensé à cette solution. Je t'avoue que c'est passionnant. Cet après midi, je me pencherais sur crypt. Encore merci pour ces exercices qui font réfléchir et surtout pousse à réfléchir un max.

                Commentaire


                • #9
                  Exercice suivant j'ai eu un peu de temps :

                  Code:
                  # -*- coding: cp1252 -*-
                   
                  #Cryptage par décalage
                  
                  # demande du texte à décalée
                  textecrypt = input ("phrase à crypter :\n >>> ")
                  
                  # je définie ma variable décalée
                  textedecal = ""
                  
                  # Renversement avec for 
                  for i in  range(len(textecrypt)) :
                      textedecal = textecrypt [i] + textedecal
                  
                  # J'affiche mon résultat    
                  print (textedecal)
                  Je travaille sur la fonction crypt, je pense que je finirais ce week end et attaquerais ainsi la 6e partie.

                  Edit: J'ai encore lu à moitié avant que tu te jette sur mon code (qui soit disant passant fonctionne), j'ai vu que tu demander une fonction crypt() et decrypt(), seulement la formulation laisser présager le contraire.

                  Je me remet dessus ce soir et demain pour les 2 fonctions.

                  EDIT 2: Voici la solution:

                  Code:
                  # -*- coding: cp1252 -*-
                   
                  message = input ("donnez une phrase à codée >>> ")  # Demande de la phrase
                  chiffre = "" # on définie chiffre
                  def crypt(string_1,valeur): # la fonction crypt() qui a comme arguments string_1 et valeur 
                      return(chr(((ord(string_1)-ord('a')+valeur)%26)+ord('a'))) # on retourne la valeur ASCII de string_1 - celle de  a (98) modulo 26 auquel on rajoute a et on le repasse en chr
                  
                  for lettre in message:
                      if lettre.isalpha(): # utilisation de la fonction isalpha() vérifie si la chaîne se compose uniquement de caractères alphabétiques.
                          chiffre = chiffre + crypt(lettre,1) # On va utilisé la clé 1 qui ajoute +1 à chaque valeur pour avançé d'une lettre
                      else:
                          chiffre = chiffre + lettre # Si ce n'est pas un caractère, il ajoute tout simplement un espace
                  
                  print(chiffre)
                  Je bosserais sur le déchiffrement demain
                  Dernière modification par DreAmuS, 02 octobre 2015, 19h48.

                  Commentaire


                  • #10
                    Le décryptage avec la possibilité de choisir le décalage. J'ai essayer de récupéré l'espace ASCII 124 mais rien à faire. De plus, j'ai créer une fonction qui devait récupéré le retour du cryptage mais ne fonctionne pas. Après avoir étudier des heures comment fonctionne ce cryptage (je suis novice dans la cryptologie), j'ai réussis à élaborer ce bout de code qui fonctionne en piochant de ci de la des idées sur google.

                    J'aimerais beaucoup avoir une correction détaillé si possible, merci.

                    Code:
                    # -*- coding: cp1252 -*-
                    
                    message_crypt = input("Entrer le texte a décrypter : ")
                    
                    message_lg=len(message_crypt)
                    
                    message_decrypt = ""
                    
                    cle= int(input("Entrer la clé de décalage : ")) # Décalage du cryptage
                    
                    for lettre in range(message_lg):
                        asc=ord(message_crypt[lettre])
                        if asc>=33 or asc<=127:
                            asc=asc-cle
                            message_decrypt = message_decrypt + chr(asc)
                    
                        
                    print (message_decrypt)

                    PS: On m'a enlever les droits d'éditer mes postes du coup je suis obliger d'écrire à la suite ^^

                    Commentaire


                    • #11
                      Hello Dreamus

                      Exercice suivant j'ai eu un peu de temps
                      Si seulement j'en avais, actuellement je donne en plus de mes heures des formations adultes, du coup me reste plus de place dans l'emploi du temps...

                      Désolé si je suis un peu long à répondre, mais envoie un bip par MP pour que je visualise rapidement tes messages.

                      Pour le cryptage ça semble correct, même si il y a plus simple, l'essentiel est de comprendre et de résoudre, ce qui est fait !

                      Pour le décryptage, faudra attendre pour la correction, mais si cryptage est une somme, alors décryptage ne serait pas une différence ?

                      Je te laisse réfléchir, le temps que j'ai un peu de temps pour écrire le code et le tester.

                      À bientôt

                      PS: On m'a enlever les droits d'éditer mes postes du coup je suis obliger d'écrire à la suite ^^
                      On a rien retiré, c'est un fonctionnement standard à tous les membres.

                      Commentaire


                      • #12
                        Merci, je l'vais vu ainsi aussi, au départ avec la soustraction du résultat afin de récupérer la valeur de départ, cependant j'ai du tout reprendre à zéro car elle me définissait des erreurs. J'ai chercher sur stack et google, mais rien à faire.

                        Je serais heureux d'avoir la solution ici ou par mp pour savoir comment faire plus simple.

                        Pour ce qui est de la fonction d'éditer, je sais qu'elle est la même pour tous les membres, mais jusqu'alors je pouvais éditer et ceux sur plusieurs jours, je pouvais même éditer mes premiers posts mais depuis ce matin, j'ai le blocage membre classique.
                        Je pense alors que j'avais eu l'obtention d'un bug du forum depuis.
                        Ce n'est pas grave mais c'est vrai que pour créer des postes ce n'est pas évident de ne pas pouvoir revenir dessus.

                        Commentaire


                        • #13
                          Tu peux utiliser des algorithmes bien connus pour t'aider...

                          La correction pas avant demain, je ne suis pas là ce soir

                          Commentaire


                          • #14
                            Voici ma solution :

                            Pour ce faire je me suis inspiré de la formule de cryptage suivante :
                            Cryptage : En(x) = (x+n) mod 26
                            Décryptage : Dn(y) = (y-n) mod 26

                            mod 26 permettant d'accuser la possibilité d'avoir un nombre négatif en sortie non traitable.

                            Voici donc les 2 scripts finis et fonctionnelles :

                            Code:
                            # -*- coding: cp1252 -*-
                            
                            ##############################
                            ##      Cryptage Cesar      ##  
                            ##############################
                            
                             
                            message = input ("donnez une phrase à codée >>> ")
                            chiffre = ""
                            def crypt(string_1,valeur):
                                return(chr(((ord(string_1)-ord('a')+valeur)%26)+ord('a')))
                            
                            
                            cle = int(input ("Donner la valeur de la clé >>> "))
                            for lettre in message:
                                if lettre.isalpha():
                                    chiffre = chiffre + crypt(lettre,cle)
                                else:
                                    chiffre = chiffre + lettre
                            
                            print(chiffre)

                            Code:
                            # -*- coding: cp1252 -*-
                            
                            
                            ##############################
                            ##     Décryptage Cesar     ##  
                            ##############################
                            
                            message = input ("donnez une phrase à décodée >>> ")
                            
                            chiffre = ""
                            def crypt(string_1,valeur):
                                return(chr(((ord(string_1)-ord('a') - valeur)%26)+ord('a')))
                            
                            
                            cle = input ("Donner la valeur de la clé >>> ")
                            for lettre in message:
                                if lettre.isalpha():
                                    chiffre = chiffre + crypt(lettre,1)
                                else:
                                    chiffre = chiffre + lettre
                            
                            print(chiffre)

                            Je leur ai doté d'un appel à la Key permettant de ce fait de varier les cryptages et décryptages au loisir.

                            Je pense que cela a été un travail difficile pour moi qui ai des notions de crypto basique mais passionnant, j'ai même bosser sur d'autres fnctions de cryptologie en connexe à cet exercice.

                            Voila qui conclu ce poste,demain j'entamerais le suivant.

                            Je serais content d'avoir tes versions avec les détails afin de comparer sur une autre manière de concevoir le problèmes et de codage.


                            Merci fred par avance.

                            Commentaire


                            • #15
                              Ça semble correct, l'essentiel est de réussir et c'est fait, donc content pour toi

                              Ma solution, sans prendre en compte les erreurs utilisateurs

                              Pour le cryptage

                              Code:
                              from string import ascii_uppercase as alphabet # 'ABCDEFGHI...'
                              
                              def crypt(message):
                                  DECALAGE = 1
                                  N_LETTERS = 26
                                  message = message.upper() # transformation de la chaîne en majuscules
                                  
                                  result = '' # préparation du résultat final (chaine vide)
                                  for letter in message:
                                      ind = alphabet.find(letter) # on retrouve l'indice de la lettre dans alphabet
                                      result += alphabet[(ind+DECALAGE)%N_LETTERS] # on ajoute la lettre cryptée dans result
                                      
                                  return result
                                  
                              print(crypt('TPZ')) # 'UQA'
                              Pour le décryptage

                              Code:
                              from string import ascii_uppercase as alphabet # 'ABCDEFGHI...'
                              
                              def decrypt(message):
                                  DECALAGE = 1
                                  N_LETTERS = 26
                                  message = message.upper() # transformation de la chaîne en majuscules
                                  
                                  result = '' # préparation du résultat final (chaine vide)
                                  for letter in message:
                                      ind = alphabet.find(letter) # on retrouve l'indice de la lettre dans alphabet
                                      result += alphabet[(ind-DECALAGE)%N_LETTERS] # on ajoute la lettre cryptée dans result
                                      
                                  return result
                                  
                              print(decrypt('APZ')) # 'ZOY'
                              Dernière modification par fred, 04 octobre 2015, 10h42.

                              Commentaire

                              Chargement...
                              X