Quelle est la règle de syntaxe pour avoir des virgules de fin dans les définitions de Tuple?
Dans le cas d'un tuple à un seul élément, la virgule de fin est requise.
a = ('foo',)
Qu'en est-il d'un tuple avec plusieurs éléments? Il semble que la virgule de fin existe ou non, elles sont toutes les deux valides. Est-ce correct? Avoir une virgule de fin est plus facile pour l'édition à mon avis. Est-ce un mauvais style de codage?
a = ('foo1', 'foo2')
b = ('foo1', 'foo2',)
Dans tous les cas sauf le tuple vide, la virgule est la chose la plus importante. Les parenthèses ne sont obligatoires que lorsque cela est nécessaire pour d'autres raisons syntaxiques: distinguer un tuple d'un ensemble d'arguments de fonction, la priorité des opérateurs ou autoriser les sauts de ligne.
La virgule de fin pour les nuplets, les listes ou les arguments de fonction est un bon style, en particulier lorsque vous avez une longue initialisation divisée sur plusieurs lignes. Si vous incluez toujours une virgule de fin, vous n'ajouterez pas une autre ligne à la fin, vous espérez ajouter un autre élément et vous créez simplement une expression valide:
a = [
"a",
"b"
"c"
]
En supposant que cela ait commencé comme une liste de 2 éléments qui a été étendue par la suite, cela a mal tourné d'une manière peut-être pas immédiatement évidente. Toujours inclure la virgule de fin et vous évitez ce piège.
Il est seulement nécessaire que les n-uplets à un seul article sachent définir un tuple ou une expression entourée de parenthèses.
(1) # the number 1 (the parentheses are wrapping the expression `1`)
(1,) # a 1-Tuple holding a number 1
Pour plus d'un objet, cela n'est plus nécessaire puisqu'il est parfaitement clair qu'il s'agit d'un tuple. Toutefois, la virgule de fin est autorisée pour faciliter leur définition à l'aide de plusieurs lignes. Vous pouvez ajouter des éléments à la fin ou les réorganiser sans enfreindre la syntaxe, car vous avez oublié une virgule par accident.
par exemple.,
someBigTuple = (
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
#...
10000000000,
)
Notez que cela s'applique également à d'autres collections (par exemple, des listes et des dictionnaires) et pas seulement aux n-uplets.
Les virgules de fin sont un autre avantage: elles rendent les différences plus agréables. Si vous avez commencé avec
a = [
1,
2,
3
]
et l'a changé en
a = [
1,
2,
3,
4
]
Le diff ressemblerait
a = [
1,
2,
- 3
+ 3,
+ 4
]
Alors que si vous aviez commencé par une virgule, comme
a = [
1,
2,
3,
]
Alors le diff serait juste
a = [
1,
2,
3,
+ 4,
]
C'est optionnel: voir le wiki Python .
Résumé: les tuples à un seul élément nécessitent une virgule de fin, mais c'est optional pour les tuples à plusieurs éléments.
En outre, considérez la situation où vous voulez:
>>> (('x','y'))*4 # same as ('x','y')*4
('x', 'y', 'x', 'y', 'x', 'y', 'x', 'y')
#Expected = (('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))
Ainsi, dans ce cas, les parenthèses externes ne sont rien de plus que des groupements de parenthèses . Pour les transformer en tuple, vous devez ajouter une virgule. c'est à dire.
>>> (('x','y'),)*4
(('x', 'y'), ('x', 'y'), ('x', 'y'), ('x', 'y'))
Une virgule finale est requise pour les nuplets à un élément uniquement. Avoir une virgule de fin pour les plus grands tuples est une question de style et n'est pas obligatoire. Son principal avantage réside dans les différences nettes sur des fichiers contenant de grands nuplets multilignes souvent modifiés (par exemple, des nuplets de configuration).
Cela existe aussi parce que la génération de code et les fonctions __repr__ sont plus faciles à écrire. Par exemple, si vous avez un objet construit comme obj(arg1, arg2, ..., argn), vous pouvez simplement écrire obj.__repr__ en tant que
def __repr__(self):
l = ['obj(']
for arg in obj.args: # Suppose obj.args == (arg1, arg2, ..., argn)
l.append(repr(arg))
l.append(', ')
l.append(')')
return ''.join(l)
Si une virgule de fin n'était pas autorisée, vous auriez à cas spécial le dernier argument. En fait, vous pourriez écrire ce qui précède sur une ligne en utilisant une liste de compréhension (je l’ai écrit plus longtemps pour le rendre plus facile à lire). Ce ne serait pas si facile de le faire si vous deviez utiliser un cas spécial le dernier trimestre.
C'est une réponse simple.
a = ("s") est une chaîne
et
a = ("s",) est un tuple avec un élément.
Python nécessite une virgule supplémentaire dans le cas d'un élément Tuple to, pour différencier string et Tuple.
Par exemple, essayez ceci sur la console python:
a = ("s")
a = a + (1,2,3)
Traceback (appel le plus récent en dernier):
Fichier stdin, ligne 1, dans le module
TypeError: impossible de concaténer les objets 'str' et 'Tuple'
PEP 8 - Guide de style pour le code Python - Quand utiliser des virgules de fin
Les virgules de fin sont généralement facultatifs, sauf qu'ils sont obligatoires pour la création d'un tuple d'un élément (et qu'ils ont une sémantique pour l'instruction print dans Python 2). Par souci de clarté, il est recommandé de placer ce dernier entre parenthèses (techniquement redondantes).
Oui:
FILES = ('setup.cfg',)
OK, mais déroutant:
FILES = 'setup.cfg',
Lorsque les virgules de fin sont redondantes, elles sont souvent utiles lorsqu'un système de contrôle de version est utilisé, lorsqu'une liste de valeurs, d'arguments ou d'éléments importés doit être étendue au fil du temps. Le modèle consiste à mettre chaque valeur (etc.) sur une ligne par elle-même, en ajoutant toujours une virgule de fin et en ajoutant les parenthèses/crochets/accolades proches à la ligne suivante. Toutefois, il n’a pas de sens de placer une virgule de fin sur la même ligne que le délimiteur de fermeture (sauf dans le cas ci-dessus de tuples singleton).
Oui:
FILES = [
'setup.cfg',
'tox.ini',
]
initialize(FILES,
error=True,
)
Non:
FILES = ['setup.cfg', 'tox.ini',]
initialize(FILES, error=True,)