Qué es Python y cómo ejecuta tu código

Un archivo de tres líneas con un ) de más en su última línea no imprime nada, mientras que el mismo archivo con una división entre cero en esa línea imprime sus dos primeras líneas antes de detenerse. La diferencia viene de los dos pasos de ejecutar un archivo: Python primero lo compila entero y después lo ejecuta.

Python is a general-purpose programming language with a small, readable syntax: blocks are marked by indentation rather than braces, and you do not declare the types of variables. It comes with a large biblioteca estándarstandard library: The modules that come with Python itself, such as json, pathlib and sqlite3, documented in the library reference. sys.stdlib_module_names lists their names for the Python that runs, whether or not each one works there. More in “A tour of the Python standard library” (en inglés), so many everyday jobs (reading files, handling dates, talking to the web) need nothing extra. People use it for scripts and automation, web back ends, data analysis, machine learning, teaching and much more. “Python” names two things: the language (the rules for what a program means, written down in the language reference) and the implementaciónimplementation: A program that runs code written in Python, such as CPython, PyPy or MicroPython. The language reference says what code means; each implementation decides how to run it and fills in what the reference leaves open, such as when objects are freed., the program that actually runs your code. Most of the time the implementation is CPython, and this lesson is about what it does.

Ejecutar un archivo lo compila entero antes de que se ejecute ninguna línea

Cuando ejecutas python3 hello.py, pasan tres cosas, en este orden:

1. El intérprete lee tu código fuente, el texto de hello.py.
2. Compila el archivo entero a bytecodeLas instrucciones compactas en las que CPython compila un archivo de Python antes de ejecutarlas en su máquina virtual. Cambian de una versión de funcionalidades a la siguiente, y el módulo dis las muestra.: instrucciones compactas para la máquina virtual propia de Python. Si el archivo tiene un error de sintaxis, se detiene aquí, antes de que se ejecute una sola línea.
3. Después, la máquina virtualLa parte de CPython que ejecuta el bytecode, una instrucción tras otra. Los errores que solo aparecen mientras el programa se ejecuta, como una división entre cero, se lanzan aquí. ejecuta el bytecode, una instrucción tras otra. Los errores que solo aparecen mientras el programa se ejecuta, como dividir entre cero, ocurren en este paso.

Estos son los dos archivos del principio de la lección. Solo se diferencian en la línea 3: uno divide entre cero y el otro tiene un ) de más. Mira la salida de cada pestaña y después recorre paso a paso lo que hace CPython con los dos archivos:

print("Line 1 ran")
print("Line 2 ran")
print(10 / 0)

Line 1 ran
Line 2 ran

Traceback (most recent call last):
  File "late_zero_division.py", line 3, in <module>
    print(10 / 0)
          ~~~^~~
ZeroDivisionError: division by zero

print("Line 1 ran")
print("Line 2 ran")
print(10 / 2))

  File "late_syntax_error.py", line 3
    print(10 / 2))
                 ^
SyntaxError: unmatched ')'

La división es gramática correcta, así que el archivo entero se compiló y sus dos primeras líneas se ejecutaron antes de que la máquina virtual llegara a la línea 3. El paréntesis de más rompió la gramática, así que la compilación se detuvo y no se ejecutó nada, ni siquiera la línea 1. Abre la segunda pestaña, pulsa Editar, borra el ) de más y pulsa Ejecutar: ahora se imprimen las tres líneas.

No hay una orden separada de “compilar y después ejecutar”, como en C o en Java: los dos pasos ocurren cada vez que ejecutas el archivo. El módulo dis de la biblioteca estándar (abreviatura de disassembler, desensamblador) te muestra el bytecode de una función:

import dis


def add(a, b):
    return a + b


dis.dis(add)

  4           RESUME                   0

  5           LOAD_FAST_BORROW_LOAD_FAST_BORROW 1 (a, b)
              BINARY_OP                0 (+)
              RETURN_VALUE

Cada línea de la salida es una instrucción. RESUME es contabilidad interna al principio de cada función; después, la máquina virtual toma los dos argumentos, los suma con el operador + y devuelve el resultado. Nunca necesitas leer bytecode para escribir Python, pero explica por qué un error de sintaxis en cualquier parte de un archivo impide que se ejecute el archivo entero.

Los módulos importados guardan su bytecode para la siguiente ejecución

Cuando un programa importa un módulo (otro archivo .py), CPython guarda el bytecode de ese módulo en una carpeta llamada __pycache__La carpeta en la que CPython guarda el bytecode de los módulos importados, en archivos como greeting.cpython-314.pyc. Un archivo se vuelve a compilar cuando cambia su código fuente, y la carpeta se puede borrar sin problema. junto a él, para que la siguiente ejecución no tenga que volver a compilarlo. Aquí tienes un programa en dos archivos: main.py, el programa que ejecutas, y greeting.py, el módulo que importa.

import greeting

print(greeting.greet("Asha"))

Hello, Asha!

def greet(name):
    return "Hello, " + name + "!"

Después de que python3 main.py se haya ejecutado una vez, __pycache__ contiene greeting.cpython-314.pyc. La parte cpython-314 dice qué implementación y qué versión lo escribieron, para que varias versiones de Python puedan compartir una carpeta sin mezclar sus archivos. El archivo que ejecutas directamente, main.py, se compila cada vez y no se guarda en caché.

Antes de usar un archivo de caché, CPython comprueba que sigue coincidiendo con su código fuente. Cuando escribe el archivo, anota dentro la fecha de última modificación y el tamaño del código fuente; si alguno ha cambiado desde entonces, el módulo se vuelve a compilar y el archivo de caché se sustituye. Recorre tres ejecuciones del programa, con un cambio en greeting.py antes de la tercera:

La segunda ejecución cargó el bytecode de la caché, y el cambio hizo que la tercera volviera a compilar greeting.py, sin que nadie borrara nada. La parte del nombre que dice qué Python escribió el archivo es la etiqueta de caché del Python que se ejecuta, y la biblioteca estándar puede calcular la ruta completa para cualquier archivo fuente:

import importlib.util
import sys

print("Cache tag:", sys.implementation.cache_tag)
print(importlib.util.cache_from_source("greeting.py"))

Cache tag: cpython-314
__pycache__/greeting.cpython-314.pyc

Pulsa Editar, pide "marks.py" en lugar de "greeting.py" y vuelve a ejecutarlo: la carpeta y la etiqueta se mantienen, solo cambia el nombre del módulo.

Puedes borrar las carpetas __pycache__ cuando quieras; Python las vuelve a escribir cuando las necesita. Déjalas fuera del control de versiones (añade __pycache__/ a tu .gitignore).

Una versión de funcionalidades cada año, cada una con correcciones durante cinco años

Todo el código actual de Python es Python 3. Python 2 no recibe correcciones desde hace años, pero su código todavía aparece en respuestas antiguas en internet, y falla en Python 3:

# Python 2 code that still turns up in old answers online
print "Hello, world"

  File "python2_print.py", line 2
    print "Hello, world"
    ^^^^^^^^^^^^^^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Python 3 informa de un SyntaxError e incluso sugiere la solución: print es una función, así que necesita paréntesis. Otras señales de código de Python 2 son raw_input() (ahora input()) y xrange() (ahora range()).

Dentro de Python 3, las versiones se numeran 3.menor.micro:

• Una versión de funcionalidadesUna versión de Python que añade funcionalidades al lenguaje, como 3.14 o 3.15. Sale una cada año y recibe soporte durante cinco años: unos dos de versiones de corrección de errores y después solo correcciones de seguridad. (3.13, 3.14, 3.15…) añade funcionalidades al lenguaje y llega más o menos una vez al año.
• Después, cada versión de funcionalidades recibe versiones de corrección de erroresUna versión como 3.14.8 que corrige errores de una versión de funcionalidades y no cambia ninguna de sus funcionalidades, así que el código escrito para 3.14.2 normalmente funciona en ella sin cambios. (3.14.1, 3.14.2…) durante unos dos años, y después solo correcciones de seguridad, hasta unos cinco años después de su salida. La Python Developer’s Guide recoge el estado de cada versión.
• Una versión de corrección de errores no cambia funcionalidades, así que el código escrito para 3.14.2 normalmente funciona sin cambios en 3.14.8.

El ciclo anual, descrito en la PEP 602, da a cada versión de funcionalidades la misma vida. Recorre las fases de una, 3.14, desde su primera versión alfa hasta su fin de vida:

Las fases anteriores a la versión de funcionalidades son para hacer pruebas; tu código debe ir en una versión final que todavía tenga soporte. Un programa puede leer qué versión de funcionalidades lo ejecuta, y en qué fase de esa vida está, en sys.version_info:

import sys

major, minor = sys.version_info.major, sys.version_info.minor
print("Feature release:", f"{major}.{minor}")
print("Release level:", sys.version_info.releaselevel)

Feature release: 3.14
Release level: final

Este curso está escrito para Python 3.14, y sus ejemplos se ejecutan con CPython 3.14.8.

CPython ejecuta tu código, y otras implementaciones lo ejecutan en otros lugares

El Python que descargas de python.org es CPython, la implementación de referencia, escrita en C. Otras ejecutan el mismo lenguaje en otros lugares:

• PyPy añade un compilador just-in-timeUn compilador que convierte en código máquina las partes de un programa que más se ejecutan, mientras el programa se ejecuta, para que esas partes vayan más rápido cuanto más tiempo lleva en marcha., que puede hacer mucho más rápidos los programas que se ejecutan durante mucho tiempo.
• MicroPython es un Python pequeño para microcontroladores.
• Pyodide is CPython compiled to WebAssemblyWebAssembly: A portable binary format for programs, which browsers and runtimes such as Node.js run in a sandbox. Programs written in C, such as CPython, can be compiled to it., so it runs inside a web browser, on your own device.

Un programa puede preguntar qué implementación, qué versión y qué plataforma lo están ejecutando:

import sys

print("Implementation:", sys.implementation.name)
print("Version:", sys.version.split()[0])
print("Platform:", sys.platform)

Implementation: cpython
Version: 3.14.8
Platform: darwin

Implementation: cpython
Version: 3.14.2
Platform: emscripten

Pulsa Ejecutar y compara las dos respuestas. El Python del navegador sigue llamándose cpython, porque Pyodide es CPython compilado para el navegador; solo la plataforma dice dónde se ejecuta. Cada implementación pone su propio nombre en sys.implementation.name, siempre en minúsculas, así que un programa que necesite saberlo pregunta ahí, y pregunta a sys.platform cuando necesita saber si se ejecuta en un navegador.

Practica: informa de qué Python se ejecuta

Escribe describe_runtime(), que le dice a un programa qué implementación y qué versión de funcionalidades lo ejecutan y si se ejecuta en un navegador. Sus pruebas de ejemplo se ejecutan aquí, en tu navegador, así que aquí la respuesta a “¿en un navegador?” es True:

{'implementation': 'cpython', 'major_minor': '3.14', 'in_browser': False}

import sys


def describe_runtime():
    """Return which Python runs this program: its implementation, feature release and whether it runs in a browser."""
    # Replace this line with your code.
    return {}

import sys

from describe import describe_runtime


def test_three_keys():
    """returns a dictionary with exactly the three keys"""
    result = describe_runtime()
    assert isinstance(result, dict)
    assert sorted(result) == ["implementation", "in_browser", "major_minor"]


def test_implementation():
    """names the implementation in lower case"""
    assert describe_runtime()["implementation"] == sys.implementation.name


def test_major_minor():
    """gives the feature release as text, such as 3.14"""
    expected = f"{sys.version_info.major}.{sys.version_info.minor}"
    assert describe_runtime()["major_minor"] == expected


def test_in_browser():
    """says whether the program runs in a browser, as True or False"""
    assert describe_runtime()["in_browser"] is (sys.platform == "emscripten")

Para terminar, una ronda de preguntas sobre la compilación, la caché, las versiones y las implementaciones. La de las cuatro que peor respondas es la que se pregunta primero, y cada respuesta se explica en cuanto la das:

Preguntas de entrevista

Calentamiento (júnior): ¿Python es un lenguaje compilado o interpretado?

Ninguna de las dos palabras describe el lenguaje en sí: compilar e interpretar es lo que hace una implementación, y CPython hace las dos cosas. Cuando ejecutas un archivo, primero compila el archivo entero a bytecode, instrucciones para su propia máquina virtual; por eso un error de sintaxis en la última línea detiene el archivo antes de su primera línea. Después, la máquina virtual interpreta ese bytecode, una instrucción cada vez, y ahí es donde aparecen los errores en tiempo de ejecución, como una división entre cero. El bytecode de los módulos importados se guarda en caché en __pycache__, así que las ejecuciones siguientes no tienen que compilarlos, pero nada se convierte en código máquina por adelantado, como haría un compilador de C. Otras implementaciones son distintas: PyPy añade un compilador just-in-time que convierte en código máquina el código que más se ejecuta, mientras el programa se ejecuta.

Dos preguntas más difíciles parten de esta lección: un bytecode que sobrevivió a una corrección, y una versión de Python cuyo soporte ha terminado. Piensa tu primer paso antes de abrir cada una:

Para recordar

• Ejecutar un archivo .py lo compila a bytecode y después ejecuta el bytecode en la máquina virtual de CPython; un error de sintaxis detiene el archivo antes de que se ejecute nada.
• Los módulos importados guardan su bytecode en __pycache__; los archivos se pueden borrar sin problema y no van en el control de versiones. CPython vuelve a compilar un módulo cuando ha cambiado la fecha de modificación o el tamaño de su código fuente.
• Las versiones de funcionalidades llegan más o menos una vez al año y tienen soporte durante unos cinco años; las versiones de corrección de errores no cambian funcionalidades. Este curso usa Python 3.14.
• CPython es la implementación de referencia; PyPy, MicroPython y Pyodide ejecutan el mismo lenguaje en otros lugares.