Manière pythonique de créer une longue chaîne multi-ligne

J'ai une très longue requête. Je voudrais le diviser en plusieurs lignes en Python. Une façon de le faire en JavaScript serait d'utiliser plusieurs phrases et de les joindre à un +opérateur (je sais, ce n'est peut-être pas le moyen le plus efficace de le faire, mais je ne suis pas vraiment préoccupé par les performances à ce stade, juste la lisibilité du code) . Exemple:

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

J'ai essayé de faire quelque chose de similaire en Python, mais cela n'a pas fonctionné, j'ai donc l'habitude \de diviser la longue chaîne. Cependant, je ne suis pas sûr que ce soit la seule / meilleure / meilleure façon de le faire. Ça a l'air maladroit. Code réel:

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

Parlez-vous de chaînes multi-lignes? Facile, utilisez des guillemets triples pour les démarrer et les terminer.

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

Vous pouvez également utiliser des guillemets simples (3 d'entre eux bien sûr au début et à la fin) et traiter la chaîne résultante scomme n'importe quelle autre chaîne.

REMARQUE : comme pour toute chaîne, tout ce qui se trouve entre les guillemets de début et de fin fait partie de la chaîne, donc cet exemple a un blanc de début (comme indiqué par @ root45). Cette chaîne contiendra également des espaces et des sauts de ligne.

C'est à dire,:

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

Enfin, on peut également construire de longues lignes en Python comme ceci:

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

qui ne comprend aucun espace supplémentaire ou (ce qui est des sauts de ligne un exemple montrant délibérément ce que l'effet de sauter des blancs entraînera):

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

Aucune virgule n'est requise, placez simplement les chaînes à assembler dans une paire de parenthèses et assurez-vous de prendre en compte les blancs et les nouvelles lignes nécessaires.

Si vous ne voulez pas de chaîne multiligne mais que vous n'avez qu'une longue chaîne à une seule ligne, vous pouvez utiliser des parenthèses, assurez-vous simplement de ne pas inclure de virgules entre les segments de chaîne, ce sera un tuple.

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)

Dans une instruction SQL comme celle que vous construisez, les chaînes multilignes conviendraient également. Mais si l'espace blanc supplémentaire qu'une chaîne multiligne contiendrait serait un problème, alors ce serait un bon moyen de réaliser ce que vous voulez.

Briser les lignes par les \œuvres pour moi. Voici un exemple:

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

Je me suis contenté de celui-ci:

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

Je trouve que lors de la construction de longues chaînes, vous faites généralement quelque chose comme la construction d'une requête SQL, auquel cas c'est le meilleur:

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

Ce que Levon a suggéré est bon, mais pourrait être vulnérable aux erreurs:

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

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

Vous pouvez également concaténer des variables lorsque vous utilisez la notation "" ":

foo = '1234'

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

EDIT: Trouvé une meilleure façon, avec des paramètres nommés et .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)

Cette approche utilise:

• une seule barre oblique inverse pour éviter un saut de ligne initial
• presque aucune ponctuation interne en utilisant une chaîne entre guillemets triples
• supprime l'indentation locale à l'aide du module textwrap inspect
• utilise l'interpolation de chaîne au format python 3.6 ('f') pour les variables account_idet def_id.

De cette façon, cela me semble le plus pythonique.

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

Mise à jour : 29/01/2019 Incorporez la suggestion de @ ShadowRanger à utiliser inspect.cleandocau lieu detextwrap.dedent

En Python> = 3.6, vous pouvez utiliser des littéraux de chaîne formatés (chaîne f)

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

Par exemple:

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'

si la valeur de condition doit être une chaîne, vous pouvez faire comme ceci:

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

Je trouve textwrap.dedentle meilleur pour les cordes longues comme décrit ici :

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

D'autres ont déjà mentionné la méthode des parenthèses, mais j'aimerais ajouter qu'avec les parenthèses, les commentaires en ligne sont autorisés.

Commentez chaque fragment:

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

Commentaire non autorisé après la suite:

Lors de l'utilisation de continuations de ligne de barre oblique inverse ( \), les commentaires ne sont pas autorisés. Vous recevrez une SyntaxError: unexpected character after line continuation charactererreur.

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

Meilleurs commentaires pour les chaînes Regex:

Basé sur l'exemple de 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)

Personnellement, je trouve que ce qui suit est le meilleur moyen (simple, sûr et Pythonic) d'écrire des requêtes SQL brutes en Python, en particulier lors de l'utilisation du module sqlite3 de Python :

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

Avantages

• Code soigné et simple (Pythonic!)
• À l'abri de l'injection SQL
• Compatible avec Python 2 et Python 3 (c'est Pythonic après tout)
• Aucune concaténation de chaîne requise
• Pas besoin de s'assurer que le caractère le plus à droite de chaque ligne est un espace

Les inconvénients

• Étant donné que les variables de la requête sont remplacées par l' ?espace réservé, il peut devenir un peu difficile de savoir laquelle ?doit être remplacée par quelle variable Python lorsqu'il y en a beaucoup dans la requête.

J'utilise habituellement quelque chose comme ça:

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

Si vous souhaitez supprimer les espaces vides ennuyeux dans chaque ligne, vous pouvez procéder comme suit:

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

Votre code actuel ne doit pas travailler, il vous manque espaces à l'extrémité des « lignes » (par exemple: role.descr as roleFROM...)

Il existe des guillemets triples pour la chaîne multiligne:

string = """line
  line2
  line3"""

Il contiendra les sauts de ligne et les espaces supplémentaires, mais pour SQL ce n'est pas un problème.

Vous pouvez également placer l'instruction sql dans un fichier séparé action.sqlet la charger dans le fichier py avec

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

Ainsi, les instructions sql seront séparées du code python. S'il y a des paramètres dans l'instruction sql qui doivent être remplis à partir de python, vous pouvez utiliser le formatage de chaînes (comme% s ou {field})

"À la" façon Scala (mais je pense que c'est la façon la plus pythonique comme OQ l'exige):

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

Si vous voulez une chaîne finale sans lignes de saut, mettez simplement \nau début du premier argument du deuxième remplacement:

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

Remarque: la ligne blanche entre "... modèles". et "Aussi, ..." nécessite un espace après le |.

tl; dr: utilisez """\et """pour envelopper la chaîne , comme dans

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

De la documentation officielle de python :

Les littéraux de chaîne peuvent s'étendre sur plusieurs lignes. Une façon consiste à utiliser des guillemets triples: "" "..." "" ou '' '...' ''. La fin des lignes est automatiquement incluse dans la chaîne, mais il est possible d'empêcher cela en ajoutant un \ à la fin de la ligne. L'exemple suivant:

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

produit la sortie suivante (notez que la nouvelle ligne initiale n'est pas incluse):

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

Hé, essayez quelque chose comme ça, j'espère que cela fonctionne, comme dans ce format, il vous renverra une ligne continue comme si vous vous êtes bien renseigné sur cette propriété.

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

J'utilise une fonction récursive pour construire des requêtes SQL complexes. Cette technique peut généralement être utilisée pour créer de grandes chaînes tout en conservant la lisibilité du code.

# 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: Jetez un oeil à la bibliothèque impressionnante python-sqlparse pour joliment imprimer des requêtes SQL si nécessaire. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format

Une autre option qui, à mon avis, est plus lisible lorsque le code (par exemple, une variable) est en retrait et que la chaîne de sortie doit être une ligne (pas de nouvelle ligne):

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 

Utilisez des guillemets triples. Les gens les utilisent souvent pour créer des docstrings au début des programmes pour expliquer leur objectif et d'autres informations pertinentes à sa création. Les gens les utilisent également dans les fonctions pour expliquer le but et l'application des fonctions. Exemple:

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

J'aime cette approche car elle privilégie la lecture. Dans les cas où nous avons de longues cordes, il n'y a aucun moyen! Selon le niveau d'indentation dans lequel vous vous trouvez et toujours limité à 80 caractères par ligne ... Et bien ... Pas besoin de dire autre chose. À mon avis, les guides de style python sont encore très vagues. J'ai adopté l'approche @Eero Aaltonen car elle privilégie la lecture et le bon sens. Je comprends que les guides de style devraient nous aider et ne pas gâcher notre vie. Merci!

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

De la documentation officielle de python :

Les littéraux de chaîne peuvent s'étendre sur plusieurs lignes. Une façon consiste à utiliser des guillemets triples: "" "..." "" ou '' '...' ''. La fin des lignes est automatiquement incluse dans la chaîne, mais il est possible d'empêcher cela en ajoutant un \ à la fin de la ligne. L'exemple suivant:

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

produit la sortie suivante (notez que la nouvelle ligne initiale n'est pas incluse):

Pour définir une longue chaîne à l'intérieur d'un dict, en gardant les sauts de ligne mais en omettant les espaces , j'ai fini par définir la chaîne dans une constante comme celle-ci:

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

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

En tant qu'approche générale des chaînes longues en Python, vous pouvez utiliser des guillemets triples splitet 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())

Production:

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

En ce qui concerne la question d'OP relative à une requête SQL, la réponse ci-dessous ne tient pas compte de l'exactitude de cette approche de construction de requêtes SQL et se concentre uniquement sur la construction de longues chaînes de manière lisible et esthétique sans importations supplémentaires. Il ignore également la charge de calcul que cela implique.

En utilisant des guillemets triples, nous construisons une chaîne longue et lisible que nous décomposons ensuite en une liste en utilisant split()ainsi en supprimant les espaces blancs, puis en les réunissant à nouveau avec ' '.join(). Enfin, nous insérons les variables à l'aide de la format()commande:

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)

Produit:

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: Cette approche n'est pas conforme à PEP8 mais je la trouve parfois utile

En général, j'utilise listet joinpour les commentaires / chaîne multi-lignes.

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)

vous pouvez utiliser n'importe quelle chaîne pour joindre tous ces éléments de la liste comme ' \n' (nouvelle ligne) ou ' ,' (virgule) ou ' ' (espace)

À votre santé..!!