Indentasi yang tepat untuk string multiline Python

Apa lekukan yang tepat untuk string multiline Python dalam suatu fungsi?

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

atau

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

atau sesuatu yang lain?

Tampaknya agak aneh memiliki string yang tergantung di luar fungsi pada contoh pertama.

Anda mungkin ingin berbaris dengan """

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

Karena baris baru dan spasi termasuk dalam string itu sendiri, Anda harus mempostingnya. Jika Anda tidak ingin melakukan itu dan Anda memiliki banyak teks, Anda mungkin ingin menyimpannya secara terpisah dalam file teks. Jika file teks tidak berfungsi dengan baik untuk aplikasi Anda dan Anda tidak ingin memposting, saya mungkin akan menggunakannya

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

Jika Anda ingin memposting proses multi-string untuk memangkas bagian-bagian yang tidak Anda butuhkan, Anda harus mempertimbangkan textwrapmodul atau teknik untuk pemrosesan pascaproses yang disajikan dalam 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)

The textwrap.dedentFungsi memungkinkan seseorang untuk memulai dengan lekukan yang benar dalam sumber , dan kemudian strip itu dari teks sebelum digunakan.

Pertukarannya, sebagaimana dicatat oleh beberapa orang lain, adalah bahwa ini adalah panggilan fungsi tambahan pada literal; memperhitungkan ini ketika memutuskan di mana menempatkan literal ini dalam kode Anda.

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)

Trailing \dalam literal pesan log adalah untuk memastikan bahwa baris tidak ada dalam literal; dengan cara itu, literal tidak dimulai dengan baris kosong, dan sebaliknya mulai dengan baris penuh berikutnya.

Nilai kembali dari textwrap.dedentadalah string input dengan semua indentasi spasi putih terkemuka yang umum dihapus pada setiap baris string. Jadi nilai di atas log_messageadalah:

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

Gunakan inspect.cleandocseperti ini:

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

Lekukan relatif akan dipertahankan seperti yang diharapkan. Seperti yang dikomentari di bawah ini, jika Anda ingin tetap menggunakan baris sebelumnya, gunakan textwrap.dedent. Namun itu juga menjaga jeda baris pertama.

Catatan: Ini praktik yang baik untuk membuat blok kode logis di bawah konteks terkait untuk memperjelas struktur. Misalnya string multi-line milik variabel string.

Satu opsi yang tampaknya hilang dari jawaban lain (hanya disebutkan jauh di dalam komentar oleh naxa) adalah sebagai berikut:

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

Ini akan memungkinkan penyelarasan yang tepat, bergabung dengan garis secara implisit, dan masih menjaga pergeseran garis yang, bagi saya, adalah salah satu alasan mengapa saya ingin tetap menggunakan string multiline.

Itu tidak memerlukan postprocessing apa pun, tetapi Anda perlu menambahkan secara manual \ndi tempat tertentu yang Anda inginkan untuk mengakhiri garis. Baik sebaris atau sebagai string terpisah setelah. Yang terakhir lebih mudah untuk di-copy-paste.

Beberapa opsi lagi. Di Ipython dengan pylab diaktifkan, dedent sudah ada di namespace. Saya memeriksa dan itu dari matplotlib. Atau dapat diimpor dengan:

from matplotlib.cbook import dedent

Dalam dokumentasi itu menyatakan bahwa itu lebih cepat daripada yang setara dengan textwrap dan dalam tes saya di ipython memang 3 kali lebih cepat rata-rata dengan tes cepat saya. Ini juga memiliki keuntungan bahwa ia membuang setiap baris kosong terkemuka yang memungkinkan Anda untuk fleksibel dalam cara Anda membangun string:

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

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

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

Menggunakan dedikasi matplotlib pada ketiga contoh ini akan memberikan hasil yang masuk akal yang sama. Fungsi deduksi tulisan teks akan memiliki baris kosong terkemuka dengan contoh 1.

Kerugian yang jelas adalah bahwa textwrap di perpustakaan standar sementara matplotlib adalah modul eksternal.

Beberapa tradeoffs di sini ... fungsi dedent membuat kode Anda lebih mudah dibaca di mana string didefinisikan, tetapi membutuhkan pemrosesan nanti untuk mendapatkan string dalam format yang dapat digunakan. Dalam dokumentasi jelas bahwa Anda harus menggunakan indentasi yang benar karena sebagian besar penggunaan docstring akan melakukan pemrosesan yang diperlukan.

Ketika saya membutuhkan string yang tidak panjang dalam kode saya, saya menemukan kode jelek berikut ini di mana saya membiarkan string panjang keluar dari lekukan terlampir. Jelas gagal pada "Cantik lebih baik daripada jelek.", Tetapi orang bisa berpendapat bahwa itu lebih sederhana dan lebih eksplisit daripada alternatif yang ditentukan.

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

Jika Anda menginginkan solusi cepat & mudah dan menyelamatkan diri dari mengetik baris baru, Anda bisa memilih daftar, misalnya:

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

saya lebih memilih

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

atau

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

Dua sen saya, lepas dari garis akhir untuk mendapatkan indentasi:

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

Saya datang ke sini mencari 1-liner sederhana untuk menghapus / memperbaiki tingkat identifikasi dokumen untuk dicetak, tanpa membuatnya terlihat berantakan , misalnya dengan membuatnya "menggantung fungsi" di dalam skrip.

Inilah yang akhirnya saya lakukan:

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:] 

Jelas, jika Anda membuat indentasi dengan spasi (mis. 4) alih-alih tombol tab gunakan sesuatu seperti ini sebagai gantinya:

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

Dan Anda tidak perlu menghapus karakter pertama jika Anda suka dokumen Anda terlihat seperti ini sebagai gantinya:

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

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

Opsi pertama adalah yang baik - dengan lekukan disertakan. Itu dalam gaya python - memberikan keterbacaan untuk kode.

Untuk menampilkannya dengan benar:

print string.lstrip()

Tergantung bagaimana Anda ingin teks ditampilkan. Jika Anda ingin semuanya disejajarkan dengan kiri maka formatlah seperti pada cuplikan pertama atau beralih melalui garis-garis kiri-memangkas semua ruang.

Untuk string, Anda bisa setelah memproses string. Untuk dokumentasi Anda perlu setelah memproses fungsi sebagai gantinya. Inilah solusi untuk keduanya yang masih bisa dibaca.

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__

Saya mengalami masalah yang sama, kode menjadi sangat tidak dapat dibaca menggunakan multilines, saya keluar dengan sesuatu seperti

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

ya, pada awalnya bisa terlihat mengerikan tetapi sintaks yang tertanam cukup kompleks dan menambahkan sesuatu di akhir (seperti '\ n "') bukan solusi

Anda dapat menggunakan fungsi ini 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


"""))

Hasil:

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