Quelle est la différence entre les notations entre crochets et points en Python?
Je viens d'un arrière-plan Javascript (où les propriétés sont accessibles par les deux . et [] notation), alors pardonnez-moi, mais quelle est exactement la différence entre les deux en Python?
De mon expérimentation, il semble que [] doit toujours être utilisé, à la fois pour obtenir l'index d'un list ou set et pour obtenir la valeur d'une certaine clé dans un dictionary. Est-ce correct et, sinon, quand utilisez-vous un . en Python?
L'opérateur point est utilisé pour accéder aux attributs de n'importe quel objet. Par exemple, un nombre complexe
>>> c = 3+4j
a (entre autres) les deux attributs real et imag:
>>> c.real
3.0
>>> c.imag
4.0
En plus de ceux-ci, il a une méthode, conjugate(), qui est également un attribut:
>>> c.conjugate
<built-in method conjugate of complex object at 0x7f4422d73050>
>>> c.conjugate()
(3-4j)
La notation entre crochets est utilisée pour accéder aux membres d'une collection, que ce soit par clé dans le cas d'un dictionnaire ou d'un autre mappage:
>>> d = {'a': 1, 'b': 2}
>>> d['a']
1
... ou par index dans le cas d'une séquence comme une liste ou une chaîne:
>>> s = ['x', 'y', 'z']
>>> s[2]
'z'
>>> t = 'Kapow!'
>>> t[3]
'o'
Ces collections ont également, séparément, des attributs:
>>> d.pop
<built-in method pop of dict object at 0x7f44204068c8>
>>> s.reverse
<built-in method reverse of list object at 0x7f4420454d08>
>>> t.lower
<built-in method lower of str object at 0x7f4422ce2688>
... et encore, dans les cas ci-dessus, ces attributs se trouvent être des méthodes.
Bien que tous les objets aient des attributs, tous les objets n'ont pas de membres. Par exemple, si nous essayons d'utiliser la notation entre crochets pour accéder à un membre de notre nombre complexe c:
>>> c[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'complex' object is not subscriptable
... nous obtenons une erreur (ce qui est logique, car il n'existe aucun moyen évident pour un nombre complexe d'avoir des membres).
Il est possible de définir comment [] Et . Fonctionnent dans une classe définie par l'utilisateur, en utilisant les méthodes spéciales __getitem__() et __getattr__() respectivement. Expliquer comment le faire dépasse le cadre de cette question, mais vous pouvez en savoir plus à ce sujet dans le Tutoriel Python .
. est utilisé pour accéder aux attributs (y compris les méthodes). [] est utilisé pour accéder à ce qu'on appelle des "éléments", qui sont généralement le contenu de divers types d'objets conteneurs.
JavaScript ne distingue pas ces deux choses, mais Python le fait. Vous avez raison que [] est utilisé pour accéder aux données d'une liste ou d'un dict. . est utilisé, par exemple, pour accéder à des méthodes comme list.append et dict.update. Il est également utilisé pour accéder à d'autres données sur d'autres types d'objets; par exemple, les objets d'expression régulière compilés ont un attribut pattern contenant le modèle d'expression régulière (vous y accéderiez avec rx.pattern).
En général, la convention est que [] est utilisé pour le stockage de données "ouvert" où vous ne savez pas à l'avance combien ou quelles sortes de données l'objet contiendra; . est plus couramment utilisé pour des données spécifiques que l'objet possède "par nature" et auxquelles on accède avec un nom prédéfini. Par exemple, le simple fait de savoir qu'un élément sous forme de liste ne vous indique pas ce qu'il contient (pour lequel vous utilisez []), mais il vous indique que vous pouvez y ajouter (et accéder à la méthode d'ajout que vous utilisez .).
L'autre différence majeure entre Python et JavaScript à cet égard est qu'en Python, le comportement des deux . et [] peut être personnalisé par l'objet. Alors obj.foo ou obj[foo] peut faire quelque chose de spécial si obj est un objet qui définit son propre comportement pour eux. Il existe différents types personnalisés qui en font usage à leurs propres fins.
[] est l'index d'un conteneur, tel qu'une liste ou un dictionnaire.
. est le membre d'un objet et de modules. Il peut s'agir d'une méthode, de données de membre ou d'un attribut.
>>> xs = [1, 7, 3, 4, 5, 4, 3, 4, 1]
>>> xs.count(4)
3
>>> xs[1]
7
En fait, Python utilise les crochets pour entourer une clé. Pour les listes, il s'agit d'un index entier (non signé) ou d'une tranche, tandis que pour les dict, il s'agit d'un objet (hasable) comme une chaîne, Tuple , etc. ou même un entier (singe et unsigned). Ceci est simple pour de nombreuses autres langues qui utilisent une syntaxe similaire ou même identique.
Le . est utilisé pour accéder aux membres d'un objet, un peu comme pour C++, C, Java, JavaScript, etc. Il serait assez simple d'écrire une classe de dictionnaire qui permet d'utiliser la syntaxe à points pour accéder à ses éléments. Cependant, pour cela, les clés doivent être valides Python identifiant (letter { letter | digit |_}. Cependant, ce n'est pas très courant.
Un ensemble ne prend pas en charge l'indexation, car il n'est pas ordonné en interne et il n'y a pas de relation entre une "clé" et une "valeur". Pour une liste, vous n'obtenez pas "l'index", mais vous "obtenez la valeur d'un index". Pour un dict, c'est similaire, mais l '"indice" est plus flexible. Cependant, le dict n'autorise pas le découpage et n'est pas (comme l'ensemble) non ordonné.
Sidenote: Python utilise un dict interne pour un objet pour organiser ses membres. Essayez simplement sur la console:
class MyClass:
def myfunc(self):
pass
print(MyClass.__dict__)
Vous obtiendrez tous les attributs (nom: valeur) de cette classe. Notez l'entrée pour myfunc.