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.

Three labels pointing at three boxed values; reassigning a label moves the arrow, not the value.

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.