Uzun çok satırlı bir dize oluşturmanın pythonic yolu

Çok uzun bir sorgum var. Python'da birkaç satıra bölmek istiyorum. JavaScript'te yapmanın bir yolu birkaç cümle kullanmak ve bunları bir +operatörle birleştirmektir (biliyorum, belki de bunu yapmanın en etkili yolu değildir, ancak bu aşamadaki performansla gerçekten ilgilenmiyorum, sadece kod okunabilirliği) . Misal:

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

Python'da benzer bir şey yapmayı denedim, ama işe yaramadı, bu yüzden \uzun dizeyi ayırırdım. Ancak, bunu yapmanın tek / en iyi / pythonicest yolu olup olmadığından emin değilim. Tuhaf görünüyor. Gerçek kod:

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

Çok satırlı dizelerden mi bahsediyorsunuz? Kolay, başlatmak ve bitirmek için üçlü tırnak kullanın.

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

Tek tırnak işaretleri de kullanabilirsiniz (3 tanesi başlangıçta ve bitişte elbette) ve elde edilen dizeye sdiğer dizeler gibi davranabilirsiniz.

NOT : Herhangi bir dizede olduğu gibi, başlangıç ​​ve bitiş tırnak işaretleri arasındaki herhangi bir şey dizenin bir parçası haline gelir, bu nedenle bu örneğin önünde bir boşluk vardır (@ root45 tarafından belirtildiği gibi). Bu dize hem boşlukları hem de yeni satırları içerecektir.

yani ,:

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

Son olarak, Python'da şöyle uzun çizgiler de yapılabilir:

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

hangi değil herhangi bir ekstra boşluk veya yeni satır (bu boşlukları atlayarak etkisi neden olacağını gösteren kasıtlı bir örneğidir) şunlardır:

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

Virgül gerekmez, birleştirilecek dizeleri bir parantez içine yerleştirin ve gerekli boşlukları ve satırsonlarını dikkate aldığınızdan emin olun.

Çok satırlı bir dize istemiyorsanız, ancak uzun bir tek satır dizeniz varsa, parantez kullanabilirsiniz, dize segmentleri arasında virgül eklemediğinizden emin olun, o zaman bir demet olacaktır.

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)

Yaptığınız gibi bir SQL deyiminde, çok satırlı dizeler de iyi olur. Ancak, çok satırlı bir dizenin içereceği fazladan boşluk sorun yaratırsa, bu istediğinizi elde etmek için iyi bir yol olacaktır.

\Benim için eserleri kırmak . İşte bir örnek:

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

Kendimi bununla mutlu buldum:

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

Uzun dizeler oluştururken, genellikle bir SQL sorgusu oluşturmak gibi bir şey yapıyorsunuz, bu durumda bu en iyisi:

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

Levon'un önerdiği şey iyidir, ancak hatalara karşı savunmasız olabilir:

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

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

"" "Gösterimini kullanırken değişkenleri birleştirebilirsiniz:

foo = '1234'

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

EDIT: adlandırılmış params ve .format () ile daha iyi bir yol bulundu:

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)

Bu yaklaşım şunları kullanır:

• ilk satır besleme önlemek için sadece bir ters eğik çizgi
• Üçlü tırnaklı dize kullanarak neredeyse hiç noktalama işareti yok
• textwrap inspect modülünü kullanarak yerel girintileri yok eder
• account_idve def_iddeğişkenleri için python 3.6 biçimli dize enterpolasyonunu ('f') kullanır .

Bu şekilde benim için en pitonik görünüyor.

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

Güncelleme : 1/29/2019 @ ShadowRanger'ın önerisini inspect.cleandocyerine kullanıntextwrap.dedent

Python> = 3.6'da Biçimlendirilmiş dize değişmezlerini (f dize) kullanabilirsiniz

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

Örneğin:

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'

koşulun değeri bir dize olması gerekiyorsa şunları yapabilirsiniz:

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

Buradatextwrap.dedent açıklandığı gibi uzun dizeler için en iyisini buluyorum :

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

Diğerleri parantez yönteminden daha önce bahsetmişlerdir, ancak bunu parantezlerle eklemek istiyorum, satır içi yorumlara izin veriliyor.

Her parça hakkında yorum:

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

Devamtan sonra yoruma izin verilmiyor:

Ters eğik çizgi devamları ( \) kullanılırken yorumlara izin verilmez. Bir SyntaxError: unexpected character after line continuation characterhata mesajı alırsınız .

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

Regex dizeleri için daha iyi yorumlar:

Https://docs.python.org/3/library/re.html#re.VERBOSE örneğinden ,

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)

Şahsen ben Python, özellikle Python sqlite3 modülünü kullanırken ham SQL sorguları yazmak için en iyi (basit, güvenli ve Pythonic) yolu bulmak :

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

Artıları

• Düzgün ve basit kod (Pitonik!)
• SQL enjeksiyonundan güvenli
• Hem Python 2 hem de Python 3 ile uyumlu (sonuçta Pythonic)
• Dize birleştirmesi gerekmez
• Her satırın en sağdaki karakterinin boşluk olduğundan emin olmanıza gerek yok

Eksileri

• Sorgudaki değişkenler ?yer tutucu ile değiştirildiğinden, sorguda çok fazla ?olduğunda hangi Python değişkeniyle değiştirileceğini takip etmek biraz zor olabilir .

Genellikle böyle bir şey kullanırım:

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

Her satırdaki can sıkıcı boşlukları kaldırmak istiyorsanız, aşağıdakileri yapabilirsiniz:

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

Gerçek kod "satırları" sonunda boşlukları eksik, işe olmamalıdır (örn: role.descr as roleFROM...)

Çok satırlı dize için üçlü tırnaklar vardır:

string = """line
  line2
  line3"""

Satır kesmelerini ve fazladan boşlukları içerecektir, ancak SQL için bu bir sorun değildir.

Ayrıca sql-deyimini ayrı bir dosyaya yerleştirebilir action.sqlve py dosyasına

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

Böylece sql-ifadeleri python kodundan ayrılacaktır. Sql deyiminde python'dan doldurulması gereken parametreler varsa, dize biçimlendirmesini kullanabilirsiniz (% s veya {field} gibi)

"À la" Scala yolu (ama bence OQ'nun talep ettiği en pitonik yol):

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

Atlama çizgileri olmadan son str istiyorsanız, sadece \nikinci değiştirmenin ilk argümanının başına koyun :

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

Not: "... şablonlar" arasındaki beyaz çizgi. ve "Ayrıca, ..." için bir boşluk gerekir |.

tl; dr: Kullanım """\ve """dizeyi sarmak için olduğu gibi,

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

Gönderen resmi piton belgelerinde :

Dize değişmezleri birden çok satıra yayılabilir. Bunun bir yolu üçlü tırnak kullanmaktır: "" "..." "" veya "" ... "". Satır sonu otomatik olarak dizeye dahil edilir, ancak satırın sonuna bir \ ekleyerek bunu önlemek mümkündür. Aşağıdaki örnek:

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

aşağıdaki çıktıyı üretir (ilk satırsonunun dahil olmadığını unutmayın):

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

Hey bu şekilde çalıştığını umuyoruz, bu formatta olduğu gibi, bu özellik hakkında başarılı bir şekilde sorduğunuz gibi sürekli bir satır döndürecektir.

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

Karmaşık SQL Sorguları oluşturmak için özyinelemeli bir işlev kullanın. Bu teknik genellikle kod okunabilirliğini korurken büyük dizeler oluşturmak için kullanılabilir.

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

Not: Gerekirse SQL sorgularını güzel yazdırmak için harika python-sqlparse kütüphanesine bir göz atın. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Kod (örn. Değişken) girintili olduğunda ve çıkış dizesi bir satır (satırsonu yok) olmalıdır daha okunabilir olduğunu düşünüyorum başka bir seçenek:

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 

Üçlü tırnak işareti kullanın. İnsanlar bunları, programların başlangıcında, amaçlarını ve yaratılışıyla ilgili diğer bilgileri açıklamak için doktrinler oluşturmak için kullanırlar. İnsanlar bunları fonksiyonların amacını ve uygulamasını açıklamak için fonksiyonlarda kullanırlar. Misal:

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

Bu yaklaşımı seviyorum çünkü okumayı ayrıcalıklı kılıyor. Uzun iplerimizin olduğu durumlarda hiçbir yolu yoktur! Girinti düzeyine bağlı olarak ve hala satır başına 80 karakterle sınırlıdır ... Şey ... Başka bir şey söylemeye gerek yok. Bana göre python stil kılavuzları hala çok belirsiz. @Eero Aaltonen yaklaşımını kullandım çünkü okuma ve sağduyu ayrıcalıklı. Stil rehberlerinin bize yardım etmesi ve hayatlarımızı dağınık hale getirmemesi gerektiğini anlıyorum. Teşekkürler!

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

Gönderen resmi piton belgelerinde :

Dize değişmezleri birden çok satıra yayılabilir. Bunun bir yolu üçlü tırnak kullanmaktır: "" "..." "" veya "" ... "". Satır sonu otomatik olarak dizeye dahil edilir, ancak satırın sonuna bir \ ekleyerek bunu önlemek mümkündür. Aşağıdaki örnek:

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

aşağıdaki çıktıyı üretir (ilk satırsonunun dahil olmadığını unutmayın):

Bir diktenin içindeki uzun bir dizeyi tanımlamak , satırsonlarını tutmak, ancak boşlukları atlamak için , dizeyi şu şekilde bir sabitte tanımladım:

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

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

Python'daki uzun dizelere genel bir yaklaşım olarak, üçlü tırnak kullanabilirsiniz splitve 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())

Çıktı:

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

OP'nin bir SQL sorgusuyla ilgili sorusu ile ilgili olarak, aşağıdaki cevap, SQL sorguları oluşturmaya yönelik bu yaklaşımın doğruluğunu göz ardı eder ve ek içe aktarma olmadan yalnızca uzun dizeleri okunabilir ve estetik bir şekilde oluşturmaya odaklanır. Bunun gerektirdiği hesaplama yükünü de göz ardı eder.

Üçlü tırnaklar kullanarak uzun ve okunabilir bir dize oluştururuz, daha sonra split()boşlukları sıyırıp sonra tekrar birleştirerek bir listeye ayrılırız ' '.join(). Son olarak şu format()komutu kullanarak değişkenleri ekliyoruz:

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)

üretir:

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

Edit: Bu yaklaşım PEP8 ile uyumlu değil ama bazen yararlı buluyorum

Genellikle, çok satırlı yorum / string için listve kullanıyorum 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' (yeni satır) veya ' ,' (virgül) veya ' gibi tüm bu liste öğelerine katılmak için herhangi bir dizeyi kullanabilirsiniz ' (boşluk)

Şerefe .. !!