Comportamiento de los operadores de incremento y decremento en Python

Posteriormente a observar en varios repositorios y sitios webs de internet finalmente descubrimos la resolución que te enseñaremos a continuación.

Solución:

++ no es un operador. Son dos + operadores. los + el operador es el identidad operador, que no hace nada. (Aclaración: la + y - los operadores unarios solo funcionan con números, pero supongo que no esperaría un hipotético ++ operador para trabajar en cadenas.)

++count

Analiza como

+(+count)

que se traduce en

count

Tienes que usar el un poco más largo. += operador para hacer lo que quieres hacer:

count += 1

sospecho que ++ y -- los operadores quedaron fuera por consistencia y simplicidad. No sé el argumento exacto que dio Guido van Rossum para la decisión, pero puedo imaginar algunos argumentos:

• Análisis más simple. Técnicamente, analizar ++count es ambigua, como podría ser +, +, count (dos unarios + operadores) tan fácilmente como podría ser ++, count (uno unario ++ operador). No es una ambigüedad sintáctica significativa, pero existe.
• Lenguaje más simple. ++ no es más que un sinónimo de += 1. Fue una abreviatura inventada porque los compiladores de C eran estúpidos y no sabían cómo optimizar a += 1 en el inc instrucciones que tienen la mayoría de las computadoras. En esta época de optimización de compiladores y lenguajes interpretados por código de bytes, agregar operadores a un lenguaje para permitir que los programadores optimicen su código generalmente está mal visto, especialmente en un lenguaje como Python que está diseñado para ser consistente y legible.
• Efectos secundarios confusos. Un error común de novato en idiomas con ++ los operadores están mezclando las diferencias (tanto en la precedencia como en el valor de retorno) entre los operadores de incremento/decremento previos y posteriores, y a Python le gusta eliminar el lenguaje “gotcha”-s. Los problemas de precedencia de pre-/post-incremento en C son bastante complicados e increíblemente fáciles de estropear.

Cuando desea aumentar o disminuir, normalmente desea hacerlo en un número entero. Al igual que:

b++

Pero en Python, los enteros son inmutable. Es decir, no puedes cambiarlos. Esto se debe a que los objetos enteros se pueden usar con varios nombres. Prueba esto:

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

a y b arriba son en realidad el mismo objeto. Si incrementaste a, también incrementarías b. Eso no es lo que quieres. Así que tienes que reasignar. Como esto:

b = b + 1

O más simple:

b += 1

que reasignará b a b+1. Eso no es un operador de incremento, porque no incrementa blo reasigna.

En resumen: Python se comporta de manera diferente aquí, porque no es C, y no es un contenedor de código de máquina de bajo nivel, sino un lenguaje dinámico de alto nivel, donde los incrementos no tienen sentido y tampoco son tan necesarios como en C , donde los usa cada vez que tiene un bucle, por ejemplo.

Mientras que las otras respuestas son correctas en la medida en que muestran lo que un mero + suele hacer (es decir, dejar el número como está, si es uno), son incompletos en la medida en que no explican lo que sucede.

Para ser exacto, +x evalúa a x.__pos__() y ++x a x.__pos__().__pos__().

Podría imaginar una estructura de clases MUY extraña (niños, ¡no hagan esto en casa!) como esta:

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)

Si sostienes alguna sospecha o forma de ascender nuestro reseña puedes dejar una crónica y con gusto lo estudiaremos.

---

---

Utiliza Nuestro Buscador