Rot and polyalphabetic ciphers in Python 2.7

Question

I'm writing a "crypto library" and gradually adding algortihms. Now it's just ancient cryptography, but I'm going to expand the library. It doesn't depend on any external libraries.

class Crypto():
    def __init__(self, rotInt=3, letters=list("abcdefghijklmnopqrstuvwxyz")):
        self.letters = letters
        self.length = len(self.letters)
        self.rotInt = rotInt
    def rot(self, string, rotInt, letters, length): # To decrypt, use a negative number
        result = []
        for letter in string:
            if letter == " ": # Skip spaces
                result.append(" ")
            else:
                letterIndex = letters.index(letter)
                resultIndex = letterIndex + rotInt
                resultIndex = resultIndex % length-1
                result.append(letters[resultIndex])
        return "".join(result) # Return result as a string
    def getRotArr(self, string, negative=False): # Negative is for decryption
        result = []
        for char in string:
            if negative:
                result.append(0-(self.letters.index(char)+1))
            else:
                result.append(self.letters.index(char)+1)
        return result
    def polyalphabetic(self, string, rotArr, letters, length):
        result = []
        rotArrIndex = 0
        for letter in string:
            if letter == " ": # Skip spaces
                result.append(" ")
            else: # Spaces would mess up rotArrIndex
                if rotArrIndex > len(rotArr)-1: # Repeat when end of rotArr is reached
                    rotArrIndex = 0
                rotInt = rotArr[rotArrIndex]
                letterIndex = letters.index(letter)
                resultIndex = letterIndex + rotInt
                resultIndex = resultIndex % length
                result.append(letters[resultIndex])
                rotArrIndex += 1
        return "".join(result) # Return result as a string

Answer 1

Handling exceptions

If you create library user should be aware what is going wrong if he uses it in the wrong way.

def rot(self, string, rotInt, letters, length): # To decrypt, use a negative number
    result = []
    for letter in string:
        if letter == " ": # Skip spaces
            result.append(" ")
        else:
            letterIndex = letters.index(letter)

Here, you will receive IndexError which is not very informative, probably you would like to make your exceptions for such situations.

Performance of string concatenations

As you can see from this post, most efficient methods are using list, cStringIO and list comprehension with str.join. I recommend you to rewrite your rot method to use list comprehension and make all required checks in the beginning of the method.

Sanity defaults

def rot(self, string, rotInt, letters, length)

length parameter is just a length of the letters, so it can be computed in the method.

Because rot method is not the static method, you already have initialized class instance so you can use letters array received in __init__ method in case if the user does not provide letters to the rot method itself.

For an example, you can write something like:

def rot(self, string, rotation_index, letters=None):
    letters = letters or self.letters
    length = len(letters)

Data structures for characters set

Storing characters set in the form of the list in order to use index method every time you what to figure out a position of the element is not the best choice in case of performance. You should probably use additional dict for excample:

index_of = dict([(e, i) for i, e in enumerate(letters)])

You will get dict with keys of your letters and values - their positions in the letters iterable. So you can find out position and find is character found in your characters set with

<character> in index_of
index_of[<character>]

Answer 2

rotInt, letters, length are defined in class. Use it.

Instead of for loop use map.

def rot(self, string, letters=None, rotInt=None):
    if letters is None:
        letters = self.letters
    length = len(letters)
    if rotInt is None:
        rotInt = self.rotInt
    return ''.join(map(lambda letter: letter in letters and letters[(letters.index(letter) + rotInt) % length] or letter, string))

and or

It's like bool ? a : b in C / C++. It's equivalent to:

if bool:
    return a
else:
    return b