> ## Documentation Index
> Fetch the complete documentation index at: https://apuntes.simulab.es/llms.txt
> Use this file to discover all available pages before exploring further.

# Python desde cero: variables, condicionales, bucles, funciones y estructuras de datos

> Introducción a Python para principiantes y estudiantes: tipos de datos, variables, operadores, entrada y salida, condicionales, bucles for y while, funciones, listas, tuplas, diccionarios y conjuntos, comprensiones, cadenas, excepciones y ficheros, con ejemplos de código explicados.

**Python** es el lenguaje más usado para aprender a programar y uno de los más usados en la industria: ciencia de datos, inteligencia artificial, automatización, desarrollo web y cálculo científico. Su sintaxis es clara y cercana al pseudocódigo, y permite escribir en pocas líneas lo que en C o Java necesitaría muchas más. Este tema recorre todo lo básico con ejemplos.

## Lo que vas a aprender

* Los tipos de datos básicos, las variables y los operadores.
* Cómo leer datos y mostrar resultados.
* Condicionales y bucles.
* Cómo definir funciones.
* Las estructuras de datos de Python: listas, tuplas, diccionarios y conjuntos.
* Comprensiones de listas, cadenas, excepciones y ficheros.

## Fundamentos

### Variables y tipos

En Python no se declara el tipo: se asigna y el intérprete lo deduce.

```python theme={null}
edad = 20            # int (entero, de tamaño ilimitado)
altura = 1.75        # float (decimal)
nombre = "Ana"       # str (cadena)
aprobado = True      # bool (True o False)
nada = None          # ausencia de valor

print(type(altura))  # <class 'float'>
```

### Operadores

| Operador | Significado | Ejemplo |
| - | - | - |
| `+ - * /` | Aritméticos (`/` siempre da float) | `7 / 2` → `3.5` |
| `//` | División entera | `7 // 2` → `3` |
| `%` | Resto | `7 % 2` → `1` |
| `**` | Potencia | `2 ** 10` → `1024` |
| `== != < <= > >=` | Comparación | `3 == 3.0` → `True` |
| `and or not` | Lógicos | `x > 0 and x < 10` |
| `in` | Pertenencia | `"a" in "casa"` → `True` |

### Entrada y salida

```python theme={null}
nombre = input("¿Cómo te llamas? ")       # input siempre devuelve str
edad = int(input("¿Cuántos años tienes? "))
print(f"Hola, {nombre}. El año que viene tendrás {edad + 1}.")
```

Las **f-strings** (`f"..."`) insertan expresiones entre llaves. Con `{x:.2f}` se muestran 2 decimales.

### Condicionales

La **indentación** (4 espacios) delimita los bloques: no hay llaves.

```python theme={null}
nota = 7.5
if nota >= 9:
    print("Sobresaliente")
elif nota >= 7:
    print("Notable")
elif nota >= 5:
    print("Aprobado")
else:
    print("Suspenso")
```

### Bucles

```python theme={null}
for i in range(5):           # 0, 1, 2, 3, 4
    print(i)

for i in range(2, 11, 2):    # 2, 4, 6, 8, 10
    print(i)

n = 10
while n > 0:
    n //= 2
    print(n)
```

`break` sale del bucle y `continue` salta a la siguiente iteración.

### Funciones

```python theme={null}
def area_circulo(r, pi=3.14159):
    """Devuelve el área de un círculo de radio r."""
    return pi * r ** 2

print(area_circulo(2))           # 12.56636
print(area_circulo(2, pi=3.14))  # 12.56
```

Los parámetros pueden tener **valores por defecto**. Una función puede devolver varios valores en una tupla: `return minimo, maximo`.

### Estructuras de datos

| Tipo | Sintaxis | Ordenada | Modificable | Duplicados | Uso |
| - | - | - | - | - | - |
| **Lista** | `[1, 2, 3]` | Sí | Sí | Sí | Secuencias en general |
| **Tupla** | `(1, 2, 3)` | Sí | No | Sí | Datos fijos, devolver varios valores |
| **Diccionario** | `{"a": 1, "b": 2}` | Sí (desde 3.7) | Sí | Claves únicas | Buscar por clave |
| **Conjunto** | `{1, 2, 3}` | No | Sí | No | Eliminar duplicados, pertenencia |

```python theme={null}
# Listas
numeros = [5, 3, 8, 1]
numeros.append(4)        # [5, 3, 8, 1, 4]
numeros.sort()           # [1, 3, 4, 5, 8]
print(numeros[0], numeros[-1])   # 1 8 (primero y último)
print(numeros[1:3])      # [3, 4] (rebanada: del índice 1 al 2)

# Diccionarios
edades = {"Ana": 20, "Luis": 22}
edades["Eva"] = 19
for nombre, edad in edades.items():
    print(nombre, edad)
print(edades.get("Pepe", 0))     # 0 si no existe

# Conjuntos
a = {1, 2, 3}
b = {2, 3, 4}
print(a & b, a | b, a - b)       # {2, 3} {1, 2, 3, 4} {1}
```

Buscar en un diccionario o un conjunto cuesta $O(1)$ de media, porque son [tablas hash](https://apuntes.simulab.es/programacion/java/tablas-hash.md); buscar en una lista, $O(n)$.

### Comprensiones

Una forma compacta de construir listas, diccionarios o conjuntos:

```python theme={null}
cuadrados = [x ** 2 for x in range(10)]
pares = [x for x in range(20) if x % 2 == 0]
longitudes = {palabra: len(palabra) for palabra in ["sol", "luna"]}
```

### Cadenas

```python theme={null}
s = "Hola Mundo"
print(s.upper(), s.lower(), len(s))   # HOLA MUNDO hola mundo 10
print(s.split())                      # ['Hola', 'Mundo']
print("-".join(["a", "b", "c"]))      # a-b-c
print(s[::-1])                        # odnuM aloH (invertida)
```

Las cadenas son **inmutables**: los métodos devuelven una cadena nueva.

### Excepciones y ficheros

```python theme={null}
try:
    x = int(input("Número: "))
    print(10 / x)
except ValueError:
    print("Eso no es un número")
except ZeroDivisionError:
    print("No se puede dividir entre cero")

with open("datos.txt", "w", encoding="utf-8") as f:
    f.write("línea 1\n")

with open("datos.txt", encoding="utf-8") as f:
    for linea in f:
        print(linea.strip())
```

`with` cierra el fichero automáticamente aunque haya un error.

## Ejemplos resueltos

> [accordion] Ejemplo 1 · ¿Es primo?
>
> ```python theme={null}
> def es_primo(n):
>     if n < 2:
>         return False
>     d = 2
>     while d * d <= n:
>         if n % d == 0:
>             return False
>         d += 1
>     return True
>
> print([n for n in range(30) if es_primo(n)])
> # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
> ```
>
> Basta con probar divisores hasta $\sqrt n$. Compáralo con la [factorización en primos](https://apuntes.simulab.es/matematicas/numeros/factorizacion.md).

> [accordion] Ejemplo 2 · Contar palabras
>
> ```python theme={null}
> texto = "el gato y el perro y el pez"
> cuenta = {}
> for palabra in texto.split():
>     cuenta[palabra] = cuenta.get(palabra, 0) + 1
> print(cuenta)   # {'el': 3, 'gato': 1, 'y': 2, 'perro': 1, 'pez': 1}
> ```
>
> La biblioteca estándar lo hace en una línea: `collections.Counter(texto.split())`.

> [accordion] Ejemplo 3 · Media y desviación típica
>
> ```python theme={null}
> datos = [4, 8, 6, 5, 3, 7]
> media = sum(datos) / len(datos)
> var = sum((x - media) ** 2 for x in datos) / len(datos)
> print(f"Media: {media:.2f}, desviación: {var ** 0.5:.2f}")
> # Media: 5.50, desviación: 1.71
> ```
>
> Compara con la calculadora de [estadística descriptiva](https://apuntes.simulab.es/matematicas/estadistica/estadistica.md).

> [accordion] Ejemplo 4 · Fibonacci con y sin recursión
>
> ```python theme={null}
> def fib_rec(n):
>     return n if n < 2 else fib_rec(n - 1) + fib_rec(n - 2)
>
> def fib_iter(n):
>     a, b = 0, 1
>     for _ in range(n):
>         a, b = b, a + b
>     return a
>
> print(fib_iter(50))   # 12586269025
> ```
>
> La versión recursiva tarda un tiempo exponencial; la iterativa, lineal. Lo explican los temas de [recursión](https://apuntes.simulab.es/programacion/c/recursion.md) y [programación dinámica](https://apuntes.simulab.es/programacion/algoritmos/programacion-dinamica.md).

## Errores frecuentes

* **Mezclar tabuladores y espacios** en la indentación. Usa siempre 4 espacios.
* **Olvidar convertir `input()`** a número: `"3" + "4"` es `"34"`.
* **Modificar una lista mientras se recorre** con `for`. Recorre una copia o construye una nueva.
* **Usar una lista como valor por defecto:** `def f(x=[])` comparte la misma lista entre llamadas. Usa `x=None`.
* **Confundir `=` (asignar) con `==` (comparar).**
* **Copiar listas con `b = a`.** Las dos variables apuntan a la misma lista; para copiar, `b = a.copy()` o `b = a[:]`.

## Preguntas frecuentes

> [accordion] ¿Python es lento?
>
> El intérprete es más lento que C para bucles puros, a veces 50 veces o más. Pero las bibliotecas científicas (NumPy, pandas, PyTorch) están escritas en C y Fortran por dentro, y operando con arrays enteros en lugar de bucles se consigue una velocidad parecida.

> [accordion] ¿Qué hago después de lo básico?
>
> Programación orientada a objetos (clases), módulos y entornos virtuales, y luego la biblioteca de tu área: NumPy y Matplotlib para cálculo y gráficas, pandas para datos, Flask o Django para web, scikit-learn o PyTorch para aprendizaje automático.

## Temas relacionados

> [card] [Estructuras de datos](https://apuntes.simulab.es/programacion/algoritmos/estructuras-datos.md)
>
> Pilas, colas y árboles animados.

> [card] [Algoritmos de ordenación](https://apuntes.simulab.es/programacion/algoritmos/ordenacion.md)
>
> Cómo ordena sort() por dentro.

> [card] [Tablas hash](https://apuntes.simulab.es/programacion/java/tablas-hash.md)
>
> Lo que hay detrás de los diccionarios.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.