Particularidades de Python: For-Next

Nota: En los ejemplos he tenido que usar un caracter (elejí | ) antes de cada linea, para poder simular el tabulado. Lamentablemente, Blogger no respeta los tabulados.

Una de las particularidades del Python es la forma en que trabaja su ciclo for-next. El ciclo for-next existe desde tiempos remotos, pero para nuestros propósitos examinaremos algunos casos en Basic y C como para ver como trabajan. Para que lo entiendan mejor, eliminé algunas partes de los programas, por lo que no veran encabezados, declaraciones de variables, ni cosas similares.

El propósito del ciclo for-next es sencillamente el de repetir una serie de comandos una determinada cantidad de veces. Una variable, que es la que controla el ciclo, va cambiando de valor en cada iteración, en este caso la he llamado "i". La variable "i" tomará el valor 1 al comenzar el primer ciclo, 2 al comenzar el segundo, y así hasta 10. En cada una de esas iteraciones se ejecutaran los comandos incluidos en el espacio donde yo he escrito "instrucciones"

En el caso del Basic la instrucción es muy sencilla

|For i = 1 To 10
| instrucciones
|Next i

Algunas versiones de Basic permiten solo este uso, otras versiones de Basic y Pascal permiten el agregado del la subinstrucción optativa (o sea que se puede poner o no) llamada Step, que permite regular la forma en que se va modificando la variable "i". El Step por defecto es 1, o sea que si no usamos el subcomando Step, el ciclo for-next se comportará como un ciclo for-next común.



La versión de C es un poco más compleja, pero a la vez más potente.

|for (i=1 ; i <= 10 ; i++) instrucciones;

Esto se entiende así:

El primer término, i=1, es el inicializador del ciclo, hace que la variable tome el valor 1 para el primer ciclo, y luego no usa este dato para el resto de los ciclos.

El segundo término, i <= 10, es una comparación. Mientras esa condición se cumpla, el ciclo se seguirá repitiendo. El tercero es el término más importante, i++ indica que incremente en 1 el valor de la variable "i" al final de cada ciclo. Esto es equivalente a poner i = i+1, y lo que es más, este término puede contener otro tipo de declaraciones, algunas bastante complejas. Como veran, si bien el de C es más complejo y a la vez más potente (permite más modificaciones), no deja de ser una mejora simple sobre algo ya conocido.


En el caso de Python, el ciclo for-next es distinto. En lugar de usar esas declaraciones, inicializadores de variables, o lo que sea, el Python utiliza su ciclo for-next para iterar entre los componentes de una lista de datos suministrada. En un principio, esto me desagradó un poco, ya que obliga a realizar un paso extra, generar la lista de datos, pero una vez que se lo comienza a usar, realmente demuestra que este cambio de concepto agregó muchísima potencia.

la sintaxis del for-next en Python es sencilla:

|for i in lista:
| instrucciones

El tabulado, que queda muy bonito y ayuda a clarificar el código, es parte integral del Python. El tabulado (o espaciado, o escalonado) es la forma en que Python controla donde comienza y donde termina cada bloque de instrucciones.

Por supuesto, para usar este for-next, deberé crear una lista, en este caso de números del 1 al 10. Para eso Python provee una función llamada range, que devuelve una lista de enteros, con step optativo incluido. En este caso alcanzaría con hacer

|for i in range (1,11):
| instrucciones

Pero vayamos a la parte interesante del asunto: Dijimos que el for-next de Python itera entre los componentes de una lista, pero no discutimos aun las posibilidades que eso representa, ya que el manejo de listas en Python es muy poderoso.

Voy a copiar algunos ejemplos desde la linea de comandos Python para que vean lo que se puede hacer con listas.

|>>> lista = range (1,11)
|>>> lista
|[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|>>> lista.append(54)
|>>> lista
|[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 54]


|>>> lista = range (1,11)
|>>> lista
|[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|>>> lista.insert (4,4.5)
|>>> lista
|[1, 2, 3, 4, 4.5, 5, 6, 7, 8, 9, 10]
|>>> lista.remove(5)
|>>> lista
|[1, 2, 3, 4, 4.5, 6, 7, 8, 9, 10]


Miren esto ahora


|>>> texto = 'supercaligragilisticoespialidoso'
|>>> texto
|'supercaligragilisticoespialidoso'
|>>> lista = list (texto)
|>>> lista
|['s', 'u', 'p', 'e', 'r', 'c', 'a', 'l', 'i', 'g', 'r', 'a', 'g', 'i', 'l', 'i', 's', 't', 'i', 'c', 'o', 'e', 's', 'p', 'i', 'a', 'l', 'i', 'd', 'o', 's', 'o']
|>>> lista.sort()
|>>> lista
|['a', 'a', 'a', 'c', 'c', 'd', 'e', 'e', 'g', 'g', 'i', 'i', 'i', 'i', 'i', 'i', 'l', 'l', 'l', 'o', 'o', 'o', 'p', 'p', 'r', 'r', 's', 's', 's', 's', 't', 'u']
|>>> lista.reverse()
|>>> lista
|['u', 't', 's', 's', 's', 's', 'r', 'r', 'p', 'p', 'o', 'o', 'o', 'l', 'l', 'l', 'i', 'i', 'i', 'i', 'i', 'i', 'g', 'g', 'e', 'e', 'd', 'c', 'c', 'a', 'a', 'a']

Pero esto son listas de letras, letras equivale a decir texto....si, asi es, el for-next de Python trabaja con listas de lo que sea, si son listas de números, trabaja con números, si son listas de texto, trabaja con textos, si son listas con texto y números mezclados, trabaja con eso también, será responsabilidad del programador diferenciarlo luego dentro del ciclo, pero el for-next lo maneja sin problemas. Es que todo en Python es un objeto, las variables numericas son objetos de tipo númerico, que es un tipo de objeto predefinido, lo mismo para los textos, y este for-next
trabaja con cualquier lista de objetos.

Por último, un ejemplo usando listas de texto (estoy usando la lista de texto del ejemplo anterior)

|>>> f=0
|>>> for a in lista:
| lista[f]= a+a
| f=f+1

|>>> lista
|['uu', 'tt', 'ss', 'ss', 'ss', 'ss', 'rr', 'rr', 'pp', 'pp', 'oo', 'oo', 'oo', 'll', 'll', 'll', 'ii', 'ii', 'ii', 'ii', 'ii', 'ii', 'gg', 'gg', 'ee', 'ee', 'dd', 'cc', 'cc', 'aa', 'aa', 'aa']

Espero que estén de acuerdo conmigo, lo que se pierde en comodidad al tener que declarar los for-next comunes mediante range, se gana en la flexibilidad con que se puede implementar una lista para trabajar con esta instrucción, haciendola tremendamente potente.