Cifra Python 3 Vigenere

Nov 02 2020

Ainda sou bastante novo em Python e estou tentando ver se usei módulos, funções, etc. com eficiência ou se há outra maneira mais fácil de fazer algo.

Esta cifra Python 3 Vigenere é uma reconstrução de uma cifra baseada em JavaScript e no Windows. Ele aceita qualquer caractere do alfabeto e possui opções de demonstração integradas. A demonstração da cifra usa o estágio 1 da cifra CIA Kryptos .

#! python
import os
import re

## Initialize global variables
continue_cipher = ""
demo_alphabet = "KRYPTOSABCDEFGHIJLMNQUVWXZ"
demo_key = "PALIMPSEST"
demo_cipher_string = "EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJYQTQUXQBQVYUVLLTREVJYQTMKYRDMFD"
demo_cipher_decoded = "BETWEENSUBTLESHADINGANDTHEABSENCEOFLIGHTLIESTHENUANCEOFIQLUSION"


## Visuals
def display_header():
    print("################################################")
    print("#                                              #")
    print("#            --- VIGENERE CIPHER ---           #")
    print("#                                              #")
    print("#   A simple Vigenere cipher decoder/encoder   #")
    print("#                                              #")
    print("################################################", end="\n\n")
    return
def display_results(mode, cipher_vars):
    # Clear screen for final results
    os.system('cls')

    # Display header
    display_header()

    # Decompose cipher_vars
    (alphabet, key, cipher_string, results) = cipher_vars

    print("Mode:", "Decrypt" if mode == "D" else "Encrypt", end="\n\n")
    print("Alphabet:", alphabet)
    print("Key:", key)
    print("Cipher String:", cipher_string, end="\n\n")
    print("Decoded string:" if mode == "D" else "Encoded string:", results, end="\n\n")
    return


## Validations
def string_is_alpha(input_string):
    return True if re.match("^[a-zA-Z_]*$", input_string) else False


## Cipher variables
def get_alphabet():
    global demo_alphabet

    while True:
        alphabet = input("Enter cipher alphabet: ").upper()
        if alphabet == "":
            alphabet = demo_alphabet
            break
        elif string_is_alpha(alphabet) is False:
            print("The alphabet is not valid. Alphabet should not contain spaces, digits or special characters.")
        else:
            break

    return alphabet
def get_key():
    global demo_key

    while True:
        key = input("Enter cipher key: ").upper()
        if key == "":
            key = demo_key
            break
        elif string_is_alpha(key) is False:
            print("The key is not valid. Key should not contain spaces, digits or special characters.")
        else:
            break

    return key
def get_cipher_string(mode):
    global demo_cipher_string
    global demo_cipher_decoded

    while True:
        cipher_string = input("Enter cipher string: ").upper()
        if cipher_string == "":
            cipher_string = demo_cipher_string if mode == "D" else demo_cipher_decoded
            break
        elif string_is_alpha(cipher_string) is False:
            print("The cipher string is not valid. Cipher strings should not contain spaces, digits or special characters.")
        else:
            break

    return cipher_string


## Cipher actions
def get_cipher_alphabets(alphabet, key):
    cipher_alphabets = []

    for char in key:
        char_index = alphabet.find(char)
        cipher_alphabet = alphabet[char_index:] + alphabet[:char_index]
        cipher_alphabets.append(cipher_alphabet)

    return cipher_alphabets
def start_cipher(mode, alphabet, key, cipher_string):
    mode_string = ""
    cipher_alphabets = get_cipher_alphabets(alphabet, key)
    
    cipher_alphabet_index = 0
    for char in cipher_string:
        # Reset cipher_alphabet_index to 0 when at end of cipher alphabets
        if cipher_alphabet_index == len(cipher_alphabets):
            cipher_alphabet_index = 0
        
        # Use appropriate alphabet based on mode
        # Syntax: base_alphabet[mode_alphabet.find(char)]
        if mode == "D":
            mode_string += alphabet[cipher_alphabets[cipher_alphabet_index].find(char)]
        else:
            mode_string += cipher_alphabets[cipher_alphabet_index][alphabet.find(char)]

        cipher_alphabet_index += 1

    return mode_string


## Cipher Mode
def get_cipher_mode():
    while True:
        cipher_mode = input("Choose cipher mode - [D]ecrypt or [E]ncrypt: ").upper()
        if cipher_mode != "D" and cipher_mode != "E":
            print("That is not a valid option. Please enter 'D' for decrypt and 'E' for encrypt.")
        else:
            break

    print("")
    return cipher_mode
def start_cipher_mode(mode):
    print("Press 'enter' to use demo options")
    alphabet = get_alphabet()
    key = get_key()
    cipher_string = get_cipher_string(mode)
    mode_string = start_cipher(mode, alphabet, key, cipher_string)
    return alphabet, key, cipher_string, mode_string


## Loop cipher
def get_continue_cipher():
    while True:
        continue_cipher = input("Do you want to decode/encode more? [Y/N]: ").upper()
        if continue_cipher != "Y" and continue_cipher != "N":
            print("That is not a valid option. Please enter 'Y' to continue and 'N' to quit.")
        else:
            break
    return continue_cipher


## Start vigenere cipher program
while continue_cipher != "N":
    # Clear the screen after each operation
    os.system('cls')

    # Display header
    display_header()

    # Determine cipher mode
    cipher_mode = get_cipher_mode()
    cipher_vars = start_cipher_mode(cipher_mode)

    # Display results
    display_results(cipher_mode, cipher_vars)

    continue_cipher = get_continue_cipher()

Respostas

7 hjpotter92 Nov 02 2020 at 17:35

shebang

O shebang deve ser genérico. Você está chamando no momento python, o que pode apontar para python 2 em certos sistemas.

Um python shebang genérico e compatível com o ambiente virtual é:

#!/usr/bin/env python3

PEP-8

Alguns pontos do guia PEP-8 :

  • Envolva as funções de nível superior e as definições de classe com duas linhas em branco.
  • Use linhas em branco nas funções, com moderação, para indicar seções lógicas.
  • As constantes são geralmente definidas em um nível de módulo e escritas em letras maiúsculas com sublinhados separando as palavras.

PEP-484

As funções de sugestão de tipo facilitam o acompanhamento das funções. Confira o PEP-484 .

if __name__ quadra

Coloque a lógica de execução do seu script dentro do if __name__ == "__main__"bloco. Uma explicação mais descritiva pode ser verificada no Stack Overflow .

Lógica redundante

Em seu código, você tem 5 funções diferentes, apenas para ler a entrada do usuário. Todos eles têm a mesma função de:

  1. Loop infinito
  2. pedir a entrada do usuário
  3. converter para maiúsculas
  4. valide se a entrada está vazia (ou em um conjunto de valores válidos)
  5. em caso de valor vazio, retorna um padrão
  6. retorna com o valor

Tudo isso pode ser tratado por uma única função:

def ask_user_input(message: str, options: List[str] = None, default: str = None, check_alpha: bool = False) -> str:
    if not any([options, default]):
        raise ValueError("Either a set of `options` for validation or a fallback `default` needed.")
    while True:
        value = input(message).upper()
        if options:
            if value in options:
                break
            else:
                print(f"Invalid value. Select one of {', '.join(options)}")
                continue
        if default is not None:
            if not value:
                value = default
                break
            elif not check_alpha:
                break
            elif not (value.isalpha() and value.isascii()):
                print("The input text should only consist of ascii alphabets.")
                continue
            else:
                break
    return value

Regex / validação

O regex para validar a entrada permite _, enquanto a mensagem de erro diz explicitamente nenhum caractere especial. A verificação na reescrita acima é feita usando (atualizado com base no comentário abaixo):

value.isalpha() and value.isascii()

que terá um desempenho mais rápido do que regex (a menos que o usuário continue inserindo valores errados \$ 10^ n \$vezes, em que o padrão pré-compilado pode ter um desempenho ligeiramente melhor).

atuação

Algumas coisas que podem ser alteradas para tornar o código mais eficiente:

  1. Em vez de concatenar (anexar) à string mode_string, envie para uma lista e, no final, use "".join(). Mais detalhes sobre Stack Overflow .

  2. Você pode fazer seu programa suportar sistemas Linux (* nix) também. A única dependência do Windows é a chamada do sistema para cls. Talvez ( tirado de Stack Overflow ):

    def clear():
        os.system("cls" if os.name == "nt" else "clear")
    
  3. Existem 2 funções com nomes muito semelhantes: start_cipher(mode...)e start_cipher_mode(mode). Isso torna muito difícil saber qual está realmente iniciando a cifra . Talvez, tenha 2 funções separadas encrypte decrypt?

  4. Usando a operação de módulo, você pode remover a seguinte condicional:

    if cipher_alphabet_index == len(cipher_alphabets):
        cipher_alphabet_index = 0
    

    e seria parecido com:

    result.append(alphabet[cipher_alphabets[cipher_alphabet_index % alphabets_length].find(char)]
    
  5. Como você só usa a alphabetstring para realmente trabalhar com os valores de índice dos caracteres nela, faça um dicionário. As pesquisas no dicionário são \$ O(1) \$em comparação com \$ O(n) \$para o .find(). Este seria:

    from itertools import count
    alphabet_map = dict(zip(alphabet, count()))
    
  6. Dos 2 pontos acima, é claro que você realmente não precisa de caracteres / alfabetos após a entrada do usuário. Apenas o módulo do valor do índice importa. Isso pode ser difícil de entender / implementar sem um considerável conhecimento matemático, portanto, você pode pular isso por enquanto.

1 Oddthinking Nov 03 2020 at 00:52

@hjpotter cobriu a maioria dos meus comentários.

Booleanos

Python tem um conceito de valores verdadeiros e falsos , então é preferível apenas tratar os valores como booleanos diretamente, em vez de compará-los com Verdadeiro ou Falso.


return True if re.match("^[a-zA-Z_]*$", input_string) else False

pode ser simplificado para:

return re.match("^[a-zA-Z_]*$", input_string)

    elif string_is_alpha(alphabet) is False:

Isso pode ser simplificado para:

    elif not string_is_alpha(alphabet):

Se for geral, você raramente deseja usar "é" para comparação. (A principal exceção é a comparação com None.)

Compilando expressões regulares

Isso é quase certamente uma melhoria de desempenho desnecessária, mas pode ser útil saber para mais tarde:

A chamada para re.matchprecisa compilar o regexp sempre que é chamada. Você pode pré- matchcompilar o regexp uma vez e, em seguida, chamar o objeto compilado para acelerá-lo.

Globais

Quase todas as vezes que procuro a globalpalavra-chave, acabo sendo um erro.

Não acho que você precise declarar os identificadores de demonstração como globais; eles já devem estar disponíveis para uso (apenas para leitura - se você tentar escrever neles, definirá uma nova variável no novo escopo, ocultando os originais).