Basic Caesar Cipher Code

Question

Could I have a couple people look over my code for a general readability check? Just make sure it is following Python standards.

def casear_cipher(letter, num):
    """ This function acts like a Casear Cipher. 

    Replaces an input letter with another letter a fixed

    number of spaces farther down the alphabet

    Args:

    * letter (string) - any upper case or lower case letter

    * num (integer) - any integer value to shift to a new letter
        """

    #Range 65 to 91 is ASCii values for uppercase alphabet
    if ord(letter) in range (65, 91):  
        x = ord(letter) - ord('A') 
        num_mod_26 = (x + num) % 26
        final_output = chr(ord('A') + num_mod_26)
        return final_output


    #Range 97 to 123 is ASCii values for lowercase alphabet 
    elif ord(letter) in range (97, 123):  
        x = ord(letter) - ord('a') 
        num_mod_26 = (x + num) % 26
        final_output = chr(ord('a') + num_mod_26)
        return final_output

Answer 1

First of all welcome to Codereview.

Good

• You have a decent function.
• You even have a nice docstring to describe what it does!
• You have decent descriptive names.

Overall your code is good, well done!

Improvements

• Make the starting_ascii value more generic, no more duplicated code.
• Rais an appropriate exeption if no letter is given, you might want to handle that differently.

---

Revised code

def casear_cipher(letter, num):
    """This function acts like a Casear Cipher. 

    Replaces an input letter with another letter a fixed
    number of spaces farther down the alphabet

    Args:
    * letter (string) - any upper case or lower case letter
    * num (integer) - any integer value to shift to a new letter"""

    if letter.isupper():
        starting_ascii = ord('A')
    elif letter.islower():
        starting_ascii = ord('a')
    else:
        raise ValueError('Input is not a letter')

    alpha_index = ord(letter) - starting_ascii
    mod_26 = (alpha_index + num) % 26
    return chr(starting_ascii + mod_26)

Answer 2

This improvement is not related with readability, but I'm posting it because it can improve the encoding throughput for large text inputs.

Modulus operations are expensive for most integral values, because they require using more expensive instructions such as integer divisions or multiplications.

You can avoid this by just having your alphabet duplicated. The trick is that instead of wrapping the index you just unwrap the alphabet, since the range of a sum of two 0..26 values is always going to be less than 2*26. It would be a bit trickier but still possible, to support upper and lower case characters.

Here's a simplified code that could complement @Ludisposed answer:

from array import array
chars = range(ord('a'),ord('z')+1)
chars.extend(chars)
alphabet = array('c',(chr(c) for c in chars))

def caesar_cipher(letter, num):
   return alphabet[ord(letter)-ord('a')+num]

print(alphabet)
hello_encoded = "".join(caesar_cipher(c, 5) for c in "helloworld")
print(hello_encoded)

Result:

array('c', 'abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz')
mjqqtbtwqi

Answer 3

Very minor detail: your method name is spelled wrong. It's caesar, not cesaer, after the Roman general and politician who was one of the first recorded users of the cipher. You spelled it right in your question title, but not in your actual code. It's a small detail, but if the method is intended for consumption through an API or in other parts of your code, you may want to make sure that you don't have silly typographical mistakes like this, because fixing them is definitely not trivial, especially on products which have been released.