Compréhension de liste Python - accès dernier élément créé?

Question

Est-il possible d'accéder à l'élément précédent généré dans une liste de compréhension. Je travaille sur des trucs de cryptage de jouets. Étant donné la clé comme un entier arbitrairement grand, une valeur d'initialisation et une liste d'éléments comme le message à chiffrer. J'ai besoin de xor chaque élément avec l'élément chiffré précédent et la clé. La boucle suivante ferait l'affaire.

previous = initialization_value 
cipher = [] 
for element in message: 
    previous = element^previous^key 
    cipher.append(previous) 

je me sens comme il devrait être possible de transformer cela en une compréhension de la liste mais je ne sais pas exactement comment gérer à la fois la valeur initiale ou l'accès à la valeur précédente générée. Est-ce possible et si oui, quelle serait la compréhension?

Answer 1

Il n'y a pas une bonne façon, Pythonic, de le faire avec une compréhension de liste. La meilleure façon de penser à la compréhension des listes est de remplacer map et filter. En d'autres termes, vous utiliseriez une compréhension de liste chaque fois que vous devez prendre une liste et

• Utilisez ses éléments en entrée pour une expression (par exemple, mise au carré des éléments)

• Retirez certains de ses éléments selon une condition

ce que ces choses ont en commun est que chacun ne regard sur un élément de liste unique à la fois. C'est une bonne règle générale. même si vous pouviez théoriquement écrire le code que vous avez montré comme une compréhension de liste, ce serait maladroit et non pythonique.

Answer 2

Vous pouvez utiliser un objet d'aide pour stocker tout l'état interne tout en évoluant sur la séquence:

class Encryption: 
    def __init__(self, key, init_value): 
    self.key = key 
    self.previous = init_value 
    def next(self, element): 
    self.previous = element^self.previous^self.key 
    return self.previous 

enc = Encryption(...) 
cipher = [enc.next(e) for e in message] 

Cela étant dit, en ajoutant l'élément chiffré précédemment dans le XOR ne rend pas votre algorithme plus dur à casser que juste xor'ing chaque élément avec la clé. Un attaquant peut simplement xoriser n'importe quel caractère dans le texte chiffré avec le caractère crypté précédent et donc annuler le xor qui a été fait pendant le cryptage.

Answer 3

Vous auriez pu faire cela en utilisant reduce(). Il est la liste non compréhension, mais il est l'approche de style fonctionnel:

cipher = [] 
def f(previous, element): 
    previous = element^previous^key 
    cipher.append(previous) 
    return previous 
reduce(f, message, initialization_value) 

Il est pas plus jolie que la boucle ordinaire dans ce cas cependant.

Answer 4

Cela peut probablement être fait; voir The Secret Name of List Comprehensions. Ce n'est pas très pythonique, cependant.

Answer 5

En tant que générateur:

def cypher(message, key, seed): 
    for element in message: 
     seed = element^seed^key 
     yield seed 

list(cypher(message, key, initial_seed))