Besoin d'aide sur le loop d'une fonction Python

[comaX]

Bah désolé, mais en gros, dans le dico de fred, on a {1:A, 2:B, 3:C, etc.}. Puis, dico[(A-B)%26]. Donc, pour A-B = 0, 26, 52, etc., la clé du dico vaut 0, qui n’existe pas. De même, Z (clé 26) ne sera jamais trouvé, vusque puisque (A-B)%26 ne peut prendre que des valeurs [0 … 25] ! Donc, soit faut réduire de 1 les clés du dico (le plus simple), soit faut utiliser (A-B)%26+1 comme clé.

Mais encore une fois, il est nettement plus simple ici d’utiliser ord()/chr(), amha…

Bonne remarque, mais comme c'est une question de crypto sur nombre consécutifs, il est impossible de tomber sur une valeur A-B=0.

Oui j'ai simplement voulu suivre l'idée de comaX et son 1er post et donc commencer à 1 jusqu'à 26, sinon il est vrai que commencer à 0 jusqu'à 25 est plus logique.

Mais mont29 a raison, chr et ord sont plus efficaces je pense...

Si tu as suivi mon idée mais que tu penses que l'autre est meilleure, alors pas de doutes, prenons la meilleure !

[SAKAROV]

Je vais pas tarder à lâcher un algo de crypto version algorithmique simple pour "tester" tous ces bons membres histoire de prendre la température

La solution de mont29 me semble la plus aboutie (selon moi).

[fred]

Si tu as suivi mon idée mais que tu penses que l'autre est meilleure, alors pas de doutes, prenons la meilleure !

Non je pense que simplement tu prends celle que tu comprends le mieux syntaxiquement parlant, et que tu adaptes nos morceaux de code pour voir celui qui te convient le mieux.

Il ne faut pas oublier que mont29 comme moi ou les autres, on essaie de t'aiguiller, non de te faire tout le travail, donc le reste c'est à toi de jouer.

Je vais pas tarder à lâcher un algo de crypto version algorithmique simple pour "tester" tous ces bons membres

Il y a pas de compétitions entre nous, juste des fans de python qui aiment améliorer leur connaissance. On apprend beaucoup de nos interventions et on s'améliore dans le domaine.

Mais je pense que sur developpez tu as dû t'en rendre compte...

[comaX]

Bien, j'ai donc repris la solution de mont29, mais il y avait un petit soucis, c'est qu'il considérait bien A-B=0 comme A. Or c'est impossible. Pas de bile, il suffit de retirer 1, et tout marche. A-B=0 donne @, mais on s'en fout, on tombe jamais dessus. En revanche, les autres lettres apparaissent comme il faut.

J'ai lu une doc sur ord(), et j'ai rien pigé. Vous m'expliqueriez "in layman's term" à quoi ça sert ?
off a toujours une valeur de 65, je ne comprend pas d'où elle vient !

Sinon, voici le code, opérationnel :

#! /usr/bin/python
from string import ascii_uppercase


A = int(input("\tEnter the second number (A):\n\t"))
B = int(input("\tEnter the first number (B):\n\t"))


off = ord('A')


while True:
    #print(off)
    print(chr(((A-B) % 26) + off - 1))
    B = A
    A = int(input("\tEnter the next number:\n\t"))

Vous voyez, je me suis pas cassé le cul, mais le problème c'est que je ne comprend pas tout, et j'aime pas ça !

Non je pense que simplement tu prends celle que tu comprends le mieux syntaxiquement parlant, et que tu adaptes nos morceaux de code pour voir celui qui te convient le mieux.

Si vous n'aviez pas dit que c'était la meilleure solution, j'aurais fait avec les arrays ou le dico[i+1], qu'au moins je comprend. Mais je ne peux me résoudre à utiliser une méthode moins efficace sous prétexte que je suis pas foutu d'en biter une autre ^^

[fred]

Si vous testez sur votre interpréteur, vous aurez

>>> chr(65)
'A'
>>> ord('A')
65
>>> ord('Z')
90
>>> chr(90)
'Z'

ça représente tout à fait la table de correspondance entre un nombre et une lettre.

de 'A' à 'Z', on va donc du nombre 65 à 90

Vous devinez d'où vient le off maintenant?

il suffit de faire chr(((A-B)%26) + 65) pour avoir la lettre correspondante.

Si ((A-B)%26) = 0, alors chr(0+65) soit chr(65) soit 'A'

Après le -1 que vous rajoutez ne dépend pas du code de mont29 mais des nombres que vous entrez et de ce que vous souhaitez voir comme résultat.

Souvent on demande un exemple d'entrée sortie pour apporter une aide précise au PO

[comaX]

Merci pour cette précision, je comprend mieux ce bout de code !

Je suis maintenant en train de me renseigner sur comment lire les arguments, et dis donc, je préfère le bash ! Quelques coups de $1, $2, shift ici, shift là.
Là, j'ai du mal. Enfin, je viens de m'y intéresser d'un coté...

Juste une chose qui n'a rien à voir, n'hésite pas à me tutoyer, et si tu préfères que je te vouvoies, n'hésite pas non plus à le dire !

[fred]

Il est vrai que j'ai l'habitude de vouvoyer avec mes élèves et du coup ça sort naturellement certaines fois, même par écrit.

En ce qui concerne les arguments, vous voulez parler de l'exécution d'un fichier python ou des arguments d'une fonction?

python fichier.py arg1 arg2 #Exécution du fichier avec arguments

ou

def mafonction(arg1, arg2):
     pass

[comaX]

Il s'agit bien des arguments passés au programme.

J'ai trouvé sys.argv[] avec à l'intérieur des crochets la position de l'argument désiré. Donc, je pense qu'on pourrait faire quelque chose du style (pseudo code, non testé)

sys.argv[2] - sys.argv[1] pour le premier résultat, puis ensuite lui indiquer de passer à [3] avec une feinte du style i+1, mais je n'ai pas encore trop d'idée de comment faire ça !

[fred]

J'ai trouvé sys.argv[] avec à l'intérieur des crochets la position de l'argument désiré

Oui c'est ce qu'il te faut

sys.argv[2] - sys.argv[1]

Tu veux parler de A - B ?

puis ensuite lui indiquer de passer à [3] avec une feinte du style i+1

J'ai pas capté là

[comaX]

Oui oui, pardon, je suis allé un peu vite.

i=1
A = sys.argv[i+1]
B = sys.argv[i]
off = ord('A')
while "tant qu'il y a des arguments": 
   #print(off) 
   print(chr(((A-B) % 26) + off - 1)) 
   B = A
#incrémentation de i 
   A = sys.argv[i+1]

[afranck64]

@ComaX:
En se servant de sys.argv, ca pourrait donner:

import sys

lst = ["12", "2", "3", "4", "24", ]
def walkList(lst, offset=1):
    length = len(lst)
    for i, elt in enumerate(lst):
        if (i<length-1 and i>=offset):
            print(chr(((int(lst[i])-int(lst[i+1])) % 26) + 65))

walkList(lst,0) #K Z Z G
walkList(sys.argv)

[comaX]

J'ai édité mon message au même moment, que penses-tu du pseudo code que j'ai écrit ? Est-ce que ca ne serait pas plus simple ?

Edit : Voilà le code qui marche ! Bon, il galère juste sur la première lettre, je regarde ca de plsu près. Sinon, je pense ajouter une option pour lire à partir d'un fichier aussi, mais chaque chose en son temps !

#! /usr/bin/python
import sys
from string import ascii_uppercase

i=1
A = int(sys.argv[i+1])
B = int(sys.argv[i])


off = ord('A')


while True:
    #print(off)
    print(chr(((A-B) % 26) + off - 1))
    B = A
    i=i+1
    A = int(sys.argv[i+1])

[fred]

Pour avoir la liste des arguments, sauf le nom du fichier

sys.argv[1:] # retourne la liste des arguments entrés

[afranck64]

J'ai édité mon message au même moment, que penses-tu du pseudo code que j'ai écrit ? Est-ce que ca ne serait pas plus simple ?

i=1 A = entier(sys.argv[i+1])  #car c'est encore une chaine B = entier(sys.argv[i])   #car c'est encore une chaineoff = ord('A') while "tant qu'il y a des arguments":     #print(off)     print(chr(((A-B) % 26) + off -1)) #je suppose que les valeurs sont 1,2...26 (vous y tenez vraiment mais pourquoi?)    B = A #incrémentation de i     A = entier(sys.argv[i+1]) #car c'est encore une chaine

[comaX]

J'avais lu ça, oui, mais à quoi ça pourrait bien servir ici ?

Sinon, question concernant le formatage de la sortie, comment faire pour qu'il n'y ait pas une nouvelle ligne à chaque fois ? J'ai essayé d'ajouter "\r", mais ça n'a pas l'air de vouloir marcher.

@afranck, j'ai édité depuis avec un code qui marche
(sauf pour la fin de la boucle, évidemment, et cette lettre de début qui plante pour une raison que je ne connais pas encore !)