📋 Referencias de Python

Referencias de Python

Los fragmentos a los que recurrirás en cada lección. El código corre en las celdas de arriba; estos son los patrones para copiar.

Variables
- Asignar y leer
```
x = 5
x = x + 1   # 6
print(x)    # 6
```
  = guarda un valor bajo un nombre. Reasignar solo apunta el nombre al nuevo valor.
- Reglas de nombres
```
score = 10      # snake_case ✅
age_2 = 3       # digits ok after first char
age 2 = 3       # ❌ space & leading digit
Score = 10      # works, but remember: case-sensitive
```
  Los nombres distinguen mayúsculas de minúsculas. Usa snake_case, nombres descriptivos y evita palabras propias como print.
- Intercambiar y desempaquetar
```
a, b = 1, 2
a, b = b, a   # swap in one line
first, *rest = [1, 2, 3]  # first=1, rest=[2, 3]
```
  Python asigna varios nombres a la vez, el intercambio más limpio que existe.
Salida
- print
```
print('Hello, world!')
print(2 + 3)      # 5, values print automatically
```
  La única función que usarás en todas las lecciones.
- Sin coma final
```
print('a', 'b', sep='-')   # a-b
```
  sep controla el separador; el valor por defecto es un espacio.
Entrada
- Leer el mensaje
```
name = input('Your name: ')
print('Hi', name)
```
  input() se detiene y espera; SIEMPRE devuelve una cadena.
- Convertirlo
```
age = int(input('Age: '))
price = float(input('Price: '))
```
  Convierte al leer con int()/float(), o fallará cada paso de matemáticas posterior.
Números
- Aritmética básica
```
x = 7
x // 2   # 3  integer division
x % 2    # 1  remainder
x ** 2   # 49 exponent
```
  // y % son los complementos de la división: responden "cuántas veces" y "cuánto queda".
- type()
```
type(3)     # <class 'int'>
type(3.0)   # <class 'float'>
type("3")   # <class 'str'>
```
  Comprueba el tipo de cualquier valor cuando un error mencione un desajuste de tipos.
- Convertir
```
int('42')   # 42
float('4.2')
str(42)     # '42'
```
  input() siempre devuelve una cadena: conviértela antes de hacer matemáticas.
Cadenas
- f-strings
```
name = 'PyDA'
print(f'{name} → {len(name)} letters')
```
  La f antes de la comilla hace que {…} inserte valores. Úsalas, no la concatenación.
- Métodos
```
'  hi  '.strip()   # 'hi'
'hello'.upper()   # 'HELLO'
'a,b'.split(',')   # ['a', 'b']
```
  Los métodos devuelven una cadena NUEVA: las cadenas son inmutables.
- Rebanar
```
word = 'python'
word[0]    # 'p'
word[-1]   # 'n'
word[1:4]  # 'yth'
```
  El inicio es inclusivo, el final exclusivo. Los índices negativos cuentan desde el final.
- Combinar, repetir, buscar
```
'py' + 'thon'    # 'python'
'ha' * 3        # 'hahaha'
'py' in 'python'  # True
len('abc')        # 3
```
  + une cadenas, * las repite, in comprueba una subcadena y len() cuenta caracteres.
- Escape con barra invertida
```
print('she\'s fine')   # she's fine
print('line1\nline2')  # two lines
print('tab\there')      # tab       here
```
  \' es una comilla, \n una línea nueva y \t una tabulación. Usa cadenas crudas r"…" cuando una ruta tenga demasiadas barras.

Listas

Crear y añadir

nums = [1, 2, 3]
nums.append(4)      # [1, 2, 3, 4]
nums + [5]        # [1, 2, 3, 4, 5]

append modifica la lista en su sitio; + crea una nueva.

Leer

nums[0]      # 1
len(nums)    # 4
nums[-1]     # 4
3 in nums    # True

in / not in son las comprobaciones de pertenencia.

Recorrer
```
for n in nums:
    print(n * 2)
```
El bucle for alcanza cada elemento uno a la vez.
Ordenar y copiar
```
nums.sort()          # in place
sorted(nums)         # NEW sorted list
copy = nums[:]       # real copy, not the same list
```
sort() cambia la lista y devuelve None; sorted() devuelve una nueva. Usa nums[:] para trabajar sobre una copia.

Trucos con rebanadas

nums = [0, 1, 2, 3, 4]
nums[1:]    # [1, 2, 3, 4]  drop the head
nums[:-1]   # [0, 1, 2, 3]  drop the tail
nums[::-1]  # [4, 3, 2, 1, 0]  reversed

La forma [inicio:fin:paso] es cirugía de listas: eliminar, copiar e invertir en una línea.

Tuplas y Conjuntos

Tuplas
```
t = (1, 2, 3)
t[0]        # 1
x, y = t        # unpack
# t[0] = 9      # ❌ tuples can't change
```
Una lista fija: úsala cuando la forma no deba cambiar: coordenadas, pares de configuración, datos de solo lectura.
Conjuntos
```
s = {1, 2, 2, 3}   # {1, 2, 3} — duplicates dropped
s.add(4)
4 in s        # True
s.remove(4)
```
Una bolsa sin orden de elementos únicos: perfecto para eliminar duplicados y comprobaciones de pertenencia rápidas.

Operaciones de conjuntos

a = {1, 2, 3}
b = {3, 4}
a | b       # {1, 2, 3, 4}  union
a & b       # {3}           intersection
a - b       # {1, 2}        difference
a ^ b       # {1, 2, 4}     symmetric

|, &, -, ^ convierten los conjuntos en matemáticas de una línea: compara grupos sin bucles anidados.

¿Qué contenedor?

list    # ordered, editable, keeps order
tuple   # ordered, read-only
set     # unordered, unique, fast in
dict    # key → value lookup

Elige según lo que necesite el código: orden, unicidad o encontrar cosas por nombre.

Diccionarios
- Crear y leer
```
ages = {'ada': 36, 'bob': 41}
ages['ada']        # 36
ages.get('zoe')    # None (safe "missing")
ages.get('zoe', 0) # 0 (with default)
```
  Usar [clave] con una clave inexistente lanza KeyError: prefiere .get() cuando dudes.
- Escribir
```
ages['ada'] = 37
ages['zoe'] = 22
del ages['bob']
```
  Asignar añade o actualiza; del elimina una clave.
- Iterar
```
for k, v in ages.items():
    print(k, v)
```
  .items() da pares (clave, valor); .keys() y .values() dan solo un lado.
Condicionales
- if / elif / else
```
if score >= 90:
    print("A")
elif score >= 80:
    print("B")
else:
    print("C")
```
  elif se detiene en cuanto una condición es True: el orden importa.
- Comparaciones
```
==  !=  <  <=  >  >=
```
  == comprueba igualdad; = asigna. Recordarlo arregla la mayoría de errores de "por qué es True".
- Operadores booleanos
```
a and b    # both truthy
a or b     # at least one
a and not b
```
  and / or / not: las palabras simples, no && ni ! como en otros lenguajes.
- Veracidad
```
if x:             # 'is x non-empty?'
    print(x)
# Falsy: 0, 0.0, '', [], {}, None
# Everything else is truthy
```
  "if x:" es la comprobación idiomática de "¿está x?"; los contenedores vacíos y el 0 fallan, todo lo demás pasa.
- Ternario en una línea
```
'pass' if score >= 50 else 'fail'
```
  Un if/else compacto que devuelve un valor: estupendo dentro de f-strings y print().
Bucles
- range
```
for i in range(3):   # 0, 1, 2
    print(i)
for i in range(1, 4): # 1, 2, 3
    print(i)
```
  range se detiene antes del segundo número: la misma regla de extremo exclusivo que las rebanadas.
- enumerate / zip
```
for i, item in enumerate(['a','b']):
    print(i, item)
for x, y in zip([1,2],[3,4]):
    print(x, y)
```
  enumerate añade un contador; zip empareja dos secuencias elemento a elemento.
- break / continue
```
for n in range(10):
    if n == 3:
        break      # stop the loop
for n in range(10):
    if n % 2:
        continue   # skip this one
    print(n)
```
  break abandona el bucle por completo; continue salta a la siguiente iteración.
- while
```
n = 3
while n > 0:
    print(n)
    n -= 1   # don't forget: while needs progress
```
  while se repite hasta que su condición sea False: un bucle que nunca actualiza su condición nunca termina.
- else del bucle (opcional)
```
for n in nums:
    if n == target:
        break
else:
    print("not found")
```
  El bloque else solo se ejecuta si el bucle terminó sin break: un indicador integrado de "¿se encontró?".
Funciones
- Definir y llamar
```
def double(x):
    return x * 2

y = double(21)   # 42
```
  El cuerpo de def… debe estar indentado. return entrega un valor; sin él obtienes None.
- Valores por defecto y palabras clave
```
def greet(name, exclaim=True):
    s = f"Hello {name}"
    return s + ("!" if exclaim else "")

greet("ada")        # Hello ada!
greet("ada", False) # Hello ada
```
  Los parámetros con = reciben valores por defecto; quien llama puede pasarlos por palabra clave.
- Devolver varios valores
```
def minmax(nums):
    return min(nums), max(nums)

lo, hi = minmax([3, 1, 4])  # lo=1, hi=4
```
  Una función puede devolver una tupla y quien la llama la desempaqueta en varios nombres a la vez.
- Ámbito y print vs return
```
x = 10            # global

def show(y):
    x = 5         # local — different x!
    print(x, y)   # side effect, returns None

result = show(1)  # result is None
```
  print muestra un valor en la consola; return realmente lo entrega. Asignar dentro de una función eclipsa la global.
- Lambda (formas cortas)
```
double = lambda x: x * 2
sorted(nums, key=lambda n: -n)
```
  Usa lambdas para funciones desechables de una línea pasadas a sort/max/map.

Comprensiones

Lista

[n * 2 for n in nums]              # [2, 4, 6]
[n for n in nums if n > 1]      # [2, 3]
{n * 2 for n in nums}           # set

Un bucle for entre corchetes: la forma idiomática de transformar una lista.

Diccionario
```
{n: n ** 2 for n in range(4)}   # {0: 0, 1: 1, 2: 4, 3: 9}
```
La misma forma, con dos puntos entre la clave y el valor.

Archivos y CSV
- Leer un archivo
```
text = open("file.txt").read()
lines = text.splitlines()
```
  La lectura más sencilla; usa with open(...) as f cuando necesites procesar por tramos.
- Filas CSV
```
import csv
with open('data.csv') as f:
    rows = list(csv.reader(f))
```
  rows[0] es la cabecera; cada fila siguiente es una lista de cadenas: conviértelas a números antes de calcular.
pandas (Análisis de datos)
- Cargar y echar un vistazo
```
import pandas as pd
df = pd.read_csv('data.csv')
df.head()      # first 5 rows
df.describe()  # numeric summary
```
  La fórmula estándar: pd.read_csv es cómo empieza toda lección de datos.
- Columnas y filas
```
df['name']          # one column
df[['a', 'b']]      # several
df.loc[0]           # first row
df[df['age'] > 30]  # filter rows
```
  Corchetes sobre un nombre de columna; máscaras booleanas para filtrar.
- Agrupar y agregar
```
df.groupby('city')['sales'].sum()
df.groupby('city').mean()
```
  groupby más un método de resumen es el eje de la sección de Análisis de datos.
Recuperación de errores
- Lee la última línea
```
TypeError: unsupported operand type(s) for +: 'int' and 'str'
```
  La última línea nombra el error y los valores ofensivos: es el mensaje que dice qué corregir.
- try / except
```
try:
    total = int(user_input) * 2
except ValueError:
    print('That was not a number')
```
  Captura solo el error concreto que esperas; capturarlo todo oculta errores reales.

Referencias de Python

📦 Variables

Asignar y leer

Reglas de nombres

Intercambiar y desempaquetar

🖨️ Salida

print

Sin coma final

⌨️ Entrada

Leer el mensaje

Convertirlo

🔢 Números

Aritmética básica

type()

Convertir

📝 Cadenas

f-strings

Métodos

Rebanar

Combinar, repetir, buscar

Escape con barra invertida

📚 Listas

Crear y añadir

Leer

Recorrer

Ordenar y copiar

Trucos con rebanadas

🏷️ Tuplas y Conjuntos

Tuplas

Conjuntos

Operaciones de conjuntos

¿Qué contenedor?

🗂️ Diccionarios

Crear y leer

Escribir

Iterar

🔀 Condicionales

if / elif / else

Comparaciones

Operadores booleanos

Veracidad

Ternario en una línea

🔁 Bucles

range

enumerate / zip

break / continue

while

else del bucle (opcional)

🛠️ Funciones

Definir y llamar

Valores por defecto y palabras clave

Devolver varios valores

Ámbito y print vs return

Lambda (formas cortas)

🧰 Comprensiones

Lista

Diccionario

🗃️ Archivos y CSV

Leer un archivo

Filas CSV

🐼 pandas (Análisis de datos)

Cargar y echar un vistazo

Columnas y filas

Agrupar y agregar

🛟 Recuperación de errores

Lee la última línea

try / except

Variables

Salida

Entrada

Números

Cadenas

Listas

Tuplas y Conjuntos

Diccionarios

Condicionales

Bucles

Funciones

Comprensiones

Archivos y CSV

pandas (Análisis de datos)

Recuperación de errores