Le comportement d'incrémentation et de décrémentation les opérateurs en Python

Je remarque qu'une pré-incrémentation/décrémentation de l'opérateur peut être appliqué sur une variable (comme ++count). Il compile, mais il ne modifie pas la valeur de la variable!

Quel est le comportement de la pré-incrémentation/décrémentation les opérateurs (++/--) en Python?

Pourquoi Python s'écarter du comportement de ces opérateurs vu en C/C++?

  • Chris: Vous avez répondu à ma requête (le quoi). En outre, je voudrais savoir pourquoi Python diffère de ce comportement à partir de C/C++.
  • Python n'est pas en C ou C++. Différentes décisions de conception est allé dans la fabrication de la langue. En particulier, Python a choisi délibérément de ne pas définir l'affectation des opérateurs qui peuvent être utilisées dans une expression arbitraire; au contraire, il ya des instructions d'affectation et augmentée des instructions d'affectation. Voir la référence ci-dessous.
  • Ce qui vous a fait penser python avait ++ et -- opérateurs?
  • Kaizer: en Venant du C/C++, j'écris ++compter et il compile en Python. Donc, je pensais que la langue a les opérateurs.
  • Je crois que ++ existe dans C surtout parce que c'est du sucre syntaxique pour l'arithmétique des pointeurs, par exemple, le classique while (dest++ = src++) {;}.
  • étant donné que la plupart des contemporains de la programmation orientée objet des langues a ces symboles GVR venu avec Python, il ne serait pas judicieux d'inclure une syntaxe avertissement pour cette construction?
  • Vous êtes en supposant un niveau de planification et d'organisation pas de preuves
  • et -- n'existent pas en c "sucre syntaxique pour l'arithmétique des pointeurs", ils existent parce que de nombreux fabricants ont automatique d'incrémentation et de décrémentation de la mémoire des mécanismes d'accès (en général pointeur de l'indexation, la pile d'indexation) dans le cadre de leurs natif du jeu d'instructions. Par exemple, en assembleur 6809: sta x++ ...atomique de l'instruction que les résultats des magasins de la a accumulateur où x est de pointage, puis incrémente x par la taille de l'accumulateur. Ceci est fait parce qu'il est plus rapide que l'arithmétique des pointeurs, car il est très commun, et parce que c'est facile à comprendre. À la fois pré - et-post.

InformationsquelleAutor Ashwin Nanjappa | 2009-09-28
  1. 925

    ++ n'est pas un opérateur. Il est deux + opérateurs. Le + l'opérateur est le identité de l'opérateur, qui ne fait rien. (Précision: le + et - opérateurs unaires seulement le travail sur les nombres, mais je présume que vous ne vous attendez pas à une hypothétique ++ à l'opérateur de travailler sur des chaînes de caractères.)

    ++count

    S'analyse comme

    +(+count)

    Qui se traduit par

    count

    Vous devez utiliser le légèrement plus += opérateur de faire ce que vous voulez faire:

    count += 1

    Je soupçonne le ++ et -- opérateurs ont été laissés de côté pour des raisons de cohérence et de simplicité. Je ne sais pas l'argument exact Guido van Rossum a donné pour la décision, mais je peux imaginer quelques arguments:

    • Plus simple de l'analyse. Techniquement, l'analyse ++count est ambigu, car il pourrait être +, +, count (deux unaire + opérateurs), tout comme il pourrait être ++, count (un unaire ++ opérateur). Ce n'est pas une importante ambiguïté syntaxique, mais il existe.
    • Un langage plus simple. ++ n'est rien de plus qu'un synonyme pour += 1. C'était une abréviation inventé parce que les compilateurs C sont stupides et ne savent pas comment optimiser a += 1 dans le inc enseignement la plupart des ordinateurs ont. En ce jour de l'optimisation des compilateurs et le bytecode des langages interprétés, l'ajout d'opérateurs à une langue pour permettre aux programmeurs d'optimiser leur code est généralement mal vu, surtout dans un langage comme Python qui est conçu pour être cohérent et lisible.
    • Confusion d'effets secondaires. Une commune erreur de débutant dans les langues avec ++ opérateurs est de mélanger les différences (à la fois dans l'ordre de priorité et en valeur de retour) entre le pré - et post-incrémentation/décrémentation les opérateurs, et Python aime à éliminer de la langue "gotcha"-s. Le la priorité des questions de pré-/post-incrémentation dans C sont assez poilu, et incroyablement facile à gâcher.
    • "L'opérateur + est "l'identité" de l'opérateur, qui ne fait rien." Uniquement pour les types numériques; pour d'autres, elle est une erreur par défaut.
    • La droite. Mais là encore, ++ et -- ne doit être prévu pour fonctionner sur les types numériques.
    • Aussi, soyez conscient que, en Python, += et amis ne sont pas les opérateurs qui peuvent être utilisées dans les expressions. Plutôt, en Python qu'ils sont définis dans le cadre d'un "augmentée instruction d'affectation". Ceci est cohérent avec le langage de conception de décision en Python pour ne pas permettre l'affectation ("=") comme un opérateur à l'intérieur de l'arbitraire des expressions, à la différence de ce qu'on peut faire en C. Voir docs.python.org/reference/...
    • Unaire + opérateur a une utilisation. Pour les décimales.Virgule des objets, il arrondit à la précision actuelle.
    • Kaizer, c'est un usage étrange pour +. Aucune idée pourquoi Python n'est que pour les décimales.Virgule des objets?
    • Chris, merci beaucoup pour cette réponse détaillée! J'ai appris beaucoup de choses, il suffit de lire et de comprendre votre explication 🙂
    • Je parie sur un analyseur de simplification. Remarque un élément dans PEP 3099, "des Choses qui ne changeront Pas en Python 3000": "L'analyseur n'est pas plus complexe que LL(1). Simple est mieux que complexe. Cette idée s'applique à l'analyseur. La restriction de Python de la grammaire à un LL(1) analyseur est une bénédiction et non une malédiction. Il nous met dans des menottes qui nous empêchent d'aller à la mer et de se retrouver avec funky règles de grammaire à l'instar de certains autres langages dynamiques qui vont sans nom, comme Perl." Je ne vois pas comment faire pour lever l'ambiguïté + + et ++ sans casser LL(1).
    • Ce doit être le renvoi d'une question que tous les autres "pourquoi ne pas Python ont ++ opérateurs?" questions fermées comme des doublons, car cette réponse représente 4% de ma réputation.
    • Cette réponse est correcte si +1, mais c'est juste un autre de ces désagréments avec Python qui m'ont fait venir à vraiment détester. strip() au lieu de trim() comme toutes les autres langues, pas de commutateurs, certains OO fonctions et d'autres non (len(s) et s.lower()). Très frustrant et incohérent de la langue
    • Pour n'importe qui qui a, comme moi, à une perte quant à ce qu'est le but de l'unaire opérateur + est, il est à l'opposé de l'unaire - opérateur. Qu'est-ce que -1? Il est négatif. Qu'est-ce que +1? C'est positif. Qu'est-ce que +(+1)? C'est toujours positive. Se sentir stupide pour avoir demandé maintenant? Moi aussi.
    • la beauté de python fonctions intégrées, telles que len(), est qu'ils ont généralement une carte à une méthode de l'objet, vous permettant de remplacer ou de donner le pouvoir à l'intégrées pour l'un de vos propres classes -- s.__len__() dans ce cas.
    • Pourquoi est-ce plus souhaitable que d'en hériter d'un objet qui a une longueur de méthode/propriété qui peut être remplacée? Aussi loin que je peux voir, il suffit d'ajouter une couche d'indirection pour aucun avantage tangible
    • Mais.. c'est précisément ce qui se passe. Cela conduit en quelque chose de beau à propos de python, un public, privé, protégé de la méthode de régime appliqué par la cohérence de style de codage, plutôt que strictement appliquées. s.__len__() est là quand vous en avez vraiment envie de le remplacer, mais caché ne pas encombrer la grande majorité des classes qui n'en ai pas besoin.
    • alors a) __len__() n'est pas vraiment privé, c'est seulement du public, mais appelé par indiretion et b), nous avons maintenant besoin de connaître toutes les méthodes qui font appel au privé des méthodes de l'objet pourrait ai juste eu un length() méthode qui pourrait être remplacé si vous le souhaitez.
    • précisément sur les deux comptes! __len__() n'est pas vraiment privé, mais on dirait que quand vous n'en avez pas besoin, et seulement quand vous en avez besoin. Lorsque vous introspecter un objet de méthodes utiles, de ne pas vous trouver une indéfini length() et une centaine d'autres pas défini des méthodes intégrées. Mais une fois que vous le faites, il est toujours là sous les couvertures. J'ai besoin d'un verre. 😉
    • Je pense que nous allons devoir accepter d'être en désaccord, je pense toujours qu'il regarde comme le bruit et les pauses OO principes pour peu d'avantages, le cas échéant. Pour cela, j'ai besoin de boire un verre de trop. Bon week-end
    • 'Python aime à éliminer de la langue "gotcha"-s' - n'est-ce pas une langue de chat?
    • comment faire pour incrémenter/décrémenter un jeu d'enregistrements ? link
    • Ce n'est pas correct de dire que ++ n'est rien de plus qu'un synonyme pour += 1. Il y a des pré-incrémentation et post-incrémentation variantes de ++ donc c'est clairement pas la même chose. Je suis d'accord avec le reste de vos points, cependant.
    • Juste pour cela, vous êtes mon idole: "les compilateurs C sont stupides et ne savent pas comment optimiser un += 1"
    • Chacune de leur propre. J'utilise ++ et -- tout le temps et de ne pas gâcher quoi que ce soit. Python est un OK de la langue, mais il a beaucoup de défauts, et je trouve que la communauté religieuse à propos de diverses constructions de langage. Ses un outil, pas la Mona Lisa. Permet de faire le travail et de passer à la tâche suivante ... qui sera le plus probablement écrit dans R ou Matlab ou C++
    • À l'avenir @NedDeily du très haut-voté remarque sur les affectations, Python 3.8 permet l'affectation de près de n'importe où avec le nouveau := de l'opérateur.

    InformationsquelleAutor Chris Lutz
  2. 373

    Quand vous voulez pour incrémenter ou décrémenter, vous souhaitez généralement de le faire que sur un nombre entier. Comme:

    b++

    Mais en Python, les entiers sont immuable. C'est que vous ne pouvez pas les modifier. C'est parce que l'entier des objets peut être utilisé sous plusieurs noms. Essayez ceci:

    >>> b = 5
>>> a = 5
>>> id(a)
162334512
>>> id(b)
162334512
>>> a is b
True

    a et b ci-dessus sont en fait le même objet. Si vous incrémentés d'une, vous aussi, vous incrément b. Ce n'est pas ce que vous voulez. Donc, vous avez à réaffecter. Comme ceci:

    b = b + 1

    Ou plus simple:

    b += 1

    Qui permettra de réaffecter b à b+1. Ce n'est pas un opérateur d'incrémentation, parce qu'il ne s'incrémente pas b, il réaffecte il.

    En bref: Python se comporte différemment ici, parce qu'il n'est pas C, et n'est pas un bas niveau wrapper autour de code machine, mais un haut niveau de langage dynamique, où incréments n'ont pas de sens, et aussi ne sont pas aussi nécessaire qu'en C, où que vous les utilisez chaque fois que vous avez une boucle, par exemple.

    • Cet exemple est mauvais (et vous êtes probablement à confusion immutabilité de l'identité) - ils ont le même id en raison de certaines vm optimisation qui utilise les mêmes objets pour les nombres jusqu'à 255 (ou quelque chose comme ça). Par exemple (plus grand nombre): >>> a = 1231231231231 >>> b = 1231231231231 >>> id(a), id(b) (32171144, 32171168)
    • L'immutabilité allégation est fausse. Sur le plan conceptuel, i++ reviendrait à attribuer i + 1 à la variable i. i = 5; i++ moyens pour attribuer 6 à i, de ne pas modifier le int objet pointé par i. C'est, il ne signifie pas pour incrémenter la valeur de 5!
    • escargot: auquel cas il ne serait pas incrément opérateurs à tous. Et puis, l'opérateur += est plus clair, plus explicite, plus souple et fait la même chose de toute façon.
    • En C++ et Java, i++ fonctionne uniquement sur lvalues. S'il était prévu d'augmenter l'objet pointé par i, cette restriction serait inutile.
    • Il rendrait les gens pas au courant à propos de la manière dont les objets sont alloués. Peut-être que mon texte dans le commentaire d'origine n'était pas très bon: l'exemple n'est pas faux, c'est le mauvais exemple, c'est irelevant à l'immutabilité des aspects en python, en effet, il montre comment disponible alloue de petites ints.
    • L'exemple est là pour montrer pourquoi les entiers sont immuables, et l'alternative de faire a = 5; b=a est moins claire à vous pourrait en fait attendre b pour le changer, quand un des changements.
    • L'immuabilité est en effet pas pertinent dans ce cas. Considérer: Clojure est doté d'un opérateur d'incrémentation et de toutes les structures de données sont immuables par défaut. Même s'il est vrai que vous obtenez une nouvelle référence à la nouvelle valeur, qui est essentiellement orthogonal à l'purement syntaxique choix de ++ vs += 1.
    • Mais peut-être que c'est juste de dire que l'idée de "incrémentation" quelque chose est un peu mal définies.
    • Si tout est immuable, je suppose que c'est OK d'utiliser ++ pour ce Clojure, comme il n'y a pas de confusion. Mais en Python il serait bizarre d'avoir un opérateur d'incrémentation qui n'a pas d'incrément.
    • Oui; je vois maintenant que ma confusion est un peu plus de la définition de "incrément". Je l'ai dans ma tête que la définition de "incrémenter", est lié à l'égalité de la sémantique de la langue, sens toute fonction f avec aucun des effets secondaires peut être appelé "incrémenter" si f(x) == x + 1, tient toujours pour toutes les valeurs numériques x. Autres personnes clairement de ne pas le voir de cette façon, je vais garder à l'esprit dans l'avenir. +1 pour une réflexion réponse en tout cas. P. S. - Clojure de l'opérateur d'incrémentation est encore plus explicite que ++: il est (inc value).
    • Cette explication, bien que interressant ne semble pas plausible: ++a pourrait en être faite par l'interprète pour avoir exactement le même effet que a = a+1 et ont a point à l'ID de 6. Je pense que le vrai problème réside dans le fait que + est un opérateur unaire et que ++un pourrait signifier soit increment a ou +(+a) qui est indistiguishable pour le python de l'analyseur.
    • Je répète pour la upmteenth temps: Ensuite, il n'a pas d' incrémenter. C'est le remplacement de l'objet avec un autre objet. Incrémentation pas l'objet premier.
    • Eh bien, quoi d'autre ne a = a + 1 autres que de remplacer un objet par un autre objet?
    • Exactement. Il ne s'incrémente pas a. Voir ma réponse ci-dessus. a = 1; b = a; a = a + 1; ne veut pas dire que b est maintenant de 2. Il ne s'incrémente pas a.
    • Vous pouvez avoir le sementics de ++ être le même que +=1. Rien de mal à cela?
    • Sommes-nous débattre de la nomenclature? Appel ++ xyz au lieu d'incrémenter car il pointe maintenant vers un autre objet? Est-ce un problème?
    • Oui, elle serait source de confusion, parce qu'il ressemble à un opérateur d'incrémentation, mais il ne l'est pas. Et oui, c'est une grosse affaire. Ceci est mentionné dans ma réponse, et aussi dans la discussion ci-dessus. Pourquoi ne pas vous le lire? Et pourquoi ajouter a++? de quel usage? Sauver un couple de personnage pour un rarement utilisé opération?
    • Je l'ai lu. Donnez-moi un scénario où il serait confondre un programmeur en ayant un comportement imprévu.
    • Je l'ai déjà fait. Juste maintenant en fait: stackoverflow.com/questions/1485841/...
    • laissez-nous garder toute répétition des mêmes vieux arguments dans le chat
    • Je demande un exemple de morceau de code qui aurait un comportement différent si ++ a été utilisé en lieu et place de +=1
    • Dans quel cas exactement, peut-il être source de confusion pour un programmeur Python lorsque a++ permettrait d'évaluer à a += 1? (outre le fait que ce serait une deuxième façon de faire)
    • Cette explication (immuable) va dans le Python livre que j'ai lu hier.
    • comment faire pour incrémenter/décrémenter un jeu d'enregistrements ? link
    • Vous ne pouvez incrémenter et décrémenter les valeurs numériques, donc je pense que vous voulez dire quelque chose d'autre. Ajouter / supprimer, peut-être?
    • Je trouve cette réponse assez déconcertant. Pourquoi êtes-vous en supposant ++ signifie rien d'autre qu'un raccourci pour +=1? C'est précisément ce que cela signifie en C (en supposant que la valeur de retour n'est pas utilisé). Vous semblez avoir tiré quelques autres du sens à partir de l'air.
    • Comme N'Éclosent dit, dans d'autres langues (Java par exemple), les entiers sont aussi immuables, et de faire +=1 ou ++ modifie simplement la valeur d'une variable de points à, à être plus grand que ce qu'il pointe actuellement à. Ni l'opérateur modifie le valeur de ce qu'est une variable de points. Cette réponse n'a pas vraiment donner une bonne raison pour laquelle un ++ opérateur n'a pas été ajoutés.
    • L'argument contre ++ qu'il supprime l'ambiguïté d'une langue semble être annulés par l' "a et b ci-dessus sont en fait le même objet. Si vous incrémentés d'une, vous aussi, vous incrément b. Ce n'est pas ce que vous voulez. Donc, vous devez réaffecter." Une optimisation prématurée en attribuant la même valeur, par référence à plusieurs variables, mais seulement si elles sont de 8 bits entiers, semble introduire inattendu et un comportement incohérent basé sur le strawman argument ++ est quelque peu ambigu, devient un véritable argument circulaire. La suppression de la langue de la concision et de la puissance expressive car un analyseur est trop stupide?

    InformationsquelleAutor Lennart Regebro
  3. 49

    Tandis que les autres réponses sont correctes, dans la mesure où ils montrent ce qu'un simple + fait habituellement (à savoir, laisser le numéro tel qu'il est, si c'en est un), elles sont incomplètes, dans la mesure où ils n'expliquent pas ce qui se passe.

    Pour être exact, +x évalue à x.__pos__() et ++x à x.__pos__().__pos__().

    Je ne pouvais imaginer une TRÈS étrange structure de classe (les Enfants, ne faites pas cela à la maison!) comme ceci:

    class ValueKeeper(object):
    def __init__(self, value): self.value = value
    def __str__(self): return str(self.value)

class A(ValueKeeper):
    def __pos__(self):
        print 'called A.__pos__'
        return B(self.value - 3)

class B(ValueKeeper):
    def __pos__(self):
        print 'called B.__pos__'
        return A(self.value + 19)

x = A(430)
print x, type(x)
print +x, type(+x)
print ++x, type(++x)
print +++x, type(+++x)
    InformationsquelleAutor glglgl
  4. 10

    Python n'a pas de ces opérateurs, mais si vous avez vraiment besoin, vous pouvez écrire une fonction ayant la même fonctionnalité.

    def PreIncrement(name, local={}):
    #Equivalent to ++name
    if name in local:
        local[name]+=1
        return local[name]
    globals()[name]+=1
    return globals()[name]

def PostIncrement(name, local={}):
    #Equivalent to name++
    if name in local:
        local[name]+=1
        return local[name]-1
    globals()[name]+=1
    return globals()[name]-1

    Utilisation:

    x = 1
y = PreIncrement('x') #y and x are both 2
a = 1
b = PostIncrement('a') #b is 1 and a is 2

    L'intérieur d'une fonction, vous devez ajouter des locals() comme deuxième argument, si vous voulez changer de variable locale, sinon, il va essayer de changer mondiale.

    x = 1
def test():
    x = 10
    y = PreIncrement('x') #y will be 2, local x will be still 10 and global x will be changed to 2
    z = PreIncrement('x', locals()) #z will be 11, local x will be 11 and global x will be unaltered
test()

    Aussi avec ces fonctions, vous pouvez faire:

    x = 1
print(PreIncrement('x'))   #print(x+=1) is illegal!

    Mais à mon avis l'approche suivante est beaucoup plus claire:

    x = 1
x+=1
print(x)

    Décrémentation les opérateurs:

    def PreDecrement(name, local={}):
    #Equivalent to --name
    if name in local:
        local[name]-=1
        return local[name]
    globals()[name]-=1
    return globals()[name]

def PostDecrement(name, local={}):
    #Equivalent to name--
    if name in local:
        local[name]-=1
        return local[name]+1
    globals()[name]-=1
    return globals()[name]+1

    J'ai utilisé ces fonctions dans mon module de traduction de javascript pour python.

    • Remarque: lors de la grande, ces méthodes d'aide ne fonctionne pas si votre locaux existent sur la fonction de classe frame de pile. j'.e - l'appel à une méthode de la classe de def ne fonctionne pas - les " locals()' dict est un instantané, et de ne pas mettre à jour le cadre de la pile.
    InformationsquelleAutor Piotr Dabkowski
  5. 9

    En Python, une distinction entre les expressions et instructions est rigidement
    appliquée, contrairement à des langages tels que Common Lisp, Scheme, ou
    Ruby.

    Wikipédia

    Par l'introduction de tels opérateurs, vous briserait l'expression ou la déclaration de split.

    Pour la même raison, vous ne pouvez pas écrire

    if x = 0:
  y = 1

    que vous pouvez dans certaines autres langues où cette distinction n'est pas conservé.

    InformationsquelleAutor Vitalii Fedorenko
  6. 4

    Ouais, j'ai raté ++ et -- fonctionnalité ainsi. Quelques millions de lignes de code c enracinée de ce genre de pensée dans ma vieille tête, et plutôt que de le combattre... Voici une classe que j'ai pavées qui met en œuvre:

    pre- and post-increment, pre- and post-decrement, addition,
subtraction, multiplication, division, results assignable
as integer, printable, settable.

    Ici, c'est:

    class counter(object):
    def __init__(self,v=0):
        self.set(v)

    def preinc(self):
        self.v += 1
        return self.v
    def predec(self):
        self.v -= 1
        return self.v

    def postinc(self):
        self.v += 1
        return self.v - 1
    def postdec(self):
        self.v -= 1
        return self.v + 1

    def __add__(self,addend):
        return self.v + addend
    def __sub__(self,subtrahend):
        return self.v - subtrahend
    def __mul__(self,multiplier):
        return self.v * multiplier
    def __div__(self,divisor):
        return self.v / divisor

    def __getitem__(self):
        return self.v

    def __str__(self):
        return str(self.v)

    def set(self,v):
        if type(v) != int:
            v = 0
        self.v = v

    Vous pouvez l'utiliser comme ceci:

    c = counter()                          # defaults to zero
for listItem in myList:                # imaginary task
     doSomething(c.postinc(),listItem) # passes c, but becomes c+1

    ...ayant déjà c, vous pourriez le faire...

    c.set(11)
while c.predec() > 0:
    print c

    ....ou tout simplement...

    d = counter(11)
while d.predec() > 0:
    print d

    ...et pour (ré)affectation en entier...

    c = counter(100)
d = c + 223 # assignment as integer
c = c + 223 # re-assignment as integer
print type(c),c # <type 'int'> 323

    ...tout cela maintiendra c type de compteur:

    c = counter(100)
c.set(c + 223)
print type(c),c # <class '__main__.counter'> 323

    EDIT:

    Et puis il y a ce peu d'inattendu (et à fond indésirables) le comportement,

    c = counter(42)
s = '%s: %d' % ('Expecting 42',c) # but getting non-numeric exception
print s

    ...parce qu'à l'intérieur que tuple, getitem() n'est pas utilisé, à la place d'une référence à l'objet est passé à la mise en forme de la fonction. Soupir. Donc:

    c = counter(42)
s = '%s: %d' % ('Expecting 42',c.v) # and getting 42.
print s

    ...ou, plus avec beaucoup de détails, et explicitement ce que nous voulions qu'il se passe, bien que contre-indiqué en forme par le niveau de verbosité (utiliser c.v à la place)...

    c = counter(42)
s = '%s: %d' % ('Expecting 42',c.__getitem__()) # and getting 42.
print s
    InformationsquelleAutor fyngyrz
  7. 1

    TL;DR

    Python n'a pas unaire incrémentation/décrémentation les opérateurs (--/++). Au lieu de cela, pour incrémenter une valeur, utiliser 

    a += 1

    Plus de détails et de pièges

    Mais être prudent ici. Si vous venez à partir de C, ce qui est différent en python. Python n'a pas de "variables" dans le sens que C ne, à la place python utilise noms et objets, et en python ints sont immuables.

    donc permet de dire que vous ne

    a = 1

    Ce que cela signifie dans le langage python est: créer un objet de type int avoir de la valeur 1 et de lier le nom a à elle. Le objet est une instance de int avoir de la valeur 1, et la nom a se réfère à elle. Le nom a et l'objet auquel il se réfère sont distincts.

    Maintenant, disons que vous ne 

    a += 1

    Depuis ints sont immuables, ce qui se passe ici est comme suit:

    1. chercher l'objet qui a fait référence (c'est un int avec l'id 0x559239eeb380)
    2. rechercher la valeur de l'objet 0x559239eeb380 (c'est 1)
    3. ajouter 1 à la valeur de (1 + 1 = 2)
    4. créer un nouveau int objet avec la valeur 2 (il a id d'objet 0x559239eeb3a0)
    5. relier le nom a à ce nouvel objet
    6. Maintenant a se réfère à l'objet 0x559239eeb3a0 et de l'objet d'origine (0x559239eeb380) n'est plus référencé par le nom de a. Si il n'y a pas d'autres noms se référant à l'objet d'origine, il sera déchets ramassés plus tard.

    Essayez-les vous-même:

    a = 1
print(hex(id(a)))
a += 1
print(hex(id(a)))
    InformationsquelleAutor RBF06