=============
Sesión 3 - Python Básico
=============

En esta sección aprenderemos los fundamentos de programación en Python. Python es un lenguaje de programación de alto nivel, interpretado y de propósito general, conocido por su sintaxis clara y legible.

Tipos de Datos Básicos
======================

Los tipos de datos son categorías que indican qué clase de información puede almacenar una variable. Python tiene cuatro tipos de datos fundamentales que usaremos con frecuencia.

Enteros (int)
-------------

Los enteros son números sin parte decimal. Pueden ser positivos, negativos o cero.

.. code-block:: python

   edad = 25
   temperatura_minima = -5
   print(type(edad))  # <class 'int'>

Podemos realizar operaciones matemáticas con enteros, como suma, resta, multiplicación y división.

Números de Punto Flotante (float)
---------------------------------

Los flotantes representan números con parte decimal. Se utilizan para medidas precisas y cálculos científicos.

.. code-block:: python

   altura = 1.75
   pi = 3.14159
   print(type(pi))  # <class 'float'>

Los flotantes son útiles cuando necesitamos representar valores que no son enteros, como distancias, pesos o porcentajes.

Booleanos (bool)
----------------

Los booleanos solo pueden tener dos valores: True (verdadero) o False (falso). Son fundamentales para la toma de decisiones en programación.

.. code-block:: python

   es_estudiante = True
   tiene_mascota = False
   print(type(es_estudiante))  # <class 'bool'>

Los valores booleanos son el resultado de expresiones de comparación y se utilizan en estructuras condicionales.

Cadenas de Texto (str)
----------------------

Las cadenas representan texto. Se pueden definir con comillas simples o dobles.

.. code-block:: python

   nombre = "Ana"
   mensaje = 'Hola, ¿cómo estás?'
   print(type(nombre))  # <class 'str'>

Las cadenas pueden contener letras, números, símbolos y espacios. Son muy útiles para almacenar y manipular texto.

Verificación de Tipos
---------------------

Para conocer el tipo de dato de una variable, utilizamos la función ``type()``. Esta función nos devuelve el tipo de dato de la variable o valor que le pasemos como argumento.

Conversión entre Tipos de Datos
-------------------------------

Python permite convertir datos de un tipo a otro utilizando funciones especializadas. Las conversiones más comunes son:

Conversión a entero (int())
~~~~~~~~~~~~~~~~~~~~~~~~~~~

La función ``int()`` convierte un valor a número entero:

.. code-block:: python

   # Convertir float a int (trunca la parte decimal)
   x = int(10.8)  # x = 10
   y = int(3.2)   # y = 3
   
   # Convertir string a int
   edad = int("25")  # edad = 25
   
   # Convertir booleano a int
   z = int(True)   # z = 1
   w = int(False)  # w = 0

Es importante notar que al convertir de float a int, Python trunca el número (elimina la parte decimal) en lugar de redondearlo.

Conversión a flotante (float())
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

La función ``float()`` convierte un valor a número de punto flotante:

.. code-block:: python

   # Convertir int a float
   x = float(10)   # x = 10.0
   
   # Convertir string a float
   peso = float("68.5")  # peso = 68.5
   
   # Convertir booleano a float
   y = float(True)   # y = 1.0
   z = float(False)  # z = 0.0

Conversión a cadena (str())
~~~~~~~~~~~~~~~~~~~~~~~~~~

La función ``str()`` convierte cualquier valor a cadena de texto:

.. code-block:: python

   # Convertir int a string
   edad_texto = str(25)  # edad_texto = "25"
   
   # Convertir float a string
   altura_texto = str(1.75)  # altura_texto = "1.75"
   
   # Convertir booleano a string
   respuesta = str(True)  # respuesta = "True"

Esto es especialmente útil cuando necesitamos mostrar valores numéricos junto con texto.

Errores comunes en la conversión
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

No todas las conversiones son posibles. Algunos valores no pueden convertirse directamente:

.. code-block:: python

   # Esto provocará un error
   numero = int("diez")  # ValueError: invalid literal for int()
   
   # Esto también provocará un error
   valor = int("10.5")   # ValueError: invalid literal for int()

Para evitar errores, podemos usar manejo de excepciones (try-except) o asegurarnos de que el valor es válido antes de intentar la conversión.

Operadores
==========

Los operadores son símbolos especiales que realizan operaciones con variables y valores. Python tiene diferentes categorías de operadores.

Operadores Aritméticos
----------------------

Estos operadores realizan operaciones matemáticas básicas.

.. code-block:: python

   a = 10
   b = 3
   
   suma = a + b            # 13
   resta = a - b           # 7
   multiplicacion = a * b  # 30
   division = a / b        # 3.3333333333333335 (siempre devuelve float)

La división normal (``/``) siempre devuelve un número de punto flotante, incluso si la división es exacta.

.. code-block:: python

   division_entera = a // b  # 3 (división entera, descarta la parte decimal)
   modulo = a % b          # 1 (residuo de la división)
   potencia = a ** b       # 1000 (a elevado a la b)

La división entera (``//``) descarta la parte decimal y devuelve solo la parte entera. El operador módulo (``%``) devuelve el residuo de la división.

Operadores de Comparación
-------------------------

Estos operadores comparan dos valores y devuelven un valor booleano (True o False).

.. code-block:: python

   x = 5
   y = 10
   
   igual = x == y          # False
   diferente = x != y      # True
   mayor = x > y           # False
   menor = x < y           # True

Los operadores de comparación son fundamentales para las estructuras condicionales, ya que permiten tomar decisiones basadas en comparaciones.

.. code-block:: python

   mayor_igual = x >= y    # False
   menor_igual = x <= y    # True

Los operadores ``>=`` y ``<=`` verifican si un valor es mayor o igual, o menor o igual que otro valor, respectivamente.

Operadores Lógicos
------------------

Los operadores lógicos combinan valores booleanos y devuelven un resultado booleano.

.. code-block:: python

   p = True
   q = False
   
   y_logico = p and q      # False (ambas deben ser True)
   o_logico = p or q       # True (al menos una debe ser True)
   negacion = not p        # False (invierte el valor)

El operador ``and`` devuelve True solo si ambos operandos son True. El operador ``or`` devuelve True si al menos uno de los operandos es True. El operador ``not`` invierte el valor booleano.

Funciones de Entrada/Salida
===========================

Para interactuar con el usuario, necesitamos funciones que nos permitan mostrar información y recibir datos.

Salida de datos con print()
-------------------------

La función ``print()`` muestra información en la consola. Es una de las funciones más utilizadas para depurar y mostrar resultados.

.. code-block:: python

   print("Hola, mundo!")

Podemos mostrar múltiples valores separándolos con comas:

.. code-block:: python
   
   nombre = "Carlos"
   edad = 22
   print("Nombre:", nombre, "Edad:", edad)

También podemos formatear cadenas para incluir variables de manera más elegante:

.. code-block:: python
   
   # Formateo de cadenas con f-strings (Python 3.6+)
   print(f"Hola, me llamo {nombre} y tengo {edad} años.")

Los f-strings (cadenas formateadas) permiten incluir el valor de variables directamente dentro de una cadena, haciendo que el código sea más legible.

Entrada de datos con input()
----------------------------

La función ``input()`` permite recibir datos del usuario a través del teclado. Siempre devuelve una cadena de texto.

.. code-block:: python

   nombre = input("Ingrese su nombre: ")
   print(f"Hola, {nombre}!")

Como ``input()`` siempre devuelve una cadena, necesitamos convertir el valor a otro tipo si queremos realizar operaciones específicas:

.. code-block:: python
   
   # input() siempre devuelve un string, hay que convertir a otros tipos
   edad_str = input("Ingrese su edad: ")
   edad = int(edad_str)  # Convertimos a entero

Podemos combinar la lectura y conversión en una sola línea:

.. code-block:: python
   
   # También podemos combinar ambos pasos
   altura = float(input("Ingrese su altura en metros: "))

Las funciones ``int()`` y ``float()`` convierten cadenas a enteros y flotantes, respectivamente.

Estructuras de Control
======================

Las estructuras de control determinan el flujo de ejecución de un programa. Permiten tomar decisiones y repetir acciones.

.. note::
   **Bloques de código e indentación en Python**
   
   Python utiliza la indentación (espacios al inicio de una línea) para definir bloques de código. A diferencia de otros lenguajes que usan llaves {} o palabras clave, Python se basa en la indentación para determinar dónde comienza y termina un bloque.
   
   Un bloque de código es un conjunto de instrucciones que se ejecutan como una unidad. Los bloques se utilizan en estructuras condicionales, bucles y funciones.
   
   Los dos puntos (:) indican que comenzará un nuevo bloque de código indentado:
   
   .. code-block:: python
   
      if condicion:  # Los dos puntos indican que viene un bloque indentado
          # Este bloque pertenece al if
          instruccion1
          instruccion2
      # Esta línea ya no pertenece al bloque del if
   
   La convención en Python es usar 4 espacios para cada nivel de indentación. Un error común de principiantes es mezclar espacios y tabulaciones, lo que puede causar errores difíciles de detectar.
   
   Siempre que veas los dos puntos (:) al final de una línea, el código que sigue debe estar indentado para indicar que forma parte de ese bloque.

Condicionales (if, elif, else)
------------------------------

Las estructuras condicionales permiten ejecutar diferentes bloques de código según se cumplan o no ciertas condiciones.

Estructura if simple
~~~~~~~~~~~~~~~~~~~~

La estructura ``if`` ejecuta un bloque de código solo si la condición es verdadera.

.. code-block:: python

   edad = 18
   
   if edad >= 18:
       print("Eres mayor de edad")

Si la condición es falsa, el bloque de código dentro del ``if`` no se ejecuta y el programa continúa con la siguiente instrucción fuera del bloque.

.. graphviz::

   digraph if_simple {
       node [shape=box, style=rounded];
       start [shape=oval, label="Inicio"];
       condition [shape=diamond, label="¿edad >= 18?"];
       action [label="Mostrar: Eres mayor de edad"];
       end [shape=oval, label="Fin"];
       
       start -> condition;
       condition -> action [label="Sí"];
       condition -> end [label="No"];
       action -> end;
   }

Estructura if-else
~~~~~~~~~~~~~~~~~~

La estructura ``if-else`` permite ejecutar un bloque de código si la condición es verdadera, o un bloque alternativo si es falsa.

.. code-block:: python

   edad = 15
   
   if edad >= 18:
       print("Eres mayor de edad")
   else:
       print("Eres menor de edad")

Esta estructura garantiza que siempre se ejecutará uno de los dos bloques, dependiendo del resultado de la condición.

.. graphviz::

   digraph if_else {
       node [shape=box, style=rounded];
       start [shape=oval, label="Inicio"];
       condition [shape=diamond, label="¿edad >= 18?"];
       action_true [label="Mostrar: Eres mayor de edad"];
       action_false [label="Mostrar: Eres menor de edad"];
       end [shape=oval, label="Fin"];
       
       start -> condition;
       condition -> action_true [label="Sí"];
       condition -> action_false [label="No"];
       action_true -> end;
       action_false -> end;
   }

Estructura if-elif-else
~~~~~~~~~~~~~~~~~~~~~~~

La estructura ``if-elif-else`` permite evaluar múltiples condiciones en secuencia. Se utiliza cuando hay más de dos posibles caminos de ejecución.

.. code-block:: python

   nota = 85
   
   if nota >= 90:
       print("Excelente")
   elif nota >= 80:
       print("Muy bien")
   elif nota >= 70:
       print("Bien")
   elif nota >= 60:
       print("Suficiente")
   else:
       print("Reprobado")

Python evalúa las condiciones en orden. En cuanto encuentra una condición verdadera, ejecuta el bloque correspondiente y omite el resto. Si ninguna condición es verdadera, ejecuta el bloque ``else``.

.. graphviz::

   digraph if_elif_else {
       node [shape=box, style=rounded];
       start [shape=oval, label="Inicio"];
       cond1 [shape=diamond, label="¿nota >= 90?"];
       cond2 [shape=diamond, label="¿nota >= 80?"];
       cond3 [shape=diamond, label="¿nota >= 70?"];
       cond4 [shape=diamond, label="¿nota >= 60?"];
       action1 [label="Mostrar: Excelente"];
       action2 [label="Mostrar: Muy bien"];
       action3 [label="Mostrar: Bien"];
       action4 [label="Mostrar: Suficiente"];
       action5 [label="Mostrar: Reprobado"];
       end [shape=oval, label="Fin"];
       
       start -> cond1;
       cond1 -> action1 [label="Sí"];
       cond1 -> cond2 [label="No"];
       cond2 -> action2 [label="Sí"];
       cond2 -> cond3 [label="No"];
       cond3 -> action3 [label="Sí"];
       cond3 -> cond4 [label="No"];
       cond4 -> action4 [label="Sí"];
       cond4 -> action5 [label="No"];
       action1 -> end;
       action2 -> end;
       action3 -> end;
       action4 -> end;
       action5 -> end;
   }

Bucles en Python
================

Los bucles permiten repetir un bloque de código múltiples veces. Son útiles para procesar listas, realizar cálculos iterativos o repetir acciones hasta que se cumpla una condición.

El bucle while
--------------

El bucle ``while`` ejecuta un bloque de código mientras una condición sea verdadera. Es útil cuando no sabemos exactamente cuántas veces necesitamos repetir el código.

.. code-block:: python

   contador = 1
   
   while contador <= 5:
       print(f"Contador: {contador}")
       contador += 1  # Equivalente a: contador = contador + 1

Es crucial modificar la variable de control dentro del bucle (en este caso, incrementar el contador) para que eventualmente la condición se vuelva falsa. De lo contrario, se creará un bucle infinito.

.. graphviz::

   digraph while_loop {
       node [shape=box, style=rounded];
       start [shape=oval, label="Inicio"];
       init [label="contador = 1"];
       condition [shape=diamond, label="¿contador <= 5?"];
       action [label="Mostrar contador\ncontador += 1"];
       end [shape=oval, label="Fin"];
       
       start -> init;
       init -> condition;
       condition -> action [label="Sí"];
       action -> condition;
       condition -> end [label="No"];
   }

El flujo de un bucle ``while`` es: evalúa la condición; si es verdadera, ejecuta el bloque de código y vuelve a evaluar la condición; si es falsa, sale del bucle y continúa con el resto del programa.

El bucle for con range()
------------------------

El bucle ``for`` con la función ``range()`` es ideal cuando sabemos exactamente cuántas veces queremos repetir un bloque de código. Es especialmente útil para recorrer secuencias de números.

.. code-block:: python

   # Imprime números del 0 al 4
   for i in range(5):
       print(i)

La función ``range(n)`` genera una secuencia de números desde 0 hasta n-1. También podemos especificar el valor inicial, final y el paso:

.. code-block:: python
   
   # Imprime números del 1 al 5
   for i in range(1, 6):
       print(i)

El rango ``range(1, 6)`` genera números del 1 al 5. El primer parámetro es inclusivo, mientras que el segundo es exclusivo.

.. code-block:: python
   
   # Imprime números pares del 0 al 10
   for i in range(0, 11, 2):
       print(i)

El tercer parámetro de ``range()`` indica el paso o incremento. En este ejemplo, generamos números de 2 en 2, obteniendo los números pares entre 0 y 10.

Ejemplos de Uso
===============

A continuación veremos algunos ejemplos prácticos que combinan los conceptos aprendidos.

Clasificación de un número
--------------------------

Este programa clasifica un número ingresado por el usuario como positivo, negativo o cero:

.. code-block:: python

   numero = int(input("Ingrese un número: "))
   
   if numero > 0:
       print("El número es positivo")
   elif numero < 0:
       print("El número es negativo")
   else:
       print("El número es cero")

Utilizamos la estructura if-elif-else para cubrir todas las posibilidades (mayor que cero, menor que cero, o igual a cero).

Conversor de unidades
---------------------

Este programa convierte entre diferentes unidades según la elección del usuario:

.. code-block:: python

   print("Conversor de unidades")
   print("1. Kilómetros a Millas")
   print("2. Millas a Kilómetros")
   print("3. Celsius a Fahrenheit")
   print("4. Fahrenheit a Celsius")
   
   opcion = int(input("Elija una opción (1-4): "))

Primero mostramos un menú y leemos la opción del usuario. Luego, según la opción elegida, solicitamos los datos necesarios y realizamos la conversión correspondiente:

.. code-block:: python
   
   if opcion == 1:
       km = float(input("Ingrese la distancia en kilómetros: "))
       millas = km * 0.621371
       print(f"{km} kilómetros equivalen a {millas} millas")
   elif opcion == 2:
       millas = float(input("Ingrese la distancia en millas: "))
       km = millas / 0.621371
       print(f"{millas} millas equivalen a {km} kilómetros")
   elif opcion == 3:
       celsius = float(input("Ingrese la temperatura en Celsius: "))
       fahrenheit = (celsius * 9/5) + 32
       print(f"{celsius}°C equivalen a {fahrenheit}°F")
   elif opcion == 4:
       fahrenheit = float(input("Ingrese la temperatura en Fahrenheit: "))
       celsius = (fahrenheit - 32) * 5/9
       print(f"{fahrenheit}°F equivalen a {celsius}°C")
   else:
       print("Opción no válida")

Este ejemplo muestra cómo combinar entrada de usuario, condicionales y operaciones matemáticas para crear un programa útil.

Sumatoria con bucle while
-------------------------

Este programa calcula la suma de los números del 1 al 10 utilizando un bucle while:

.. code-block:: python

   # Sumatoria de los números del 1 al 10
   suma = 0
   contador = 1
   
   while contador <= 10:
       suma += contador
       contador += 1
       
   print(f"La suma de los números del 1 al 10 es: {suma}")

Inicializamos una variable ``suma`` en 0 y un ``contador`` en 1. En cada iteración del bucle, añadimos el valor actual del contador a la suma y luego incrementamos el contador. El bucle termina cuando el contador supera 10.

Conclusión
=========

En esta introducción hemos cubierto los conceptos básicos de Python:

- Tipos de datos (int, float, bool, str): las categorías fundamentales para almacenar información.
- Conversión entre tipos de datos: mecanismos para transformar valores de un tipo a otro.
- Operadores (aritméticos, comparación, lógicos): símbolos que nos permiten manipular y comparar datos.
- Funciones de entrada/salida (input, print): herramientas esenciales para la interacción con el usuario.
- Estructuras de control (if, elif, else): mecanismos para tomar decisiones en nuestros programas.
- Bucles (while, for con range): técnicas para repetir acciones múltiples veces.

Estos conceptos son los cimientos sobre los que construiremos programas más complejos a lo largo del curso. En las próximas sesiones, profundizaremos en estos temas y aprenderemos nuevas técnicas de programación.