Am o foarte lungă perioadă de interogare. Aș dori să-l împartă în mai multe rânduri în Python. O modalitate de a face în JavaScript-ar fi folosit mai multe exemple și unindu-le cu un " + " operator (stiu, poate l's, cel mai eficient mod de a face asta, dar nu'm nu prea preocupat de performanță în această etapă, doar codul de lizibilitate). Exemplu:
var long_string = 'some text not important. just garbage to' +
'illustrate my example';
Am încercat să fac ceva similar în Python, dar nu't de lucru, asa ca am folosit \
de a împărți șir lung. Cu toate acestea, am'm nu sunt sigur dacă acest lucru este doar/cel mai bun/pythonicest mod de a face aceasta. Se pare penibil.
Codul Actual:
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
Vorbești despre multi-linie siruri de caractere? Ușor, utilizați ghilimele triple la începutul și sfârșitul ei.
s = """ this is a very
long string if I had the
energy to type more and more ..."""
Puteți folosi ghilimele simple prea (3 dintre ele, desigur, la începutul și sfârșitul) și trata șirul rezultat " s " la fel ca orice alt șir de caractere.
NOTĂ: la fel ca și cu orice șir de caractere, ceva între început și de sfârșit citate devine parte a șirului, deci, acest exemplu are un lider gol (după cum a subliniat de către @root45). Acest șir va conține, de asemenea, ambele spații și linii noi.
I. e.,:
' this is a very\n long string if I had the\n energy to type more and more ...'
În cele din urmă, se pot construi linii lungi în Python astfel:
s = ("this is a very"
"long string too"
"for sure ..."
)
care va nu include orice suplimentare spații sau linii noi (aceasta este o deliberată exemplu care arată ce efect sărind peste golurile vor duce la):
'this is a verylong string toofor sure ...'
Nu virgule necesare, pur și simplu loc de siruri de caractere pentru a fi uniți într-o pereche de paranteze și asigurați-vă că pentru a ține cont de orice nevoie de spații și linii noi.
Dacă tu nu't vrei un string multilinie dar au doar o singură linie de șir de caractere, puteți utiliza paranteze, doar asigurați-vă că don't include virgule între șir de segmente, atunci acesta va fi un tuplu.
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)
Într-o declarație SQL ca ceea ce ai're construirea, multilinie siruri de caractere, de asemenea, ar fi bine. Dar dacă extra spațiu un string multilinie ar conține-ar fi o problemă, atunci acest lucru ar fi o modalitate buna de a obține ceea ce vrei.
Consider că atunci când construirea de șiruri lungi, vă sunt, de obicei, de a face ceva cum ar fi construirea unei interogări SQL, în cazul în care acest lucru este cel mai bun:
query = ' '.join(( # note double parens, join() takes an iterable
"SELECT foo",
"FROM bar",
"WHERE baz",
))
Ce Levon sugerat este bun, dar ar putea fi vulnerabile la greșeli:
query = (
"SELECT foo"
"FROM bar"
"WHERE baz"
)
query == "SELECT fooFROM barWHERE baz" # probably not what you want
De asemenea, puteți înlănțui variabile atunci când se utilizează """ notație:
foo = '1234'
long_string = """fosdl a sdlfklaskdf as
as df ajsdfj asdfa sld
a sdf alsdfl alsdfl """ + foo + """ aks
asdkfkasdk fak"""
EDIT: am Găsit o cale mai bună, cu nume params și .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)
În Python >= 3.6 puteți utiliza Formatat literali șir (f string)
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}'''
Această abordare utilizează:
inspecta
modululaccount_id " și " def_id
variabile. În acest fel se pare cel mai pythonic pentru mine.
# 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}'''
)
**** Update: 1/29/2019 Includă @ShadowRanger's sugestia de a folosi controlați.cleandoc "în loc de" textwrap.dedent`
De exemplu:
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'
dacă valoarea de condiție ar trebui să fie un șir de caractere, se poate face astfel:
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'"
Personal, găsesc următorul să fie mai bun (simplu, sigur și Pythonic) mod de a scrie prime interogări SQL în Python, mai ales atunci când se utilizează Python's sqlite3 modul:
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
?
substituent, aceasta poate deveni un pic dificil de a urmări de care ?
este de a fi substituite prin care Python variabilă atunci când există o mulțime de ei în interogare.Am gasittextwrap.dedent
](https://docs.python.org/2/library/textwrap.html) cel mai bun pentru șiruri lungi așa cum este descris aici:
def create_snippet():
code_snippet = textwrap.dedent("""\
int main(int argc, char* argv[]) {
return 0;
}
""")
do_something(code_snippet)
Alții au menționat paranteze metoda deja, dar am'd dori să adaug că, cu paranteze, comentarii inline sunt permise.
python nursery_rhyme = ( 'Maria a avut un miel mic,' # Comentarii sunt mari! 'sa fleece era albă ca zăpada.' 'Și peste tot că Maria s-a dus,' 'i-oi ar merge cu siguranță.' # Ce oi plictisitor. )
Atunci când se utilizează backslash linie continuari (\
), comentariile nu sunt permise. Te'll primi un SyntaxError: caracter neașteptat după linia continuarea caracter` eroare.
`` nursery_rhyme = 'Maria a avut un miel mic,' \ # Aceste comentarii 'sa fleece era albă ca zăpada.' \ # sunt invalide! 'Și peste tot că Maria s-a dus,' \ 'i-oi ar merge cu siguranță.'
``
Bazat pe exemplul din https://docs.python.org/3/library/re.html#re.VERBOSE,
o = re.compila( r'\d+' # parte integrantă r'\.' # punctul zecimal r'\d*' # unele cifre fracționare )
``
o = re.compila(r"""\d + # a parte integrantă . # punctul zecimal \d * # unele fracționată cifre""", re.X) ``
Eu folosesc, de obicei, ceva de genul asta:
text = '''
This string was typed to be a demo
on how could we write a multi-line
text in Python.
'''
Dacă doriți să eliminați enervant spații goale în fiecare linie, ai putea face după cum urmează:
text = '\n'.join(line.lstrip() for line in text.splitlines())
Dvs. de codul actual ar trebui't de lucru, vă lipsesc spatiile de la sfârșitul de "linii" (de exemplu: rol.descr ca roleFROM...
)
Există triplequotes pentru string multilinie:
string = """line
line2
line3"""
Acesta va conține pauze de linie și spații suplimentare, dar pentru SQL care'nu e nici o problema.
"À la" Scala mod (dar cred că este cel mai pythonic fel ca AP cereri):
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(' | ',' ')
Dacă doriți finală str fără a sări liniile, doar a pus \n
la începutul primului argument de-al doilea înlocui:
.replace('\n | ',' ')`.
Notă: linia albă între "...template-uri." și "de Asemenea, ..." necesită un spațiu după |
.
Puteți plasa, de asemenea, sql-declarație într-un fișier separat de acțiune.sql
și încărcați-l în fișierul cu
with open('action.sql') as f:
query = f.read()
Deci sql-declarații vor fi separate de cod python. Dacă există parametri în instrucțiunea sql care trebuie să fie umplut de python, puteți utiliza șir formating (ca %s sau {câmp})
Eu folosesc o funcție recursivă pentru a construi Interogări SQL complexe. Aceasta tehnica poate fi, în general, folosite pentru a construi siruri de caractere mari, menținând în același timp codul de lizibilitate.
# 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)
P. S: Au o privire la minunat python-sqlparse biblioteca pentru a destul de print interogări SQL, dacă este necesar. http://sqlparse.readthedocs.org/en/latest/api/#sqlparse.format
O altă opțiune care cred că este mai ușor de citit atunci când codul (de exemplu.g variabilă) este indentat și șir de ieșire ar trebui să fie o singură linie (nu newline):
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
tl;dr: Folosesc"""` și """
să-și încheie șirul, la fel ca în
string = """\ Acesta este un lung șir întinde pe mai multe linii. """
De oficial python documentația:
literali Șir se poate întinde pe mai multe linii. O modalitate este utilizarea triplu-citate: """...""" sau '''...'''. Sfârșitul de linii sunt în mod automat inclus în șir, dar este posibil pentru a preveni acest lucru prin adăugarea unui \ la capăt de linie. Următorul exemplu:
de imprimare("""\ Utilizare: chestia [OPȚIUNI] -h a Afișa această utilizare mesaj -H hostname nume de Gazdă pentru a vă conecta la """)
produce următoarea ieșire (rețineți că inițial newline nu este inclus):
Utilizare: chestia [OPȚIUNI] -h a Afișa această utilizare mesaj -H hostname nume de Gazdă pentru a vă conecta la
Îmi place această abordare, deoarece privilegiile de citire. În cazurile în care avem șiruri lungi nu există nici un fel! În funcție de nivelul de indentare și încă limitată la 80 de caractere pe linie... ei Bine... Nu-i nevoie să mai spun nimic altceva. Din punctul meu de vedere python ghiduri de stil sunt încă foarte vagi. Mi-am luat @Eero Aaltonen abordare pentru că privilegiile de citire și de bun simț. Am înțeles că, ghiduri de stil ar trebui să ne ajute și nu să ne facă viața un dezastru. Multumesc!!!
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
)
"""