बडिंग प्रोग्रामर्स के लिए पायथन रेगेक्स चीट शीट

प्रिंट करें () एक आदेश का परिणाम प्रदर्शित करें x = "नमस्ते दुनिया"
प्रिंट (x)
आउटपुट: नमस्ते दुनिया इनपुट () उपयोगकर्ताओं से इनपुट एकत्र करें प्रिंट (इनपुट ("आपका नाम क्या है?")
आउटपुट: आपका नाम क्या है? प्रकार() एक चर के प्रकार का पता लगाएं x = "नियमित अभिव्यक्ति"
प्रकार (x)
आउटपुट: लेन () एक चर में मदों की संख्या का पता लगाएं लेन ([१, २, ३])
आउटपुट: 3 \ एक वर्ण से बचो जो कोड की एक पंक्ति के इरादे को बदल देता है प्रिंट करें ("मैं आपको" \ "जोड़ना चाहता हूं")
आउटपुट: मैं आपको "" जोड़ना चाहता हूं \ n अगली पंक्ति पर शुरू करने के लिए एक स्ट्रिंग चरित्र को तोड़ें प्रिंट ("यह एक लाइन है \ n यह एक दूसरी पंक्ति है")
आउटपुट:
यह एक लाइन है
यह एक दूसरी पंक्ति है def function_name (पैरामीटर):
आदेशों एक वैकल्पिक पैरामीटर के साथ एक फ़ंक्शन शुरू करें अपना नाम बदलें (x):
प्रिंट (x + 1) लैम्ब्डा एक अनाम फ़ंक्शन को कॉल करें add_3_to = lambda y: y + 3
प्रिंट (add_3_to (4))
आउटपुट: 7 वापसी किसी फ़ंक्शन से परिणाम लौटाएं अपना नाम बदलें (x):
वापसी x + 1 कक्षा एक पायथन ऑब्जेक्ट बनाएँ वर्ग myClass:
myFunc (x) को हराया: __init__ को हराया एक वर्ग के गुण को प्रारंभ करें वर्ग myClass:
def __init __ (स्व, गुण ...) "__init__.py एक मॉड्यूल युक्त फ़ाइल को सहेजें ताकि यह एक और पायथन फ़ाइल में सफलतापूर्वक पढ़े एक मॉड्यूल के रूप में एक फ़ाइल का नाम बदलें:
"__init__.py int () एक वैरिएबल को पूर्णांक में बदलें int (1.234)
आउटपुट: 1 str () एक चर को स्ट्रिंग में बदलें str (1.234)
आउटपुट: '1.234' नाव एक चर को फ्लोट में बदलें फ्लोट (23)
आउटपुट: 23.0 तानाशाह (काउंटर) पायथन बिल्ट-इन काउंटर के साथ छाँटने के बाद एक सूची या एक शब्दकोष में एक शब्दकोश में परिवर्तित करें संग्रह आयात काउंटर से
तानाशाह (काउंटर ([१,१,२,१,२,३,३,४]])
आउटपुट: {१: ३, २: २, ३: २, ४: १} गोल() किसी ऑपरेशन के आउटपुट को निकटतम पूर्ण संख्या में गोल करें दौर (23.445)
आउटपुट: 23 दौर (संचालन या संख्या, दशमलव स्थान) किसी ऑपरेशन की आउटपुट को दशमलव स्थानों की एक विशिष्ट संख्या तक गोल करें दौर (23.4568, 2)
आउटपुट: 23.46 अगर: एक सशर्त बयान शुरू करें यदि 2 <3:
प्रिंट ("दो छोटा है") एलिफ: यदि कथन गलत है तो एक प्रतिवाद करें यदि 2 <3:
प्रिंट ("दो छोटा है")
एलीफ 2 == 3:
प्रिंट करें ("पर जाएं") अन्य: यदि अन्य स्थितियाँ गलत हैं, तो एक अंतिम प्रतिवाद करें यदि 2 <3:
प्रिंट ("दो छोटा है")
एलीफ 2 == 3:
प्रिंट करें ("पर जाएं")
अन्य:
प्रिंट ("तीन अधिक है") जारी रखें एक शर्त को अनदेखा करें और बाकी लूप को निष्पादित करें a = [१, ४, -१०, ६, 4]
एक में बी के लिए:
अगर b <= 0:
जारी रखें
प्रिंट (बी)
आउटपुट:
1
4
6
8 टूटना किसी दिए गए शर्त के साथ लूप के प्रवाह को समाप्त करें a = [१, ४, -१०, ६, 4]
एक में बी के लिए:
अगर b> = 6:
टूटना
प्रिंट (बी)
आउटपुट:
1
4
-10 उत्तीर्ण करना पूर्व निर्देशों के एक सेट को अनदेखा करें एक में बी के लिए:
उत्तीर्ण करना कोशिश करो, को छोड़कर
कोड के एक ब्लॉक का प्रयास करें, अन्यथा, एक परिभाषित अपवाद उठाएं प्रयत्न:
प्रिंट (ए)
के सिवाय:
प्रिंट ("एक त्रुटि हुई!")
आउटपुट: एक त्रुटि हुई! आखिरकार अंतिम कोड निष्पादित करें जब कोशिश और अपवाद ब्लॉक विफल हो जाएं प्रयत्न:
प्रिंट (ए)
के सिवाय:
प्रिंट (डी)
आखिरकार:
प्रिंट करें ("आप एक अपरिभाषित चर प्रिंट नहीं कर सकते हैं")
आउटपुट: आप एक अपरिभाषित चर प्रिंट नहीं कर सकते अपवाद उठाना () जब अपवाद संभव न हो तो एक अपवाद उठाएं जो कमांड को रोकता है a = 7 + 2
यदि <10:
अपवाद उठाएं ("ओह!" आपको 10 का स्कोर नहीं मिला ") आयात x संपूर्ण मॉड्यूल या लाइब्रेरी आयात करें आयात गणित x आयात y से किसी फ़ाइल, या वर्ग y से लायब्रेरी x आयात करें scipy.stats आयात मोड से जैसा अपने पसंदीदा नाम की अभिव्यक्ति को अनुकूलित करें पीडी के रूप में आयात पांडा में जाँचें कि क्या कोई मान किसी चर में मौजूद है x = [१, ४, ६, 4]
यदि x में 5:
प्रिंट ("एक पाँच है")
अन्य:
प्रिंट ("कोई पाँच नहीं है")
आउटपुट: कोई पाँच नहीं है है जांचें कि क्या दो चर एक तत्व को संदर्भित करते हैं x = [१, ४, ६, 4]
x = बी
प्रिंट (x b है)
सच कोई नहीं शून्य मान की घोषणा करें x = कोई नहीं < जांचें कि क्या एक मूल्य दूसरे की तुलना में कम है 5<10
आउटपुट: सच है > जांचें कि क्या एक मूल्य दूसरे से अधिक है 5>10
आउटपुट: गलत <= जाँच करें कि क्या मान कम है या दूसरे के बराबर है 2*2<=3
आउटपुट: गलत >= जांचें कि क्या कोई मान दूसरे से अधिक या बराबर है 2*2>=3
आउटपुट: सच है "== जांचें कि क्या एक मूल्य दूसरे के बराबर है 3==4
ouput: झूठा != पता लगाना कि एक मूल्य दूसरे के बराबर नहीं है 3!=4
ouput: सच है आयात फिर से पायथन के अंतर्निहित नियमित भावों को आयात करें आयात फिर से
re.findall ("स्ट्रिंग्स", चर) ए | बी जांचें कि क्या दो में से कोई एक तत्व स्ट्रिंग में मौजूद है आयात फिर से
someText = "नमस्ते नियमित अभिव्यक्ति"
a = re.findall ("नियमित | हैलो", someText)
प्रिंट (ए)
आउटपुट: ['हैलो', 'नियमित'] स्ट्रिंग $ जाँच करें कि क्या एक चर तार के सेट के साथ समाप्त होता है आयात फिर से
someText = "नमस्ते नियमित अभिव्यक्ति"
a = re.findall ("अभिव्यक्ति $", someText)
आउटपुट: ['अभिव्यक्ति'] ^ स्ट्रिंग जांचें कि क्या एक चर स्ट्रिंग के सेट से शुरू होता है आयात फिर से
someText = "नमस्ते नियमित अभिव्यक्ति"
a = re.findall ("^ हैलो", someText)
प्रिंट (ए)
आउटपुट: ['हैलो'] string.index () किसी स्ट्रिंग वर्ण की अनुक्रमणिका स्थिति की जाँच करें a = "हैलो वर्ल्ड"
a.index ('H')
आउटपुट: 0 string.capitalize () स्ट्रिंग्स के एक सेट में पहले चरित्र को कैपिटलाइज़ करें a = "हैलो वर्ल्ड"
a.capitalize ()
आउटपुट: 'हैलो वर्ल्ड' string.swapcase () प्रत्येक शब्द के पहले अक्षर को निचले मामले के रूप में और अन्य को ऊपरी मामले के रूप में प्रिंट करें a = "हैलो वर्ल्ड"
a.swapcase ()
आउटपुट:
'नमस्ते दुनिया' string.lower () सभी स्ट्रिंग्स को लोअरकेस में बदलें a = "हैलो वर्ल्ड"
एक निम्न()
आउटपुट: 'हैलो वर्ल्ड' string.upper () सभी स्ट्रिंग को अपरकेस में बदलें a = "हैलो वर्ल्ड"
a.upper ()
आउटपुट: 'हेलो वर्ल्ड' string.startswith () जांचें कि क्या एक स्ट्रिंग एक विशेष चरित्र से शुरू होती है a = "हैलो वर्ल्ड"
एस्टार्टस्विथ ('ए')
आउटपुट: गलत string.endswith () जांचें कि क्या कोई स्ट्रिंग किसी विशेष वर्ण के साथ समाप्त होती है a = "हैलो वर्ल्ड"
a.endwith ('d')
आउटपुट: सच है string.split () प्रत्येक शब्द को एक सूची में अलग करें a = "हैलो वर्ल्ड"
एक बँटवारा()
आउटपुट: ['हैलो', 'दुनिया'] तार {} '। स्वरूप () स्ट्रिंग के रूप में एक आउटपुट प्रदर्शित करें a = 3 + 4
प्रिंट ("उत्तर {}" है। प्रारूप (ए))
आउटपुट: उत्तर 7 है कोई नहीं है जाँचें कि क्या एक चर का मान खाली नहीं है चेक चेकनल (a):
यदि कोई नहीं है:
वापसी "अपने पूर्ण!"
अन्य:
वापसी "अपने खाली!" x% y किसी मंडल के शेष (मापांक) ज्ञात कीजिए 9%4
आउटपुट: 1 x // y किसी मंडल का भागफल ज्ञात कीजिए 9//4
आउटपुट: 2 "= किसी वैरिएबल के लिए मान निर्दिष्ट करें a = {1: 5, 3: 4} "+ तत्वों को एक साथ जोड़ें ["एक दो"] + [एक एक "]
आउटपुट: ['ए टू', 'ए वन']
1+3
आउटपुट = 4 "- संख्याओं के समूह के बीच का अंतर ज्ञात कीजिए 3-4
आउटपुट = -1 "* संख्याओं के समूह का गुणनफल ज्ञात कीजिए 3*4
आउटपुट: 12 ए + = एक्स एक नए चर के लिए इसके मूल्य को बताए बिना चर में x जोड़ें a = २
ए + = ३
आउटपुट: 5 ए- = एक्स एक नए चर को निर्दिष्ट किए बिना चर से x को वापस लाएं a = ३
a- = २
आउटपुट: 1 ए * = एक्स एक नए चर को फिर से प्रकाशित किए बिना चर ए और एक्स के उत्पाद का पता लगाएं a = [१, ३, ४]
ए * = २
आउटपुट: [१, ३, ४, १, ३, ४] x ** y बेस x को पावर y तक उठाएं 2**3
आउटपुट: 8 पाव (x, y) Y की शक्ति के लिए x उठाएँ पाउ (2, 3)
आउटपुट: 8 एब्स (x) एक नकारात्मक पूर्णांक को उसके पूर्ण मान में बदलें पेट (-5)
आउटपुट: 5 x ** (1 / nth) एक नंबर की nth रूट का पता लगाएं 8**(1/3)
आउटपुट: 2 a = b = c = d = x एक से अधिक चर के लिए एक ही मान असाइन करें a = b = c = d = "हैलो वर्ल्ड" x, y = y, x स्वैप चर x = [१, २]
य = ३
x, y = y, x
प्रिंट (x, y)
आउटपुट:
3 [1, 2] के लिये एक चर में तत्वों के माध्यम से लूप a = [१, ३, ५]
एक में बी के लिए:
प्रिंट (बी, "एक्स", "2", "=", बी * 2)
आउटपुट:
1 एक्स 2 = 2
3 x 2 = 6
5 x 2 = 10 जबकि एक चर के माध्यम से पाशन रखें, जहां तक ​​एक विशेष स्थिति सही बनी हुई है a = 4
बी = २
जबकि b <= a:
प्रिंट (बी, "से कम है", ए)
बी + = १
आउटपुट:
2 4 से कम है
3 4 से कम है
4 4 से कम है सीमा () एक्स और वाई के बीच सकारात्मक पूर्णांक की एक श्रृंखला बनाएं एक्स = रेंज (4)
प्रिंट (x)
सीमा (0, 4)
एक्स में बी के लिए:
प्रिंट (बी)
आउटपुट:
0
1
2
3 योग () सूची में तत्वों के माध्यम से परिवर्तन प्रिंट (राशि ([1, 2, 3]))
आउटपुट: 6 योग (सूची, प्रारंभ) किसी जोड़े गए तत्व के साथ सूची का योग लौटाएं प्रिंट (राशि ([1, 2, 3], 3))
आउटपुट: 9 [] तत्वों की एक सूची बनाएं x = ['ए', ३, ५, 'एच', [१, ३, ३], {'डी': ३}] () एक tuppletupples बनाएँ अपरिवर्तनीय हैं x = (1, 2, 'जी', 5) {} एक शब्दकोश बनाएँ a = {'x': 6, 'y': 8} x [a: b] एक सूची के माध्यम से टुकड़ा x = [१, ३, ५, ६]
x [0: 2]
आउटपुट: [१, ३] x [कुंजी] शब्दकोश x में एक कुंजी का मूल्य प्राप्त करें a = {'x': 6, 'y': 8}
प्रिंट ([['x'])
आउटपुट: 6 x.append () रिक्त सूची में मानों की सूची जोड़ें x = [१]
x.append ([1,2,3])
प्रिंट (x)
आउटपुट: [१, [१,२,३]] x.extend () आवश्यक रूप से नेस्टेड सूची बनाए बिना मौजूदा सूची को जारी रखने के लिए मूल्यों की एक सूची जोड़ें x = [1,2]
x.extend ([3,4,6,2])
प्रिंट (x)
आउटपुट:
[1, 2, 3, 4, 6, 2] डेल (एक्स [ए: बी]) किसी विशिष्ट अनुक्रमणिका की सूची से किसी आइटम को पूरी तरह से हटा दें x = [1,2,3,5]
डेल (x [0: 2])
प्रिंट (x)
आउटपुट: [2,3,5]
डेल (x [कुंजी]) किसी विशेष इंडेक्स पर एक शब्दकोश से एक कुंजी और एक मूल्य को पूरी तरह से हटा दें y = {१: ३, २: ५, ४: ६, 3: २}
डेल (y [1], y [8])
प्रिंट (y)
आउटपुट = {२: ५, ४: ६} तानाशाही। एक कुंजी का मूल्य बाहर निकालें और इसे एक विशेष इंडेक्स पर एक शब्दकोश से हटा दें a = {1: 3, 2: 4, 5: 6}
a.pop (1)
आउटपुट: 3 तानाशाही। किसी शब्दकोश से अंतिम आइटम को पॉप आउट करें और उसे हटा दें a = {1: 2, 4: 8, 3: 5}
a.popitem ()
आउटपुट: (3, 5)
प्रिंट (ए)
आउटपुट: {१: २, ४::} list.pop () किसी सूची से दिए गए सूचकांक को पॉप आउट करें और इसे सूची से हटा दें a = [1, 3, 2, 4, 1, 6, 6, 4]
a.pop (-2)
आउटपुट: 6
प्रिंट (ए)
आउटपुट: [१, ३, २, ४, १, ६, ४] स्पष्ट() सूची या शब्दकोश के तत्वों को खाली करें x = [१, ३, ५]
x.clear ()
प्रिंट (x)
आउटपुट: [] हटाना() किसी सूची से कोई आइटम निकालें x = [१, ५, ६, 5]
x.remove (1)
आउटपुट: [५, ६, 6] डालें () तत्वों को एक सूची में डालें x = [३, ५, ६]
x.insert (1, 4)
प्रिंट (x)
आउटपुट: [१, ४, ३, ५, ६] सॉर्ट (रिवर्स = कंडीशन) किसी सूची में तत्वों की दिशा को उल्टा करें x = [१, ३, ५, ६]
x.sort (रिवर्स = ट्रू)
प्रिंट (x)
आउटपुट: [६, ५, ३, १] अपडेट करें() इसके पहले तत्व को बदलकर और इसके अंत में किसी अन्य आइटम को जोड़कर एक शब्दकोश अपडेट करें x = {1: 3, 5: 6}
x.update ({1: 4, 8: 7, 4: 4})
प्रिंट (x)
आउटपुट: {१: ४, ५: ६,,: 4, ४: ४} चांबियाँ() एक शब्दकोश में सभी चाबियाँ दिखाएं a = {1: 2, 4: 8}
a.keys ()
आउटपुट: dict_keys ([1, 4]) मान () एक शब्दकोश में सभी मूल्यों को दिखाएं a = {1: 2, 4: 8}
a.values ​​()
आउटपुट: डिक्टल_वेल्यूज़ ([2, 8]) आइटम () शब्दकोश में कुंजियों और मूल्यों को प्रदर्शित करें a = {1: 2, 4: 8}
a.items ()
आउटपुट: तानाशाही चाबी देना) किसी वस्तु के मूल्य को उसकी कुंजी से शब्दकोश में प्राप्त करें a = {1: 2, 4: 8, 3: 5}
a.get (1)
आउटपुट: 2 सेटडेफ़ॉल्ट (कुंजी) किसी तत्व के मूल मान को शब्दकोश में लौटाएं a.setdefault (2) f = {** a, ** b} दो शब्दकोश मर्ज करें a = {'x': 6, 'y': 8}
b = {'c': 5, 'd': 3}
f = {** a, ** y}
प्रिंट (एफ)
आउटपुट: {8 x ’: 6, 'y’: 8,: c ’: 5,' d’: 3} हटाना() किसी सूची के तत्व का पहला मिलान मूल्य उसके सूचकांक को ध्यान में रखे बिना हटा दें a = [1, 3, 2, 4, 4, 1, 6, 6, 4]
ए। मोरोव (4)
प्रिंट (ए)
आउटपुट: [१, ३, २, ४, १, ६, ६, ४] मेमोरीव्यू (x) किसी ऑब्जेक्ट के आंतरिक बफ़र्स तक पहुँचें a = मेमोरीव्यू (ऑब्जेक्ट) बाइट्स () मेमोरी बफ़र प्रोटोकॉल को बाइट्स में बदलें बाइट्स ([0: 2]) बायट्रेयर () बाइट्स की एक सरणी लौटें बायट्रेयर (ऑब्जेक्ट) # टिप्पणी की एक पंक्ति लिखें या कोड की एक पंक्ति को निष्पादित होने से रोकें # अजगर रेगेक्स चीट शीट एक बहु-पंक्ति टिप्पणी लिखें पायथन रेगेक्स चीट शीट शुरुआती लोगों के लिए अच्छा है
यह विशेषज्ञों के लिए समान रूप से एक बढ़िया रिफ्रेशर है कमांड लाइन पाइप स्थापित पैकेज एक ऑनलाइन लाइब्रेरी स्थापित करें पंडाल स्थापित करें virtualenv नाम वर्चुअल वातावरण बनाने के लिए virtaulenv का उपयोग करें virtualenv myproject mkvirtualenv नाम वर्चुअल वातावरण बनाने के लिए वर्चुअल एन्वायरनमेंट रैपर का उपयोग करें mkvirtualenv myproject python file.py पायथन फ़ाइल में कमांड चलाएँ "अजगर my_file.py पाइप फ्रीज वर्चुअल वातावरण में सभी स्थापित पैकेजों को सूचीबद्ध करें पाइप फ्रीज पाइप फ्रीज> somefiles एक ही फाइल में सभी स्थापित पुस्तकालयों की प्रतिलिपि बनाएँ पाइप फ्रीज> आवश्यकताएँ कहां है पायथन की स्थापना पथ का पता लगाएं जहां अजगर - फैलाव पैकेज का संस्करण जांचें अजगर - विसर्जन ।प्रोग्राम फ़ाइल पायथन शेल चलाएं python.exe खुले (फ़ाइल, 'w') के साथ किसी मौजूदा फ़ाइल में लिखें और उसकी मौजूदा सामग्री को अधिलेखित करें खुले रूप में ('regex.txt', 'w') wf के रूप में:
wf.write ("हैलो वर्ल्ड!") खुले (फ़ाइल, 'आर') के साथ फ़ाइल को केवल पढ़ने के लिए खोलें rf के रूप में खुले ('regex.txt', 'r') के साथ:
प्रिंट (rf.read) खुले (फ़ाइल, 'ए') के साथ किसी फ़ाइल को उसकी मौजूदा सामग्री को अधिलेखित किए बिना लिखें खुले रूप में ('regex.txt', 'a') as af:
af.write ("\ n हेलो हाँ!") file.close यदि यह उपयोग में नहीं है तो एक फाइल बंद करें af = खुला ('regex.txt')
af.close बाहर जाएं पायथन शेल से बाहर निकलें बाहर जाएं()