Introducción a Python

class: center, middle, inverse, title-slide

.title[
# Introducción a Python
]
.subtitle[
## Clase 2: Variables, objetos y tipos básicos
]
.author[
### Daniel Miles Touya Máster en Análisis de Datos · UdelaR-Uvigo
]
.date[
### 27 abril 2026
]

---

class: inverse, middle

.huge[Comprensión lectora]

## en código generado por LLM

---

# Guía de lectura de la clase

.smallest[
En esta clase vamos a leer código Python básico.

El objetivo .hi-red[no] es .hi-blue[memorizar instrucciones/expresiones].

Lo que se pretende en esta clase es **aprender a responder** tres preguntas en un código generado por LLM:

- ¿qué objetos aparecen en el código?
- ¿qué nombres apuntan a esos objetos?
- ¿qué tipo tiene cada objeto?
]

.div_bloque.small[
.hi-blue[Idea central:]

> Para leer código Python —también código generado por IA— necesitamos entender cómo Python guarda y manipula la información.
]

---

# La idea más importante

.div_bloque[
En Python, .hi-red[todo es un objeto].
]

.smallest[
Un .hi-red[objeto] puede ser:

- un número: `42`
- un texto: `"hola"`
- una lista: `[1, 2, 3]`
- una función: `print`
- una librería importada: `math`
]

.div_bloque.small[
Cada objeto tiene tres propiedades:

- .hi-blue[identidad]
- .hi-blue[tipo]
- .hi-blue[valor]
]

---

# Tres preguntas para leer código

.smallest[
Cuando veamos una línea de código, intentaremos responder:

1. .hi-red[¿Qué .hi-blue[objeto] se crea o se usa?]
2. .hi-red[¿Qué .hi-blue[nombre apunta] a ese objeto?]
3. .hi-red[¿Qué .hi-blue[tipo] tiene ese objeto?]
]

.div_bloque.small[
Ejemplo:

```python
x = 42
```

Esta línea no significa “meter 42 dentro de una caja llamada `x`.

Significa:

> crear o usar el objeto `42` y hacer que el nombre `x` apunte a él.
]

---

# Primer ejemplo en Python

.smallest[
Ejecuta este código en JupyterLab:
]

```python
x = 42

print(x)
print(type(x))
print(id(x))
```

.smallest[
Lectura del código:

- `x = 42` asigna el nombre `x` al objeto `42`
- `print(x)` muestra el valor
- `type(x)` pregunta por el tipo del objeto
- `id(x)` pregunta por su identidad en memoria
]

---

# Identidad, tipo y valor

.div_bloque.small[
Para Python, el objeto al que apunta `x` tiene:

- .hi-blue[valor]: `42`
- .hi-blue[tipo]: `int`
- .hi-blue[identidad]: una dirección interna de memoria
]

```python
x = 42

print("valor:", x)
print("tipo:", type(x))
print("identidad:", id(x))
```

.smallest[
No hace falta memorizar el número que devuelve `id()`.

Lo importante es entender que cada objeto tiene una identidad propia.
]

---

# Variables: etiquetas, no cajas

.div_bloque[
Una .hi-blue[variable] en Python no es una caja.

> Es una .hi-red[etiqueta] que .hi-blue[apunta] a un objeto.
]

```python
x = 42
y = x

print(x)
print(y)

print(id(x))
print(id(y))
```

.smallest[
Pregunta para .hi-green[leer y comprender] el código:

> ¿`x` e `y` contienen dos copias de `42`, o apuntan al mismo objeto?
]

---

# Comparar valor y comparar identidad

.smallest[
Python permite comparar dos cosas distintas:

- `==` compara valores
- `is` compara identidades
]

```python
x = 42
y = x

print(x == y)
print(x is y)
```

.div_bloque.small[
.hi-red[Regla práctica:]

- usa `==` para comparar valores
- usa `is` solo cuando quieras saber si dos nombres apuntan exactamente al mismo objeto
]

---

# Reasignar una variable

.smallest[
Ahora observa qué ocurre cuando cambiamos el valor de `x`.
]

```python
x = 42
print(id(x))

x = 43
print(id(x))
```

.div_bloque.small[
Cuando escribimos `x = 43`, Python no modifica el objeto `42`.

Lo que hace es:

> mover la etiqueta `x` para que apunte a otro objeto.
]

---

# El operador `=`

.div_bloque[
En Python, `=` no significa igualdad matemática.

Significa .hi-red[asignación].
]

.smallest[
La línea:

```python
x = x + 1
```

se lee en tres pasos:

1. Python mira el lado derecho: `x + 1`
2. calcula el resultado
3. mueve el nombre `x` al nuevo objeto (cambia la flecha; reasigna)
]

```python
x = 10
print(x)

x = x + 1
print(x)
```

---

# Leer código generado por IA

.div_bloque.small[
Cuando ChatGPT, Copilot u otra IA genere código, no debemos copiarlo a ciegas.
]

.smallest[
Primero hacemos preguntas simples:

- ¿qué variables aparecen?
- ¿qué objetos se están creando?
- ¿qué tipo tiene cada objeto?
- ¿hay alguna reasignación?
- ¿hay alguna operación cuyo resultado no entiendo?
]

```python
precio = 100
iva = 0.21
precio_final = precio * (1 + iva)

print(precio_final)
print(type(precio_final))
```

---

# Material de lectura

.smallest[
En la primera parte del material de lectura vais a encontrar cuatro ideas principales:

1. Todo en Python es un objeto.
2. Todo objeto tiene identidad, tipo y valor.
3. Las variables son etiquetas que apuntan a objetos.
4. El operador `=` asigna nombres a objetos: no expresa igualdad matemática.
]

.div_bloque[
.hi-blue[Consejo de lectura:]

> No intentéis memorizar cada línea. Intentad comprender o explicar con palabras qué hace cada línea de código: la IA te dará el código que se deberá leer y comprender.
]

---

# Mutabilidad: ¿cambia el objeto?

.div_bloque[
Algunos objetos pueden cambiar.

Otros no.
]

.smallest[
- .hi-blue[Inmutables:] no pueden cambiar  
- .hi-blue[Mutables:] sí pueden cambiar  
]

```python
x = "hola"
print(id(x))

x = "hola mundo"
print(id(x))
```

.smallest[
Pregunta:

> ¿ha cambiado el objeto o solo la etiqueta?
]

---

# Objetos inmutables

.div_bloque.small[
Los objetos como:

- números (`int`, `float`)
- texto (`str`)
- booleanos (`bool`)

son .hi-red[inmutables].
]

.smallest[
Esto significa:

> cualquier “cambio” crea un objeto nuevo
]

```python
x = 10
print(id(x))

x = x + 1
print(id(x))
```

---

# Objetos mutables

.div_bloque.small[
Otros objetos sí pueden cambiar.

Por ejemplo: las listas.
]

```python
lista = [1, 2, 3]

print(id(lista))

lista.append(4)

print(id(lista))
print(lista)
```

.smallest[
Pregunta:

> ¿por qué aquí el `id` no cambia?
]

---

# Diferencia clave

.div_bloque[
- Inmutable → se crea un objeto nuevo  
- Mutable → se modifica el mismo objeto  
]

.smallest[
Esto es fundamental para leer código.

Especialmente cuando varias variables apuntan al mismo objeto.
]

---

# Tipos: qué puedes hacer con cada objeto

.div_bloque[
El .hi-red[tipo] determina qué operaciones puedes hacer.
]

```python
x = 10
y = "hola"

print(type(x))
print(type(y))
```

.smallest[
No puedes hacer cualquier operación con cualquier tipo.
]

---

# Error de tipos

.smallest[
Ejecuta esto:
]

```python
x = 10
y = "hola"

print(x + y)
```

.div_bloque.small[
.hi-red[Resultado:]

Python lanza un error.

¿Por qué?

> porque los tipos no son compatibles
]

---

# Leer errores

.div_bloque[
Los errores son información útil.
]

.smallest[
Cuando Python da un error, está diciendo:

- qué tipo de problema hay  
- en qué línea ocurre  
]

.smallest[
Objetivo:

> no evitar errores, sino aprender a leerlos
]

---

# Tipos en datos reales

.smallest[
En código real aparecen muchos tipos distintos.
]

```python
import numpy as np
import pandas as pd

x = np.array([1, 2, 3])
print(type(x))

df = pd.DataFrame({"a": [1, 2, 3]})
print(type(df))
```

.div_bloque.small[
.hi-blue[Idea importante:]

No todo es `list` o `int`.

Cada modulo-paquete (librería en R) define sus propios tipos.
]

---

# Regla para leer código

.div_bloque[
Cuando no entiendas algo:

&gt; usa `type()`
]

```python
x = [1, 2, 3]
print(type(x))
```

.smallest[
Esto es exactamente lo que harás leyendo código generado por IA.
]

---

# Qué has aprendido

.smallest[
- hay objetos mutables e inmutables  
- las variables apuntan a objetos  
- el tipo determina las operaciones  
- los errores ayudan a entender el código  
]

.div_bloque[
.hi-blue[Idea final:]

> Leer código es entender objetos, tipos y relaciones entre ellos.

>> Mira la segunda parte del html que les he dado...trabaja para entender...no hay mejor memoria que la de un LLM

]

---

# Tipos y operadores

.div_bloque[
Hasta ahora:

- sabemos qué es un objeto  
- sabemos qué es una variable

Ahora:

> ¿qué podemos hacer con esos objetos?
]

---

# Operaciones básicas

.smallest[
Python permite operar con objetos.

Pero solo si los **tipos son compatibles**.
]

```python
x = 10
y = 5

print(x + y)
print(x - y)
print(x * y)
print(x / y)
```

.div_bloque.small[
.hi-blue[Idea:]

Las operaciones dependen del tipo del objeto.
]

---

# Operaciones con texto

.smallest[
Los .hi-blue[strings] también tienen operaciones.
]

```python
x = "hola"
y = " mundo"

print(x + y)
print(x * 3)
```

.div_bloque.small[
.hi-red[Importante:]

Observar que `+` no siempre significa lo mismo.

**Depende del tipo**.
]

---

# El mismo símbolo, distinto significado

.div_bloque[
El operador depende del tipo.
]

```python
print(2 + 3)
print("2" + "3")
```

.smallest[
Pregunta:

> ¿por qué el resultado es distinto?
]

---

# Mezclar tipos

.smallest[
Ejecuta esto:
]

```python
x = 10
y = "20"

print(x + y)
```

.div_bloque.small[
.hi-red[Error]

Python no sabe cómo sumar un número y un string.
]

.smallest[
Solución:

> convertir tipos
]

---

# Conversión de tipos

.smallest[
Python permite cambiar el tipo de un objeto.
]

```python
x = 10
y = "20"

print(x + int(y))
```

.div_bloque.small[
.hi-blue[Idea:]

Leer código = entender cuándo hay conversiones.
]

---

# Operadores lógicos

.smallest[
También hay operaciones con booleanos.
]

```python
print(True and False)
print(True or False)
print(not True)
```

.div_bloque.small[
Estos operadores aparecen mucho en código real.
]

---

# Comparaciones

.smallest[
Python permite comparar objetos.
]

```python
print(10 > 5)
print(10 == 10)
print(10 != 3)
```

.div_bloque.small[
.hi-blue[Resultado:]

Siempre devuelven `True` o `False`.
]

---

# Leer expresiones

.div_bloque[
El código no se ejecuta “de izquierda a derecha”.

Sigue reglas de prioridad.
]

```python
print(2 + 3 * 4)
```

.smallest[
Pregunta:

> ¿por qué no es 20?

]

---

# Regla práctica

.div_bloque[
Si dudas en la forma de concatenar operadores:

> usa paréntesis
]

```python
print((2 + 3) * 4)
```

.smallest[
Esto hace el código más claro.
]

---

# En código real

.smallest[
En librerías verás cosas como:
]

```python
import numpy as np

x = np.array([1, 2, 3])
print(x * 2)
```

.div_bloque.small[
.hi-blue[Idea:]

Las operaciones también dependen del tipo de objeto de la librería.
]

---

# Qué hemos visto hasta ahora

.smallest[
- los operadores dependen del tipo  
- el mismo símbolo puede significar cosas distintas  
- los errores indican incompatibilidad  
- las conversiones son comunes  
- los paréntesis ayudan a leer

> Mira el material en el html y trabaja por tu cuenta.

]

.div_bloque[
.hi-blue[Idea final:]

> Leer código = entender operaciones + tipos
]

---

# Parte IV · Tareas

.div_bloque[En lso html que les adjunto aparece una sección de **Tareas**.

> Objetivo: que trabajen y consulten con los LLM, que hoy en día son los mejores tutores en programación

]

---

# Qué tenéis que hacer a partir de ahora

.div_bloque[

Mi dinámica de clase es dar una guía de lo que hay en el html de cada clase y, a partir de aquí, que ustedes trabajen a su ritmo.

Tienen aproximadamente 1:30 de clase para trabajar; más todo el tiempo que ustedes dispongan por fuera.

> La idea es que ejecutan el código en JupyterLab y aprendan a leer y comprender lo que sale...la única forma de aprender es haciendo...
]

.smallest[
Para cada bloque:

1. copia el código  
2. ejecútalo (`Shift + Enter`)  
3. observa el resultado  
4. intenta explicarlo con tus palabras  
]

---

# Cómo trabajar

.div_bloque[
No se trata de copiar y pegar sin pensar.
]

.smallest[
Para cada fragmento de código, pregúntate:

- ¿qué objetos aparecen?
- ¿qué variables hay?
- ¿qué tipo tiene cada objeto?
- ¿qué operación se está haciendo?
- ¿por qué funciona o falla?
]

---

# Regla de oro

.div_bloque[
> Si no entiendes una línea, no sigas adelante
]

.smallest[
Prueba:

- cambiar valores  
- ejecutar de nuevo  
- usar `print()`  
- usar `type()`  
]

---

# Ejemplo de cómo trabajar

.smallest[
No hagas solo esto:
]

```python
x = 10
y = 20
print(x + y)
```

.smallest[
Haz esto:
]

```python
x = 10
y = 20

print(type(x))
print(type(y))

print(x + y)
```

.div_bloque.small[
.hi-blue[Objetivo:]

entender qué está pasando, no solo ver el resultado
]

---

# Si hay errores

.div_bloque[
Los errores son parte del proceso
]

.smallest[
Cuando aparezca un error:

- léelo  
- identifica la línea  
- intenta entender qué tipo de problema es  
]

.smallest[
> No ignores los errores — son la mejor forma de aprender
]

---

# Trabajo individual

.div_bloque[
Cada uno debe trabajar a su ritmo
]

.smallest[
- algunos bloques serán rápidos  
- otros requerirán más tiempo  
]

.smallest[
> lo importante no es terminar todo, sino entender lo que haces, usando los LLM como soporte en las dudas

>> Hay que aprender a redactar un prompt para que la IA nos ayude

]

---

# Qué vais a aprender

.smallest[
Al final de la sesión deberías poder:

- leer código Python básico  
- entender qué hacen las variables  
- identificar tipos  
- detectar errores simples  
]

---

# Suerte

.hi-red[Aprender Python en el mundo de los LLM = aprender a .hi-blue[leer código]]

.small[
No se trata de escribir mucho código.

Se trata de entender lo que ves.
]