El Libro De Python (24.

95 €) Comprar Ebook

CONTENIDO

Identidad, tipo y valor

Mutabilidad
Excepciones de mutabilidad
Mutabilidad y paso por valor/referencia
Ejercicios y ejemplos
Modificar una tupla con slicing

03. Tipos y estructuras / Mutabilidad

Identidad, tipo y valor

Python es un lenguaje de programación orientado a objetos, y como tal, trata a todos los tipos de datos como
objetos. Un simple entero es un objeto.

# x es un objeto

x = 5

Y una función es también un objeto.

# x es un objeto

def x():
pass

Sabido esto, tal vez te preguntes ¿y entonces cuál es la diferencia? ¿en qué se diferencian los objetos? Pues bien,
cada objeto viene identificado por su identidad, tipo y valor:

• Identidad: Nunca cambia e identifica de manera unívoca al objeto. El operador is nos permite saber si dos
objetos son en realidad el mismo. Es decir, si dos variables hacen referencia al mismo.
• Tipo: Nos indica el tipo al que pertenece, como un float o una lista. La función type() nos indica el tipo de un
determinado objeto. Es la clase a la que pertenece.
• Valor: Todo objeto tiene unas características particulares. Si estas características pueden ser modificadas,
diremos que es un tipo mutable. De lo contrario, que es inmutable.

Veamos un ejemplo con un entero:

• Podemos ver con id() , que se trata de un identificador único. Es importante notar que si ejecutamos el código
diferentes veces, su valor no tiene porqué se el mismo.
• Por otro lado el tipo entero, <class 'int'> .

• Por último tenemos su valor, 10 .

 x = 10

print("Identidad:", id(x))

print("Tipo:", type(x))
print("Value:", x)

# Identidad: 4474035136

# Tipo: <class 'int'>

# Value: 10

Los enteros en Python, son un tipo inmutable y a continuación explicaremos las implicaciones que tiene esto.

Mutabilidad
Los diferentes tipos de Python u otros objetos en general, pueden ser clasificados atendiendo a su mutabilidad.
Pueden ser:

• Mutables: Si permiten ser modificados una vez creados.

• Inmutables: Si no permiten ser modificados una vez creados.

Son mutables los siguientes tipos:

• Listas
• Bytearray
• Memoryview
• Diccionarios
• Sets
• Y clases definidas por el usuario

Y son inmutables:

Booleanos
•
• Complejos
• Enteros
• Float
• Frozenset
• Cadenas
• Tuplas
• Range
• Bytes

Sabida ya la clasificación, tal vez te preguntes porqué es esto relevante. Pues bien, Python trata de manera
diferente a los tipos mutables e inmutables, y si no entiendes bien este concepto, puedes llegar a tener
comportamientos inesperados en tus programas.
La forma más sencilla de ver la diferencia, es usando las listas en oposición a las tuplas. Las primeras son mutables,
las segundas no.

Una lista l puede ser modificada una vez creada.

# La asignación se puede realizar

l = [1, 2, 3]
l[0] = 0

Como hemos explicado antes, id() nos devuelve un identificador único del objeto. Como puedes observar, es el
mismo antes y después de realizar la modificación.

l = [1, 2, 3]

print(id(l)) #4383854144

l[0] = 0

print(id(l)) #4383854144

Sin embargo, una tupla es inmutable, por lo que la siguiente asignación dará un error.

# La asignación no se puede realizar

t = (1, 2, 3)

t[0] = 0

Aunque la tupla es inmutable, si que habría una forma de modificar el valor de t, pero lo que en realidad hacemos
es crear una nueva tupla y asignarle el mismo nombre.

Se podría hacer algo como lo siguiente, convertir la tupla en lista, modificar la lista y convertir a tupla otra vez.

t = (1, 2, 3)

print(id(t)) #4483581184

t = list(t)

# Modificar elemento

t[0] = 0

t = tuple(t)

print(t) #(0, 2, 3)

print(id(t)) #4483953088

Como puedes ver, hemos conseguido modificar el valor de t, pero id(t) ya no nos devuelve el mismo valor. El
nombre de la variable es el mismo, pero el objeto al que “apunta” ha cambiado.

Lo mismo pasa con los sets (mutables) y los frozenset (no mutables).
Esto no resulta tan evidente si usamos un entero. Veamos un ejemplo.

Tenemos una variable x con su id y le añadimos una unidad. El resultado es que el identificador cambia, ya que
Python no puede cambiar el 5 al ser el entero un tipo inmutable.

x = 5

print(id(x)) # 4525173536

x = x + 1

print(id(x)) # 4525173568 (Ha cambiado)

Sin embargo, si usamos una lista, que es un tipo mutable, al intentar modificar la x, dicha modificación puede ser
realizada en la misma variable, por lo que el id() es el mismo

x = [1, 2]

print(id(x)) # 4382432768

x.append(3)

print(id(x)) # 4382432768 (No cambia)

Las principales diferencias entre tipos mutables e inmutables son las siguientes:

• Los tipos inmutables son generalmente más rápidos de acceder. Por lo que si no piensas modificar una lista, es
mejor que uses una tupla.
• Los tipos mutables son perfectos cuando quieres cambiar su contenido repetidas veces.
• Los tipos inmutables son caros de cambiar, ya que lo que se hace en realidad es hacer una copia de su
contenido en un nuevo objeto con las modificaciones.

Excepciones de mutabilidad
Aunque tampoco se trata de una excepción propiamente dicha ya que no rompe con lo explicado anteriormente,
hay casos en los que si podría parecer que se modifica un tipo inmutable.

Imaginemos que tenemos una tupla (inmutable) compuesta por varios elementos, donde hay una lista (mutable).
 l = [4, 5, 6]

# La lista es parte de la tupla

t = (1, 2, 3, l)

print(t) # (1, 2, 3, [4, 5, 6])

# Podemos modificar la lista

l[0] = 0

# Que también modifica la tupla

print(t) # (1, 2, 3, [0, 5, 6])

Aunque parece que hayamos modificado la tupla t, lo que en realidad hemos modificado es la lista l, y como la
tupla referencia a ella, también se ve modificada.

Mutabilidad y paso por valor/referencia

La mutabilidad de los objetos es una característica muy importante cuando tratamos con funciones, ya que Python
los tratará de manera distinta.

Si conoces lenguajes de programación como C, los conceptos de paso por valor o referencia te resultarán familiares:

• Los tipos inmutables son pasados por valor, por lo tanto dentro de la función se accede a una copia y no al valor
original.
• Los tipos mutables son pasados por referencia, como es el caso de las listas y los diccionarios. Algo similar a
como C pasa las array como punteros.

En otros posts te explicamos con más detalle el paso por valor y referencia, pero veamos un ejemplo.

Tenemos una función que modifica dos variables.

def funcion(a, b):

a = 10

b[0] = 10

# x es un entero

x = 5

# y es una lista

y = [5]

Si llamamos a la función con ambas variables, vemos como el valor de x no ha cambiado, pero el de y sí.
 funcion(x, y)

print(x) # 5

print(y) # 10

Esto se debe a que a=10 trabaja con un valor de a local a la función, al ser el entero un tipo inmutable. Sin
embargo b[0]=10 actúa sobre la variable original.

Ejercicios y ejemplos
Modificar una tupla con slicing
Como hemos visto anteriormente, realizar la siguiente asignación no es posible.

T = (1, 2, 3, 4, 5)

T[2] = 0

# TypeError: 'tuple' object does not support item assignment

Si por ejemplo queremos modificar el índice T[2] , podemos hacer uso del slicing.

T = (1, 2, 3, 4, 5)

T = T[:2] + (0,) + T[3:]

print(T) #(1, 2, 0, 4, 5)

Anterior
Colecciones
Siguiente
04. Funciones

Nuestra tienda Colabora Canal de telegram

Política de privacidad Términos y condiciones Contacta con nosotros

Copyright © El Libro De Python. All Rights Reserved