20 पायथन फ़ंक्शंस आपको पता होना चाहिए

कम कोड लिखना अधिक पठनीय, कार्यात्मक कार्यक्रमों को तैयार करने का एक शानदार तरीका है। आपको आसानी से उपलब्ध पायथन कार्यों या विधियों को फिर से बनाने में अपना बहुमूल्य समय बर्बाद नहीं करना चाहिए। हालाँकि, यदि आप पायथन के अंतर्निहित टूल से परिचित नहीं हैं, तो आप ऐसा कर सकते हैं।

यहां मूल्यवान अंतर्निहित पायथन फ़ंक्शंस और विधियों की सूची दी गई है जो आपके कोड को छोटा करते हैं और इसकी दक्षता में सुधार करते हैं।

1. कम करना()

अजगर कम करना() फ़ंक्शन किसी सूची, या किसी अन्य पुनरावृत्त डेटा प्रकार में प्रत्येक आइटम पर पुनरावृति करता है, और एक एकल मान देता है। यह बिल्ट-इन के तरीकों में से एक है फंक्शनटूल्स पायथन की कक्षा।

कम करने का उपयोग करने का एक उदाहरण यहां दिया गया है:

functools से आयात कम करें
def add_num (ए, बी):
वापसी ए+बी
ए = [१, २, ३, १०]
प्रिंट करें (कम करें (add_num, a))
आउटपुट: 16

आप स्ट्रिंग्स की सूची को का उपयोग करके भी प्रारूपित कर सकते हैं कम करना() समारोह:

functools से आयात कम करें
def add_str (ए, बी):
वापसी ए+''+बी
ए = ['एमयूओ', 'है', 'ए', 'मीडिया', 'वेबसाइट']
प्रिंट करें (कम करें (add_str, a))
आउटपुट: MUO एक मीडिया वेबसाइट है 

2. विभाजित करना()

NS विभाजित करना() फ़ंक्शन सेट मानदंड के आधार पर एक स्ट्रिंग को तोड़ता है। आप इसका उपयोग किसी वेब प्रपत्र से स्ट्रिंग मान को विभाजित करने के लिए कर सकते हैं। या आप इसका उपयोग टेक्स्ट के एक टुकड़े में शब्दों की संख्या गिनने के लिए भी कर सकते हैं।

नीचे दिया गया उदाहरण कोड एक सूची को विभाजित करता है जहाँ भी कोई स्थान हो:

शब्द = "कॉलम 1 कॉलम 2 कॉलम 3"
शब्द = शब्द। विभाजन ("")
प्रिंट (शब्द)
आउटपुट: ['कॉलम 1', 'कॉलम 2', 'कॉलम 3']

सम्बंधित: पायथन में एक स्ट्रिंग को कैसे विभाजित करें

3. गणना ()

NS गणना () फ़ंक्शन एक पुनरावृत्त की लंबाई देता है और एक साथ अपने आइटम के माध्यम से लूप करता है। इस प्रकार, प्रत्येक आइटम को एक पुनरावृत्त डेटा प्रकार में प्रिंट करते समय, यह एक साथ अपनी अनुक्रमणिका को आउटपुट करता है।

मान लें कि आप चाहते हैं कि कोई उपयोगकर्ता आपके डेटाबेस में उपलब्ध आइटम्स की सूची देखे। आप उन्हें एक सूची में पास कर सकते हैं और इसका उपयोग कर सकते हैं गणना () इसे क्रमांकित सूची के रूप में वापस करने के लिए कार्य करें।

यहां बताया गया है कि आप इसका उपयोग करके इसे कैसे प्राप्त कर सकते हैं गणना () तरीका:

फल = ["अंगूर", "सेब", "आम"]
i, j के लिए एन्यूमरेट (फल) में:
प्रिंट (आई, जे)
आउटपुट:
0 अंगूर
1 सेब
२ आम

जबकि, आपने इसे प्राप्त करने के लिए निम्न विधि का उपयोग करके अपना बहुमूल्य समय बर्बाद किया होगा:

फल = ["अंगूर", "सेब", "आम"]
के लिए मैं सीमा में (लेन (फल)):
प्रिंट (i, फल [i])

तेज़ होने के अलावा, सूची की गणना करने से आप अनुकूलित कर सकते हैं कि आपके क्रमांकित आइटम कैसे आते हैं।

संक्षेप में, आप a. को शामिल करके, शून्य के बजाय एक से नंबरिंग शुरू करने का निर्णय ले सकते हैं प्रारंभ पैरामीटर:

i के लिए, j गणना में (फल, प्रारंभ = 1):
प्रिंट (आई, जे)
आउटपुट:
1 अंगूर
2 सेब
3 आम

4. eval ()

अजगर eval () फ़ंक्शन आपको पूर्णांकों या फ़्लोट्स पर गणितीय संचालन करने देता है, यहां तक ​​कि उनके स्ट्रिंग रूपों में भी। यदि गणितीय गणना एक स्ट्रिंग प्रारूप में है तो यह अक्सर सहायक होता है।

यहां देखिए यह कैसे काम करता है:

जी = "(4 * 5)/4"
डी = eval (जी)
प्रिंट (डी)
आउटपुट: 5.0

5. गोल()

आप गणितीय संक्रिया के परिणाम को एक विशिष्ट संख्या में महत्वपूर्ण अंकों का उपयोग करके गोल कर सकते हैं गोल():

कच्चा_औसत = (4+5+7/3)
गोल_औसत = गोल (कच्चा_औसत, 2)
प्रिंट ("कच्चा औसत है:", raw_average)
प्रिंट ("गोल औसत है:", Rounded_average)
आउटपुट:
कच्चा औसत है: 11.33333333333333334
गोल औसत है: 11.33

6. अधिकतम ()

NS अधिकतम () फ़ंक्शन किसी पुनरावर्तनीय में उच्चतम रैंक वाला आइटम देता है। हालांकि, इसे सबसे अधिक बार होने वाले मान के साथ भ्रमित न करने के लिए सावधान रहें।

आइए नीचे दिए गए शब्दकोश में उच्चतम रैंक वाले मान को प्रिंट करें अधिकतम () समारोह:

बी = {1: "अंगूर", 2: "सेब", 3: "सेब", 4: "ज़ेबरा", 5: "आम"}
प्रिंट (अधिकतम (b.values ​​()))
आउटपुट: ज़ेबरा

ऊपर दिया गया कोड डिक्शनरी में आइटम्स को वर्णानुक्रम में रैंक करता है और अंतिम को प्रिंट करता है।

अब का प्रयोग करें अधिकतम () किसी सूची में सबसे बड़ा पूर्णांक देखने के लिए कार्य करें:

ए = [१, ६५, ७, ९]
प्रिंट (अधिकतम (ए))
आउटपुट: 65

7. मिनट ()

NS मिनट () फंक्शन किसके विपरीत करता है अधिकतम () करता है:

फल = ["अंगूर", "सेब", "सेब रहित", "ज़ेबरा", "आम"]
बी = {1: "अंगूर", 2: "सेब", 3: "सेब", 4: "ज़ेबरा", 5: "आम"}
ए = [१, ६५, ७, ९]
प्रिंट (मिनट (ए))
प्रिंट (न्यूनतम (बी.मान ()))
आउटपुट:
1
सेब

8. नक्शा()

पसंद कम करना(), NS नक्शा() फ़ंक्शन आपको प्रत्येक आइटम पर पुनरावृति में पुनरावृति करने देता है। हालांकि, एक भी परिणाम देने के बजाय, नक्शा() प्रत्येक वस्तु पर स्वतंत्र रूप से कार्य करता है।

अंततः, आप दो या दो से अधिक सूचियों पर गणितीय संक्रियाएँ निष्पादित कर सकते हैं नक्शा() समारोह। आप इसका उपयोग किसी भी डेटा प्रकार वाले सरणी में हेरफेर करने के लिए भी कर सकते हैं।

यहां बताया गया है कि पूर्णांकों वाली दो सूचियों का संयुक्त योग कैसे प्राप्त करें नक्शा() समारोह:

बी = [१, ३, ४, ६]
ए = [१, ६५, ७, ९]
# जोड़ को संभालने के लिए एक अलग फ़ंक्शन घोषित करें:
डीईएफ़ जोड़ें (ए, बी):
वापसी ए+बी
# फ़ंक्शन और दो सूचियों को अंतर्निहित मानचित्र () फ़ंक्शन में पास करें:
ए = योग (मानचित्र (जोड़ें, बी, ए))
प्रिंट (ए) 
आउटपुट: 96

9. गेटअटर ()

अजगर गेटअटर () किसी वस्तु की विशेषता लौटाता है। यह दो मापदंडों को स्वीकार करता है: वर्ग और लक्ष्य विशेषता नाम।

यहाँ एक उदाहरण है:

कक्षा ty:
def __init__ (स्वयं, संख्या, नाम):
स्वयं संख्या = संख्या
स्व.नाम = नाम
a = ty (5*8, "Idowu")
बी = गेटटर (ए, 'नाम')
प्रिंट (बी)
आउटपुट:इडोवु

सम्बंधित:उदाहरण बनाम। स्टेटिक बनाम। पायथन में कक्षा के तरीके: महत्वपूर्ण अंतर

10. संलग्न करें ()

चाहे आप वेब विकास में तल्लीन हों या पायथन के साथ मशीन लर्निंग, संलग्न करें () एक और पायथन विधि है जिसकी आपको अक्सर आवश्यकता होगी। यह अपनी मूल सामग्री को अधिलेखित किए बिना सूची में नया डेटा लिखकर काम करता है।

सम्बंधित:पायथन में एक सूची कैसे जोड़ें

नीचे दिया गया उदाहरण प्रत्येक आइटम को पूर्णांकों की श्रेणी में तीन से गुणा करता है और उन्हें मौजूदा सूची में लिखता है:

अंक = [१, २, ३]
परिशिष्ट सूची = [२, ४]
मेरे लिए संख्या में:
ए = मैं*3
परिशिष्ट सूची। संलग्न करें (ए)
प्रिंट (संलग्न सूची)
आउटपुट:[2, 4, 3, 6, 9]

11. श्रेणी()

आप पहले से ही परिचित हो सकते हैं श्रेणी() पायथन में। यदि आप स्पष्ट रूप से लिखे बिना विशिष्ट संख्याओं के बीच पूर्णांकों की एक सूची बनाना चाहते हैं तो यह आसान है।

आइए इस फ़ंक्शन का उपयोग करके एक और पांच के बीच की विषम संख्याओं की सूची बनाएं:

ए = रेंज (1, 6)
बी = []
मैं के लिए एक में:
अगर मैं% 2!=0:
b.परिशिष्ट (i)
प्रिंट (बी)
आउटपुट: [1, 3, 5]

12. टुकड़ा ()

हालांकि टुकड़ा () फ़ंक्शन और पारंपरिक स्लाइस विधि का उपयोग करके समान आउटपुट देते हैं टुकड़ा () आपके कोड में इसे और अधिक पठनीय बना सकते हैं।

आप किसी भी परिवर्तनशील पुनरावर्तनीय को स्लाइस विधि का उपयोग करके स्लाइस कर सकते हैं:

बी = [१, ३, ४, ६, ७, १०]
सेंट = "पायथन ट्यूटोरियल"
टुकड़ा भाग = टुकड़ा (0, 4)
प्रिंट (बी [स्लाइसपोर्ट])
प्रिंट (सेंट [स्लाइसपोर्ट])
आउटपुट:
[1, 3, 4, 6]
पाइथो

जब आप नीचे दी गई पारंपरिक विधि का उपयोग करते हैं तो उपरोक्त कोड एक समान आउटपुट देता है:

प्रिंट (बी [0:4])
प्रिंट (सेंट [0:4])

13. प्रारूप()

NS प्रारूप() विधि आपको अपने स्ट्रिंग आउटपुट में हेरफेर करने देती है। यहां देखिए यह कैसे काम करता है:

एकाधिक = 5*2
मल्टीपल2 = 7*2
a = "{} 5 और 2 का गुणज है, लेकिन {} 7 और 2 के लिए है"
ए = ए प्रारूप (एकाधिक, एकाधिक 2)
प्रिंट (ए)
आउटपुट:
१०, ५ और २ का गुणज है, लेकिन १४, ७ और २ के लिए है 

14. पट्टी ()

अजगर पट्टी () एक स्ट्रिंग से प्रमुख पात्रों को हटा देता है। यह स्ट्रिंग से पहले वर्ण को बार-बार हटा देता है, अगर यह किसी भी आपूर्ति किए गए वर्ण से मेल खाता है।

यदि आप कोई वर्ण निर्दिष्ट नहीं करते हैं, तो पट्टी सभी प्रमुख रिक्त स्थान वर्णों को स्ट्रिंग से हटा देती है।

नीचे दिया गया उदाहरण कोड अक्षर को हटा देता है पी और स्ट्रिंग से इससे पहले की जगह:

सेंट = "पायथन ट्यूटोरियल"
सेंट = सेंट स्ट्रिप ("पी")
प्रिंट (सेंट)
आउटपुट: योथन ट्यूटोरियल

आप बदल सकते हैं (" पी") साथ ("पी") देखने के लिए क्या होता है।

15. पेट ()

क्या आप नकारात्मक गणितीय आउटपुट को बेअसर करना चाहते हैं? फिर कोशिश करें पेट () समारोह। यह कम्प्यूटेशनल प्रोग्रामिंग या डेटा साइंस ऑपरेशंस में काम आ सकता है।

यह कैसे काम करता है, इसके लिए नीचे दिया गया उदाहरण देखें:

नकारात्मक = 4 - 9
पॉज़ = एब्स (नकारात्मक)
प्रिंट (स्थिति)
आउटपुट: 5

16. ऊपरी ()

जैसा कि नाम का तात्पर्य है, ऊपरी () विधि स्ट्रिंग वर्णों को उनके अपरकेस समकक्ष में परिवर्तित करती है:

y = "पायथन ट्यूटोरियल"
y = y.ऊपरी ()
प्रिंट (वाई)
आउटपुट: पायथन ट्यूटोरियल

17. निचला ()

आपने सही अनुमान लगाया! अजगर निचला () के विपरीत है ऊपरी ()। तो यह स्ट्रिंग वर्णों को लोअरकेस में परिवर्तित करता है:

वाई = "पायथन ट्यूटोरियल"
y = y.लोअर ()
प्रिंट (वाई)
आउटपुट: पायथन ट्यूटोरियल

18. क्रमबद्ध ()

NS क्रमबद्ध () फ़ंक्शन एक पुनरावृत्त से एक सूची बनाकर काम करता है और फिर उसके मूल्यों को अवरोही या आरोही क्रम में व्यवस्थित करता है:

f = {1, 4, 9, 3} # इसे एक सेट पर आज़माएं
Sort = {"G":8, "A":5, "B":9, "F":3} # इसे किसी डिक्शनरी में आज़माएं
प्रिंट (सॉर्ट किया गया (f, रिवर्स = ट्रू)) # अवरोही
प्रिंट (सॉर्ट किया गया (सॉर्ट.वैल्यू ())) # आरोही (डिफ़ॉल्ट)
आउटपुट:
[9, 4, 3, 1]
[3, 5, 8, 9]

19. शामिल हों ()

NS शामिल हों () फ़ंक्शन आपको एक सूची में स्ट्रिंग आइटम मर्ज करने देता है।

इसका उपयोग करने के लिए आपको केवल एक सीमांकक और लक्ष्य सूची निर्दिष्ट करने की आवश्यकता है:

ए = ["पायथन", "ट्यूटोरियल", "ऑन", "एमयूओ"]
ए = ""। शामिल हों (ए)
प्रिंट (ए)
आउटपुट: MUO पर पायथन ट्यूटोरियल

20. बदलने के()

अजगर बदलने के() विधि आपको स्ट्रिंग के कुछ हिस्सों को किसी अन्य वर्ण से बदलने देती है। यह अक्सर डेटा साइंस में काम आता है, खासकर डेटा क्लीनिंग के दौरान।

NS बदलने के() विधि दो मापदंडों को स्वीकार करती है: बदला हुआ वर्ण और वह जिसे आप इसके साथ बदलना चाहते हैं।

यहां देखिए यह कैसे काम करता है:

कॉलम = ["कार्ट_नाम", "फर्स्ट_नाम", "लास्ट_नाम"]
कॉलम में मैं के लिए:
i = i.replace ("_", "")
प्रिंट (i)
आउटपुट:
गाड़ी का नाम
पहला नाम
उपनाम

पायथन की शक्ति पर निर्माण करना सीखते रहें

एक संकलित, उच्च-स्तरीय प्रोग्रामिंग भाषा के रूप में, विशाल सामुदायिक समर्थन के साथ, पायथन कई अतिरिक्त कार्यों, विधियों और मॉड्यूल को प्राप्त करता रहता है। और जब हमने यहां अधिकांश लोकप्रिय लोगों को कवर किया है, तो रेगुलर एक्सप्रेशन जैसी विशेषताओं का अध्ययन कर रहे हैं, और वे अभ्यास में कैसे काम करते हैं, इस पर गहराई से विचार करने से आपको पायथन की गति के साथ बने रहने में मदद मिलेगी क्रमागत उन्नति।

नवोदित प्रोग्रामर के लिए पायथन रेगेक्स चीट शीट

पायथन नियमित अभिव्यक्तियों की इस सूची का उपयोग करें ताकि आप इस बहुमुखी प्रोग्रामिंग भाषा का उपयोग करने में बेहतर हो सकें।

आगे पढ़िए

लेखक के बारे में