Пробелы в выражениях и операторах языка Python

Как ставить пробелы в выражениях

Избегайте лишних пробелов в следующих ситуациях:

Сразу внутри скобок.

# Правильно
spam(ham[1], {eggs: 2})
# Неправильно
spam( ham[ 1 ], { eggs: 2 } )

Между последней запятой и следующей закрывающей скобкой.
```
# Правильно
foo = (0,)
# Неправильно
bar = (0, )
```

Непосредственно перед запятой, точкой с запятой или двоеточием:

# Правильно
if x == 4: print x, y; x, y = y, x
# Неправильно
if x == 4 : print x , y ; x , y = y , x

Однако в срезе двоеточие действует как двоичный оператор и должен иметь равные промежутки с обеих сторон (рассматривая его как оператор с наименьшим приоритетом). В расширенном срезе оба двоеточия должны иметь одинаковое расстояние между ними. Исключение - когда параметр среза опущен, пробел опущен.
```
# Правильно
ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:]
ham[lower:upper], ham[lower:upper:], ham[lower::step]
ham[lower+offset : upper+offset]
ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]
ham[lower + offset : upper + offset]
```
```
# Неправильно
ham[lower + offset:upper + offset]
ham[1: 9], ham[1 :9], ham[1:9 :3]
ham[lower : : upper]
ham[ : upper]
```
Непосредственно перед открытой скобкой, которая запускает список аргументов вызова функции:
```
# Правильно
spam(1)
# Неправильно
spam (1)
```
Непосредственно перед открытой скобкой, которая указывает на индекс или срез:
```
# Правильно
dct['key'] = lst[index]
# Неправильно
dct ['key'] = lst [index]
```
Более одного пространства вокруг оператора присваивания (или другого), чтобы выровнять его с другим.
```
# Правильно
x = 1
y = 2
long_variable = 3
```
```
# Неправильно
x             = 1
y             = 2
long_variable = 3
```

Другие рекомендации:

Избегайте конечных пробелов в строках, в любом месте. Поскольку он обычно невидим, он может сбивать с толку: например, обратная косая черта, за которой следует пробел, в некоторых редакторах, не считается переводом строки и отображается только визуально. И многие компиляторы (например, сам CPython) отклоняют его, что приводит к ошибкам.
Всегда окружайте эти двоичные операторы одним пробелом с обеих сторон: присваивание ( = ), расширенное присваивание ( += , -= и т. д.), сравнения (==, <, >, !=, <>, <=, >=, in, not in, is, is not), логические (and, or, not).
Если используются операторы с разными приоритетами, рассмотрите возможность добавления пробелов вокруг операторов с наименьшим приоритетом. Используйте свое собственное суждение; однако никогда не используйте более одного пробела и всегда имейте одинаковое количество пробелов с обеих сторон двоичного оператора.
```
# Правильно
i = i + 1
submitted += 1
x = x*2 - 1
hypot2 = x*x + y*y
c = (a+b) * (a-b)
```
```
# Неправильно
i=i+1
submitted +=1
x = x * 2 - 1
hypot2 = x * x + y * y
c = (a + b) * (a - b)
```
Аннотации функций должны использовать обычные правила для двоеточий и всегда иметь пробелы вокруг стрелки ->, если она присутствует.
```
# Правильно
def munge(input: AnyStr): ...
def munge() -> PosInt: ...
```
```
# Неправильно
def munge(input:AnyStr): ...
def munge()->PosInt: ...
```
Не используйте пробелы вокруг знака '=', когда он используется для указания ключевого аргумента или для указания значения по умолчанию для параметра функции без указания имени.
```
# Правильно
def complex(real, imag=0.0):
    return magic(r=real, i=imag)
```
```
# Неправильно
def complex(real, imag = 0.0):
    return magic(r = real, i = imag)
```
Однако при объединении аннотации аргумента со значением по умолчанию используйте пробелы вокруг знака '=' :
```
# Правильно
def munge(sep: AnyStr = None): ...
def munge(input: AnyStr, sep: AnyStr = None, limit=1000): ...
```
```
# Неправильно
def munge(input: AnyStr=None): ...
def munge(input: AnyStr, limit = 1000): ...
```

Составные операторы (несколько операторов в одной строке), как правило, не рекомендуется.

# Правильно
if foo == 'blah':
    do_blah_thing()
do_one()
do_two()
do_three()

# Неправильно
if foo == 'blah': do_blah_thing()
do_one(); do_two(); do_three()

Хотя иногда можно поставить if/for/while с небольшим телом на одной строке, никогда не делайте этого для операторов с несколькими условиями. Также избегайте выстраивания таких конструкций в длинные строки!

# Неправильно
if foo == 'blah': do_blah_thing()
for x in lst: total += x
while t < 10: t = delay()

if foo == 'blah': do_blah_thing()
else: do_non_blah_thing() 

try: something()
finally: cleanup()

do_one(); do_two(); do_three(long, argument,
                            list, like, this)

if foo == 'blah': one(); two(); three()