index - string python deutsch




Pythonischer Weg, um eine lange mehrzeilige Zeichenfolge zu erstellen (10)

"À la" Scala Weg (aber ich denke, ist der pythischste Weg, wie OQ verlangt):

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

Wenn du final str ohne Sprungzeilen willst, setze einfach \n am Anfang des ersten Arguments des zweiten replace:

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

Hinweis: Die weiße Linie zwischen "... Templates." und "Auch, ..." benötigt nach dem | einen Leerzeichen .

Ich habe eine sehr lange Frage. Ich möchte es in mehreren Zeilen in Python aufteilen. Eine Möglichkeit, dies in JavaScript zu tun, wäre, mehrere Sätze zu verwenden und sie mit einem + Operator zu verbinden (ich weiß, vielleicht ist es nicht der effizienteste Weg dazu), aber ich mache mir in dieser Phase keine Gedanken über die Lesbarkeit des Codes ). Beispiel:

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

Ich habe versucht, etwas ähnliches in Python zu tun, aber es hat nicht funktioniert, also habe ich \ die lange Zeichenfolge aufgeteilt. Ich bin mir jedoch nicht sicher, ob dies der einzige / beste / pythonsche Weg ist, dies zu tun. Es sieht umständlich aus. Tatsächlicher Code:

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

Beispielsweise:

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'

Wenn der Wert der Bedingung eine Zeichenfolge sein soll, können Sie Folgendes tun:

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

Eine weitere Option, die meiner Meinung nach besser lesbar ist, wenn der Code (z. B. Variable) eingerückt ist und der Ausgabe-String ein Einstrich (keine Zeilenumbrüche) sein sollte:

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 

Ich benutze eine rekursive Funktion, um komplexe SQL-Abfragen zu erstellen. Diese Technik kann allgemein verwendet werden, um große Zeichenfolgen zu erstellen, während die Lesbarkeit des Codes erhalten bleibt.

# 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: Sehen Sie sich die großartige Bibliothek python-sqlparse an, um bei Bedarf SQL-Abfragen zu drucken. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format


Ich finde, dass Sie beim Erstellen langer Strings in der Regel so etwas wie das Erstellen einer SQL-Abfrage tun. In diesem Fall ist das das Beste:

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

Was Levon vorgeschlagen hat, ist gut, könnte aber anfällig für Fehler sein:

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

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

Ich mag diesen Ansatz, weil er das Lesen bevorzugt. In Fällen, wo wir lange Strings haben, gibt es keinen Weg! Abhängig von der Höhe der Einrückung, in der Sie sich befinden und immer noch auf 80 Zeichen pro Zeile begrenzt sind ... Nun ... Es ist nicht nötig, etwas anderes zu sagen. Aus meiner Sicht sind die Python Style Guides immer noch sehr vage. Ich habe den Ansatz von @Eero Aaltonen gewählt, weil er das Lesen und den gesunden Menschenverstand fördert. Ich verstehe, dass Style-Guides uns helfen und unser Leben nicht zu einem Chaos machen sollten. Vielen Dank!

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

In Python> = 3.6 können Sie formatierte Zeichenfolgenliterale (f string) verwenden

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

Linien zu brechen, funktioniert für mich. Hier ist ein Beispiel:

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

Sie können die sql-Anweisung auch in eine action.sql Datei action.sql und mit der Datei in die py-Datei laden

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

Also werden die SQL-Anweisungen vom Python-Code getrennt. Wenn in der sql-Anweisung Parameter vorhanden sind, die aus Python gefüllt werden müssen, können Sie die Formatierung von Zeichenfolgen verwenden (wie% s oder {field})


Sprechen Sie über mehrzeilige Saiten? Einfach, verwenden Sie dreifache Anführungszeichen, um sie zu beginnen und zu beenden.

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

Sie können auch einfache Anführungszeichen verwenden (3 davon natürlich am Anfang und Ende) und die resultierende Zeichenfolge wie jede andere Zeichenfolge behandeln.

HINWEIS : Genau wie bei jeder anderen Zeichenfolge wird auch eine beliebige Zahl zwischen den Anführungszeichen von Anfang und Ende Teil der Zeichenfolge. Daher hat dieses Beispiel eine führende Leerstelle (wie von @ root45 angegeben). Diese Zeichenfolge enthält auch Leerzeichen und Zeilenumbrüche.

Dh ,:

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

Schließlich kann man in Python auch lange Linien wie folgt konstruieren:

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

die keine zusätzlichen Leerzeichen oder Zeilenumbrüche enthält (dies ist ein Beispiel, das zeigt, wie sich der Effekt des Überspringens von Leerzeichen auswirkt):

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

Es sind keine Kommas erforderlich. Platzieren Sie einfach die zu verknüpfenden Zeichenfolgen in einem Klammerpaar und achten Sie darauf, dass alle erforderlichen Leerzeichen und Zeilenumbrüche berücksichtigt werden.







python