En Python, todo es un objeto. Comprender cómo funcionan los objetos es fundamental para escribir código efectivo.

Identidad, Tipo y Valor de un Objeto

Cada objeto en Python tiene tres características principales:

• Identidad: Representa la ubicación única del objeto en la memoria. Se puede obtener usando la función id().
• Tipo: Determina qué clase de valores puede contener el objeto y qué operaciones se pueden realizar sobre él. Se obtiene con la función type().
• Valor: Son los datos que el objeto representa. Se puede visualizar usando la función print().

Referencias a Objetos y Compartición

Las variables en Python no almacenan objetos directamente, sino que actúan como referencias a ellos. Cuando asignas una variable a otra (b = a), ambas variables apuntan al mismo objeto.

Este comportamiento se conoce como compartición de referencias. Si el objeto al que se hace referencia es mutable (como una lista), modificarlo a través de una variable afectará a todas las demás referencias a ese mismo objeto.

mi_lista_original = [1, 2, 3]
mi_otra_lista = mi_lista_original # Ambas variables referencian la misma lista
mi_otra_lista[0] = 0
print(mi_lista_original) # Salida: [0, 2, 3]

Por otro lado, si el objeto es inmutable (como un número o una cadena), asignar un nuevo valor a una variable crea un nuevo objeto, y la otra referencia sigue apuntando al objeto original.

numero_a = 10
numero_b = numero_a
numero_b = 20 # Se crea un nuevo objeto para 20
print(numero_a) # Salida: 10

Comparación de Objetos: is vs ==

Es crucial diferenciar entre comparar la identidad de los objetos y comparar sus valores:

• is: Comprueba si dos variables se rfeieren exactamente al mismo objeto en memoria.
• ==: Comprueba si los valores de los objetos a los que se refieren las variables son iguales.

lista1 = [1, 2, 3]
lista2 = lista1
print(lista1 is lista2) # Salida: True (ambas apuntan al mismo objeto)

lista3 = [1, 2, 3]
print(lista1 is lista3) # Salida: False (objetos diferentes en memoria)
print(lista1 == lista3) # Salida: True (los valores son iguales)

Python utiliza un mecanismo de caché para objetos inmutables pequeños (como enteros bajos y cadenas cortas). Esto significa que múltiples referencias a estos valores a menudo apuntarán al mismo objeto para optimizar el uso de memoria.

num_x = 256
num_y = 256
print(num_x is num_y) # Salida: True (debido al caché)

Reglas de Nomenclatura de Variables

Los nombres de variables en Python deben seguir estas reglas:

• Pueden contener letras (mayúsculas y minúsculas), números y el guion bajo (_).
• El primer carácter no puede ser un número.
• No se pueden usar palabras reservadas del lenguaje.

Algunas palabras reservadas importantes incluyen: if, else, for, while, def, class, import, return, True, False, None, entre otras.

Tipos de Datos Fundamentales

1. Números (Number)

Python soporta varios tipos numéricos:

• int: Números enteros.
• float: Números de punto flotante (decimales).
• bool: Booleanos (True y False, que internamente se tratan como 1 y 0 respectivamente).
• complex: Números complejos (ej. 3+4j).

Operadores Numéricos Comunes:

• +, -, *, / (división flotante)
• // (división entera)
• ** (exponenciación)
• % (módulo u operador de resto)

Funciones Matemáticas Útiles:

• abs(x): Valor absoluto.
• max(a, b, ...): Valor máximo.
• min(a, b, ...): Valor mínimo.
• round(x, n): Redondea a n decimales.
• Funciones del módulo math: math.floor(), math.sqrt(), math.log(), etc. (requieren import math).

Asignación de Múltiples Variables:

Python permite asignaciones concisas:

• a = b = c = 1 (mismo valor para todas).
• x, y, z = 1, 2, 3 (valores diferentes asignados en orden).

Al realizar operaciones entre enteros y flotantes, el resultado es un flotante.

2. Cadenas (String)

Las cadenas son secuencias inmutables de caracteres, definidas con comillas simples (') o dobles (").

Operaciones y Métodos de Cadenas:

• Concatenación: +
• Repetición: *
• Indexación: cadena[indice]
• Slicing (Subcadenas): cadena[inicio:fin]
• Pertenencia: in, not in
• capitalize(): Primera letra en mayúscula.
• count(sub): Cuenta ocurrencias de una subcadena.
• find(sub): Busca la primera ocurrencia de una subcadena (devuelve -1 si no se encuentra).
• index(sub): Similar a find, pero lanza una excepción si no se encuentra.
• Métodos de verificación: isalnum(), isalpha(), isdigit(), islower(), isupper(), isspace(), istitle().
• join(iterable): Une elementos de un iterable usando la cadena como separador.
• lower(), upper(): Convierte a minúsculas o mayúsculas.
• replace(old, new): Reemplaza subcadensa.
• split(sep): Divide la cadena en una lista de subcadenas.
• swapcase(): Invierte mayúsculas y minúsculas.

3. Listas (List)

Las listas son secuencias mutables y ordenadas de elementos. Pueden contener elementos de diferentes tipos y anidarse.

Creación de Listas:

• Constructor: list() o list("abc").
• Directa: [] o [elemento1, elemento2, ...].

Acceso y Modificación:

• Indexación: mi_lista[indice].
• Slicing: mi_lista[inicio:fin].
• Asignación a índices o slices: mi_lista[indice] = nuevo_valor, mi_lista[inicio:fin] = otra_lista.
• Inserción en una posición: mi_lista[indice:indice] = [elementos].
• Eliminación: del mi_lista[indice], del mi_lista[inicio:fin].

Operaciones de Secuencia:

Las listas soportan operadores como in, not in, + (concatenación), * (repetición), len(), max(), min(), sum().

Funciones y Métodos de Listas:

• reversed(lista): Devuelve un iterador para la lista invertida.
• sorted(lista, key=..., reverse=...): Devuelve una nueva lista ordenada.
• zip(iter1, iter2, ...): Combina elementos de múltiples iterables en tuplas.
• enumerate(iterable): Devuelve pares de índice y valor.
• Métodos: append(), count(), extend(), index(), pop(), remove(), reverse(), sort(), clear(), copy().

Comprensión de Listas (List Comprehensions):

Una forma concisa de crear listas:

cuadrados = [x**2 for x in range(10)]
pares_dobles = [2 * x for x in range(10) if x % 2 == 0]

4. Tuplas (Tuple)

Las tuplas son secuencias inmutables y ordenadas. Se definen usando paréntesis ().

• Son útiles para agrupar datos que no deben modificarse.
• La sintaxis para acceder y las operaciones de secuencia son similares a las listas, pero no se pueden modificar después de su creación.

mi_tupla = (1, 'hola', 3.14)
print(mi_tupla[0]) # Acceso
# mi_tupla[0] = 5 # Esto generaría un error (TypeError)

5. Diccionarios (Dictionary)

Los diccionarios son coleciones mutables y desordenadas (en versiones antiguas de Python; ordenadas por inserción en Python 3.7+) de pares clave-valor.

Creación y Acceso:

• Se crean con llaves: {} o {'clave1': valor1, 'clave2': valor2}.
• Acceso por clave: mi_dict[clave].
• Obtener todos los valores: mi_dict.values().
• Obtener todas las claves: mi_dict.keys().
• Obtener pares clave-valor: mi_dict.items().

Adición, Modificación y Eliminación:

• Adición/Modificación: mi_dict[nueva_clave] = nuevo_valor.
• Eliminación: del mi_dict[clave], mi_dict.pop(clave).
• Vaciar diccionario: mi_dict.clear().

Métodos Comunes de Diccionario:

• copy(): Crea una copia superficial.
• fromkeys(seq, valor): Crea un diccionario a partir de una secuencia de claves.
• get(clave, default): Obtiene el valor de una clave, devolviendo un valor por defecto si no existe.
• update(otro_dict): Fusiona otro diccionario en el actual.