02.1-asignaciones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Asignaciones\n",
    "\n",
    "* En Python una variable se traduce en crear un *nombre* que guarda una *referencia* a un *objeto*.\n",
    "    * Importante, puesto que *NO* se crean copias de un objeto\n",
    "* En Python el tipo de la variable se determina de forma automática, basándose en el tipo del objeto al que hace referencia.\n",
    "    * Tipado dinámico.\n",
    "* Un nombre se crea la primera vez que aparece a la izquierda de un `=` en una sentencia.\n",
    "    * Se pueden asignar varias variables a la vez.\n",
    "* Una referencia se elimina mediante _garbage collection_ cuando no tiene referencias.\n",
    "* El acceso a un nombre (variable) no existente, produce un error de ejecución."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'b' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-e20ca0ac85cf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m  \u001b[0;31m# Creo el nombre (variable) \"a\", que hace referencia al objeto de tipo entero \"3\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mb\u001b[0m  \u001b[0;31m# b no existe, produce un error de ejecución NameError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'b' is not defined"
     ]
    }
   ],
   "source": [
    "a = 3  # Creo el nombre (variable) \"a\", que hace referencia al objeto de tipo entero \"3\"\n",
    "\n",
    "b  # b no existe, produce un error de ejecución NameError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n"
     ]
    }
   ],
   "source": [
    "a, b =  10, 20  # Asigno \"a\" y \"b\" a la vez\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n"
     ]
    }
   ],
   "source": [
    "a = b = 0\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nombres reservados:\n",
    "\n",
    "* No todos los nombres están disponibles, hay algunos nombres reservados:\n",
    "```python\n",
    "  False      await      else       import     pass\n",
    "  None       break      except     in         raise\n",
    "  True       class      finally    is         return\n",
    "  and        continue   for        lambda     try\n",
    "  as         def        from       nonlocal   while\n",
    "  assert     del        global     not        with\n",
    "  async      elif       if         or         yield\n",
    " ```\n",
    " \n",
    "* Hay otros que aunque no están reservados, no se debeían utilizar porque enmascaran a funciones de Python.\n",
    "    * [Funciones built-in](https://docs.python.org/3/library/functions.html)\n",
    "    * Módulos de la librería estándar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-75ac93d55d42>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-75ac93d55d42>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    del = \"foo\"\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "del = \"foo\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'int' object is not callable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-b7a1f27a8833>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m5\u001b[0m  \u001b[0;31m# Sin embargo, si lo asigno, no es un error, pero dejo de tener accesible la funcioón max()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not callable"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "print(max(l))  # La función max() devuelve el máximo de una secuencia\n",
    "\n",
    "max = 5  # Sin embargo, si lo asigno, no es un error, pero dejo de tener accesible la funcioón max()\n",
    "max(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Entendiendo las referencias\n",
    "\n",
    "* Recordemos: Las variables en Python guardan referencias a objetos en memoria.\n",
    "    * Cuando decimos: \"la variable `a` vale `3`\", en realidad debería ser: \"la variable `a` hace referencia al objeto entero `3`\".\n",
    "* Por tanto, Cuando accedemos a una variable\n",
    "    * Para leerla, utilizamos la referencia para leer el objeto de memoria.\n",
    "    * Para modificarla, utilizamos la referencia para modificar un objeto en memoria\n",
    "* Operadores `is` e `is not`: Identidad de objetos.\n",
    "* Función `id(objeto)`: Devuelve la identidad de un objeto (entero único para cada objeto)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "a 4\n",
      "b 3\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = a\n",
    "a = 4\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "print(\"a\", a)\n",
    "print(\"b\", b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "m = l\n",
    "m.append(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "l [1, 2, 3, 4, 5]\n",
      "m [1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print(l == m)\n",
    "print(l is m)\n",
    "print(\"l\", l)\n",
    "print(\"m\", m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetos inmutables\n",
    "\n",
    "* En Python, los objetos de tipo entero (`int`), flotante (`float`), cadena (`string`) y tupla (`tuple`) son inmutables (entre otros muchos).\n",
    "* Eso quiere decir, que si tratamos de cambiar su valor a través de una variable, obtenemos un nuevo objeto, puesto que el objeto original no se puede modificar.\n",
    "* ¿Qué pasa cuando escribimos en Python el siguiente código?\n",
    "```python\n",
    "a = 5\n",
    "```\n",
    "    1. Se crea un objeto de tipo entero, con valor `5` en memoria.\n",
    "    1. Se crea la variable `a`.\n",
    "    1. Se asigna la referencia a la posición de memoria donde el objeto `5` se guardó.\n",
    "    \n",
    "* ¿Qué pasa cuando escribimos en Python el siguiente código?\n",
    "```python\n",
    "a = 5\n",
    "a = a + 1\n",
    "```\n",
    "    1. Se crea un objeto de tipo entero, con valor `5` en memoria.\n",
    "    1. Se crea la variable `a`.\n",
    "    1. Se asigna la referencia a la posición de memoria donde el objeto `5` se guardó.\n",
    "    1. Como el objeto `5` es inmutable, se calcula `5 + 1` y se guarda en memoria.\n",
    "    1. Se asigna la referencia al objeto `6` a la variable a.\n",
    "    1. El objeto `3` se eliminará de memoria por _garbage collection_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140477489396960 140477489396960\n",
      "True\n",
      "140477489396992 140477489396960\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "b = a\n",
    "print(id(a), id(b))\n",
    "print(a is b)\n",
    "a += 1\n",
    "print(id(a), id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetos mutables\n",
    "\n",
    "* Sin embargo, el resto de tipos de datos son mutables\n",
    "    * Listas (`list`), diccionarios (`dict`), conjuntos (`set`), etc.\n",
    "* Cuando se accede a la variable para modificar el objeto *si* se modifican los datos a los que se hace referencia.\n",
    "* Es decir *no se hace una nueva copia, ni se crea un nuevo objeto*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [] b: []\n",
      "a: [1] b: [1]\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo:\n",
    "\n",
    "a = [1, 2, 3, 4]\n",
    "b = a\n",
    "b.clear()\n",
    "print(\"a:\", a, \"b:\", b)\n",
    "a.append(1)\n",
    "print(\"a:\", a, \"b:\", b)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d: {'uno': 10, 'dos': 2, 'tres': 3} e: {'uno': 10, 'dos': 2, 'tres': 3}\n"
     ]
    }
   ],
   "source": [
    "d = {\n",
    "    \"uno\": 1,\n",
    "    \"dos\": 2,\n",
    "    \"tres\": 3,\n",
    "}\n",
    "e = d\n",
    "d[\"uno\"] = 10\n",
    "print(\"d:\", d, \"e:\",e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ojo: para los objetos mutables, no es lo mismo:\n",
    "    * igualdad (dos objetos son iguales), operadores `==` e `!=`.\n",
    "    * identidad (dos objetos son el mismo), operadores `is` e `is not`.\n",
    "* Podemos tener dos objetos *mutables* iguales en memoria.\n",
    "    * Son iguales\n",
    "    * No son el mismo objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Operador igualdad \"==/!=\" e identidad \"is/is not\"\n",
    "\n",
    "l = [1, 2, 3, 4]  # Creo un objeto lista en memoria, asigno a l\n",
    "m = [1, 2, 3, 4]  # Creo otro objeto lista en memoria, asigno a m\n",
    "\n",
    "print(l == m)  # Verdadero, tienen los mismos valores\n",
    "print(l is m)  # Falso, son dos objetos diferentes\n",
    "\n",
    "l.append(5)\n",
    "print(l == m)  # Falso, l contiene un 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3, 4, 5]\n",
    "m = l\n",
    "\n",
    "l.append(6)\n",
    "\n",
    "print(l == m)  # Verdadero, son el mismo objeto\n",
    "print(l is m)  # Verdadero, son el mismo objeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Obteniendo copias de los objetos\n",
    "\n",
    "* Si lo que queremos es obtener una *copia* de un objeto no basta con igualarlo.\n",
    "* Hay diferentes métodos para obtener una copia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listas: slicing\n",
    "\n",
    "l = [1, 2, 3, 4]\n",
    "m = l[:]\n",
    "\n",
    "l == m, l is m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listas: nueva lista\n",
    "\n",
    "l = [1, 2, 3, 4]\n",
    "m = list(l)\n",
    "\n",
    "l == m, l is m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listas: list comprehension\n",
    "\n",
    "l = [1, 2, 3, 4]\n",
    "m = [i for i in l]\n",
    "\n",
    "l == m, l is m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Listas: copia\n",
    "l = [1, 2, 3, 4]\n",
    "m = l.copy()\n",
    "\n",
    "l == m, l is m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Diccionarios: copia\n",
    "d = {\n",
    "    \"uno\": 1,\n",
    "    \"dos\": 2,\n",
    "    \"tres\": 3,\n",
    "}\n",
    "e = d.copy()\n",
    "\n",
    "d == e, d is e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Diccionarios: nuevo diccionario\n",
    "d = {\n",
    "    \"uno\": 1,\n",
    "    \"dos\": 2,\n",
    "    \"tres\": 3,\n",
    "}\n",
    "e = dict(d)\n",
    "\n",
    "d == e, d is e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Diccionarios: dict comprehension\n",
    "d = {\n",
    "    \"uno\": 1,\n",
    "    \"dos\": 2,\n",
    "    \"tres\": 3,\n",
    "}\n",
    "e = {k: v for k, v in d.items()}\n",
    "\n",
    "d == e, d is e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Hay un problema si los objetos contienen objetos a su vez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['one', 'uno', 'un'], 2: ['two', 'dos', 'deux'], 3: ['three', 'tres', 'troix']}\n",
      "{1: ['one', 'uno', 'un'], 2: ['two', 'dos', 'deux'], 3: ['three', 'tres', 'troix']}\n",
      "['one', 'uno', 'un']\n",
      "['two', 'dos', 'deux']\n",
      "['three', 'tres', 'troix']\n"
     ]
    }
   ],
   "source": [
    "uno = [\"one\", \"uno\"]\n",
    "dos = [\"two\", \"dos\"]\n",
    "tres = [\"three\", \"tres\"]\n",
    "\n",
    "d = {\n",
    "    1: uno,\n",
    "    2: dos,\n",
    "    3: tres,\n",
    "}\n",
    "\n",
    "e = d.copy()\n",
    "\n",
    "e[1].append(\"un\")\n",
    "e[2].append(\"deux\")\n",
    "e[3].append(\"troix\")\n",
    "\n",
    "print(d)\n",
    "print(e)\n",
    "\n",
    "print(uno)\n",
    "print(dos)\n",
    "print(tres)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(uno)\n",
    "print(dos)\n",
    "print(tres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* En estos casos hay que utilizar la función `deepcopy` del módulo `copy` (veremos los módulos más adelante)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ['one', 'uno'], 2: ['two', 'dos'], 3: ['three', 'tres']}\n",
      "{1: ['one', 'uno', 'un'], 2: ['two', 'dos', 'deux'], 3: ['three', 'tres', 'troix']}\n",
      "['one', 'uno']\n",
      "['two', 'dos']\n",
      "['three', 'tres']\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "uno = [\"one\", \"uno\"]\n",
    "dos = [\"two\", \"dos\"]\n",
    "tres = [\"three\", \"tres\"]\n",
    "\n",
    "d = {\n",
    "    1: uno,\n",
    "    2: dos,\n",
    "    3: tres,\n",
    "}\n",
    "\n",
    "e = copy.deepcopy(d)\n",
    "\n",
    "e[1].append(\"un\")\n",
    "e[2].append(\"deux\")\n",
    "e[3].append(\"troix\")\n",
    "\n",
    "print(d)\n",
    "print(e)\n",
    "\n",
    "print(uno)\n",
    "print(dos)\n",
    "print(tres)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}