Cómo funciona el lenguaje

TIPOS DE DATOS

Qué tipos existen

Los básicos están todos — con dos ausencias deliberadas que cambian cómo se escribe cierto código.

Enteros, decimales, texto, booleanos

int, float, str, bool — se comportan como en Python real, con una excepción: bool NO es subtipo numérico de int. True + 1 da TypeError aquí; en Python real da 2. Los literales True/False son palabras reservadas de verdad — a diferencia de pi/e (que son solo constantes globales que una variable propia puede tapar), no hay forma de reasignarlos.

Listas y diccionarios

Literal normal: [1, 2, 3], {"a": 1}. Se comportan como en Python real, incluido indexado, slicing y los métodos usuales.

Tuplas — de verdad, no listas disfrazadas

(a, b) es una tupla real e inmutable (intentar .append() o asignar por índice falla). (5,) es la forma de tupla de un solo elemento; (5) sin coma sigue siendo solo 5 agrupado por paréntesis — igual que en Python real.

No existe `None`

Este intérprete no tiene un valor "nada". Por eso diccionario.get(clave, valor_por_defecto) exige siempre el valor por defecto, y una función sin return no devuelve None en silencio: si se intenta usar su resultado, el programa se detiene con un error claro en vez de propagar un None silencioso.

No existe `set`

No hay literal {1, 2, 3} ni función set(...) — { siempre se interpreta como el inicio de un diccionario.

CONTROL DE FLUJO

Qué se puede controlar

Todo lo esperable de un curso introductorio, incluido try/except — con match/case como única ausencia.

if / elif / else, while, break, continue

Igual que Python real, sin sorpresas.

for — tres formas

for i in range(...) (1, 2 o 3 argumentos), for x in lista_o_tupla_o_texto, y for clave in diccionario (recorre las claves, nunca los valores — igual que Python real).

try / except

Atrapa errores reales del lenguaje (TypeError, ZeroDivisionError, etc.). La diferencia con Python real: la variable del except recibe el mensaje de error como texto, no un objeto de excepción con atributos.

No existe `match`/`case`

El intérprete no reconoce esa sintaxis en absoluto.

FUNCIONES

def, lambda y sus límites

Funciones puras con parámetros y return — sin las partes más avanzadas del scoping de Python real.

def, return, recursión

Funciona, incluida la recursión (factorial, fibonacci, etc.) — pero con un límite de profundidad bajo a propósito: 40 llamadas anidadas, muy por debajo del ~1000 de Python real. Pasarse da RecursionError.

Sin parámetros por defecto ni *args/**kwargs

Todos los argumentos son posicionales y obligatorios — llamar con un número distinto de argumentos da TypeError siempre.

Alcance de variables: sin closures verdaderas

Asignar una variable dentro de una función SIEMPRE crea una variable local — nunca modifica una variable global del mismo nombre, incluso sin la palabra clave global de por medio (que no existe). Y como el "marco" de una función se descarta apenas termina de ejecutarse, una función anidada no puede guardarse y usarse después recordando una variable de la función que la creó, como sí puede una clausura real de Python.

lambda

Una sola expresión, sin bloques ni return — igual de simple que en Python real usado así.

No existe `class`

No hay programación orientada a objetos con clases propias del jugador — ningún tipo del lenguaje.

OPERADORES Y EXPRESIONES

Lo que se puede escribir en una expresión

Aritmética, comparación, comprensión de listas — con algunos recortes puntuales frente a Python real.

Aritmética

+ - * / // % **. // y % son exclusivos de enteros — con float dan TypeError (usa / para decimales). / sí acepta cualquier combinación de int/float y siempre da un resultado decimal.

Comparación, lógicos, ternario

== != < > <= >=, and/or/not con cortocircuito real, y el ternario x if condición else y — todos como en Python real. Nota: < > <= >= solo están implementados entre números o solo entre texto — comparar listas/tuplas/diccionarios con esos operadores da TypeError (Python real sí compara listas de forma lexicográfica).

Asignación aumentada

+= -= *= /= //= %= — no existe **=.

Slicing sin paso

lista[1:3] funciona igual que en Python real (fuera de rango se recorta, no truena), pero no acepta un tercer valor de paso — lista[::2] no es sintaxis válida aquí.

Comprensión de listas

[x*2 for x in lista] y con filtro [x for x in lista if x > 0] — funcionan, pero a diferencia de Python real, la variable del for de la comprensión NO tiene su propio scope: se filtra afuera y puede pisar una variable existente con el mismo nombre.

Sin f-strings ni .format()

Solo comillas simples/dobles normales — para armar texto con una variable adentro, hay que concatenar con + y str(...).

MÓDULOS

No existe import

math y random están siempre disponibles, sin ningún paso previo.

No hay ninguna forma de import en el lenguaje. En su lugar, lo que en Python real vendría de math (pi, sqrt, sin, cos, etc.) y de random (random(), randint(a, b), gauss(media, desvío), random_seed(x)) es directamente global, disponible en cualquier programa. Ojo con pi/e: si el jugador ya usó ese nombre para su propia variable, esa variable gana sobre la constante.

ERRORES

Qué truena y cómo se ve

Nombres de excepción en inglés (como Python real), descripción siempre en español.

El intérprete lanza TypeError, ValueError, IndexError, KeyError, NameError, ZeroDivisionError, AttributeError, RecursionError, RuntimeError y SyntaxError — el nombre va en inglés, igual que en Python real, pero el mensaje que lo acompaña está siempre en español y explica qué pasó, no solo el nombre técnico. Dentro de un except error:, esa variable recibe el mensaje completo como texto — no un objeto de excepción con atributos como en Python real.

LÍMITES DELIBERADOS

Topes pensados contra "se cuelga"

Todos existen para que un error de lógica del jugador (un ciclo infinito, una recursión sin caso base) no congele el navegador o la app — no son un capricho arbitrario.

Límite	Valor por defecto
Profundidad de recursión / llamadas anidadas	40
Pasos totales antes de "ciclo infinito"	200 000
Tortugas simultáneas (`Turtle()`)	150
Celdas totales de `Patches` (filas × columnas)	2 500 (ej. 50×50)
Puntos por serie de `plot`/`plot_xy`	2 000
Series distintas de `plot` / `plot_xy`	20 / 20
Histogramas distintos / valores por histograma	20 / 5 000
Monitores / sliders distintos	40 / 20

Estos topes son configurables por quien corre el programa (más generosos en escritorio que en un reto curado), y el detector de "ciclo infinito" cede el hilo a la interfaz cada tanto para no congelarla durante simulaciones pesadas.

RESUMEN

Diferencias con Python real, todas juntas

Para quien ya conoce Python y quiere la lista corta antes de probar.

// y % solo aceptan enteros (con float truenan).
// con negativos trunca hacia cero en vez de redondear hacia abajo (-7 // 3 da -2, no -3 como en Python real).
round(2.5) no usa redondeo bancario — redondea el empate hacia arriba.
bool no es subtipo de int (True + 1 truena).
range(), enumerate(), map(), filter() se materializan de una vez como listas reales, no son perezosos.
Slicing sin paso (a[::2] no existe).
No hay comparación de orden (<, >) entre listas/tuplas/diccionarios.
La comprensión de listas no tiene su propio scope — su variable se filtra afuera.
No hay closures verdaderas ni parámetros por defecto ni *args/**kwargs.
No existen None, set, class, import, f-strings ni .format().
Límite de recursión bajo a propósito (40, no ~1000).