PEP-8 ट्यूटोरियल: Python में कोड मानक

इस शुरुआती ट्यूटोरियल के साथ, आप PEP-8—Python की स्टाइल गाइड—को तलाशना शुरू करेंगे ताकि आप अपने कोड को सही ढंग से फ़ॉर्मैट कर सकें और उसकी पठनीयता अधिकतम कर सकें!

Chitrank Dixit

अपडेट किया गया 6 अक्टू॰ 2026 · 15 मि॰ पढ़ें

AI के साथ खोजें

ChatGPT Claude Perplexity

अपना निःशुल्क खाता बनाएँ

अभ्यास और ट्रैक अपनी प्रगति को।

Google के साथ जारी रखें

जारी रखने पर, आप हमारी उपयोग की शर्तें, हमारी गोपनीयता नीति को स्वीकार करते हैं और यह भी कि आपका डेटा संयुक्त राज्य अमेरिका में संग्रहीत किया जाता है।

PEP-8 या Python Enhancement Proposal आपके कोड को अधिक सुव्यवस्थित और पठनीय बनाने के लिए कुछ प्रमुख बिंदु प्रस्तुत करता है। जैसा कि Python के निर्माता Guido Van Rossum कहते हैं:

कोड को जितनी बार लिखा जाता है, उससे कहीं अधिक बार पढ़ा जाता है।

इस पोस्ट में, आप कुछ कोड उदाहरणों के साथ PEP-8 को तलाशना शुरू करेंगे! आप निम्नलिखित विषयों को कवर करेंगे:

सबसे पहले, आप PEP-8 से परिचित होंगे—यह क्या है और आपको इसकी आवश्यकता क्यों है;
अगला, आप इंडेंटेशन पर बात करेंगे, जो प्रोग्रामरों के बीच एक गर्म विषय है। क्या आपको टैब्स का उपयोग करना चाहिए या स्पेसेज़? आप इस खंड में उत्तर जानेंगे;
शायद आप उम्मीद न करें, लेकिन अधिकतम पंक्ति लंबाई के लिए भी दिशानिर्देश हैं;
साथ ही, खाली पंक्तियों को संभालने का एक प्रस्तावित तरीका भी है;
अगला, एक्सप्रेशंस और स्टेटमेंट्स में व्हाइटस्पेसेज़ ऐसी चीज़ है जिसे आप एक शुरुआती के रूप में भी आसानी से संभाल सकते हैं;
एन्कोडिंग क्या है और Python के साथ काम करते समय इसकी आवश्यकता क्यों पड़ती है? Python3 की डिफ़ॉल्ट एन्कोडिंग क्या है? सोर्स फ़ाइल एन्कोडिंग सेक्शन इन सब पर चर्चा करेगा।
आप संभवतः कोडिंग करते समय अक्सर इम्पोर्ट्स करते हैं। यह खंड आपके इम्पोर्ट्स का क्रम, एब्सोल्यूट और रिलेटिव इम्पोर्ट्स, वाइल्डकार्ड इम्पोर्ट्स आदि जैसे विषयों पर चर्चा करेगा;
दस्तावेज़ीकरण किसी एप्लिकेशन के सभी पहलुओं का हिसाब रखने और अंतिम उत्पाद की समग्र गुणवत्ता सुधारने के लिए आवश्यक है। यहाँ कमेंट्स बेहद महत्वपूर्ण हैं!
क्या आप मॉड्यूल-स्तरीय डंडर नाम जानते हैं? ये विशेष रूप से डॉकस्ट्रिंग्स में सहायक होते हैं!
अंत में, आप नामकरण परंपराओं के बारे में और जानेंगे: आप फ़ंक्शन नाम कैसे तय कर सकते हैं, आम तौर पर किस प्रकार की नामकरण शैली का उपयोग करेंगे, और बहुत कुछ;
क्या आपका कोड PEP-8 के अनुरूप है? यह निश्चित रूप से एक सवाल है जो आपको खुद से पूछना चाहिए। इसलिए आखिरी खंड कुछ ऐसे टूल्स को कवर करता है जो आपको यह जाँचने में मदद करेंगे कि आपका कोड इस पोस्ट में प्रस्तुत दिशानिर्देशों (और कई और जिन्हें यहाँ कवर नहीं किया गया) का पालन करता है या नहीं!

PEP-8 का परिचय

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

हालाँकि, आप Python के लाभों का उपयोग तभी कर सकते हैं जब आप अपने विचारों को अपने कोड से बेहतर तरीके से व्यक्त करना जानते हों। Python कुछ लक्ष्यों को ध्यान में रखकर बनाया गया था, जिन्हें आप import this टाइप करने पर देख सकते हैं।

import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

उपर्युक्त वे 20 सिद्धांत हैं जिनका Python प्रोग्रामिंग में उपयोग होता है, जिन्हें Zen of Python के नाम से जाना जाता है। आउटपुट में आप "Readability Counts" भी देखते हैं, जो कोड लिखते समय आपका मुख्य ध्यान होना चाहिए: अन्य प्रोग्रामर या डेटा वैज्ञानिक आपके कोड को समझें और उसमें योगदान दे सकें ताकि वह वर्तमान कार्य को हल कर सके।

आगे के खंड आपको बताएँगे कि आप यह सब कैसे हासिल कर सकते हैं!

इंडेंटेशन

Python में प्रोग्रामिंग करते समय इंडेंटेशन का उपयोग आप निश्चित रूप से करेंगे। हालाँकि, आपको इसके साथ सावधानी बरतनी चाहिए, क्योंकि यह सिंटैक्स एरर्स का कारण बन सकता है। इसलिए सिफारिश है कि इंडेंटेशन के लिए चार स्पेस का उपयोग करें। उदाहरण के लिए, यह स्टेटमेंट चार स्पेस का इंडेंटेशन उपयोग करता है:

if True:
    print("If works")

और यह for लूप भी print स्टेटमेंट के साथ चार स्पेस से इंडेंट किया गया है:

for element in range(0, 5):
    print(element)

जब आप एक बड़ा एक्सप्रेशन लिखते हैं, तो सबसे अच्छा है कि एक्सप्रेशन को वर्टिकली अलाइन रखें। ऐसा करने पर आप एक "हैंगिंग इंडेंट" बनाएँगे।

यहाँ बड़े एक्सप्रेशंस में हैंगिंग इंडेंट के कुछ उदाहरण हैं, जो दिखाते हैं कि आप इसे कैसे अलग-अलग तरीकों से उपयोग कर सकते हैं:

value = square_of_numbers(num1, num2,
                       num3, num4)

def square_of_number(
     num1, num2, num3, 
     num4):
 return num1**2, num2**2, num3**2, num4**2

value = square_of_numbers(
              num1, num2,
              num3, num4)

list_of_people = [
 "Rama",
 "John",
 "Shiva"
]

dict_of_people_ages = {
 "ram": 25,
 "john": 29,
 "shiva": 26
}

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

आम तौर पर, स्पेसेज़ को प्राथमिकता दी जाती है, लेकिन यदि आपको कुछ Python स्क्रिप्ट्स पहले से टैब्स का उपयोग करते हुए मिलती हैं, तो आपको टैब्स के साथ ही इंडेंटेशन जारी रखना चाहिए। अन्यथा, आपको अपनी स्क्रिप्ट में सभी एक्सप्रेशंस का इंडेंटेशन स्पेसेज़ में बदल देना चाहिए।

ध्यान दें कि Python 3 इंडेंटेशन के लिए टैब्स और स्पेसेज़ का मिश्रण अनुमति नहीं देता। इसलिए आपको दोनों में से एक चुनना चाहिए और उसी पर टिके रहना चाहिए!

अधिकतम पंक्ति लंबाई

आम तौर पर, अपने Python कोड में 79 अक्षरों की पंक्ति लंबाई का लक्ष्य रखना अच्छा है।

इस लक्ष्य संख्या का पालन करने के कई फायदे हैं। उनमें से कुछ इस प्रकार हैं:

फ़ाइलों को साथ-साथ खोलकर तुलना करना संभव होता है;
आप बिना क्षैतिज स्क्रॉलिंग के पूरा एक्सप्रेशन देख सकते हैं, जिससे पठनीयता और कोड की समझ बढ़ती है।

कमेंट्स के लिए पंक्ति लंबाई 72 अक्षर होनी चाहिए। आप इस ट्यूटोरियल में आगे कमेंट्स के लिए सबसे आम परंपराओं के बारे में और जानेंगे!

अंत में, यदि आप एक छोटे समूह में काम कर रहे हैं, तो कौन-सी कोडिंग परंपराएँ और शैली आप अपनाते हैं यह आप पर निर्भर है, और अधिकतम पंक्ति लंबाई के दिशानिर्देश से भटकना अधिकांश डेवलपर्स के लिए स्वीकार्य हो सकता है। हालाँकि, यदि आप किसी ओपन-सोर्स प्रोजेक्ट में योगदान दे रहे हैं, तो आप शायद PEP-8 द्वारा निर्धारित अधिकतम पंक्ति लंबाई नियम का पालन करना चाहेंगे और/या करना पड़ेगा।

+ ऑपरेटर का उपयोग करते समय, बेहतर है कि आप उचित लाइन ब्रेक लगाएँ, जिससे आपका कोड समझना आसान हो जाता है:

आपको यह उपयोग करना चाहिए…	आपको इससे बचना चाहिए…
`total = (A + B + C)`	`total = (A + B + C)`

वैकल्पिक रूप से, आप ऐसे भी लिख सकते हैं:

total = A
        + B
        + C

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

खाली पंक्तियाँ

Python स्क्रिप्ट्स में, शीर्ष-स्तरीय फ़ंक्शंस और क्लासेस को दो खाली पंक्तियों से अलग किया जाता है। क्लासेस के अंदर मेथड परिभाषाएँ एक खाली पंक्ति से अलग होनी चाहिए। आप इसे निम्न उदाहरण में स्पष्ट रूप से देख सकते हैं:

import unittest

class SwapTestSuite(unittest.TestCase):
    """
        Swap Operation Test Case
    """
    def setUp(self):
        self.a = 1
        self.b = 2

    def test_swap_operations(self):
        instance = Swap(self.a,self.b)
        value1, value2 =instance.get_swap_values()
        self.assertEqual(self.a, value2)
        self.assertEqual(self.b, value1)


class OddOrEvenTestSuite(unittest.TestCase):
    """
        This is the Odd or Even Test case Suite
    """
    def setUp(self):
        self.value1 = 1
        self.value2 = 2

    def test_odd_even_operations(self):
        instance1 = OddOrEven(self.value1)
        instance2 = OddOrEven(self.value2)
        message1 = instance1.get_odd_or_even()
        message2 = instance2.get_odd_or_even()
        self.assertEqual(message1, 'Odd')
        self.assertEqual(message2, 'Even')

SwapTestSuite और OddOrEvenTestSuite क्लासेस दो खाली पंक्तियों से अलग हैं, जबकि .setUp() और .test_swap_operations() जैसी मेथड परिभाषाएँ केवल एक खाली पंक्ति से अलग हैं। कोड सफलतापूर्वक चलेगा, लेकिन कोई आउटपुट उत्पन्न नहीं करेगा क्योंकि यूनिट टेस्ट चलाने के लिए आवश्यक कोड गायब है (यह सिर्फ सर्वश्रेष्ठ प्रथाएँ दिखा रहा है)।

एक्सप्रेशंस और स्टेटमेंट्स में व्हाइटस्पेसेज़

आपको व्हाइटस्पेसेज़ से बचने की कोशिश करनी चाहिए जब आपका कोड निम्न उदाहरणों जैसा दिखे:

आपको यह उपयोग करना चाहिए…	आपको इससे बचना चाहिए…
`func(data, {pivot: 4})`	`func( data, { pivot: 4 } )`
`indexes = (0,)`	`indexes = (0, )`
`if x == 4: print x, y; x, y = y, x`	`if x == 4 : print x , y ; x , y = y , x`
`spam(1)`	`spam (1)`
`dct['key'] = lst[index]`	`dct ['key'] = lst [index]`
`x = 1 y = 2 long_variable = 3`	`x = 1 y = 2 long_variable = 3`
`ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:] ham[lower:upper], ham[lower:upper:], ham[lower::step] ham[lower+offset : upper+offset] ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)] ham[lower + offset : upper + offset]`	`ham[lower + offset:upper + offset] ham[1: 9], ham[1 :9], ham[1:9 :3] ham[lower : : upper] ham[ : upper]`
`i = i + 1 submitted += 1 x = x2 - 1 hypot2 = xx + yy c = (a+b) (a-b)`	`i=i+1 submitted +=1 x = x 2 - 1 hypot2 = x x + y y c = (a + b) (a - b)`
`def complex(real, imag=0.0): return magic(r=real, i=imag)`	`def complex(real, imag = 0.0): return magic(r = real, i = imag)`
`def munge(input: AnyStr): ... def munge() -> AnyStr: ...`	`def munge(input:AnyStr): ... def munge()->PosInt: ...`
`def munge(sep: AnyStr = None): ... def munge(input: AnyStr, sep: AnyStr = None, limit=1000): ...`	`def munge(input: AnyStr=None): ... def munge(input: AnyStr, limit = 1000): ...`
`if foo == 'blah': do_blah_thing() do_one() do_two() do_three()`	`if foo == 'blah': do_blah_thing() do_one(); do_two(); do_three()` या `if foo == 'blah': do_blah_thing() for x in lst: total += x while t < 10: t = delay()` या `if foo == 'blah': do_blah_thing() else: do_non_blah_thing() try: something() finally: cleanup() do_one(); do_two(); do_three(long, argument,list, like, this) if foo == 'blah': one(); two(); three()`
`FILES = ('setup.cfg',)`	`FILES = 'setup.cfg',`
`FILES = [ 'setup.cfg', 'tox.ini', ] initialize(FILES, error=True, )`	`FILES = ['setup.cfg', 'tox.ini',] initialize(FILES, error=True,)`

ये उदाहरण PEP-8 से लिए गए हैं।

सोर्स फ़ाइल एन्कोडिंग

कंप्यूटर "अक्षर", "संख्याएँ", "चित्र" या कुछ भी और संग्रहीत नहीं कर सकता; यह केवल बिट्स को संग्रहीत कर सकता है और उनके साथ काम कर सकता है, जिनके केवल द्विआधारी मान हो सकते हैं: yes या no, true या false, 1 या 0 आदि। जैसा कि आप जानते हैं, कंप्यूटर बिजली के साथ काम करता है; इसका मतलब है कि एक "वास्तविक" बिट बिजली की एक झिलमिल का होना या न होना है। आप आम तौर पर इस उपस्थिति (या अनुपस्थिति) को 1 और 0 से दर्शाते हैं।

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

American Standard Code for Information Interchange (ASCII) कंप्यूटरों और इंटरनेट पर टेक्स्ट फ़ाइलों के लिए सबसे आम फ़ॉर्मेट है। इस प्रकार की फ़ाइलों में, प्रत्येक वर्णमाला, संख्यात्मक या विशेष अक्षर को 7-बिट बाइनरी संख्या (सात 0 या 1 की स्ट्रिंग) से दर्शाया जाता है।
Unicode Worldwide Character Standard, संक्षेप में Unicode, "आधुनिक विश्व की विविध भाषाओं के लिखित पाठों के आदान-प्रदान, प्रोसेसिंग और प्रदर्शन" के लिए एक प्रणाली है। संक्षेप में, Unicode दुनिया की सभी ज्ञात लेखन प्रणालियों को समायोजित करने के लिए डिज़ाइन किया गया है। Unicode वर्तमान में Unicode कैरेक्टर सेट्स को दर्शाने के लिए तीन अलग-अलग एन्कोडिंग का उपयोग करता है: UTF-8, UTF-16 और UTF-32।
- UTF-16 एक वैरिएबल-लेंथ Unicode एन्कोडिंग है: कोड पॉइंट्स को एक या दो 16-बिट कोड यूनिट्स से एन्कोड किया जाता है।
- UTF-8 एक अन्य प्रकार की Unicode वैरिएबल-लेंथ एन्कोडिंग है, जो एक से चार 8-बिट बाइट्स का उपयोग करती है।
- UTF-32 एक फिक्स्ड-लेंथ एन्कोडिंग है जो प्रति Unicode कोड पॉइंट ठीक 32 बिट्स का उपयोग करती है।

टिप: यदि आप एन्कोडिंग के बारे में अधिक जानना चाहते हैं, तो यह पोस्ट देखें।

अब, यह महत्वपूर्ण क्यों है?

आपने पाया होगा कि स्ट्रिंग्स Python में सबसे अधिक उपयोग किए जाने वाले डेटा प्रकारों में से हैं। जैसा कि आप उम्मीद कर सकते हैं, ऐसा समय आएगा जब आप ऐसी स्ट्रिंग्स के साथ काम करना चाहेंगे जिनमें ऐसे अक्षर हों या जो पूरी तरह से ऐसे अक्षरों से बनी हों जो मानक ASCII सेट का हिस्सा नहीं हैं। आखिरकार, ऐसा हो सकता है कि आपको ऐसे टेक्स्ट्स के साथ काम करना पड़े जिनमें उच्चारित अक्षर हों, जैसे á, ž, ç आदि।

अब, Python 3 में UTF-8 डिफ़ॉल्ट सोर्स एन्कोडिंग है। लेकिन, जो लोग Python 2 का उपयोग करते हैं, वे शायद पहले से जानते होंगे कि वहाँ डिफ़ॉल्ट ASCII है।

लेकिन यदि आपके पास कोई स्ट्रिंग है जिसमें कोई non-ASCII अक्षर है, जैसे "Flügel", तो क्या होगा?

जब आप Python 2 में उस स्ट्रिंग को संदर्भित करते हैं, तो आपको निम्न आउटपुट मिलेगा:

>>> s 
'Fl\xfcgel'

यह आपकी स्ट्रिंग जैसा नहीं दिखता! जब आप इसे प्रिंट करते हैं तो क्या होता है?

>>> print(s)
Flügel

प्रिंट करने पर आपको वही मान मिला जो आपने वेरिएबल को असाइन किया था। non-ASCII अक्षर ÃŒ एन्कोड किया गया था। इसलिए जब आपने स्ट्रिंग को संदर्भित किया तो आपको \xfc मिला। इसे संभालने के लिए, आप स्ट्रिंग मेथड्स .encode() और .decode() का उपयोग कर सकते हैं। पहला अनुरोधित एन्कोडिंग में Unicode स्ट्रिंग का 8-बिट स्ट्रिंग संस्करण लौटाता है, जबकि दूसरा दी गई एन्कोडिंग का उपयोग करके स्ट्रिंग की व्याख्या करता है।

इम्पोर्ट्स

लाइब्रेरीज़ और/या मॉड्यूल्स को इम्पोर्ट करना वह काम है जो आप डेटा साइंस के लिए Python के साथ काम करते समय अक्सर करेंगे। जैसा कि आप पहले से जानते होंगे, आपको हमेशा अपने स्क्रिप्ट की शुरुआत में लाइब्रेरीज़ इम्पोर्ट करनी चाहिए।

ध्यान दें कि यदि आप कई इम्पोर्ट्स करते हैं, तो सुनिश्चित करें कि प्रत्येक इम्पोर्ट को एक अलग पंक्ति पर लिखें।

इसे थोड़ा बेहतर समझने के लिए निम्न तालिका देखें:

आपको यह उपयोग करना चाहिए… आपको इससे बचना चाहिए…

आपको यह उपयोग करना चाहिए…	आपको इससे बचना चाहिए…
`from config import settings` या `import os import sys`	`import os, sys`

from config import settings

या

import os import sys

import os, sys

इसके अतिरिक्त, आपको ध्यान रखना चाहिए कि लाइब्रेरीज़ इम्पोर्ट करते समय एक क्रम होता है जिसका सम्मान करना चाहिए। सामान्यतः, आप इस क्रम का पालन कर सकते हैं:

स्टैंडर्ड लाइब्रेरी इम्पोर्ट्स।
संबंधित थर्ड-पार्टी इम्पोर्ट्स।
लोकल एप्लिकेशन/लाइब्रेरी-विशिष्ट इम्पोर्ट्स।

एब्सोल्यूट और रिलेटिव इम्पोर्ट्स

अगला, एब्सोल्यूट और रिलेटिव इम्पोर्ट्स के बीच का अंतर जानना अच्छा है। सामान्यतः, Python में एब्सोल्यूट इम्पोर्ट्स को प्राथमिकता दी जाती है, क्योंकि वे पठनीयता बढ़ाते हैं। हालाँकि, जैसे-जैसे आपका एप्लिकेशन अधिक जटिल होता जाता है, आप रिलेटिव इम्पोर्ट्स का भी उपयोग कर सकते हैं। इम्प्लिसिट रिलेटिव इम्पोर्ट्स का कभी उपयोग नहीं करना चाहिए और उन्हें Python 3 में हटा दिया गया है।

लेकिन ये एब्सोल्यूट और रिलेटिव इम्पोर्ट्स हैं क्या?

एब्सोल्यूट इम्पोर्ट वह इम्पोर्ट है जो फ़ंक्शन या क्लास के एब्सोल्यूट पाथ का उपयोग करता है, जिसे . से अलग किया जाता है। उदाहरण के लिए,
```
  import sklearn.linear_model.LogisticRegression
```
रिलेटिव इम्पोर्ट वह इम्पोर्ट है जो उस वर्तमान स्थान के सापेक्ष होता है जहाँ आपकी Python फ़ाइल मौजूद है। यदि आपका प्रोजेक्ट स्ट्रक्चर बड़ा हो रहा है, तो आप इस प्रकार के इम्पोर्ट का उपयोग कर सकते हैं, क्योंकि यह आपके प्रोजेक्ट को अधिक पठनीय बनाएगा। इसका अर्थ है कि यदि आपका Python प्रोजेक्ट स्ट्रक्चर निम्न जैसा है:
```
  .
  ├── __init__.py
  ├── __init__.pyc
  ├── __pycache__
  │   ├── __init__.cpython-35.pyc
  │   ├── bubble_sort.cpython-35.pyc
  │   ├── selection_sort.cpython-35.pyc
  ├── bubble_sort.py
  ├── heap_sort.py
  ├── insertion_sort.py
  ├── insertion_sort.pyc
  ├── merge_sort.py
  ├── merge_sort.pyc
  ├── quick_sort.py
  ├── radix_sort.py
  ├── selection_sort.py
  ├── selection_sort.pyc
  ├── shell_sort.py
  ├── tests
  │   ├── test1.py
```

आप test1 में bubble_sort.py में संग्रहीत बबल सॉर्ट एल्गोरिदम BubbleSort को इम्पोर्ट करने के लिए रिलेटिव इम्पोर्ट का उपयोग कर सकते हैं। यह इस प्रकार दिखेगा:

from ..bubble_sort import BubbleSort

यदि आप एब्सोल्यूट और रिलेटिव इम्पोर्ट्स के बारे में अधिक जानना चाहते हैं, तो PEP 328 देखें।

वाइल्डकार्ड इम्पोर्ट्स

अंत में, आपको वाइल्डकार्ड इम्पोर्ट्स से बचने की कोशिश करनी चाहिए, क्योंकि वे पठनीयता नहीं बढ़ाते; आपको यह पता नहीं रहता कि आप अपने मॉड्यूल से कौन-सी क्लासेस, मेथड्स या वेरिएबल्स उपयोग कर रहे हैं, उदाहरण के लिए:

from scikit import *

कमेंट्स

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

कमेंट्स # प्रतीक से शुरू होते हैं। हैशटैग के बाद लिखा कुछ भी इंटरप्रेटर द्वारा निष्पादित नहीं होता। उदाहरण के लिए, निम्न कोड खंड केवल "This is a Python comment" लौटाएगा।

# This is a Python single line comment
print("This is a Python comment")

याद रखें: पिछले खंड में आपने पढ़ा कि कमेंट्स की पंक्ति लंबाई 72 अक्षर होनी चाहिए!

यह कहा जाए तो, कमेंट्स के तीन प्रकार होते हैं:

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

निम्न अंश देखें, जो scikit-learn लाइब्रेरी से लिया गया है, ताकि आप समझ सकें कि ये कमेंट्स कैसे दिखते हैं:

   if Gram is None or Gram is False:
        Gram = None
        if copy_X:
            # force copy. setting the array to be fortran-ordered
            # speeds up the calculation of the (partial) Gram matrix
            # and allows to easily swap columns
            X = X.copy('F')

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

उदाहरण के लिए:

counter = 0  # initialize the counter

आप डॉक्यूमेंटेशन स्ट्रिंग्स या डॉकस्ट्रिंग्स पब्लिक मॉड्यूल्स, फ़ाइलों, क्लासेस और मेथड्स की शुरुआत में लिखते हैं। इस प्रकार के कमेंट्स """ से शुरू होते हैं और """ पर समाप्त होते हैं:

    """
        This module is intended to provide functions for scientific computing 
    """

मॉड्यूल-स्तरीय डंडर नाम

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

__all__, __author__, __version__ जैसे मॉड्यूल-स्तरीय डंडर मुख्य मॉड्यूल डॉकस्ट्रिंग के बाद और सभी import स्टेटमेंट्स से पहले रखने चाहिए। आपको from __future__ इम्पोर्ट्स को किसी भी अन्य कोड से पहले, सिवाय डॉकस्ट्रिंग्स के, परिभाषित करना चाहिए:

"""
    Algos module consists of all the basic algorithms and their implementation
"""

from __future__ import print

__all__ = ['searching', 'sorting']
__version__ = '0.0.1'
__author__ = 'Chitrank Dixit'

import os
import sys

टिप: डॉकस्ट्रिंग्स लिखने के लिए निम्न परंपराएँ देखें।

नामकरण परंपराएँ

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

यदि आप सुनिश्चित नहीं हैं कि कौन-सी नामकरण शैलियाँ उपलब्ध हैं, तो निम्न पर विचार करें:

b या एकल लोअरकेस अक्षर;
B या एकल अपरकेस अक्षर;
lowercase
UPPERCASE
lower_case_with_underscores
UPPER_CASE_WITH_UNDERSCORES
CapitalizedWords, जिसे CapWords, CamelCase या StudlyCaps भी कहा जाता है।
mixedCase
Capitalized_Words_With_Underscores
_single_leading_underscore: आंतरिक उपयोग का कमजोर संकेतक। उदाहरण के लिए, from M import * उन ऑब्जेक्ट्स को इम्पोर्ट नहीं करता जिनके नाम अंडरस्कोर से शुरू होते हैं।
single_trailing_underscore_: परंपरा से Python कीवर्ड के साथ टकराव से बचने के लिए उपयोग होता है, उदाहरण के लिए, Tkinter.Toplevel(master, class_='ClassName')
__double_leading_underscore: किसी क्लास एट्रिब्यूट का नाम रखते समय, नेम मैंगलिंग लागू करता है (क्लास FooBar के अंदर, __boo _FooBar__boo बन जाता है)।
__double_leading_and_trailing_underscore__: "मैजिक" ऑब्जेक्ट्स या एट्रिब्यूट्स जो उपयोगकर्ता-नियंत्रित नेमस्पेसेज़ में रहते हैं। उदाहरण के लिए, __init__, __import__ या __file__। ऐसे नाम आपको कभी इजाद नहीं करने चाहिए, बल्कि केवल दस्तावेज़ के अनुसार उपयोग करने चाहिए।

सामान्य नामकरण परंपराएँ

निम्न तालिका आपको आपके आइडेंटिफ़ायर्स का नाम कैसे रखें, इस पर कुछ सामान्य दिशानिर्देश दिखाती है:

आइडेंटिफ़ायर	परंपरा
मॉड्यूल	lowercase
क्लास	CapWords
फ़ंक्शंस	lowercase
मेथड्स	lowercase
टाइप वेरिएबल्स	CapWords
कॉनस्टेंट्स	UPPERCASE
पैकेज	lowercase

'l', 'O' या 'I' को एकल वेरिएबल नाम के रूप में उपयोग न करें: ये अक्षर कुछ फ़ॉन्ट्स में शून्य (0) और (1) से मिलते-जुलते लगते हैं।
आम तौर पर, संभव हो तो छोटे नामों का उपयोग करना अच्छा है। कुछ मामलों में, पठनीयता बढ़ाने के लिए आप अंडरस्कोर का उपयोग कर सकते हैं।

यदि आप सामान्य नामकरण परंपराओं के अपवादों के बारे में अधिक जानना चाहते हैं, तो यह लेख देखें।

क्या आपका कोड PEP-8 के अनुरूप है?

PEP-8 के बारे में अधिक जानने के बाद, आप शायद सोच रहे होंगे कि आप कैसे जाँच सकते हैं कि आपका कोड वास्तव में इन दिशानिर्देशों (और उन कई और जिन पर इस ट्यूटोरियल में चर्चा नहीं हुई!) का पालन करता है या नहीं।

PEP-8 को स्वयं पढ़ने और इसके बारे में अधिक सीखने के अलावा, आपको निश्चित रूप से उपयोगी pep8 मॉड्यूल, coala पैकेज और अगले खंडों में वर्णित अन्य विकल्पों पर विचार करना चाहिए!

Python `pep8` पैकेज

pep8 पैकेज का उपयोग आपके Python कोड में PEP-8 असंगतियाँ जाँचने और उन्हें PEP-8 दिशानिर्देशों के अनुरूप बनाने के लिए परिवर्तन सुझाने में किया जा सकता है। आप निम्न कमांड चलाकर pip की मदद से pep8 मॉड्यूल इंस्टॉल कर सकते हैं:

pip install pep8

यह दिखाने के लिए कि pep8 कैसे काम करता है, example.py नाम की एक नई Python फ़ाइल निम्न कोड के साथ बनाएँ:

def my_function(a, b):
    print("The sum of a and b is: ", a + b)

a = 1
b = 2

my_function(a,b)

फ़ाइल सहेजें और फिर अपने टर्मिनल या कमांड प्रॉम्प्ट में उस पर pep8 कमांड इस प्रकार चलाएँ:

pep8 example.py

यह कोड में pep8 द्वारा पता की गई किसी भी PEP-8 असंगति को इस प्रकार आउटपुट करेगा:

example.py:1:1: E302 expected 2 blank lines, found 0
example.py:3:5: E225 missing whitespace around operator
example.py:5:5: E225 missing whitespace around operator

आउटपुट की पहली पंक्ति इंगित करती है कि पंक्ति 1 पर फ़ंक्शन परिभाषा से पहले दो खाली पंक्तियाँ होनी चाहिए। अगली दो पंक्तियाँ इंगित करती हैं कि print स्टेटमेंट और असाइनमेंट स्टेटमेंट्स में जोड़ ऑपरेटर के चारों ओर व्हाइटस्पेस होना चाहिए।

इन समस्याओं को ठीक करने के लिए, आप कोड को इस प्रकार संशोधित कर सकते हैं:

def my_function(a, b):
    print("The sum of a and b is:", a + b)

a = 1
b = 2

my_function(a, b)

अब, जब आप pep8 example.py फिर से चलाएँगे, तो कोई आउटपुट नहीं होना चाहिए, जो दर्शाता है कि कोड अब PEP-8 के अनुरूप है।

आप --show-source आर्ग्युमेंट के साथ उस सोर्स कोड को भी देख सकते हैं जहाँ असंगति मिली है:

$ pep8 --show-source --show-pep8 testsuite/E40.py
testsuite/E40.py:2:10: E401 multiple imports on one line
import os, sys
         ^
    Imports should usually be on separate lines.

    Okay: import os\nimport sys
    E401: import sys, os

या आप --statistics जोड़कर यह दिखा सकते हैं कि प्रत्येक त्रुटि कितनी बार मिली:

$ pep8 --statistics -qq Python-2.5/Lib
232     E201 whitespace after '['
599     E202 whitespace before ')'
631     E203 whitespace before ','
842     E211 whitespace before '('
2531    E221 multiple spaces before operator
4473    E301 expected 1 blank line, found 0
4006    E302 expected 2 blank lines, found 1
165     E303 too many blank lines (4)
325     E401 multiple imports on one line
3615    E501 line too long (82 characters)
612     W601 .has_key() is deprecated, use 'in'
1188    W602 deprecated form of raising exception

टिप: अन्य मॉड्यूल्स भी देखें, जैसे flake8, autopep8 या pylint!

`coala` के साथ अपने कोड का विश्लेषण

coala सभी भाषाओं के लिए लिंटिंग और फ़िक्सिंग प्रदान करता है, लेकिन यहाँ आपका ध्यान Python प्रोग्रामिंग पर है। आप pip का उपयोग करके coala इंस्टॉल कर सकते हैं:

$ pip3 install coala-bears

ऊपर के कोड खंड में, आप देखते हैं कि वास्तव में आप coala-bears इंस्टॉल करते हैं: bears प्लगइन्स या साधारण मॉड्यूल्स हैं जो आपके coala की क्षमता बढ़ाते हैं और भाषा के अनुसार बदलते हैं। इस मामले में, आप pep8bear का उपयोग करना चाहते हैं, जो PEP-8 असंगत कोड ढूँढता है और उसे वहीं पर ठीक कर देता है। आपको अपने Python कोड की जाँच के लिए इसे अवश्य विचार करना चाहिए।

$ coala -S python.bears=PEP8Bear python.files=\*\*/\*.py \
python.default_actions=PEP8Bear:ApplyPatchAction --save
# other output ...
Executing section python...
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.
[INFO][11:03:37] Applied 'ApplyPatchAction' for 'PEP8Bear'.

pep8online: अपने Python कोड को ऑनलाइन जाँचें

उपयोगी pep8 मॉड्यूल और coala पैकेज के अलावा, आप pep8online पर जाकर भी जाँच सकते हैं कि आपका Python कोड PEP-8 के अनुरूप है या नहीं। इस साइट पर एक ऑनलाइन एडिटर है जो आपको बस अपना कोड पेस्ट करने और "Check code" बटन दबाने देता है! परिणामस्वरूप, आपको यह फीडबैक मिलेगा कि आपको क्या सुधारना है। बढ़िया और सुविधाजनक!

निष्कर्ष

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

अब जब आप इस ट्यूटोरियल से गुज़र चुके हैं, तो अपने लिए PEP-8 देखना एक बहुत अच्छा विचार है! जानने के लिए और भी बहुत कुछ है।

यदि आपके पास PEP-8 का पालन करने के और सुझाव हैं या आपको लगता है कि हमने इस लेख में कुछ महत्वपूर्ण छोड़ दिया है, तो बेझिझक हमें @DataCamp पर बताइए।

विषय

Python

डेटा साइंस

Python कोर्स

कोर्स

Python परिचय

4 घंटा

7.1M

Python के साथ डेटा विश्लेषण की बुनियादी बातें सिर्फ चार घंटे में सीखें। यह ऑनलाइन पाठ्यक्रम Python इंटरफ़ेस का परिचय देगा और लोकप्रिय पैकेजों का अन्वेषण करेगा।

विवरण देखें पाठ्यक्रम शुरू करें

कोर्स

Python में Data Science परिचय

4 घंटा

504K

Python से डेटा विज्ञान में उतरें और अपने डेटा का प्रभावी विश्लेषण व विज़ुअलाइज़ेशन करना सीखें। कोई कोडिंग अनुभव या कौशल की आवश्यकता नहीं।

विवरण देखें पाठ्यक्रम शुरू करें

अपना निःशुल्क खाता बनाएँ

अभ्यास और ट्रैक अपनी प्रगति को।

Google के साथ जारी रखें

और देखें

PEP-8 का परिचय

इंडेंटेशन

अधिकतम पंक्ति लंबाई

खाली पंक्तियाँ

एक्सप्रेशंस और स्टेटमेंट्स में व्हाइटस्पेसेज़

सोर्स फ़ाइल एन्कोडिंग

इम्पोर्ट्स

एब्सोल्यूट और रिलेटिव इम्पोर्ट्स

वाइल्डकार्ड इम्पोर्ट्स

कमेंट्स

मॉड्यूल-स्तरीय डंडर नाम

नामकरण परंपराएँ

सामान्य नामकरण परंपराएँ

क्या आपका कोड PEP-8 के अनुरूप है?

Python pep8 पैकेज

coala के साथ अपने कोड का विश्लेषण

pep8online: अपने Python कोड को ऑनलाइन जाँचें

निष्कर्ष

Python कोर्स

Python में Data Science परिचय

अपना निःशुल्क खाता बनाएँ

Python `pep8` पैकेज

`coala` के साथ अपने कोड का विश्लेषण