Cifra Python 3 Vigenere
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
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:
- Loop infinito
- pedir a entrada do usuário
- converter para maiúsculas
- valide se a entrada está vazia (ou em um conjunto de valores válidos)
- em caso de valor vazio, retorna um padrão
- 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:
Em vez de concatenar (anexar) à string
mode_string, envie para uma lista e, no final, use"".join(). Mais detalhes sobre Stack Overflow .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")Existem 2 funções com nomes muito semelhantes:
start_cipher(mode...)estart_cipher_mode(mode). Isso torna muito difícil saber qual está realmente iniciando a cifra . Talvez, tenha 2 funções separadasencryptedecrypt?Usando a operação de módulo, você pode remover a seguinte condicional:
if cipher_alphabet_index == len(cipher_alphabets): cipher_alphabet_index = 0e seria parecido com:
result.append(alphabet[cipher_alphabets[cipher_alphabet_index % alphabets_length].find(char)]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()))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.
@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).