Bien sûr !
sortie, i = "", 0 est une série d'affectations. J'aurai pu écrire
sortie = ""
i = 0

% est l'opérateur "modulo" : x % y renvoie le reste de la division de x par y.

chr( ( ord(caract) + ord(cle[i]) ) % 256 )

L'objectif est d'obtenir un caractère codé, en faisant la "somme" d'un caractère en clair et d'un caractère de la clé.
clair + clé = code
J'additionne donc les codes ascii, puis je fais % 256 pour obtenir une valeur entre 0 et 256 -> on retombe sur la table ascii. On peut alors utiliser chr() pour obtenir le caractère correspondant, codé.

En espérant être clair ;)

Ouiii... enfin, ne poussons pas le vice trop loin ! :D Mais c'est vrai qu'en donnant comme valeur à chaque arc, les Km de routes qui séparent les deux villes, on peut trouver le parcours minimal en Km pour aller d'une ville donnée à une autre.
Ca ne devrait pas être trop dur à faire, vu ce qu'il y a déjà !

Je n'ai pas pu tester le code (pas installé PIL), mais je te propose ceci pour la méthode pluscourtchemin, de la classe Itineraire (modifications signalées par #<----):

def pluscourtchemin(self, G, start, end):
    def flatten(L):       # Flatten linked list of form [0,[1,[2,[]]]]
        while len(L) > 0:
        yield L[0]
        L = L[1]
    q = [(0, start, ())]  # Heap of (cost, path_head, path_rest).
    visited = set()       # Visited vertices.
    res = False   #<----
    fin = False   #<----
    while not fin:   #<----
        (cost, v1, path) = heappop(q)
        if v1 not in visited:
            visited.add(v1)
            if v1 == end:
                res = list(flatten(path))[::-1] + [v1]   #<----
                fin = True    #<----
            path = (v1, path)
            for (v2, cost2) in G[v1].iteritems():
                if v2 not in visited:
                    heappush(q, (cost + cost2, v2, path))
    return res   #<----


Pour être "propre", une fonction ne doit avoir qu'un seul point de sortie (return), et cela doit être sa dernière instruction. Visualise l'exécution comme un fluide qui sécoule du début à la fin de ta fonction : il n'y a qu'une entrée, il n'y a qu'une sortie. Entre les deux, le traitement. Il faut éviter de mettre des sorties n'importe où au milieu, ou on prend le risque de ne pas contrôler le flux.

De plus, si on fait abstraction de ton "return" au milieu du code, ta boucle "while True:" est une boucle infinie. Il faut absolument éviter ça, ça ne t'apportera que des ennuis !

En espérant être utile ;)
A++

Désolé, mais je n'ai pas reçu ton message, ou alors je ne peut pas le voir...
Je t'ai envoyé mon adresse mail sur ta messagerie privée. Et oui, elle est bien valide ;)
++

Oui, hum... Il me faudrait peut-être ton adresse mail, si tu veux que je t'envoie tout ça ! :) Passe-la moi donc par la messagerie privée (cliques sur mon pseudo), tu recevra un courriel avec un lien pour télécharger une archive zip avec tout ce qui va bien dedans.

En effet je n'ai pas publié le programme. Il te faut donc Visual Studio 2003 ou 2005. Il est payant, sauf si tu es étudiant en informatique ;)

Ce programme est une sorte de grosse usine à gaz qui te permettra d'écrire et utiliser des programmes écrits en VB.NET

Si tu ne peut pas te le procurer, je pourrai toujours t'envoyer le programme et ce qu'il faut par mail. Par contre tu ne pourras pas développer de programmes sans VS.

Bonjour à tous.
Je sais qu'il se fait tard, mais faut croire que j'aime à converser quelques mois (années?) après qu'un sujet se soit épuisé...

Pour commencer, thecryingshadow, la fonction MD5 est une fonction de hashage, pas de cryptage. On va me dire que je chipotte, mais les mots sont là pour ça. :)

Ensuite, ta fonction avecArgv() n'est pas une fonction. Une fonction (comme l'addition) retourne un résultat (2+2 = 4) qui peut être affecté à une variable
(res = 2+2). avecArgv() est une procédure. Parlons le même langage, ça aide à se comprendre.

Après les remarques amères :p, les remarques pratiques !
Il est déconseillé de donner à un scipt Python le même nom qu'un module existant. Ton script se nomme md5, et il importe un module nommé md5... A éviter.

Pour ce qui est de la variable CRYPTED, à éviter aussi : l'utilisateur n'a pas à changer le programme pour l'utiliser. Tu pourrai mettre un système d'appel à deux paramètres :
le premier indique que l'on veut hasher / retrouver un mot,
le second est le mot / le hash à traiter.
Exemple :

erreur = """
          Usage : md5.py option chaine
          option : -hash : hasher la chaine
                   -find : trouver le mot correspondant au hash chaine
         """
if len(argv) != 3:  #mauvais appel du programme
    print erreur

elif not argv[1] in ['-hash','-find']: #mauvaise option
    print erreur

elif argv[1] == '-hash':
    Hasher(argv[2])   #la chaine est un mot à hasher

elif argv[1] == '-find':
    Trouver(argv[2])  #la chaine est un hash : rechercher le mot correspondant


Voilà voilà. Ca devrait te servir ! Sauf si tu t'en sers déjà :)
Bonne continuation.

Oups... Petite correction : le déchiffrement ne se fait pas selon la même formule :
asc(clair) = (asc(codé) - asc(clé)) mod 256. Là ça marche !!

Au temps pour moi, je retire ce que j'ai dit. Je récapitule :

Chiffrer : (lettre_claire + lettre_clé) mod 256
Déchiffrer : (lettre_codée - lettre_clé) mod 256

Voilà !

Mais ton algo montre bien qu'avec un peu de volonté on y arrive, même sans s'embrouiller avec les maths ! ;) Cela dit, ça pourra t'économiser des lignes si tu fais une grosse appli sur les algorithmes de chiffrement.

Bon boulot, et bonne continuation !
A++

Salut DARKEENU,

A priori, cette formule devrait salement accélérer le processus... Maintenant, en tant qu'êtres humains, on ne verrait peut-être pas la différence ! ;)

Tu utilise tous les caractères ascii, exact ? donc pour avoir le code ascii d'un caractère crypté, tu fais : (asc(clair) + asc(clé)) mod 256. Du coup, tu as seulement deux mécanismes à faire tourner autour : parcourir toute la chaîne à crypter d'un côté, et en même temps tourner en boucle sur la clé de cryptage.

Ca devrait diminuer pas mal la longeur de ton code.
Exemple :

dim txt_clair as string
dim clé as string
dim txt_crypté as string
dim i as integer    'compteur de boucle : déplacement sur txt_clair
dim j as integer    'compteur de boucle : déplacement sur clé

'initialisation
txt_crypté = ""
j = 0

For i = 0 to txt_clair.length - 1 'parcours de la chaîne à crypter
    'cryptage
    txt_crypté = txt_crypté & chr((asc(txt_clair.chars(i)) + asc(clé.chars(j))) mod 256)

    'on avance sur la clé
    j = j + 1
    If j > clé.length - 1 Then j = 0  'on a atteint la fin de la clé : on se replace au début
Next

Ca suffit à chiffrer tout le texte !

Désolé c'est du .NET, je sais pas si c'est pareil sous VB6... Donc c'est plus court, c'est plus rapide. Tu trouveras des détails sur le chiffre de Vigenère sur http://fr.wikipedia.org/wiki/Vigen%C3%A8re.

Notamment ceci : pour décrypter un texte chiffré avec la table de Vigenère, il suffit de lui refaire subir le même traitement. Donc tu ne devrais pas avoir de fonction "décrypter", cela devrait fonctionner rien qu'en repassant le texte chiffré dans ta fonction Crypter. Ce qui n'est pas le cas... Ce n'est donc pas un chiffre de Vigenère !

Perso, je viens de tester la formule citée... Bilan : ça ne marche pas avec moi non plus !! :) Je vais essayer de voir pourquoi...

A++ !

Salut DARKEENU,

Si tu veux élargir le jeu de caractères, tu adaptes la numérotation : pour le jeu A..Za..z tu comptes 0..51, etc... Le tout c'est de respecter la même numérotation partout, et de faire modulo le nombre de caractères. C'est mathématique. A priori.

Maintenant, je dis ça, mais j'ai pas testé... Je te laisse l'honneur ;)

A++