දිගු බහු රේඛා නූලක් නිර්මාණය කිරීම සඳහා පයිතොනික් ක්‍රමය

මට ඉතා දිගු විමසුමක් තිබේ. මම එය පයිතන්හි පේළි කිහිපයකින් බෙදීමට කැමතියි. ජාවාස්ක්‍රිප්ට් හි එය කළ හැකි ක්‍රමයක් වනුයේ වාක්‍ය කිහිපයක් භාවිතා කර ඒවා +ක්‍රියාකරුවෙකු සමඟ සම්බන්ධ කිරීමයි (මම දනිමි, සමහර විට එය එය කිරීමට වඩාත්ම කාර්යක්ෂම ක්‍රමය නොවිය හැකිය, නමුත් මෙම අදියරේ කාර්ය සාධනය ගැන මම සැබවින්ම තැකීමක් නොකරමි, කේත කියවීමේ හැකියාව) . උදාහරණයක්:

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

ඔබ කතා කරන්නේ බහු රේඛා නූල් ගැනද? ආරම්භ කිරීම සහ අවසන් කිරීම සඳහා ත්‍රිත්ව උපුටා දැක්වීම් පහසුය.

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

ඔබට තනි උපුටා දැක්වීම් ද භාවිතා කළ හැකිය (ඒවායින් 3 ක්ම ආරම්භයේ සහ අවසානයේ ඇත්ත වශයෙන්ම) සහ එහි ප්‍රති string ලයක් ලෙස ඇති නූල් sවෙනත් ඕනෑම නූලකට සේ සලකන්න .

සටහන : ඕනෑම නූලක් සේම, ආරම්භක සහ අවසන් උපුටා දැක්වීම් අතර ඇති ඕනෑම දෙයක් නූලෙහි කොටසක් බවට පත්වේ, එබැවින් මෙම උදාහරණයේ ප්‍රමුඛ හිස් එකක් ඇත (@ 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 ..."
     )

එයට අමතර හිස් හෝ නව රේඛා ඇතුළත් නොවේ (මෙය හිස් තැන් මඟ හැරීමේ ප්‍රති result ලය කුමක් වේදැයි පෙන්වන හිතාමතා උදාහරණයකි):

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

කොමාව අවශ්‍ය නොවේ, වරහන් වර්‍ග යුගලයකට සම්බන්ධ කළ යුතු නූල් තබා අවශ්‍ය හිස් හා නව රේඛා සඳහා වග බලා ගන්න.

ඔබට බහු රේඛාවක් අවශ්‍ය නැති නමුත් දිගු තනි පේළියක් තිබේ නම්, ඔබට වරහන් භාවිතා කළ හැකිය, ඔබ නූල් කොටස් අතර කොමාව ඇතුළත් නොකරන බවට වග බලා ගන්න, එවිට එය ටුපල් එකක් වනු ඇත.

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)

ඔබ ගොඩනඟන දේ වැනි SQL ප්‍රකාශයක, බහු රේඛා ද හොඳ වනු ඇත. නමුත් බහු සුදු නූලක් අඩංගු අමතර සුදු අවකාශය ගැටළුවක් වනු ඇත, එවිට මෙය ඔබට අවශ්‍ය දේ සාක්ෂාත් කර ගැනීමට හොඳ ක්‍රමයක් වනු ඇත.

\මා වෙනුවෙන් වැඩ කිරීමෙන් රේඛා බිඳීම . මෙන්න උදාහරණයක්:

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

මම මේ ගැන සතුටු වුනා:

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

දිගු නූල් තැනීමේදී, ඔබ සාමාන්‍යයෙන් කරන්නේ SQL විමසුමක් තැනීම වැනි දෙයක් බව මට පෙනී ගියේය.

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

ලෙවොන් යෝජනා කළ දේ හොඳයි, නමුත් වැරදි වලට ගොදුරු විය හැකිය:

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

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

අංකනය භාවිතා කිරීමේදී ඔබට විචල්‍යයන් සංයුක්ත කළ හැකිය:

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)

මෙම ප්‍රවේශය භාවිතා කරන්නේ:

• ආරම්භක රේඛීය සංග්‍රහයක් වළක්වා ගැනීම සඳහා එක් බැක්ස්ලෑෂ් එකක් පමණි
• ත්‍රිත්ව උපුටා ගත් නූලක් භාවිතා කිරීමෙන් අභ්‍යන්තර විරාම ලකුණු නොමැත
• පෙළ ආවරණ inspect මොඩියුලය භාවිතයෙන් දේශීය ඉන්ඩෙන්ටේෂන් ඉවත් කරයි
• account_idසහ def_idවිචල්‍යයන් සඳහා python 3.6 ආකෘතිගත නූල් අන්තර් මැදිහත්වීම ('f') භාවිතා කරයි .

මේ ආකාරයෙන් මට වඩාත්ම පයිතොනික් පෙනේ.

# import textwrap  # See update to answer below
import inspect

# query = textwrap.dedent(f'''\
query = inspect.cleandoc(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}'''
)

යාවත්කාලීන කිරීම : 1/29/2019 සංස්ථාගත කරන්න @ ෂැඩෝ රේන්ජර්ගේ යෝජනාව inspect.cleandocවෙනුවට භාවිතා කිරීමtextwrap.dedent

පයිතන්> = 3.6 හි ඔබට ආකෘතිගත වචන වචන භාවිතා කළ හැකිය (f string)

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}'''

උදාහරණයක් වශයෙන්:

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'"

මෙහිtextwrap.dedent විස්තර කර ඇති පරිදි දිගු නූල් සඳහා හොඳම දේ මම සොයා ගතිමි :

def create_snippet():
    code_snippet = textwrap.dedent("""\
        int main(int argc, char* argv[]) {
            return 0;
        }
    """)
    do_something(code_snippet)

තවත් සමහරු වරහන් වර්‍ග ක්‍රමය දැනටමත් සඳහන් කර ඇත, නමුත් වරහන් සමඟ, පේළිගත කිරීමේ අදහස් දැක්වීමට අවසර ඇත.

එක් එක් කොටස ගැන අදහස් දක්වන්න:

nursery_rhyme = (
    'Mary had a little lamb,'          # Comments are great!
    'its fleece was white as snow.'
    'And everywhere that Mary went,'
    'her sheep would surely go.'       # What a pesky sheep.
)

ඉදිරියට යාමෙන් පසුව අදහස් දැක්වීමට අවසර නැත:

බැක්ස්ලෑෂ් රේඛා අඛණ්ඩව ( \) භාවිතා කරන විට , අදහස් දැක්වීමට අවසර නැත. ඔබට SyntaxError: unexpected character after line continuation characterදෝෂයක් ලැබෙනු ඇත .

nursery_rhyme = 'Mary had a little lamb,' \  # These comments
    'its fleece was white as snow.'       \  # are invalid!
    'And everywhere that Mary went,'      \
    'her sheep would surely go.'
# => SyntaxError: unexpected character after line continuation character

රීජෙක්ස් නූල් සඳහා වඩා හොඳ අදහස්:

Https://docs.python.org/3/library/re.html#re.VERBOSE වෙතින් උදාහරණය මත පදනම්ව ,

a = re.compile(
    r'\d+'  # the integral part
    r'\.'   # the decimal point
    r'\d*'  # some fractional digits
)

# Using VERBOSE flag, IDE usually can't syntax highight the string comment.
a = re.compile(r"""\d +  # the integral part
                   \.    # the decimal point
                   \d *  # some fractional digits""", re.X)

පයිතන් හි අමු SQL විමසුම් ලිවීමට හොඳම (සරල, ආරක්ෂිත සහ පයිතොනික්) ක්‍රමය ලෙස මම පෞද්ගලිකව සොයා ගතිමි, විශේෂයෙන් පයිතන්ගේ sqlite3 මොඩියුලය භාවිතා කරන විට :

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

වාසි

• පිළිවෙලට හා සරල කේතය (පයිතොනික්!)
• SQL එන්නත් වලින් ආරක්ෂිතයි
• පයිතන් 2 සහ පයිතන් 3 සමඟ අනුකූල වේ (එය පයිතොනික් සියල්ලටම පසුව)
• නූල් සම්මුතියක් අවශ්‍ය නොවේ
• එක් එක් පේළියේ නිවැරදි-වඩාත්ම අක්‍ෂරය අවකාශයක් බව සහතික කිරීම අවශ්‍ය නොවේ

අවාසි

• විමසුමේ විචල්‍යයන් ?ස්ථානගත කරන්නා විසින් ප්‍රතිස්ථාපනය කර ඇති හෙයින්, විමසුමේ විශාල ප්‍රමාණයක් ඇති විට ඒවා වෙනුවට ආදේශ කළ ?යුත්තේ කුමන පයිතන් විචල්‍යයද යන්න සොයා බැලීම ටිකක් අපහසු විය හැකිය .

මම සාමාන්‍යයෙන් මේ වගේ දෙයක් භාවිතා කරනවා:

text = '''
    This string was typed to be a demo
    on how could we write a multi-line
    text in Python.
'''

එක් එක් පේළියේ කරදරකාරී හිස් අවකාශ ඉවත් කිරීමට ඔබට අවශ්‍ය නම්, ඔබට පහත පරිදි කළ හැකිය:

text = '\n'.join(line.lstrip() for line in text.splitlines())

පයිතන්හි දිගු නූල් සඳහා පොදු ප්‍රවේශයක් ලෙස ඔබට ත්‍රිත්ව උපුටා දැක්වීම් භාවිතා කළ හැකිය, splitසහ join:

_str = ' '.join('''Lorem ipsum dolor sit amet, consectetur adipiscing 
        elit, sed do eiusmod tempor incididunt ut labore et dolore 
        magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation 
        ullamco laboris nisi ut aliquip ex ea commodo.'''.split())

ප්‍රතිදානය:

'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo.'

SQL විමසුමකට අදාළ OP හි ප්‍රශ්නය සම්බන්ධයෙන්, පහත දැක්වෙන පිළිතුර SQL විමසුම් තැනීමේ මෙම ප්‍රවේශයේ නිරවද්‍යතාවය නොසලකා හරින අතර අතිරේක ආනයනයන් නොමැතිව කියවිය හැකි හා සෞන්දර්යාත්මක ආකාරයකින් දිගු නූල් තැනීම කෙරෙහි පමණක් අවධානය යොමු කරයි. මෙය ඇතුළත් වන පරිගණකමය බර ද නොසලකා හැරේ.

ත්‍රිත්ව උපුටා දැක්වීම් භාවිතා කරමින් අපි දිගු හා කියවිය හැකි නූලක් සාදන්නෙමු. ඉන්පසු අපි ලැයිස්තුවක් බවට පත් කර split()එමඟින් අවකාශය ඉවත් කර නැවත එය සමඟ සම්බන්ධ වෙමු ' '.join(). අවසාන වශයෙන් අපි format()විධානය භාවිතා කරමින් විචල්යයන් ඇතුල් කරමු :

account_id = 123
def_id = 321

_str = '''
    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 = {}
    '''

query = ' '.join(_str.split()).format(account_id, account_id, def_id)

නිෂ්පාදනය:

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 = 123 AND record_def.account_id=123 AND def_id=321

සංස්කරණය කරන්න: මෙම ප්‍රවේශය PEP8 සමඟ නොගැලපෙන නමුත් ඇතැම් විට එය ප්‍රයෝජනවත් බව මට පෙනේ

(උදා: ඔබ "රේඛා" අවසානයේ දී whitespaces අතුරුදහන් වැඩ නොකළ යුතු, ඔබේ සැබෑ කේතය role.descr as roleFROM...)

මල්ටිලයින් නූල් සඳහා ත්‍රිත්ව කෝෂ ඇත:

string = """line
  line2
  line3"""

එය රේඛා බිඳීම් සහ අමතර අවකාශයන් අඩංගු වනු ඇත, නමුත් SQL සඳහා එය ගැටළුවක් නොවේ.

ඔබට SQL ප්‍රකාශය වෙනම ගොනුවක action.sqlතබා පයි ගොනුවේ පටවන්න

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

එබැවින් SQL ප්‍රකාශයන් පයිතන් කේතයෙන් වෙන් කරනු ලැබේ. පයිතන් වලින් පිරවිය යුතු SQL ප්‍රකාශයේ පරාමිතීන් තිබේ නම්, ඔබට නූල් හැඩතල ගැන්වීම භාවිතා කළ හැකිය (% s හෝ {field like වැනි)

"ලා A" Scala මාර්ගය (නමුත් මම හිතන්නේ OQ ඉල්ලීම් ලෙස වඩාත් pythonic මාර්ගය):

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            | ',' ')`.

සටහන: "... සැකිලි" අතර සුදු රේඛාව. සහ "එසේම, ..." ට පසුව හිස් අවකාශයක් අවශ්‍ය වේ |.

TL; dr: භාවිත """\සහ """වැල ඔතාගෙන දී මෙන්,

string = """\
This is a long string
spanning multiple lines.
"""

සිට නිල පිඹුරා ප්රලේඛනය :

සංගීත සාහිත්‍යකරුවන්ට පේළි කිහිපයක් විහිදිය හැකිය. එක් ක්‍රමයක් වන්නේ ත්‍රිත්ව උපුටා දැක්වීම් ය: "" "..." "" හෝ "" "..." ". රේඛාවල අවසානය ස්වයංක්‍රීයව නූලට ඇතුළත් වේ, නමුත් රේඛාවේ අවසානයේ \ එකතු කිරීමෙන් මෙය වළක්වා ගත හැකිය. පහත උදාහරණය:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

පහත ප්‍රතිදානය නිපදවයි (ආරම්භක නව රේඛාව ඇතුළත් කර නොමැති බව සලකන්න):

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

කේතය (උදා: විචල්‍යය) ඉන්ඩෙන්ට් කර ප්‍රතිදාන නූල එක ලයිනර් එකක් විය යුතු විට (නව රේඛා නැත) වඩා කියවිය හැකි යැයි මා සිතන තවත් විකල්පයක්:

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 

හේයි, එය ක්‍රියාත්මක වන මේ බලාපොරොත්තුව වැනි දෙයක් උත්සාහ කරන්න, මෙම ආකෘතියෙන් මෙන් ඔබ මෙම දේපල ගැන සාර්ථකව විමසා ඇති ආකාරයට අඛණ්ඩ රේඛාවක් ලබා දෙනු ඇත.

"message": f'you have successfully inquired about '
           f'{enquiring_property.title} Property owned by '
           f'{enquiring_property.client}'

සංකීර්ණ SQL විමසුම් තැනීම සඳහා මම පුනරාවර්තන ශ්‍රිතයක් භාවිතා කරමි. කේත කියවීමේ හැකියාව පවත්වා ගනිමින් විශාල නූල් තැනීමට මෙම තාක්ෂණය සාමාන්‍යයෙන් භාවිතා කළ හැකිය.

# 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)

PS: අවශ්‍ය නම් SQL විමසුම් මුද්‍රණය කිරීම සඳහා පුදුමාකාර python-sqlparse පුස්තකාලය දෙස බලන්න. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

ත්රිත්ව උද්ධෘත ලකුණු භාවිතා කරන්න. වැඩසටහන් ආරම්භයේදීම ලේඛණ නිර්මාණය කිරීම සඳහා මිනිසුන් බොහෝ විට මේවා භාවිතා කරන්නේ ඔවුන්ගේ අරමුණ සහ එය නිර්මාණය කිරීමට අදාළ වෙනත් තොරතුරු පැහැදිලි කිරීම සඳහා ය. කාර්යයන් වල අරමුණ සහ යෙදුම පැහැදිලි කිරීම සඳහා මිනිසුන් මේවා ශ්‍රිතවල භාවිතා කරයි. උදාහරණයක්:

'''
Filename: practice.py
File creator: me
File purpose: explain triple quotes
'''


def example():
    """This prints a string that occupies multiple lines!!"""
    print("""
    This
    is 
    a multi-line
    string!
    """)

මම මෙම ප්‍රවේශයට කැමතියි එය කියවීමේ වරප්‍රසාදය නිසා. අපට දිගු නූල් ඇති අවස්ථාවන්හිදී ක්‍රමයක් නොමැත! ඔබ සිටින ඉන්ඩෙන්ටේෂන් මට්ටම අනුව සහ තවමත් එක් පේළියකට අක්ෂර 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
)
"""

සිට නිල පිඹුරා ප්රලේඛනය :

සංගීත සාහිත්‍යකරුවන්ට පේළි කිහිපයක් විහිදිය හැකිය. එක් ක්‍රමයක් වන්නේ ත්‍රිත්ව උපුටා දැක්වීම් ය: "" "..." "" හෝ "" "..." ". රේඛාවල අවසානය ස්වයංක්‍රීයව නූලට ඇතුළත් වේ, නමුත් රේඛාවේ අවසානයේ \ එකතු කිරීමෙන් මෙය වළක්වා ගත හැකිය. පහත උදාහරණය:

print("""\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
""")

පහත ප්‍රතිදානය නිපදවයි (ආරම්භක නව රේඛාව ඇතුළත් කර නොමැති බව සලකන්න):

ඩික්ට් එකක් තුළ දිගු නූලක් අර්ථ දැක්වීම සඳහා, නව රේඛා තබාගෙන අවකාශය මඟ හැරීම සඳහා , මම මේ ආකාරයට නියතයකින් නූල් අර්ථ දැක්වීම අවසන් කළෙමි:

LONG_STRING = \
"""
This is a long sting
that contains newlines.
The newlines are important.
"""

my_dict = {
   'foo': 'bar',
   'string': LONG_STRING
}

සාමාන්යයෙන්, මම භාවිතා කරන්නේ listසහ joinබහු පේළි අදහස් / වචන සඳහා ය.

lines = list()
lines.append('SELECT action.enter code here descr as "action", ')
lines.append('role.id as role_id,')
lines.append('role.descr as role')
lines.append('FROM ')
lines.append('public.role_action_def,')
lines.append('public.role,')
lines.append('public.record_def, ')
lines.append('public.action')
query = " ".join(lines)

' \n' (නව රේඛාව) හෝ ' ,' (කොමාව) හෝ ' ' (අවකාශය) වැනි මෙම ලැයිස්තු මූලද්‍රව්‍යයට සම්බන්ධ වීමට ඔබට ඕනෑම නූලක් භාවිතා කළ හැකිය.

චියර්ස් .. !!