Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 7 de 47 · El array de PHP en Python ✦ WebMCP implementado

list: el array indexado

9 min de lectura 4 retos

El array de PHP hace de lista y de diccionario a la vez. Python lo reparte en cuatro tipos y el primero es list: la lista, el array indexado [1, 2, 3] sin claves. Aquí ves cuándo usarla, sus métodos esenciales, las rebanadas y las comprensiones.

¿De dónde vienen los nombres?

list = inglés list (lista)
Una colección ordenada de cosas, una detrás de otra. Es tu ["a", "b"] de PHP cuando no usas claves.
append = inglés append (añadir al final)
Pega un elemento detrás del último. Es el $tareas[] = "x" de PHP.
pop = inglés pop (hacer saltar)
Viene del vocabulario de las pilas (stack): meter es push y sacar es pop. pop() saca el último y te lo devuelve.
extend = inglés extend (extender)
Alarga la lista con todos los elementos de otra. Es un array_merge que cambia la lista original.
slice = inglés slice (loncha, rebanada)
Un trozo de la lista, como una loncha de pan de molde: tareas[1:3]. Es el array_slice de PHP.
comprensión (comprehension) = inglés comprehension: construir una lista describiéndola
Una lista que se escribe en una línea con la forma «esto, por cada aquello, si pasa este filtro».
En 4 ideas
1/4

list es el array indexado de PHP (["a", "b"] sin claves): ordenado, se puede cambiar, admite repetidos y mezcla tipos. Para clave => valor hay otro tipo, dict.

1 · Qué es una lista y cuándo usarla

Piensa en la lista de la compra: papeles uno debajo de otro, en orden, y puedes tachar, añadir o cambiar de sitio. Eso es una list. En PHP escribes ["pan", "leche"] y no sabes si es una lista o un diccionario hasta que miras las claves (las claves 0, 1, 2… están ahí, ocultas). En Python una lista solo tiene posiciones: el primer elemento es el 0.

Pythonmain.py
tareas = ["Comprar pan", "Llamar al banco", "Repasar Python"]

# En PHP: echo $tareas[0] . PHP_EOL;
print(tareas[0])

# En PHP: echo end($tareas) . PHP_EOL;
print(tareas[-1])

# En PHP: echo count($tareas) . PHP_EOL;
print(len(tareas))

# En PHP: var_dump(in_array("Comprar pan", $tareas, true));
print("Comprar pan" in tareas)

# Una lista cambia con el índice, y puede mezclar tipos.
tareas[1] = "Llamar a la gestoría"
mezcla = ["Pan", 3, True, None]
print(tareas)
print(mezcla)
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = ["Comprar pan", "Llamar al banco", "Repasar Python"];

echo $tareas[0] . PHP_EOL;
echo end($tareas) . PHP_EOL;
echo count($tareas) . PHP_EOL;
var_dump(in_array("Comprar pan", $tareas, true));
Pythonmain.py
tareas = ["Comprar pan", "Llamar al banco", "Repasar Python"]

print(tareas[0])
print(tareas[-1])
print(len(tareas))
print("Comprar pan" in tareas)

El índice negativo cuenta desde el final: -1 es el último, -2 el penúltimo. En PHP necesitas end() o $a[count($a) - 1]. Y el operador in pregunta si un valor está dentro (es el in_array de PHP, sin el tercer argumento de comparación estricta: in ya compara con ==).

¿Cuándo usar una lista? Cuando tienes muchas cosas del mismo tipo, en orden y que van a cambiar:

  1. La cola de tareas pendientes: añades al final, atiendes por el principio.
  2. El historial de lo que has hecho hoy: solo crece y el orden importa.
  3. Las etiquetas de una tarea (["casa", "urgente"]): una tarea puede tener varias.
  4. Los resultados de una consulta: filas una detrás de otra que luego recorres con for.

2 · Añadir, quitar y juntar

Los métodos de una lista se escriben detrás de ella con un punto: tareas.append(...). Piensa en una lista como en un objeto que sabe hacer cosas con sus propios datos.

Pythonmain.py
tareas = ["Comprar pan", "Llamar al banco"]

# En PHP: $tareas[] = "Repasar Python";
tareas.append("Repasar Python")

# En PHP: array_unshift($tareas, "Pagar la luz");
tareas.insert(0, "Pagar la luz")

# En PHP: array_push($tareas, "Regar", "Barrer");
tareas.extend(["Regar", "Barrer"])
print(tareas)

# En PHP: $ultima = array_pop($tareas);
ultima = tareas.pop()
print("Saco:", ultima)

# En PHP: $primera = array_shift($tareas);
primera = tareas.pop(0)
print("Saco:", primera)

# En PHP: unset($tareas[array_search("Regar", $tareas, true)]);
tareas.remove("Regar")
print(tareas)

# En PHP: unset($tareas[0]); $tareas = array_values($tareas);
del tareas[0]
print(tareas)
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = ["Comprar pan", "Llamar al banco"];

$tareas[] = "Repasar Python";
array_unshift($tareas, "Pagar la luz");
$tareas = array_merge($tareas, ["Regar", "Barrer"]);

$ultima = array_pop($tareas);
$primera = array_shift($tareas);

echo implode(", ", $tareas) . PHP_EOL;
Pythonmain.py
tareas = ["Comprar pan", "Llamar al banco"]

tareas.append("Repasar Python")
tareas.insert(0, "Pagar la luz")
tareas.extend(["Regar", "Barrer"])

ultima = tareas.pop()
primera = tareas.pop(0)

print(", ".join(tareas))
Quiero…En PHPEn Python
Añadir al final$a[] = $xa.append(x)
Añadir al principioarray_unshift($a, $x)a.insert(0, x)
Juntar otra lista$a = array_merge($a, $b)a.extend(b) o a + b
Sacar el últimoarray_pop($a)a.pop()
Sacar el primeroarray_shift($a)a.pop(0)
Borrar por valorunset($a[array_search($x, $a)])a.remove(x)
Borrar por posiciónunset($a[2]) (deja un hueco)del a[2] (reindexa solo)
Contarcount($a)len(a)
¿Está?in_array($x, $a)x in a
Unir en un textoimplode(", ", $a)", ".join(a)

¿Por qué? · En PHP no existe

¿Por qué append, sort o remove devuelven None? En PHP cada función devuelve algo

Los métodos que cambian la lista no te devuelven nada (None). Es una regla de Python: o una operación cambia la lista, o te da un valor nuevo, pero nunca las dos cosas a la vez.

Así, al leer tareas.append(x) sabes que es una orden y que tareas ha cambiado. Y si ves sorted(tareas) sabes que tareas sigue igual. En PHP sort($a) cambia el array y devuelve true, y array_merge devuelve uno nuevo: tienes que acordarte de cuál es cuál.

3 · Rebanadas: [inicio:fin:paso]

Una rebanada saca un trozo de la lista sin tocarla y devuelve una lista nueva. Se escribe con dos puntos entre corchetes: tareas[desde:hasta]. El desde sí entra y el hasta no. Si dejas uno vacío, es «hasta el principio» o «hasta el final».

Pythonmain.py
dias = ["lun", "mar", "mie", "jue", "vie", "sab", "dom"]

# En PHP: array_slice($dias, 0, 3)
print(dias[0:3])
print(dias[:3])

# En PHP: array_slice($dias, 5)
print(dias[5:])

# En PHP: array_slice($dias, -2)
print(dias[-2:])

# Cada dos: lun, mie, vie, dom.
print(dias[::2])

# En PHP: array_reverse($dias)
print(dias[::-1])

# Una rebanada que se pasa no falla: devuelve lo que haya.
print(dias[10:20])
PHP 8.5index.php
<?php
declare(strict_types=1);

$dias = ["lun", "mar", "mie", "jue", "vie", "sab", "dom"];

print_r(array_slice($dias, 0, 3));
print_r(array_slice($dias, -2));
print_r(array_reverse($dias));
Pythonmain.py
dias = ["lun", "mar", "mie", "jue", "vie", "sab", "dom"]

print(dias[0:3])
print(dias[-2:])
print(dias[::-1])

¿Por qué? · En PHP no existe

¿Por qué el final de la rebanada no se incluye?

Porque así las cuentas salen solas. dias[0:3] tiene 3 - 0 = 3 elementos. Y dias[:3] + dias[3:] te devuelve la lista entera, sin huecos ni repetidos: lo que sale por un lado entra por el otro.

En PHP array_slice pide una longitud (array_slice($a, 2, 3) son tres elementos desde el 2); en Python pides dónde empieza y dónde acaba. Es como cortar una cuerda marcando dos puntos en vez de decir cuántos centímetros.

4 · Ordenar: sorted y sort

Hay dos formas. sorted(lista) es una función que te da una lista nueva ordenada y deja la original como estaba. lista.sort() es un método que ordena la propia lista (devuelve None, ya sabes por qué). Para ordenar por otra cosa que no sea el propio valor, pasas key=: una función que dice «ordena por esto».

Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "prioridad": 2},
    {"titulo": "Pagar la luz", "prioridad": 3},
    {"titulo": "Regar", "prioridad": 1},
]

# En PHP: usort($tareas, fn($a, $b) => $b["prioridad"] <=> $a["prioridad"]);
por_prioridad = sorted(tareas, key=lambda t: t["prioridad"], reverse=True)
for t in por_prioridad:
    print(t["prioridad"], t["titulo"])

# sorted no toca la original.
print(tareas[0]["titulo"])

# En PHP: sort($titulos);
titulos = ["Regar", "Barrer", "Comprar pan"]
titulos.sort()
print(titulos)
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = [
    ["titulo" => "Comprar pan", "prioridad" => 2],
    ["titulo" => "Pagar la luz", "prioridad" => 3],
    ["titulo" => "Regar", "prioridad" => 1],
];

usort($tareas, fn (array $a, array $b): int => $b["prioridad"] <=> $a["prioridad"]);

foreach ($tareas as $t) {
    echo $t["prioridad"] . " " . $t["titulo"] . PHP_EOL;
}
Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "prioridad": 2},
    {"titulo": "Pagar la luz", "prioridad": 3},
    {"titulo": "Regar", "prioridad": 1},
]

tareas.sort(key=lambda t: t["prioridad"], reverse=True)

for t in tareas:
    print(t["prioridad"], t["titulo"])

lambda t: t["prioridad"] es una función de una línea sin nombre (la lección de lambda llega en el módulo 03). Aquí basta con leerla como «para cada tarea t, mira su prioridad». Es mucho más corta que el usort con <=> de PHP porque Python no compara de dos en dos: calcula una clave por elemento y ordena por ella.

5 · Comprensiones: una lista descrita en una línea

Una comprensión construye una lista nueva diciendo qué quieres de cada elemento y, si hace falta, qué filtro pasa. Se lee casi como una frase: «esto, por cada tarea en tareas, si cumple tal cosa».

Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "hecha": False},
    {"titulo": "Pagar la luz", "hecha": True},
    {"titulo": "Regar", "hecha": False},
]

# En PHP: array_map(fn($t) => $t["titulo"], $tareas)
titulos = [t["titulo"] for t in tareas]
print(titulos)

# En PHP: array_filter($tareas, fn($t) => !$t["hecha"])
pendientes = [t for t in tareas if not t["hecha"]]
print(len(pendientes))

# Las dos cosas a la vez: los títulos en mayúsculas de lo que falta.
faltan = [t["titulo"].upper() for t in tareas if not t["hecha"]]
print(faltan)
PHP 8.5index.php
<?php
declare(strict_types=1);

$tareas = [
    ["titulo" => "Comprar pan", "hecha" => false],
    ["titulo" => "Pagar la luz", "hecha" => true],
    ["titulo" => "Regar", "hecha" => false],
];

$faltan = array_map(
    fn (array $t): string => strtoupper($t["titulo"]),
    array_values(array_filter($tareas, fn (array $t): bool => !$t["hecha"])),
);

echo implode(", ", $faltan) . PHP_EOL;
Pythonmain.py
tareas = [
    {"titulo": "Comprar pan", "hecha": False},
    {"titulo": "Pagar la luz", "hecha": True},
    {"titulo": "Regar", "hecha": False},
]

faltan = [t["titulo"].upper() for t in tareas if not t["hecha"]]

print(", ".join(faltan))

¿Por qué? · En PHP no existe

¿Por qué una comprensión y no map y filter? En PHP solo hay array_map y array_filter

En PHP, para quedarte con los pendientes y transformarlos, anidas array_map(array_filter(...)) y encima array_filter conserva las claves originales, así que casi siempre acabas añadiendo array_values para reindexar. Se lee de dentro hacia fuera.

La comprensión se lee de izquierda a derecha, igual que lo dirías en voz alta, y siempre produce una lista bien indexada. Python tiene map y filter también (módulo 03), pero casi todo el mundo usa comprensiones.

6 · Cuidado: b = a no copia la lista

En PHP, $b = $a copia el array: cambiar uno no cambia el otro. En Python una variable es una etiqueta pegada a un objeto, y b = a pega una segunda etiqueta al mismo objeto. Hay una sola lista con dos nombres.

Pythonmain.py
a = ["Comprar pan", "Regar"]

# En PHP: $b = $a;  (copia)
b = a
b.append("Barrer")
print(a)
print(a is b)

# Copia de verdad: una lista nueva con los mismos elementos.
c = a.copy()
c.append("Planchar")
print(a)
print(c)

# Otra forma de copiar, con una rebanada vacía.
d = a[:]
print(d == a, d is a)
PHP 8.5index.php
<?php
declare(strict_types=1);

$a = ["Comprar pan", "Regar"];

$b = $a;
$b[] = "Barrer";

echo count($a) . PHP_EOL;
echo count($b) . PHP_EOL;
Pythonmain.py
a = ["Comprar pan", "Regar"]

b = a.copy()
b.append("Barrer")

print(len(a))
print(len(b))

Hay una variante todavía más traicionera: repetir una lista de listas. [[]] * 3 no crea tres listas vacías, crea la misma lista vacía tres veces.

Pythonmain.py
# Tres columnas de un tablero de tareas: baja, media, alta.
mal = [[]] * 3
mal[0].append("Regar")
print(mal)

# Una lista nueva por columna con una comprensión.
bien = [[] for _ in range(3)]
bien[0].append("Regar")
print(bien)

¿Por qué? · En PHP no existe

¿Por qué Python no copia al asignar? En PHP sí

Porque copiar es caro. Una lista de un millón de elementos se copiaría entera cada vez que la pasas a una función o la guardas en otra variable. PHP evita ese coste con copy-on-write (copia solo cuando cambias algo, de forma invisible); Python elige que tú decidas cuándo copiar.

A cambio hay que saberlo: asignar comparte, .copy() copia. Y .copy() es una copia superficial: si la lista contiene otras listas, esas se siguen compartiendo. Todo esto se explica a fondo en el módulo 04 (referencias y mutabilidad).

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Añade y saca

Con la lista tareas ya escrita, añade Repasar Python al final y después saca la primera tarea (la que está en la posición 0). Imprime la lista: debe salir ['Llamar al banco', 'Repasar Python']. Son $tareas[] = ... y array_shift de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. list es el array indexado de PHP: ["a", "b"] sin claves, ordenado, mutable y con repetidos.
  2. Añadir y quitar: append, insert, extend, pop, remove ($a[], array_unshift, array_merge, array_pop, unset). Devuelven None: no escribas a = a.append(x).
  3. Rebanadas a[1:3], a[-1], a[::-1] (array_slice, end, array_reverse): el final no entra y pasarse no falla.
  4. sorted(a, key=...) devuelve una lista nueva y a.sort(key=...) ordena en el sitio (el usort de PHP, sin comparar de dos en dos).
  5. [f(t) for t in ts if cond] hace de array_map + array_filter en una línea y siempre reindexa.
  6. b = a no copia (en PHP sí): usa a.copy(), y cuidado con [[]] * 3.

Para recordarlo: «Añadir, Quitar, Rebanar, Ordenar, Comprender»

AAñadir
append · insert · extend
QQuitar
pop · remove · del
RRebanar
a[1:3] · a[::-1]
OOrdenar
sorted(a, key=...)
CComprender
[x for x in a if ...]

Cinco verbos para una lista: Añadir, Quitar, Rebanar, Ordenar y Comprender. Y una frase para el peligro: «asignar es compartir, copiar es .copy()».