Introducción a Python
#####################

El intérprete de Python
========================

Python es un lenguaje de programación versátil y fácil de aprender. Una de sus características más accesibles es su intérprete interactivo. El intérprete de Python es una herramienta poderosa que permite a los usuarios ejecutar código Python en tiempo real, línea por línea.

Características del intérprete:

* Al abrirlo, muestra un prompt (``>>>``), indicando que está listo para recibir comandos.
* Funciona como una interfaz REPL (Read-Eval-Print Loop):
   - Lee la entrada del usuario
   - Evalúa el código
   - Imprime el resultado
   - Vuelve a esperar la próxima instrucción

Usos comunes del intérprete:

1. Probar pequeños fragmentos de código rápidamente
2. Experimentar con nuevas ideas o conceptos
3. Depurar programas más grandes
4. Realizar cálculos rápidos

Usando el intérprete como una calculadora
------------------------------------------

Una forma sencilla de comenzar con el intérprete de Python es usarlo como una calculadora avanzada. Python admite operaciones aritméticas básicas y complejas.

. code-block:: python

   >>> 15 + 7
   22
   >>> 20 * 3 - 10
   50
   >>> 100 / 5 + 2 ** 3
   28.0

En este ejemplo, se realizan tres operaciones aritméticas simples: suma, multiplicación y división, junto con una operación de potencia. El intérprete devuelve el resultado de cada operación inmediatamente.

Operadores Aritméticos en Python
--------------------------------

Python ofrece una amplia gama de operadores aritméticos que permiten realizar cálculos matemáticos de manera eficiente. Estos operadores son fundamentales para realizar operaciones numéricas, desde las más simples hasta las más complejas.


+-------------+------------+-------------------+----------+
| Operador    | Descripción| Ejemplo           | Resultado|
+=============+============+===================+==========+
| ``+``       | Suma       | ``5 + 3``         | ``8``    |
+-------------+------------+-------------------+----------+
| ``-``       | Resta      | ``10 - 7``        | ``3``    |
+-------------+------------+-------------------+----------+
| ``*``       | Multiplic. | ``4 * 6``         | ``24``   |
+-------------+------------+-------------------+----------+
| ``/``       | División   | ``15 / 3``        | ``5.0``  |
+-------------+------------+-------------------+----------+
| ``//``      | Div. entera| ``17 // 3``       | ``5``    |
+-------------+------------+-------------------+----------+
| ``%``       | Módulo     | ``17 % 3``        | ``2``    |
+-------------+------------+-------------------+----------+
| ``**``      | Potencia   | ``2 ** 3``        | ``8``    |
+-------------+------------+-------------------+----------+
| ``-``       | Negación   | ``-5``            | ``-5``   |
+-------------+------------+-------------------+----------+
| ``+``       | Positivo   | ``+5``            | ``5``    |
+-------------+------------+-------------------+----------+
| ``abs()``   | Valor abs. | ``abs(-5)``       | ``5``    |
+-------------+------------+-------------------+----------+
| ``round()`` | Redondeo   | ``round(3.7)``    | ``4``    |
+-------------+------------+-------------------+----------+

Nota: Los operadores ``abs()`` y ``round()`` son funciones integradas,
no operadores en sentido estricto, pero se incluyen por su utilidad en
cálculos aritméticos.

Operadores de comparación
-------------------------

Los operadores de comparación en Python se utilizan para comparar valores. Estos operadores devuelven un valor booleano (``True`` o ``False``) dependiendo de si la comparación es verdadera o falsa. Son fundamentales en la programación para tomar decisiones y controlar el flujo de ejecución de un programa.

+----------+--------------------+-------------------+----------+
| Operador | Descripción        | Ejemplo           | Resultado|
+==========+====================+===================+==========+
| ``==``   | Igual a            | ``5 == 5``        | ``True`` |
+----------+--------------------+-------------------+----------+
| ``!=``   | No igual a         | ``5 != 3``        | ``True`` |
+----------+--------------------+-------------------+----------+
| ``>``    | Mayor que          | ``7 > 3``         | ``True`` |
+----------+--------------------+-------------------+----------+
| ``<``    | Menor que          | ``2 < 8``         | ``True`` |
+----------+--------------------+-------------------+----------+
| ``>=``   | Mayor o igual que  | ``5 >= 5``        | ``True`` |
+----------+--------------------+-------------------+----------+
| ``<=``   | Menor o igual que  | ``4 <= 4``        | ``True`` |
+----------+--------------------+-------------------+----------+

Estos operadores son esenciales en estructuras de control como ``if``, ``while``, y en expresiones condicionales. Permiten comparar no solo números, sino también otros tipos de datos como cadenas y objetos, siempre que sean comparables entre sí.

Operadores de asignación
------------------------

Los operadores de asignación en Python se utilizan para asignar valores a variables. Además de la asignación básica (=), Python ofrece operadores de asignación compuestos que combinan una operación aritmética con la asignación. Estos operadores proporcionan una forma concisa de actualizar el valor de una variable basándose en su valor actual.

+----------+-------------------------+--------------------+---------------------------+
| Operador | Descripción             | Ejemplo            | Equivalente               |
+==========+=========================+====================+===========================+
| ``=``    | Asignación simple       | ``x = 5``          | ``x = 5``                 |
+----------+-------------------------+--------------------+---------------------------+
| ``+=``   | Suma y asignación       | ``x += 3``         | ``x = x + 3``             |
+----------+-------------------------+--------------------+---------------------------+
| ``-=``   | Resta y asignación      | ``x -= 2``         | ``x = x - 2``             |
+----------+-------------------------+--------------------+---------------------------+
| ``*=``   | Multiplicación y asign. | ``x *= 4``         | ``x = x * 4``             |
+----------+-------------------------+--------------------+---------------------------+
| ``/=``   | División y asignación   | ``x /= 2``         | ``x = x / 2``             |
+----------+-------------------------+--------------------+---------------------------+
| ``//=``  | División entera y asign.| ``x //= 3``        | ``x = x // 3``            |
+----------+-------------------------+--------------------+---------------------------+
| ``%=``   | Módulo y asignación     | ``x %= 3``         | ``x = x % 3``             |
+----------+-------------------------+--------------------+---------------------------+
| ``**=``  | Potencia y asignación   | ``x **= 2``        | ``x = x ** 2``            |
+----------+-------------------------+--------------------+---------------------------+

Estos operadores de asignación compuestos son útiles para actualizar variables de manera concisa y eficiente. Son comúnmente utilizados en bucles y en situaciones donde se necesita modificar repetidamente el valor de una variable basándose en su valor actual.


Variables y Tipos de Datos Numéricos en Python
==============================================

Variables en Python
-------------------

En Python, una variable es un nombre que se refiere a un valor almacenado en la memoria del ordenador. Las variables son fundamentales en programación, ya que permiten almacenar y manipular datos.

Características de las variables en Python:

1. **Asignación dinámica**: Python asigna tipos a las variables automáticamente basándose en el valor que contienen.
2. **Flexibilidad**: Una variable puede cambiar de tipo durante la ejecución del programa.
3. **Nomenclatura**: Deben comenzar con una letra o guión bajo, seguido de letras, números o guiones bajos.

Ejemplo de asignación de variables:

.. code-block:: python

   x = 5
   nombre = "Alice"
   pi = 3.14159

Tipos de Datos Numéricos en Python
----------------------------------

Python ofrece varios tipos de datos numéricos para representar diferentes tipos de números:

1. Enteros (int)
^^^^^^^^^^^^^^^^

Los enteros son números completos sin parte decimal.

Características:
- Pueden ser positivos o negativos.
- No tienen límite de tamaño (sólo limitados por la memoria disponible).

Ejemplo:

.. code-block:: python

   edad = 25
   población = 7800000000

2. Números de Punto Flotante (float)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Los flotantes son números con parte decimal.

Características:
- Representan números reales.
- Tienen precisión limitada (típicamente 15-17 dígitos significativos).

Ejemplo:

.. code-block:: python

   pi = 3.14159
   temperatura = -2.5

3. Números Complejos (complex)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Los números complejos tienen una parte real y una parte imaginaria.

Características:
- Se escriben como ``a + bj``, donde ``a`` es la parte real y ``b`` la imaginaria.
- ``j`` representa la raíz cuadrada de -1.

Ejemplo:

.. code-block:: python

   z = 2 + 3j
   w = complex(1, -2)

Conversión entre Tipos Numéricos
--------------------------------

Python permite convertir entre diferentes tipos numéricos:

.. code-block:: python

   # Conversión a entero
   int_num = int(3.14)  # Resultado: 3

   # Conversión a float
   float_num = float(5)  # Resultado: 5.0

   # Conversión a complex
   complex_num = complex(2, 3)  # Resultado: 2+3j

Operaciones con Tipos Numéricos
-------------------------------

Las operaciones aritméticas básicas funcionan con todos los tipos numéricos:

.. code-block:: python

   x = 10
   y = 3

   suma = x + y
   resta = x - y
   multiplicación = x * y
   división = x / y  # Siempre devuelve un float
   división_entera = x // y
   módulo = x % y
   potencia = x ** y



Introducción al Módulo math en Python
=====================================

¿Qué es un Módulo?
------------------

En Python, un módulo es simplemente un archivo que contiene código Python. Los módulos permiten organizar y reutilizar código. Python incluye muchos módulos útiles, y uno de ellos es el módulo ``math``.

El Módulo math
--------------

El módulo ``math`` proporciona funciones matemáticas avanzadas que no están disponibles con los operadores aritméticos básicos de Python.

Cómo Usar el Módulo math en la Consola
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Para utilizar el módulo ``math`` en la consola de Python, primero debes importarlo:

>>> import math

Después de importarlo, puedes usar sus funciones directamente:

>>> math.sqrt(16)  # Calcula la raíz cuadrada de 16
4.0

Funciones Principales del Módulo math
-------------------------------------

1. Constantes Matemáticas
^^^^^^^^^^^^^^^^^^^^^^^^^

>>> math.pi  # Aproximadamente 3.141592653589793
3.141592653589793
>>> math.e   # Aproximadamente 2.718281828459045
2.718281828459045

2. Funciones Trigonométricas
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

>>> math.sin(math.pi/2)  # Seno de 90 grados (en radianes)
1.0
>>> math.cos(0)  # Coseno de 0 grados
1.0

3. Raíz Cuadrada y Potencias
^^^^^^^^^^^^^^^^^^^^^^^^^^^^

>>> math.sqrt(16)  # Raíz cuadrada de 16
4.0
>>> math.pow(2, 3)  # 2 elevado a la 3
8.0

4. Funciones Exponenciales y Logarítmicas
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

>>> math.exp(1)  # e^1
2.718281828459045
>>> math.log(math.e)  # Logaritmo natural de e
1.0
>>> math.log10(100)  # Logaritmo en base 10 de 100
2.0

5. Funciones de Redondeo
^^^^^^^^^^^^^^^^^^^^^^^^

>>> math.ceil(4.3)   # Redondeo hacia arriba
5
>>> math.floor(4.7)  # Redondeo hacia abajo
4
>>> math.trunc(-4.7) # Truncamiento hacia cero
-4

Ejemplo Práctico
----------------

Calcular el área de un círculo:

>>> import math
>>> radio = 5
>>> area = math.pi * math.pow(radio, 2)
>>> area
78.53981633974483

Funciones y Constantes del Módulo math en Python
================================================

El módulo ``math`` proporciona una amplia gama de funciones matemáticas y algunas constantes importantes. Aquí se presenta una lista completa:

Constantes
----------

>>> import math

>>> math.pi  # Pi
3.141592653589793

>>> math.e   # Número de Euler
2.718281828459045

>>> math.tau  # Tau (2*pi)
6.283185307179586

>>> math.inf  # Infinito positivo
inf

>>> math.nan  # Not a Number
nan

Funciones Trigonométricas
-------------------------

>>> math.sin(x)    # Seno de x (x en radianes)
>>> math.cos(x)    # Coseno de x
>>> math.tan(x)    # Tangente de x
>>> math.asin(x)   # Arcoseno de x
>>> math.acos(x)   # Arcocoseno de x
>>> math.atan(x)   # Arcotangente de x
>>> math.atan2(y, x)  # Arcotangente de y/x

Funciones Hiperbólicas
----------------------

>>> math.sinh(x)   # Seno hiperbólico de x
>>> math.cosh(x)   # Coseno hiperbólico de x
>>> math.tanh(x)   # Tangente hiperbólica de x
>>> math.asinh(x)  # Arcoseno hiperbólico de x
>>> math.acosh(x)  # Arcocoseno hiperbólico de x
>>> math.atanh(x)  # Arcotangente hiperbólica de x

Funciones Exponenciales y Logarítmicas
--------------------------------------

>>> math.exp(x)    # e elevado a la x
>>> math.log(x[, base])  # Logaritmo de x en la base especificada (por defecto, logaritmo natural)
>>> math.log2(x)   # Logaritmo en base 2 de x
>>> math.log10(x)  # Logaritmo en base 10 de x

Funciones de Potencia y Raíz
----------------------------

>>> math.pow(x, y)  # x elevado a la y
>>> math.sqrt(x)    # Raíz cuadrada de x

Funciones de Redondeo y Absolutas
---------------------------------

>>> math.ceil(x)   # Redondeo hacia arriba
>>> math.floor(x)  # Redondeo hacia abajo
>>> math.trunc(x)  # Truncamiento hacia cero
>>> math.fabs(x)   # Valor absoluto de x (como float)

Otras Funciones
---------------

>>> math.factorial(x)  # Factorial de x
>>> math.gcd(a, b)     # Máximo común divisor de a y b
>>> math.fmod(x, y)    # Resto de la división de x por y
>>> math.frexp(x)      # Retorna la mantisa y el exponente de x
>>> math.ldexp(x, i)   # x * (2**i)
>>> math.modf(x)       # Parte fraccionaria y entera de x
>>> math.isclose(a, b[, *, rel_tol=1e-09, abs_tol=0.0])  # Comprueba si a y b son casi iguales
>>> math.isfinite(x)   # Comprueba si x es finito
>>> math.isinf(x)      # Comprueba si x es infinito
>>> math.isnan(x)      # Comprueba si x es NaN (Not a Number)
>>> math.copysign(x, y)  # Retorna x con el signo de y
>>> math.fsum(iterable)  # Suma de precisión de un iterable de flotantes
>>> math.prod(iterable)  # Producto de un iterable de números

Funciones de Ángulos
--------------------

>>> math.degrees(x)  # Convierte de radianes a grados
>>> math.radians(x)  # Convierte de grados a radianes

Funciones Especiales
--------------------

>>> math.erf(x)      # Función de error
>>> math.erfc(x)     # Función de error complementaria
>>> math.gamma(x)    # Función gamma
>>> math.lgamma(x)   # Logaritmo natural de la función gamma absoluta

Nota: Esta lista está basada en Python 3.9+. Versiones anteriores de Python pueden no incluir todas estas funciones.


Python Básico
=============

¿Qué es Python?
---------------

Python es un lenguaje de programación de alto nivel, interpretado y de propósito general. Fue creado por Guido van Rossum y lanzado por primera vez en 1991. Python se ha convertido en uno de los lenguajes de programación más populares debido a su simplicidad y versatilidad.

Características Principales de Python
-------------------------------------

1. **Sintaxis Clara**: Python utiliza una sintaxis clara y legible, lo que lo hace fácil de aprender y escribir.

2. **Interpretado**: No necesita ser compilado antes de ejecutarse, lo que facilita el proceso de desarrollo y prueba.

3. **Multiplataforma**: Funciona en diversos sistemas operativos como Windows, macOS y Linux.

4. **Tipado Dinámico**: No es necesario declarar el tipo de las variables, Python lo determina automáticamente.

5. **Amplia Biblioteca Estándar**: Viene con un conjunto extenso de módulos y funciones incorporadas que facilitan muchas tareas comunes.

6. **Versátil**: Se utiliza en una amplia gama de aplicaciones, desde desarrollo web hasta ciencia de datos e inteligencia artificial.


Reglas básicas de un buen programa
----------------------------------

Antes de sumergirnos en la programación propiamente dicha, es importante comprender que existen ciertas reglas y principios que conviene seguir al crear un programa. Estas pautas nos ayudan a desarrollar lo que consideramos un "buen programa".

Es posible que algunas de estas reglas no tengan mucho sentido en este momento, especialmente si eres nuevo en la programación. Sin embargo, a medida que vayas programando y enfrentándote a diversos desafíos y problemas en tus códigos, se hará evidente por qué estas reglas son tan importantes. La experiencia te mostrará cómo aplicarlas mejora significativamente la calidad y mantenibilidad de tu código.

Un buen programa debe:

#. Dar resultados correctos

#. Ser claro y fácil de leer. Es decir debe entenderse con facilidad que
   hace cada una de sus partes.

#. Estar "autodocumentado" para facilitarle la vida al lector y al
   programador.

#. Ser fácil de usar.

#. Ser robusto de tal forma que aun al modificarlo sea fácil verificar que
   los resultados son correctos.

#. Ser eficiente en el uso de recursos (memoria, tiempo de ejecución).

#. Seguir las convenciones de estilo del lenguaje (en Python, PEP 8).

#. Manejar errores y excepciones de manera adecuada.

#. Ser modular y reutilizable, dividiendo el código en funciones y clases lógicas.

#. Incluir pruebas unitarias para verificar su funcionamiento.

#. Ser mantenible a largo plazo, con código bien estructurado y comentarios útiles.

#. Ser seguro, protegiendo contra vulnerabilidades comunes.

A medida que avances en tu aprendizaje de Python y en la práctica de la programación, 
estas reglas se convertirán en una segunda naturaleza, ayudándote a escribir código 
de alta calidad de manera consistente.


Primer programa en Python
-------------------------

Bienvenido a tu primer programa en Python. Este ejemplo te mostrará algunos conceptos básicos del lenguaje. Para empezar, copia o escribe el siguiente código en un editor de texto como nano o Visual Studio Code. Guarda el archivo con un nombre como "primer_programa.py".

Para ejecutar el programa, abre una consola o terminal, navega hasta el directorio donde guardaste el archivo, y escribe:

.. code-block:: bash

   python3 primer_programa.py

Ahora, veamos el código paso a paso:

.. sourcecode:: python

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   
   print('Este es un primer programa en Python')
   
   a = 10
   b = 20.0
   
   # Este es un comentario
   print('Este es un número entero:', a)
   print('Este es un número flotante:', b)
   
   a = complex(10, 3)
   print('Este es un número complejo:', a)

Explicación del código:

1. La primera línea es un "shebang" que indica al sistema que use Python 3 para ejecutar este script.
2. La segunda línea especifica la codificación del archivo (UTF-8).
3. Usamos la función `print()` para mostrar un mensaje en la consola.
4. Creamos variables `a` (entero) y `b` (flotante) y les asignamos valores.
5. Mostramos los valores de `a` y `b` usando `print()`.
6. Creamos un número complejo usando la función `complex()` y lo asignamos a `a`.
7. Finalmente, mostramos el valor del número complejo.

Este programa te introduce a conceptos como variables, tipos de datos (enteros, flotantes y complejos) y la función `print()` para mostrar información en la consola.

Ejecución del programa en Linux
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Además de ejecutar el programa con el comando `python3`, también puedes darle permisos de ejecución al archivo y ejecutarlo directamente. Sigue estos pasos:

1. Abre una terminal y navega hasta el directorio donde guardaste el archivo.

2. Dale permisos de ejecución al archivo con el siguiente comando:

   .. code-block:: bash

      chmod +x primer_programa.py

3. Ahora puedes ejecutar el programa directamente escribiendo:

   .. code-block:: bash

      ./primer_programa.py

Recuerda que para que esto funcione, la primera línea del archivo (el shebang) debe ser correcta y apuntar a la ubicación de Python en tu sistema. En la mayoría de los casos, `#!/usr/bin/env python3` funcionará correctamente.

Esta forma de ejecución es útil cuando quieres tratar tu script de Python como un ejecutable independiente, lo cual es común en entornos Unix/Linux.

Imprimiendo resultados hacia la pantalla
----------------------------------------

Python ofrece varias formas de formatear strings para imprimir resultados. Veamos algunas de ellas:

.. sourcecode:: python

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   
   q = 305
   j = 8
   k = 20
   
   # Método tradicional
   print('q, j, k son', q, j, k)
   
   # Usando el método .format()
   print('q es {}, j es {}, y k es {}'.format(q, j, k))
   print('j={1}, q={0}, y k={2}'.format(q, j, k))
   
   # Usando f-strings (disponible desde Python 3.6+)
   print(f'q es {q}, j es {j}, y k es {k}')

Los f-strings son una forma más concisa y legible de formatear strings en Python 3.6+. Permiten incluir expresiones directamente dentro de las llaves.

Ahora, veamos cómo formatear números con diferentes anchuras y precisiones:

.. sourcecode:: python

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   
   a = 9
   
   # Usando .format()
   print("{:1d}".format(a))   # Ancho mínimo de 1 dígito
   print("{:01d}".format(a))  # Ancho mínimo de 1 dígito, rellena con 0
   print("{:2d}".format(a))   # Ancho mínimo de 2 dígitos
   print("{:02d}".format(a))  # Ancho mínimo de 2 dígitos, rellena con 0
   print("{:3d}".format(a))   # Ancho mínimo de 3 dígitos
   print("{:03d}".format(a))  # Ancho mínimo de 3 dígitos, rellena con 0
   
   # Usando f-strings
   print(f"{a:1d}")
   print(f"{a:01d}")
   print(f"{a:2d}")
   print(f"{a:02d}")
   print(f"{a:3d}")
   print(f"{a:03d}")

Para números de punto flotante, podemos especificar la precisión en la impresión, sin alterar el valor almacenado en la variable:

.. sourcecode:: python

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   
   import math
   
   # El valor de math.pi se mantiene con toda su precisión en la variable
   print(f"Valor completo de pi: {math.pi}")
   
   # Solo se modifica la presentación al imprimir, no el valor almacenado
   print(f"Pi con 3 decimales: {math.pi:.3f}")
   print(f"Pi en notación científica: {math.pi:.3e}")
   
   # Diferentes anchos de campo, manteniendo 3 decimales
   print(f"{math.pi:5.3f}")
   print(f"{math.pi:6.3f}")
   print(f"{math.pi:7.3f}")
   print(f"{math.pi:8.3f}")
   print(f"{math.pi:9.3f}")

   # La variable math.pi sigue conteniendo el valor completo
   print(f"Valor de pi sin cambios: {math.pi}")

Es importante notar que estas operaciones de formateo solo afectan a cómo se muestra el número cuando se imprime. El valor real almacenado en la variable (en este caso, `math.pi`) permanece inalterado y mantiene toda su precisión original.

Recibiendo información desde el teclado
---------------------------------------

Antes de continuar, es importante entender qué es un string en Python:

Un string (o cadena de caracteres) es una secuencia inmutable de caracteres. En Python, los strings se pueden definir usando comillas simples ('') o dobles (""). Los strings son utilizados para representar texto y pueden contener letras, números, símbolos y espacios.

Ejemplos de strings:
- 'Hola, mundo!'
- "Python 3"
- '12345'
- "¡Los strings pueden contener símbolos y números!"

En Python 3, `input()` siempre devuelve un string, independientemente de lo que el usuario ingrese. Esto significa que si necesitamos trabajar con otros tipos de datos (como números), debemos convertir explícitamente el string a esos tipos. Veamos algunos ejemplos:

.. sourcecode:: python

   #!/usr/bin/env python3
   # -*- coding: utf-8 -*-
   
   # input() siempre devuelve un string
   nombre = input("Ingrese su nombre: ")
   print(f"Hola, {nombre}!")  # nombre es un string, no necesita conversión
   
   # Para trabajar con números, necesitamos convertir el string
   edad_str = input("Ingrese su edad: ")
   edad = int(edad_str)  # Convierte el string a un entero
   print(f"El año que viene tendrás {edad + 1} años.")
   
   altura_str = input("Ingrese su altura en metros: ")
   altura = float(altura_str)  # Convierte el string a un float
   print(f"Tu altura en centímetros es {altura * 100:.1f} cm.")

   # Podemos hacer operaciones con strings
   apellido = input("Ingrese su apellido: ")
   nombre_completo = nombre + " " + apellido  # Concatenación de strings
   print(f"Su nombre completo es: {nombre_completo}")
   print(f"Su nombre completo en mayúsculas es: {nombre_completo.upper()}")

   # Los strings son secuencias, podemos acceder a sus caracteres
   primera_letra = nombre[0]
   print(f"La primera letra de su nombre es: {primera_letra}")

Recuerda que los strings tienen muchas operaciones y métodos útiles, como `upper()`, `lower()`, `strip()`, `split()`, entre otros, que nos permiten manipular el texto de diversas formas.

Los strings como secuencias
^^^^^^^^^^^^^^^^^^^^^^^^^^^

Los strings en Python son secuencias de caracteres, lo que significa que podemos acceder a caracteres individuales o a sub-strings utilizando índices y slicing. Veamos algunos ejemplos:

.. sourcecode:: python

   # Creamos un string de ejemplo
   frase = "Python es genial"

   # Acceder a caracteres individuales
   print(f"El primer carácter es: {frase[0]}")
   print(f"El último carácter es: {frase[-1]}")

   # Slicing: obtener sub-strings
   print(f"Los primeros 6 caracteres: {frase[:6]}")
   print(f"Los últimos 6 caracteres: {frase[-6:]}")
   print(f"Caracteres del 7 al 9: {frase[7:10]}")

   # Paso en el slicing
   print(f"Caracteres alternos: {frase[::2]}")
   
   # Imprimir el string al revés
   print(f"La frase al revés: {frase[::-1]}")

   # Longitud del string
   print(f"La frase tiene {len(frase)} caracteres")

   # Buscar sub-strings
   print(f"'es' aparece en la posición: {frase.index('es')}")

   # Contar ocurrencias
   print(f"La letra 'n' aparece {frase.count('n')} veces")

   # Dividir el string
   palabras = frase.split()
   print(f"Palabras en la frase: {palabras}")

   # Unir strings
   nueva_frase = " ".join(palabras)
   print(f"Frase reconstruida: {nueva_frase}")

Explicación de los ejemplos:

1. Usamos índices para acceder a caracteres individuales. Los índices comienzan en 0 y también pueden ser negativos para contar desde el final.

2. El slicing `[inicio:fin:paso]` nos permite obtener sub-strings. Si se omite el inicio o el fin, se asume el principio o el final del string respectivamente.

3. Usar `[::-1]` invierte el string, útil para imprimir palabras o frases al revés.

4. La función `len()` devuelve la longitud del string.

5. Podemos iterar sobre un string como si fuera una secuencia de caracteres.

6. Métodos como `index()` y `count()` nos permiten buscar y contar sub-strings.

7. `split()` divide el string en una lista de sub-strings, mientras que `join()` une una lista de strings en un solo string.

Estos ejemplos muestran la versatilidad de los strings en Python y cómo podemos manipularlos de diversas formas aprovechando su naturaleza de secuencia.


Ejercicios
----------

1. Haga un programa que pregunte un número e imprima su seno y coseno con 5 cifras significativas.

2. Haga un programa que pregunte la parte real e imaginaria de un número complejo, e imprima el cuadrado de su módulo.

3. Haga un programa que pregunte 5 números e imprima una tabla con estos valores y sus cuadrados.

4. Usando input, haga un programa que pregunte un número e imprima su raíz cuadrada.

5. Haga un programa que pregunte una palabra e imprima ésta al revés.

6. Haga un programa que pregunte una palabra y que la imprima en mayúsculas.

7. Haga un programa que pregunte un número binario de 4 dígitos, e imprima su valor en decimal.

Nota: Para resolver estos ejercicios, recuerde utilizar las técnicas de formateo de strings aprendidas, como f-strings, para presentar los resultados de manera clara y legible.