2. Crypto¶

alphabet_position¶

Open up your caesar.py file in Visual Studio Code. In that file, write a function alphabet_position(letter), which receives a letter (that is, a string with only one alphabetic character) and returns the 0-based numerical position of that letter within the alphabet.

Here are some example input parameter values, with the corresponding return values.

When (you think) you are finished, the best way to test your function is to fire up the Python shell in your terminal, and then import your file as a module:

$ python
>>> import caesar
>>> caesar.alphabet_position("a")
0
>>> caesar.alphabet_position("E")
4
# ... etc

rotate_character¶

Next, write another helper function rotate_character(char, rot) which receives a character char (that is, a string of length 1), and an integer rot. Your function should return a new string of length 1, the result of rotating char by rot number of places to the right.

Here are some example input values, with the corresponding return values.

Ok, go code like a champ.

encrypt¶

Now let’s get to the heart of the matter. Write one more function called encrypt(text, rot), which receives as input a string and an integer. This is just like the rot13 function, but instead of hardcoding the number 13, your function should receive a second argument, rot which specifies the rotation amount. Your function should return the result of rotating each letter in the text by rot places to the right.

Here are some example input values, with the corresponding return values:

Make It Interactive¶

You’re almost done with Caesar! The last step is simply to write some print and input statements so the user can run your program from the terminal. Remember, you should ask the user for their message and rotation amount, and then print the encrypted message:

$ python caesar.py
Type a message:
Hello, World!
Rotate by:
5
Mjqqt, Btwqi!

Recall that, as described in the Initials assignment, you should place everything “loose” inside a main function, like this:

# ... the functions you wrote ...


def main():
    # your main code (input and print statements)

if __name__ == "__main__":
    main()

Reusing your Caesar code¶

You probably noticed that Vigenere is very similar to Caesar. The only difference is that the rotation amount varies throughout the course of the message.

Whenever you find yourself in a situation like this – faced with a coding task that is very similar to one you did previously – your instinct should be to sniff around for ways to reuse the code you have already written. Ideally, all the work that is required by both tasks should be factored out into reusable components (like functions).

In this case, the majority of the logic that Vigenere has in common with Caesar is encapsulated in those two helper functions you wrote, alphabet_position and rotate_character. Indeed, that is why we intentionally guided you down the path of writing those functions. You are going to find both of those functions equally helpful for implementing Vigenere.

Go ahead and copy / paste those functions into vigenere.py so you can use them. (In reality, copy / pasting is not a very smart thing to do here, and there is a better way, which you will see farther down in this assignment. But for now, just do it.)

encrypt¶

Now that you have your helper functions, go ahead and write a new version of the encrypt function which uses the Vigenere cipher rather than Caesar.

Your first step is to figure out what the function signature should say. How should it be different from the Caesar version, def encrypt(text, rot)?

As usual, don’t move on until you have tested your function against a lot of different inputs and seen the results you expect.

Make It Interactive¶

Finally, add the appropriate print and input statements inside a main function so that your program behaves as specified:

$ python vigenere.py
Type a message:
The crow flies at midnight!
Encryption key:
boom
Uvs osck rmwse bh auebwsih!

Import to the Rescue¶

If a function is only defined in one place, a particular file somewhere, then how can some other file use it? It is actually quite easy: the other file simply needs to import the function. You have already used the import keyword throughout this course, whenever you wanted to access code written by other people, such as the math and random modules. It is also possible to create and import your own code. Here’s how:

1. In your editor, open up a new file called helpers.py. Paste both helper functions, alphabet_position and rotate_character into this new file.

2. Next, open up caesar.py, and delete both of those functions.

3. Finally, add this line to the top of caesar.py:

   from helpers import alphabet_position, rotate_character
   

   This says that we want to import code from a module helpers, but that we only want to import particular pieces of that module, specificially the functions alphabet_position and rotate_character.

Now we should be able to use those functions! Try running python caesar.py again, and you should find that it works just like it did before.

Once you have Caesar working, do the same thing for Vigenere: simply delete the two helper functions, and import them from helpers.py.

Now your helper functions are defined only once, and your code remains nice and DRY (Don’t Repeat Yourself)!

Bonus Mission 1: Command-line Arguments¶

Each of our programs requires two pieces of input from the user:

• Caesar requires a message and a rotation amount.
• Vigenere requires a message and an encryption key-word.

Let’s now make the following tweak: instead of prompting the user for both pieces of info, let’s allow the user to include the second value right away at the beginning.

For example, rather than Caesar behaving like this:

$ python caesar.py
Type a message:
Hello, World!
Rotate by:
5
Mjqqt, Btwqi!

... we want Caesar to instead behave like this:

$ python caesar.py 5
Type a message:
Hello, World!
Mjqqt, Btwqi!

Notice how, on the first line, the user included the number 5 as an argument when running the program. This means that the program only needed to make one additional input prompt, asking for the text message. This makes for a slightly nicer user experience.

In order to implement this feature, you obviously need some way of knowing, inside your caesar.py script, that the user typed the number 5 as a command-line argument.

Conveniently enough, it just so happens that inside any Python program, you do have access to a list containing each of the words the user typed on the command line. This list of strings lives in a module called sys, and has the variable name argv, short for “argument vector” (“vector” is another word for a list).

Try adding the following two lines to the beginning of your main function in your caesar.py file:

def main():
    from sys import argv
    print("This is what the user typed on the command line:", argv)
    # ... the rest of your code ...

Now run your program, and you should see output like this:

$ python caesar.py 5
This is what the user typed on the command line: ['caesar.py', '5']
Type a message:
... etc

The important part is the second line.

Notice that:

• The word 'python' is not included.
• The first item, argv[0] is always the name of your script (in this case, 'caesar.py').
• The other arguments follow. (In this case, we only have one additional argument, '5').

Ok! Now you have all the tools you need to implement this feature. Remember that the argv variable is just a normal list like any other. The rotation number (5 or whatever it is), is sitting there inside that list, waiting for you.

First, modify caesar.py to match the behavior specified above, which, once again for easy reference, looks like this:

$ python caesar.py 5
Type a message:
Hello, World!
Mjqqt, Btwqi!

Once you have finished Caesar, make similar changes to Vigenere so that the user can specify their encryption key on the command-line while typing the program command. Vigenere should behave like this:

$ python vigenere.py boom
Type a message:
The crow flies at midnight!
Uvs osck rmwse bh auebwsih!

Bonus Mission 2: Validation¶

You may or may not have noticed that if the user types certain things, your program will freak out.

There are two main cases to handle:

1. User fails to type a number when specifying rotation amount.

   $ python caesar.py grandpa
   

   If the user gives you something like “grandpa” instead of “5”, your program will crash, probably with this error:

   ValueError: invalid literal for int() with base 10: 'grandpa' on line X
   

2. User fails to provide a command-line argument.

   Now that you are expecting the user to specify the rotation amount via a command-line argument, there is a danger that the user will fail to type anything at all, i.e.:

   $ python caesar.py
   

   In this case, you will probably see:

   IndexError: list index out of range
   

   because you are trying to read from argv at an index that does not exist, since argv only contains one string, rather than two.

Rather than simply crash whenever one of these things happens, your program should handle it more gracefully, by printing a helpful “usage” message (explaining how to properly use your program), and then exiting immediately, rather than continuing on and crashing.

$ python caesar.py
usage: python caesar.py n
$ python caesar.py grandpa
usage: python caesar.py n
$ python caesar.py 5.0
usage: python caesar.py n
$ python caesar.py 5
Type a message:
Hello, World!
Mjqqt, Btwqi!

$ python
>>> "grandpa".isdigit()
False
>>> "5.0".isdigit()
False
>>> "5".isdigit()
True

from sys import argv, exit

exit()

$ python vigenere.py
usage: python vigenere.py keyword
$ python vigenere.py boom!
usage: python vigenere.py keyword
$ python vigenere.py boom52
usage: python vigenere.py keyword
$ python vigenere.py boom
Type a message:
The crow flies at midnight!
Uvs osck rmwse bh auebwsih!

$ python vigenere.py boom!
usage: python vigenere.py keyword
Arguments:
-keyword : The string to be used as a "key" to encrypt your message. Should only contain alphabetic characters-- no numbers or special characters.
$ python vigenere.py boom52
usage: python vigenere.py keyword
Arguments:
-keyword : The string to be used as a "key" to encrypt your message. Should only contain alphabetic characters-- no numbers or special characters.
$ python vigenere.py boom
Type a message:
The crow flies at midnight!
Uvs osck rmwse bh auebwsih!