2.2. Variables y tipos básicos

Una variable es un nombre que asocias a un valor con el operador =. Tras la asignación, el nombre puede usarse en cualquier lugar donde pueda usarse el valor:

width = 320
height = 240
pixels = width * height
print(pixels)               # prints 76800

El lado derecho de = se evalúa primero, y luego el resultado se asocia al nombre de la izquierda. Leer un nombre que nunca se asignó lanza NameError.

Una variable es solo una etiqueta. Apunta a un valor; el valor reside en otro lugar, y el mismo valor puede tener cualquier número de etiquetas.

Tres etiquetas apuntando a tres valores en cajas; reasignar una etiqueta mueve la flecha, no el valor.

Las variables son etiquetas que apuntan a valores. Reasignar una variable mueve la etiqueta; no cambia el valor al que la etiqueta solía apuntar.

2.2.1. Reglas de nomenclatura

  • Los nombres comienzan con una letra o un guion bajo y pueden contener letras, dígitos y guiones bajos. frame_count y _internal son válidos; 1st_frame es un error de sintaxis.

  • Los nombres distinguen entre mayúsculas y minúsculas: Width y width son dos variables diferentes.

  • Evita reutilizar nombres incorporados como list, str, id() o print(): ensombrecerlos no genera un error, pero la función incorporada original queda inaccesible durante el resto del script.

  • Convención: snake_case para variables y funciones, ALL_CAPS para las constantes que no piensas cambiar, CamelCase para los nombres de clases.

2.2.2. Tipos básicos

Cada valor en Python tiene un tipo que determina qué operaciones admite. Los cuatro tipos que escribirás con más frecuencia son:

  • int – números enteros, positivos o negativos. Los enteros de MicroPython crecen tanto como la memoria lo permita. Los literales se escriben como dígitos sencillos: 0, 42, -7. Los literales hexadecimales (0x1A), octales (0o17) y binarios (0b1010) también son válidos y útiles para registros y máscaras de bits.

  • float – números con un punto decimal o un exponente: 3.14, 1.0, -0.5, 2e6 (= 2 000 000.0). Todos los flotantes de la cámara son IEEE 754 de 32 bits, precisos hasta unos siete dígitos significativos.

  • bool – uno de los dos literales True o False (fíjate en el uso de mayúsculas).

  • str – texto, escrito como caracteres entre comillas simples o dobles: "hello", 'OpenMV'. Ambos estilos de comillas son equivalentes; elige el que te permita evitar escapar los caracteres de comillas que aparezcan dentro de la cadena.

También hay un quinto valor que conviene conocer de inmediato:

  • None – el único valor del tipo NoneType. Se usa para significar «sin valor» o «aún no establecido». Las funciones que no devuelven explícitamente nada devuelven implícitamente None.

2.2.3. Comprobar y convertir tipos

La función incorporada type() devuelve el tipo de cualquier valor:

>>> type(42)
<class 'int'>
>>> type(3.14)
<class 'float'>
>>> type("hello")
<class 'str'>

Cada tipo también actúa como una función de conversión. Pásale un valor de un tipo diferente y obtendrás de vuelta el valor equivalente del nuevo tipo, cuando la conversión está bien definida:

>>> int("42")
42
>>> int(3.9)
3                           # truncates toward zero, not rounds
>>> float("1.5")
1.5
>>> str(255)
'255'
>>> bool(0), bool(1), bool("")
(False, True, False)

Las conversiones que no están bien definidas lanzan ValueError:

>>> int("hello")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid syntax for integer with base 10

2.2.4. Reasignación y tipado dinámico

Un nombre puede reasignarse a un valor de cualquier tipo en cualquier momento. Lo siguiente es válido:

x = 42
x = "now I'm a string"
x = 3.14

Python no asocia una variable a un tipo. El código que depende de que x sea un entero simplemente espera un entero en el punto donde lo usa; si recibe otra cosa, obtienes un TypeError en tiempo de ejecución.

Nota

Reasignar x no cambia el valor al que apuntaba la asociación anterior. Si dos nombres comparten el mismo valor, reasignar uno no afecta al otro:

a = [1, 2, 3]
b = a                       # both point at the same list
a = "different now"
print(b)                    # still [1, 2, 3]

Mutar un valor compartido es diferente: un método como list.append cambia el valor al que apunta la asociación, de modo que cualquier otro nombre que apunte a ese mismo valor ve el cambio.