Python文本加密：rot13

Question

I am currently doing an assignment that encrypts text by using rot 13, but some of my text wont register.

# cgi is to escape html
# import cgi

def rot13(s):
    #string encrypted
    scrypt=''
    alph='abcdefghijklmonpqrstuvwxyz'
    for c in s:
        # check if char is in alphabet
        if c.lower() in alph:
            #find c in alph and return its place
            i = alph.find(c.lower())

            #encrypt char = c incremented by 13
            ccrypt = alph[ i+13 : i+14 ]

            #add encrypted char to string
            if c==c.lower():
                scrypt+=ccrypt
            if c==c.upper():
                scrypt+=ccrypt.upper()

        #dont encrypt special chars or spaces
        else:
            scrypt+=c

    return scrypt
    # return cgi.escape(scrypt, quote = True)


given_string = 'Rot13 Test'
print rot13(given_string) 

OUTPUT:

13 r
[Finished in 0.0s]

Answer 1

Hmmm, seems like a bunch of things are not working. Main problem should be in ccrypt = alph[ i+13 : i+14 ] : you're missing a % len(alph) otherwise if, for example, i is equal to 18 , then you'll end out of the list boundary. In your output, in fact, only e is encoded to r because it's the only letter in your test string which, moved by 13, doesn't end out of boundary.

The rest of this answer are just tips to clean the code a little bit:

• instead of alph='abc.. you can declare an import string at the beginning of the script and use a string.lowercase
• instead of using string slicing, for just one character it's better to use string[i] , gets the work done
• instead of c == c.upper() , you can use builtin function if c.isupper() ... .

Answer 2

The trouble you're having is with your slice. It will be empty if your character is in the second half of the alphabet, because i+13 will be off the end. There are a few ways you could fix it.

The simplest might be to simply double your alphabet string (literally: alph = alph * 2 ). This means you can access values up to 52, rather than just up to 26. This is a pretty crude solution though, and it would be better to just fix the indexing.

A better option would be to subtract 13 from your index, rather than adding 13. Rot13 is symmetric, so both will have the same effect, and it will work because negative indexes are legal in Python (they refer to positions counted backwards from the end).

In either case, it's not actually necessary to do a slice at all. You can simply grab a single value (unlike C, there's no char type in Python, so single characters are strings too). If you were to make only this change, it would probably make it clear why your current code is failing, as trying to access a single value off the end of a string will raise an exception.

Edit: Actually, after thinking about what solution is really best, I'm inclined to suggest avoiding index-math based solutions entirely. A better approach is to use Python's fantastic dictionaries to do your mapping from original characters to encrypted ones. You can build and use a Rot13 dictionary like this:

alph="abcdefghijklmnopqrstuvwxyz"
rot13_table = dict(zip(alph, alph[13:]+alph[:13])) # lowercase character mappings
rot13_table.update((c.upper(),rot13_table[c].upper()) for c in alph) # upppercase

def rot13(s):
    return "".join(rot13_table.get(c, c) for c in s) # non-letters are ignored

Answer 3

This line

ccrypt = alph[ i+13 : i+14 ]

does not do what you think it does - it returns a string slice from i+13 to i+14 , but if these indices are greater than the length of the string, the slice will be empty:

"abc"[5:6] #returns ''

This means your solution turns everything from n onward into an empty string, which produces your observed output.

The correct way of implementing this would be (1.) using a modulo operation to constrain the index to a valid number and (2.) using simple character access instead of string slices, which is easier to read, faster, and throws an IndexError for invalid indices, meaning your error would have been obvious.

ccrypt = alph[(i+13) % 26]

Answer 4

First thing that may have caused you some problems - your string list has the n and the o switched, so you'll want to adjust that :) As for the algorithm, when you run:

ccrypt = alph[ i+13 : i+14 ]

Think of what happens when you get 25 back from the first iteration (for z ). You are now looking for the index position alph[38:39] (side note: you can actually just say alph[38] ), which is far past the bounds of the 26-character string, which will return '' :

In [1]: s = 'abcde'

In [2]: s[2]
Out[2]: 'c'

In [3]: s[2:3]
Out[3]: 'c'

In [4]: s[49:50]
Out[4]: ''

As for how to fix it, there are a number of interesting methods. Your code functions just fine with a few modifications. One thing you could do is create a mapping of characters that are already 'rotated' 13 positions:

alph = 'abcdefghijklmnopqrstuvwxyz'
coded = 'nopqrstuvwxyzabcdefghijklm'

All we did here is split the original list into halves of 13 and then swap them - we now know that if we take a letter like a and get its position ( 0 ), the same position in the coded list will be the rot13 value. As this is for an assignment I won't spell out how to do it, but see if that gets you on the right track (and @Makoto's suggestion is a perfect way to check your results).

Answer 5

If you're doing this as an exercise for a course in Python, ignore this, but just saying...

>>> import codecs
>>> codecs.encode('Some text', 'rot13')
'Fbzr grkg'
>>>