Variables y tipos de datos en MicroPython

5 min
Iniciación

Continuamos viendo la sintaxis básica de MicroPython. En este tutorial veremos cómo trabajar con variables y tipos de datos.

Aunque MicroPython es una versión reducida de Python, básicamente comparte los mismos tipos y forma de trabajar con variables que su “hermano mayor”.

Así que vamos a repasarlo brevemente. Cuando haya alguna diferencia importante entre MicroPython y Python, os lo indico.

Si quieres aprender más consulta,

¿Qué son las variables?

Una variable es un espacio en la memoria que almacena un valor que puede cambiar durante la ejecución de un programa.

En Python y en MicroPython, las variables se declaran dinámicamante, y su tipo se infiere automáticamente en función del valor que se le asigna (es decir, que no es necesario especificar su tipo).

mi_variable = 10

En este caso,

mi_variable es una variable que almacena el valor 10.
MicroPython infiere que el tipo de mi_variable es un entero (int).

Reasignación de variables

Una de las características de Python (y compartida, de MicroPython) es que las variables pueden cambiar de tipo durante la ejecución del programa.

mi_variable = 10      # Ahora es un entero
mi_variable = "Hola"  # Ahora es una cadena de texto

Esto es posible porque Python es un lenguaje de tipado dinámico. Es decir, que el tipo de las variables no está fijado.

Sin embargo, en MicroPython, donde los recursos son limitados, es recomendable evitar cambios innecesarios de tipo para optimizar el uso de memoria.

Tipos de datos en MicroPython

MicroPython soporta los tipos de datos básicos de Python, aunque con algunas limitaciones debido a las restricciones de hardware.

A continuación, veremos los tipos de datos más comunes y cómo se utilizan.

Tipo de Dato	Descripción	Ejemplo
Enteros (`int`)	Números sin decimales	`42`
Flotantes (`float`)	Números con decimales	`3.14`
Cadenas (`str`)	Secuencias de caracteres	`"Hola, MicroPython"`
Booleanos (`bool`)	Valores de verdad (`True` o `False`)	`True` / `False`

Números enteros

Enteros (`int`)

Los enteros son números sin parte decimal. En MicroPython, los enteros pueden ser de tamaño arbitrario. Pero en la práctica, están limitados mucho más limitados por la memoria disponible (que es mucho menos que en un PC).

entero = 42

Veamos las operaciones que podemos hacer con números enteros

a = 10
b = 3

suma = a + b       # 13
resta = a - b      # 7
multiplicacion = a * b  # 30
division = a / b   # 3.333... (en Python 3, la división siempre devuelve un float)
division_entera = a // b  # 3 (división entera)
modulo = a % b     # 1 (resto de la división)

Números fraccionarios

Números de punto flotante

Los números de punto flotante son números con parte decimal. En MicroPython, los float suelen ser de 32 bits (en Python suelen ser 64bits), lo que significa que tienen una precisión limitada.

flotante = 3.14

Las operaciones que podemos hacer con flotantes, pues las de siempre 😆

a = 5.0
b = 2.0

suma = a + b       # 7.0
resta = a - b      # 3.0
multiplicacion = a * b  # 10.0
division = a / b   # 2.5

Cadenas de texto

Las cadenas de texto son secuencias de caracteres. Igual que en Python, en MicroPython las cadenas se pueden definir utilizando comillas simples (') o dobles (").

cadena = "Hola, MicroPython"

Repasemos algunas operaciones comunes con cadenas

saludo = "Hola"
nombre = "MicroPython"

mensaje = saludo + ", " + nombre  # "Hola, MicroPython"
longitud = len(mensaje)           # 16
subcadena = mensaje[0:4]          # "Hola"

Booleanos

Los booleanos son un tipo de dato que solo puede tener dos valores: True (verdadero) o False (falso).

es_verdadero = True
es_falso = False

Son útiles para expresar condiciones y tomar decisiones en el código. Las operaciones comunes que podemos realizar con booleanos son,

a = True
b = False

and_logico = a and b  # False
or_logico = a or b    # True
not_logico = not a    # False

Colecciones

Otro de los puntos fuertes de Python son sus colecciones dinámicas includas por defecto. MicroPython incorpora practicamente todas las colecciones y características.

Veamos algunas de ellas.

Listas

Las listas son colecciones ordenadas y mutables de elementos. Tanto en Python como MicroPython, las listas son una de las estructuras de datos más queridas y utilziadas debido a su flexibilidad.

mi_lista = [1, 2, 3, 4, 5]

Algunas operaciones comunes con listas

mi_lista = [1, 2, 3]

mi_lista.append(4)       # [1, 2, 3, 4]
mi_lista[0] = 10         # [10, 2, 3, 4]
longitud = len(mi_lista) # 4

Tuplas

Las tuplas son similares a las listas, pero son inmutables, lo que significa que no se pueden modificar después de su creación. Son útiles para almacenar datos que no deben cambiar.

mi_tupla = (1, 2, 3)

Operaciones comunes con tuplas son,

mi_tupla = (1, 2, 3)

primer_elemento = mi_tupla[0]  # 1
longitud = len(mi_tupla)       # 3

Diccionarios

Los diccionarios son colecciones de pares clave-valor. Son útiles para almacenar y recuperar datos de manera eficiente utilizando una clave única.

mi_diccionario = {"clave1": "valor1", "clave2": "valor2"}

Y por último, algunas operaciones comunes con diccionarios

mi_diccionario = {"nombre": "MicroPython", "version": 1.0}

valor = mi_diccionario["nombre"]  # "MicroPython"
mi_diccionario["version"] = 1.1   # Actualiza el valor
mi_diccionario["nuevo"] = "valor" # Añade un nuevo par clave-valor

Es decir, básicamente tenemos los mismos tipos que en Python. Simplemente hay que ser conscientes de que tenemos mucha menos memoria, por lo que no podemos hacer tantas “locuras”