01_Intro.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Intro.ipynb",
      "version": "0.3.2",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o_M49AGEMVD0",
        "colab_type": "text"
      },
      "source": [
        "# Introducción a Python \n",
        "\n",
        "Esta es una celda de texto, ya que está seleccionada la opción \"Markdown\" en \"Cell Type\". Para editar este texto, hacer doble click y luego ejecutar la celda con shift-enter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZaCFW0iyMVD4",
        "colab_type": "text"
      },
      "source": [
        "Para introducir un comando lo escribimos en una celda tipo \"Code\" y lo ejecutamos con shift-enter:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hw7R8pjbMVD6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(\"Hola mundo\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "24mE-jhLMVEF",
        "colab_type": "text"
      },
      "source": [
        "En Python, el texto que sigue a un caracter # se lo considera un comentario y no es ejecutado. Los comentarios perminten mejorar la legibilidad de los programas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9TwVZO98MVEG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Este es un comentario\n",
        "print(\"Hola mundo\") # este también"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jQqY5u0SMVEM",
        "colab_type": "text"
      },
      "source": [
        "#Variables"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IduuNN6TMVEN",
        "colab_type": "text"
      },
      "source": [
        "Para almacenar datos se utilizan variables, que tiene un nombre y un contenido. El nombre debe empezar con una letra o el caracter underscore (_)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yYs5oijVMVEO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "texto = \"Hola Mundo\"\n",
        "print(texto)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RSIl4LZqMVER",
        "colab_type": "text"
      },
      "source": [
        "Las variables en Python tienen tipos de datos definidos (números enteros, números reales, cadenas de caracteres), pero no es necesario definir a priorir el tipo de datos. La función `type()` nos permite conocer el tipo de datos de una variable:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tt-YQJ51MVES",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 2\n",
        "kT = 25.3e-3"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uJoGaEssMVEV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nKJbKy5QMVEY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(kT)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L47ZAlTOMVEd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "type(texto)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AxAzHA8VMVEg",
        "colab_type": "text"
      },
      "source": [
        "Se puedne convertir los datos de un tipo a otro utilizando una función que es el tipo de datos de destino, por ejemplo `int()` o `str()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-sf_Iwl5MVEh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "float(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Eit7jlU7MVEk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "int(kT)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ZewntTEMVEo",
        "colab_type": "text"
      },
      "source": [
        "Si la conversión no es posible, Python nos dará un mensaje de error:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n7CBMEUOMVEo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "int(texto)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Krtd-EMMVEt",
        "colab_type": "text"
      },
      "source": [
        "Python maneja tipos dinámicos, esto es, el tipo de la variable está definido por el valor que contiene. Por ejemplo, lo siguiente es completamente válido:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2NE4MS9jMVEu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 1\n",
        "print(type(x))\n",
        "x = 0.1\n",
        "print(type(x))\n",
        "x = \"hola mundo\"\n",
        "print(type(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cDsC4ta0MVEy",
        "colab_type": "text"
      },
      "source": [
        "Python posee además variables de tipo booleano:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fTtD2bZYMVEz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = (1 == 0)\n",
        "print(type(a))\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hSNa7n-NMVE4",
        "colab_type": "text"
      },
      "source": [
        "acá, asignamos a la variable `a` el resultado de la comparción entre `1` y `0`. El resultado es una variable typo `bool`con el valor `False`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hI2EXT1HMVE5",
        "colab_type": "text"
      },
      "source": [
        "En Python existe además un valor especial para variables no inicializadas: `None`. Esto permite diferenciar entre variables con una inicialización trivial (0 o \"\") y variables no inicializadas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IdefpURqMVE6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = None\n",
        "b = 2\n",
        "print(type(a))\n",
        "print(a+b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-c0DUXNNMVE_",
        "colab_type": "text"
      },
      "source": [
        "#Operadores"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dDFxr6a7MVFA",
        "colab_type": "text"
      },
      "source": [
        "Para realizar operaciones con variables, la sintaxis de Python posee operadores. Estos operadores pueden ser unarios (operando sobre una única variable), binarios o ternarios:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-bOhoAgMVFB",
        "colab_type": "text"
      },
      "source": [
        "* Operadores unarios:\n",
        "    * positivo: `+x`\n",
        "    * negativo: `-x`\n",
        "    * negación lógica: `not x`\n",
        "    * inversión de bits: `~x` (convierte los unos en ceros y los ceros en unos en la represetación binaria de x)\n",
        "    * borrado de una variable: `del x`\n",
        "    * llamado a la variable: `x()` (devuelve su valor)\n",
        "    * afirmación: `assert x` (devuelve un error si el valor de `bool(x)` es `False`)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qk4YDRc8MVFD",
        "colab_type": "text"
      },
      "source": [
        "* Operadores binarios:\n",
        "    * asignación: `x=y` (coloca en x el valor de y).\n",
        "    * acceso a atributos: `x.y` (accede al atributo `y` dentro de la variable `x`)\n",
        "    * indexado: `x[y]` (devuelve el valor de `x` en la posición `y`)\n",
        "    * borrado de un elemento: `del x[y]` (borra el elemento `y`-esimo de la variable x)\n",
        "    * Y lógico: `x and y`\n",
        "    * O lógico: `x or y`    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wnC0pBIJMVFE",
        "colab_type": "text"
      },
      "source": [
        "* Operadores binarios aritméticos:\n",
        "    * suma, resta, multiplicación, división: `x+y, x-y, x*y, y/y`.\n",
        "    * división entera: `x//y` (ojo, en Python 2, / entre enteros también es división entera)\n",
        "    * resto: `x%y`.\n",
        "    * exponente: `x**y`\n",
        "    * Y bit a bit: `x & y`\n",
        "    * O bit a bit: `x | y`\n",
        "    * XOR bit a bit: `x ^ y`\n",
        "    * left shift: `x << y`\n",
        "    * right shift: `x >> y`\n",
        "    * Operadores inplace: `x+=y, x*=y, x-=y, x/=y`, etc. Realiza la operación y modifica el valor de `x`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KRe5-eYqMVFF",
        "colab_type": "text"
      },
      "source": [
        "* Operadores binarios de comparación:\n",
        "    * igual: `x == y`\n",
        "    * desigual: `x != y`\n",
        "    * menor: `x < y`\n",
        "    * menor o igual: `x <= y`\n",
        "    * mayor: `x > y`\n",
        "    * mayor o igual: `x >= y`\n",
        "    * contenido: `x in y` (devuelve `True` si `x` es parte de `y`)\n",
        "    * contenido: `x not in y` (devuelve `True` si `x` no es parte de `y`)\n",
        "    * identidad: `x is y` (devuelve `True` si `x` apunta al mismo lugar de memoria que `y`)\n",
        "    * identidad: `x is not y` (devuelve `False` si `x` apunta al mismo lugar de memoria que `y`)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u5AMHCVjMVFH",
        "colab_type": "text"
      },
      "source": [
        "* Operadores ternarios:\n",
        "    * asignación ternaria: `x = y = z`, `x` e `y` reciben el valor de z\n",
        "    * asignación de atributos: `x.y = z`, el atributo `y`de `x` recibe el valor `z`.\n",
        "    * asignación por índice: `x[y] = z`, el elemento `y` de `x`recibe el valor `z`.\n",
        "    * comparación ternaria: `x < y < z`, equivalente a `(x < y) and (y < z)`. `<` puede reemplazarse por otro operador de comparación.\n",
        "    * O ternario: `x if y else z`, si `y` es `True` devuelve `x`, caso contrario devuelve `z`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cWXZ6fUCMVFJ",
        "colab_type": "text"
      },
      "source": [
        "#Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fs43g7WkMVFJ",
        "colab_type": "text"
      },
      "source": [
        "Las cadenas de caracteres (strings) son uno de los tipos de datos fundamentales de Python. El tipo de datos se llama `str`, y se definen utilizando comillas simples o dobles:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0pCS3E0pMVFK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = \"Hola\"\n",
        "y = 'mundo'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oSbLLXTyMVFO",
        "colab_type": "text"
      },
      "source": [
        "En Python 2 las cadenas de caracteres están formadas por caracteres ASCII y existe otro tipo de datos (unicode string) para cadenas de caracteres Unicode. En Python 3 directamente el tipo de datos string soporta Unicode. En Python 2 las cadenas Unicode se representan antenponiendo la letra u a la definición de la cadena:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s0vItFBaMVFQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "unicode_str = u'Es válido utilizar acentos y eñe' \n",
        "print(unicode_str)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BT2lu5XUMVFT",
        "colab_type": "text"
      },
      "source": [
        "Para acceder a los caracteres de la cadena se utiliza el operador binario de indexado (x[y]). Los índices en Python empiezan en 0, como en C."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T97s0TfEMVFT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = \"Hola\"\n",
        "print(x[0])\n",
        "print(x[1])\n",
        "print(x[2])\n",
        "print(x[3])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "267t4B5pMVFX",
        "colab_type": "text"
      },
      "source": [
        "El largo del string puede obtenerse con la función `len()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jiojEekRMVFX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "len(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "99vHpLOcMVFb",
        "colab_type": "text"
      },
      "source": [
        "El índice -1 es el último elemento, y es equivalente a hacer x[len(x)-1]:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WeEBK_XuMVFc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x[-1])\n",
        "print(x[len(x)-1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vvXPvyyZMVFf",
        "colab_type": "text"
      },
      "source": [
        "El elemento anteúltimo es -2 y así sucesivamente:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JdHw-CWZMVFg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x[-1])\n",
        "print(x[-2])\n",
        "print(x[-3])\n",
        "print(x[-4])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JPd7NOaXMVFm",
        "colab_type": "text"
      },
      "source": [
        "Para obtener partes de un string se utilizan *slices*: `x[inicio:fin]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T_ye9fxkMVFo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x[0:2])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pw69aar-MVFr",
        "colab_type": "text"
      },
      "source": [
        "El comienzo y el final son opcionales."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nTWXbTUiMVFs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x[:2])\n",
        "print(x[1:])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UAX9GtKFMVFw",
        "colab_type": "text"
      },
      "source": [
        "Las cadenas de caracteres pueden ser manipuladas de distintas formas. Una es la concatenación, que se reliza  utilizando el operador de adicion:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nQgVKLiCMVFx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "z = x + y\n",
        "print(z)\n",
        "z = x + \" \" + y\n",
        "print(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hv0LNnHxMVF0",
        "colab_type": "text"
      },
      "source": [
        "Para crear cadenas de caracteres que incluyan saltos de linea se puede utilizar la comilla triple o incluir el caracter de escape \\n:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S7K6b7eqMVF1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = '''Este\n",
        "es \n",
        "un\n",
        "ejemplo.'''\n",
        "b = 'Y\\neste\\nes otro.'\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mvQoM6jFMVF4",
        "colab_type": "text"
      },
      "source": [
        "Las variables en Python pueden tener dentro otras variables (atributos) e incluso funciones (métodos). Estos atributos y métodos se acceden con el operador \".\". En IPython uno puede acceder a los atributos y métodos disponibles escribiendo . y presionando la tecla [TAB]. Por ejemplo, para pasar a mayúsculas y minúsculas podemos hacer:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h5Srvjq1MVF6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x.upper())\n",
        "print(x.lower())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f5rY1s0JMVF8",
        "colab_type": "text"
      },
      "source": [
        "es importante notar que `.upper()` y `.lower` no modifican la variable sino que devuelven una copia de la variable con los caracteres en mayúsculas o minúsculas. Eso podemos verificarlo haciendo:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xruKA7O0MVF_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qcx7rT4fMVGE",
        "colab_type": "text"
      },
      "source": [
        "Para generar cadenas con valores variables (en forma similar al `sprintf` de C), se utiliza el método `.format()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PUCkt9nWMVGF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = \"{0} {1} hoy es {2} {3}.\".format(x,y,\"Martes\", 7)\n",
        "print(a)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3qSwlVwoMVGI",
        "colab_type": "text"
      },
      "source": [
        "#Módulos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I6Sbzc3dMVGJ",
        "colab_type": "text"
      },
      "source": [
        "Una de las grandes ventajas de Python es la facilidad que tiene para reutilizar código. Esto se realiza a través de *módulos*. Por ejemplo, en el mismo directorio donde tengo este Notebook de Jupyter, tengo un archivo llamado constantes.py, que puedo ver usando la directiva de Ipython para ejecutar comandos de shell:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w9ARwG9OMVGL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "!wget --quiet -O constantes.py \"https://onedrive.live.com/download?cid=22422A8EEA2A85B9&resid=22422A8EEA2A85B9%21108&authkey=AK6QExN9Iqi8Qns\"\n",
        "!cat constantes.py"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EyddSmECMVGR",
        "colab_type": "text"
      },
      "source": [
        "Para utilizar esto dentro de iPython debo importarlo, y como Python es muy intuitivo eso se realiza con la palabra `import`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BmVOUowTMVGR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import constantes"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-CLoFPvcMVGe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(constantes.kT)\n",
        "print(constantes.pi)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGeJV_jLMVGj",
        "colab_type": "text"
      },
      "source": [
        "Si sólo quisieramos importar alguna de las variables desde el módulo constantes, podemos hacerlo con la palabra `from`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Z1EtOdEMVGk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from constantes import pi"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5J7Dn1cTMVGm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(pi)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xEx7atJwMVGp",
        "colab_type": "text"
      },
      "source": [
        "constantes es un nombre largo. Esto se puede cambiar utilizando la palabra `as`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GZq6rkIQMVGs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import constantes as ctes"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gtHwbVyRMVGu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(ctes.kT)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fs0tCWceMVGy",
        "colab_type": "text"
      },
      "source": [
        "Un conjunto de módulos de Python se denomina paquete (package). Cada paquete contiene varios módulos, que pueden importarse utilizando el operador \".\". Por ejemplo, el paquete os incluye varios módulos. Uno de ellos, path, permite obtener información sobre los directorios:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTjCOLEMMVGz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from os import path"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BKAEBIwgMVG1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(path.curdir)\n",
        "print(path.realpath(path.curdir))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BwU9jePaeUQM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}