ESTRUCTURAS DE CONTROL

ESTRUCTURAS DE CONTROL EN PYTHON

TRANSCRIBIR EN EL CUADERNO

PROXIMA SEMANA EXAMEN ESCRITO DE LOS DOS ULTIMOS TEMAS

Las estructuras de control son instrucciones que permiten decidir qué debe hacer un programa, cuándo hacerlo y cuántas veces hacerlo.

Gracias a ellas, un programa no tiene que ejecutar todas las instrucciones de manera seguida. Puede tomar decisiones, repetir acciones o elegir diferentes caminos.

Las principales estructuras de control en Python son:

1. Condicionales: permiten tomar decisiones.
2. Bucles: permiten repetir instrucciones.

---

1. ESTRUCTURA CONDICIONAL if

La palabra if significa "si".

Se utiliza cuando queremos que Python realice una acción solamente si se cumple una condición.

Ejemplo:

edad = 15

if edad >= 14:
    print("Puedes entrar al curso")

¿Cómo funciona?

Python revisa la condición:

edad >= 14

Como 15 es mayor o igual que 14, la condición es verdadera y se ejecuta:

print("Puedes entrar al curso")

Recuerda: en Python, las instrucciones que pertenecen al if llevan una sangría o indentación.

---

2. ESTRUCTURA if - else

else significa "si no".

Se utiliza cuando tenemos dos posibilidades:

• Si la condición es verdadera → ocurre una cosa.
• Si la condición es falsa → ocurre otra.

Ejemplo:

edad = 12

if edad >= 13:
    print("Eres adolescente")
else:
    print("Eres niño")

¿Cómo funciona?

Python pregunta:

¿La edad es mayor o igual a 13?

Como 12 no cumple la condición, ejecuta el bloque else:

Eres niño

---

3. ESTRUCTURA if - elif - else

elif significa "si no, si...".

Se utiliza cuando tenemos más de dos posibilidades.

Ejemplo:

nota = 4

if nota >= 4.5:
    print("Excelente")
elif nota >= 3:
    print("Aprobado")
else:
    print("No aprobado")

¿Cómo funciona?

Python revisa las condiciones de arriba hacia abajo.

En este caso:

• ¿La nota es mayor o igual a 4.5? → No.
• ¿La nota es mayor o igual a 3? → Sí.
• Entonces muestra:

Aprobado

---

4. BUCLE for

El bucle for se utiliza para repetir una acción varias veces.

Ejemplo:

for i in range(5):
    print("Hola")

¿Qué ocurre?

El programa repite print("Hola") 5 veces.

El resultado será:

Hola
Hola
Hola
Hola
Hola

range(5) genera los números:

0, 1, 2, 3, 4

Por eso se repite cinco veces.

---

5. BUCLE while

El bucle while significa "mientras".

Se utiliza para repetir instrucciones mientras una condición sea verdadera.

Ejemplo:

numero = 1

while numero <= 5:
    print(numero)
    numero = numero + 1

¿Cómo funciona?

Mientras numero sea menor o igual que 5, Python imprime el número y después aumenta su valor en uno.

El resultado será:

1
2
3
4
5

Cuando numero llega a 6, la condición:

numero <= 5

deja de cumplirse y el ciclo termina.

---

6. DIFERENCIA ENTRE FOR Y WHILE

Aunque ambos sirven para repetir instrucciones, se utilizan de manera diferente.

for

Lo utilizamos generalmente cuando sabemos cuántas veces queremos repetir algo.

for i in range(3):
    print("Hola")

Repite la acción 3 veces.

while

Lo utilizamos cuando queremos repetir algo mientras se cumpla una condición.

numero = 1

while numero <= 3:
    print(numero)
    numero = numero + 1

Repite mientras numero sea menor o igual a 3.

---

RESUMEN

Estructura	¿Para qué sirve?
if	Tomar una decisión
if - else	Elegir entre dos opciones
if - elif - else	Elegir entre varias opciones
for	Repetir un número determinado de veces
while	Repetir mientras se cumpla una condición

Idea principal para recordar:

Las estructuras de control permiten que un programa pueda decidir y repetir acciones.

• if → decide
• else → hace otra cosa si no se cumple
• elif → comprueba otra condición
• for → repite
• while → repite mientras se cumpla una condición

SENSORES Y ACTUADORES EN ARDUINO

 SENSORES Y ACTUADORES EN ARDUINO

1. ¿Qué son los sensores?

Los sensores son componentes electrónicos que permiten a Arduino detectar información del entorno.

Podemos decir que los sensores son como los sentidos de un robot.

Por ejemplo:

• Los ojos permiten ver.

• Los oídos permiten escuchar.

• La piel permite sentir.

De manera parecida, los sensores permiten que un robot detecte diferentes situaciones.

Ejemplos de sensores

Sensor ultrasónico HC-SR04:
Permite medir la distancia hasta un objeto.

Sensor infrarrojo TCRT5000:
Permite detectar diferencias entre superficies, por ejemplo, una línea negra sobre una superficie blanca.

Sensor de temperatura:
Permite detectar la temperatura del ambiente.

Sensor de luz:
Permite detectar la cantidad de luz.

---

2. ¿Qué son los actuadores?

Los actuadores son componentes que permiten que Arduino realice una acción.

Podemos decir que los actuadores son como los músculos de un robot.

Cuando Arduino toma una decisión, puede enviar una orden a un actuador para realizar una acción.

Ejemplos de actuadores

Motor DC: permite mover un robot.

LED: permite producir luz.

Buzzer: permite producir sonidos.

Servo motor: permite mover una pieza hasta una posición determinada.

---

3. ¿Cómo trabajan juntos?

Los sensores y los actuadores trabajan junto con Arduino.

El proceso puede resumirse así:

SENSOR → ARDUINO → ACTUADOR

Primero, el sensor detecta algo.

Después, Arduino procesa la información según el programa.

Finalmente, el actuador realiza una acción.

Ejemplo: robot que evita obstáculos

Un robot tiene un sensor ultrasónico.

1. El sensor detecta un objeto.

2. Arduino calcula la distancia.

3. Arduino determina que el objeto está demasiado cerca.

4. Arduino ordena a los motores cambiar de dirección.

5. El robot evita el obstáculo.

Sensor ultrasónico → Arduino → Motores

---

4. Diferencia entre sensor y actuador

SENSOR	ACTUADOR
Detecta información.	Realiza una acción.
Recibe información del entorno.	Recibe órdenes de Arduino.
Es una entrada.	Es una salida.
Ejemplo: HC-SR04.	Ejemplo: motor.
Ejemplo: TCRT5000.	Ejemplo: LED.

Para recordar

SENSOR = DETECTA

ARDUINO = PROCESA

ACTUADOR = ACTÚA

Ejemplo sencillo

Si un robot detecta una línea negra:

TCRT5000 detecta la línea → Arduino procesa la información → motores cambian el movimiento.

De esta manera, Arduino puede hacer que un robot perciba su

Arduino es una plataforma electrónica programable que permite crear proyectos utilizando componentes electrónicos.

Con Arduino podemos hacer que un dispositivo reciba información, la procese y realice una acción.

Por ejemplo, podemos construir un robot que:

• Detecte obstáculos.
• Siga una línea.
• Encienda y apague luces.
• Controle motores.
• Mida distancias.
• Reaccione ante sensores.

¿Qué partes tiene un sistema Arduino?

Un proyecto con Arduino generalmente tiene tres elementos principales:

1. ENTRADAS

Son los elementos que permiten que Arduino reciba información del entorno.

Ejemplos:

• Sensor ultrasónico.
• Sensor de luz.
• Sensor de temperatura.
• Sensor infrarrojo.

2. PROCESAMIENTO

Arduino recibe la información de los sensores y ejecuta las instrucciones que hemos programado.

El Arduino UNO es uno de los modelos más utilizados para aprender.

3. SALIDAS

Son los elementos que realizan una acción después de recibir las instrucciones de Arduino.

Ejemplos:

• Motores.
• LEDs.
• Buzzer.
• Pantallas.

¿Cómo funciona Arduino?

Podemos resumir su funcionamiento en tres pasos:

ENTRADA → PROCESAMIENTO → SALIDA

Por ejemplo:

Un sensor detecta un objeto → Arduino procesa la información → el motor cambia de dirección.

¿Qué es un sensor?

Un sensor es un componente que permite detectar o medir algo del entorno.

Por ejemplo, el sensor HC-SR04 puede medir la distancia entre el robot y un objeto.

¿Qué es un actuador?

Un actuador es un componente que realiza una acción cuando recibe una orden.

Los motores son un ejemplo de actuador porque pueden hacer que un robot se mueva.

¿Qué es programar Arduino?

Programar Arduino significa escribir una serie de instrucciones para indicarle qué debe hacer.

Arduino utiliza un lenguaje basado principalmente en C y C++.

Un programa de Arduino normalmente tiene dos partes principales:

setup()
Se ejecuta una vez al comenzar el programa. Se utiliza para configurar los componentes.

loop()
Se repite continuamente mientras Arduino esté encendido.

Ejemplo sencillo

Imaginemos un robot:

Sensor: detecta un obstáculo.
Arduino: analiza la distancia.
Motor: cambia el movimiento del robot.

Esto se puede representar así:

SENSOR → ARDUINO → MOTOR

Conceptos importantes

Arduino: plataforma que permite controlar proyectos electrónicos mediante programación.

Sensor: componente que recibe información del entorno.

Actuador: componente que realiza una acción.

Entrada: información que recibe Arduino.

Procesamiento: análisis que realiza Arduino según el programa.

Salida: acción que realiza el sistema.

Conclusión

Arduino permite combinar electrónica y programación para crear proyectos capaces de percibir su entorno, tomar decisiones y realizar acciones.

Por eso Arduino es una herramienta muy utilizada para aprender robótica, programación y electrónica.

CODIGO CARRO EVASOR DE OBSTACULOS

 CODIGO CARRO EVASOR DE OBSTACULOS

// ==========================================

// EVASOR DE OBSTACULOS

// Arduino UNO + L298N + HC-SR04

// ==========================================

// ---------- MOTORES ----------

const int ENA = 5;

const int IN1 = 8;

const int IN2 = 9;

const int ENB = 6;

const int IN3 = 10;

const int IN4 = 11;

// ---------- HC-SR04 ----------

const int TRIG = 3;

const int ECHO = 4;

// const int TRIG = 12;

// const int ECHO = 13;

// ---------- CONFIGURACION ----------

const int VELOCIDAD = 140;

const int DISTANCIA_MINIMA = 20;

// ==========================================

// FUNCIONES DE MOVIMIENTO

// ==========================================

void adelante() {

  digitalWrite(IN1, LOW);

  digitalWrite(IN2, HIGH);

  digitalWrite(IN3, LOW);

  digitalWrite(IN4, HIGH);

  analogWrite(ENA, VELOCIDAD);

  analogWrite(ENB, VELOCIDAD);

}

void atras() {

  digitalWrite(IN1, HIGH);

  digitalWrite(IN2, LOW);

  digitalWrite(IN3, HIGH);

  digitalWrite(IN4, LOW);

  analogWrite(ENA, VELOCIDAD);

  analogWrite(ENB, VELOCIDAD);

}

void izquierda() {

  digitalWrite(IN1, HIGH);

  digitalWrite(IN2, LOW);

  digitalWrite(IN3, LOW);

  digitalWrite(IN4, HIGH);

  analogWrite(ENA, VELOCIDAD);

  analogWrite(ENB, VELOCIDAD);

}

void derecha() {

  digitalWrite(IN1, LOW);

  digitalWrite(IN2, HIGH);

  digitalWrite(IN3, HIGH);

  digitalWrite(IN4, LOW);

  analogWrite(ENA, VELOCIDAD);

  analogWrite(ENB, VELOCIDAD);

}

void detener() {

  analogWrite(ENA, 0);

  analogWrite(ENB, 0);

}

// ==========================================

// MEDIR DISTANCIA

// ==========================================

float medirDistancia() {

  digitalWrite(TRIG, LOW);

  delayMicroseconds(2);

  digitalWrite(TRIG, HIGH);

  delayMicroseconds(10);

  digitalWrite(TRIG, LOW);

  long tiempo = pulseIn(ECHO, HIGH);

  float distancia = tiempo * 0.0343 / 2;

  return distancia;

}

// ==========================================

// CONFIGURACION

// ==========================================

void setup() {

  pinMode(ENA, OUTPUT);

  pinMode(IN1, OUTPUT);

  pinMode(IN2, OUTPUT);

  pinMode(ENB, OUTPUT);

  pinMode(IN3, OUTPUT);

  pinMode(IN4, OUTPUT);

  pinMode(TRIG, OUTPUT);

  pinMode(ECHO, INPUT);

}

// ==========================================

// PROGRAMA PRINCIPAL

// ==========================================

void loop() {

  float distancia = medirDistancia();

  if (distancia > DISTANCIA_MINIMA) {

    adelante();

  } 

  else {

    detener();

    delay(300);

    atras();

    delay(300);

    detener();

    delay(200);

    derecha();

    delay(600);

    detener();

    delay(200);

  }

}

MINI FLASK

 

CLIC AQUI PARA DESCARGAR MINI_FLASK

ATENTOS A LAS INSTRUCCIONES DEL PROFESOR:

CODIGO ADICIONADO:

TEMA: Control de Usuarios y Sesiones en Flask

En esta guía vamos a revisar el código que hemos añadido a nuestra aplicación (app.py) para lograr que cada usuario tenga su propio nombre, inicie sesión y se valide que el nombre ingresado sea correcto.

Para lograr esto, utilizamos algo llamado Sesiones (session). Una sesión es como una memoria temporal que el servidor guarda de cada usuario mientras navega por la página.

A continuación, explicamos cada bloque de código paso a paso:

1. Importar la herramienta y configurar la llave secreta

python

from flask import Flask, render_template, request, redirect, session

app = Flask(__name__)

app.secret_key = 'clave_secreta_super_segura' # Necesario para usar 'session'

¿Qué hicimos? Agregamos session a la lista de importaciones de Flask.

¿Por qué la llave secreta? Para que Flask pueda usar sesiones, necesita encriptar los datos (protegerlos para que nadie los pueda modificar). La secret_key es la contraseña maestra que usa Flask para esto. ¡En un proyecto real, esta clave no debe ser compartida!

2. La ruta de Inicio de Sesión (Login)

python

@app.route("/login", methods=["GET", "POST"])

def login():

    error = None

    if request.method == "POST":

        nombre = request.form.get("nombre")

        

        # Validar que el nombre tenga al menos 10 caracteres

        if nombre and len(nombre.strip()) >= 10:

            session['nombre'] = nombre.strip()

            return redirect("/")

        else:

            error = "El nombre debe tener al menos 10 caracteres."

    

    return render_template("login.html", error=error)

¿Cómo funciona?

Recibimos el nombre del formulario HTML a través de request.form.get("nombre").

Validación: Usamos len(nombre.strip()) >= 10. strip() borra los espacios en blanco al principio y al final para que no hagan trampa. Luego verificamos que la longitud del texto sea de 10 caracteres o más.

Guardar en la Sesión: Si la validación es exitosa, guardamos el nombre usando session['nombre'] = nombre.strip(). De esta forma, Flask recordará a este usuario.

Manejo de errores: Si el nombre es muy corto, guardamos un mensaje de error y lo enviamos al archivo login.html para que el usuario sepa qué hizo mal.

3. Proteger nuestra página principal (Index)

Ahora que tenemos un login, no queremos que cualquier persona pueda ver o enviar mensajes si no se ha registrado antes.

python

@app.route("/", methods=["GET", "POST"])

def inicio():

    # Verificar si el usuario ha iniciado sesión

    if 'nombre' not in session:

        return redirect("/login")

El portero del club: La instrucción if 'nombre' not in session: verifica si el usuario actual tiene su nombre guardado en la "memoria". Si no lo tiene, lo mandamos expulsado al /login usando redirect("/login").

4. Guardar mensajes con el nombre del usuario

Dentro de la misma ruta /, cuando el usuario envía un mensaje nuevo:

python

        # Validar que no envíen mensajes vacíos

        if texto and texto.strip() != "":

            # Usamos insert(0, ...) para agregar el mensaje al inicio de la lista

            mensajes.insert(0, {"nombre": session['nombre'], "texto": texto})

Ahora nuestros mensajes ya no son textos simples, sino Diccionarios de Python que guardan dos cosas: quién lo escribió ("nombre") y qué dijo ("texto").

En lugar de pedirle el nombre en el formulario principal, ¡lo sacamos de session['nombre']! Es más seguro y cómodo.

Al final de la ruta /, le enviamos a nuestra plantilla HTML la lista de mensajes y también el nombre del usuario conectado para saludarlo en pantalla:

python

    return render_template("index.html", mensajes=mensajes, nombre_usuario=session['nombre'])

5. Cerrar Sesión (Logout)

Por último, todo buen sistema debe permitirle al usuario salir de su cuenta.

python

@app.route("/logout")

def logout():

    session.pop('nombre', None)

    return redirect("/login")

¿Qué hace pop? Busca la clave 'nombre' dentro de la memoria de la sesión y la elimina. Una vez eliminada, el usuario es redirigido al /login y como ya no tiene su nombre guardado, no podrá entrar hasta volver a registrarse.

TIP

Resumen para recordar:

session['llave'] = valor -> Guardar un dato temporal.

session['llave'] -> Leer el dato que guardamos.

session.pop('llave', None) -> Borrar el dato de la memoria.

TEORIA

 ¿Qué son las Sesiones y por qué son Vitales?

Para entender las sesiones, primero hay que entender un problema fundamental de la web: Internet sufre de "amnesia".

El protocolo que usamos para navegar por internet (HTTP) es "sin estado" (stateless). Esto significa que cada vez que haces clic en un enlace o envías un formulario, para el servidor eres un completo desconocido. El servidor no tiene memoria de lo que hiciste hace 2 segundos.

¿El problema? Si el servidor no tiene memoria:

Inicias sesión en una página, pero al hacer clic en tu perfil, el servidor te olvida y te vuelve a pedir la contraseña.

Agregas unos zapatos a un carrito de compras, pero al ir a pagar, el carrito está vacío porque el servidor olvidó quién eres.

La Solución: Las Sesiones (session)

Una sesión es un mecanismo que le da memoria temporal al servidor sobre un usuario específico.

Funciona como un brazalete VIP en una discoteca:

Cuando el usuario inicia sesión (muestra su ID en la entrada), el servidor verifica que sea válido.

Si es válido, el servidor le da un "brazalete virtual" (una Cookie encriptada) que se guarda en el navegador web del usuario.

Cada vez que el usuario va a otra página del sitio web, su navegador muestra automáticamente el brazalete.

El servidor ve el brazalete, dice "¡Ah! Ya sé quién eres" y le deja pasar sin pedirle la contraseña de nuevo.

¿Por qué es tan importante manejar bien las Sesiones?

Identidad (Logins): Es la única forma de mantener a un usuario conectado mientras navega por diferentes páginas (como Facebook, Netflix o el correo electrónico).

Personalización: Permite recordar preferencias del usuario, como el modo oscuro, el idioma elegido o el contenido de su carrito de compras.

Seguridad (Control de Acceso): Nos permite proteger rutas. Gracias a las sesiones, podemos decirle al servidor: "Si alguien intenta entrar a la página principal y no tiene el brazalete de la sesión, échalo y envíalo al login" (exactamente lo que hicimos en nuestro código).