{"id":5387,"date":"2012-09-02T13:56:44","date_gmt":"2012-09-02T11:56:44","guid":{"rendered":"http:\/\/elclubdelautodidacta.es\/wp\/?p=5387"},"modified":"2012-09-02T13:56:44","modified_gmt":"2012-09-02T11:56:44","slug":"python-el-sagrado-misterio-de-la-inmutabilidad","status":"publish","type":"post","link":"http:\/\/elclubdelautodidacta.es\/wp\/2012\/09\/python-el-sagrado-misterio-de-la-inmutabilidad\/","title":{"rendered":"Python: El sagrado misterio de la inmutabilidad"},"content":{"rendered":"

\"\"<\/a>Objetivo:<\/strong> comprender los conceptos cr\u00edticos de mutabilidad, inmutabilidad y referencia en Python.<\/em><\/p>\n

Est\u00e1s ante un art\u00edculo esencial<\/strong> en tu formaci\u00f3n como programador en Python<\/em>. Te llevar\u00e1 s\u00f3lo cinco minutos leerlo, pero puede dar luz sobre conceptos que no resultan ni mucho menos obvios cuando se comienza con Python<\/em>, particularmente si procedes de otros lenguajes de programaci\u00f3n.<\/p>\n

Por lo general, cuando empezamos a estudiar un lenguaje de programaci\u00f3n, se nos cuenta que existen distintos tipos de datos<\/em>, tales como num\u00e9ricos<\/em>, strings<\/em>, etc.<\/p>\n

En Python<\/em> se nos ense\u00f1a algo m\u00e1s: determinados tipos son inmutables<\/strong> y otros mutables<\/strong>. Los n\u00fameros<\/em>, los strings<\/em> y las tuplas<\/em> son inmutables<\/em>. Por el contrario, las listas<\/em> son mutables<\/em>.<\/p>\n

Ah\u00ed ya empiezan a sacudirnos algo; pero nuestro cerebro, al que no le gustan las dudas, intenta buscar una respuesta coherente para no quedarse atascado y seguir avanzando. Claro: los n\u00fameros<\/em>, los strings<\/em> y las tuplas<\/em> no se pueden modificar<\/strong>, mientras que las listas<\/em> s\u00ed<\/strong>.<\/p>\n

Bueno, bueno, un momento:<\/p>\n

>>> a = 5\n>>> b = 'pradera'<\/code><\/pre><\/p>\n
La variable a contiene<\/em> un n\u00famero<\/em>; la variable b contiene<\/em> un string<\/em>. Hemos dicho que los n\u00fameros<\/em> y los strings<\/em> son inmutables<\/em>. \u00bfSignifica eso que no podemos modificar ni a<\/em> ni b<\/em>?<\/p>\n
>>> a = 6\n>>> b = 'casa'\n>>> a\n6\n>>> b\n'casa'<\/code><\/pre><\/p>\n
Pues s\u00ed, se pueden modificar<\/strong> (de no ser as\u00ed Python tendr\u00eda un serio problema), por lo que eso de la inmutabilidad<\/em> debe de significar algo diferente. Decir que un tupla<\/em> es inmutable<\/em>, pero una lista<\/em> no, \u00bfsignificar\u00e1 acaso que \u00e9sta tiene cosquillas pero la otra no?<\/p>\n
M\u00e1s adelante cuando estudiamos las listas<\/em> y las tuplas<\/em> creemos haber comprendido, al fin, el misterio.<\/p>\n
>>> lista = [1, 2, 3, 4]\n>>> lista[0] = 5\n>>> lista\n[5, 2, 3, 4]<\/code><\/pre><\/p>\n
Bien: las listas<\/em>, mutables<\/em>, se pueden modificar.<\/p>\n
>>> tupla = (1, 2, 3, 4)\n>>> tupla[0] = 5\nTraceback (most recent call last):\n  File "<pyshell#55>", line 1, in <module>\n    tupla[0] = 5\nTypeError: 'tuple' object does not support item assignment<\/code><\/pre><\/p>\n
En cambio, las tuplas<\/em>, inmutables<\/em>, no, como podemos comprobar.<\/p>\n
Aprendemos tambi\u00e9n que los strings<\/em> tambi\u00e9n son secuencias<\/strong>, como las listas<\/em> y las tuplas<\/em> y, como tales, podemos acceder a sus caracteres individuales<\/strong>:<\/p>\n
>>> serie = 'la casa de la pradera'\n>>> serie[3]\n'c'<\/code><\/pre><\/p>\n
Pero no podemos modificarlos<\/strong>:<\/p>\n
>>> serie[3] = 'k'\nTraceback (most recent call last):\n  File "<pyshell#60>", line 1, in <module>\n    serie[3] = 'k'\nTypeError: 'str' object does not support item assignment<\/code><\/pre><\/p>\n
Un error semejante al que recibimos al tratar de modificar una tupla<\/em>. Esto hace que cuadre todo: los strings<\/em> son inmutables<\/em>, tambi\u00e9n.<\/p>\n
Pero \u00bfcuadra realmente todo? Parece que s\u00ed, aunque no aparenta tener mucho sentido pr\u00e1ctico eso de la inmutabilidad<\/em> de los n\u00fameros<\/em>.<\/p>\n
Tarde o temprano, cualquier estudiante de Python<\/em> que ya ha programado en otros lenguajes se enfrenta al siguiente misterio.<\/p>\n
Observ\u00e9moslo muy despacio:<\/p>\n
>>> x = 5\n>>> y = x<\/code><\/pre><\/p>\n
Pregunta: \u00bfcu\u00e1nto crees que vale y<\/em>?<\/p>\n
En efecto, 5:<\/p>\n
>>> y\n5<\/code><\/pre><\/p>\n
Modifiquemos ahora el valor de x<\/em>:<\/p>\n
>>> x = 6\n<\/code><\/pre><\/p>\n
\u00bfCu\u00e1nto crees que valdr\u00e1 ahora y<\/em>?<\/p>\n
Vamos a ver, no me asustes: x<\/em> e y<\/em> son dos variables diferentes, cada una con su propio contenido; por lo tanto y<\/em> tiene que seguir valiendo 5, aunque hayas modificado x<\/em>, \u00bfno?<\/p>\n
En efecto, as\u00ed es:<\/p>\n
>>> y\n5<\/code><\/pre><\/p>\n
Veamos otro ejemplo. Ahora x<\/em> es una lista<\/em>:<\/p>\n
>>> x = [1, 2, 3, 4]\n>>> y = x\n>>> y\n[1, 2, 3, 4]<\/code><\/pre><\/p>\n
Voy a modificar el valor de x<\/em>:<\/p>\n
>>> x[0] = 5\n>>> x\n[5, 2, 3, 4]<\/code><\/pre><\/p>\n
\u00bfCu\u00e1nto crees que valdr\u00e1 ahora y<\/em>?<\/p>\n
Por la l\u00f3gica anterior, x<\/em> e y<\/em> son dos variables diferentes, cada una con su propio contenido, por lo que cabr\u00eda esperar que el valor de y<\/em> fuera [1, 2, 3, 4].<\/p>\n
Pero no es as\u00ed:<\/p>\n
>>> y\n[5, 2, 3, 4]<\/code><\/pre><\/p>\n
Esto rompe completamente nuestros esquemas. Si somos programadores en otros lenguajes una alarma<\/strong> nos sacude inmediatamente.<\/p>\n
\u00bfPor qu\u00e9 al modificar x<\/em> ha cambiado y<\/em> tambi\u00e9n?<\/p>\n
De acuerdo: los n\u00fameros son inmutables<\/em>, pero las listas<\/em> no. \u00bfPero qu\u00e9 tiene que ver esto con el hecho de que se haya modificado el valor de y<\/em>?<\/p>\n
Para resolver el misterio hace falta un una nueva pieza clave<\/strong>: el concepto de referencia<\/strong>.<\/p>\n
Veamos lo que est\u00e1 sucediendo realmente entre bastidores:<\/p>\n
>>> x = 5\n<\/code><\/pre><\/p>\n
En Python<\/em>, todo son objetos<\/strong>. Se acaba de crear uno nuevo: un n\u00famero<\/em> de valor 5.<\/p>\n
Este objeto, que reside en alg\u00fan lugar de la memoria, posee un identificador \u00fanico que lo diferencia del resto de los objetos. Piensa en \u00e9l como si fuera su DNI<\/em> (es, en realidad, la direcci\u00f3n de memoria en la que reside el objeto).<\/p>\n
Para conocer ese identificador, Python<\/em> dispone de la funci\u00f3n id()<\/strong>:<\/p>\n
>>> id(5)\n137396064\n<\/code><\/pre><\/p>\n
Y ahora el concepto cr\u00edtico<\/strong>: la variable x<\/em> no es m\u00e1s que una referencia<\/strong> a ese objeto. A efectos pr\u00e1cticos, es como si se tratara de un puntero<\/em> (empleando conceptos de otros lenguajes) a ese objeto. No contiene su valor, sino una referencia a \u00e9l<\/strong>.<\/p>\n
La funci\u00f3n id()<\/strong>, aplicada a una variable, nos devuelve el id<\/em> del objeto al que referencia, por lo que obtenemos el mismo valor que antes:<\/p>\n
>>> id(x)\n137396064<\/code><\/pre><\/p>\n
Proseguimos; asignamos a la variable y<\/em> el valor de x<\/em>:<\/p>\n
>>> y = x\n<\/code><\/pre><\/p>\n
Observa ahora cuidadosamente qu\u00e9 pasa al preguntar por el id<\/em> del objeto al que referencia y<\/em>:<\/p>\n
>>> id(y)\n137396064<\/code><\/pre><\/p>\n
Exactamente el mismo<\/strong> al que referencia x<\/em>. Tanto x<\/em> como y<\/em> apuntan al mismo objeto.<\/p>\n
Este es un concepto radicalmente distinto al de las variables en otros lenguajes, en los que el contenido de x<\/em> y de y<\/em> estar\u00eda en diferentes direcciones de memoria.<\/p>\n
A continuaci\u00f3n, modificamos x<\/em>:<\/p>\n
>>> x = 6\n>>> id(x)\n137396080<\/code><\/pre><\/p>\n
Se ha creado un nuevo objeto, de valor 6, y ahora x<\/em> apunta a ese valor. Esto tambi\u00e9n es muy diferente a lo que suceder\u00eda en otros lenguajes: la variable x<\/em> seguir\u00eda en la misma direcci\u00f3n de memoria, habiendo modificado \u00fanicamente su contenido.<\/p>\n
Fij\u00e9monos que, como es de esperar, y<\/em> sigue apuntando al objeto primero:<\/p>\n
>>> id(y)\n137396064\n>>> y\n5<\/code><\/pre><\/p>\n
Analicemos ahora qu\u00e9 sucede en el caso de las listas:<\/p>\n
>>> x = [1, 2, 3, 4]\n>>> y = x\n>>> id(x)\n170964396\n>>> id(y)\n170964396<\/code><\/pre><\/p>\n
De momento, todo es exactamente igual que antes: se ha creado un \u00fanico objeto<\/strong>, la lista [1, 2, 3, 4]<\/code>, que est\u00e1 referenciado por dos variables, x<\/em> e y<\/em>.<\/p>\n
Si ahora modificamos directamente el objeto<\/strong> (al ser mutable, podemos hacerlo):<\/p>\n
>>> x[0] = 5\n>>> id(x)\n170964396\n>>> id(y)\n170964396<\/code><\/pre><\/p>\n
comprobamos que tanto x<\/em> como y<\/em> siguen siendo referencias al mismo objeto<\/strong>. <\/p>\n
Por lo tanto y<\/em> tiene el mismo valor que x<\/em>:<\/p>\n
>>> y\n[5, 2, 3, 4]<\/code><\/pre><\/p>\n
En el ejemplo anterior, cuando hicimos x = 6<\/code>, se cre\u00f3 un nuevo objeto. En el caso de la lista, hemos modificado in situ<\/strong> el propio<\/strong> objeto, aprovech\u00e1ndonos de su mutabilidad<\/em>. Es como si un cirujano hubiese realizado una operaci\u00f3n sobre el objeto.<\/p>\n
La situaci\u00f3n habr\u00eda sido muy distinta si hubi\u00e9ramos hecho esto otro:<\/p>\n
>>> x = [1, 2, 3, 4]\n>>> y = x\n>>> x = [5, 2, 3, 4]\n>>> y\n[1, 2, 3, 4]\n>>> id(x)\n170489580\n>>> id(y)\n170791756<\/code><\/pre><\/p>\n
F\u00edjate en la importante diferencia: al hacer x = [5, 2, 3, 4]<\/code> hemos creado un objeto diferente, de modo que x<\/em> e y<\/em> apuntan a objetos distintos y por eso ahora sus valores difieren. En el caso anterior, al hacer x[0] = 5<\/code> modificamos directamente<\/strong> el mismo objeto y no se cre\u00f3 otro nuevo<\/strong>.<\/p>\n
Espero que todo resulte m\u00e1s claro ahora y entiendas la diferencia esencial que hay en lo que respecta al concepto de variable respecto a otros lenguajes de programaci\u00f3n. Si es as\u00ed, felic\u00edtate, pues habr\u00e1s cambiado de nivel en tu proceso de aprendizaje de Python<\/em>.<\/p>\n
Javier Montero Gabarr\u00f3<\/span><\/strong><\/p>\n
\n
http:\/\/elclubdelautodidacta.es\/wp\/2012\/09\/python-el-sagrado-misterio-de-la-inmutabilidad\/<\/p>\n
\n
El texto de este art\u00edculo se encuentra sometido a una licencia Creative Commons<\/em> del tipo CC-BY-NC-ND<\/strong> (reconocimiento, no comercial, sin obra derivada, 3.0 unported)<\/p>\n
\n
El Club del Autodidacta<\/em><\/p>\n
\n
Consulta el \u00edndice completo de art\u00edculos relacionados con Python<\/a>.<\/p>\n
Tal vez te interese...<\/H3>