Ciclos anidados

Los ciclos anidados suelen usarse para llenar matrices (un vector de varias dimensiones) donde un ciclo recorre cada fila y otro cada columna o viceversa

Segun el caso, los ciclos anidados yo los asimilo a las muñecas rusas, “Matrioshkas”

Con la premisa que se resuelven de afuera hacia adentro

Como pueden ver el resultado del profe, primero imprimio la “fila” y luego la “columna”

for row in matriz:
	print(row)
	for column in row:
		print(column) 

'''print
[1, 2, 3]
1
2
3
[4, 5, 6]
4
5
6
[7, 8, 9]
7
8
9
'''

Un reto divertido, espero les guste:

El código:

def anidado_uno():
    for row in range(1, 12):
        a = ''
        for x in range(1, row):
            a = a + 'x'
        print(a)


def anidado_dos():
    for row in range(1, 12):
        a = 12 - row
        toPrint = ''
        for _ in range(1, a):
            toPrint = toPrint + 'x'
        print(toPrint)


def run():
    anidado_uno()
    print('=='*8)
    anidado_dos()


if __name__ == '__main__':
    run()

Que buena clase! 💚

Les comparto el código

# Ciclos anidados

matriz = [
  [1, 2, 3], 
  [4, 5, 6], 
  [7, 8, 9]
]

# Imprime la primera fila de la matriz
print(matriz[0])

# Imprime el elemento 2 de la primera fila
print(matriz[0][1])

'''
Recorremos las filas de la matriz y por cada fila recorremos cada una de las columnas
'''
for row in matriz:
  print(row)
  for column in row:
    print(column)

MATRIZ : datos organizados
Filas y Columnas

For anidados

Es posible anidar los for, es decir, meter uno dentro de otro. Esto puede ser muy útil si queremos iterar algún objeto que en cada elemento, tiene a su vez otra clase iterable.

→ 56, 34, 1, 12, 4, 5, 9, 4, 3

Al bucle que se encuentra dentro del otro se le puede denominar bucle interior o bucle interno. El otro bucle sería el bucle exterior o bucle externo.

Es recomendable que los nombres de las variables de control de los bucles anidados no coincidan, para evitar ambigüedades.

Los ciclos anidados en Python se refieren a la situación en la que un ciclo está contenido dentro de otro ciclo. Esto significa que hay un bucle interno que se ejecuta repetidamente dentro de un bucle externo.

Los ciclos anidados son útiles cuando se necesita iterar sobre una estructura de datos multidimensional, como una matriz bidimensional o una lista de listas. Con los ciclos anidados, es posible acceder y procesar cada elemento de manera sistemática en una estructura de datos compleja.

Que buen curso, aprendi un monto con los ejercicios de Playground!!

""" Loops """
matriz = [
  [34, 82, -21],
  [-1, 73, -48],
  [59, 0.3, 13]
]
for i in matriz:
  print(i)

for i in matriz:
  for j in i:
    print(j)
print(matriz[0][2])

print("-" * 35)
matriz_2 = [
  [1,2,3],
  [4,5,6],
  [7,8]
]
for i in matriz_2:
  print(i)

for row in matriz_2:
  for column in row:
    print(column)

Practicando un poco más:

def run():

    super_list = [
        {"firstname" : "Fabián", "lastname" : "Beltran"},
        {"firstname" : "Maria", "lastname" : "Rivera"},
        {"firstname" : "Karen", "lastname" : "Agredo"},
        {"firstname" : "Zury", "lastname" : "Beleño"},
        {"firstname" : "Yuliza", "lastname" : "Mujica"}
    ]

    super_dict = {
        "natural_nums" : [1,2,3,4,5],
        "integer_nums" : [-1,-2,0,1,2],
        "floating_nums": [1.1, 4.5, 6.43, 5.86]
    }

    for key,value in super_dict.items():
        print(key, " - ", value)


    print("\n===========================================\n")

    for a in super_list:
        for k,v in a.items():
            print(k, " - ", v)


    print("\n===========================================\n")

    for a in super_list:
        print(f'{a["firstname"]} {a["lastname"]}')


if __name__ == '__main__':
    run()

No es recomendable anidar ciclos para matrices grandes, para mayor referencia ver la teoría de la notación Big O y las mejores prácticas para el diseño de algoritmos.

conocer esto es bueno, aunque no siempre lo vamos a utilizar.

Estoy impresionado con este concepto de matrices. Ahora toca implementarlo.

Aqui un ejemplo basico utilizando ciclos anidados.
Tabla de multiplicacion del 1 al 10.

for i in range(1, 11):  # Ciclo exterior que itera sobre los números del 1 al 10
    for j in range(1, 11):  # Ciclo interior que itera sobre los números del 1 al 10
        resultado = i * j  # Multiplicamos los números i y j
        print(f"{i} x {j} = {resultado}")  # Imprimimos el resultado

se que no tiene nada que ver pero lo quise hacer también en código php.

$arra = [
    [14, 5, 7],
    [18, 4, 1],
    [19, 5, 2]
];

for ($i=0; $i < count($arra) ; $i++) { 
    for ($a=0; $a < count($arra) ; $a++) {
        echo $arra[$i][$a]."<br>";
    }
}

falto la clase de los conjuntos

for row in matriz:
    for column in row:
        print(column, end = " ")
    print()

matriz = [
    [1,2,3],
    [4,5,6],
    [7,8,9]
]
print(matriz)       # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matriz[0])    # [1, 2, 3]
print(matriz[1])    # [4, 5, 6]
print(matriz[2])    # [7, 8, 9]
print(matriz[0][0]) # 1
print(matriz[1][2]) # 6
print(matriz[2][1]) # 8

✅

# Primer ciclo: Abre la caja grande (3 veces)
for caja_grande in range(3):
    # Segundo ciclo: Abre la cajita pequeña dentro de la caja grande (2 veces)
    for cajita_pequeña in range(2):
        # Tercer ciclo: Cuenta las piezas de LEGO en la cajita pequeña (5 veces)
        for pieza_de_lego in range(5):
            print("¡Encontré una pieza de LEGO!")

# ¡Has contado todas las piezas de LEGO!

Deseas ser :
'Tijera’
ecribe s, ó n,
y
tu turno…Tijera

el juego… Papel

GANASTE¡¡¡

import random
i = 0
coin = True

while coin:
  element = [
      ["Piedra", "Papel", "Tijera"],
      [0, 1, 2],
      ]
  select = input("Deseas ser :\n'"+ element[0][i]+"' \necribe s, ó n, \n").lower()
  
  if select == "s" or select == "si" or select == "y" or select == "yes":
    player = element[1][i]

    print("tu turno.........."+ element[0][i] )
    print("")
    pc = random.choice(element[1])
    print("\nel juego..........",element[0][pc] )
    print("")
    if player == pc:
      print(" => EMPATE <= ")
      nuevo = input("\nnuevo juego  \necribe s, ó n, \n").lower()
      if nuevo == "s" or nuevo == "si" or nuevo == "y" or nuevo == "yes":
        print("\nnueva partida ")
        continue
      else:
        print("\ncerrando juego ")
        coin = False
        break
    if player - 1 == pc or player + 2 == pc:
      print(" GANASTE¡¡¡ ")
      nuevo = input("nuevo juego  \necribe s, ó n, \n").lower()
      if nuevo == "s" or nuevo == "si" or nuevo == "y" or nuevo == "yes":
        print("\nnueva partida ")
        continue
      else:
        print("\ncerrando juego ")
        coin = False
    else:
      print("SUERTE PARA LA PROXIMA...")
      nuevo = input("nuevo juego  \necribe s, ó n, \n").lower()
      if nuevo == "s" or nuevo == "si" or nuevo == "y" or nuevo == "yes":
        print("\nnueva partida ")
        continue
      else:
        print("\ncerrando juego ")
        coin = False

  else:
    i += 1
    if i == 3:
      i = 0

Un ejemplo de loop anidado

for i in range(1, 13):  # Loop exterior para las filas (del 1 al 10)
    for j in range(1, 13):  # Loop interior para las columnas (del 1 al 10)
        resultado = i * j
        print(f"{i} x {j} = {resultado}")
    print('\n ')

import random

while True:
    print("¡Juguemos a ... Piedra, papel o tijera!")
    print("1) Piedra\n2) Papel\n3) Tijera")
    
    # Ingreso de opción para el usuario
    user_option = int(input("¿Cuál es tu opción? (Ingresa el número correspondiente): "))
    
    option_tuple = (1, 2, 3)
    
    # Ingreso de opción de la computadora (número aleatorio del 1 al 3)
    computer_option = random.choice(option_tuple)
    
    # Computadora saca esta opción.
    print("La computadora saca:", computer_option)
    
    # Evaluamos con if
    if user_option == computer_option:
        print("¡Empate!, wow, empataste a la computadora")
    elif user_option == 1 and computer_option == 2:
        print("¡Pierdes!... Computadora saca papel, papel envuelve piedra.")
    elif user_option == 1 and computer_option == 3:
        print("¡Ganas!... Computadora sacó tijera, piedra rompe tijera.")
    elif user_option == 2 and computer_option == 1:
        print("¡Ganas!... Computadora sacó piedra, papel envuelve a la piedra.")
    elif user_option == 2 and computer_option == 3:
        print("¡Pierdes!... Computadora 1sacó tijera, tijera rompe papel.")
    elif user_option == 3 and computer_option == 1:
        print("¡Pierdes!... Computadora sacó piedra, piedra rompe tijera.")
    elif user_option == 3 and computer_option == 2:
        print("¡Ganas!... Computadora sacó papel, tijera rompe papel.")
    else:
        print("Elige una opción válida, ¡inténtalo de nuevo!")
    
    play_again = input("¿Quieres jugar de nuevo? (s/n): ")
    
    if play_again.lower() != 's':
        print("Gracias por jugar. ¡Hasta luego!")
        break

Algo divertudi que se puede hacer.

x = 0
for row in range(1,12):
    x += 1
    col = "x" * row
    print(col)
    
y = 12
for colum in range(1, 12):
    y -= 1
    col = "x" * y
    print(col)

Documentación oficial:

https://docs.python.org/3/tutorial/datastructures.html?highlight=matrix

No termino entendiendo mucho las explicaciones.

muy buena clase

matriz = [[1,2,3],[‘Maria’,‘Luis’,‘Andrés’],[25.6,16.5,32.8]]

counter = 1
for fila in matriz:
for columna in fila:
print("Fila ",counter, “=>”, columna)
counter +=1

matriz = [[1,2,3],[4,5,6],[7,8,9]]
print(matriz)
print(matriz[0])

for fila in matriz:
print(fila)
for columna in fila:
print(columna)

matrix = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
print(matrix[0][1])

for row in matrix:
  print(row)
  for column in row:
    print(column)

En el ejemplo de la clase pasada, donde teníamos una lista y dentro de ella varios diccionarios, yo anide un bucle for para imprimir los valores, aquí los dejo el código:

people = [
  {
    'name': 'Manuel',
    'age': 12
  },
  {
    'name': 'Juan',
    'age': 10
  },
  {
    'name': 'Pedro',
    'age': 15
  },
]

for person in people:
  for key, value in person.items():
    print(f"{key}: {value}")

Los ciclos anidados en Python son una técnica de programación que consiste en utilizar un ciclo dentro de otro ciclo. Esto permite realizar operaciones más complejas al procesar estructuras de datos que tienen varias dimensiones, como matrices, listas de listas, entre otras.

Resumen de una venta de artículos utilizando for anidados. Esto se podía resolver con un solo for, pero el código no queda tan legible a comparación de cuando utilizamos for anidados.

#iteracion de tablas o matrices
matriz = [
  [1, 2, 3], 
  [4, 5, 6], 
  [7, 8, 9]
]
f=1
for fila in matriz:
  c=1
  for e in fila:
    print('fila',f,'columna',c,f'[{e}]')
    c+=1
  f+=1
# fila 1 columna 1 [1]
# fila 1 columna 2 [2]
# fila 1 columna 3 [3]
# fila 2 columna 1 [4]
# fila 2 columna 2 [5]
# fila 2 columna 3 [6]
# fila 3 columna 1 [7]
# fila 3 columna 2 [8]
# fila 3 columna 3 [9]

Para que salga en forma de matriz:

for element in matriz:
  # print(element)
  
  for item in element:
    if element.index(item)==2:
      print(item)
    else:
      print(item, end=" ")
    

#Ciclos anidados

matriz=[[1,2,3],
        [4,5,6],
        [7,8,9]]

print(matriz[0][1])

for elemento in matriz:
    print(elemento)
    for element in elemento:
        print(element)

def superposicion (list1, list2): # Toma dos listas
    for item in list1: # Cicla por los objetos de la lista 1
        for item2 in list2: # Cicla por los objetos de la lista 2
            if item == item2: # Compara el objeto actual del ciclado de la lista 1 con el objeto actual de la lista 2 si son iguales sigue la sentencia
                return True # Devuelve verdadero (que el objeto esta duplicado)
    return False # Se termina el bucle y si no hay ningún objeto duplicado devuelve falso

Imprime tablas de multiplicar

for tabla in range(1, 11):
print(’-------------------------------’)
input(‘Pulsa enter para siguiente tabla ‘)
print(’-------------------------------’)
print(‘Tabla del’, tabla)
print(’-------------------------------’)

for i in range(1, 11):
    print( tabla, '*', i, '=', i*tabla)      

matriz = [ [1,2,3], [4,5,6], [7,8,9]]
print (matriz [0][0]);print(matriz [0][1]);print(matriz [0][2]);print(matriz [1][0]);print(matriz [1][1]);print(matriz [1][2]);
for row in matriz: print(row)
for col in row: print(col)

matriz = [
  [1,2,3],
  [4,5,6],
  [7,8,9]
]
print(matriz[0][1])

for row in matriz:
  print(row)
  for column in row:
    print(column)

matriz = [
[1,2,3],
[4,5,6],
[7,8,9]
]
print(matriz[0][1])