Implementing the Caesar Cipher in Python

was a Roman ruler identified for his navy methods and wonderful management. Named after him, the Caesar Cipher is a captivating cryptographic approach that Julius Caesar employed to ship secret alerts and messages to his navy personnel.

The Caesar Cipher is sort of fundamental in its working. It really works by shifting all of the letters of the message to be encrypted by a hard and fast variety of locations, referred to as the important thing. The individual receiving it’s conscious of the important thing and makes use of it to decrypt the message, thereby offering a straightforward and clever means of conducting non-public correspondence.

Understanding the Challenge

On this article, we’ll learn to implement the Caesar Cipher in Python. This can be a beginner-friendly mission the place we will likely be utilizing conditional statements, loops and capabilities to encode and decode person enter knowledge.

Right here is how this system will work: This system asks the person for a message to be encoded or decoded. The person chooses both encryption or decryption. This system asks for the important thing by which the message will likely be encrypted. As soon as the person offers the important thing, this system will convert the message by changing every letter of the message based on the important thing, both by shifting the letters ahead if encoding, or backward if decoding.

Allow us to first outline the mission steps with the assistance of a flowchart.

Step 1: Defining the Alphabet Listing

Initially, we’ll use the List datatype in Python to create an inventory of the letters within the alphabet. Python lists are a sequence of things in a particular order and have a number of built-in capabilities. This system will use this record as a reference to shift letters ahead or backward based on the selection of encoding or decoding. Allow us to outline the record, alphabet.

alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
            'v', 'w', 'x', 'y', 'z']

Step 2: Ask Consumer Enter

The following step is to take the person’s enter. We’ll ask the person:

1. Whether or not they wish to encode or decode a message encode_or_decode
2. The respective message secret_message which they wish to encode or decode, and
3. The shift quantity key by which the message will likely be encoded or decoded.

encode_or_decode = enter("Kind 'encode' to encrypt, sort 'decode' to decrypt:n").decrease()
secret_message = enter("Kind your message right here:n").decrease()
key = int(enter("Kind the important thing:n"))

Make certain to transform the key into an int datatype, in any other case you would possibly run into an issue in shifting the letter by the variety of key as Python will think about the enter as a string and never an integer sort. Additionally keep in mind to transform the person enter secret_message and encode_or_decode to lowercase to match the gadgets within the record alphabet and conditional statment that may come forward.

Step 3: Defining Capabilities and Utilizing the Modulo Operator

The following step is to outline each the encode and decode capabilities which will likely be referred to as later. The encode perform will likely be referred to as when the person chooses ‘encode’ within the encode_or_decode enter immediate, and the decode perform will likely be referred to as when the person sorts ‘decode’ within the encode_or_decode enter immediate.

Each capabilities are fairly simple to code. It should take the secret_message, loop by way of all of the letters, and for all of the letters within the alphabet record that we outlined earlier, it is going to take their index place, add the key to it, and provides the shifted_position. We’ll use this shifted_position as an index of the letters and add them to the output_text which would be the encoded or decoded message.

However we have now one downside right here! What if by shifting the letters, the index place goes out of the alphabet record? Effectively the answer to that is utilizing an fascinating Python operator referred to as the ‘modulo‘. The modulo is an operator that offers the rest after division and is symbolized by ‘%’ in Python. So 8 % 5 will equal 3, as 3 is the rest left after 8 is split by 5.

We’ll use this operator in our encode and decode capabilities. So, contemplating the alphabet record has 26 gadgets, and if the person offers a message to encode “vampire” and key as “10”, if we simply add the important thing quantity to the index place of ‘v’, 22 + 10 = 32, we can have an error as there is no such thing as a merchandise on the thirty second place within the alphabet record. Nonetheless, if we wish to restart the alphabet record after ‘z’ from ‘a’, the thirty second alphabet would fall on ‘f’, which is the sixth merchandise within the alphabet record. The identical letter and index place will be achieved utilizing the modulo operator; for a shifted worth of 32, the letter will likely be on the 32 % 26 = sixth place. So we’ll use the identical logic in coding our encode and decode capabilities.

Right here is the encode perform:

def encode(message, keynumber, operation):
    output_text = ""
    for letter in message:
        if letter in alphabet:
            shifted_position = alphabet.index(letter) + keynumber
            shifted_position = shifted_position % len(alphabet)
            output_text = output_text + alphabet[shifted_position]
        else:
            output_text += letter       
    print("Right here is the encoded textual content : ", output_text)

So if I wish to encode “I’ve a pet cat” with the important thing quantity ‘6’, I’ll get the next encoded message:

For the decode perform, since we’re decoding, we have now to shift the letters by the key within the reverse order, that’s, backwards. So if I wish to decode the above message: ‘o ngbk g vkz igz’, I should multiply the important thing quantity by -1, in order that as a substitute of including the important thing, it subtracts the key, and the shifted_position will likely be achieved by shifting the index place backward.

Allow us to outline the decode perform:

def decode(message, keynumber, operation):
    keynumber = keynumber * -1
    output_text = ""
    for letter in message:
        if letter in alphabet:
            shifted_position = alphabet.index(letter) + keynumber
            shifted_position = shifted_position % len(alphabet)
            output_text = output_text + alphabet[shifted_position]
        else:
            output_text += letter       
    print("Right here is the decoded textual content : ", output_text)

Right here is our decoded message:

Step 4: Calling Capabilities

As soon as our capabilities are outlined, we’ll name them when wanted. If the person desires to encrypt a message, we’ll name the encode perform, and in the event that they wish to decrypt a message, we’ll name the decode perform. Allow us to implement this in our code utilizing conditional statements if, elif, and else:

if encode_or_decode == 'encode':
    encode(message=secret_message, keynumber=key, operation=encode_or_decode)
elif encode_or_decode == 'decode':
    decode(message=secret_message, keynumber=key, operation=encode_or_decode)
else:
    print("Error")

Step 5: Program Continuity

The final step of this program is to ask the person whether or not they wish to proceed with this system of encryption and decryption or finish. We’ll implement this with a variable continue_program that will likely be True at the start and can stay so when the person desires to proceed with this system. If the person desires to finish, the variable will change to False, and this system will finish. We’ll embrace this situation in a whereas loop that may run so long as the variable stays True.

continue_program = True

whereas continue_program:

    encode_or_decode = enter("Kind 'encode' to encrypt, sort 'decode' to decrypt:n").decrease()
    secret_message = enter("Kind your message right here:n").decrease()
    key = int(enter("Kind the important thing:n"))

    if encode_or_decode == 'encode':
        encode(message=secret_message, keynumber=key, operation=encode_or_decode)
    elif encode_or_decode == 'decode':
        decode(message=secret_message, keynumber=key, operation=encode_or_decode)
    else:
        print("Error")
        
    restart = enter("Kind 'sure' if you wish to proceed with this system.nOtherwise, sort 'no'.n").decrease()
    if restart == "no":
        continue_program = False

Conclusion

With the inclusion of the whereas loop above, we have now efficiently carried out the Caesar cipher program in Python. This mission explored conditional statements if, elif, and else, for and whereas loops, and defining and calling capabilities. Furthermore, we additionally launched the modulo operator on this program to deal with exceptions.

You’ll find the whole supply code of this mission here.

In case you have any questions or wish to share a special strategy, be happy to touch upon this text. I’ll stay up for it. Blissful coding! 🙂