पायथन में सीज़र सिफर फ़ंक्शन

Question

मैं पाइथन में एक साधारण सीज़र सिफर फ़ंक्शन बनाने की कोशिश कर रहा हूं जो उपयोगकर्ता से इनपुट के आधार पर अक्षरों को बदलता है और अंत में एक अंतिम, नई स्ट्रिंग बनाता है। एकमात्र समस्या यह है कि अंतिम सिफर टेक्स्ट केवल अंतिम स्थानांतरित चरित्र दिखाता है, न कि सभी स्थानांतरित वर्णों के साथ एक संपूर्ण स्ट्रिंग।

plainText = raw_input("What is your plaintext? ") 
shift = int(raw_input("What is your shift? ")) 

def caesar(plainText, shift): 

    for ch in plainText: 
     if ch.isalpha(): 
      stayInAlphabet = ord(ch) + shift 
      if stayInAlphabet > ord('z'): 
       stayInAlphabet -= 26 
      finalLetter = chr(stayInAlphabet) 
     cipherText = "" 
     cipherText += finalLetter 

    print "Your ciphertext is: ", cipherText 

    return cipherText 

caesar(plainText, shift) 

Answer 1

आप पाश के लिए शुरू होने से पहले cipherText = "" बढ़ने की जरूरत है:

यहाँ मेरी कोड है। आप इसे लूप के माध्यम से हर बार रीसेट कर रहे हैं।

def caesar(plainText, shift): 
    cipherText = "" 
    for ch in plainText: 
    if ch.isalpha(): 
     stayInAlphabet = ord(ch) + shift 
     if stayInAlphabet > ord('z'): 
     stayInAlphabet -= 26 
     finalLetter = chr(stayInAlphabet) 
     cipherText += finalLetter 
    print "Your ciphertext is: ", cipherText 
    return cipherText 

Answer 2

समस्या आप हर चक्र यात्रा पर रिक्त स्ट्रिंग पर सिफर निर्धारित करते हैं, लाइन

cipherText = "" 

पाश से पहले ले जाया जाना चाहिए कि है।

Answer 3

plainText = raw_input("What is your plaintext? ") 
shift = int(raw_input("What is your shift? ")) 

def caesar(plainText, shift): 
    for ch in plainText: 
     if ch.isalpha(): 
      stayInAlphabet = ord(ch) + shift 
      if stayInAlphabet > ord('z'): 
       stayInAlphabet -= 26 
      finalLetter = chr(stayInAlphabet) 
     #####HERE YOU RESET CIPHERTEXT IN EACH ITERATION##### 
     cipherText = "" 
     cipherText += finalLetter 

    print "Your ciphertext is: ", cipherText 

    return cipherText 

caesar(plainText, shift) 

एक किसी और के रूप में अगर ch.isalpha() करने के लिए आप finalLetter=ch डाल सकते हैं। cipherText = ""

चीयर्स:

आप लाइन निकाल देना चाहिए।

Answer 4

जैसा कि @ I82much ने कहा था, आपको अपने लूप के बाहर cipherText = "" लेने की आवश्यकता है। इसे समारोह की शुरुआत में रखें। साथ ही, आपके प्रोग्राम में एक बग है जो इनपुट के रूप में पूंजी अक्षरों को प्राप्त करते समय एन्क्रिप्शन त्रुटियों को उत्पन्न करने का कारण बनती है। आज़माएं:

if ch.isalpha(): 
     finalLetter = chr((ord(ch.lower()) - 97 + shift) % 26 + 97) 

Answer 5

मुझे एहसास है कि यह उत्तर वास्तव में आपके प्रश्न का उत्तर नहीं देता है, लेकिन मुझे लगता है कि यह वैसे भी सहायक है। यहाँ स्ट्रिंग तरीकों के साथ सीज़र सिफर को लागू करने के लिए एक वैकल्पिक तरीका है:

def caesar(plaintext, shift): 
    alphabet = string.ascii_lowercase 
    shifted_alphabet = alphabet[shift:] + alphabet[:shift] 
    table = string.maketrans(alphabet, shifted_alphabet) 
    return plaintext.translate(table) 

वास्तव में, के बाद से स्ट्रिंग तरीकों सी में लागू किया जाता है, तो हम इस संस्करण के साथ प्रदर्शन में वृद्धि देखेंगे। यही वह है जो मैं इसे करने के 'पायथनिक' तरीके पर विचार करता हूं।

Answer 6

जैसा कि दूसरों ने इंगित किया है, आप लूप के पुनरावृत्ति में cipherText को रीसेट कर रहे थे। लूप की शुरुआत से पहले cipherText को रखने से आपकी समस्या हल हो जाएगी।

इसके अतिरिक्त, पाइथन की मानक लाइब्रेरी का उपयोग करके इस समस्या को हल करने के लिए एक वैकल्पिक दृष्टिकोण है। पायथन मानक लाइब्रेरी एक फ़ंक्शन maketrans() और एक विधि अनुवाद को परिभाषित करती है जो तारों पर चलती है।

फ़ंक्शन maketrans() अनुवाद तालिकाओं को बनाता है जिसका उपयोग अनुवाद विधि के साथ वर्णों के एक सेट को और अधिक कुशलतापूर्वक बदलने के लिए किया जा सकता है। (उदाहरण के द्वारा पायथन मानक पुस्तकालय से उद्धृत)।

import string 

def caesar(plaintext, shift): 

shift %= 26 # Values greater than 26 will wrap around 

alphabet_lower = string.ascii_lowercase 
alphabet_upper = string.ascii_uppercase 

shifted_alphabet_lower = alphabet_lower[shift:] + alphabet_lower[:shift] 
shifted_alphabet_upper = alphabet_upper[shift:] + alphabet_upper[:shift] 

alphabet = alphabet_lower + alphabet_upper 
shifted_alphabet = shifted_alphabet_lower + shifted_alphabet_upper 

table = string.maketrans(alphabet, shifted_alphabet) 

return plaintext.translate(table) 

Answer 7

बैटरियों

while 1: 
    phrase = raw_input("Could you please give me a phrase to encrypt?\n") 
    if phrase == "" : break 
    print "Here it is your phrase, encrypted:" 
    print phrase.encode("rot_13") 
print "Have a nice afternoon!" 

https://docs.python.org/2/library/codecs.html#python-specific-encodings

शामिल अजगर 3 अद्यतन

fine docs कहना

[अब rot_13] कोडेक एक टेक्स्ट ट्रांसफॉर्म प्रदान करता है: str से str मैपिंग। यह str.encode() द्वारा समर्थित नहीं है (जो केवल बाइट आउटपुट उत्पन्न करता है)।

या, दूसरे शब्दों में, आप अपनी पहली तर्क

from codecs import decode 
... 
    print(encode(phrase, 'rot13')) 

Answer 8

के रूप में एन्कोड करने की कुछ ascii संख्या सुझावों का उपयोग करना codecs मॉड्यूल से encode आयात और तार के साथ इसका इस्तेमाल करने के लिए है:

# See http://ascii.cl/ 
upper = {ascii:chr(ascii) for ascii in range(65,91)} 
lower = {ascii:chr(ascii) for ascii in range(97,123)} 
digit = {ascii:chr(ascii) for ascii in range(48,58)} 


def ceasar(s, k): 
    for c in s: 
     o = ord(c) 
     # Do not change symbols and digits 
     if (o not in upper and o not in lower) or o in digit: 
      yield o 
     else: 
      # If it's in the upper case and 
      # that the rotation is within the uppercase 
      if o in upper and o + k % 26 in upper: 
       yield o + k % 26 
      # If it's in the lower case and 
      # that the rotation is within the lowercase 
      elif o in lower and o + k % 26 in lower: 
       yield o + k % 26 
      # Otherwise move back 26 spaces after rotation. 
      else: # alphabet. 
       yield o + k % 26 -26 

x = (''.join(map(chr, ceasar(s, k)))) 
print (x) 

Answer 9

from string import ascii_lowercase as alphabet 

class CaesarCypher: 
    alpha_len = len(alphabet) 
    min_guess_rate = 0.2 

एन्क्रिप्शन और डिक्रिप्शन एक ही सामान है। जब आप शिफ्ट 10 के साथ उदाहरण के लिए डिक्रिप्ट करना चाहते हैं तो इसका मतलब है कि आप इसे 26 - 10 के साथ एन्क्रिप्ट कर सकते हैं। इस मामले में चक्र पूरे वर्णमाला को स्थानांतरित करने के लिए दोहराएगा, यह वही होगा। इसके अलावा मैं ऊपरी केस और गैर वर्ण

def __call__(self, text, offset, encrypt=True): 
     if not encrypt: 
      offset = self.alpha_len - offset 
     result = [] 
     for letter in text: 
      if not letter.isalpha(): 
       result.append(letter) 
       continue 
      letter_to_process = letter.lower() 
      processed_letter = self._encrypt_letter(letter_to_process, offset) 
      if letter.isupper(): 
       processed_letter = processed_letter.upper() 
      result.append(processed_letter) 
     return ''.join(result) 

सभी एन्क्रिप्शन यहां सबसे अधिक चला गया है।

def _encrypt_letter(self, letter, offset=0): 
     position = (alphabet.find(letter) + offset) % self.alpha_len 
     return alphabet[position] 

यह हिस्सा ब्रूट बल के लिए है और थ्रूग शब्दकोश आवृत्ति अनुमान लगाता है।

@staticmethod 
    def __how_many_do_i_know(text): 
     clean_words = filter(lambda x: x.isalpha(), text.split()) 
     clean_words = ['\'{}\''.format(x) for x in clean_words] 
     cursor = conn.cursor() 
     query = 'SELECT COUNT(*) FROM mydictionary WHERE word IN ({})'.format(",".join(clean_words)) 
     cursor.execute(query) 
     response = cursor.fetchone()[0] 
     return response/len(clean_words) 

    def guess_encode(self, text): 
     options = [self(text, offset, encrypt=False) for offset in range(self.alpha_len)] 
     best_option = [self.__how_many_do_i_know(option) for option in options] 
     best_key, guess_rate = max(enumerate(best_option), key=lambda x: x[-1]) 
     guess_text = options[best_key] 
     return best_key, guess_rate, guess_text 

Answer 10

यहाँ

, एक और अधिक कार्यात्मक तरीका: (यदि आप बदलाव मैं एन्कोड करने के लिए उपयोग करते हैं, तो मैं का उपयोग डिकोड करने के लिए)

def ceasar(story, shift): 
    return ''.join([ # concentrate list to string 
      (lambda c, is_upper: c.upper() if is_upper else c) # if original char is upper case than convert result to upper case too 
       (
        ("abcdefghijklmnopqrstuvwxyz"*2)[ord(char.lower()) - ord('a') + shift % 26], # rotate char, this is extra easy since Python accepts list indexs below 0 
        char.isupper() 
       ) 
      if char.isalpha() else char # if not in alphabet then don't change it 
      for char in story 
     ]) 

Answer 11

key = 3 

def wub(): 
    def choice(): 
     choice = input("Do you wish to Encrypt of Decrypt?") 
     choice = choice.lower() 
     if choice == "e" or "encrypt": 
      return choice 
     elif choice == "d" or "decrypt": 
      return choice 
     else: 
      print("Invalid response, please try again.") 
      choice() 

    def message(): 
     user = input("Enter your message: ") 
     return user 

    def waffle(choice, message, key): 
     translated = "" 
     if choice == "e" or "encrypt": 
      for character in message: 
       num = ord(character) 
       num += key 
       translated += chr(num) 

       derek = open('Encrypted.txt', 'w') 
       derek.write(translated) 
      derek.close() 
      return translated 
     else: 
      for character in message: 
       num = ord(character) 
       num -= key 
       translated += chr(num) 
      return translated 

    choice = choice() #Runs function for encrypt/decrypt selection. Saves choice made. 
    message = message() #Run function for user to enter message. Saves message. 
    final = waffle(choice, message, key) #Runs function to translate message, using the choice, message and key variables) 
    print("\n Operation complete!") 
    print(final) 

wub() 

Answer 12

import string 
wrd=raw_input("Enter word").lower() 
fwrd="" 
for let in wrd: 
    fwrd+=string.ascii_lowercase[(string.ascii_lowercase).index(let)+3] 
print"Original word",wrd 
print"New word",fwrd 

Answer 13

मेरे हिसाब से यह जवाब है आपके लिए उपयोगी:

def casear(a,key): 
str="" 
if key>26: 
    key%=26 
for i in range(0,len(a)): 
    if a[i].isalpha(): 
     b=ord(a[i]) 
     b+=key 
     #if b>90:     #if upper case letter ppear in your string 
     # c=b-90     #if upper case letter ppear in your string 
     # str+=chr(64+c)   #if upper case letter ppear in your string 
     if b>122: 
      c=b-122 
      str+=chr(96+c) 
     else: 
      str+=chr(b) 
    else: 
     str+=a[i] 
print str 

a=raw_input() 
key=int(input()) 
casear(a,key) 

यह फ़ंक्शन शिफ दिए गए कुंजी के अनुसार सही सभी पत्र टीएस।

Answer 14

>>> def rotate(txt, key): 
... def cipher(i, low=range(97,123), upper=range(65,91)): 
...  if i in low or i in upper: 
...  s = 65 if i in upper else 97 
...  i = (i - s + key) % 26 + s 
...  return chr(i) 
... return ''.join([cipher(ord(s)) for s in txt]) 

# test 
>>> rotate('abc', 2) 
'cde' 
>>> rotate('xyz', 2) 
'zab' 
>>> rotate('ab', 26) 
'ab' 
>>> rotate('Hello, World!', 7) 
'Olssv, Dvysk!' 

Answer 15

मैं एक कठिन समय चार याद रूपांतरण int करने के लिए तो यह

def decryptCaesar(encrypted, shift): 
    minRange = ord('a') 
    decrypted = "" 
    for char in encrypted: 
     decrypted += chr(((ord(char) - minRange + shift) % 26) + minRange) 

    return decrypted 

Answer 16

def encrypt(): 
    plainText = input("What is your plaintext? ") 
    shift = int(input("What is your shift? ")) 
    cipherText = "" 
    for ch in plainText: 
     if ch.isalpha(): 
      stayInAlphabet = ord(ch) + shift 
     if stayInAlphabet > ord('z'): 
      stayInAlphabet -= 26 
     finalLetter = chr(stayInAlphabet) 
     cipherText += finalLetter 

    print ("Your ciphertext is: ", cipherText,"with a shift of",shift) 


def decrypte(): 
    encryption=input("enter in your encrypted code") 
    encryption_shift=int(input("enter in your encryption shift")) 

    cipherText1 = "" 
    for c in encryption: 
     if c.isalpha(): 
      stayInAlphabet1 = ord(c) - encryption_shift 
     if stayInAlphabet1 > ord('z'): 
      stayInAlphabet1 += 26 
     finalLetter1 = chr(stayInAlphabet1) 
     cipherText1 += finalLetter1 

    print ("Your ciphertext is: ", cipherText1,"with negative shift of",encryption_shift) 

from tkinter import * 

menu=Tk() 
menu.title("menu") 
menu.geometry("300x300") 
button1= Button(menu,text="encrypt",command=encrypt) 
button1.pack() 

button2= Button(menu,text="decrypt",command=decrypte) 
button2.pack() 

button3= Button(menu,text="exit",command=exit) 
button3.pack() 

menu.mainloop() 

Answer 17

अनुकूलित किया जा सकता है क्यों समारोह पारी इनपुट पर रिवर्स, और और साथ plain_text में शामिल होने का उपयोग नहीं सिफर पाठ के रूप में पारी, और यह इनपुट:

Plain = int(input("enter a number ")) 
Rev = plain[::-1] 
Cipher = " ".join(for cipher_text in Rev)