web-dev-qa-db-fra.com

Que signifie + = en Python?

Je vois un code comme celui-ci par exemple en Python:

    if cnt > 0 and len(aStr) > 1:
        while cnt > 0:                  
            aStr = aStr[1:]+aStr[0]
            cnt += 1

Que signifie le +=?

pythonsyntax
10
aksr

a += b est essentiellement identique à a = a + b, sauf que:

  • + renvoie toujours un objet nouvellement alloué, mais += doit (mais ne doit pas obligatoirement) modifier l'objet en place s'il est mutable (par exemple, list ou dict, mais int et str sont immuables).
  • Dans a = a + b, a est évalué deux fois.

http://docs.python.org/reference/simple_stmts.html#augmented-assignment-statements

Si vous rencontrez l'opérateur += pour la première fois, vous vous demandez peut-être pourquoi il est important de pouvoir modifier l'objet en place au lieu d'en créer un nouveau. Voici un exemple:

# two variables referring to the same list
>>> list1 = []
>>> list2 = list1

# += modifies the object pointed to by list1 and list2
>>> list1 += [0]
>>> list1, list2
([0], [0])

# + creates a new, independent object
>>> list1 = []
>>> list2 = list1
>>> list1 = list1 + [0]
>>> list1, list2
([0], [])
69
Bastien Léonard
a += b

est dans ce cas le même que

a = a + b

Dans ce cas, cnt + = 1 signifie que cnt est augmenté de un.

Notez que le code que vous avez collé sera mis en boucle indéfiniment si cnt> 0 et len ​​(aStr)> 1.

Edit: quote Carl Meyer : `` [..] la réponse est généralement trompeuse. Il existe une différence subtile mais très significative entre + et + =, voir Réponse de Bastien . ''.

24
Stephan202

L'opérateur "python + =" de Google vous mène à http://docs.python.org/library/operator.html

Recherchez + = une fois la page chargée pour une réponse plus détaillée.

7
Gishu

Pour votre information: il semblerait que vous ayez une boucle infinie dans votre exemple ...

if cnt > 0 and len(aStr) > 1:
    while cnt > 0:                  
        aStr = aStr[1:]+aStr[0]
        cnt += 1
  • une condition pour entrer dans la boucle est que cnt est supérieur à 0
  • la boucle continue à s'exécuter tant que cnt est supérieur à 0
  • chaque itération de la boucle incrémente cnt de 1

Le résultat net est que cnt sera toujours sera supérieur à 0 et la boucle ne se terminera jamais.

1
STW

+= est l'opérateur d'addition in-place .

C'est la même chose que de faire cnt = cnt + 1. Par exemple:

>>> cnt = 0
>>> cnt += 2
>>> print cnt
2
>>> cnt += 42
>>> print cnt
44

L'opérateur est souvent utilisé de la même manière que l'opérateur ++ dans les langages C-ish, pour incrémenter une variable d'une unité dans une boucle (i += 1).

Il existe des opérateurs similaires pour la soustraction/multiplication/division/puissance et autres:

i -= 1 # same as i = i - 1
i *= 2 # i = i * 2
i /= 3 # i = i / 3
i **= 4 # i = i ** 4

L'opérateur += fonctionne également sur les chaînes, par exemple:

>>> s = "Hi"
>>> s += " there"
>>> print s
Hi there

Les gens ont tendance à ne pas le faire pour des raisons de performances, mais pour la plupart des scripts, ce n'est pas vraiment un problème. Pour citer les docs "Sequence Types" :

  1. Si s et t sont tous les deux des chaînes, certaines implémentations de Python telles que CPython peuvent généralement effectuer une optimisation sur place pour les assignations de la forme s = s + t ou s + = t. Le cas échéant, cette optimisation rend le temps d’exécution quadratique beaucoup moins probable. Cette optimisation dépend à la fois de la version et de la mise en œuvre. Pour le code sensible aux performances, il est préférable d'utiliser la méthode str.join (), qui garantit des performances de concaténation linéaire cohérentes d'une version à l'autre et d'une implémentation.

La méthode str.join () fait référence à ce qui suit:

mysentence = []
for x in range(100):
    mysentence.append("test")
" ".join(mysentence)

.. au lieu de la plus évidente:

mysentence = ""
for x in range(100):
    mysentence += " test"

Le problème avec ce dernier est (mis à part l'espace de début), en fonction de l'implémentation Python, l'interpréteur Python devra créer une nouvelle copie de la chaîne en mémoire chaque fois que vous l'ajoutez (car les chaînes sont immuables), lentement, plus la chaîne à ajouter est longue, plus lente est longue. Considérant que l'ajout à une liste, puis sa réunion dans une chaîne est une vitesse constante (quelle que soit la mise en oeuvre)

Si vous manipulez des chaînes de base, ne vous en faites pas. Si vous voyez une boucle qui consiste simplement à ajouter une chaîne, envisagez de construire un tableau, puis "".join() '.

0
dbr