Python – anotaciones de los ejercicios

Con el = le asigno el valor

Ejemplo  Base = 20

En Python las celdas se ejecutan en orden, por lo que si cambio un dato, el valor que se toma es
el último que se toma

Muy importante la ortografía, si yo escribo Base, no puedo poner base para buscarlo ( ya que lo
denominamos con B y no con b)

Para mostrar los resultados se puede poner

- perímetro, área
- Print(perímetro) … Print(área)

Variables y tipos básicos

edad = 34 # int (entero)

tasa = 0.035 # float (decimal)

nombre = "Ana" # str (cadena de texto)

activo = True # bool (booleano) ósea sirve para poner verdadero o falso. Use condicional
para poner activo. es Activo si es true e inactivo si es false

Ejemplo

Frase = (f"Hola {nombre}, tu edad es {edad} años y estado = { "Activo" if activo else
"inactivo"}")
print(Frase)

F-sting sirve para poder poner variables definidas dentro de un string. Esto se hace poniendo
una "f" dentro del string y luego en entre llaves la variable que se quiere poner.

Casting y operadores

Casting= es la conversión de tipos

x = "42"
# x + 8
int(x) + 8
int(x) es para convertir ‘x’ en un entero, ya que es un string

Operadores de comparación y lógicos

 != es diferente
 == es igual
 < es menor
 > es mayor
 <= es menor o igual
 >= es mayor o igual

Ejemplo
n = 19 # cambiá este valor
es_par = (n % 2 == 0)
f"¿{n} es par? {es_par}"
Resultado= ¿19 es par? False

El operador % devuelve el resto de la división entre n y 2. Si el resto es 0, entonces n es par.

String y f-strings

Ejemplo

S = “Actuaria y Python”

[Link](),  Nos pone todo en minúscula  ‘actuaria y python’

[Link](),  Nos pone todo en mayúscula  ‘ACTUARIA Y PYTHON’
[Link]("Python", "Datos"), remplazo Python por Datos ‘Actuaria y Datos
len(s) es una función que cuenta la cantidad de caracteres que tiene el string s ya que
es una palabra y no un numero o lista.  17

capitalize() pone la primera letra en mayuscula y split() separa las palabras por espacio.

Join() une las palabras con espacio

[Link]() separa las palabras por espacio

Cliente = "lucila capuñay reato"

Cliente = " ".join([[Link]() for p in [Link]()])
Cliente
año_actual= 2025
año_nacimiento = 2004
años=año_actual - año_nacimiento
print(f"la señorita {Cliente} tiene {años} años")

Resultado: ‘la señorita Lucila Capuñay Reato tiene 21 años

Estructuras nativas: List, Tuple, dict, set

- list es una estructura de datos que permite almacenar varios valores en una sola variable.
Se define con corchetes [] y los valores se separan por comas. Las listas son mutables, es
decir, se pueden modificar después de su creación. Permiten duplicados y mantienen el
orden de los elementos.
o (el nombre).append ()  agrega un elemento al final
o (el nombre). Sort  ordena la lista
- tupla es una estructura de datos similar a la lista, pero a diferencia de esta, las tuplas son
inmutables, es decir, no se pueden modificar después de su creación. Se definen con
paréntesis () y los valores se separan por comas. Las tuplas permiten duplicados y
mantienen el orden de los elementos.
- diccionario es una estructura de datos que almacena pares de clave-valor. Se define con
llaves {} y los pares se separan por comas. Las claves deben ser únicas e inmutables
(como strings o números), mientras que los valores pueden ser de cualquier tipo. Los
diccionarios son mutables, es decir, se pueden modificar después de su creación.
o keys() devuelve las claves del diccionario y values() devuelve los valores del
diccionario.
 o list() convierte las claves y valores en listas
o list([Link]() #list convierte las claves del diccionario en una lista
- Un set es una estructura de datos que almacena una colección de elementos únicos y
desordenados. Se define con llaves {} o con la función set(). Los sets no permiten
duplicados, es decir, si se intenta agregar un elemento que ya existe en el set, no se
producirá ningún cambio. Los sets son mutables, es decir, se pueden modificar después de
su creación.
o Lo podemos usar para eliminar duplicados

Cuando hay números, podemos usar Len) para contar la cantidad de elementos que tiene la lista

Data frame

Pandas

import pandas as pd #pd es el alias que se usa comúnmente para pandas

data = { #data es un diccionario
"Asegurado": ["Juan", "Ana", "Pedro", "Laura"], #lista de asegurados, eso se hace
poniendo entre corchetes []
"Edad": [34, 45, 29, 52],
"Prima": [1200, 1500, 950, 2000],
"Suma_Asegurada": [100000, 120000, 80000, 150000],
}
df = [Link](data) #[Link] es para crear un dataframe a partir del diccionario
data
[Link]()

[Link]() #info() es para ver la información del dataframe, como la cantidad de filas y columnas, los
tipos de datos, etc.

[Link]()
describe() es para ver estadísticas descriptivas del dataframe, como la media, la desviación
estándar, el mínimo, el máximo, etc. Nos devuelve una tabla con todos esos datos

df = [Link](data)  [Link] es para crear un dataframe a partir del diccionario data

para que sea con 2 decimales se pone :.2f  prom_prima: .2f

Clase 2 parte 1
Python es una programación orientada al objeto, no importa el valor real, sino el objeto. Si le
cambiamos el monto, sigue funcionando la función

Clases, atributos y métodos (POO)

Class  es una palabra reservada en python para definir una clase

Atributos datos que describen al objeto (estado)

métodos Funciones definidas dentro de la clase que describen. Método es una función dentro
de una clase. solo se puede usar en contexto de una clase comportamientos

--init--  es el constructor: se ejecuta al crear el objeto y sirve para inicializar atributos. Con esto
iniciamos

def  sirve para definir una función en python

Flota tota  la FLOTA_TOTAL es un atributo de clase, porque es compartido por todas las
instancias de la clase Auto. Se usa para llevar un conteo del total de autos creados (en este caso)

[Link], [Link], [Link] son atributos de instancia, porque son específicos para cada
instancia (objeto) de la clase Auto.
self  es una referencia a la instancia actual de la clase. Se usa para acceder a los atributos y
métodos de la clase dentro de sus propios métodos. Se usa después de –init—

- self es una referencia a la instancia actual de la clase. Se usa para acceder a los atributos
y métodos de la clase dentro de sus propios métodos.
- self va a ser abarcativo y nos permite trabajar en la clase de manera más fácil, super
usado.

def descripcion(self) es un método de instancia. sirve para describir el auto (en este caso)

def arrancar(self): #def arrancar(self): es un metodo de instancia.

@classmethod  classmethod es un decorador que indica que el siguiente metodo es un metodo

de clase. Metodo que recibe CLS (la clase) en vez de self

def cantidad_en_flota(cls):  def cantidad_en_flota(cls): es un metodo de clase. cls es una

referencia a la clase en sí misma, similar a self pero para métodos de clase.

@staticmethod staticmethod es un decorador que indica que el siguiente metodo es un metodo

estático. Metodo utilitario que no depende de self ni cls

def es_antiguo(anio): def es_antiguo(año): es un metodo estático. no recibe self ni CLS como
primer argumento, ya que no depende de la instancia ni de la clase.

def resumen(self):  resumen es un metodo de instancia que se usa para mostrar un resumen
de la póliza

ejemplo

def resumen(self):
return póliza de {[Link]} | edad={[Link]} | prima={[Link]}"

p1 = poliza ("Juan", 45, 1500)

p2 = Poliza ("Ana", 38, 1200)
[Link](), [Link]()
el resultado es (póliza de juan | edad=45 | prima=1500, póliza de Ana | edad=38 | prima=1200)

return es una palabra reservada en python para devolver un valor de una función

class Auto: #class es una palabra reservada en python para definir una clase
flota_total = 0 # atributo de clase (compartido)

def __init__(self, color, marca, año): #aca se inicializan los atributos de la clase
[Link] = color # atributo de instancia
[Link] = marca # atributo de instancia
[Link] = año # atributo de instancia
Auto.flota_total += 1

def descripcion(self): #def descripcion(self): es un metodo de instancia. def es

una palabra reservada en python para definir una función
return f"{[Link]} {[Link]} ({[Link]})"

def arrancar(self):
return f"{[Link]()} está arrancando"

@classmethod
def cantidad_en_flota(CLS): #def cantidad_en_flota(CLS): es un metodo de clase. CLS es
una referencia a la clase en sí misma, similar a self pero para métodos de clase.
return cls.flota_total

@staticmethod
def es_antiguo(año):
return año < 2000

mi_auto = Auto("rojo", "Toyota", 2020)

otro_auto = Auto("azul", "Ford", 2015) #CADA VEZ QUE TENGA UN NUEVO AUTO, SE VA A
INCREMENTAR EN 1 LA FLOTA TOTAL
print(Auto.flota_total)

mi_auto.arrancar(), Auto.cantidad_en_flota(), Auto.es_antiguo(1999)

mi_auto.descripcion()

Numpy provee ndarrayuna estructura eficiente para computación numérica vectorizada

- es una librería para trabajar con arreglos y matrices

- herramientas
o array es un arreglo unidimensional. sirve para almacenar datos de manera eficiente
o mat es una matriz bidimensional. sirve para almacenar datos en dos dimensiones

import numpy as np #numpy es una libreria para trabajar con arreglos y matrices

arr = [Link]([10, 20, 30, 40]) #array es un arreglo unidimensional. sirve para almacenar
datos de manera eficiente
mat = [Link]([[1,2,3],[4,5,6]]) #mat es una matriz bidimensional. sirve para almacenar
datos en dos dimensiones
arr, mat, [Link], [Link], [Link]

type(arr) #type es el tipo de dato del objeto. nos dice que tipo de dato es el objeto
[Link] #dtype es el tipo de dato del arreglo. nos dice que tipo de dato tiene el
arreglo
[Link] #shape es la forma del arreglo. nos dice cuantas dimensiones tiene el arreglo
[Link] #shape es la forma de la matriz. nos dice cuantas dimensiones tiene la matriz

- type(arr)  type es el tipo de dato del objeto. nos dice que tipo de dato es el objeto
- [Link]  dtype es el tipo de dato del arreglo. nos dice que tipo de dato tiene el arreglo
- [Link]  shape es la forma del arreglo. nos dice cuantas dimensiones tiene el arreglo.
Tupla de dimensiones
- .ndim  n° de dimensiones

Operaciones vectorizadas y estadísticas rápidas

o arr + 5  le suma 5 a la matriz  array([15, 25, 35, 45]

o arr * 2  multiplica *2 a la matriz  array([20, 40, 60, 80])
o arr ** 2  es el cuadrado de cada elemento del arreglo  array([ 100, 400, 900, 1600]
o [Link]()  es el promedio de los elementos del arreglo  np.float64(25.0)
o [Link]() suma los elementos de la matriz  np.int64(100)
o [Link]() da el mínimo
o [Link]()da el máximo
o [Link]()  es la desviación estándar de los elementos del arreglo

Creación útil. arange, linspace, cero/unos aleatorios

[Link](0, 10, 2), [Link](0, 1, 5), [Link]((2,3)), [Link]((2,3)),

[Link](2,3)
o [Link](inicio, fin, paso)  crea un arreglo con valores desde inicio hasta fin con un
paso determinado. en este caso es de crear una matriz entre 0 y 10 que vaya de 2 en 2
o [Link](inicio, fin, cantidad)  crea un arreglo con una cantidad determinada de
valores igualmente espaciados entre inicio y fin. entre 0 y 1 y lo divide en 5 intervalos
o [Link]((filas, columnas))  crea una matriz de ceros con la cantidad de filas y columnas
especificadas
o [Link]((filas, columnas))  crea una matriz de unos con la cantidad de filas y columnas
especificadas
o [Link](filas, columnas)  crea una matriz con valores aleatorios entre 0 y 1 con
la cantidad de filas y columnas especificadas
o .reshape(), .ravel(), .t(traspuesta)

DataFrame

- Es una tabla (filas x columnas). Cada columna es una serie

Estadísticos y conteos
- [Link](), # cantidad de no nulos por columna
- [Link](numeric_only=True), # suma de valores numéricos por columna.
Numeric_only=True ignora las columnas no numéricas
- [Link](numeric_only=True), # valor mínimo por
 - [Link](numeric_only=True), # valor máximo por columna
- [Link](numeric_only=True), # promedio por columna
- [Link](numeric_only=True), # mediana por columna
- [Link](numeric_only=True), # desviación estándar por columna

# Selección / filtrado / ordenamiento

subset = df[["Asegurado","Prima"]]
filtrado = df[df["Prima"] > 1000]
ordenado = df.sort_values("Prima", ascending=False)
subset, filtrado, [Link](3)

1. selecciona las columnas Asegurado y Prima del dataframe df

2. filtra las filas del dataframe df donde la columna Prima es mayor a 1000
3. ordena el dataframe df por la columna Prima en orden descendente
4. head(3) muestra las primeras 3 filas del datafram
5. .sort_values es un método de pandas para ordenar un dataframe por una columna
determinada

Listado breve de cosas posibles (DataFrame/Series):

- Estructura: `.head()`, `.tail()`, `.shape`, `.columns`, `.dtypes`, `.info()`

- Estadísticos: `.count()`, `.sum()`, `.min()`, `.max()`, `.mean()`, `.median()`, `.std()`,
`.describe()`
- Selección: `df[cols]`, `.loc[fila, col]`, `.iloc[idx]`
- Filtrado: `df[df[col] > x]`, combinaciones con `&`, `|`, `~`
- Ordenar: `.sort_values(col)`, `.sort_index()`
- Crear/Modificar: `df["nueva"] = ...`, `.assign(...)`, `.drop(columns=[...])`
- Agrupar: `.groupby(col).agg({...})`
- Unir/merge: `.merge()`, `.concat()`
- Lectura/Escritura: `pd.read_csv`, `to_csv`, `read_excel`, `to_excel`

Preprocesamiento de data

import pandas as pd
import numpy as np
import [Link] as plt
[Link]['[Link]'] = (8,4)

# Si tu archivo usa otro nombre/ruta, ajustarlo acá:

CSV_PATH = 'insurance_claims.csv' #archivo con datos de que ya esta guardado

# Carga + normalización de marcadores de faltantes

df = pd.read_csv(CSV_PATH, sep= ";") #lee el archivo csv y lo carga en un dataframe de
pandas. sep es el separador de columnas en el archivo csv, definimos con que sumbolo
separar las columnas
df = [Link]('?', [Link])# reemplaza los valores '?' por NaN (valores faltantes) usando
numpy
print('Shape:', [Link]) #shape es una propiedad que devuelve una tupla con las
dimensiones del dataframe (filas, columnas). Es de pandas
[Link](3) #muestra las primeras 3 filas del dataframe

# Tipos de datos y primeras filas

display([Link](10))  vemos las primeras 10 filas del dataframe

display([Link]())  vemos el tipo de dato de cada columna y la cantidad de valores no nulos, el

nombre de la columna y el tipo de dato
- info es un metodo de pandas que muestra información sobre el dataframe
- head es un metodo de pandas que muestra las primeras n filas del dataframe
- display es una función de Python que muestra un objeto en el notebook de manera mas
bonita que print

Faltantes - Verlos y decidir

# Conteo de faltantes por columna (top 20)

missing_counts = [Link]().sum().sort_values(ascending=False) #esta funcion cuenta la
cantidad de valores faltantes (NaN) en cada columna del dataframe df. Luego, ordena los
resultados en orden descendente.
display(missing_counts.head(20))
#isna() es un metodo de pandas que devuelve un dataframe booleano indicando si cada valor
es NaN (True) o no (False)

# Gráfico de barras horizontal para faltantes

top_n = 20 if (missing_counts>0).sum() > 20 else (missing_counts>0).sum()
ax = missing_counts.head(top_n).plot(kind='barh', title='Valores faltantes por columna
(Top)')
[Link]().invert_yaxis()
plt.tight_layout()
[Link]()
#plt es una libreria para graficar en python
#gca() es un metodo de matplotlib que devuelve el eje actual. tight_layout() ajusta
automaticamente los parametros de la figura para que se vea bien

#shwow() muestra la figura

# Copia de trabajo para "antes/después"

df_clean = [Link]()

# a) Drop de columnas con mucha proporción de nulos (ejemplo: >70%)

null_ratio = df_clean.isna().mean()
to_drop = null_ratio[null_ratio > 0.7].[Link]() #columnas con más del 70% de nulos,
lo
print('Columnas eliminadas por nulos>70%:', to_drop)
df_clean = df_clean.drop(columns=to_drop, errors='ignore') #elimina las columnas con más
del 70% de nulos, eso se hace con to_drop

# b) Imputación simple (numéricos: mediana; categóricos: modo)

num_cols = df_clean.select_dtypes(include=[Link]).columns
cat_cols = df_clean.select_dtypes(exclude=[Link]).columns
for col in num_cols: #for col in num_cols: itera sobre cada columna en num_cols
df_clean[col] = df_clean[col].fillna(df_clean[col].median()) #fillna rellena los
valores nulos con la mediana de la columna, en este caso. es una funcion de pandas

for col in cat_cols: #for col in cat_cols: itera sobre cada columna en cat_cols. cat_cols
son las columnas categoricas
mode_val = df_clean[col].mode(dropna=True)
if not mode_val.empty:
df_clean[col] = df_clean[col].fillna(mode_val[0])
else:
df_clean[col] = df_clean[col].fillna('Desconocido')

print('Shape original:', [Link], '| Shape limpio:', df_clean.shape)

Columnas poco útiles

# Ejemplo: remover IDs/fechas que no aportan al modelo (ajustar a tu dataset)

drop_candidates = ['policy_number', 'policy_bind_date']
df_clean = df_clean.drop(columns=[c for c in drop_candidates if c in df_clean.columns],
errors='ignore')
df_clean.head(2)
#drop elimina las columnas que no aportan al modelo, en este caso las columnas
policy_number y policy_bind_date.

El % nos da el resto de una división

// es la división sin decimal

Algoritmo

- conjunto ordenado y finito de operaciones que permite hallar la solución de un problema

- método y notación en las distintas formas del calculo
- no es mas que un conjunto ordenado de instrucciones para llevar a cabo una tarea
especifica
- características
o ordenado
o finito
o debe estar bien definido
o debe estar bien especificado, sin ambigüedades, para ser aplicable a problemas
similares

Ejemplo

▶ Paso 1: Abrir la canilla y regular la temperatura del agua a

nuestro gusto

▶ Paso 2: Meterse bajo la ducha

▶ Paso 3: Cerrar la canilla

El paso 2 no está bien definido porque no especifica que haya

que mojarse el pelo!

Lo reescribimos..

▶ Paso 1: Abrir la canilla y regular la temperatura del agua a

nuestro gusto

▶ Paso 2: Meterse bajo la ducha

▶ Paso 3: Cerrar la canilla

▶ Paso 4: Abrir el frasco con shampoo y depositar sobre la

mano una cantidad de tamaño similar a una nuez.

▶ Paso 5: Extender el champú sobre el pelo mojado y masajearlo

▶ Paso 6: Volver al paso 1

Es una secuencia bien definida, y ordenada.

Qué dificultad presenta?  no es finito, es un bucle

▶ Paso 1: Abrir la canilla y regular la temperatura del agua a nuestro gusto

▶ Paso 2: Mojarse todo el cabello

▶ Paso 3: Cerrar la canilla

▶ Paso 4: Abrir el frasco con el shampoo y depositar sobre la mano una cantidad de tamaño
similar a una

nuez

▶ Paso 5: Extender el shampoo sobre el pelo mojado y masajearlo.

▶ Paso 6: Abrir la canilla y regular la temperatura del agua a nuestro gusto

▶ Paso 7: Aclarar el cabello hasta que no quede espuma

▶ Paso 8: Cerrar la canilla

▶ Paso 9: Abrir el frasco con el shampoo y depositar sobre la mano una cantidad de tamaño
similar a una

nuez.

▶ Paso 10: Extender el shampoo sobre el pelo mojado y masajearlo.

▶ Paso 11: Abrir la canilla y regular la temperatura del agua a nuestro gusto

▶ Paso 12: Aclarar el cabello hasta que no quede espuma

▶ Paso 13: Cerrar la canilla

▶ FIN
Problemas que tiene eso

- Podríamos haberlo escrito de forma más compacta, usando un contador que cuente las
veces que nos ponemos shampoo.  A ese contador lo llamamos j (por jabón) y al
principio es igual a 0
- Solo sirve para lavar el pelo, no para gente que no tiene pelo

▶ Paso 1: j=0

▶ Paso 2: Abrir la canilla y regular la temperatura del agua a nuestro gusto.

▶ Paso 3: Mojarse todo el cabello

▶ Paso 4: Cerrar la canilla

▶ Paso 5: Abrir el frasco con el shampoo y depositar sobre la mano una cantidad de tamaño
similar a una nuez

▶ Paso 6: Extender el shampoo sobre el pelo mojado y masajearlo

▶ Paso 7: j=j+1

▶ Paso 8: Abrir la canilla y regular la temperatura del agua a nuestro gusto

▶ Paso 9: Aclarar el cabello hasta que no quede espuma

▶ Paso 10: Cerrar la canilla

▶ Paso 11: Si j<2 volver al paso 5

▶ FIN

Esta forma de escritura: es compacta? es general?

▶ Es eficiente? Es óptimo en términos de tiempo y recursos?

De cuantas formas distintas podemos ordenar una lista de números

- Podemos dar todas las permutaciones posibles de los números de la lista y ver cual de
ellas es en la que aparecen todos los números ordenados (n!)
- Algo mas simple  tomar los primeros números de la lista y ordenarlos, después comparar
el tercero con el primero y el segundo para determinan su pisicion, y lo mismo con el
cuerto, etc

[4,1,5,2,3]

- ¿El 4 es < 1? No  cambian sus posiciones  lista resultante [1,4]

- ¿El 5<1? No  cambiamos sus posiciones → Lista resultante [1,5,4]. El 5 < 4? No 
cambiamos sus posiciones  Lista resultante [1,4,5]
- El 2 es < el 1? No → cambiamos sus posiciones → Lista resultante [1,2,4,5]. El 2 es <l 4?
Si → no cambiamos sus posiciones  Lista resultante [1,2,4,5] 3:
- El 3 es < 1? No → cambiamos sus posiciones → Lista resultante [1,3,2,4,5] . El 3 es < 2?
No → cambiamos sus posiciones  Lista resultante [1,2,3,4,5] . El 3 es < 4? Si → no
cambiamos sus posiciones  Lista resultante [1,2,3,4,5]
Cuantas menos operaciones tenga el algoritmo para llevarlo a cabo, mejor

Las operaciones solo dependen del algoritmo y de la entrada

Estructuras de control

Las estructuras for y while se utilizan para controlar el flujo de ejecución de un algoritmo,
especialmente en tareas que requieren repetición o iteración.

For:

- Cuando el número de iteraciones es conocido o está basado en una secuencia fija. Esta
definido
- Ventaja: Código más claro y menos propenso a errores.

While:

- Cuando el número de iteraciones no está definido de antemano y depende de una

condición dinámica. Cuando se produce algo particular
- Ventaja: Flexibilidad para condiciones complejas o cuando el bucle puede terminar antes.