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

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

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

1. कम करें ()

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

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

 from functools import reduce
def add_num(a, b):
return a+b
a = [1, 2, 3, 10]
print(reduce(add_num, a))
Output: 16

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

 from functools import reduce
def add_str(a,b):
return a+' '+b
a = ['MUO', 'is', 'a', 'media', 'website']
print(reduce(add_str, a))
Output: MUO is a media website

2. विभाजित ()

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

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

 words = "column1 column2 column3"
words = words.split(" ")
print(words)
Output: ['column1', 'column2', 'column3']

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

3. गणना ()

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

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

यहां बताया गया है कि आप एन्यूमरेट () विधि का उपयोग करके इसे कैसे प्राप्त कर सकते हैं:

 fruits = ["grape", "apple", "mango"]
for i, j in enumerate(fruits):
print(i, j)
Output:
0 grape
1 apple
2 mango

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

 fruits = ["grape", "apple", "mango"]
for i in range(len(fruits)):
print(i, fruits[i])

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

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

 for i, j in enumerate(fruits, start=1):
print(i, j)
Output:
1 grape
2 apple
3 mango

4. eval ()

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

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

 g = "(4 * 5)/4"
d = eval(g)
print(d)
Output: 5.0

5. गोल ()

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

 raw_average = (4+5+7/3)
rounded_average=round(raw_average, 2)
print("The raw average is:", raw_average)
print("The rounded average is:", rounded_average)
Output:
The raw average is: 11.333333333333334
The rounded average is: 11.33

6. अधिकतम ()

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

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

 b = {1:"grape", 2:"apple", 3:"applesss", 4:"zebra", 5:"mango"}
print(max(b.values()))
Output: zebra

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

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

 a = [1, 65, 7, 9]
print(max(a))
Output: 65

7. मिनट ()

न्यूनतम () फ़ंक्शन इसके विपरीत करता है जो अधिकतम () करता है:

 fruits = ["grape", "apple", "applesss", "zebra", "mango"]
b = {1:"grape", 2:"apple", 3:"applesss", 4:"zebra", 5:"mango"}
a = [1, 65, 7, 9]
print(min(a))
print(min(b.values()))
Output:
1
apple

8. नक्शा ()

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

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

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

 b = [1, 3, 4, 6]
a = [1, 65, 7, 9]
# Declare a separate function to handle the addition:
def add(a, b):
return a+b
# Pass the function and the two lists into the built-in map() function:
a = sum(map(add, b, a))
print(a)
Output: 96

9. गेटटर ()

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

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

 class ty:
def __init__(self, number, name):
self.number = number
self.name = name
a = ty(5*8, "Idowu")
b = getattr(a, 'name')
print(b)
Output: Idowu

संबंधित: पायथन में इंस्टेंस बनाम स्टेटिक बनाम क्लास मेथड्स: महत्वपूर्ण अंतर

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

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

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

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

 nums = [1, 2, 3]
appendedlist = [2, 4]
for i in nums:
a = i*3
appendedlist.append(a)
print(appendedlist)
Output: [2, 4, 3, 6, 9]

11. रेंज ()

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

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

 a = range(1, 6)
b = []
for i in a:
if i%2!=0:
b.append(i)
print(b)
Output: [1, 3, 5]

12. टुकड़ा ()

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

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

 b = [1, 3, 4, 6, 7, 10]
st = "Python tutorial"
sliceportion = slice(0, 4)
print(b[sliceportion])
print(st[sliceportion])
Output:
[1, 3, 4, 6]
Pyth

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

 print(b[0:4])
print(st[0:4])

13. प्रारूप ()

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

 multiple = 5*2
multiple2 = 7*2
a = "{} is the multiple of 5 and 2, but {} is for 7 and 2"
a = a.format(multiple, multiple2)
print(a)
Output:
10 is the multiple of 5 and 2, but 14 is for 7 and 2

14. पट्टी ()

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

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

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

 st = " Python tutorial"
st = st.strip(" P")
print(st)
Output: ython tutorial

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

15. पेट ()

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

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

 neg = 4 - 9
pos = abs(neg)
print(pos)
Output: 5

16. ऊपरी ()

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

 y = "Python tutorial"
y = y.upper()
print(y)
Output: PYTHON TUTORIAL

17. निचला ()

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

 y = "PYTHON TUTORIAL"
y = y.lower()
print(y)
Output: python tutorial

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

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

 f = {1, 4, 9, 3} # Try it on a set
sort = {"G":8, "A":5, "B":9, "F":3} # Try it on a dictionary
print(sorted(f, reverse=True)) # Descending
print(sorted(sort.values())) # Ascending (default)
Output:
[9, 4, 3, 1]
[3, 5, 8, 9]

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

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

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

 a = ["Python", "tutorial", "on", "MUO"]
a = " ".join(a)
print(a)
Output: Python tutorial on MUO

20. बदलें ()

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

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

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

 columns = ["Cart_name", "First_name", "Last_name"]
for i in columns:
i = i.replace("_", " ")
print(i)
Output:
Cart name
First name
Last name

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

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