पायथन ट्रांसपिलर श्रृंखला → 11l → C ++ [पायथन कोड को गति देने के लिए और अधिक]

श्रेणी के साथ स्लाइस \ स्लाइस की जगह

s[-1] s[-2] s[:-1] s[1:] s[:2] s[1:2] s[::2] s[1::2] s[3:10:2] 

 s.last s[(len)-2] s[0..<(len)-1] s[1..] s[0..<2] s[1..<2] s[(0..).step(2)] s[(1..).step(2)] s[(3..<10).step(2)] 

1. जब, उदाहरण के लिए, पिछले चरित्र को s[i-1] से प्राप्त करना आवश्यक है, लेकिन i = 0 के लिए / जैसे कि त्रुटि के बजाय यह रिकॉर्ड चुपचाप स्ट्रिंग के अंतिम चरित्र को लौटा देगा [ और व्यवहार में मुझे ऐसी त्रुटि का सामना करना पड़ा है ] ।
2. अभिव्यक्ति s[i:] बाद i = s.find(":") गलत तरीके से काम करेगा जब चरित्र स्ट्रिंग में नहीं पाया जाता है [ पहले अक्षर से शुरू होने वाले स्ट्रिंग के '' भाग के बजाय : और फिर 'स्ट्रिंग का अंतिम चरित्र' लिया जाएगा ] (और आम तौर पर) , मुझे लगता है कि पायथन में फ़ंक्शन find() फ़ंक्शन के साथ -1 लौटना भी गलत है [ अशक्त / कोई नहीं लौटना चाहिए [ और यदि -1 की आवश्यकता है, तो इसे स्पष्ट रूप से लिखा जाना चाहिए: i = s.find(":") ?? -1 ] ] )।
3. किसी स्ट्रिंग के अंतिम n अक्षर प्राप्त करने के लिए s[-n:] लिखना n = 0 पर सही ढंग से काम नहीं करेगा।

तुलना ऑपरेटरों के चेन

सूची की समझ

1. उन सभी स्थानों पर जहां मैंने पायथन की सूची को देखा है, आप आसानी से फ़ंक्शंस `फ़िल्टर ()` और `मैप ()` के साथ प्राप्त कर सकते हैं।

    dirs[:] = [d for d in dirs if d[0] != '.' and d != exclude_dir] dirs[:] = filter(lambda d: d[0] != '.' and d != exclude_dir, dirs) '[' + ', '.join(python_types_to_11l[ty] for ty in self.type_args) + ']' '[' + ', '.join(map(lambda ty: python_types_to_11l[ty], self.type_args)) + ']' # Nested list comprehension: matrix = [ [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], ] [[row[i] for row in matrix] for i in range(4)] list(map(lambda i: list(map(lambda row: row[i], matrix)), range(4))) 

2. 11l में `फिल्टर ()` और `नक्शा ()` पायथन की तुलना में सुंदर लगते हैं

    dirs[:] = filter(lambda d: d[0] != '.' and d != exclude_dir, dirs) dirs = dirs.filter(d -> d[0] != '.' & d != @exclude_dir) '[' + ', '.join(map(lambda ty: python_types_to_11l[ty], self.type_args)) + ']' '['(.type_args.map(ty -> :python_types_to_11l[ty]).join(', '))']' outfile.write("\n".join(x[1] for x in fileslist if x[0])) outfile.write("\n".join(map(lambda x: x[1], filter(lambda x: x[0], fileslist)))) outfile.write(fileslist.filter(x -> x[0]).map(x -> x[1]).join("\n")) 

   और फलस्वरूप, 11l में सूची बोध की आवश्यकता वास्तव में गायब हो जाती है [ filter() और (या / या map() filter() साथ सूची बोध के प्रतिस्थापन को स्वचालित रूप से 11l में पायथन कोड के रूपांतरण के दौरान किया जाता है ] ।

परिवर्तित करें अगर-एलिफ-और-श्रृंखला को स्विच करने के लिए

 ch = instr[i] if ch == "[": nesting_level += 1 elif ch == "]": nesting_level -= 1 if nesting_level == 0: break elif ch == "'": ending_tags.append(''') # '' elif ch == "'": assert(ending_tags.pop() == ''') 

 switch instr[i] '[' nesting_level++ ']' if --nesting_level == 0 loop.break "'" ending_tags.append("'") // '' "'" assert(ending_tags.pop() == "'") 

 switch (instr[i]) { case u'[': nesting_level++; break; case u']': if (--nesting_level == 0) goto break_; break; case u''': ending_tags.append(u"'"_S); break; // '' case u''': assert(ending_tags.pop() == u'''); break; } 

छोटे शब्दकोशों को देशी कोड में बदलें

 tag = {'*':'b', '_':'u', '-':'s', '~':'i'}[prev_char()] 

 var tag = switch prev_char() {'*' {'b'}; '_' {'u'}; '-' {'s'}; '~' {'i'}} 

 auto tag = [&](const auto &a){return a == u'*' ? u'b'_C : a == u'_' ? u'u'_C : a == u'-' ? u's'_C : a == u'~' ? u'i'_C : throw KeyError(a);}(prev_char()); 

 rn = {'I': 1, 'V': 5, 'X': 10, 'L': 50, ...} 

 var rn = ['I' = 1, 'V' = 5, 'X' = 10, 'L' = 50, ...] 

 auto rn = create_dict(dict_of(u'I'_C, 1)(u'V'_C, 5)(u'X'_C, 10)(u'L'_C, 50)...); 

कैप्चर \ Ca बाहरी चर चर

 writepos = 0 def write_to_pos(pos, npos): nonlocal writepos outfile.write(...) writepos = npos 

 var writepos = 0 fn write_to_pos(pos, npos) @outfile.write(...) @writepos = npos 

 auto writepos = 0; auto write_to_pos = [..., &outfile, &writepos](const auto &pos, const auto &npos) { outfile.write(...); writepos = npos; }; 

वैश्विक चर

 break_label_index = -1 ... def parse(tokens, source_): global source, tokeni, token, scope source = source_ tokeni = -1 token = None break_label_index = -1 scope = Scope(None) ... 

 var break_label_index = -1 ... fn parse(tokens, source_) :source = source_ :tokeni = -1 :token = null break_label_index = -1 :scope = Scope(null) ... 

वर्तमान कंटेनर आइटम का सूचकांक / संख्या

 items = ['A', 'B', 'C'] for index, item in enumerate(items): print(str(index) + ' = ' + item) 

 var items = ['A', 'B', 'C'] loop(item) items print(loop.index' = 'item) 

उत्पादकता

और अब Python → 11l → C ++ ट्रांसपिलर द्वारा उत्पन्न आरेख को आरेख में जोड़ें:

रनटाइम [ 488Kb फ़ाइल रूपांतरण समय ] CP68 के लिए 868 एमएस और उत्पन्न सी ++ कोड के लिए 38 एमएस था [ इस समय में पूर्ण-भाग शामिल है [ अर्थात न केवल रैम में डेटा के साथ काम करना ] ऑपरेटिंग सिस्टम द्वारा प्रोग्राम चलाना और सभी इनपुट / आउटपुट [ स्रोत फ़ाइल [ .pq ] पढ़ना और नई फ़ाइल [ .html ] को डिस्क पर सहेजना ] ।

मैं शेड स्किन को भी आजमाना चाहता था, लेकिन यह स्थानीय कार्यों का समर्थन नहीं करता है।
Numba का उपयोग नहीं किया जा सकता (यह एक त्रुटि 'अज्ञात opcode का उपयोग LOAD_BUILD_CLASS' फेंकता है)।
यहां प्रदर्शन के साथ तुलना करने के लिए उपयोग किए जाने वाले प्रोग्राम के साथ संग्रह है [ विंडोज के तहत ] (अजगर 3.6 या उच्चतर की आवश्यकता है और निम्नलिखित पायथन पैकेज: pywin32, साइथन)।