Python: inicialización de variables – None, listas y clases

1. Introducción

Python es un lenguaje de programación caracterizado por una sintaxis simple y fácil de leer, y es utilizado por una amplia gama de usuarios, desde principiantes hasta profesionales. Entre ellos, la “inicialización de variables” es uno de los conceptos importantes a los que se enfrentan los que comienzan a aprender Python.

Una variable es un “contenedor con nombre” que sirve para almacenar datos temporalmente dentro de un programa. Y la inicialización se refiere a la operación de asignar un valor inicial a ese contenedor. En Python no es necesario especificar el tipo de forma explícita como en C o Java, pero si no se realiza una inicialización adecuada puede causar errores y afectar la legibilidad y mantenibilidad del código.

Por ejemplo, problemas como “pensé que había inicializado una lista vacía, pero el valor se compartió entre funciones” o “inicialicé con None, pero la intención no quedó clara y provocó un bug” no son poco comunes y a menudo se deben a una falta de comprensión de la inicialización.

En este artículo se explicará de forma sistemática cómo inicializar variables en Python. Desde la inicialización básica de números y cadenas, hasta tipos de datos complejos como listas y diccionarios, y también se cubrirán consideraciones al inicializar en funciones y clases, presentándolo de manera clara y cuidadosa para principiantes.

Si ha buscado con la palabra clave “Python variable inicialización”, encontrará aquí información concreta útil tanto para el trabajo como para el aprendizaje, así que le invitamos a leer hasta el final.

2. ¿Qué es la inicialización de variables en Python?

¿Qué es la inicialización de variables?

«Inicializar una variable» significa asignarle un valor inicial antes de usarla en el programa. En otras palabras, es el primer paso para indicarle al programa «esta variable se usará con este propósito».

Por ejemplo, el siguiente código inicializa la variable count con el entero 0.

count = 0

De esta forma, la variable count puede usarse en cálculos y comparaciones de manera fluida.

Características de la inicialización en Python

Python se considera un «lenguaje de tipado dinámico», por lo que no es necesario especificar el tipo al declarar una variable. Por ejemplo, tanto para enteros como para cadenas, basta escribir de la siguiente manera para usarlos de inmediato.

number = 100        # Inicializado con entero
text = "Hello"      # Inicializado con cadena

En C o Java es necesario especificar el tipo antes de declarar e inicializar una variable, pero en Python no hay esa molestia, lo que permite escribir código de forma más intuitiva.

Sin embargo, esta flexibilidad puede volverse en contra, provocando que se introduzcan tipos de datos inesperados o que se use accidentalmente una variable no inicializada, generando errores.

¿Qué ocurre al usar una variable no inicializada?

En Python, intentar acceder a una variable no inicializada produce el error NameError. A continuación se muestra un ejemplo.

print(user_name)

Como se ve arriba, acceder a user_name sin haberle asignado un valor genera el siguiente error.

NameError: name 'user_name' is not defined

Para evitar este tipo de errores, es importante inicializar siempre las variables antes de usarlas.

Inicialización implícita y explícita

En Python, la «inicialización implícita» es común: basta asignar un valor cuando se necesita. No obstante, para escribir código más seguro y claro, a veces se recomienda realizar una «inicialización explícita» previamente, por ejemplo asignando None o una lista vacía.

Por ejemplo:

data = None  # El valor aún no está definido, pero se aclarará su uso en el futuro.

De este modo, declarar la existencia de la variable con antelación facilita la comprensión en desarrollo en equipo y al revisar el código más tarde.

3. Métodos básicos de inicialización y ejemplos por tipo de dato

En Python, la inicialización de variables es muy simple; basta con asignar un valor. Aquí presentamos los métodos de inicialización para los tipos de datos básicos más usados, acompañados de código concreto.

3.1 Inicialización de números y cadenas

En Python, para inicializar números (enteros y de punto flotante) o cadenas, basta con asignar como se muestra a continuación.

count = 0               # Inicialización de entero
temperature = 36.5      # Inicialización de punto flotante
message = "Hola"        # Inicialización de cadena

Estas inicializaciones rara vez generan errores y son intuitivas. Los números y las cadenas son los fundamentos de Python, así que es conveniente manejarlos con fluidez.

3.2 Inicialización usando None

Cuando aún no se ha decidido un valor o se quiere indicar explícitamente que está ‘vacío’, es útil None.

username = None

Al inicializar de esta forma, se puede indicar en el código que «esta variable recibirá algún valor más adelante, pero por ahora está indefinida».

None es similar al concepto de null, y puede devolverse cuando una función no tiene valor de retorno. También se usa frecuentemente combinado con estructuras condicionales.

if username is None:
    print("El nombre de usuario no está configurado")

3.3 Inicialización de listas, diccionarios y conjuntos

Cuando se manejan varios valores, se utilizan listas, diccionarios o conjuntos (sets). Se inicializan de la siguiente manera.

my_list = []               # lista vacía
my_dict = {}               # diccionario vacío
my_set = set()             # conjunto vacío (※ {} se convierte en diccionario, por lo que tenga cuidado)

Cada uno tiene usos diferentes, así que utilícelos según el caso.

• Lista (list): colección de datos ordenados
• Diccionario (dict): estructura de datos compuesta por pares clave-valor
• Conjunto (set): se usa cuando se desea mantener datos sin duplicados

Por ejemplo, para almacenar una lista de nombres de usuario se usa una lista, para una tabla de correspondencia entre ID de usuario y nombre se usa un diccionario, y para registrar los ID ya procesados es apropiado un conjunto.

3.4 Inicialización de tuplas

Una tupla es una «colección de datos inmutable» que no se puede modificar una vez creada. A continuación se muestra un ejemplo de inicialización.

empty_tuple = ()                  # Tupla vacía
point = (10, 20)                  # Par fijo similar a coordenadas

Al estar garantizada su inmutabilidad, es útil cuando se desea tratar varios valores como un «conjunto fijo».

Como punto de atención, una tupla de un solo elemento requiere una coma, como (value,).

single = (5,)  # Esto crea una tupla con un solo elemento

Resumen: Inicialización adecuada según el uso

Realizar la inicialización adecuada según el tipo de dato ayuda a evitar errores y mejora la legibilidad del código. En particular, estructuras de datos complejas como listas y diccionarios presentan consideraciones al combinarlas con funciones y clases que se describirán más adelante, por lo que es importante comprenderlas bien en la fase básica.

4. Puntos de Atención y Errores Comunes

La inicialización de variables en Python parece sencilla, pero en realidad hay varios puntos donde los principiantes suelen tropezar. Aquí explicamos las “trampas de inicialización” que son fáciles de pasar por alto y que pueden conducir a errores reales o comportamientos inesperados.

4.1 Cuidado con los Argumentos Predeterminados Mutables

Al definir una función en Python, usar listas o diccionarios como argumentos predeterminados puede producir comportamientos inesperados.

El siguiente código parece no tener problemas a primera vista.

def add_item(item, items=[]):
    items.append(item)
    return items

Sin embargo, al llamar a esta función varias veces, ocurre el fenómeno de que el resultado de la llamada anterior se hereda.

print(add_item("A"))  # ['A']
print(add_item("B"))  # ['A', 'B'] ← Comportamiento inesperado

Este problema ocurre porque, al definir la función, items=[] se evalúa solo una vez y se reutiliza.

Forma Correcta

En tales casos, es seguro inicializar con None y crear la lista dentro de la función.

def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

4.2 Confusión entre Alcance de Variables e Inicialización

En Python, las variables globales y locales con el mismo nombre se tratan como distintas según su alcance.

En el siguiente ejemplo, parece que se usa el mismo counter, pero al tener alcances diferentes se trata como variables distintas.

counter = 10

def increment():
    counter = counter + 1  # generará un error
    print(counter)

Este código genera un UnboundLocalError en tiempo de ejecución. Esto ocurre porque al intentar asignar a counter dentro de la función, Python lo considera una “variable local”.
Sin embargo, esa variable local aún no ha sido inicializada, lo que produce el error.

Para que Funcione Correctamente

• Si deseas cambiar el valor dentro de la función,global usar la palabra clave
• O diseñar la función para pasar valores mediante argumentos o valores de retorno

def increment():
    global counter
    counter += 1
    print(counter)

4.3 Trampas al Inicializar sin Considerar el Tipo

Python es de tipado dinámico, por lo que el tipo puede cambiar automáticamente. Esto es útil, pero también puede ser la causa de errores.

value = 5       # entero
value = "5"     # ahora es una cadena

Este código parece funcionar correctamente, pero si más tarde se intenta tratar value como un número, se producirá un error.

result = value + 1  # TypeError: can only concatenate str (not "int") to str

Medidas

• Si deseas fijar el tipo, usar anotaciones de tipo (ver más abajo)
• Al menos, al inicializar la variable, deja claro «para qué se usa esta variable»

Resumen Breve: Conocer los Puntos de Atención Previene Errores

Python es un lenguaje amigable para principiantes, pero también tiene trampas ocultas detrás de su “facilidad de uso”. En particular, el manejo de objetos mutables, las diferencias de alcance y la ambigüedad de tipos son factores que con frecuencia generan errores incluso a nivel profesional.

Para evitar estos problemas, es importante no solo conocer los fundamentos de la inicialización, sino también los errores comunes y sus soluciones de antemano.

5. Mejores prácticas de inicialización en funciones y clases

Inicialización de variables en funciones

Inicialización de variables locales

Las variables definidas dentro de una función de Python se tratan como variables locales de esa función. Son independientes del exterior de la función, y si intentas usar una variable que no ha sido inicializada dentro de la función, se producirá un error.

def greet():
    message = "Hola"
    print(message)

greet()

Por lo tanto, es importante inicializar siempre las variables que se usarán dentro de la función.

Uso seguro de argumentos por defecto

Como se mencionó en el capítulo anterior, usar objetos mutables (listas o diccionarios) como argumentos por defecto puede provocar compartición no intencionada de valores.

Como método de inicialización seguro, se recomienda usar None y luego inicializar dentro de la función.

def append_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

Este estilo conduce a un diseño de funciones más reutilizable, seguro y predecible.

Inicialización de variables en clases (método __init__)

En una clase de Python, cuando se crea una instancia se llama al método __init__. Allí se inicializan las variables de instancia.

Inicialización de variables de instancia

class User:
    def __init__(self, name):
        self.name = name
        self.age = None  # Se inicializan también las variables que se asignarán después

user1 = User("Sato")
print(user1.name)  # → Sato

De esta manera, al inicializar con self., cada instancia puede tener datos propios.

Atención a la diferencia con variables de clase

Python tiene variables de instancia y variables de clase. Si se usan sin comprender la diferencia, puede producirse una compartición no intencionada de datos.

class Sample:
    shared_list = []  # Variable de clase (compartida entre todas las instancias)

    def __init__(self):
        self.my_list = []  # Variable de instancia (independiente en cada instancia)

a = Sample()
b = Sample()

a.shared_list.append("A")
b.shared_list.append("B")

print(a.shared_list)  # → ['A', 'B']
print(b.shared_list)  # → ['A', 'B']

Las variables de clase se comparten entre todas las instancias, por lo que no son adecuadas para almacenar estado. Si se necesita datos independientes por estado, siempre debe usarse self. y inicializar en __init__.

Clarificar la intención del código mediante la inicialización

La inicialización de variables en funciones y clases es un elemento de diseño importante que indica «cómo se espera que se use esta variable». Al inicializar adecuadamente, se facilita la comprensión para quien lea el código más adelante (o para uno mismo en el futuro).

6. Inicialización usando pistas de tipo (Optional, Union)

¿Qué son las pistas de tipo?

Las pistas de tipo son, un mecanismo que indica explícitamente que una variable o los argumentos y valores de retorno de una función “se espera que usen este tipo”. Python 3.5 en adelante lo soporta de forma estándar, y se pueden aprovechar los beneficios de autocompletado y advertencias de herramientas de análisis estático (mypy, Pyright) y editores (VS Code, PyCharm, etc.).

name: str = "Yamada"
age: int = 25
is_active: bool = True

Como se muestra arriba, se puede especificar explícitamente el tipo escribiendo dos puntos (:) y el nombre del tipo después del nombre de la variable.

Inicialización usando Optional

Optional es una pista de tipo que indica que una variable puede ser de un tipo o None. Por ejemplo, para una variable que “aún no está configurada pero que podría contener una cadena más adelante”, se usa de la siguiente manera.

from typing import Optional

username: Optional[str] = None

Esto tiene el mismo significado que lo siguiente:

from typing import Union

username: Union[str, None] = None

En otras palabras, Optional[X] es una forma abreviada de Union[X, None].

Al escribirlo de esta manera, queda claro que “esta variable puede estar en un estado no configurado (None), pero se espera que finalmente sea una str”.

Permitir varios tipos con Union

Al usar Union, es posible definir de forma flexible que “esta variable puede tomar cualquiera de varios tipos”.

from typing import Union

data: Union[int, str] = 42
data = "texto"  # ambos son OK

Se utiliza con el objetivo de mantener los beneficios de la tipificación dinámica, pero limitando las opciones de tipo y evitando errores inesperados.

Inicialización de listas y diccionarios con pistas de tipo

Las listas y los diccionarios también pueden especificarse detalladamente con pistas de tipo.

from typing import List, Dict

names: List[str] = []
user_ages: Dict[str, int] = {}

Al escribirlo como se muestra arriba, se puede comunicar claramente la especificación de que “esta lista solo contiene cadenas” y “este diccionario tiene claves de cadena y valores enteros”.

Efectos y beneficios de usar pistas de tipo

• Mejora la autocompletación del editor: al reducir las opciones, disminuyen los errores tipográficos
• Ayuda a detectar bugs temprano: herramientas como mypy pueden identificar incompatibilidades de antemano
• Sirve como documentación: facilita entender el uso del código incluso para otros

Especialmente cuando los principiantes avanzan a nivel intermedio, el hábito de ser consciente de los tipos es sumamente importante.

Resumen: Inicialización clara para un código legible y seguro

Python no es un lenguaje estricto con los tipos, pero el uso de pistas de tipo mejora considerablemente la fiabilidad del código. Si se indica claramente la intención al inicializar usando Optional o Union, se reducen los bugs y el mantenimiento futuro se vuelve más sencillo.

7. Preguntas frecuentes (FAQ)

Aquí se recopilan, en formato Q&A, las dudas más frecuentes de los principiantes relacionadas con la “inicialización de variables en Python”. Cada respuesta incluye ejemplos de código prácticos y puntos a tener en cuenta.

Q1. ¿Es necesario especificar el tipo de una variable en Python?

A1. Funciona sin especificar el tipo, pero usar anotaciones de tipo (type hints) lo hace más seguro.

Python es un lenguaje de tipado dinámico, por lo que basta con escribir lo siguiente para usar una variable.

age = 25        # Sin especificación de tipo (int)
name = "Sato"   # Sin especificación de tipo (str)

Sin embargo, asignar un tipo diferente más adelante puede provocar errores inesperados. Por eso, para mejorar la legibilidad del código, la asistencia de autocompletado y el chequeo de tipos, se recomienda utilizar anotaciones de tipo (type hints).

age: int = 25

Q2. ¿Por qué inicializar una variable con None?

A2. Para indicar que el valor aún no existe.

En Python, usar None permite indicar claramente que el valor aún no ha sido asignado.

result = None  # Se asume que se asignará un valor más adelante.

Especialmente es útil para valores de retorno de funciones, argumentos opcionales y la inicialización de variables cuyo estado aún no está determinado. Además, usar None permite evaluar el estado de forma concisa, como en if result is None:.

Q3. ¿Cuál es la forma correcta de inicializar una lista?

A3. Una lista vacía se inicializa con [], pero hay que tener cuidado con los argumentos de funciones.

items = []  # La inicialización normal es correcta con esto

Sin embargo, usar [] como argumento predeterminado de una función puede provocar que el valor se comparta entre llamadas.

def add(item, items=[]):  # ❌ Los valores se acumulan en cada ejecución
    items.append(item)
    return items

Lo correcto es usar None y luego inicializar dentro de la función.

def add(item, items=None):  # ✅
    if items is None:
        items = []
    items.append(item)
    return items

Q4. ¿Por qué una variable de clase comparte su valor con otras instancias?

A4. Es necesario comprender la diferencia entre variables de clase y variables de instancia.

En las clases de Python existen los siguientes dos tipos de variables:

• variable de clase: compartida por toda la clase
• variable de instancia: tiene valores independientes por cada instancia

class Sample:
    shared_list = []  # Variable de clase (compartida entre todas las instancias)

    def __init__(self):
        self.my_list = []  # Variable de instancia (independiente en cada instancia)

a = Sample()
b = Sample()

a.shared_list.append("A")
b.shared_list.append("B")

print(a.shared_list)  # → ['A', 'B']
print(b.shared_list)  # → ['A', 'B']

Para evitar compartir de forma no intencional, use self.変数名 como variable de instancia y inicialícela dentro de __init__.

Q5. ¿Cómo decidir entre usar 0, "" y None como valor inicial de una variable?

A5. Depende de si el valor está “indefinido” o si se ha confirmado que está “vacío”.

Por ejemplo, si se está esperando la entrada del usuario, use None; si ya se asume que se usará una lista vacía, use []. Al aclarar la diferencia de intención, se mejora la seguridad y la legibilidad del procesamiento posterior.

8. Resumen｜Mejores prácticas de inicialización en Python

En este artículo, hemos cubierto ampliamente la «inicialización de variables en Python», desde lo básico hasta aplicaciones prácticas, errores comunes y el uso de pistas de tipo.

Python es un lenguaje de tipado dinámico y flexible, pero esa misma característica hace que la «ambigüedad en la inicialización» sea una causa frecuente de errores y bugs inesperados. Por eso, adquirir las mejores prácticas de inicialización está directamente relacionado con una codificación saludable.

✅ Resumen de las mejores prácticas de inicialización

• Los tipos básicos (int, str, list, etc.) deben inicializarse explícitamente

count = 0
  name = ""
  items = []

• Usa None cuando quieras indicar un estado indefinido

result = None

def func(data=None):
      if data is None:
          data = []

• No uses tipos mutables (lista, diccionario, etc.) como argumentos predeterminados de funciones

def func(data=None):
      if data is None:
          data = []

class User:
      def __init__(self, name):
          self.name = name

• En una clase, inicializa cada instancia con self.変数名

class User:
      def __init__(self, name):
          self.name = name

from typing import Optional
  age: Optional[int] = None

• Usa pistas de tipo (Optional, Union) para clarificar la intención del código

from typing import Optional
  age: Optional[int] = None

✍️ Consejos para principiantes

En Python, que el código «funcione» y que sea «seguro y claro» son cosas distintas. Al principio está bien enfocarse en que funcione, pero a medida que aprendas a inicializar con claridad y a usar los tipos, podrás escribir código con menos bugs y mayor fiabilidad.

📘 Temas relacionados (para avanzar)

• Comprensión del alcance y espacio de nombres en Python
• Automatización de la verificación de tipos mediante mypy
• Simplificación de la inicialización con data classes（@dataclass）
• Aprovechamiento de la autocompletación de tipos mediante la integración con IDEs (VS Code, PyCharm)

Gracias por leer hasta el final. Esperamos que este artículo ayude a resolver las dudas y a mejorar el nivel de quienes tienen problemas con la «inicialización de variables en Python».