string एक लंबी बहु लाइन स्ट्रिंग बनाने के लिए पाइथोनिक तरीका




python (15)

मेरे पास बहुत लंबी क्वेरी है। मैं इसे पायथन में कई पंक्तियों में विभाजित करना चाहता हूं। जावास्क्रिप्ट में ऐसा करने का एक तरीका कई वाक्यों का उपयोग करेगा और उन्हें + ऑपरेटर के साथ शामिल करेगा (मुझे पता है, शायद यह करने का सबसे प्रभावी तरीका नहीं है, लेकिन मैं इस चरण में प्रदर्शन के बारे में वास्तव में चिंतित नहीं हूं, बस कोड पठनीयता )। उदाहरण:

var long_string = 'some text not important. just garbage to' +
                  'illustrate my example';

मैंने पायथन में कुछ ऐसा करने की कोशिश की, लेकिन यह काम नहीं किया, इसलिए मैंने लंबी स्ट्रिंग को विभाजित करने के लिए \ हालांकि, मुझे यकीन नहीं है कि यह करने का यह एकमात्र / सर्वोत्तम / पायदानपूर्ण तरीका है या नहीं। यह अजीब लग रहा है। वास्तविक कोड:

query = 'SELECT action.descr as "action", '\
    'role.id as role_id,'\
    'role.descr as role'\
    'FROM '\
    'public.role_action_def,'\
    'public.role,'\
    'public.record_def, '\
    'public.action'\
    'WHERE role.id = role_action_def.role_id AND'\
    'record_def.id = role_action_def.def_id AND'\
    'action.id = role_action_def.action_id AND'\
    'role_action_def.account_id = ' + account_id + ' AND'\
    'record_def.account_id=' + account_id + ' AND'\
    'def_id=' + def_id

https://code.i-harness.com


"À ला" स्कैला रास्ता (लेकिन मुझे लगता है कि ओक्यू मांगों के रूप में सबसे अधिक पागल तरीका है):

description = """
            | The intention of this module is to provide a method to 
            | pass meta information in markdown_ header files for 
            | using it in jinja_ templates. 
            | 
            | Also, to provide a method to use markdown files as jinja 
            | templates. Maybe you prefer to see the code than 
            | to install it.""".replace('\n            | \n','\n').replace('            | ',' ')

यदि आप जंप लाइनों के बिना अंतिम स्ट्रेट चाहते हैं, तो दूसरी जगह के पहले तर्क की शुरुआत में \n डाल दें:

.replace('\n            | ',' ')`.

नोट: "... टेम्पलेट्स" के बीच सफेद रेखा। और "इसके अलावा, ..." के बाद एक सफेद जगह की आवश्यकता है ।


आप sql-statement को एक अलग फ़ाइल action.sql में भी रख सकते हैं और इसे पीई फ़ाइल में लोड कर सकते हैं

with open('action.sql') as f:
   query = f.read()

तो एसक्यूएल-स्टेटमेंट पायथन कोड से अलग हो जाएंगे। यदि एसक्यूएल कथन में पैरामीटर हैं जिन्हें पाइथन से भरने की आवश्यकता है, तो आप स्ट्रिंग फॉर्मेटिंग (जैसे% s या {field}) का उपयोग कर सकते हैं


आपका वास्तविक कोड काम नहीं करना चाहिए, आप "लाइनों" के अंत में सफेद role.descr as roleFROM... याद कर रहे हैं (उदाहरण: role.descr as roleFROM... )

मल्टीलाइन स्ट्रिंग के लिए triplequotes है:

string = """line
  line2
  line3"""

इसमें लाइन ब्रेक और अतिरिक्त रिक्त स्थान होंगे, लेकिन एसक्यूएल के लिए यह कोई समस्या नहीं है।


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

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1={} "
       "and condition2={}").format(1, 2)

Output: 'select field1, field2, field3, field4 from table 
         where condition1=1 and condition2=2'

यदि स्थिति का मूल्य एक स्ट्रिंग होना चाहिए, तो आप ऐसा कर सकते हैं:

sql = ("select field1, field2, field3, field4 "
       "from table "
       "where condition1='{0}' "
       "and condition2='{1}'").format('2016-10-12', '2017-10-12')

Output: "select field1, field2, field3, field4 from table where
         condition1='2016-10-12' and condition2='2017-10-12'"

एक और विकल्प जो मुझे लगता है वह अधिक पठनीय है जब कोड (जैसे परिवर्तनीय) इंडेंट किया गया है और आउटपुट स्ट्रिंग एक लाइनर होना चाहिए (कोई न्यूलाइन नहीं):

def some_method():

    long_string = """
a presumptuous long string 
which looks a bit nicer 
in a text editor when
written over multiple lines
""".strip('\n').replace('\n', ' ')

    return long_string 

क्या आप मल्टी-लाइन तारों के बारे में बात कर रहे हैं? आसान, उन्हें शुरू करने और समाप्त करने के लिए ट्रिपल उद्धरण का उपयोग करें।

s = """ this is a very
        long string if I had the
        energy to type more and more ..."""

आप सिंगल कोट्स का भी उपयोग कर सकते हैं (उनमें से 3 निश्चित रूप से शुरुआत और अंत में) और परिणामस्वरूप स्ट्रिंग को किसी अन्य स्ट्रिंग की तरह ही इलाज कर सकते हैं।

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

अर्थात,:

' this is a very\n        long string if I had the\n        energy to type more and more ...'

अंत में, कोई भी इस तरह पाइथन में लंबी लाइनें बना सकता है:

 s = ("this is a very"
      "long string too"
      "for sure ..."
     )

जिसमें कोई अतिरिक्त रिक्त स्थान या न्यूलाइन नहीं शामिल होगी (यह एक जानबूझकर उदाहरण है जो दिखाता है कि स्किपिंग रिक्त स्थान का असर क्या होगा):

'this is a verylong string toofor sure ...'

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


नोटेशन का उपयोग करते समय आप चर को जोड़ सकते हैं:

foo = '1234'

long_string = """fosdl a sdlfklaskdf as
as df ajsdfj asdfa sld
a sdf alsdfl alsdfl """ +  foo + """ aks
asdkfkasdk fak"""

संपादित करें: नामित पैरा और .format () के साथ एक बेहतर तरीका मिला:

body = """
<html>
<head>
</head>
<body>
    <p>Lorem ipsum.</p>
    <dl>
        <dt>Asdf:</dt>     <dd><a href="{link}">{name}</a></dd>
    </dl>
    </body>
</html>
""".format(
    link='http://www.asdf.com',
    name='Asdf',
)

print(body)

पायथन में = = 3.6 आप स्वरूपित स्ट्रिंग अक्षर (एफ स्ट्रिंग) का उपयोग कर सकते हैं

query= f'''SELECT   action.descr as "action"
    role.id as role_id,
    role.descr as role
    FROM
    public.role_action_def,
    public.role,
    public.record_def,
    public.action
    WHERE role.id = role_action_def.role_id AND
    record_def.id = role_action_def.def_id AND
    action.id = role_action_def.action_id AND
    role_action_def.account_id = {account_id} AND
    record_def.account_id = {account_id} AND
    def_id = {def_id}'''

मुझे यह दृष्टिकोण पसंद है क्योंकि यह पढ़ने योग्य विशेषाधिकार है। ऐसे मामलों में जहां हमारे पास लंबे तार हैं, कोई रास्ता नहीं है! इंडेंटेशन के स्तर के आधार पर आप प्रति पंक्ति 80 वर्णों तक सीमित हैं और अभी भी सीमित हैं ... अच्छा ... किसी और चीज को कहने की आवश्यकता नहीं है। मेरे विचार में पाइथन शैली गाइड अभी भी बहुत अस्पष्ट हैं। मैंने @ एरो एल्टन दृष्टिकोण लिया क्योंकि यह पढ़ने और सामान्य ज्ञान के विशेषाधिकारों को प्राप्त करता है। मैं समझता हूं कि शैली मार्गदर्शिकाओं को हमारी मदद करनी चाहिए और हमारे जीवन को गड़बड़ नहीं करना चाहिए। धन्यवाद!

class ClassName():
    def method_name():
        if condition_0:
            if condition_1:
                if condition_2:
                    some_variable_0 =\
"""
some_js_func_call(
    undefined, 
    {
        'some_attr_0': 'value_0', 
        'some_attr_1': 'value_1', 
        'some_attr_2': '""" + some_variable_1 + """'
    }, 
    undefined, 
    undefined, 
    true
)
"""

मुझे लगता है कि लंबे तारों का निर्माण करते समय, आप आम तौर पर एक एसक्यूएल क्वेरी बनाने की तरह कुछ कर रहे हैं, इस मामले में यह सबसे अच्छा है:

query = ' '.join((  # note double parens, join() takes an iterable
    "SELECT foo",
    "FROM bar",
    "WHERE baz",
))

क्या Levon सुझाव दिया अच्छा है, लेकिन गलतियों के लिए कमजोर हो सकता है:

query = (
    "SELECT foo"
    "FROM bar"
    "WHERE baz"
)

query == "SELECT fooFROM barWHERE baz"  # probably not what you want

मेरे लिए \ कार्यों द्वारा लाइनों को तोड़ना। यहाँ एक उदाहरण है:

longStr = "This is a very long string " \
        "that I wrote to help somebody " \
        "who had a question about " \
        "writing long strings in Python"

मैं जटिल एसक्यूएल क्वेरीज़ बनाने के लिए एक रिकर्सिव फ़ंक्शन का उपयोग करता हूं। कोड तकनीक पठनीयता को बनाए रखते हुए इस तकनीक का उपयोग आम तौर पर बड़े तारों के निर्माण के लिए किया जा सकता है।

# Utility function to recursively resolve SQL statements.
# CAUTION: Use this function carefully, Pass correct SQL parameters {},
# TODO: This should never happen but check for infinite loops
def resolveSQL(sql_seed, sqlparams):
    sql = sql_seed % (sqlparams)
    if sql == sql_seed:
        return ' '.join([x.strip() for x in sql.split()])
    else:
        return resolveSQL(sql, sqlparams)

पीएस: यदि आवश्यक हो तो सुंदर प्रिंट एसक्यूएल प्रश्नों के लिए भयानक पायथन-स्क्लपरसे लाइब्रेरी पर नज़र डालें। http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format


मैं पाइथन में कच्चे एसक्यूएल प्रश्न लिखने के लिए विशेष रूप से निम्नलिखित (सरल, सुरक्षित और पायथनिक) तरीका प्राप्त करता हूं, खासकर जब पाइथन के एसक्लाइट 3 मॉड्यूल का उपयोग करते समय:

query = '''
    SELECT
        action.descr as action,
        role.id as role_id,
        role.descr as role
    FROM
        public.role_action_def,
        public.role,
        public.record_def,
        public.action
    WHERE
        role.id = role_action_def.role_id
        AND record_def.id = role_action_def.def_id
        AND action.id = role_action_def.action_id
        AND role_action_def.account_id = ?
        AND record_def.account_id = ?
        AND def_id = ?
'''
vars = (account_id, account_id, def_id)   # a tuple of query variables
cursor.execute(query, vars)   # using Python's sqlite3 module

पेशेवरों

  • साफ और सरल कोड (पायथनिक!)
  • एसक्यूएल इंजेक्शन से सुरक्षित
  • पाइथन 2 और पायथन 3 दोनों के साथ संगत (यह सब के बाद पाइथोनिक है)
  • कोई स्ट्रिंग concatenation की आवश्यकता नहीं है
  • यह सुनिश्चित करने की कोई ज़रूरत नहीं है कि प्रत्येक पंक्ति का सही-चरित्र एक स्थान है

विपक्ष

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

मैंने खुद को इस से खुश पाया:

string = """This is a
very long string,
containing commas,
that I split up
for readability""".replace('\n',' ')

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

query = ('SELECT   action.descr as "action", '
         'role.id as role_id,'
         'role.descr as role'
         ' FROM '
         'public.role_action_def,'
         'public.role,'
         'public.record_def, '
         'public.action'
         ' WHERE role.id = role_action_def.role_id AND'
         ' record_def.id = role_action_def.def_id AND'
         ' action.id = role_action_def.action_id AND'
         ' role_action_def.account_id = '+account_id+' AND'
         ' record_def.account_id='+account_id+' AND'
         ' def_id='+def_id)

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





python