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

[fred]

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:

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

def ma_fonction():
    # suite

Avec paramètres

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.

def ma_fonction():
    # suite
    return valeur

Exemple :

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

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.

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...

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 :

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.

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)

>>> ord('A')
65

b) Ajouter 1 à chaque lettre codée en ascii
c) L'inverse de la fonction ord() est chr()

[DreAmuS]

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

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.

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.

[fred]

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)

[DreAmuS]

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

Voici la rectification.

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.

[fred]

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...

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é

[DreAmuS]

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.

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.

[fred]

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

Voici une correction.

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

[DreAmuS]

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.

[DreAmuS]

Exercice suivant j'ai eu un peu de temps :

# -*- 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:

# -*- 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

[DreAmuS]

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.

# -*- 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 ^^

[fred]

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.

[DreAmuS]

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.

[fred]

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

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

[DreAmuS]

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 :

# -*- 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)

# -*- 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.

[fred]

Ç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

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

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'