python_data_science.py

# -*- coding: utf-8 -*-
"""python_data_science.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/gist/Matkloss/3c245b9a1e7cf570cce74a1615bc4b5e/python_data_science.ipynb

# Python para Data Science

Notebook para el curso de Python para Data Science publicado en la plataforma de [Alura Latam](https://www.aluracursos.com/)

# Introducción a Python
¡Vamos a conocer Python, nuestro ambiente de estudio, y también generaremos nuestro primer código en este lenguaje!

## Google Colaboratory

Ya aprendimos qué es [Python](https://www.python.org/) y ahora aprenderemos a usar nuestra herramienta de ejecución [Google Colaboratory](https://colab.research.google.com/) para programar en un notebook interactivo.

Vamos a probar algunas funciones de este ambiente.

**`>>> Usa esta celda para mover <<<`**
"""



"""## ¡Hola mundo!

Vamos a conocer un poco más de cerca nuestro notebook. Para ello ejecutaremos nuestro primer comando en Python: [`print()`](https://docs.python.org/3/library/functions.html#print)
"""

print('¡Hola Mundo!');

15

print("Matias");
print("Rodolfo");

print(' M\n',"A\n","T"'\n',"I"'\n',"A"'\n',"S"'\n');

print("04 enero 1989");

print("2025");

"""# Manipulando los datos

Vamos a aprender sobre las variables en Python, cómo declararlas y utilizarlas además de conocer otros comandos de este lenguaje. :D

## Variables

En Data Science trabajamos con varios tipos de datos e informaciones, entonces es esencial saber cómo trabajar con las variables.

Las variables en Python se crean cuando atribuimos un valor a ella.

Para esto, colocamos el nombre de la variable, el signo de igual (`=`) y el valor que queremos atribuirle.
"""

5

id(5)

edad = 5

print(id(edad));
print(id(5));

numerocinco = 5;

id(numerocinco);

nombre = 'Gabriel';

id(nombre)

id('Gabriel')



"""Existen algunos tipos de nomes que **no** podemos definir para las variables:

- **Nombres que comiencen con números**
  - Ejemplos: `10_notas`, `2_nombre_casa`, etc.
- **Palabras separadas por espacio**
  - Ejemplos: `Nombre escuela`, `notas estudiantes`, etc.
- **Nombres de funciones de Python**
  - Ejemplos: `print`, `type`, etc.

> Las letras mayúsculas y minúsculas generarán diferentes variables. La variable `edad` es diferente de `Edad` que a su vez es diferente de `EDAD`:
``` Python
edad = 1
Edad = 2
EDAD = 3
_edad = 4
_edad_ = 5
print(edad, Edad, EDAD, _edad, _edad_)
1 2 3 4 5
```

## Tipos de variables

Cada variable contiene una clase específica con respecto al tipo de objeto al cual esta hace referencia. Estas clases serán diferentes de acuerdo con el tipo de dato que le sea atribuido a una variable.

Para conocer la clase de cada elemento usamos la función [`type()`](https://docs.python.org/3/library/functions.html#type)
"""







"""En un conjunto de datos escolares podemos tener varios tipos de informaciones. Supongamos que tenemos acceso a la ficha de datos del alumno *Penélope Camacho*, cómo transformamos este nombre en variables de Python?

#### Ficha:

- Nombre: Penélope Camacho
- Edad: 11 años
- Promedio del semestre: 9,75
- Situación de aprobación: Verdadera (aprobado)
"""





"""## Variables numéricas

Entre los tipos de datos numéricos vamos a enfocarnos en los tipos `entero` y `float`.

Tenemos una tabla de información sobre los diversos cargos, cantidad de personas empleadas y el salario correspondiente:

|Cargo | Cantidad | Salario|
|---|---|---|
|Vigilante | 5 | 300 |
|Docente | 16| 500|
|Coordinador| 2 |600|

Necesitamos trabajar con estos datos para obtener:

- La cantidad total de empleados;
- La diferencia entre el salario más bajo y más alto; y
- El promedio ponderado de los salarios de los empleados de la escuela.
"""







"""## Strings

Strings hace referencia a un conjunto de caracteres formando un texto.

Podemos crear Strings cuando atribuimos un dato a una variable entre comillas sencillas (`'`) o comillas dobles (`"`).
"""



"""Las variables textuales son objetos que poseen métodos que nos ayudan a formatear strings. Los métodos los podemos ejecutar al definir un objeto de acuerdo con la siguiente estructura:

```
objeto.metodo()
```

Existen métodos que no necesitan los `()`, siempre es una buena práctica verificar la documentación para cada caso.

---
**Situación:**

Recibimos una variable con el nombre de una profesora de la escuela para añadirla a los registros. Sin embargo, necesitamos darle un tratamiento a este texto antes de insertarlo al sistema.
"""

texto = '  Micaela de los Sanyos '

"""El objetivo final es que el nombre aparezca de la siguiente forma:

```
'MICAELA DE LOS SANTOS'
```

### [`str.upper()` ](https://docs.python.org/3/library/stdtypes.html#str.upper)
Convierte una string a mayúsculas.
"""



"""### [`str.lower()`](https://docs.python.org/3/library/stdtypes.html#str.lower)
Convierte una string a minúsculas.
"""



"""### [`str.strip()`](https://docs.python.org/3/library/stdtypes.html#str.strip)
Elimina los espacios en blanco al inicio y al final de una string.
"""



"""### [`str.replace(antiguo, nuevo)`](https://docs.python.org/3/library/stdtypes.html#str.replace)

Sustituye todas las ocurrencias del texto "antiguo" en la string por el  "nuevo".
"""



"""### Observaciones

1. Los métodos devuelven una **tranformación**, no son ejecutados directamente sobre la variable donde está almacenado el texto.

2. Adicionalmente, podemos acumular la ejecución de los métodos.
"""



"""Para que la transformación se pueda ejecutar debemos atribuir la salida de las transformaciones a las variables"""





"""## Capturando datos

En algunas aplicaciones necesitamos capturar los valores del usuario de nuestro proyecto. En python, logramos capturar los datos del usuario a través del comando [`input()`](https://docs.python.org/3/library/functions.html#input).

Para ejecutar la captura debemos atribuir el resultado de esta función a una variable.
"""





"""La salida de este comando siempre será una *string*. Esto quiere decir que aunque capturemos un valor de variable numérica, este será de tipo string.

Entonces, será necesario **convertir el resultado cuando no se desea utilizar el valor como tipo string**.

Existen funciones para la conversión de valores:

- Enteros: [`int(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#int)
- Coma flotante: [`float(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#float)
- String: [`str(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#func-str)
- Booleano: [`bool(dato_para_conversion)`](https://docs.python.org/3/library/functions.html#bool)
"""







"""Trataremos de representar mejor ahora el resultado de la transformación que obtuvimos. Nosotros podemos formatear y presentar nuestro resultado mezclando strings con valores no textuales.

Para ello utilizamos la estructura de formatación `f` con strings.
"""



"""# Estructuras condicionales"""





"""## `IF` y `ELSE`

Los comandos `if` y `else` son dos estructuras condicionales. El comando `if` ejecutará el bloque de comandos en caso de que la condición citada sea  **verdadera**. El comando `else` ejecutará el bloque de comandos en el caso de que la condicional de `if` sea **falsa**.

El comando `if` es una palabra clave en Python que significa "si". Este se emplea para conformar la estructura condicional, que te permite verificar si una determinada condición es verdadera o falsa e, inmediatamente después, ejecute un bloque de código específico dependiendo del resultado de la verificación. La sintaxis para usar el comando `if` es:



```
if condicion:
    # Realiza algo
```
"""





"""Ya el comando `else` en Python se usa en junción con la palabra clave `if` para formar una estructura condicional. la sintaxis para usar el `else` es:

```
if condicion:
  # codigo en caso de que sea verdad
else:
  # codigo en caso de que sea falso
```

el comando `else` se ejecuta cuando la condición verificada por el `if` es evaluada como `False`.
"""





"""---
**Situación:**

Recibiremos el promedio de la nota de los estudiantes y necesitamos de un algoritmo que ejecute el análisis y determine si el estudiante fue **Aprobado** o **Reprobado**, mostrando un mensaje del resultado. Para ser aprobado, el promedio necesita ser igual o superior a 7.0.
"""





"""Ahora, nuestra institución educativa estableció que las personas que tengan el promedio entre 5.0 y 7.0 pueden participar del curso de **Recuperación** durante las vacaciones para lograr aprobar.

Entonces podemos apoyarnos en un conjunto de `if`s para poder estructurar esta nueva condición.
"""





"""Observa que en casos con 3 situaciones como este necesitamos definir bien nuestras condiciones. Pues, si realizamos una condición con `else` al final, este irá a considerar solamente la condición `if` inmediatamente anterior para generar la salida en caso de que el resultado de su operación lógica sea **falso** dando como resultado, dos o más ejecuciones.

Por ejemplo:
"""





"""## `ELIF`

El comando `elif` es una palabra clave en Python que significa "si no, si" y lo podemos considerar una *contracción* entre `else` e `if`. Se utiliza en conjunto con la palabra clave `if` para formar una estructura condicional en cadena.

la sintaxis para utilizar el comando `elif` es:

```
if condicion1:
    # Realiza algo
elif condicion2:
    # Realiza otra cosa
elif condicion3:
    # Realiza otra cosa
else:
    # Realiza algo diferente
```

El comando `elif` permite que puedas verificar varias condiciones en cadena, economizando espacio en tu código. Si la primera condición se evalúa como `False`, el interpretador de Python evaluará la próxima condición con el `elif`. Ello continuará hasta que una condición sea evaluada como `True` o hasta que el `else` sea alcazado. Si ninguna de las condiciones es evaluada como `True`, la ejecución del código del comando `else` será iniciada.

Vamos a emplear el mismo caso anterior:
"""





"""## Operadores

Durante la construcción de comandos a veces necesitamos de una elaboración mayor de la expresión condicional, necesitando que algunos operadores lógicos se encuentren integrados.

### `AND`, `OR`, `NOT`

Los operadores lógicos `and`, `or` y `not` son usados para combinar expresiones lógicas en Python. Ellos son usados frecuentemente en conjunto con el comando `if` para crear estructuras condicionales más complejas.

- `AND` es usado para verificar si dos condiciones son verdaderas. La expresión lógica¹ `x and y` se evalúa como `True` tan solo si **ambas condiciones `x` y `y` son verdaderas**, y como `False` en caso contrario.

- `OR` es usado para verificar si al menos una de las condiciones es verdadera. La expresión lógica `x or y` se evalúa como `True` **si al menos una de las condiciones `x` o `y` es verdadera**, y como `False` si ambas condiciones son falsas.

- `NOT` es usado para **negar una condición**. La expresión lógica `not x` es evaluada como `True` si la condición x es falsa, y como `False` si la condición x es verdadera.

¹ Una expresión lógica es una declaración que puede ser evaluada como verdadera o falsa. Ella se compone por operandos lógicos² y por operadores lógicos³, que son usados ​​para combinar varias expresiones lógicas en una única expresión.

² Los operandos lógicos son los elementos que son comparados o evaluados en una expresión lógica. Ellos son generalmente valores verdaderos o falsos, pero también pueden ser expresiones lógicas más complejas. En Python, los operandos lógicos son los valores `True` y `False`.

³ Los operadores lógicos son ls símbolos o palabras clave que son usados ​​para combinar varias expresiones lógicas en una única expresión. En Python, los operadores lógicos son `and`, `or` y `not`, bien como las palabras clave `if`, `elif` e `else`.

> Operadores lógicos más comunes

|a|b|AND|OR|NOT|
|-|-|-|-|-|
|0|0|0|0|1
|0|1|0|1|-
|1|0|0|1|-
|1|1|1|1|0
"""







"""### `IN`

Es usado para verificar si un elemento está presente en una lista, tupla u otra colección de conjunto. La expresión `x in y` se evalúa como `True` si el elemento `x` esta presente na variávelen la variable de conjunto `y`, y como `False` en caso contrario.

Podemos verificarlo con variables de texto.

---

**Situación:**

En la escuela nos entregaron una lista con nombres de estudiantes que fueron aprobados según el promedio del semestre, pero es necesario verificar si algunos nombres están en esa lista para confirmar que los datos estén correctos.

La lista distribuida puede ser observada a continuación:

```
lista = 'Juan Pérez, María González, Pedro Rodríguez, Ana López, Carlos Martínez,
    Laura Sánchez, José García, Elena Fernández, Luis Morales, Carmen Torres,
    David Ruiz, Isabel Ramírez, Javier Díaz, Sara Herrera, Miguel Castro,
    Patricia Ortega, Francisco Vargas, Marta Jiménez, Manuel Medina, Rosa Molina,
    Alejandro Silva, Silvia Ruiz, Andrés Torres, Natalia Soto, Diego Guerrero,
    Paula Ríos, Ricardo Navarro, Alicia Cordero, Carlos Vidal, Lorena Gómez'
```

Los nombres que necesitas verificar son los siguientes:

```
nombre_1 = 'Miguel Castro'
nombre_2 = 'Marcelo Noguera'
```
"""







"""# Estructuras de repetición

Cuando tenemos que ejecutar un mismo bloque de comandos durante varias ocasiones no es nada práctico hacerlo a mano.

**Situación**: Nos fue solicitado obtener e imprimir el promedio de 2 notas de **3 estudantes**:
"""







"""Ahora imaginemos una situación en que no son tan solo 3 estudiantes, sino 100 estudiantes. No sería nada interesante repetir el mismo código 100 veces, sino **ejecutar el mismo código 100 veces**.

¡Esta estructura la logramos construir con lazos de repetición!

## `WHILE`

El lazo `while` es una estructura de control de repetición en Python que permite ejecutar un bloque de código repetidamente mientras que una determinada condición sea verdadera. Su estructura es:



```
while condicion:
    # bloque de codigo
```

Vamos a construir un ejemplo con un contador de 1 hasta 10.
"""





"""Ahora vamos a colectar las notas y promedios de cada alumno dentro del lazo `while`. Haremos un ejemplo con 3 promedios."""





"""## `FOR`

El lazo `for` es un tipo de estructura de control de flujo en Python que permite iterar sobre un conjunto de elementos. Su estructura es:



```
for elemento in conjunto:
    # codigo a ser ejecutado para cada elemento
```

El lazo `for` itera sobre cada elemento del conjunto especificado y ejecuta el bloque de código dentro del lazo para cada elemento. Cuando el lazo llega al final del conjunto, este se interrumpe y el programa continúa la ejecución después del lazo.

El conjunto lo podemos generar con la función incorporada [`range()`](https://docs.python.org/3/library/functions.html#func-range). Se trata de una función capaz de generar una secuencia de números enteros. La estructura de esta función es:

```
range(inicio, fin, paso)
```

Según la documentación, `range()` genera una secuencia de números enteros a partir del valor del parámetro `inicio` hasta el valor del parámetro `fin`, de acuerdo con el valor del parámetro `paso`. Si `inicio` no es especificado, el valor por defecto es `0`. Si `paso` no es especificado, el valor por defecto es `1`.

Vamos a recrear el mismo contador `while` con el lazo `for`.
"""





"""# Estructuras de datos

Un conjunto de elementos es una colección de items, que son almacenados juntos de manera organizada. Algunos ejemplos de conjuntos de elementos en Python son las listas, los strings y los diccionarios.

## Listas

Las listas pueden almacenar una colección de items en orden. Ellas son delimitadas por corchetes `[]` y sus elementos son separados por comas.

Estas pueden almacenar cualquier tipo de items, incluyendo números, strings, objetos, otras listas, entre otros. También nos permiten almacenar items de tipos de datos diferentes juntos en una única lista.
"""

lista = ['Penélope Camacho',9.5,9.0,9.7,True]
lista



"""Las listas son organizadas en Python porque **cada elemento de la lista tiene un índice que indica su posición al interior de la lista**. Los índices comienzan en 0 van hasta el tamaño de la lista menos 1.

Tenemos entonces 5 elementos con índices que varían de 0 a 4, ordenadamente:

```
#             [0]           [1]   [2]   [3]    [4]
lista = ['Penélope Camacho', 9.5 , 9.0 , 9.7 , True]
```

En Python tenemos también los índices **negativos** que se inician en el último elemento con el valor de `-1` y avanzan en el universo de los negativos hasta llegar al 1° elemento:

```
#             [-5]         [-4]  [-3]  [-2]   [-1]
lista = ['Penélope Camacho', 9.5 , 9.0 , 9.7 , True]
```

Logramos seleccionar separadamente cada elemento a través de sus respectivos índices. Colocando el nombre de la lista y en seguida el índice que será seleccionado.
"""





"""Una forma más dinámica de trabajar item a item en una lista es utilizando un lazo `for` para leer un elemento a la vez."""



"""**Situación**: La nota `9.0` de Penélope necesita ser ajustada pues ganó 1 punto en su última nota por participación en clase. Entonces es necesario realizar un cambio en el índice `2` de `9.0` a `10.0`."""





"""También podemos calcular el promedio del estudiante a partir de los datos que tenemos."""



"""## Manipulación de listas

Las listas son muy útiles en Python porque nos permiten almacenar y acceder a una colección de items de manera organizada y rápida. Estas también ofrecen muchos métodos útiles para manipular los itens almacenados, como adicionar, remover, clasificar y buscar elementos.

#### Cantidad de elementos

Usamos la función [`len()`](https://docs.python.org/3/library/functions.html#len) para descubrir la cantidad de elementos de un conjunto.
"""



"""#### Partición

La partición de listas por indexación en Python es una técnica muy útil para seleccionar un subconjunto de elementos de una lista. Esta se realiza usando la sintaxis `lista[inicio:fin]`, donde `inicio` es el índice del primer elemento que será incluído en la partición `fin` es el índice del primer elemento que será excluído de la partición.
"""





"""#### [`append()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=of%20list%20objects%3A-,list.append(x),-Add%20an%20item)

Añade un elemento al final de la lista.
"""





"""#### [`extend()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=list.extend(iterable))

Añade varios elementos al final de la lista.

Añadiremos las notas `[10.0,8.0,9.0]` En la lista de Penélope Camacho.
"""





"""*A continuación te mostraremos lo que no puede realizarse con* `append`."""





"""#### [`remove()`](https://docs.python.org/3/tutorial/datastructures.html#:~:text=append(x).-,list.remove(x),-Remove%20the%20first)

Remueve un elemento específico de la lista.
"""





"""## Diccionario

Los diccionarios son un tipo de estructura de datos que almacenan pares de *llave-valor*. Estos son delimitados por llaves `{}` y los pares *llave-valor* son separados por comas.

```
diccionario = {llave: valor}
```

La **llave** es un elemento único que identifica a un valor en el diccionario, mientras que el **valor** es el item que será almacenado para la llave. Las llaves y sus respectivos valores se pueden emplear para **cualquier tipo de dato**.

Los diccionarios son útiles para almacenar y acceder a los datos de manera organizada y rápida. Se trata de un tipo de conjunto de elementos en Python, pues almacenan una colección de items.
"""





"""---
**Situación:**

Vamos a crear un conjunto de datos con las informaciones de matrícula de un estudiante. Los datos son los siguientes:

- matrícula: 2000168933
- día de registro: 25
- mes de registro: 10
- grupo: 2E
"""





"""Es posible sustituir los valores dentro de una llave. Por ejemplo, recibimos la información de que el grupo del estudiante que registramos cambio a `'2G'` y ahora necesitamos cambiar el valor de la llave `'grupo'`."""





"""También podemos añadir otros datos al diccionario. Vamos a añadir la información sobre la modalidad de estudio, nuestro estudiante estudiará inicialemente en la modalidad EAD.

Definiremos una llave llamada `'modalidad'` con el valor `'EAD'`.
"""





"""## Profundizando en diccionarios

#### [`pop()`](https://python-reference.readthedocs.io/en/latest/docs/dict/pop.html)
Remueve un item de un diccionario y lo representa en la salida.
"""





"""#### [`items()`](https://python-reference.readthedocs.io/en/latest/docs/dict/items.html)
Retorna una lista de pares `llave-valor` del diccionario.
"""



"""#### [`keys()`](https://python-reference.readthedocs.io/en/latest/docs/dict/keys.html)
Retorna una lista de las llaves del diccionario.
"""



"""#### [`values()`](https://python-reference.readthedocs.io/en/latest/docs/dict/values.html)
Retorna una lista de los valores del diccionario.
"""



"""### Lectura de valores con el lazo `for`"""