Incremento de pitón por 1
Cuando te conoces con Python, probablemente sepa que las expresiones de incremento y disminución (tanto antes y después) no son compatibles. Python fue creado para ser comprensible y consistente. En la lingüística que tiene expresiones ++ y -, un programador principiante con frecuencia comete el error de confundir las distinciones entre las expresiones de incremento/disminución, Post y pre (tanto en valor de prioridad como de retorno). En comparación con muchos otros lenguajes de programación, las expresiones básicas de incremento y disminución no son tan necesarias. En este tutorial, aprenderemos sobre el incremento de 1 operador en el código de Python. Asegúrese de que debe tener una herramienta Python instalada y configurada en su sistema. Por lo tanto, hemos instalado la herramienta Spyder Python en nuestro sistema.
Ejemplo 01:
Nuestro primer ejemplo sería mirar cómo agregar incremento por 1 en cualquier código de Python. Abra primero la herramienta Spyder y nombre el archivo de código como prueba.py. En el área del código, escriba el siguiente código Python para incrementar 1 en una variable de tipo entero. Hemos agregado el soporte de Python en nuestra página Spyder primero. Puedes ver que hemos definido un entero x que tiene un valor de 0. Después de eso, hemos incrementado esta variable x con 1 usando el operador "+=" dentro de. Después de eso, hemos impreso la variable x para ver si el incremento por 1 funciona correctamente o no. Guarde el código y haga clic en el botón "Ejecutar" para ejecutar el código Python.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 0
x += 1
Imprimir (x)
Las ventanas de salida nos muestran que el valor de la variable x se ha incrementado en 1, ya que inicialmente era 0. Esto significa que la sintaxis utilizada anteriormente para incrementar cualquier variable por 1 es viable y confiable.
Ejemplo 02:
Echemos un vistazo a diferentes formas de incrementar una variable por 1. En este caso, nuevamente hemos agregado soporte de Python en la ventana Spyder. Después de eso, hemos declarado una variable x con un valor de 2. En la cuarta línea, hemos utilizado el signo de incremento "+" para agregar 1 en el valor anterior de x, y el resultado se ha guardado nuevamente en la variable x. Esto significa que el último valor ha estado anulando aquí. Después de eso, la declaración de impresión imprimirá el nuevo valor anulado. Guarde su código para ver los resultados. Toque el botón "Ejecutar" para interpretar el código.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 2
x = x + 1
Imprimir (x)
La salida muestra que el valor 2 de la variable x se ha incrementado en 1 y se convierte en 3. Entonces este valor se guardó nuevamente en la variable x e imprimió.
Ejemplo 03:
Como hemos mencionado anteriormente, los operadores de incremento y disminución no se pueden usar en el lenguaje de programación de Python, ya que no sirven de nada aquí. Verifiquemos si es cierto o no para limpiar la comprensión. Por lo tanto, hemos actualizado el código e inicializado una variable "n" que tiene un valor de 2. Luego hemos utilizado el operador previo al incremento para incrementar su valor y ahorrado ese valor en variable "n" nuevamente. Después de la declaración de impresión, hemos guardado el código y lo ejecutamos a través del signo "Ejecutar".
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
n = 2
n = ++ n
Imprimir (n)
Cuando hemos ejecutado el código, sabemos que el valor original no se ha incrementado, y la salida muestra el mismo valor original en su resultado. Esto significa que el operador previo al incremento no funciona aquí y no sirve de nada mientras se usa en la programación.
Vamos a ver el operador posterior al incremento ahora. Hemos usado el mismo código aquí nuevamente mientras reemplazamos el operador de preincremento con un operador posterior al incremento, como se muestra en el código a continuación.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
n = 2
n = n++
Imprimir (n)
La salida del código anterior devuelve un error de sintaxis diciendo que la sintaxis no es válida. Esto demuestra que los operadores de postes y preincrementos o decrementos no son de nada en Python.
Ejemplo 04:
Echemos un vistazo a un ejemplo simple para incrementar una variable con 1. Hemos utilizado una variable que tiene un valor de 0 al principio. El valor original se ha imprimido, y luego el valor se ha incrementado por 1 usando el signo "+=". Entonces el nuevo valor debería ser 1 ahora. El nuevo valor se imprimirá. Luego hemos usado nuevamente el operador "+=" para incrementar el valor en 30 esta vez e imprimirlo. Guardar el código y ejecutarlo a través del botón "Ejecutar".
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 0
Imprimir (x)
x += 1
Imprimir (x)
x += 30
Imprimir (x)
La siguiente salida muestra los resultados esperados. Primero muestra el valor original 0, y después del incremento de 1, imprime 1. Al final, el valor 1 ha sido incremento en 30, y se convierte en 31.
Ejemplo 05:
Usemos el operador incremento por 1 en cualquier valor de tipo de cadena y veamos sus resultados. En primer lugar, tomamos una variable entera "x" como lo hicimos en el ejemplo anterior. La variable x tiene un valor original de 0. Su valor se ha incrementado en 1 y después de eso por 31. Este es el mismo caso que discutimos anteriormente. Aquí viene otra variable, "y" que tiene el valor "aqsa". Luego hemos usado el signo "+=" para incrementar el valor de la variable "y" con 1. Lógicamente es incorrecto porque el valor entero no puede ser incremento en el valor de cadena. Entonces, debemos recibir un error al ejecutar este código. Entonces, guarde su código y ejecútelo.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 0
Imprimir (x)
x += 1
Imprimir (x)
x += 30
Imprimir (x)
y = 'aqsa'
y +-1
Imprimir (y)
Cuando imprimimos el código, el incremento realizado en la variable de tipo entero "X" ha tenido éxito y ha mostrado el valor incrementado cada vez. Pero en el caso de la variable "Y", lanza una excepción de "typeError" diciendo que los datos de tipo de cadena solo pueden concatenarse con cadena en lugar de datos de tipo entero.
Modifiquemos el código e incrementemos el valor "Y" entero por un valor de tipo de cadena, como se muestra en el código a continuación. Guarde su código y ejecute el archivo para verlos funcionando.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 0
Imprimir (x)
x += 1
Imprimir (x)
x +-30
Imprimir (x)
y = 'aqsa'
y += 'Yasin'
Imprimir (y)
Este tiempo mostró todos los valores incrementados, incluido el valor de incremento de tipo de cadena en la salida. Esto se debe a que el signo + se puede tomar como concatenación para las cadenas y no puede incrementar el valor entero en algún tipo de valor de cadena.
Ejemplo 06:
Comprender que no podemos usar operadores previos y posteriores al incremento o disminución en los bucles "para" también. Por lo tanto, hemos estado usando el operador "+=" en un bucle de tiempo para imprimir los valores de una lista.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
Lista = [12, 14, 16, 18, 20]
x = 0
mientras (x
x += 1
Tras la ejecución del código, tenemos los valores de la lista uno tras otro en una secuencia.
Ejemplo 07:
Veamos el efecto del incremento por 1 en una variable "ID" esta vez. Hemos inicializado una variable "x" con el valor 2 y verificamos su "ID" primero. Después de eso, tenemos que incrementarlo por 1 y verificar su "ID" una vez más. Guardar y ejecutar el código.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = 2 impresión (x)
Imprimir (ID (x))
x += 1
Imprimir (x)
Imprimir (ID (x))
Mientras que la ejecución del código, la salida muestra dos "ID" diferentes antes y después del incremento en 1. Esto significa cada vez que incrementamos o cambiamos una variable, su dinámica también cambia.
# -* -Codificación: UTF -8 -*-#!/usuario/bin/python
x = y = z = 2
Imprimir (ID (x))
Imprimir (ID (y))
Imprimir (ID (Z))
x += 1
Imprimir (ID (x))
Imprimir (ID (y))
Imprimir (ID (Z))
Conclusión:
Este tutorial discutió y vio cómo fallan los operadores Post y Pre-Increment o Decrement en Python. También hemos visto cómo usar diferentes formas de incrementar cualquier variable en 1. Espero que este artículo sea útil para usted mientras usa Python.