पायथन में मैं लाइन ब्रेक (लाइन निरंतरता) कैसे कर सकता हूं?

Question

मेरे पास कोड की एक लंबी लाइन है जिसे मैं कई लाइनों के बीच तोड़ना चाहता हूं। मैं क्या उपयोग करूं और वाक्यविन्यास क्या है?

उदाहरण के लिए, तार का एक समूह जोड़ने,

e = 'a' + 'b' + 'c' + 'd' 

और दो पंक्तियों में इस तरह यह है:

e = 'a' + 'b' + 
    'c' + 'd' 

Answer 1

लाइन क्या है? तुम बस बिना किसी समस्या के अगली पंक्ति पर बहस हो सकती है:

a = dostuff(blahblah1, blahblah2, blahblah3, blahblah4, blahblah5, 
      blahblah6, blahblah7) 

नहीं तो आप कुछ इस तरह कर सकते हैं:

if a == True and \ 
    b == False 

चेक अधिक जानकारी के लिए style guide।

a = '1' + '2' + '3' + \ 
    '4' + '5' 

या::

अपने उदाहरण रेखा से

a = ('1' + '2' + '3' + 
    '4' + '5') 

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

Answer 2

अपनी लाइन के अंत में एक \ रखो या में बयान संलग्न माता-पिता (..)। IBM से:

b = ((i1 < 20) and 
    (i2 < 30) and 
    (i3 < 40)) 

या

b = (i1 < 20) and \ 
    (i2 < 30) and \ 
    (i3 < 40) 

Answer 3

घोड़े के मुंह से: Explicit line joining

दो या दो से अधिक शारीरिक लाइनों हो सकता है, बैकस्लैश वर्ण (\) का उपयोग तार्किक लाइनों में शामिल हो गए इस प्रकार है: जब एक भौतिक लाइन एक बैकस्लैश में समाप्त होता है कि एक स्ट्रिंग शाब्दिक या टिप्पणी का हिस्सा नहीं है, यह के साथ एक एकल लॉजिकल लाइन बनाने, बैकस्लैश को हटाने और अंत-रेखा के बाद वर्ण में शामिल है। उदाहरण के लिए:

if 1900 < year < 2100 and 1 <= month <= 12 \ 
    and 1 <= day <= 31 and 0 <= hour < 24 \ 
    and 0 <= minute < 60 and 0 <= second < 60: # Looks like a valid date 
     return 1 

एक बैकस्लैश में समाप्त होने वाले एक लाइन एक टिप्पणी नहीं ले कर सकते हैं। बैकस्लैश कोई टिप्पणी जारी नहीं करता है। बैकस्लैश स्ट्रिंग अक्षरों को छोड़कर टोकन जारी नहीं रखता है (यानी स्ट्रिंग अक्षरों के अलावा टोकन बैकस्लैश का उपयोग करके भौतिक रेखाओं में विभाजित नहीं किए जा सकते हैं)। एक बैकस्लैश एक स्ट्रिंग अक्षर के बाहर लाइन पर कहीं और अवैध है।

Answer 4

Style Guide for Python Code से:

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

बैकस्लैश कभी-कभी उचित हो सकता है। उदाहरण के लिए, लंबे,-बयान के साथ कई अंतर्निहित निरंतरता उपयोग नहीं कर सकते, तो बैकस्लैश स्वीकार्य हैं:

with open('/path/to/some/file/you/want/to/read') as file_1, \ 
     open('/path/to/some/file/being/written', 'w') as file_2: 
    file_2.write(file_1.read()) 

एक और इस तरह के मामले ज़ोर बयान के साथ है।

सुनिश्चित करें कि निरंतर लाइन को उचित रूप से इंडेंट करना सुनिश्चित करें। एक बाइनरी ऑपरेटर के चारों ओर तोड़ने के लिए पसंदीदा स्थान ऑपरेटर के बाद, इससे पहले नहीं है। कुछ उदाहरण:

class Rectangle(Blob): 

    def __init__(self, width, height, 
       color='black', emphasis=None, highlight=0): 
     if (width == 0 and height == 0 and 
       color == 'red' and emphasis == 'strong' or 
       highlight > 100): 
      raise ValueError("sorry, you lose") 
     if width == 0 and height == 0 and (color == 'red' or 
              emphasis is None): 
      raise ValueError("I don't think so -- values are %s, %s" % 
          (width, height)) 
     Blob.__init__(self, width, height, 
         color, emphasis, highlight) 

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

डोनाल्ड नुथ की शैली ऑपरेटरों संरेखित खड़ी है, इस प्रकार आंख काम का बोझ कम करने का निर्धारण करते समय आइटम जोड़ा गया है और घटाया जाता है।

PEP8: Should a line break before or after a binary operator? से:

डोनाल्ड नुथ अपने कंप्यूटर और टंकित श्रृंखला में पारंपरिक नियम बताते हैं: "एक पैरा के भीतर सूत्रों हमेशा द्विआधारी संचालन और संबंधों के बाद तोड़ हालांकि, प्रदर्शित सूत्रों हमेशा द्विआधारी आपरेशन से पहले तोड़" [3 ]।

गणित से परंपरा का अनुसरण आमतौर पर अधिक पठनीय कोड में जो परिणाम:

# Yes: easy to match operators with operands 
income = (gross_wages 
      + taxable_interest 
      + (dividends - qualified_dividends) 
      - ira_deduction 
      - student_loan_interest) 

अजगर कोड में, यह पहले या एक द्विआधारी ऑपरेटर के बाद तोड़ने के लिए अनुमति है, जब तक सम्मेलन स्थानीय रूप से संगत है के रूप में। नए कोड के लिए Knuth की शैली का सुझाव दिया गया है।

[3]: डोनाल्ड नुथ की द TeXBook, पृष्ठों 195 और 196

Answer 5

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

पाइथन मुहावरे और एंटी-इडियम्स (Python 2 या Python 3 के लिए) देखें।

Answer 6

आप कोष्ठक और ब्रेसिज़ के बीच लाइनों को तोड़ सकते हैं। साथ ही, आपको एक लाइन के लिए बैकस्लैश चरित्र \ संलग्न स्पष्ट रूप से इसे तोड़ने के लिए कर सकते हैं:

x = (tuples_first_value, 
    second_value) 
y = 1 + \ 
    2