เยื้องที่เหมาะสมสำหรับ Python หลายสาย

การเยื้องที่เหมาะสมสำหรับ Python หลายสายภายในฟังก์ชันคืออะไร

    def method():
        string = """line one
line two
line three"""

หรือ

    def method():
        string = """line one
        line two
        line three"""

หรืออย่างอื่น?

มันดูแปลก ๆ ที่มีสตริงที่ห้อยอยู่ภายนอกฟังก์ชั่นในตัวอย่างแรก

คุณอาจต้องการที่จะสอดคล้องกับ """

def foo():
    string = """line one
             line two
             line three"""

เนื่องจากการขึ้นบรรทัดใหม่และช่องว่างรวมอยู่ในสตริงนั้นคุณจะต้องทำการประมวลผลภายหลัง หากคุณไม่ต้องการทำเช่นนั้นและมีข้อความจำนวนมากคุณอาจต้องการเก็บแยกไว้ในไฟล์ข้อความ หากไฟล์ข้อความทำงานได้ไม่ดีสำหรับแอปพลิเคชันของคุณและคุณไม่ต้องการประมวลผลภายหลังฉันอาจไปด้วย

def foo():
    string = ("this is an "
              "implicitly joined "
              "string")

หากคุณต้องการประมวลผลสตริงหลายบรรทัดเพื่อตัดส่วนที่ไม่ต้องการออกคุณควรพิจารณาtextwrapโมดูลหรือเทคนิคสำหรับการประมวลผลเอกสารหลังการประมวลผลที่แสดงในPEP 257 :

def trim(docstring):
    if not docstring:
        return ''
    # Convert tabs to spaces (following the normal Python rules)
    # and split into a list of lines:
    lines = docstring.expandtabs().splitlines()
    # Determine minimum indentation (first line doesn't count):
    indent = sys.maxint
    for line in lines[1:]:
        stripped = line.lstrip()
        if stripped:
            indent = min(indent, len(line) - len(stripped))
    # Remove indentation (first line is special):
    trimmed = [lines[0].strip()]
    if indent < sys.maxint:
        for line in lines[1:]:
            trimmed.append(line[indent:].rstrip())
    # Strip off trailing and leading blank lines:
    while trimmed and not trimmed[-1]:
        trimmed.pop()
    while trimmed and not trimmed[0]:
        trimmed.pop(0)
    # Return a single string:
    return '\n'.join(trimmed)

textwrap.dedentฟังก์ชั่นช่วยให้หนึ่งในการเริ่มต้นด้วยการเยื้องที่ถูกต้องในแหล่งที่มาและจากนั้นตัดมันออกจากข้อความก่อนการใช้งาน

การแลกเปลี่ยนตามที่ระบุไว้โดยคนอื่น ๆ ก็คือว่านี่คือการเรียกฟังก์ชั่นพิเศษเกี่ยวกับตัวอักษร; พิจารณาสิ่งนี้เมื่อตัดสินใจว่าจะวางตัวอักษรเหล่านี้ในรหัสของคุณที่ใด

import textwrap

def frobnicate(param):
    """ Frobnicate the scrognate param.

        The Weebly-Ruckford algorithm is employed to frobnicate
        the scrognate to within an inch of its life.

        """
    prepare_the_comfy_chair(param)
    log_message = textwrap.dedent("""\
            Prepare to frobnicate:
            Here it comes...
                Any moment now.
            And: Frobnicate!""")
    weebly(param, log_message)
    ruckford(param)

การติดตาม\ในสัญลักษณข้อความบันทึกคือเพื่อให้แน่ใจว่าตัวแบ่งบรรทัดไม่ได้อยู่ในสัญพจน์ ด้วยวิธีนี้ตัวอักษรไม่ได้เริ่มต้นด้วยบรรทัดว่างเปล่าและเริ่มต้นด้วยบรรทัดเต็มถัดไปแทน

ค่าส่งคืนจากtextwrap.dedentคือสตริงอินพุตที่มีการเยื้องช่องว่างนำหน้าทั้งหมดที่นำออกในแต่ละบรรทัดของสตริง ดังนั้นlog_messageค่าข้างต้นจะเป็น:

Prepare to frobnicate:
Here it comes...
    Any moment now.
And: Frobnicate!

ใช้inspect.cleandocอย่างนั้น:

def method():
    string = inspect.cleandoc("""
        line one
        line two
        line three""")

เยื้องสัมพัทธ์จะถูกเก็บรักษาไว้ตามที่คาดไว้ ในฐานะที่เป็นความเห็นtextwrap.dedentด้านล่างหากคุณต้องการที่จะเก็บก่อนบรรทัดว่างใช้ อย่างไรก็ตามนั่นก็ยังทำให้ตัวแบ่งบรรทัดแรก

หมายเหตุ:เป็นการดีที่จะเยื้องบล็อกโลจิคัลของโค้ดภายใต้บริบทที่เกี่ยวข้องเพื่อทำให้โครงสร้างชัดเจนขึ้น stringเช่นสตริงหลายสายที่อยู่ในตัวแปร

ตัวเลือกหนึ่งที่ดูเหมือนว่าจะหายไปจากคำตอบอื่น ๆ (เฉพาะที่กล่าวถึงอย่างลึกลงไปในความคิดเห็นโดย naxa) คือต่อไปนี้:

def foo():
    string = ("line one\n"          # Add \n in the string
              "line two"  "\n"      # Add "\n" after the string
              "line three\n")

สิ่งนี้จะช่วยให้การจัดตำแหน่งที่เหมาะสมเข้าร่วมบรรทัดโดยปริยายและยังคงให้การเปลี่ยนบรรทัดซึ่งสำหรับฉันเป็นหนึ่งในเหตุผลที่ฉันต้องการใช้สตริงหลายบรรทัดอย่างไรก็ตาม

ไม่จำเป็นต้องมีการประมวลผลภายหลัง แต่คุณต้องเพิ่มด้วยตนเอง\nณ ที่ใดก็ตามที่คุณต้องการให้บรรทัดสิ้นสุด ทั้งอินไลน์หรือเป็นสตริงแยกต่างหากหลังจาก หลังนี้ง่ายต่อการคัดลอกวาง

ตัวเลือกเพิ่มเติม ใน Ipython ที่เปิดใช้งาน pylab แล้วผู้อุทิศจะอยู่ในเนมสเปซแล้ว ฉันตรวจสอบและมาจาก matplotlib หรือสามารถนำเข้าด้วย:

from matplotlib.cbook import dedent

ในเอกสารมันระบุว่ามันเร็วกว่า textwrap เทียบเท่าหนึ่งและในการทดสอบของฉันใน ipython แน่นอนโดยเฉลี่ย 3 ครั้งด้วยการทดสอบอย่างรวดเร็วของฉัน นอกจากนี้ยังมีประโยชน์ที่จะทิ้งบรรทัดว่างนำหน้าซึ่งจะทำให้คุณมีความยืดหยุ่นในการสร้างสตริง:

"""
line 1 of string
line 2 of string
"""

"""\
line 1 of string
line 2 of string
"""

"""line 1 of string
line 2 of string
"""

การใช้ matplotlib ที่อุทิศให้กับตัวอย่างทั้งสามนี้จะให้ผลลัพธ์ที่เหมือนกัน ฟังก์ชั่นการอุทิศ textwrap จะมีบรรทัดว่างนำหน้าด้วยตัวอย่างที่ 1

ข้อเสียที่เห็นได้ชัดคือ textwrap อยู่ในไลบรารีมาตรฐานในขณะที่ matplotlib เป็นโมดูลภายนอก

การแลกเปลี่ยนบางอย่างที่นี่ ... ฟังก์ชั่นพิเศษทำให้โค้ดของคุณสามารถอ่านได้มากขึ้นเมื่อมีการกำหนดสตริง แต่ต้องการการประมวลผลในภายหลังเพื่อรับสตริงในรูปแบบที่ใช้งานได้ ในเอกสารมีความชัดเจนว่าคุณควรใช้การเยื้องที่ถูกต้องเนื่องจากการใช้งานส่วนใหญ่ของ docstring จะทำการประมวลผลที่จำเป็น

เมื่อฉันต้องการสตริงที่ไม่ยาวในรหัสของฉันฉันพบรหัสน่าเกลียดดังต่อไปนี้ที่ฉันปล่อยให้สตริงที่ยาวหลุดออกจากการเยื้อง ล้มเหลวอย่างแน่นอนใน "ความสวยงามดีกว่าน่าเกลียด" แต่ใคร ๆ ก็สามารถแย้งได้ว่ามันง่ายกว่าและชัดเจนกว่าทางเลือกที่อุทิศตน

def example():
    long_string = '''\
Lorem ipsum dolor sit amet, consectetur adipisicing
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.\
'''
    return long_string

print example()

หากคุณต้องการวิธีแก้ปัญหาที่ง่ายและรวดเร็วและช่วยตัวเองจากการพิมพ์บรรทัดใหม่คุณสามารถเลือกรายการแทนเช่น:

def func(*args, **kwargs):
    string = '\n'.join([
        'first line of very long string and',
        'second line of the same long thing and',
        'third line of ...',
        'and so on...',
        ])
    print(string)
    return

ฉันชอบ

    def method():
        string = \
"""\
line one
line two
line three\
"""

หรือ

    def method():
        string = """\
line one
line two
line three\
"""

สองเซ็นต์ของฉันหนีออกจากจุดสิ้นสุดเพื่อรับการเยื้อง:

def foo():
    return "{}\n"\
           "freq: {}\n"\
           "temp: {}\n".format( time, freq, temp )

ฉันมาที่นี่เพื่อค้นหา 1-liner ง่าย ๆ เพื่อลบ / แก้ไขระดับการระบุของ docstring สำหรับการพิมพ์โดยไม่ทำให้ดูสกปรกเช่นโดยการทำให้ "อยู่นอกฟังก์ชัน" ภายในสคริปต์

นี่คือสิ่งที่ฉันทำ:

import string
def myfunction():

    """
    line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print str(string.replace(myfunction.__doc__,'\n\t','\n'))[1:] 

เห็นได้ชัดว่าหากคุณเยื้องด้วยช่องว่าง (เช่น 4) แทนที่จะใช้ปุ่มแท็บให้ใช้สิ่งนี้แทน:

print str(string.replace(myfunction.__doc__,'\n    ','\n'))[1:]

และคุณไม่จำเป็นต้องลบอักขระแรกหากคุณต้องการให้เอกสารของคุณมีหน้าตาแบบนี้แทน:

    """line 1 of docstring
    line 2 of docstring
    line 3 of docstring"""

print string.replace(myfunction.__doc__,'\n\t','\n') 

ตัวเลือกแรกคือตัวเลือกที่ดี - รวมการเยื้อง มันอยู่ในรูปแบบหลาม - ให้อ่านง่ายสำหรับรหัส

วิธีแสดงอย่างถูกต้อง:

print string.lstrip()

ขึ้นอยู่กับว่าคุณต้องการให้ข้อความแสดงผลอย่างไร หากคุณต้องการให้จัดแนวซ้ายทั้งหมดให้จัดรูปแบบเหมือนในตัวอย่างแรกหรือวนซ้ำตามบรรทัดที่เหลือไว้เพื่อตัดพื้นที่ทั้งหมด

สำหรับสตริงที่คุณสามารถประมวลผลสตริงได้ สำหรับเอกสารคุณต้องดำเนินการฟังก์ชั่นแทน นี่คือวิธีแก้ปัญหาสำหรับทั้งสองที่ยังคงสามารถอ่านได้

class Lstrip(object):
    def __rsub__(self, other):
        import re
        return re.sub('^\n', '', re.sub('\n$', '', re.sub('\n\s+', '\n', other)))

msg = '''
      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 consequat. Duis aute irure dolor in reprehenderit in voluptate
      velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
      cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
      est laborum.
      ''' - Lstrip()

print msg

def lstrip_docstring(func):
    func.__doc__ = func.__doc__ - Lstrip()
    return func

@lstrip_docstring
def foo():
    '''
    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 consequat. Duis aute irure dolor in reprehenderit in voluptate
    velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat
    cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id
    est laborum.
    '''
    pass


print foo.__doc__

ฉันมีปัญหาที่คล้ายกันรหัสไม่สามารถอ่านได้โดยใช้ multilines ฉันออกมาพร้อมกับสิ่งที่ชอบ

print("""aaaa
"""   """bbb
""")

ใช่ที่จุดเริ่มต้นอาจดูแย่ แต่ไวยากรณ์ที่ฝังอยู่นั้นค่อนข้างซับซ้อนและการเพิ่มบางอย่างในตอนท้าย (เช่น '\ n "') ไม่ใช่วิธีแก้ปัญหา

คุณสามารถใช้ฟังก์ชั่นtrim_indent

import re


def trim_indent(s: str):
    s = re.sub(r'^\n+', '', s)
    s = re.sub(r'\n+$', '', s)
    spaces = re.findall(r'^ +', s, flags=re.MULTILINE)
    if len(spaces) > 0 and len(re.findall(r'^[^\s]', s, flags=re.MULTILINE)) == 0:
        s = re.sub(r'^%s' % (min(spaces)), '', s, flags=re.MULTILINE)
    return s


print(trim_indent("""


        line one
            line two
                line three
            line two
        line one


"""))

ผลลัพธ์:

"""
line one
    line two
        line three
    line two
line one
"""