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

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

अधिक जानकारी के लिए स्टाइल गाइड की जाँच करें ।

अपनी उदाहरण पंक्ति से:

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

या:

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

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

Comments

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

— कार्ल मेयर

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

— जेरुब

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

— टोनी मेयर

संभवतः पीईपी -8 बदल गया है क्योंकि इन टिप्पणियों को जोड़ा गया था, क्योंकि यह अब काफी हद तक स्पष्ट है कि कोष्ठक को लंबी लाइनों को लपेटने के लिए जोड़ा जाना चाहिए: "कोष्ठक में अभिव्यक्तियों को लपेटकर लंबी लाइनों को कई लाइनों पर तोड़ा जा सकता है।"

— डैनियल

PEP8 वास्तव में 2010 में बदल गया - "कभी-कभी बैकस्लैश का उपयोग करना बेहतर दिखता है" चला गया है।

— e100

Answer 2

से पीईपी 8 - अजगर कोड के लिए स्टाइल गाइड :

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

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

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)

पीईपी 8 अब गणितज्ञों और उनके प्रकाशकों द्वारा पठनीयता में सुधार के लिए इस्तेमाल किए जाने वाले विपरीत सम्मेलन (बाइनरी ऑपरेशंस पर ब्रेकिंग के लिए) की सिफारिश करता है।

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

से PEP8: से पहले या एक द्विआधारी ऑपरेटर के बाद एक लाइन ब्रेक? :

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

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

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

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

[३]: डोनाल्ड नुथ की द टीएक्सबुक, पृष्ठ १ ९ ५ और १ ९ ६

Comments

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

— e100

@ e100: पाठ को ऊपर बोल्ड में पढ़ें: The preferred way .. is by using Python's implied line continuation inside parenthesesयह उसी तरह है जैसे कि by wrapping expressions in parentheses। मैंने उदाहरण प्रस्तुत किया है

— jfs

लेकिन ध्यान दें कि "कभी-कभी बैकस्लैश का उपयोग करना बेहतर लगता है" भी चला गया है।

— e100

@ e100: यहां तीन कोड उदाहरण दिए गए हैं जहां बैकस्लैश कोड को अधिक पठनीय बनाते हैं: "कभी-कभी स्टाइल गाइड सिर्फ लागू नहीं होता है। जब संदेह होता है, तो अपने सर्वोत्तम निर्णय का उपयोग करें।"

— JFS

2015 में स्टाइल गाइड को अद्यतन किया गया था क्योंकि पठनीयता में कथित सुधारों के कारण डोनाल्ड नुथ द्वारा अनुसंधान के बाद द्विआधारी ऑपरेटरों से पहले तोड़ना पसंद किया गया था ।

— J2C

Answer 3

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

अधिक के लिए पायथन मुहावरे और एंटी-मुहावरे ( पायथन 2 या पायथन 3 के लिए ) देखें।

Comments

यह एक कारण है कि बेहतर व्हाट्सएप को देखने में सक्षम होना अच्छा है; यानी कुछ-कुछ set list listchars=trail:·वैम की तरह । :)

— ब्यू

Answer 4

एक रखो \अपने पंक्ति के अंत में या कोष्ठक में बयान लगा ( .. )। से आईबीएम :

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

या

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

Answer 5

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

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

Answer 6

घोड़े के मुँह से: स्पष्ट रेखा जुड़ना

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

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

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

Comments

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

— u0b34a0f6ae

Answer 7

यह पाइथोनिक तरीका नहीं हो सकता है, लेकिन मैं आमतौर पर एसक्यूएल प्रश्नों की तरह एक लंबी स्ट्रिंग लिखने के लिए जॉइन फ़ंक्शन के साथ एक सूची का उपयोग करता हूं:

query = " ".join([
    'SELECT * FROM "TableName"',
    'WHERE "SomeColumn1"=VALUE',
    'ORDER BY "SomeColumn2"',
    'LIMIT 5;'
])

Answer 8

द हिचहाइकर गाइड टू पाइथन ( रेखा निरंतरता ) से लिया गया:

जब कोड की एक तार्किक रेखा स्वीकृत सीमा से अधिक लंबी होती है, तो आपको इसे कई भौतिक रेखाओं में विभाजित करने की आवश्यकता होती है। यदि पंक्ति का अंतिम वर्ण बैकस्लैश है, तो पायथन दुभाषिया लगातार रेखाओं से जुड़ जाएगा। यह कुछ मामलों में सहायक है, लेकिन आमतौर पर इसकी नाजुकता से बचा जाना चाहिए: लाइन के अंत में जोड़ा गया एक सफेद स्थान, बैकस्लैश के बाद, कोड को तोड़ देगा और अप्रत्याशित परिणाम हो सकते हैं।

एक बेहतर उपाय अपने तत्वों के आसपास कोष्ठक का उपयोग करना है। एंड-ऑफ-लाइन पर एक असम्बद्ध कोष्ठक के साथ छोड़ दिया पायथन दुभाषिया अगली पंक्ति में शामिल हो जाएगा जब तक कि कोष्ठक बंद न हो जाए। वही व्यवहार घुंघराले और वर्गाकार ब्रेसिज़ के लिए होता है।

हालांकि , अधिक बार नहीं, एक लंबी तार्किक रेखा को विभाजित करना एक संकेत है कि आप एक ही समय में बहुत सारे काम करने की कोशिश कर रहे हैं, जो पठनीयता में बाधा हो सकती है।

उस ने कहा, यहाँ एक उदाहरण है कई आयातों पर विचार (जब लाइन की सीमा से अधिक , PEP-8 पर परिभाषित ), सामान्य रूप से तार पर भी लागू होता है:

from app import (
    app, abort, make_response, redirect, render_template, request, session
)

Answer 9

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

long_string = "a very long string"
print("a very long string")

द्वारा प्रतिस्थापित किया जाएगा

long_string = (
  "a "
  "very "
  "long "
  "string"
)
print(
  "a "
  "very "
  "long "
  "string"
)

दोनों प्रिंट स्टेटमेंट के लिए आउटपुट:

a very long string

कोष्ठक को प्रभावित करने में ध्यान दें।

यह भी ध्यान दें कि शाब्दिक तारों को टुकड़ों में तोड़कर शाब्दिक उपसर्ग का उपयोग केवल स्ट्रिंग के हिस्सों पर करने की अनुमति देता है:

s = (
  "2+2="
  f"{2+2}"
)

Answer 10

लाइन निरंतरता ऑपरेटर अर्थात "\" का उपयोग करें

उदाहरण:

# Ex.1

x = 1
s =  x + x**2/2 + x**3/3 \
       + x**4/4 + x**5/5 \
       + x**6/6 + x**7/7 \
       + x**8/8
print(s)
# 2.7178571428571425


----------


# Ex.2

text = ('Put several strings within parentheses ' \
        'to have them joined together.')
print(text)


----------


# Ex.3

x = 1
s =  x + x**2/2 \
       + x**3/3 \
       + x**4/4 \
       + x**6/6 \
       + x**8/8
print(s)
# 2.3749999999999996