पायथन दिलचस्प और उपयोगी

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

जैसा कि अजगर में कई भाषाओं में, 1 सच के बराबर है, और 0 झूठी है, अर्थात।

1 == True. 

यह प्रतीत होता है, और इसमें क्या गलत है? हालाँकि, इसके कुछ साइड इफेक्ट्स हैं जो इस तथ्य से जुड़े हैं कि एक ही ऑब्जेक्ट में एक ही हैश होना चाहिए, इसलिए आप कुंजी 1 और ट्रू को एक शब्दकोष में रटना नहीं कर पाएंगे।

  >>> a = {1: "one", 0: "zero", True: "true", False: "false"} # -> {1: 'true', 0: 'false'} 

यह निम्नलिखित कार्यों की भी अनुमति देता है:

  >>> print(2 * False + True) # -> 1 

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

  >>> {"one": 1, "two": 2, "three": 3} == dict(one=1, two=2, three=3) # -> True 

इसके अलावा, न केवल शब्दकोशों, बल्कि सेट (सेट) घुंघराले ब्रेसिज़ का उपयोग करके बनाई गई हैं।

  >>> a = {1, 2, 3} 

दो सेटों को संयोजित करने के लिए, किसी कारण से मैं + ऑपरेटर का उपयोग करना चाहता हूं, शायद जिस तरह से तारों को समतल किया जाता है। हालाँकि, अजगर सेट के लिए इस ऑपरेटर का समर्थन नहीं करता है। लेकिन निश्चित रूप से, इसका मतलब यह नहीं है कि हमें हमेशा कार्यों का उपयोग करना पड़ता है, रचनाकारों ने इस मुद्दे को अधिक व्यवस्थित और सेट पर बुनियादी संचालन के लिए समर्थन (न केवल यूनियनों) के लिए भाषा में जोड़ा और तार्किक ऑपरेटरों पर "लटका" दिया ।

 a = {1, 2, 3} b = {0, 2, 4} print(a & b) # -> {2} print(a | b) # -> {0, 1, 2, 3, 4} print(a ^ b) # -> {0, 1, 3, 4} print(a - b) # -> {1, 3},    #     

शब्दकोशों के बारे में बातचीत जारी रखना, संस्करण 3.7 से शुरू करना, भाषा विनिर्देश सुनिश्चित करता है कि शब्दकोशों तत्वों के सम्मिलन क्रम को बनाए रखता है, ऑर्डरडीड को अब ज़रूरत नहीं है।

www.python.org/downloads/release/python-370
mail.python.org/pipermail/python-dev/2017-December/151283.html

 d = dict(zero='Cero', one='Uno', two='Dos', three='Tres', four='Cuatro', five='Cinco', six='Seis', seven='Siete', eight='Ocho', night='Nueve') for index, (key, value) in enumerate(d.items()): print(f"{index} is {key} in England and {value} in Spain") 

आउटपुट लाइन पर ध्यान दें, यह उपसर्ग f के साथ शुरू होता है - यह एक विशेष प्रकार की लाइनें है जो अजगर 3.6 में पेश की गई हैं।

भाषा में तीन प्रकार के तार होते हैं: नियमित, उपसर्गों के बिना इंगित किए गए संकेत, कच्ची \ _ संसाधित नहीं (कच्ची), जिसमें विशेष वर्ण, जैसे \ n, संसाधित नहीं होते हैं और पाठ और एफ-लाइनों के रूप में सम्मिलित होते हैं।

वे उत्पादन को सरल बनाने के लिए बनाए गए थे, अजगर उत्पादन विधियों की एक बड़ी संख्या का समर्थन करता है:

 print("result" + str(2)) #   , python   #      #  ,     print("result", 2) # print      , #        , #        , #      print("result %d" % 2) # %-,      C. print("result %d %.2f" % (2, 2)) # https://docs.python.org/3.4/library/string.html#formatspec print("result %(name)s" % {"name": 2}) #      print("{}".format(2)) #      format() #       print("{0} {1} {0}".format(1, 2)) #          #     #     #        ,    print("{} {}".format(2)) # -> IndexError: tuple index out of range print("{0} {0}".format(2, 3)) # -> 2 2       #     from math import pi #         print("{:.2f}".format(pi)) # -> 3.14 from string import Template #      s = Template("result $res") #       print(s.substitute(res = [3, 4])) 

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

 from math import pi result = 4 name = "user" print(f"{name:84s} pi= {pi:.2f}, result={result}, {name[2]}") # -> user pi= 3.14, result=4, e from datetime import datetime print(f"{datetime.now():%Y:%m-%d}") 

वे अन्य सभी आउटपुट विधियों की तुलना में तेज़ हैं, इसलिए यदि python3.6 आपके लिए उपलब्ध है, तो यह अनुशंसा की जाती है कि आप उनका उपयोग करें।

अजगर के सबसे अच्छे टुकड़ों में से एक - इसमें ऑब्जेक्ट्स और प्राइमिटिव्स पैक और अनपैक्ड नहीं हैं, लेकिन पैरामीटर और संग्रह हैं।

 def func(*argv, **kwargs) 

हालांकि, कार्यान्वयन में एक वास्तु दोष है:

• argv - एक ट्यूपल, इसके मूल्यों को नहीं बदला जा सकता है, मूल्यों को जोड़ा या हटाया नहीं जा सकता है
• kwargs एक शब्दकोश उत्परिवर्ती है, इसलिए कैशिंग संभव नहीं है

कमी, बड़ी नहीं है, लेकिन यह अभी भी अप्रिय है कि आप सीधे शब्दकोश-आधारित कैश में kwargs को स्थानांतरित नहीं कर सकते हैं, दूसरी तरफ, यदि आप एक सूची को ट्यूपल में जोड़ते हैं, तो इस तरह के एक ट्यूपल को शब्दकोश में भी नहीं जोड़ा जा सकता है।

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

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

किसने, अपने छात्र के स्कूल के वर्षों में, एक सरणी के मूल्यों को प्रदर्शित करने के लिए चक्र लिखे और अंत में अल्पविराम के बारे में गुस्से में थे, हर बार उन्होंने फैसला किया कि क्या इसे सुंदर बनाने के लिए स्कोर करना है या फिर से लिखना है, और केवल 2-3 पाठ्यक्रम में उन्होंने शामिल होने के तरीके के बारे में सीखा? या मैं ही एक हूँ?

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

 a = list(range(5)) print(" ".join(a)) # -> TypeError: sequence item 0: expected str instance, int found print(" ".join(str(i) for i in a)) # -> 0 1 2 3 4 print(*a) # -> 0 1 2 3 4 

चूंकि स्ट्रिंग्स भी संग्रह हैं, इसलिए उन्हें "जॉइन" भी किया जा सकता है।

 print('-'.join("hello")) # -> hello 

पिछले उदाहरण से लाइन पर विचार करें।

 print(" ".join(str(i) for i in a)) # -> 0 1 2 3 4 

जनरेटर की अभिव्यक्ति को किसी भी कोष्ठक के बिना शामिल होने के समारोह में पारित किया जाता है; कोड पढ़ने को आसान बनाने के लिए कोष्ठक को छोड़ा जा सकता है। अजगर अभिव्यक्ति की देखभाल करता है।

 print(sum(i**2 for i in range(10))) # -> 285 

इसके अलावा, टुपल्स बनाते समय कोष्ठकों को छोड़ा जा सकता है:

 article = "python", 2018, "LinearLeopard" #   theme, year, author = "python", 2018, "LinearLeopard"#   theme, year, _ = "python", 2018, "LinearLeopard" #     #    # ,  , #  -   , #    #  theme, _, _ = "python", 2018, "LinearLeopard" #    theme, *, author = "python", 2018, "LinearLeopard" #    # ,   #  , # ,  #   #   

तारांकन का उपयोग फ़ंक्शन घोषणाओं में भी किया जा सकता है, इसलिए आप ऐसे पैरामीटर बना सकते हैं जो केवल कुंजी द्वारा निर्दिष्ट किए जा सकते हैं।

 def sortwords(*wordlist, case_sensitive=False): 

आप बिना किसी डर के जितने चाहें उतने पैरामीटर पास कर सकते हैं कि उनमें से एक को case_sensitive पैरामीटर के मान के रूप में माना जाएगा।

यह संभव है और ऐसा है।

 def func(first, second, *, kwonly): 

हम इस बात पर करीब से नज़र डालेंगे कि यह कैसे * * से भिन्न होता है।

 def func(first, second, *, kwonly=True): print(first, second, kwonly) def func2(first, second, *args, kwonly=True): print(first, second, *args, kwonly) func(1) #-> TypeError: func() missing 1 required positional argument: 'second' func(1, 2) #-> 1 2 True func(1, 2, False) #-> TypeError: func() takes 2 positional arguments but 3 were given #  *    ,  #        #   func(1, 2, kwonly=False) #-> 1 2 False func2(1, 2, False) #-> 1 2 False True # *args      # ,       #    (>2)  #  

एक दिलचस्प विशेषता डिफ़ॉल्ट मापदंडों के साथ जुड़ा हुआ है: उन्हें मॉड्यूल के संकलन के चरण में बाईटेकोड में गणना की जाती है, इसलिए बेहतर है कि वहां उत्परिवर्तित प्रकारों का उपयोग न करें। हम एक फ़ंक्शन की घोषणा करते हैं जो सूची के अंत में एक तत्व जोड़ता है, यदि दूसरा तर्क छोड़ दिया जाता है, तो फ़ंक्शन केवल इस तत्व से युक्त एक नई सूची लौटाता है।

 def add_to(elem, collection=[]): collection.append(elem) return collection a = ["a", "c"] print(add_to("b", a)) # -> ['a', 'c', 'b'] print(add_to("a")) # -> ['a'] print(add_to("b")) # -> ['a', 'b']   'a'? 

डिफ़ॉल्ट मान __defaults__ फ़ील्ड में संग्रहीत हैं, आप यह पता लगा सकते हैं कि किसी भी समय क्या है।

 print(add_to.__defaults__) # -> (['a', 'b'],) 

चूंकि प्रोग्राम शुरू होने के समय डिफ़ॉल्ट डिफॉल्ट (एक खाली सूची) बनाई गई थी और प्रत्येक बार फिर से बनाई नहीं गई थी, हमें बिल्कुल यही व्यवहार मिला।

यदि आप डिफ़ॉल्ट मान को अपरिवर्तनीय प्रकार बनाते हैं, और फ़ंक्शन के मुख्य भाग में एक सूची बनाते हैं, तो आप इस व्यवहार को ठीक कर सकते हैं:

 def add_to(elem, collection=None): collection = collection or [] collection.append(elem) return collection 

आज्ञा पर ध्यान दो

 collection = collection or [] 

यह एक छोटा (और कम स्पष्ट, हालांकि सभी के लिए नहीं) एनालॉग है

 collection = collection if collection else [] 

अगले भाग का लिंक