दिलचस्प पोस्ट
.xls फ़ाइल को .csv फ़ाइल में कनवर्ट करने का कोई आसान तरीका है? (एक्सेल) सी ++ में शुद्ध आभासी नाशक एपीआई द्वारा विकिपीडिया पृष्ठ की मुख्य तस्वीर तक पहुंचना Java / स्विंग के लिए अच्छा डॉकिंग चौखटे क्या हैं? क्यों जावास्क्रिप्ट eval समारोह का उपयोग कर एक बुरा विचार है? यदि राज्य मेरी कक्षाओं से बना है तो एंड्रॉइड में अभिविन्यास परिवर्तन के दौरान राज्य को कैसे बचाया जाए? गिट में लेखक और कॉमटर नाम और कई कमानों के ई-मेल को बदलें गिट में पेड़-ईश का क्या अर्थ है? संदर्भ: mod_rewrite, URL पुनर्लेखन और "सुंदर लिंक" समझाया अपाचे POI का उपयोग करते हुए xlsx फ़ाइल पढ़ते समय अपवाद (org.apache.poi.openxml4j.exception – कोई सामग्री प्रकार प्राप्त नहीं हो रही है? CodeIgniter PHP फ़्रेमवर्क – क्वेरी स्ट्रिंग प्राप्त करने की आवश्यकता है Android पर चलाने के लिए मैं एक देशी (कमांड लाइन) निष्पादन योग्य कैसे बना सकता हूं? अजगर में मोनोटोनिक समय की अवधि कैसे प्राप्त की जा सकती है? कैसे काम करता है? लोडिंग के साथ jqgrid reloadGrid को सही पर सेट करें

शॉर्ट रोट 13 फ़ंक्शन – पायथन

मैं पायथन में एक छोटी और शांत रोट13 फ़ंक्शन के लिए खोज रहा हूं 😉 मैंने यह फ़ंक्शन लिखा है:

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

क्या कोई इसे बेहतर बना सकता है? उदाहरण के लिए अपरकेस वर्णों का समर्थन करना

वेब के समाधान से एकत्रित समाधान "शॉर्ट रोट 13 फ़ंक्शन – पायथन"

यहाँ एक मकेटरन / अनुवाद समाधान है

 import string rot13 = string.maketrans( "ABCDEFGHIJKLMabcdefghijklmNOPQRSTUVWXYZnopqrstuvwxyz", "NOPQRSTUVWXYZnopqrstuvwxyzABCDEFGHIJKLMabcdefghijklm") string.translate("Hello World!", rot13) # 'Uryyb Jbeyq!' 

यह बहुत सरल है

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

(मैंने सुना है अफवाहें ये पायथन 3.x में काम नहीं करती हैं।)

maketrans और string मॉड्यूल में फ़ंक्शन का translate इस प्रकार की चीज़ के लिए आसान है। बेशक, एम्बर की प्रतिक्रिया में 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' 

मॉड्यूल से यह ( 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]) 

पायथन 3.1 के रूप में, string.translate और string.maketrans अब मौजूद नहीं हैं। हालांकि, इन तरीकों का उपयोग bytes बजाय किया जा सकता है।

इस प्रकार, पॉल रूबेल के एक से प्रेरित एक अप-टू-डेट समाधान सीधे है:

 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 codec जो कि @ एम्बर 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" 

यदि आप बड़े अक्षरों के इंडेक्स को देखते हैं तो सभी नंबर भी होते हैं, जबकि लोअर केस अक्षरों का सूचक अजीब है

  • ए = 0 ए = 1,
  • बी = 2, बी = 3,
  • सी = 4, सी = 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) 

आउटपुट (अजगर 2.7 के साथ परीक्षण किया गया):

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

निम्न फ़ंक्शन rot(s, n) किसी स्ट्रिंग के साथ किसी स्ट्रिंग को आरओटी- n एन्कोडिंग के लिए एन्कोड करता है, जो n साथ 13 से चूक है। दोनों ऊपरी और लोअरकेस अक्षरों का समर्थन है। 26 से अधिक या नकारात्मक मूल्यों के मूल्य उचित रूप से नियंत्रित किए जाते हैं, जैसे, 27 पदों के स्थानांतरण एक स्थिति से स्थानांतरण के बराबर है। invrot(s, n) साथ डिकोडिंग किया जाता है

 import string def rot(s, n=13): '''Encode string s with ROT-n, ie, 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)) 

एक-लाइनर को रोट 13 को स्ट्रिंग 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 az upper_chars = ''.join(chr(c) for c in range (65,91)) #ASCII AZ 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 

स्थानांतरण के साथ एक और समाधान। हो सकता है कि यह कोड अन्य लोगों को रोट 13 को बेहतर ढंग से समझने में मदद करता है इसे पूरी तरह से परीक्षण नहीं किया है

 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. एएससीआई पर आधारित, कोई मैपिंग डिक्र्स / स्ट्रिंग आदि नहीं।

पायथन 2 और 3 (शायद पायथन 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 था कि पायथन में rot13 को लागू करने का सबसे आसान तरीका है मेरे लक्ष्य थे:

  • दोनों पायथन 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 

यह एक लुकअप तालिका बनाकर काम करता है और केवल लुकअप तालिका में न मिलने वाले किसी भी पात्र के मूल चरित्र को लौटाता है।

अद्यतन करें

मुझे किसी के बारे में चिंतित होना चाहिए, जिसका उपयोग किसी मनमाने ढंग से बड़ी फ़ाइल को एन्क्रिप्ट करने के लिए करना है (जैसे, पाठ की कुछ गीगाबाइट्स)। मुझे नहीं पता कि वे ऐसा क्यों करना चाहते हैं, लेकिन क्या हुआ अगर वे करते हैं? इसलिए मैं इसे जनरेटर के रूप में पुनः लिखता हूं। दोबारा, यह अजगर 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]) 

यह अजगर और न ही अच्छा अभ्यास है, लेकिन यह काम करता है!

 >> 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])