Должен ли я добавить конечную запятую после последнего аргумента в вызове функции?

Ответ 1

Я думаю, что нет никаких технических причин, чтобы избежать запятых в вызовах функций, но некоторые люди, вероятно, считают их отвлекающими. Некоторые могут остановиться и сказать:

"Хм, интересно, действительно ли это должно быть там?"

Я смущаюсь назвать это преимуществом, но один эффект использования концевых запятых в сочетании с стилем с отступом , чтобы изменения в управлении версиями выглядели немного чище при добавлении аргумента.

Например, такая функция:

def my_fun(a, b, c=None):
    ...

... называется так:

my_fun(
    a='abc',
    b=123
)

... затем изменилось на следующее:

my_fun(
    a='abc',
    b=123,
    c='def'
)

создает этот diff в git:

$ git diff
...
 my_fun(
     a='abc',
-    b=123
+    b=123,
+    c='def'
 )

В то время,

my_fun(
    a='abc',
    b=123,
)

изменено на...

my_fun(
    a='abc',
    b=123,
    c='def',
)

создает этот diff в git:

$ git diff
...
 my_fun(
     a='abc',
     b=123,
+    c='def',
 )

Ответ 2

В структурах данных конечная запятая "полезна" для упрощения добавления элементов:

a = [
      1,
      2,
      3,
    ]

легче изменить на

a = [
      1,
      2,
      3,
      4,
      5,
    ]

потому что вам не нужно редактировать строку, которая говорит 3,.

Но в вызовах функций нет такой выгоды, которые обычно не изменяются по длине. Поэтому я бы отказался от использования конечной запятой.

Ответ 3

Я думаю, в этом вопросе одинаковые причины применимы как к спискам и кортежам, потому что список аргументов функции именно таков.

Вот цитата из FAQ по проектным решениям, которые были сделаны для языка (c.f.):

Почему Python разрешает запятые в конце списков и кортежей?

Python позволяет добавлять конечную запятую в конце списков, кортежей и словарей:

[1, 2, 3,]
('a', 'b', 'c',)
d = {
    "A": [1, 5],
    "B": [6, 7],  # last trailing comma is optional but good style
}

Есть несколько причин, позволяющих это сделать.

Когда у вас есть буквальное значение для списка, кортежа или словаря, распределенного по нескольким строкам, его проще добавить больше элементов, потому что вам не нужно запоминать, чтобы добавить запятую в предыдущую строку. Строки также могут быть переупорядочены без создания синтаксической ошибки.

Случайное отсутствие запятой может привести к ошибкам, которые трудно диагностировать. Например:

x = [
  "fee",
  "fie"
  "foo",
  "fum"
]

Этот список выглядит так, как будто он имеет четыре элемента, но на самом деле он содержит три: "гонорар", "fiefoo" и "fum". Всегда добавление запятой позволяет избежать этого источника ошибок.

Предоставление конечной запятой может также облегчить создание программных кодов.

Ответ 4

Я также оставлю свои 2 цента здесь, даже если этот поток был здесь в течение достаточно долгого времени, это могло бы кому-то помочь :)

PEP8 на самом деле говорит, когда следует использовать конечные запятые, и если вы будете следовать их рекомендациям (не обязательно, но определенно рекомендуется), то ваш второй однострочный пример может быть исключен, а именно:

Нет:

self.call(1, True, "hi",)

Да:

self.call(
    1,
    True,
    "hi",
)

Использование в вызовах функций (используйте редко, чтобы никогда) и вот почему:

• Один из принципов кодирования заключается в том, что функция должна выполнять одно и только одно. Так что, видя запятую там, может возникнуть много вопросов, когда они действительно не должны. Обычно, когда вы видите где-то запятую, вы ожидаете, что эта вещь со временем изменится. Так что, если это список, кортеж, диктовка и т.д., Это обычно означает, что тот, кто его спроектировал, сделал это с целью физического добавления, удаления или переключения линий в этой структуре, и что ж... вы не видите этого с помощью функций так много, или, по крайней мере, вы не должны, и если вы делаете, лучше рассмотреть лучший дизайн.

• Как упомянуто выше, функция также должна быть очень предсказуемой, вы не разрабатываете функцию для одновременной отправки почты и ракет на Луну и оставляете запятую при вызове для отправки почты, потому что кто знает, когда вы можете отправлять ракеты и вы хотите меньше загроможденного diff (это только вызовет больше путаницы и плохой дизайн)

• Произвольное количество параметров (или даже фиксированное, но большое количество параметров) обычно указывает на то, что либо вы создаете экземпляр объекта, либо выполняете несколько вещей, когда на самом деле то, что вы должны делать, это разделить ваш дизайн на создание нескольких меньших функции, которые каждый делает одну вещь, следовательно, не нужно использовать запятую.

• Также подумайте, даже если у вас есть функция, которую вы сможете вызывать с несколькими параметрами, подумайте, как часто вы будете делать это и что это будет означать? Ну, это будет означать что-то вроде:

  • Это подразумевает рефакторинг кода в месте вызова (который может быть в другой функции, или в модуле, или где-то еще), потому что обычно результат от функций хранится в переменных, и вам нужно использовать этот новый результат, что подразумевает рефакторинг.
  • Если это не подразумевает рефакторинг, то это означает, что функция ничего не возвращает, или она возвращает то же самое, и в этом случае это означает, что она делает несколько вещей с дополнительными аргументами, переданными в вызове, что, как было сказано ранее не очень идеален.
  • Даже если вы не заботитесь о принципах кодирования и игнорируете вышесказанное, как часто это будет сделано? Если ответ часто, то другая плохая, нестабильная реализация проекта. И если это не очень часто (ну, это в значительной степени отвечает на это сам по себе, что этого не должно быть, и даже если вы думаете, что это должно быть, я думаю, что ваши глаза могут нести еще одну дополнительную строку в diff контроля версий, чтобы вы могли избежать вызывая дополнительную путаницу в рядах людей, которые также разделяют ваш проект.

Фактические использования

• Конечные запятые имеют смысл, как вы сказали в структурах данных, структурах данных, которые, как ожидается, изменятся физически с течением времени, потому что, если вы измените их во время выполнения, ну, это не будет иметь никакого смысла для всего, что в редакторе, кроме определение, которое также может быть пустой структурой [] xD

• Если ожидается изменение структур данных (списков, диктов, наборов, кортежей и т.д.) (Физически, исходный код), то конечные запятые фактически рекомендуются и действительно полезны (см. Полную ссылку на PEP, в ней есть варианты использования и рекомендации)

Заключение:

• Рекомендуется в многострочных структурах данных, которые, как ожидается, физически изменятся
• Редко никогда в вызовах функций
• Никогда в определениях функций