පයිතන්හි රේඛීය විවේකයක් (රේඛීය අඛණ්ඩව) කරන්නේ කෙසේද?

බහුවිධ රේඛා අතර බිඳී යාමට අවශ්‍ය දිගු කේත පේළියක් මා සතුව ඇත. මා භාවිතා කරන්නේ කුමක්ද සහ වාක්‍ය ඛණ්ඩය කුමක්ද?

උදාහරණයක් ලෙස, නූල් පොකුරක් එකතු කිරීම,

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

එය පේළි දෙකකින් තබා ගන්න:

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

රේඛාව කුමක්ද? ඔබට කිසිදු ගැටළුවක් නොමැතිව ඊළඟ පේළියේ තර්ක ඉදිරිපත් කළ හැකිය:

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

ශෛලමය මාර්ගෝපදේශය පවසන්නේ වරහන් සමඟ ව්‍යංග අඛණ්ඩතාව භාවිතා කිරීම වඩාත් සුදුසු බවයි, නමුත් මෙම විශේෂ අවස්ථාවෙහිදී ඔබේ ප්‍රකාශනය වටා වරහන් එකතු කිරීම බොහෝ විට වැරදි මාර්ගය විය හැකිය.

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

කියවීමේ හැකියාව වැඩි දියුණු කිරීම සඳහා ගණිත ians යින් සහ ඔවුන්ගේ ප්‍රකාශකයින් විසින් භාවිතා කරන ප්‍රතිවිරුද්ධ සම්මුතිය (ද්විමය මෙහෙයුම් බිඳ දැමීම සඳහා) PEP8 දැන් නිර්දේශ කරයි .

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

PEP8 වෙතින් : ද්විමය ක්‍රියාකරුට පෙර හෝ පසුව රේඛාවක් කැඩී යා යුතුද? :

ඩොනල්ඩ් නූත් සිය පරිගණක හා යතුරු ලියන මාලාවේ සාම්ප්‍රදායික රීතිය පැහැදිලි කරයි: “ඡේදයක් තුළ ඇති සූත්‍ර සෑම විටම ද්විමය මෙහෙයුම් හා සම්බන්ධතාවයන්ගෙන් බිඳී ගියද, පෙන්වන සූත්‍ර සෑම විටම ද්විමය මෙහෙයුම් වලට පෙර කැඩී යයි” [3].

ගණිතයේ සම්ප්‍රදාය අනුගමනය කිරීමෙන් සාමාන්‍යයෙන් කියවිය හැකි කේතයක් ලැබේ:

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

පයිතන් කේතයේ, සම්මුතිය දේශීයව ස්ථාවර වන තාක් කල්, ද්විමය ක්‍රියාකරුට පෙර හෝ පසුව කැඩීමට අවසර ඇත. නව කේත සඳහා නුත්ගේ විලාසය යෝජනා කෙරේ.

[3]: ඩොනල්ඩ් නූත්ගේ ද ටෙක්ස්බුක්, පිටු 195 සහ 196

රේඛාවක් අවසන් කිරීම සඳහා බැක්ස්ලෑෂ් භාවිතා කිරීමේ අන්තරාය වන්නේ බැක්ස්ලෑෂ් පසු සුදු අවකාශය එකතු කළහොත් (ඇත්ත වශයෙන්ම එය දැකීම ඉතා අසීරු ය), බැක්ස්ලෑෂ් තවදුරටත් ඔබ සිතූ දේ නොකරයි.

වැඩි විස්තර සඳහා පයිතන් අයිඩියම් සහ ප්‍රති-අයිඩියම් ( පයිතන් 2 හෝ පයිතන් 3 සඳහා) බලන්න.

එය දාන්න \ඔබගේ මාර්ගය අවසන් හෝ parens ප්රකාශයක් වැල ( .. ). IBM වෙතින් :

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

හෝ

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

වරහන් සහ වරහන් අතර රේඛා බිඳ දැමිය හැකිය. ඊට අමතරව, බැක්ස්ලෑෂ් අක්ෂරය \පැහැදිලිවම බිඳ දැමීම සඳහා රේඛාවකට එය එකතු කළ හැකිය :

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

අශ්වයාගේ මුඛයෙන්: පැහැදිලි රේඛාව සම්බන්ධ වීම

\පහත දැක්වෙන පරිදි බැක්ස්ලෑෂ් අක්ෂර ( ) භාවිතා කරමින් භෞතික රේඛා දෙකක් හෝ වැඩි ගණනක් තාර්කික රේඛාවලට සම්බන්ධ කළ හැකිය : භෞතික රේඛාවක් වචනාර්ථයෙන් හෝ විවරණයක කොටසක් නොවන බැක්ස්ලෑෂ් එකකින් අවසන් වූ විට, එය පහත දැක්වෙන කරුණු සමඟ එක් තාර්කික රේඛාවක් සාදයි , බැක්ස්ලෑෂ් සහ පහත දැක්වෙන පේළියේ අක්‍ෂරය මකා දැමීම. උදාහරණයක් වශයෙන්:

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

බැක්ස්ලෑෂ් එකකින් අවසන් වන රේඛාවකට අදහස් දැක්වීමක් කළ නොහැක. බැක්ස්ලෑෂ් එකක් දිගටම අදහස් දක්වන්නේ නැත. නූල් වචනාර්ථයන් හැර බැක්ස්ලෑෂ් ටෝකනයක් දිගටම කරගෙන යන්නේ නැත (එනම්, නූල් වචනාර්ථ හැර වෙනත් ටෝකන බැක්ස්ලෑෂ් භාවිතයෙන් භෞතික රේඛා හරහා බෙදිය නොහැක). වචනාර්ථයෙන් පිටත පේළියක බැක්ස්ලෑෂ් වෙනත් තැනක නීති විරෝධී ය.

එය පයිතොනික් ක්‍රමය නොවිය හැක, නමුත් මම සාමාන්‍යයෙන් SQL විමසුම් වැනි දිගු නූලක් ලිවීම සඳහා එක්වීමේ ශ්‍රිතය සහිත ලැයිස්තුවක් භාවිතා කරමි:

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

දිගු වචනාර්ථයක් නිසා ඔබේ රේඛාව බිඳ දැමීමට ඔබට අවශ්‍ය නම්, ඔබට එම නූල කැබලිවලට කැඩිය හැකිය:

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}"
)

හිච්හිකර්ගේ මාර්ගෝපදේශයේ සිට පයිතන් දක්වා ( රේඛීය අඛණ්ඩව ):

තාර්කික කේත රේඛාවක් පිළිගත් සීමාවට වඩා දිගු වූ විට, ඔබ එය භෞතික රේඛා කිහිපයකට බෙදිය යුතුය. පේළියේ අවසාන අක්‍ෂරය බැක්ස්ලෑෂ් එකක් නම් පයිතන් පරිවර්තකය අඛණ්ඩ රේඛාවලට සම්බන්ධ වේ. සමහර අවස්ථාවල මෙය ප්‍රයෝජනවත් වේ, නමුත් සාමාන්‍යයෙන් එහි අස්ථාවරත්වය නිසා එය වළක්වා ගත යුතුය: රේඛාවේ කෙළවරට එකතු කරන ලද සුදු අවකාශයක්, බැක්ස්ලෑෂ් පසු, කේතය බිඳ දමනු ඇති අතර අනපේක්ෂිත ප්‍රති .ල ලැබිය හැකිය.

වඩා හොඳ විසඳුමක් වන්නේ ඔබේ මූලද්‍රව්‍ය වටා වරහන් භාවිතා කිරීමයි. පේළියේ කෙළවරක නොවරදින වරහන් සමඟ වම්පස වරහන් වැසෙන තුරු පයිතන් පරිවර්තකය ඊළඟ පේළියට සම්බන්ධ වේ. කැරලි සහ හතරැස් වරහන් සඳහා එකම හැසිරීම දරයි.

කෙසේ වෙතත් , බොහෝ විට, දිගු තාර්කික රේඛාවක් බෙදීමට සිදුවීම ඔබ එකවර ඕනෑවට වඩා දේවල් කිරීමට උත්සාහ කරන බවට ලකුණක් වන අතර එය කියවීමට බාධාවක් විය හැකිය.

එසේ පැවසීමෙන් පසු, බහු ආනයන සලකා බලන උදාහරණයක් මෙන්න ( රේඛීය සීමාවන් ඉක්මවා යන විට , PEP-8 මත අර්ථ දක්වා ඇත ), පොදුවේ නූල් සඳහා ද අදාළ වේ:

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

රේඛීය අඛණ්ඩ ක්‍රියාකරු භාවිතා කරන්න, එනම් "\"

උදාහරණ:

# 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