Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Resources
Learning how to automate the iteration process in lists using loops and iteration controls is fundamental to optimize data handling in Python.
How to iterate a list using a for loop?
To iterate over a collection of data, we can use a for loop. Here is how to access each element of a list of numbers from 1 to 6:
numbers = [1, 2, 3, 4, 4, 5, 6]for i in numbers: print(f"i is equal to: {i}").In this example, i represents each element of the numbers list.
How to iterate using the range function?
The range function allows you to generate a sequence of numbers. You can specify the start, end and step:
for i in range(10): print(i) # Print from 0 to 9for i in range(3, 10): print(i) # Print from 3 to 9.How to use conditionals inside a for loop?
You can include conditionals inside the for loop to perform specific operations:
fruits = ["apple", "pear", "grape", "grapes", "orange", "tomato"]for fruit in fruits: if fruit == "orange": print("orange found") print(fruit).How does the while loop work?
The while loop executes a block of code as long as a condition is met:
x = 0while x < 5: print(x) x += 1What to do to avoid infinite loops?
It is important to modify the condition inside the while loop to prevent it from executing indefinitely:
x = 0while x < 5: print(x) x += 1How to use break and continue in loops?
The break keyword is used to exit the loop prematurely, while continue skips the current iteration and moves on to the next one:
for i in numbers: if i == 3: breakprint(i) # Terminate on reaching 3for i in numbers: if i == 3: continueprint(i) # Skip 3Contributions 54
Questions 1
Sort by:
`range` genera un iterable (lista) con los valores de inicio inclusivo y final exclusivo.
Si se pasa solo un valor como iniciara en 0 (inclusivo) y terminará en el valor pasado por parámetro menos 1.
Si se le pasa dos parámetros el primero sera el inicio (inclusivo) y el segundo sera el final menos 1
Si se le pasa un tercer parámetro sera el step o número de saltos.
# Menú Interactivo con Bucle Infinito
Ejemplo de un menú interactivo que utiliza un bucle infinito para permitir múltiples interacciones hasta que el usuario decida salir.
```js
def mostrar_menu():
print("\nMenú:")
print("1. Opción 1")
print("2. Opción 2")
print("3. Opción 3")
print("4. Salir")
while True:
mostrar_menu()
opcion = input("Elige una opción (1-4): ")
if opcion == "1":
print("Has elegido la Opción 1")
elif opcion == "2":
print("Has elegido la Opción 2")
elif opcion == "3":
print("Has elegido la Opción 3")
elif opcion == "4":
print("Saliendo del programa...")
break
else:
print("Opción no válida. Inténtalo de nuevo.")
```
* **Función** `mostrar_menu`: Esta función imprime el menú de opciones.
* **Bucle** `while True`: El bucle se ejecuta indefinidamente.
* **Condiciones Internas**: Se utiliza `if`, `elif` y `else` para manejar las opciones del usuario.
* **Condición de Salida**: Si el usuario elige la opción "4", se utiliza `break` para salir del bucle.
La clase de list comprenhension no debería ir antes de explicar los condicionales y los bucles :c
Creo que sería mejor colocar la clase de List Comprehension después de este bloque de clases, creo mas sencillo comprender los bucles tradicionales y después la forma simplificada
### Bucle `for` en Python:
El bucle for elemento in secuencia: # Bloque de código a ejecutar repetidamente # Puedes utilizar el elemento actual (elemento) en el bloque de códigoEn cada iteración, `elemento` toma el valor del siguiente elemento de la `secuencia` y se ejecuta el bloque de código asociado. El bucle `for` termina cuando se agotan los elementos en la secuencia.`for` se utiliza para iterar sobre una secuencia (como una lista, tupla, diccionario, conjunto o cadena) o cualquier objeto iterable. La sintaxis general es:
```js
for elemento in secuencia:
# Bloque de código a ejecutar repetidamente
# Puedes utilizar el elemento actual (elemento) en el bloque de código
```
En cada iteración, `elemento` toma el valor del siguiente elemento de la `secuencia` y se ejecuta el bloque de código asociado. El bucle `for` termina cuando se agotan los elementos en la secuencia.
### Ejemplo de bucle # Iterar sobre una lista de nombres e imprimir cada nombre nombres = \["Juan", "María", "Carlos", "Ana"] for nombre in nombres: print(nombre) # Calcular la suma de los primeros 5 números naturales suma = 0 for num in range(1, 6): # range(1, 6) genera números desde 1 hasta 5 suma += num print("La suma de los primeros 5 números naturales es:", suma)`for`:
```js
# Iterar sobre una lista de nombres e imprimir cada nombre
nombres = ["Juan", "María", "Carlos", "Ana"]
for nombre in nombres:
print(nombre)
# Calcular la suma de los primeros 5 números naturales
suma = 0
for num in range(1, 6): # range(1, 6) genera números desde 1 hasta 5
suma += num
print("La suma de los primeros 5 números naturales es:", suma)
```
En este ejemplo:
* El primer bucle `for` itera sobre la lista `nombres` e imprime cada nombre en la lista.
* El segundo bucle `for` utiliza `range(1, 6)` para generar números del 1 al 5, y calcula la suma de estos números.
### Bucle `while` en Python:
El bucle `while` se utiliza para ejecutar un bloque de código mientras una condición especificada sea verdadera. La sintaxis general es:
```js
while condicion:
# Bloque de código a ejecutar repetidamente
# La condición se evalúa antes de cada iteración
```
El bloque de código dentro del bucle `while` se ejecuta repetidamente siempre que `condicion` sea verdadera. Si en algún momento la condición se evalúa como falsa, el bucle `while` termina y la ejecución continúa con el código después del bucle.
### Ejemplo de bucle `while`:
###
```js
# Contador hasta 5 usando un bucle while
contador = 1
while contador <= 5:
print(contador)
contador += 1 # Incrementa el contador en cada iteración
# Sumar números ingresados por el usuario hasta que se ingrese un cero
suma = 0
num = int(input("Ingrese un número (o 0 para salir): "))
while num != 0:
suma += num
num = int(input("Ingrese otro número (o 0 para salir): "))
print("La suma de los números ingresados es:", suma)
```
En este ejemplo:
* El primer bucle `while` cuenta del 1 al 5 e imprime cada número.
* El segundo bucle `while` solicita al usuario ingresar números y suma esos números hasta que se ingrese un cero.
donde encuentro ejercicios para practicar? estos deberian ser proveidos por platzi
Los \*\*bucles\*\* y el \*\*control de iteraciones\*\* son herramientas fundamentales en la programación que te permiten ejecutar un bloque de código repetidamente. Python ofrece varios tipos de bucles y mecanismos para controlar cómo se ejecutan estas iteraciones.
\### Tipos de Bucles
1\. \*\*`for`\*\*: Se utiliza para iterar sobre una secuencia (como una lista, tupla, diccionario, conjunto o cadena) o sobre un rango de números.
2\. \*\*`while`\*\*: Repite un bloque de código mientras una condición dada sea `True`.
\### Bucle `for`
El bucle `for` en Python es ideal para iterar sobre los elementos de una secuencia. La sintaxis básica es la siguiente:
```python
for elemento in secuencia:
\# Bloque de código a ejecutar
```
\#### Ejemplo: Iterar sobre una lista
```python
numeros = \[1, 2, 3, 4, 5]
for numero in numeros:
print(numero)
```
En este ejemplo, el bucle `for` recorre la lista `numeros` y `numero` toma el valor de cada elemento en la lista durante cada iteración.
\#### Ejemplo: Usando `range()`
La función `range()` se utiliza comúnmente con `for` para generar una secuencia de números.
```python
for i in range(5): # Esto genera los números 0 a 4
print(i)
```
El código anterior imprime los números del 0 al 4. También puedes especificar un inicio, fin y un paso:
```python
for i in range(1, 10, 2):
print(i)
\# Salida: 1, 3, 5, 7, 9
```
\### Bucle `while`
El bucle `while` repite un bloque de código mientras una condición sea `True`. La sintaxis básica es:
```python
while condición:
\# Bloque de código a ejecutar
```
\#### Ejemplo: Contador con `while`
```python
contador = 0
while contador < 5:
print(contador)
contador += 1
```
Este código comienza con `contador = 0` y sigue incrementándolo hasta que llega a 5. En cada iteración, se imprime el valor actual de `contador`.
\### Control de Iteraciones
Python ofrece varias formas de controlar la ejecución de bucles:
1\. \*\*`break`\*\*: Termina el bucle inmediatamente.
2\. \*\*`continue`\*\*: Salta la iteración actual y pasa a la siguiente.
3\. \*\*`else`\*\*: Un bloque que se ejecuta cuando el bucle termina de manera normal, es decir, sin que se haya usado `break`.
\#### Ejemplo: Uso de `break`
```python
for i in range(10):
if i == 5:
break
print(i)
\# Salida: 0, 1, 2, 3, 4
```
El bucle se detiene cuando `i` llega a 5, debido a la instrucción `break`.
\#### Ejemplo: Uso de `continue`
```python
for i in range(10):
if i % 2 == 0:
continue
print(i)
\# Salida: 1, 3, 5, 7, 9
```
Aquí, `continue` hace que el bucle salte la iteración actual si `i` es par, por lo que solo se imprimen los números impares.
\#### Ejemplo: Uso de `else` con Bucles
El bloque `else` en un bucle se ejecuta solo si el bucle no se interrumpe con `break`.
```python
for i in range(5):
print(i)
else:
print("Bucle completado.")
\# Salida:
\# 0
\# 1
\# 2
\# 3
\# 4
\# Bucle completado.
```
Si el bucle se completa sin interrupciones, se ejecuta el bloque `else`. Sin embargo, si se usa `break`, el bloque `else` se omite.
\#### Ejemplo: `else` con `break`
```python
for i in range(5):
if i == 3:
break
print(i)
else:
print("Bucle completado.")
\# Salida:
\# 0
\# 1
\# 2
```
En este caso, como el bucle se interrumpe con `break` cuando `i` es igual a 3, el bloque `else` no se ejecuta.
\### Bucles Anidados
Puedes anidar bucles dentro de otros bucles para trabajar con estructuras de datos más complejas, como matrices.
```python
for i in range(3):
for j in range(2):
print(f"i = {i}, j = {j}")
```
Este código tiene un bucle `for` dentro de otro `for`. Para cada valor de `i`, el bucle interno recorre todos los valores de `j`.
\### Bucles Infinito con `while`
Si la condición de un `while` siempre es verdadera, el bucle se ejecutará indefinidamente. Esto se conoce como un bucle infinito.
```python
while True:
respuesta = input("¿Quieres salir? (s/n): ")
if respuesta == 's':
break
```
Este ejemplo sigue preguntando al usuario si quiere salir hasta que la respuesta sea `'s'`.
\---
Estos son los fundamentos de los bucles y el control de iteraciones en Python. Son herramientas esenciales para ejecutar tareas repetitivas y para gestionar la lógica de flujo en tus programas.
El uso de bucles `while` en desarrollos profesionales puede ser menos común en comparación con `for` debido a varias razones. Los bucles `while` son más propensos a generar errores como bucles infinitos si no se gestionan correctamente. En cambio, los bucles `for` son más legibles y controlables, especialmente al iterar sobre colecciones conocidas, como listas o rangos. Esto facilita la comprensión del código y reduce riesgos en el mantenimiento. En entornos profesionales, la claridad y la seguridad en el código son primordiales.
Piedra papel o tijeras usando funciones para controlar el numero de rounds y guardar los puntos y método random.choice para simular al CPU:
```python
import random
def game(n):
playerScore = 0
cpuScore = 0
options = ["rock", "paper", "scissors"]
for i in range(1,n+1):
print("Round " + str(i))
playerChoice = input("Player : ")
cpuChoice = random.choice(options)
if playerChoice == "rock":
if cpuChoice == "paper":
cpuScore += 1
elif cpuChoice == "scissors":
playerScore += 1
elif playerChoice == "paper":
if cpuChoice == "scissors":
cpuScore += 1
elif cpuChoice == "rock":
playerScore += 1
elif playerChoice == "scissors":
if cpuChoice == "rock":
cpuScore += 1
elif cpuChoice == "paper":
playerScore += 1
print("CPU : "+ cpuChoice)
print()
print("--- Final Results ---")
print("Player Score : " + str(playerScore))
print("CPU Score : " + str(cpuScore))
print()
if playerScore > cpuScore:
print("You win!")
elif playerScore < cpuScore:
print("You loose...")
elif playerScore == cpuScore:
print("It's a tie")
print()
game(5) # Así se invoca al juego para 5 rounds
```
Sabian que pueden usar else en un ciclo for?
Al usar `else` con un ciclo `for`, el bloque de código dentro de `else` se ejecutará únicamente si el ciclo completa todas sus iteraciones sin encontrar una condición que provoque una interrupción (como `break`). Esto es especialmente útil para realizar acciones cuando no se ha encontrado un elemento que cumpla cierta condición durante la búsqueda en una lista, tupla o cualquier otro iterable
solo escriben else al final del ciclo for y lo tienen ya listo
Esta clase DEBERIA estar antes del Comprehension List.
Para practicar los conceptos de bucles y control de iteraciones en Python, puedes realizar el siguiente ejercicio:
**Ejercicio: Crea un programa que imprima los números del 1 al 20, pero omita los múltiplos de 3.**
1. Utiliza un bucle `for` para iterar a través de un rango de números del 1 al 20.
2. Dentro del bucle, utiliza una condición `if` para verificar si el número es múltiplo de 3.
3. Si el número es múltiplo de 3, utiliza `continue` para omitirlo.
4. Imprime el número si no es múltiplo de 3.
Este ejercicio te ayudará a consolidar el uso de bucles y condiciones en Python. ¡Inténtalo!
Vamos con toda!! Cada vez se pone más interesante.
while true es una mala práctica, solo escribir while: y lo que sigue hace lo mismo
Las estructuras de programación son herramientas que nos permiten repetir un conjunto de instrucciones hasta que se cumpla una condición. Los bucles son fundamentales en programación y se utilizan para automatizar tareas repetitivas. El bucle for en se utiliza para iterar sobre una secuencia como una lista, una tupla o un rango.
Un bucle `for` se usa para iterar sobre una secuencia (como listas o rangos) cuando conoces de antemano cuántas veces necesitas ejecutar el bucle. Por otro lado, un bucle `while` se utiliza cuando no se sabe cuántas veces se repetirá el ciclo, ya que depende de una condición.
El `break` se utiliza para salir de un bucle antes de que se complete, como al encontrar un valor específico. El `continue` omite la iteración actual y pasa a la siguiente, útil para saltar ciertos casos sin romper el ciclo.
Contextos reales incluyen:
- `break` en búsquedas para detener al encontrar el elemento.
- `continue` al omitir errores o condiciones no deseadas en procesamientos.
En el bloque de codigo:
Me parece q hay un error, pues lo q quieres imprimir es la posicion actual , no la suma i+1, por lo que para obtener el indice q itera por numbers se debe RESTAR 1 de i NO SUMARLE.
PEQUEÑO DETALLE
por eso a carly le sale un output extraño y sin sentido como
```python
numbers = [1, 2, 3, 4, 5, 6]
# for es un bucle iterable
for i in numbers:
print("Aqui i es igual:", i+1)
for i in range(3, 10):
print(i)
fruits = ["Manzana", "Pera", "Fresa", "Uva", "Aguacate"]
fPreferida = input(str("Ingresa tu fruta preferida de la lista de arriba: "))
for fruit in fruits:
print(fruit)
if fruit == fPreferida:
print("Felicidades, Fresa encontrada 🍓")
x = 0
while x < 5:
if x == 3:
break
print(x)
x += 1
numbers = [1, 2, 3, 4, 5, 6]
for i in numbers:
if i == 3:
# Omite cuando i es igual a 3
continue
print("Aqui i es igual a: ", i)
numbers = [1, 2, 3, 4, 5, 6]
for i in numbers:
if i == 3:
# se pausa cuando i es igual a 3
break
print("Aqui i es igual a: ", i)
```numbers = \[1, 2, 3, 4, 5, 6]*# for es un bucle iterable*for i in numbers: print("Aqui i es igual:", i+1)
for i in range(3, 10): print(i)
fruits = \["Manzana", "Pera", "Fresa", "Uva", "Aguacate"]fPreferida = input(str("Ingresa tu fruta preferida de la lista de arriba: "))for fruit in fruits: print(fruit) if fruit == fPreferida: print("Felicidades, Fresa encontrada 🍓")
x = 0while x < 5: if x == 3: break print(x) x += 1
numbers = \[1, 2, 3, 4, 5, 6]for i in numbers: if i == 3: *# Omite cuando i es igual a 3* continue print("Aqui i es igual a: ", i)
numbers = \[1, 2, 3, 4, 5, 6]for i in numbers: if i == 3: *# se pausa cuando i es igual a 3* break print("Aqui i es igual a: ", i)
```python
Aspirantes = {"Juanes":70, "Sandra":42, "Pedro":63, "Stella":78, "Sebas":41, "Miquel":65, "Mateo":58, "Juan":80, "Carla":64, "Matias":57}
for nombre, edad in Aspirantes.items():
if edad >= 60:
print("Beneficiario adulto mayor:",nombre)
```
Aqui algunos ejemplos tomados de los comentarios con algunas modificaciones
print("Control de saldo con while")saldo = 50000retiros = \[]print("Su saldo es:", saldo)
while saldo: Retiro = int(input("Ingrese el vlor a retirar")) if Retiro > saldo: print(f'Saldo infuciencite, solo tienes: {saldo}') print("retiros Realizados", retiros) break else: saldo -= Retiro retiros.append(Retiro) print("Ahoraa su saldo es:", saldo)
print("suma progresiva")acumulado = 0numeros = \[]num = int(input("Ingrese un numera para sumar, o 0 para salir"))while num != 0: acumulado += num numeros.append(num) print("La suma es =", acumulado) num = int(input("Ingrese otro Número o 0 para salir"))else: print("Fin de la suma, los numeros sumados son:", numeros, "Totla", acumulado)
Realizando bucle While =)
Dejo el ejercicio anterior del piedra papel o tijera pero usando bucles While añidados
```python
nombre_jugador_1 = input("Indique su nombre: ")
nombre_jugador_2 = "Computadora"
print() #dejo espacio
print(f"{nombre_jugador_1} vs {nombre_jugador_2}")
opciones = ["Piedra", "Papel", "Tijera"]
partidas_ganadas_J1 = 0
partidas_ganadas_J2 = 0
print(f"Resultado del juego: {nombre_jugador_1}: {partidas_ganadas_J1} || {nombre_jugador_2}: {partidas_ganadas_J2}")
print() #dejo espacio
while(partidas_ganadas_J1 < 3 and partidas_ganadas_J2 < 3):
hayEleccion = False
while(hayEleccion == False):
opcion_jugador_1 = input("Eliga Piedra, Papel o Tijera: ").capitalize()
for opcion in opciones:
#print(opcion)
if opcion_jugador_1 == opcion:
print(f"{nombre_jugador_1} eligio: {opcion_jugador_1}")
print()
hayEleccion = True
break
if hayEleccion == False:
print("Por favor, elija una opcion correcta")
import random
opcion_computadora = random.choice(opciones)
print(f"{nombre_jugador_2} eligio: {opcion_computadora}")
if opcion_jugador_1 == opcion_computadora:
print() #dejo espacio
print('Han empatado!')
elif (opcion_jugador_1 == 'Piedra' and opcion_computadora == 'Tijera') or \
(opcion_jugador_1 == 'Papel' and opcion_computadora == 'Piedra') or \
(opcion_jugador_1 == 'Tijera' and opcion_computadora == 'Papel'):
print() #dejo espacio
partidas_ganadas_J1 += 1
print('Gano ', nombre_jugador_1)
else:
print() #dejo espacio
partidas_ganadas_J2 += 1
print('Gano ', nombre_jugador_2)
print(f"Resultado del juego: {nombre_jugador_1}: {partidas_ganadas_J1} || {nombre_jugador_2}: {partidas_ganadas_J2}")
print()
```
```js
numbers=[1,2,3,4,5,6]
#Ejercicio 1
print("Ejercicio 1")
for i in numbers:
print(i)
#Ejercicio 2
print("")
print("Ejercicio 2")
for i in range(0,10):
print(i)
#Ejercicio 3
print("")
print("Ejercicio 3")
fruits = ["apple","banana","cherry"]
for fruit in fruits:
print(fruit)
if fruit == "banana":
print("fruta encontrada:",fruit)
#Ejercicio 4
print("")
print("Ejercicio 4")
x = 0
while x < 5:
print("x es:",x)
x +=1
#Ejercicio 5
print("")
print("Ejercicio 5")
numbers=[1,2,3,4,5,6]
#Ejercicio 1
print("Ejercicio 1")
for i in numbers:
if i == 3:
continue
print(i)
```numbers=\[1,2,3,4,5,6]
\#Ejercicio 1print("Ejercicio 1")for i in numbers: print(i) #Ejercicio 2print("")print("Ejercicio 2")for i in range(0,10): print(i)
\#Ejercicio 3print("")print("Ejercicio 3")fruits = \["apple","banana","cherry"]for fruit in fruits: print(fruit) if fruit == "banana": print("fruta encontrada:",fruit)
\#Ejercicio 4print("")print("Ejercicio 4")
x = 0while x < 5: print("x es:",x) x +=1 #Ejercicio 5print("")print("Ejercicio 5")numbers=\[1,2,3,4,5,6]
\#Ejercicio 1print("Ejercicio 1")for i in numbers: if i == 3: continue print(i)
Bucles y Control de Iteraciones en Python
Los bucles son estructuras fundamentales en Python que permiten ejecutar un bloque de código repetidamente. Son esenciales para automatizar tareas, procesar datos y crear programas dinámicos. Python ofrece dos tipos principales de bucles: for y while.
1\. Bucle for:
Se utiliza para iterar sobre una secuencia (lista, tupla, string, rango, etc.) o cualquier objeto iterable.
Ejecuta un bloque de código para cada elemento de la secuencia.
Sintaxis:
for variable in secuencia:
\# Bloque de código a ejecutar para cada elemento
Ejemplo:
nombres = \["Ana", "Juan", "María"]
for nombre in nombres:
print(f"Hola, {nombre}!")
2\. Bucle while:
Ejecuta un bloque de código mientras una condición sea verdadera.
Es importante asegurarse de que la condición eventualmente se vuelva falsa para evitar un bucle infinito.
Sintaxis:
while condición:
\# Bloque de código a ejecutar mientras la condición sea verdadera
Ejemplo:
contador = 0
while contador < 5:
print(f"Contador: {contador}")
contador += 1
Control de Iteraciones:
Python proporciona palabras clave para controlar el flujo de los bucles:
break: Termina la ejecución del bucle inmediatamente, incluso si la condición del while sigue siendo verdadera o si quedan elementos por iterar en el for.
for i in range(10):
if i == 5:
break # Sale del bucle cuando i es igual a 5
print(i)
continue: Salta a la siguiente iteración del bucle, omitiendo el resto del código dentro del bloque para la iteración actual.
for i in range(10):
if i % 2 == 0:
continue # Salta a la siguiente iteración si i es par
print(i) # Solo imprime números impares
else (con for y while): El bloque else se ejecuta después de que el bucle se complete normalmente (es decir, no se interrumpió con break).
for i in range(5):
print(i)
else:
print("Bucle terminado normalmente")
contador = 0
while contador < 3:
print(contador)
contador += 1
else:
print("Bucle while terminado normalmente")
Consideraciones:
Bucles infinitos: Ten cuidado con las condiciones del bucle while que nunca se vuelven falsas, ya que esto puede provocar un bucle infinito que bloquea el programa.
Eficiencia: Elige el tipo de bucle adecuado para cada tarea. for es generalmente más eficiente para iterar sobre secuencias conocidas, mientras que while es más flexible para condiciones más complejas.
Claridad: Escribe código legible y fácil de entender. Usa nombres de variables descriptivos y comenta tu código cuando sea necesario.
Uso de range() en bucles for:
La función range() es comúnmente usada para generar secuencias de números en bucles for.
for i in range(5): # Itera de 0 a 4.
print(i)
for i in range (2,10,2): #Itera de 2 a 9 en incrementos de 2 en 2.
print(i)
En resumen, los bucles for y while son herramientas esenciales para la programación en Python. Comprender cómo funcionan y cómo controlar su flujo con break, continue y else te permitirá escribir programas más eficientes y dinámicos.
Buenas tardes, una consulta, soy novato en la plataforma y hasta en el lenguaje, veo que hablan de ejercicios luego de cada clase, es asi? donde estan? yo lo unico que veo son Recursos, Comentarios y Clases. Muchas gracias
Bucles y Control de Iteraciones:
i son los valores dentro de por ejemplo:
numbers = \[1, 2, 3, 4, 5, 6]
while puede generar bucles infinitos, hay que declarar un lugar donde parar, ejemplo:
x = 0
while x<5:
print(x)
x +1 #Esto hace que se vaya incrementando en 1 en cada print
Tambien se puede usar break para romper los bucles cuando por ejemplo x llega a x valor:
x = 0
while x<5:
if x ==3:
break
print(x)
x +1
continue sirve para saltar valores:
x = 0
while x<5:
if x ==3:
continue #se salta 3
print(x)
x +1
Mi aporte
mi aporte
Aquí tienes algunos ejemplos de ejercicios para repasar bucles y control de iteraciones en Python:
1. **Imprimir números del 1 al 10**: Usa un bucle `for` para imprimir todos los números del 1 al 10.
```python
for i in range(1, 11):
print(i)
```
2. **Suma de números en una lista**: Crea una lista con algunos números y usa un bucle `for` para calcular la suma total.
```python
numeros = [1, 2, 3, 4, 5]
suma = 0
for num in numeros:
suma += num
print(suma)
```
3. **Encontrar un elemento en una lista**: Usa un bucle `for` para buscar un elemento específico (por ejemplo, "naranja") en una lista de frutas.
```python
frutas = ["manzana", "pera", "uva", "naranja"]
for fruta in frutas:
if fruta == "naranja":
print("Naranja encontrada")
```
4. **Contar hasta 5 usando `while`**: Usa un bucle `while` para imprimir números del 1 al 5.
```python
x = 1
while x <= 5:
print(x)
x += 1
```
5. **Ejercicio de `continue`**: Crea un bucle `for` que imprima los números del 1 al 10, pero omita el número 5.
```python
for i in range(1, 11):
if i == 5:
continue
print(i)
```
Realiza estos ejercicios para consolidar tu comprensión sobre bucles y control de iteraciones en Python.
el uso de estructuras como for y while para recorrer colecciones de datos, como listas. Carli explica cómo manipular los elementos durante la iteración, realizar operaciones específicas y gestionar el flujo del bucle utilizando las instrucciones break y continue. Además, destaca la importancia de la práctica para dominar estos conceptos fundamentales y aplicarlos eficazmente en diversas situaciones.
Wow Carli eres la primera profesora con la que por fin logro entender el for a la perfección.
Y eso que he visto vaaaaaaaarios videos en youtube y cursos anteriores de platzi
Me gustan los ejemplos muy prácticos.
Para este caso no solo represente un arreglo de 1 sola dimensión y también una matriz, para darme una mejor idea del funcionamiento.
```js
arr = [1,2,3,4,5]
for i in arr:
print(i)
print("Aqui inicia el while \n")
x = 0
while x < len(arr):
print(arr[x])
x += 1
# arreglos de 2 dimensiones
arr_2d = [[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10]]
print(f"Arreglo en 2d {arr_2d} \n")
for i in arr_2d:
print("Esto es i: ", i)
for j in i:
print("Esto es j:", j)
if j == 3:
break
```arr = \[1,2,3,4,5]for i in arr: print(i)
print("Aqui inicia el while \n")
x = 0while x < len(arr): print(arr\[x]) x += 1
\# arreglos de 2 dimensiones
arr\_2d = \[\[1, 2, 3, 4, 5], \[6, 7, 8, 9, 10]]
print(f"Arreglo en 2d {arr\_2d} \n")for i in arr\_2d: print("Esto es i: ", i) for j in i: print("Esto es j:", j) if j == 3: break
```python
#Juego de piedra Papel o Tijera en consola.
player1_wins = 0
player2_wins = 0
while player1_wins < 3 and player2_wins < 3:
player1_move = input("Movimiento jugador 1").capitalize()
player2_move = input("Movimineto jugador 2").capitalize()
if player1_move == "Tijera" and player2_move == "Papel" or\
player1_move == "Piedra" and player2_move == "Tijera" or\
player1_move == "Papel" and player2_move == "Piedra":
player1_wins = player1_wins +1
print("Gana jugador 1")
print("Marcador es Jugador 1: ", player1_wins, "jugador 2: ", player2_wins)
elif player2_move == "Tijera" and player2_move == "Papel" or\
player2_move == " Piedra" and player1_move == "Tijera" or\
player2_move == "Papel" and player1_move == "Piedra":
player2_wins = player2_wins +1
print("Gana jugador 2")
print("Marcador es Jugador 1", player1_wins, "Jugador 2", player2_wins)
else:
print("empate")
if player2_wins > player1_wins:
print("GANA 2")
elif player1_wins > player2_wins:
print("GANA 1")
```
mi sugerencia hasta lo que he mirado del curso, es que seria bueno que den un acercamiento a la documentación oficial de Python, y los ejemplos que se muestren en el para que cualquier alumno pueda autogestionarse en caso de que no entiendan a la profesora.
```python
saldo = 50000
Retiro = 278
while saldo > 0:
print(f'Tu saldo es de: {saldo}')
saldo -= Retiro
if saldo < Retiro:
print(f'Saldo infuciencite, solo tienes: {saldo}')
break
```saldo = 50000Retiro = 278
while saldo > 0: print(f'Tu saldo es de: {saldo}') saldo -= Retiro if saldo < Retiro: print(f'Saldo infuciencite, solo tienes: {saldo}') break
```python
import random
#Game: Rock, paper, scissors
def main ():
list_options = ["rock", "paper", "scissors"]
while True:
user_selection= input("Choose one option -rock, paper, scissors-: ")
#If the user's input is validated, the game starts.
if format_validation (user_selection, list_options) == True:
machine_selection = random.choice(list_options)
print ("The machine selection is:", machine_selection)
print ("***")
#user = user.lower()
if user_selection == machine_selection:
print ("it's a tie, both win!")
elif user_selection == "rock" and machine_selection =="paper":
print("The machine wone! Try again!")
elif user_selection == "rock" and machine_selection =="scissors":
print("You wone!")
elif user_selection == "paper" and machine_selection == "scissors":
print("The machine wone! Try again!")
elif user_selection == "paper" and machine_selection == "rock":
print("You wone!")
elif user_selection == "scissors" and machine_selection == "rock":
print("The machine wone! Try again!")
else:
print("You wone!")
else:
print ("***")
print("Your choice is not valid. Please, choose one of this options -rock, paper, scissors-: ")
print("***")
#A function that validates user input and filters out text that differs from the text used in the game."
def format_validation (user_selection, list_options):
if user_selection.lower() in list_options:
return True
else:
return False
if __name__ == "__main__":
main()
```
Los **bucles** permiten ejecutar un bloque de código varias veces. En Python, los más comunes son `for` y `while`.
* **for**: Recorre una secuencia (como una lista o rango) y ejecuta el código para cada elemento.
* **while**: Repite el código mientras una condición sea verdadera.
El **control de iteraciones** usa las palabras clave:
* **break**: Termina el bucle antes de tiempo.
* **continue**: Salta al siguiente ciclo del bucle, sin ejecutar el resto del código en esa iteración.
hola soy nuevo una pregunta es normal llegar a esta clase y no entender aun nada soy muy nuevo pero quiero aprender aun creo que estoy un poco mal alguien mas le ha pasado
Profe me causo curiosidad que herramienta de white boarding estabas usando?
x = 0while x < 100: if x == 75: print("Hemos llegado a 75, pero continuamos hasta 100") print(x) x += 1
`#LA FUNCIÓN RANGE()`
`#Para un solo argumento:`
`# range(ultimo) por defecto el primer valor será = 0 y avanza de 1 en 1 `
`for i in range(5): `
`print(i) # 1, 2, 3, 4`
`#Para dos argumentos:`
`#range(primero, ultimo) por defecto avanza de 1 en 1`
`for i in range(4,11): `
`print(i) # 4, 5, 6, 7, 8, 9, 10`
`#Para tres argumentos:`
`#range(primero, ultimo, salto)`
`for i in range(1,11,3): `
`print(i) # 1, 4, 7 ,10`
Aca fui volviendo mas dificil el ejercicio, comence con una multiplicación sencilla para que me de la tabla, y luego fui a que me de el factorial del numero, a lo que pase a doble factorial.#Ejericio 1## Tabla de multiplicar de cualquier númeronumero = input("Ingrese un número: ")print("La tabla de multiplicar de", numero, 'es: ')
if numero.isdigit(): numero = int(numero) for i in range(3): print(numero, 'x', i, '=', numero\*i)
\# Ejercicio 2## Calcula el factorial de un número
factor = input("Ingresa un número para calcular su factorial: ")
print("El factorial de", factor, "es: ")
if factor.isdigit(): factor = int(factor) # Se convierte el número a entero factorial = 1e0 # Se inicializa el factorial en 1e0, se coloca el e0 para que empieze desde exponente 1 que es el mismo número. for i in range(1, factor+1): # Se recorre el rango del número ingresado factorial \*= i # Se calcula el factorial print(factorial) # Se imprime los numeros factoriales del número ingresado # Ejercicio 3## Calcular el numero de doble factorialde un número
factor = input('ingresa un numero para el n!!: ')
print('El doble factorial de', factor, 'es: ')
if factor.isdigit(): factor = int(factor) # Se convierte el número a entero factorial = 1e0 # Se incia el factorial en 1 #Para numeros pares if factor % 2 == 0: # Se verifica si el número es par for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2 factorial \*= i # Se calcula el factorial #Para numeros impares else: for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2 factorial \*= i # Se calcula el factorial print(factorial)
```js
#Ejericio 1
## Tabla de multiplicar de cualquier número
numero = input("Ingrese un número: ")
print("La tabla de multiplicar de", numero, 'es: ')
if numero.isdigit():
numero = int(numero)
for i in range(3):
print(numero, 'x', i, '=', numero*i)
# Ejercicio 2
## Calcula el factorial de un número
factor = input("Ingresa un número para calcular su factorial: ")
print("El factorial de", factor, "es: ")
if factor.isdigit():
factor = int(factor) # Se convierte el número a entero
factorial = 1e0 # Se inicializa el factorial en 1e0, se coloca el e0 para que empieze desde exponente 1 que es el mismo número.
for i in range(1, factor+1): # Se recorre el rango del número ingresado
factorial *= i # Se calcula el factorial
print(factorial) # Se imprime los numeros factoriales del número ingresado
# Ejercicio 3
## Calcular el numero de doble factorialde un número
factor = input('ingresa un numero para el n!!: ')
print('El doble factorial de', factor, 'es: ')
if factor.isdigit():
factor = int(factor) # Se convierte el número a entero
factorial = 1e0 # Se incia el factorial en 1
#Para numeros pares
if factor % 2 == 0: # Se verifica si el número es par
for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2
factorial *= i # Se calcula el factorial
#Para numeros impares
else:
for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2
factorial *= i # Se calcula el factorial
print(factorial)
```
¿Qué se vió en la sesión?
**While**
Control + C (para parar la terminal)
**Range**
**Continue**
**Breake**
El ejercicio unicial de frutas con 'break' al final, para al encontrar la fruta.
```js
frutas = ['mango', 'pera', 'manzana', 'uva', 'lulo', 'piña', 'fresa']
for fruta in frutas:
print(fruta)
if fruta=='lulo':
print('lulo encontrado')
break
```
```js
while True:
question = input("Adivina el dia de la semana favorito: ").lower()
if question == 'jueves':
print("adivinaste")
break
else:
("Intentalo de nuevo")
#Bucle while True: Esto crea un bucle infinito que solo se
#detendrá cuando se encuentre una instrucción break.
# Convertir la entrada a minúsculas: dia.lower() convierte la entrada a
# minúsculas para que la comparación sea insensible a mayúsculas.
```while True: question = input("Adivina el dia de la semana favorito: ").lower() if question == 'jueves': print("adivinaste") break else: ("Intentalo de nuevo") #Bucle while True: Esto crea un bucle infinito que solo se #detendrá cuando se encuentre una instrucción break.
\# Convertir la entrada a minúsculas: dia.lower() convierte la entrada a# minúsculas para que la comparación sea insensible a mayúsculas.
Range además de generar un iterable, existe untercer parámetro en el que se puede especificar la longitud de los "saltos" que queremos que range haga por cada iteración dentro de cualquierblucle, ya sea for, while.
Recuerda que dentro del rango especificado conel primer y segundo parámetro range toma en cuenta los números contenidos entre el primer parámetro y el segundo parametro menos 1. Osea que si especificamos de 0 a 9, solo se tomaran en cuenta los números del 0 al 8. Osea que si:x = primer parametro, z = segundo parametro Entonces el rango de número será entre: x y (z-1)
Ejemplo en código:
```js
for i in range(0 ,9, 2):
print(i)
```*Resultado: 012468*
Apuntes y codigo:
```python
#Bucles y control e Iteraciones
#ya vimos que en la listas hay informacion que puede ser cinsultada con la indexacion o con el slicing
#Sin envago hay una forma de automatizar el ñroceso cuando lo quermos hacer de manera iterable
#Para eso se utilizan lo bucles o controles de iteracion
#EJEMPLO
# en una lista [1,2,3,4,5,6,7,8,9,10]
#Si quieo buscar infrmacion dentro tendre que moverme eir almacendo informacion para saber donde estoy
#POS ser para la posicion
#VAL sera para su contenido o valor
# en la lista del ejemplo el uno esta en POS=0 pero du VAL="1"
numbers =[0,1,2,3,4,5,6,7,8,9,10]
for i in numbers: #sin novedad se utiliza como un for en progra, solo no olvidemos los puntos y la identación
if i == 3:
continue
print ("Aqui 1 es igual ", i+1)
for i in range(10):
print(i)
for x in range(2,9):
print(i)
fruits = ["manzana", "uva", "mando","naranja", "lima", "mandarina"]
for fruit in fruits:
print(fruit)
if fruit == "Naranja":
print("naranja encontrada")
w=0
while w<5: #while es un mientras y se utiliza como siempre, solo no olvidemos los : a final, si no al dar enter no hace identacion
if w == 3: #se agrega una condicion como cualquier otra de if que si se cumple
break #Hace que estre break pare el while y si no hay otra isntruccion se sale
print(w)
#w = w+1
w +=1 # metodo abreviado de w = w +1
```#Bucles y control e Iteraciones#ya vimos que en la listas hay informacion que puede ser cinsultada con la indexacion o con el slicing#Sin envago hay una forma de automatizar el ñroceso cuando lo quermos hacer de manera iterable#Para eso se utilizan lo bucles o controles de iteracion
\#EJEMPLO# en una lista \[1,2,3,4,5,6,7,8,9,10]#Si quieo buscar infrmacion dentro tendre que moverme eir almacendo informacion para saber donde estoy#POS ser para la posicion#VAL sera para su contenido o valor# en la lista del ejemplo el uno esta en POS=0 pero du VAL="1"numbers =\[0,1,2,3,4,5,6,7,8,9,10] for i in numbers: #sin novedad se utiliza como un for en progra, solo no olvidemos los puntos y la identación if i == 3: continue print ("Aqui 1 es igual ", i+1)
for i in range(10): print(i)
for x in range(2,9): print(i)
fruits = \["manzana", "uva", "mando","naranja", "lima", "mandarina"] for fruit in fruits: print(fruit) if fruit == "Naranja": print("naranja encontrada")
w=0 while w<5: #while es un mientras y se utiliza como siempre, solo no olvidemos los : a final, si no al dar enter no hace identacion if w == 3: #se agrega una condicion como cualquier otra de if que si se cumple break #Hace que estre break pare el while y si no hay otra isntruccion se sale print(w) #w = w+1 w +=1 # metodo abreviado de w = w +1
\#Juego de piedra Papel o Tijera en consola.
player1\_wins = 0player2\_wins = 0
while player1\_wins < 3 and player2\_wins < 3: player1\_move = input("Movimiento jugador 1").capitalize() player2\_move = input("Movimineto jugador 2").capitalize()
if player1\_move == "Tijera" and player2\_move == "Papel" or\ player1\_move == "Piedra" and player2\_move == "Tijera" or\ player1\_move == "Papel" and player2\_move == "Piedra": player1\_wins = player1\_wins +1 print("Gana jugador 1") print("Marcador es Jugador 1: ", player1\_wins, "jugador 2: ", player2\_wins) elif player2\_move == "Tijera" and player2\_move == "Papel" or\ player2\_move == " Piedra" and player1\_move == "Tijera" or\ player2\_move == "Papel" and player1\_move == "Piedra": player2\_wins = player2\_wins +1 print("Gana jugador 2") print("Marcador es Jugador 1", player1\_wins, "Jugador 2", player2\_wins) else: print("empate")
if player2\_wins > player1\_wins: print("GANA 2")elif player1\_wins > player2\_wins: print("GANA 1")
\## bucles y controles de iteracion
numbers = \[1,2,3,4,5,6]
for i in numbers:
print("Aqui is es igual a ", i+1)
for i in range (3,10):
print(i)
fruits = \["Manzana","Pera","uva","Naranja","Tomate"]
for fruit in fruits:
if fruit =="Naranja":
print("Naranja encontrada")
x = 0
while x<5:
if x == 3:
break
print(x)
x+=1
numbers = \[1,2,3,4,5,6]
for i in numbers:
if i == 3:
continue
print("Aqui i es igual a: ", i)
Want to see more contributions, questions and answers from the community?