Programación en Python

P=A+D
NOTA:

Tené siempre a mano tu PP con un detalle de todas las herramientas, su formato y

variaciones de uso.

Como ya vimos, un Ciclo repite un bloque de sentencias (al que llamamos Cuerpo del Ciclo).
Por supuesto que ese Cuerpo puede estar conformado con cualquier combinación y
cantidad de sentencias válidas de PYTHON. Por lo tanto, resulta obvio suponer que dentro
de un Ciclo pueda haber otro. Cuando se da esto, decimos que los Ciclos están anidados. El
FCP de un programa ejecuta un Bucle hasta salir y recién sigue por la sentencia siguiente al
Bucle. Por lo tanto, cuando el FCP ingrese a un Ciclo interno (que está dentro de otro más
externo), se quedará repitiendo este hasta finalizar y recién proseguirá ejecutando el
Cuerpo del más externo. Por ello, los Cuerpos de Bucles internos siempre se ejecutan más
seguido que los de los externos.

¿Cuántos niveles de anidamiento se puede tener?

Los que necesites…

Sólo debés considerar:

 Siempre se repiten más los de adentro que los de afuera. Como las agujas de un reloj
analógico; la aguja minutera recorre toda la circunferencia más veces que la de la
hora
 Cuando hay varios Ciclos anidados hay que tener mucho cuidado de no alterar
dentro de uno interno la variable de control de un bucle externo. Para ser ordenados
y evitar problemas, cada bucle con su/s variables de control!!! Los relojes que
emplean misma aguja para horas, minutos y segundos, no son muy prácticos!!!
Acá tenés un ejemplo gráfico de tres Bucles anidados:

La segunda parte del TP3 consiste en ejercicios para hacer gráficos sencillos de dos
dimensiones. El objetivo de esta tarea no es incorporar herramientas de graficación, sino
sencillamente practicar anidamiento de ciclos; algo muy útil y que requiere un poco de
entrenamiento. Por ello, emplearemos print(), con un uso bastante limitado. Sabemos que
print() muestra por pantalla lo que se le pida en la posición en la que esté el cursor. Va
saturando de izquierda a derecha y cuando finaliza la línea sigue en la de abajo desde la
primera columna. No podemos escribir de derecha a izquierda; ni podemos volver a un
renglón superior usando print().

Este es un paso a paso que te ayudará con los ejercicios:

Para obtener la siguiente salida:

*
*
*
 Programación en Python

El programa que debes escribir es:

print('*')
print('*')
print('*')
exit()

Y si quiero la siguiente:

***
Debería ser:

print('***')
exit()

Ahora…

¿Si quisiera generar la primera salida para una cantidad n de asteriscos; donde n la ingresa
el usuario?

n=int(input('Ingrese largo (debe ser menor que 21): '))

while n>20:
n=int(input('Ingrese largo (debe ser menor que 21): '))
for i in range(n):
print('*')
exit()

¿Por qué coloco el límite de 20?

Al ocupar los dibujos el espacio de un carácter con cada asterisco, la pantalla de salida
tendrá una definición de aproximadamente 24x80 caracteres (en realidad, en la ventana de
ejecución del IDLE tenemos unas lineas más). Si ocupás más de 80 columnas los asteriscos
seguirán imprimiéndose en la fila siguiente desde la izquierda. Y si usás más de 24 filas, sólo
verás las últimas 24, ya que la pantalla scrollará automáticamente. Máximos de 20x70
sobran para esta práctica.

Ahora repensá la segunda salida:

n=3 ***

n=6 ******

n=11 ***********
n=int(input('Ingrese ancho (menor o igual que 70): '))
while n>70:
n=int(input('Ingrese ancho (menor o igual que 70): '))
for i in range(n):
print('*',end='')
exit()

Intentá mostrar un cuadrado de * con su lado n a definir por el usuario

Ej:

n=4 * * * *
* * * *
* * * *
* * * *

n=2 * *
* *
Antes que nada debés pensar qué límites de valores te conviene que tenga n.

Luego probá escribir un programa que resuelva esto…

Pensá una versión propia… Y luego mirá la mía.

n=int(input('Ingrese ancho ( 2-20 ) :'))

while (n<2)or(n>20):
n=int(input('Ingrese ancho ( 2-20 ) :'))
for i in range(n):
for j in range(n):
print('*',end='')
print()
exit()
 Programación en Python

Si te fijás, lo único que hicimos fue repetir n veces la impresión de la línea a lo ancho que
hicimos en el programa anterior… Porque el cuadrado se forma con n líneas de n *

n=int(input('Ingrese ancho ( 2-20 ) :'))

while (n<2)or(n>20):
n=int(input('Ingrese ancho ( 2-20 ) :'))
for i in range(n):
for j in range(n):
Código para dibujar la línea de *
print('*',end='')
print()
exit()

¿Podés extender esto al concepto genérico de un rectángulo?

¿Cómo modificarías el programa anterior?

Nuevamente verás una opción mía a continuación…

n=int(input('Ingrese ancho ( 2-70 ) :'))

while (n<2)or(n>70):
n=int(input('Ingrese ancho ( 2-70 ) :'))
m=int(input('Ingrese alto ( 2-20 ) :'))
while (n<2)or(n>20):
m=int(input('Ingrese alto ( 2-20 ) :'))
for i in range(m):
for j in range(n):
print('*',end='')
print()
exit()
Ahora te propongo dibujar un cuadrado vacío…

n=3 * * *
* *
* * *

n=6 * * * * * *
* *
* *
* *
* *
* * * * * *

¿Cómo podrías modificar los ejercicios anteriores para resolver este caso?

Observá que el espacio o blanco (‘ ‘) es un carácter imprimible…

Acá tenés una opción:

n=int(input('Ingrese base ( 3-20 ) :'))

while (n<3)or(n>20):
n=int(input('Ingrese base ( 3-20 ) :'))
for i in range(n):
print('*',end='')
print()
for i in range(n-2):
print('*',end='')
for j in range(n-2):
print(' ',end='')
print('*')
for i in range(n):
print('*',end='')
exit()
 Programación en Python

¿Qué se hizo?

n=int(input('Ingrese base ( 3-20 ) :'))

while (n<3)or(n>20):
n=int(input('Ingrese base ( 3-20 ) :'))
for i in range(n):
print('*',end='') línea superior
print()

for i in range(n-2):
print('*',end='') recuadro interior
for j in range(n-2):
print(' ',end='')
print('*')

for i in range(n):
print('*',end='') línea inferior
exit()

Se consideró a la figura como la suma de tres figuras diferentes:

La línea de arriba, el centro, y la línea inferior. Y sabemos que por las limitaciones de print()
se debe dibujar primero completamente la línea superior, luego el centro (también
completando cada una de sus líneas de arriba para abajo) , y finalmente la línea inferior.

Por eso se trabajó por separado. Para realizar la línea superior, ya sabés cómo:

for i in range(n):
print('*',end='')
print()

El print() inferior permite seguir en la línea de abajo para completar el dibujo. Una porción
de código similar se empleó para la última línea. Entre esas partes del programa se dibujó
el centro, que es un rectángulo de n-2 líneas. Todas ellas comienzan con *, siguen con n-2
blancos y finalizan con *

for i in range(n-2):
print('*',end='')
for j in range(n-2):
print(' ',end='')
print('*')
Otra forma de realizarlo válida es:

n=int(input('Ingrese base ( 3-20 ) :'))

while (n<3)or(n>20):
n=int(input('Ingrese base ( 3-20 ) :'))
for i in range(1,n+1):
for j in range(1,n+1):
if (i==1)or(i==n)or(j==1)or(j==n):
print('*',end='')
else:
print(' ',end='')
print()
exit()

En este caso utilizamos un enfoque diferente. Visualizamos el gráfico como contenido en un

tablero imaginario de n filas x n columnas:

1 2 3 4 5
1 * * * * *
2 * *
3 * *
4 * *
5 * * * * *

Y nos limitamos a recorrerlo y pintar cada casillero con blanco o * según la posición del
casillero. Consideremos que i lleva el número de la fila y j el de la columna…

De ahí la condición que usamos:

if (i==1)or(i==n)or(j==1)or(j==n):
print('*',end='')
else:
print(' ',end='')

Es decir, si el casillero es de la primer fila, o de la última, o de la primer columna, o de la

última, va *. Caso contrario va blanco (' ').
 Programación en Python

Tips para ansiosos:

Una forma alternativa de escribir la condición:

En lugar de …
if (i==1)or(i==n)or(j==1)or(j==n):

Podría ser …
if (i in(1,n))or(j in (1,n)):

Esto significa que se verifica si i o j están en el grupo (1,n). Acá estamos usando una clase de
objeto llamada tupla, que veremos más adelante y el operador in que significa
pertenencia…
Por ejemplo, para verificar si un número es par y está entre 10 y 20 podemos escribir la
siguiente condición :
if (num%2==0)and(num>=10)and(num<=20):
o…
if num in(10,12,14,16,18,20):

Esta es una condición típica para saber si un número cae dentro de un rango:
(num>=10)and(num<=20) Puede ser reemplazada por: num in range(10,21)
Y ésta, aplicando De Morgan, es la condición típica para saber si un número cae fuera de
rango:
(num<=9)or(num>=21) Puede ser reemplazada por: not(num in range(10,21))
o… num not in range(10,21)

Finalmente proponemos graficar un triángulo rectángulo con el vértice hacia abajo,

recostado sobre la izquierda usando el último modelo de tablero…
Se ingresará la base del triángulo:
n=3 * * * n=7 * * * * * * *
* * * * * * * *
* * * * * *
* * * *
* * *
* *
*
Visualizá el tablero para n=5…

1 2 3 4 5
1 * * * * *
2 * * * *
3 * * *
4 * *
5 *

Si dibujamos un par de ejemplos de n no será complicado pensar en alguna función de

valores i y j ( filas y columnas ) para decidir si hacemos print de * o de blanco.

Aquí van un par de opciones:

n=int(input('Ingrese base ( 3-20 ) :'))

while not(n in range(3,21)):
n=int(input('Ingrese base ( 3-20 ) :'))
for i in range(1,n+1):
for j in range(1,n+1):
if j<=n+1-i:
print('*',end='')
else:
print(' ',end='')
print()
exit()

Otra versión, arrancando i y j en 0 y despejando i en la inecuación…

n=int(input('Ingrese base ( 3-20 ) :'))

while not(n in range(3,21)):
n=int(input('Ingrese base ( 3-20 ) :'))
for i in range(n):
for j in range(n):
if i<n-j:
print('*',end='')
else:
print(' ',end='')
print()
exit()
 Programación en Python

Corolario de la práctica:
1. Es cierto que el objetivo principal de esta práctica es entrenarte en el uso de ciclos
anidados; pero obtendrás, sin percatarte, una interesante práctica en el recorrido
estándar de matrices (como las de álgebra, con filas y columnas) y por ello, el
esfuerzo será doblemente recompensado.
2. Cuando no entiendas lo que hace un programa, realizale una Prueba de Escritorio. Es
INFALIBLE!!! (y te sirve para el coloquio final…)