Это очень просто:

>>> import codecs
>>> codecs.encode('foobar', 'rot_13')
'sbbone'

>>> 'foobar'.encode('rot13')
'sbbone'

(Я слышал слухи, что это не работает в Python 3.хотя Икс.)

The maketrans и translate функции string модуль удобен для этого типа вещей. Конечно же,encode метод в ответе Амбера еще удобнее для этого конкретного случая.

вот общее решение:

import string

def make_rot_n(n):
 lc = string.ascii_lowercase
 uc = string.ascii_uppercase
 trans = string.maketrans(lc + uc,
                          lc[n:] + lc[:n] + uc[n:] + uc[:n])
 return lambda s: string.translate(s, trans)

rot13 = make_rot_n(13)

rot13('foobar')
# 'sbbone'

в модуле this.py (import this).

d = {}
for c in (65, 97):
    for i in range(26):
        d[chr(i+c)] = chr((i+13) % 26 + c)

print "".join([d.get(c, c) for c in s])

начиная с Python 3.1,string.translate и string.maketrans больше не существует. Однако, эти методы могут быть использованы с .

таким образом, современное решение, непосредственно вдохновленное одним из Павла Рубеля, является:

rot13 = bytes.maketrans(
    b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
    b"nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM")
b'Hello world!'.translate(rot13)

преобразование string до bytes и наоборот можно сделать с encode и decode встроенные функции.

попробуйте это:

import codecs
codecs.encode("text to be rot13()'ed", "rot_13")

в Python-3 в str - кодек, который @amber упомянул, переместился в codecs стандартные-библиотека:

> import codecs
> codecs.encode('foo', 'rot13')
sbb

для произвольных значений, что-то вроде этого работает для 2.x

from string import ascii_uppercase as uc, ascii_lowercase as lc, maketrans                                                                                                            

rotate = 13 # ROT13                                                                    
rot = "".join([(x[:rotate][::-1] + x[rotate:][::-1])[::-1] for x in (uc,lc)])   

def rot_func(text, encode=True):                                                
    ascii = uc + lc                                                             
    src, trg = (ascii, rot) if encode else (rot, ascii)                         
    trans = maketrans(src, trg)                                                 
    return text.translate(trans)                                                

text = "Text to ROT{}".format(rotate)                                           
encode = rot_func(text)                                                         
decode = rot_func(encode, False)

это работает для верхнего и нижнего регистра. Я не знаю, насколько элегантным ты его считаешь.

def rot13(s):
    rot=lambda x:chr(ord(x)+13) if chr(ord(x.lower())+13).isalpha()==True else chr(ord(x)-13)
    s=[rot(i) for i in filter(lambda x:x!=',',map(str,s))]
    return ''.join(s)

вы можете поддерживать прописные буквы в исходном коде, опубликованном г-ном Уолтером, чередуя буквы верхнего и нижнего регистра.

chars = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"

если вы заметили, что индекс прописных букв-это все четные числа, а индекс строчных букв-нечетные.

• A = 0 a = 1,
• B = 2, b = 3,
• C = 4, c = 4,
• ...

эта нечетно-четная картина позволяет нам безопасно добавить необходимую сумму без необходимости беспокоиться о деле.

trans = chars[26:] + chars[:26]

причина, по которой вы добавляете 26, заключается в том, что строка удвоилась в буквах из-за букв верхнего регистра. Тем не менее, сдвиг по-прежнему составляет 13 пробелов в алфавите.

полный код:

def rot13(s):
    chars = "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz"
    trans = chars[26:]+chars[:26]
    rot_char = lambda c: trans[chars.find(c)] if chars.find(c) > -1 else c
    return ''.join(rot_char(c) for c in s)

выход (протестирован с python 2.7):

print rot13("Hello World!") --> Uryyb Jbeyq!

следующая функция rot(s, n) кодирует строку s С сгноить-n кодировка для любого целого n С n по умолчанию 13. Поддерживаются как прописные, так и строчные буквы. Значения n более 26 или отрицательные значения обрабатываются соответствующим образом, например, смещение на 27 позиций равно смещению на одну позицию. Декодирование выполняется с помощью invrot(s, n).

import string

def rot(s, n=13):
    '''Encode string s with ROT-n, i.e., by shifting all letters n positions.
    When n is not supplied, ROT-13 encoding is assumed.
    '''
    upper = string.ascii_uppercase
    lower = string.ascii_lowercase
    upper_start = ord(upper[0])
    lower_start = ord(lower[0])
    out = ''
    for letter in s:
        if letter in upper:
            out += chr(upper_start + (ord(letter) - upper_start + n) % 26)
        elif letter in lower:
            out += chr(lower_start + (ord(letter) - lower_start + n) % 26)
        else:
            out += letter
    return(out)

def invrot(s, n=13):
    '''Decode a string s encoded with ROT-n-encoding
    When n is not supplied, ROT-13 is assumed.
    '''
    return(rot(s, -n))

один лайнер для rot13 строка S:

S.translate({a : a + (lambda x: 1 if x>=0 else -1)(77 - a) * 13 for a in range(65, 91)})

def rot13(s):
    lower_chars = ''.join(chr(c) for c in range (97,123)) #ASCII a-z
    upper_chars = ''.join(chr(c) for c in range (65,91)) #ASCII A-Z
    lower_encode = lower_chars[13:] + lower_chars[:13] #shift 13 bytes
    upper_encode = upper_chars[13:] + upper_chars[:13] #shift 13 bytes
    output = "" #outputstring
    for c in s:
        if c in lower_chars:
                output = output + lower_encode[lower_chars.find(c)]
        elif c in upper_chars:
            output = output + upper_encode[upper_chars.find(c)]
        else:
            output = output + c
    return output

другое решение изменено. Может быть, этот код помогает другим людям лучше понять rot13. Не проверял его полностью.

from string import maketrans, lowercase, uppercase

def rot13(message):
   lower = maketrans(lowercase, lowercase[13:] + lowercase[:13])
   upper = maketrans(uppercase, uppercase[13:] + uppercase[:13])
   return message.translate(lower).translate(upper)

интересное упражнение ;-) я думаю, что у меня есть лучшее решение, потому что:

1. модули не нужны, использует только встроенные функции -->нет осуждения
2. его можно использовать как один вкладыш
3. на основе ascii, без отображения диктов / строк и т. д.

Python 2 & 3 (вероятно, Python 1):

def rot13(s):
    return ''.join([chr(ord(n) + (13 if 'Z' < n < 'n' or n < 'N' else -13)) if n.isalpha() else n for n in s])

def rot13_verbose(s):
    x = []
    for n in s:
        if n.isalpha():
            # 'n' is the 14th character in the alphabet so if a character is bigger we can subtract 13 to get rot13
            ort = 13 if 'Z' < n < 'n' or n < 'N' else -13
            x.append(chr(ord(n) + ort))
        else:
            x.append(n)
    return ''.join(x)



# crazy .min version (99 characters) disclaimer: not pep8 compatible^

def r(s):return''.join([chr(ord(n)+(13if'Z'<n<'n'or'N'>n else-13))if n.isalpha()else n for n in s])

Я нашел этот пост, когда я начал задаваться вопросом о самом простом способе реализации rot13 в Python себя. Мои цели были:

• работает как в Python 2.7.6 и 3.3.
• ручка как верхний, так и нижний регистр.
• не использовать внешние библиотеки.

Это соответствует всем трем из этих требований. При этом я уверен, что он не выигрывает никаких соревнований по кодовому гольфу.

def rot13(string):
    CLEAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
    ROT13 = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
    TABLE = {x: y for x, y in zip(CLEAR, ROT13)}

    return ''.join(map(lambda x: TABLE.get(x, x), string))



if __name__ == '__main__':
    CLEAR = 'Hello, World!'
    R13 = 'Uryyb, Jbeyq!'

    r13 = rot13(CLEAR)
    assert r13 == R13

    clear = rot13(r13)
    assert clear == CLEAR

это работает путем создания lookup таблица и просто возвращает исходный символ для любого символа, не найденного в таблице поиска.

обновление

я стал беспокоиться о том, что кто-то хочет использовать это для шифрования произвольно большого файла (скажем, несколько гигабайт текста). Я не знаю, зачем им это нужно, но что, если они захотят? Поэтому я переписал его как генератор. Опять же, это было протестировано как в Python 2.7.6, так и в 3.3.

def rot13(clear):
    CLEAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
    ROT13 = 'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
    TABLE = {x: y for x, y in zip(CLEAR, ROT13)}

    for c in clear:
        yield TABLE.get(c, c)



if __name__ == '__main__':
    CLEAR = 'Hello, World!'
    R13 = 'Uryyb, Jbeyq!'

    r13 = ''.join(rot13(CLEAR))
    assert r13 == R13

    clear = ''.join(rot13(r13))
    assert clear == CLEAR

Я не мог оставить этот вопрос здесь без одного оператора, используя оператор по модулю.

def rot13(s):
    return ''.join([chr(x.islower() and ((ord(x) - 84) % 26) + 97
                        or x.isupper() and ((ord(x) - 52) % 26) + 65
                        or ord(x))
                    for x in s])

Это не подходящие для Python ни хорошая практика, но это работает!

>> rot13("Hello World!")
Uryyb Jbeyq!

вы также можете использовать

def n3bu1A(n):
    o=""
    key = {
       'a':'n', 'b':'o', 'c':'p', 'd':'q', 'e':'r', 'f':'s', 'g':'t', 'h':'u', 
       'i':'v', 'j':'w', 'k':'x', 'l':'y', 'm':'z', 'n':'a', 'o':'b', 'p':'c', 
       'q':'d', 'r':'e', 's':'f', 't':'g', 'u':'h', 'v':'i', 'w':'j', 'x':'k',
       'y':'l', 'z':'m', 'A':'N', 'B':'O', 'C':'P', 'D':'Q', 'E':'R', 'F':'S', 
       'G':'T', 'H':'U', 'I':'V', 'J':'W', 'K':'X', 'L':'Y', 'M':'Z', 'N':'A', 
       'O':'B', 'P':'C', 'Q':'D', 'R':'E', 'S':'F', 'T':'G', 'U':'H', 'V':'I', 
       'W':'J', 'X':'K', 'Y':'L', 'Z':'M'}
    for x in n:
        v = x in key.keys()
        if v == True:
            o += (key[x])   
        else:
            o += x
    return o

Yes = n3bu1A("N zhpu fvzcyre jnl gb fnl Guvf vf zl Zragbe!!")
print(Yes)

короткое решение:

def rot13(text):
    return "".join([x if ord(x) not in range(65, 91)+range(97, 123) else
            chr(((ord(x)-97+13)%26)+97) if x.islower() else
            chr(((ord(x)-65+13)%26)+65) for x in text])