“est” l'opérateur se comporte de manière inattendue avec des entiers

Python “est” l'opérateur se comporte de manière inattendue avec des entiers?

En résumé - permettez-moi de souligner: Ne pas utiliser is pour comparer des nombres entiers.

Ce n'est pas le comportement que vous devez avoir toutes les espérances au sujet.

Au lieu de cela, utiliser == et != de comparer pour l'égalité et l'inégalité, respectivement. Par exemple:

>>> a = 1000
>>> a == 1000       # Test integers like this,
True
>>> a != 5000       # or this!
True
>>> a is 1000       # Don't do this! - Don't use `is` to test integers!!
False

Explication

De savoir cela, vous devez connaître les éléments suivants.

D'abord, qu'est - is faire? C'est un opérateur de comparaison. À partir de la la documentation:

Les opérateurs is et is not test pour l'identité de l'objet: x is y est vrai
si et seulement si x et y sont le même objet. x is not y les rendements de la
inverse la valeur de vérité.

Et donc les suivantes sont équivalentes.

>>> a is b
>>> id(a) == id(b)

De la la documentation:

id
De retour de “l'identité” d'un objet. C'est un entier (ou long
entier) qui est garanti pour être unique et constante pour cet objet
au cours de sa durée de vie. Deux objets avec des non-cumul de la durée de vie peut
ont la même id() valeur.

Noter que le fait que l'id d'un objet dans Disponible (l'implémentation de référence de Python) est l'emplacement dans la mémoire est un détail d'implémentation. D'autres implémentations de Python (comme Python ou IronPython) pourrait facilement avoir une mise en œuvre différente pour id.

Quel est donc le cas d'utilisation pour is? PEP8 décrit:

Des comparaisons à des singletons comme None devrait toujours être fait avec is ou
is not, jamais les opérateurs d'égalité.

La Question

Vous demandez, et l'état, la question suivante (avec code):

Pourquoi la suite de se comporter de façon inattendue en Python?

>>> a = 256
>>> b = 256
>>> a is b
True           # This is an expected result

Il est pas un résultat attendu. Pourquoi est-il prévu? Cela signifie seulement que les nombres entiers sont évalués à 256 référencé par les deux a et b sont la même instance de l'entier. Les entiers sont immuables en Python, donc ils ne peuvent pas changer. Cela ne devrait pas avoir d'impact sur le code. Il ne devrait pas être prévu. C'est qu'un détail d'implémentation.

Mais peut-être que nous devrions être heureux qu'il n'y a pas une nouvelle instance en mémoire à chaque fois que nous l'état d'un montant égal à 256.

>>> a = 257
>>> b = 257
>>> a is b
False          # What happened here? Why is this False?

Ressemble, nous avons maintenant deux instances distinctes de nombres entiers avec la valeur de 257 dans la mémoire. Puisque les nombres entiers sont immuables, ce déchets de la mémoire. Espérons que nous ne sommes pas perdre beaucoup de lui. Nous ne serons probablement pas. Mais ce comportement n'est pas garanti.

>>> 257 is 257
True           # Yet the literal numbers compare properly

Bien, cela ressemble à votre mise en œuvre de Python est d'essayer d'être intelligent et ne pas créer évalués de manière redondante des nombres entiers en mémoire, sauf si elle a pour. Vous semblez indiquer que vous êtes en utilisant le référent de la mise en œuvre de Python, qui est Disponible. Bon pour Disponible.

Il pourrait être encore mieux si Disponible pourrait faire cela à l'échelle mondiale, si elle pouvait le faire à bon marché (comme il y aurait un coût dans la recherche), peut-être une autre implémentation.

Mais comme pour l'impact sur le code, vous ne devriez pas les soins si un nombre entier est un cas particulier d'un entier. Vous devez seulement garde à ce que la valeur de cette instance, et vous devez utiliser la normale des opérateurs de comparaison pour cela, c'est à dire ==.

Ce is ne

is vérifie que le id de deux objets sont les mêmes. Dans Disponible, le id est l'emplacement dans la mémoire, mais il pourrait être un autre numéro d'identification unique dans une autre mise en œuvre. Pour rappeler ce avec le code:

>>> a is b

est le même que

>>> id(a) == id(b)

Pourquoi nous voulons utiliser is alors?

Cela peut être un très rapides par rapport à-dire, vérifier si les deux très longues chaînes sont égales en valeur. Mais puisqu'il s'applique à l'unicité de l'objet, nous avons donc limité des cas d'utilisation. En fait, nous voulons surtout l'utiliser pour vérifier None, qui est un singleton (une seule instance existante dans un endroit de la mémoire). On pourrait créer d'autres célibataires s'il est possible de faire un amalgame entre eux, que l'on pourrait vérifier avec is, mais ils sont relativement rares. Voici un exemple (en Python 2 et 3), par exemple

SENTINEL_SINGLETON = object() # this will only be created one time.

def foo(keyword_argument=None):
    if keyword_argument is None:
        print('no argument given to foo')
    bar()
    bar(keyword_argument)
    bar('baz')

def bar(keyword_argument=SENTINEL_SINGLETON):
    # SENTINEL_SINGLETON tells us if we were not passed anything
    # as None is a legitimate potential argument we could get.
    if keyword_argument is SENTINEL_SINGLETON:
        print('no argument given to bar')
    else:
        print('argument to bar: {0}'.format(keyword_argument))

foo()

Qui imprime:

no argument given to foo
no argument given to bar
argument to bar: None
argument to bar: baz

Et nous le voyons donc, avec is et une sentinelle, nous sommes en mesure de différencier entre le moment où bar est appelé sans argument, et lorsqu'elle est appelée avec None. Tels sont les principaux cas d'utilisation pour is - faire pas l'utiliser pour tester l'égalité des entiers, des chaînes, tuples, ou d'autres choses comme celles-ci.

OriginalL'auteur Aaron Hall

Je suis en retard, mais, vous voulez qu'une source de votre réponse?^*

Bonne chose à propos de Disponible, c'est que vous pouvez réellement voir la source pour cela. Je vais utiliser des liens pour le 3.5 communiqué pour le moment; trouver le correspondant 2.x est trivial.

Dans Disponible, le C-API fonction qui gère la création d'un nouveau int objet est PyLong_FromLong longue(v). La description de cette fonction est:

La mise en œuvre actuelle conserve un tableau d'entiers à des objets pour tous les entiers compris entre -5 et 256, lorsque vous créez un int dans cette gamme vous fait juste de revenir d'une référence à l'objet existant. Il devrait donc être possible de modifier la valeur de 1. Je soupçonne que le comportement de Python dans ce cas n'est pas défini. 🙂

Ne sais pas vous, mais je vois cela et pense que: nous allons trouver que la matrice de!

Si vous n'avez pas trafiqué avec la C d'application du code des Disponible vous devriez, tout est très organisé et lisible. Pour notre cas, nous avons besoin de regarder dans le Objets/ sous-répertoire de la code source principal de l'arbre de répertoire.

PyLong_FromLong traite long objets de sorte qu'il ne devrait pas être difficile d'en déduire que nous avons besoin de jeter un regard à l'intérieur de longobject.c. Après avoir regardé à l'intérieur, vous pourriez penser que les choses sont chaotiques; ils sont, mais n'ayez crainte, la fonction nous sommes à la recherche pour est froid à 230 en attente pour nous de le vérifier. C'est une petite fonction de sorte que le corps principal (à l'exclusion des déclarations) est facilement collé ici:

PyObject *
PyLong_FromLong(long ival)
{
    // omitting declarations

    CHECK_SMALL_INT(ival);

    if (ival < 0) {
        /* negate: cant write this as abs_ival = -ival since that
           invokes undefined behaviour when ival is LONG_MIN */
        abs_ival = 0U-(unsigned long)ival;
        sign = -1;
    }
    else {
        abs_ival = (unsigned long)ival;
    }

    /* Fast path for single-digit ints */
    if (!(abs_ival >> PyLong_SHIFT)) {
        v = _PyLong_New(1);
        if (v) {
            Py_SIZE(v) = sign;
            v->ob_digit[0] = Py_SAFE_DOWNCAST(
                abs_ival, unsigned long, digit);
        }
        return (PyObject*)v; 
}

Maintenant, nous ne sommes pas C maître-code-haxxorz mais nous sommes également pas dumb, nous pouvons voir que CHECK_SMALL_INT(ival); jeter un oeil à nous tous séduisante; nous pouvons comprendre qu'il a quelque chose à voir avec cela. Let's check it out:

#define CHECK_SMALL_INT(ival) \
    do if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { \
        return get_small_int((sdigit)ival); \
    } while(0)

Donc, c'est une macro qui appelle la fonction get_small_int si la valeur ival satisfait la condition:

if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS)

Quels sont donc NSMALLNEGINTS et NSMALLPOSINTS? Si vous avez deviné macros vous n'obtenez rien parce que ce n'était pas une question difficile.. De toute façon, ici, ils sont:

#ifndef NSMALLPOSINTS
#define NSMALLPOSINTS           257
#endif
#ifndef NSMALLNEGINTS
#define NSMALLNEGINTS           5
#endif

Si notre condition est if (-5 <= ival && ival < 257) appel get_small_int.

Pas d'autre endroit où aller, mais continuons notre voyage en regardant get_small_int dans toute sa splendeur (eh bien, nous allons regarder à corps c'est parce que c'est là que les choses intéressantes sont):

PyObject *v;
assert(-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS);
v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
Py_INCREF(v);

D'accord, déclarer un PyObject, affirmer que la condition précédente est titulaire et d'exécuter la mission:

v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];

small_ints ressemble beaucoup à ce tableau, nous avons été à la recherche pour.. et, il est! Nous pourrions viens de lire la putain de la documentation et nous avons connaître tout le long!:

/* Small integers are preallocated in this array so that they
   can be shared.
   The integers that are preallocated are those in the range
   -NSMALLNEGINTS (inclusive) to NSMALLPOSINTS (not inclusive).
*/
static PyLongObject small_ints[NSMALLNEGINTS + NSMALLPOSINTS];

Donc ouais, c'est notre gars. Lorsque vous souhaitez créer un nouveau int dans la gamme [NSMALLNEGINTS, NSMALLPOSINTS) vous aurez juste revenir une référence à un objet qui a été préaffectés.

Depuis que la référence se rapporte au même objet, l'émission de id() directement ou vérification d'identité avec is sur qu'il sera de retour à exactement la même chose.

Mais, quand sont-ils répartis??

Lors de l'initialisation _PyLong_Init Python fera un plaisir d'entrer dans une boucle for ne le faire pour vous:

for (ival = -NSMALLNEGINTS; ival <  NSMALLPOSINTS; ival++, v++) {
    // Look me up!
}

J'espère que mon explication vous a fait C (jeu de mots évidemment destiné) les choses clairement maintenant.

---

Mais, 257 257 est? Qu'est-ce?

C'est effectivement plus facile à expliquer, et j'ai tenté de le faire déjà; elle est due au fait que Python va exécuter cette déclaration interactive:

>>> 257 is 257

comme un seul bloc. Au cours de complilation de cette déclaration, Disponible verrez que vous avez deux correspondants littéraux, et d'utiliser la même PyLongObject représentant 257. Vous pouvez voir si vous ne la compilation de vous-même et examiner son contenu:

>>> codeObj = compile("257 is 257", "blah!", "exec")
>>> codeObj.co_consts
(257, None)

Disponible lorsque l'opération; il est maintenant tout va charger exactement le même objet:

>>> import dis
>>> dis.dis(codeObj)
  1           0 LOAD_CONST               0 (257)   # dis
              3 LOAD_CONST               0 (257)   # dis again
              6 COMPARE_OP               8 (is)

Donc is sera de retour True.

---

_{* -- je vais essayer de mot et de plus en plus d'introduction, de manière de plus pour être en mesure de la suivre.}

OriginalL'auteur Jim Fasarakis Hilliard

Je pense que vos hypothèses sont correctes. Expérience avec id (identité de l'objet):

In [1]: id(255)
Out[1]: 146349024

In [2]: id(255)
Out[2]: 146349024

In [3]: id(257)
Out[3]: 146802752

In [4]: id(257)
Out[4]: 148993740

In [5]: a=255

In [6]: b=255

In [7]: c=257

In [8]: d=257

In [9]: id(a), id(b), id(c), id(d)
Out[9]: (146349024, 146349024, 146783024, 146804020)

Il semble que les numéros de <= 255 sont traités comme des littéraux et rien au-dessus est traité différemment!

OriginalL'auteur Amit

is est l'identité de l'opérateur d'égalité (fonctionnement comme id(a) == id(b)); c'est juste que les deux chiffres ne sont pas nécessairement le même objet. Pour des raisons de performances, certains petits entiers se trouvent être memoized de sorte qu'ils ont tendance à être les mêmes (ce qui peut être fait depuis qu'ils sont immuables).

PHP === opérateur, d'autre part, est décrite comme la vérification de l'égalité et de type: x == y and type(x) == type(y) comme par Paulo Freitas commentaire. Cela ne sera pas suffisant pour le commun des nombres, mais diffèrent de is pour les classes qui définissent __eq__ dans une absurde:

class Unequal:
    def __eq__(self, other):
        return False

PHP apparemment permet la même chose pour "built-in" des classes (qui, pour moi, signifie en œuvre au niveau C, pas en PHP). Un peu moins absurde utilisez peut-être un objet timer, qui a une valeur différente à chaque fois qu'il est utilisé comme un nombre. Tout à fait pourquoi vous voulez émuler Visual Basic Now au lieu de montrer que c'est une évaluation avec time.time() je ne sais pas.

Greg Hewgill (OP) fait une clarification de commentaire "Mon objectif est de comparer l'identité de l'objet, plutôt que de l'égalité de valeur. Sauf pour les nombres, où je veux traiter de l'identité de l'objet même que l'égalité de valeur."

Ce serait encore une autre réponse, comme nous l'avons à catégoriser les choses comme des numéros ou non, de choisir si l'on compare avec == ou is. Disponible définit la numéro de protocole, y compris PyNumber_Check, mais ce n'est pas accessible à partir de Python lui-même.

On pourrait essayer d'utiliser isinstance avec tous les types de nombre que nous connaissons, mais ce sera inévitablement incomplète. Les types de module contient un StringTypes liste, mais pas de NumberTypes. Depuis la version 2.6 de Python, est construit dans le nombre de classes qui ont une classe de base nombres.Nombre, mais il a le même problème:

import numpy, numbers
assert not issubclass(numpy.int16,numbers.Number)
assert issubclass(int,numbers.Number)

Par la voie, NumPy produira des instances séparées de leur faible nombre.

Je ne sais pas vraiment une réponse à cette variante de la question. Je suppose que l'on pourrait théoriquement utiliser ctypes appeler PyNumber_Check, mais même que la fonction a été débattu, et ce n'est certainement pas portable. Nous devons simplement être moins particulier à propos de ce que nous avons test pour l'instant.

En fin de compte, cette question découle de Python à l'origine, pas d'avoir un type d'arbre avec des prédicats comme Schéma de l' number?, ou Haskell type de classe Num. is vérifie l'identité de l'objet, pas la valeur de l'égalité. PHP a une histoire colorée, où === apparemment se comporte comme is seulement sur les objets en PHP5, mais pas en PHP4. Tels sont les douleurs de croissance de déplacement à travers les langues (y compris les versions d'un seul).

OriginalL'auteur Yann Vernier

Il y a un autre problème qui n'est pas souligné dans l'une des questions /réponses. Python est autorisé à fusionner les deux valeurs inaltérables, et pré-créé de petites int les valeurs ne sont pas la seule façon, cela peut arriver. Un Python de mise en œuvre n'est jamais garanti pour ce faire, mais ils font tous pour plus que juste des petits ints.

---

Pour une chose, il ya quelques autres pré-créé des valeurs telles que le vide tuple, str, et bytes, et quelques courtes chaînes de caractères (Disponible 3.6, c'est l'256 unique de caractères Latin-1 chaînes de caractères). Par exemple:

>>> a = ()
>>> b = ()
>>> a is b
True

---

Mais aussi, même les non-pré-créé valeurs peuvent être identiques. Considérez ces exemples:

>>> c = 257
>>> d = 257
>>> c is d
False
>>> e, f = 258, 258
>>> e is f
True

Et ce n'est pas limité à int valeurs:

>>> g, h = 42.23e100, 42.23e100
>>> g is h
True

Évidemment, Disponible ne vient pas avec un pré-créé float valeur pour 42.23e100. Donc, ce qui se passe ici?

Disponible le compilateur va fusionner les valeurs des constantes de certains connus-immuable des types comme int, float, str, bytes, dans la même unité de compilation. Pour un module, le module est une unité de compilation, mais à la interactives interprète, chaque instruction distincte de l'unité de compilation. Depuis c et d sont définies dans des déclarations séparées, leurs valeurs ne sont pas fusionnés. Depuis e et f sont définies dans la même déclaration, leurs valeurs sont regroupées.

---

Vous pouvez voir ce qui se passe par le démontage du bytecode. Essayez de définir une fonction qui ne e, f = 128, 128 et puis l'appel de dis.dis sur elle, et vous allez voir qu'il y a une seule valeur de la constante (128, 128)

>>> def f(): i, j = 258, 258
>>> dis.dis(f)
  1           0 LOAD_CONST               2 ((128, 128))
              2 UNPACK_SEQUENCE          2
              4 STORE_FAST               0 (i)
              6 STORE_FAST               1 (j)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> f.__code__.co_consts
(None, 128, (128, 128))
>>> id(f.__code__.co_consts[1], f.__code__.co_consts[2][0], f.__code__.co_consts[2][1])
4305296480, 4305296480, 4305296480

---

Vous remarquerez peut-être que le compilateur a stocké 128 comme une constante, même si elle n'est pas réellement utilisée par le bytecode, qui vous donne une idée de la façon dont peu d'optimisation Disponible du compilateur. Ce qui signifie que (non vide) de n-uplets fait de ne pas fusionné:

>>> k, l = (1, 2), (1, 2)
>>> k is l
False

Mettre que dans une fonction, dis, et à regarder le co_consts—il y a un 1 et un 2, deux (1, 2) tuples qui partagent le même 1 et 2 mais ne sont pas identiques, et une ((1, 2), (1, 2)) tuple qui a deux distincts de l'égalité des n-uplets.

---

Il y a une optimisation plus que Disponible: chaîne de stage. Contrairement au compilateur de constantes, ce n'est pas restreinte à code source de littéraux:

>>> m = 'abc'
>>> n = 'abc'
>>> m is n
True

D'autre part, elle est limitée à la str type, et pour les chaînes de stockage interne de type ascii "compact", "compact", ou "legacy prêt", et dans de nombreux cas seulement ascii "compact" aura interné.

---

En tout cas, les règles pour quelles valeurs doivent être, peut-être, ou ne peut pas être distinctes varier de mise en œuvre de la mise en œuvre, et entre les différentes versions de la même application, et peut-être même entre deux exécutions du même code sur la même copie de la même mise en œuvre.

Il peut être vaut la peine d'apprendre les règles d'un Python pour le plaisir. Mais c'est pas la peine de compter sur eux dans votre code. La seule règle est:

• Ne pas écrire le code qui suppose l'égalité des deux, mais séparément, créé immuable valeurs sont identiques.
• Ne pas écrire le code qui suppose l'égalité des deux, mais séparément, créé immuable valeurs sont distinctes.

Ou, en d'autres termes, seule l'utilisation is de test pour la documentation des singletons (comme None) ou qui sont créés uniquement dans un endroit dans le code (comme le _sentinel = object() idiome).

OriginalL'auteur abarnert