1_Conceptos_básicos_solucion.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "1. Conceptos básicos.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/NatBarbosa/CCG2021_Python-para-geolog-s/blob/main/1_Conceptos_b%C3%A1sicos_solucion.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MI17EKmQXzqU"
      },
      "source": [
        "print(\"hola mundo\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5j4CM2gtKwr"
      },
      "source": [
        "---\n",
        "# 1. NUESTRO PRIMER CÓDIGO"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hjJIYhXCPiUL"
      },
      "source": [
        "print(\"Eileen Pertuz)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DyG5KSTZYQgb"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EynDZMQJe6k8"
      },
      "source": [
        "**Clases**\n",
        "\n",
        "**Funciones**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o0Og32sxPuYT"
      },
      "source": [
        "class Roca:\n",
        "\n",
        "  def __init__(self, textura, claros, oscuros, q, a, p):\n",
        "    \n",
        "    self.textura= textura\n",
        "    self.claros= claros\n",
        "    self.oscuros = oscuros\n",
        "    self.q = q\n",
        "    self.a = a\n",
        "    self.p = p\n",
        "  \n",
        "  def cristales(self):\n",
        "    if self.textura == \"faneritica\":\n",
        "      print(f\"Mis cristales se pueden reconocer a simple vista\")\n",
        "    else:\n",
        "      print(f\"Mis cristales no se pueden reconocer a simple vista\")  \n",
        "\n",
        "  def origen(self):\n",
        "    if self.textura ==\"faneritica\":\n",
        "      print(\"Lo mas probable es que sea una roca instrusiva\")\n",
        "    if self.textura == \"afanitica\":\n",
        "      print(\"Lo mas probables es que sea una roca extrusiva\")  "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sfuUPZg9PyfD"
      },
      "source": [
        "#creamos nuestra roca\n",
        "granito= Roca(\"faneritica\",60,40,20,50,30)\n",
        "basalto= Roca(\"afanitica\", 30,70,20,50,30)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6bfzlz7NPyah"
      },
      "source": [
        "#conocer sus atributos\n",
        "granito.textura"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NAI8Q6hGPzWK"
      },
      "source": [
        "granito.cristales()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dLr1_0m4cXoT"
      },
      "source": [
        "basalto.origen()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u0fyYPlLm9Vu"
      },
      "source": [
        "--- \n",
        "**Resumen** \n",
        "\n",
        "Sobre la sintaxis, los comentarios, la indentación etc\n",
        "Python  - objetos, atributos y métodos\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vgMoxR3G8H4A"
      },
      "source": [
        "---\n",
        "# 2. TIPOS DE DATOS\n",
        "\n",
        "\n",
        "2.1 Simples\n",
        " - Numéricos (Entero, Real, Booleano)\n",
        " - Texto (String)\n",
        "\n",
        "2.2 Compuestos \n",
        "  - Lista - Modificable\n",
        "  - Tupla - Inmodificable\n",
        "  - Conjuntos (Set)\n",
        "  - Diccionario - Grupo de pares\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0xGOUhh0ANRi"
      },
      "source": [
        "##2.1 Simples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "67mgJueB9fth"
      },
      "source": [
        "### 2.1.1 Enteros, reales y texto"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TzpLRawrP64y"
      },
      "source": [
        "entero=5\n",
        "print(type(entero))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2svs6g5XQAfx"
      },
      "source": [
        "real=5.2\n",
        "print(type(real))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uZ0lW9H2eKOz"
      },
      "source": [
        "tx=\"Bienvenidos al curso de Python para Geólogos\"\n",
        "print(tx)\n",
        "print(type(tx))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dar2Nt58edyI"
      },
      "source": [
        "#operaciones aritméticas\n",
        "op=entero*real\n",
        "print(op)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zgcKDZnLel_z"
      },
      "source": [
        "#exponente\n",
        "a=50\n",
        "print(a**2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zQc1PitA9UFy"
      },
      "source": [
        "### 2.1.2 Variables booleanas\n",
        "Pueden tomar dos simples valores. En general elementos nulos o vacíos se consideran false y el resto True.\n",
        "\n",
        "*   bT= True \n",
        "*   bF= False\n",
        "\n",
        "**Operadores lógicos (booleanos And, Or, Not)** \n",
        "\n",
        "Son palabras o símbolos que permiten conectar de forma lógica conceptos o grupos de términos para así ampliar, limitar o definir tus búsquedas rápidamente\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l7OYx1RSQE15"
      },
      "source": [
        "#ejemplo con booleanos entero vs vacío\n",
        "\n",
        "bool([])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AO2ZNROwQEo6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24c0db81-8f26-4ad1-f0e8-e39a486c6c8c"
      },
      "source": [
        "bool([25])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VDhjfvPuA3fi"
      },
      "source": [
        "## 2.2 Compuestos\n",
        "Las listas son colecciones ordenadas que pueden contener enteros, booleanos, texto, flotantes, listas y tuplas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3imeattNRS7"
      },
      "source": [
        "### 2.2.1 Listas y tuplas"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DeIEvz_VQJtR",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d16e487c-552d-46cc-d26e-3b917cfe7178"
      },
      "source": [
        "lista=[\"a\",True, 25, [\"minerales\"], (3,2)]\n",
        "print(lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['a', True, 25, ['minerales'], (3, 2)]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AjKcEI-tQP6e"
      },
      "source": [
        "tupla=(3,\"geología\", False, (5,2))\n",
        "print(tupla)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RtSEpF1BHPd3"
      },
      "source": [
        "**Acceder y recorrer una lista y/o tupla**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bxeHnThVQK-h"
      },
      "source": [
        "#como acceder a los elementos\n",
        "lista=[\"a\",True, 25, [\"minerales\"], (3,2)]\n",
        "print(lista[2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v4gtEbYaQK0Z"
      },
      "source": [
        "print(tupla[3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G6qyKxX_QWvy"
      },
      "source": [
        "tipos_roca=[\"gabro\",\"basalto\",\"granito\",\"esquisto\"]\n",
        "\n",
        "for roca in tipos_roca:\n",
        "  print(roca)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-viboBW0QWhI"
      },
      "source": [
        "#recorrieno los índices\n",
        "\n",
        "for i in range(len(tipos_roca)):\n",
        "  print(tipos_roca[i])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xF7xhTABI_La"
      },
      "source": [
        "**Listas vs Tuplas**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xM2cvyCQaKx"
      },
      "source": [
        "l=[\"a\",\"b\",35, False]\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sDnOoo3zQacx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e97e091-f202-4670-9223-acf9a836fbb0"
      },
      "source": [
        "l[3]=[\"cambio\"]\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['a', 'b', 35, ['cambio']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AlcP6K7lQaxJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "523cd89a-ae83-4205-96c7-5225b776111e"
      },
      "source": [
        "l[:3]=[2,4]\n",
        "print(l)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[2, 4, ['cambio']]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r7rfrkXTh_0c"
      },
      "source": [
        "t=(3,4,50)\n",
        "t[0]=[3,2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4bLsxuhSBFE"
      },
      "source": [
        "### 2.2.2 Conjuntos\n",
        "\n",
        "Es una colección no ordenada y sin elementos repetidos. Los usos básicos de éstos incluyen verificación de pertenencia y eliminación de entradas duplicadas. Los conjuntos también soportan operaciones matemáticas como la unión, intersección, diferencia, y diferencia simétrica."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T8KeqRE4QeqR"
      },
      "source": [
        "basket={\"apple\",\"orange\", \"apple\",\"banana\",\"pear\"}\n",
        "print(basket)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IAyiabOpQeVZ"
      },
      "source": [
        "\"banana\" in basket"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wJHkaImFQeLx"
      },
      "source": [
        "\"mango\" in basket"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lF5GSKi2OE54"
      },
      "source": [
        "### 2.2.3 Diccionarios\n",
        "\n",
        "Son un tipo de datos asociativos indexados por medio de claves. Es como pensarlo como un conjunto de pares clave:valor con el requerimiento de que las claves sean únicas (dentro de un diccionario)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fUZtRwaZQjpK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e44a2055-e3af-48de-d0b7-fc0eaae8884c"
      },
      "source": [
        "dic={\"plagioclasa\":20, \"olivino\":30, \"feldespato\":False}\n",
        "print(dic)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'plagioclasa': 20, 'olivino': 30, 'feldespato': False}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mb2q39iyLcwj"
      },
      "source": [
        "**Concepto de claves**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LOdyON7TQj9J"
      },
      "source": [
        "#cómo acceder a las claves\n",
        "d={\"a\":3,\"b\":14, \"c\":True}\n",
        "print(d[\"a\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "__--eA5AQkOp"
      },
      "source": [
        "for a in d.items():\n",
        "  print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MKofeVuIQkeh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2698a9e2-3775-4296-c7af-c69464d2b278"
      },
      "source": [
        "#puedo modificar los elementos \n",
        "d[\"b\"]= True\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'a': 3, 'b': True, 'c': True}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MocykA4c233Q"
      },
      "source": [
        "---\n",
        "\n",
        "# 3. LIBRERÍAS\n",
        "\n",
        "Numpy es una librería de Python especializada en el cálculo numérico y el análisis de datos especialmente para un gran volumen de datos. Incorpora una nueva clase de objetos llamados arreglos (arrays) que permite representar colecciones de datos de un mismo tipo en varias dimensiones, y funciones muy eficientes para su manipulación.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1i-lbLti7BqrDtMJwcy5hrma2hMzSq33k\" width=300 />"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yYqNpNms__R0"
      },
      "source": [
        "## 3.1. Concepto de arreglos (Array)\n",
        "\n",
        "**La clase de objetos array**\n",
        "\n",
        "Un array es una estructura de datos de un mismo tipo organizada en forma de tabla o cuadrícula de distintas dimensiones.\n",
        "\n",
        "Las dimensiones de un array también se conocen como ejes.\n",
        "\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1_DUGbiJxn2CcIwkx0HKpLd6dr9Uw9A5R\" width=400 />\n",
        "\n",
        "\n",
        "Los arreglos tienen algunas similitudes con las listas:\n",
        "\n",
        "- Los elementos tienen un orden y se pueden acceder mediante su posición\n",
        "\n",
        "- Los elementos se pueden recorrer usando un ciclo for\n",
        "\n",
        "**Restricciones:**\n",
        "\n",
        "- Todos los elementos del arreglo deben ser del mismo tipo\n",
        "\n",
        "- En general, el tamaño del arreglo es fijo van creciendo dinámicamente como las listas\n",
        "\n",
        "- Se ocupan principalmente para almacenar datos numéricos\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VR5jFXdERMPq"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mM5lwkTPRMyj"
      },
      "source": [
        "arraylista=[20,50,30,58]\n",
        "print(type(arraylista))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x4yqfOQuRT0k"
      },
      "source": [
        "arraynp= np.array(arraylista)\n",
        "print(type(arraynp))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IT3Oea7lRTy_"
      },
      "source": [
        "matriz= np.array([(1,2,3), (4,5,6)])\n",
        "print(matriz)\n",
        "matriz.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N3zlHZcgRTPh"
      },
      "source": [
        "c= np.array([[[[1,2], [3,4]], [5,6], [7,8]]])\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fo5kRugURTHC"
      },
      "source": [
        "c.shape\n",
        "c.size"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9UudKCiERS95",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1bddb246-e28f-4c5a-aab9-bf595cce042c"
      },
      "source": [
        "print(c[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[list([1, 2]) list([3, 4])]\n",
            " [5 6]\n",
            " [7 8]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eqftUezXRSyK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f5b4c2e9-0ed7-4ce6-e9c1-17119b0fb53e"
      },
      "source": [
        "print(arraynp)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[20 50 30 58]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "za6-kTzHRScp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c2db16a7-c007-45b8-ad05-bcb63a2f92e9"
      },
      "source": [
        "print(arraynp[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "58\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "onmsOuzNRSSy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3d966fee-efeb-4690-beeb-08da44b56917"
      },
      "source": [
        "print(arraynp[0:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[20 50]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lqQUbjj9C6D9"
      },
      "source": [
        "---\n",
        "**Resumen**\n",
        "\n",
        "\n",
        "Python tiene como base diversos tipos de datos. Sin embargo, no existen los areglos (arrays).\n",
        "\n",
        "Para usar arreglos usamos una librería llamada Numpy - https://numpy.org/\n",
        "\n",
        "Para acceder a las funciones de numpy usamos notación punto\n",
        "\n",
        "El arreglo es un tipo de dato principal en el análisis espacial de datos. Arreglos bi-dimensionales son usados para representar modelos de elevacion digital (columnas y filas). Arreglos multi-dimensionales son usados para almacenar y procesar imagenes espectrales/multiespectrales y series de tiempo.\n",
        "\n",
        "Para acceder a los datos contenidos en un arreglo usamos *índices*. Los índices nos indican la posicion de un dato (pixel) en el arreglo. Entender este concepto es ¡fundamental! \n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZZXIYXOPDuE"
      },
      "source": [
        "# 4. MANEJO DE DIRECTORIOS\n",
        "\n",
        "El acceso a los datos para usar en el código es un tarea principal a la hora de programar. \n",
        "\n",
        "- Los datos para este curso fueron enviados con anterioridad. Por favor descargarlos y tenerlos en una carpeta de Google Drive. \n",
        "\n",
        "**Manejo de archivos y directorios**\n",
        "\n",
        "La librería para manejar directorios en Python se llama **os** - Provee funciones para interactuar con el sistema operativo.\n",
        "\n",
        "Para acceder a tus datos desde Google Colab necesitas:\n",
        "\n",
        "* Una autenticación desde tu cuenta asociada al Drive\n",
        "\n",
        "* Conexión de Google Colab con la carpeta donde almacenamos los datos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JAiQw47aRnQZ"
      },
      "source": [
        "from google.colab import drive\n",
        "import os"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QG5yO67URo6J",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07b5a6ec-1ef3-4558-a765-1c5f49e681cb"
      },
      "source": [
        "#conecta tu Drive con Colab\n",
        "drive.mount('/content/GoogleDrive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/GoogleDrive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1ItoqDwARoZB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b7675b13-ed23-4ffb-d333-87a0cc0d68bd"
      },
      "source": [
        "#¿Cuál es tu directorio?\n",
        "cwd= os.getcwd()\n",
        "print(\"pinte el directorio actual:\", cwd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "pinte el directorio actual: /content/GoogleDrive/My Drive/CourseData\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ExWSZ0SqRrFp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "309b0b8c-b389-428d-8a8e-75d82ec61b9f"
      },
      "source": [
        "os.chdir('/content/GoogleDrive/My Drive/CourseData')\n",
        "print(cwd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/content/GoogleDrive/My Drive/CourseData\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bEY8oJZggQ-y"
      },
      "source": [
        "* ¿Qué información está almacenada en la carpeta del curso? "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e1U-1jIhRz0h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "673f3bce-2c41-4560-c850-7995b6089b16"
      },
      "source": [
        "dir_lista=os.listdir(cwd)\n",
        "print(dir_lista)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['Dia1', 'EjercicioFinal', 'Dia2']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1k0OH6ErvreM"
      },
      "source": [
        "---\n",
        "\n",
        "**Resumen**\n",
        "\n",
        "Para acceder desde Google Colab a nuestro datos necesitamos:\n",
        "\n",
        "1. Tenerlos almacenados en la nube de Google Drive\n",
        "2. Autenticar el ingreso a nuestro datos\n",
        "\n",
        "Para navegar y modificar nuestras carpetas usamos las funciones de la libraría **os**\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "crxKW9gUZM7g"
      },
      "source": [
        "## 4.1 ¿Cómo acceder a todos los datos dentro de una carpeta?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Yda2IjmdHsN6"
      },
      "source": [
        "\n",
        "\n",
        "Vemos que nuestra carpeta tiene otra carpeta dentro (subdirectorio). Para listar todos los archivos dentro de la carpeta necesitamos entrar a las subcarpetas. Esto lo podemos hacer por medio de un *bucle* \n",
        "\n",
        "**Bucles**\n",
        "\n",
        "Los bucles son herramientas de programación que permiten alterar el flujo normal de un programa. Nos permiten repetir una porción del código tantas veces como queramos. \n",
        "\n",
        "Sintaxis:\n",
        "\n",
        "1. Palabra clave 'for'.\n",
        "2. Declarar la variable donde se alojarán los items del elemento iterable.\n",
        "3. Operador 'in'.\n",
        "4. Elemento a iterar (lista, directorio, cadena, etc).\n",
        "5. Cuerpo de la repetición - acción a realizar.\n",
        "\n",
        "Para crear una lista de directorios, carpetas y nombres de archivos usamos la función walk de la libreria os. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gib5uZyGR5ay",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c36b6bca-895e-4436-de48-385641067fdd"
      },
      "source": [
        "lista=[]\n",
        "\n",
        "for dirpath, dirnames, files in os.walk(cwd):\n",
        "  for name in files:\n",
        "    lista.append(name)\n",
        "\n",
        "print(lista)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['._AP_20744_FBS_F0060_RT1.dem.tif', '._Findme1.tif', '._Findme.tif', '._Findme2.tif', '._Readme copy.rtf', '._Readme.rtf', '._Rocas.png', '._Findme.tif', 'Icon_', 'Findme1.tif', 'Findme.tif', 'Findme2.tif', 'Readme copy.rtf', 'Readme.rtf', 'Rocas.png', 'Icon_', 'Findme.tif', 'Icon_', 'AP_20744_FBS_F0060_RT1.dem.tif', 'Icon_', '._EjercicioFinal', '._MM_12.prj', '._MM_12.sbn', '._MM_12.dbf', '._MM_12.shp', '._MM_12.shx', '._MM_12.shp.xml', '._MM_12.sbx', '._MM_12.cpg', '._Cuencas proyectadas.dbf', '._Cuencas proyectadas.sbn', '._Cuencas proyectadas.shx', '._Cuencas proyectadas.sbx', '._Cuencas proyectadas.shp.xml', '._Cuencas proyectadas.cpg', '._Cuencas proyectadas.shp', '._Cuencas proyectadas.prj', '._Medellin_5m.tif', '._S2A_MSIL2A_20200218T152631_N0214_R025', '._R20m', '._.DS_Store', '._R10m', '._B02_20mB02_20m.tif', '._B02_20mB03_20m.tif', '._B02_20mB04_20m.tif', '._B02_20mB05_20m.tif', '._B02_20mB06_20m.tif', '._B02_20mB07_20m.tif', '._B02_20mB11_20m.tif', '._B02_20mB8A_20m.tif', '._B02_20mB12_20m.tif', '._B02_10cmB02_10m.tif', '._B02_10cmB03_10m.tif', '._B02_10cmB04_10m.tif', '._B02_10cmB08_10m.tif', 'MM_12.prj', 'MM_12.sbx', 'MM_12.sbn', 'MM_12.shp.xml', 'MM_12.shx', 'MM_12.cpg', 'MM_12.shp', 'MM_12.dbf', 'Cuencas proyectadas.dbf', 'Cuencas proyectadas.shx', 'Cuencas proyectadas.sbx', 'Cuencas proyectadas.sbn', 'Cuencas proyectadas.shp', 'Cuencas proyectadas.shp.xml', 'Cuencas proyectadas.prj', 'Cuencas proyectadas.cpg', 'Medellin_5m.tif', 'Icon_', '.DS_Store', 'Icon_', 'B02_10cmB02_10m.tif', 'B02_10cmB03_10m.tif', 'B02_10cmB04_10m.tif', 'B02_10cmB08_10m.tif', 'Icon_', 'B02_20mB03_20m.tif', 'B02_20mB02_20m.tif', 'B02_20mB04_20m.tif', 'B02_20mB05_20m.tif', 'B02_20mB06_20m.tif', 'B02_20mB07_20m.tif', 'B02_20mB11_20m.tif', 'B02_20mB8A_20m.tif', 'B02_20mB12_20m.tif', 'Icon_', 'Icon_', 'AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.prj', 'AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf', 'AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shx', 'AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shp', 'catchments@subset_4@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf', 'catchments@subset_4@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shp', 'catchments@subset_4@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.prj', 'catchments@subset_4@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shx', 'catchments@subset_3@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shp', 'catchments@subset_3@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.shx', 'catchments@subset_3@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.prj', 'catchments@subset_3@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf', 'Icon_', 'Icon_', 'Icon_', 'T18NVK_20190822T152641_B03_10m.jp2', 'T18NVK_20190822T152641_B02_10m.jp2', 'T18NVK_20190822T152641_B04_10m.jp2', 'T18NVK_20190822T152641_TCI_10m.jp2', 'T18NVK_20190822T152641_B08_10m.jp2', 'Icon_', 'T18NVK_20190822T152641_AOT_20m.jp2', 'T18NVK_20190822T152641_SCL_20m.jp2', 'T18NVK_20190822T152641_B04_20m.jp2', 'T18NVK_20190822T152641_WVP_20m.jp2', 'T18NVK_20190822T152641_B12_20m.jp2', 'T18NVK_20190822T152641_B02_20m.jp2', 'T18NVK_20190822T152641_B11_20m.jp2', 'T18NVK_20190822T152641_B8A_20m.jp2', 'T18NVK_20190822T152641_B05_20m.jp2', 'T18NVK_20190822T152641_B03_20m.jp2', 'T18NVK_20190822T152641_B07_20m.jp2', 'T18NVK_20190822T152641_B06_20m.jp2', 'T18NVK_20190822T152641_TCI_20m.jp2', 'Icon_', 'T18NVK_20190822T152641_AOT_60m.jp2', 'T18NVK_20190822T152641_B02_60m.jp2', 'T18NVK_20190822T152641_B03_60m.jp2', 'T18NVK_20190822T152641_B07_60m.jp2', 'T18NVK_20190822T152641_B01_60m.jp2', 'T18NVK_20190822T152641_B05_60m.jp2', 'T18NVK_20190822T152641_B09_60m.jp2', 'T18NVK_20190822T152641_B11_60m.jp2', 'T18NVK_20190822T152641_B12_60m.jp2', 'T18NVK_20190822T152641_SCL_60m.jp2', 'T18NVK_20190822T152641_B06_60m.jp2', 'T18NVK_20190822T152641_B8A_60m.jp2', 'T18NVK_20190822T152641_TCI_60m.jp2', 'T18NVK_20190822T152641_WVP_60m.jp2', 'T18NVK_20190822T152641_B04_60m.jp2', 'Icon_', '._S2A_MSIL2A_20190822T152641_N0213_R025_T18NVK_20190822T210428', '._R20m', '._R60m', '._R10m', '._T18NVK_20190822T152641_B03_10m.jp2', '._T18NVK_20190822T152641_B02_10m.jp2', '._T18NVK_20190822T152641_B04_10m.jp2', '._T18NVK_20190822T152641_TCI_10m.jp2', '._T18NVK_20190822T152641_B08_10m.jp2', '._T18NVK_20190822T152641_AOT_20m.jp2', '._T18NVK_20190822T152641_SCL_20m.jp2', '._T18NVK_20190822T152641_B04_20m.jp2', '._T18NVK_20190822T152641_WVP_20m.jp2', '._T18NVK_20190822T152641_B11_20m.jp2', '._T18NVK_20190822T152641_B12_20m.jp2', '._T18NVK_20190822T152641_B8A_20m.jp2', '._T18NVK_20190822T152641_B02_20m.jp2', '._T18NVK_20190822T152641_B05_20m.jp2', '._T18NVK_20190822T152641_B03_20m.jp2', '._T18NVK_20190822T152641_B07_20m.jp2', '._T18NVK_20190822T152641_TCI_20m.jp2', '._T18NVK_20190822T152641_B06_20m.jp2', '._T18NVK_20190822T152641_AOT_60m.jp2', '._T18NVK_20190822T152641_B02_60m.jp2', '._T18NVK_20190822T152641_B07_60m.jp2', '._T18NVK_20190822T152641_B03_60m.jp2', '._T18NVK_20190822T152641_B01_60m.jp2', '._T18NVK_20190822T152641_B06_60m.jp2', '._T18NVK_20190822T152641_SCL_60m.jp2', '._T18NVK_20190822T152641_B12_60m.jp2', '._T18NVK_20190822T152641_B11_60m.jp2', '._T18NVK_20190822T152641_B05_60m.jp2', '._T18NVK_20190822T152641_B09_60m.jp2', '._T18NVK_20190822T152641_B8A_60m.jp2', '._T18NVK_20190822T152641_TCI_60m.jp2', '._T18NVK_20190822T152641_WVP_60m.jp2', '._T18NVK_20190822T152641_B04_60m.jp2']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ATBnP1MBZV7W"
      },
      "source": [
        "## 4.2 ¿Cómo crear una lista con los archivos que contiene una extensión de interés?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PxEHvj9-Voyr"
      },
      "source": [
        "\n",
        "\n",
        "De la lista de archivos queremos tener la lista de todos los .tif. Para esto usamos condicionales.\n",
        "\n",
        "*Condicionales*\n",
        " \n",
        "Los condicionales se usan para tomar decisiones.\n",
        "Consisten básicamente en las siguientes partes principales:\n",
        "\n",
        "- Una prueba que evalúa a verdadero o falso.\n",
        "- Un bloque de código que se ejecuta si la prueba es verdadero.\n",
        "- Un bloque opcional de código si la prueba es falsa.\n",
        "\n",
        "Sintaxis del if:\n",
        "\n",
        "1. Palabra clave 'if'\n",
        "2. Condición\n",
        "3. Acción\n",
        "4. Palabra clave 'else' (opcional)\n",
        "5. Otra acción\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GpTRUA2rR_X7"
      },
      "source": [
        "extension=\"tif\"\n",
        "list_tif=[]\n",
        "\n",
        "for dirpath, dirnames, files in os.walk(cwd):\n",
        "  for name in files:\n",
        "    if name[-3:]== extension:\n",
        "      list_tif.append(name)\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "u05r0iX4sJhr",
        "outputId": "282c0c2d-b286-4744-fd90-b6e67c700eda"
      },
      "source": [
        "print(\"la lista con la extension .tiff\")\n",
        "print(\"\\n\".join(list_tif))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "la lista con la extension .tiff\n",
            "._AP_20744_FBS_F0060_RT1.dem.tif\n",
            "._Findme1.tif\n",
            "._Findme.tif\n",
            "._Findme2.tif\n",
            "._Findme.tif\n",
            "Findme1.tif\n",
            "Findme.tif\n",
            "Findme2.tif\n",
            "Findme.tif\n",
            "AP_20744_FBS_F0060_RT1.dem.tif\n",
            "._Medellin_5m.tif\n",
            "._B02_20mB02_20m.tif\n",
            "._B02_20mB03_20m.tif\n",
            "._B02_20mB04_20m.tif\n",
            "._B02_20mB05_20m.tif\n",
            "._B02_20mB06_20m.tif\n",
            "._B02_20mB07_20m.tif\n",
            "._B02_20mB11_20m.tif\n",
            "._B02_20mB8A_20m.tif\n",
            "._B02_20mB12_20m.tif\n",
            "._B02_10cmB02_10m.tif\n",
            "._B02_10cmB03_10m.tif\n",
            "._B02_10cmB04_10m.tif\n",
            "._B02_10cmB08_10m.tif\n",
            "Medellin_5m.tif\n",
            "B02_10cmB02_10m.tif\n",
            "B02_10cmB03_10m.tif\n",
            "B02_10cmB04_10m.tif\n",
            "B02_10cmB08_10m.tif\n",
            "B02_20mB03_20m.tif\n",
            "B02_20mB02_20m.tif\n",
            "B02_20mB04_20m.tif\n",
            "B02_20mB05_20m.tif\n",
            "B02_20mB06_20m.tif\n",
            "B02_20mB07_20m.tif\n",
            "B02_20mB11_20m.tif\n",
            "B02_20mB8A_20m.tif\n",
            "B02_20mB12_20m.tif\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VjDM926EZ2UQ"
      },
      "source": [
        "## 4.3 FUNCIÓN PARA ITERAR SOBRE ARCHIVOS"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wk9dVsNgcSL1"
      },
      "source": [
        "**Funciones**\n",
        "\n",
        "Una funcion permite definir un bloque de código reutilizable que se puede ejecutar muchas veces dentro de un programa. \n",
        "\n",
        "Sintaxis:\n",
        "\n",
        "1. Palabra clave 'def'\n",
        "2. Nombre de la función - se recomienda que sea autoexplanatoria, escrita en letras minúsculas y si incluye muchas palabras separarlas con _ para mejorar claridad\n",
        "3. Paréntesis con parámetros de entrada\n",
        "4. Dos puntos\n",
        "5. Bloque de código a ejecutar\n",
        "6. Sentencia de retorno (opcional)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0uc95hi2SD6S"
      },
      "source": [
        "def search_files(directory, extension):\n",
        "  list_tif=[]\n",
        "  for dirpath, dirnames, files in os.walk(cwd):\n",
        "    for name in files:\n",
        "      if name[-3:]== extension:\n",
        "        list_tif.append(name)\n",
        "  return list_tif\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OSNsovNlSEXl"
      },
      "source": [
        "list_tif_function=search_files(cwd, \"tif\")\n",
        "print(list_tif_function)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eMitKI4USElB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b86f73e0-5a80-49a8-854c-8b591e27603c"
      },
      "source": [
        "list_tif_function=search_files(cwd, \"dbf\")\n",
        "print(list_tif_function)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['._MM_12.dbf', '._Cuencas proyectadas.dbf', 'MM_12.dbf', 'Cuencas proyectadas.dbf', 'AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf', 'catchments@subset_4@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf', 'catchments@subset_3@AP_20744_FBS_F0060_RT1.dem_TH_1_LEN_1_MA.dbf']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ybZx6gIdXX99"
      },
      "source": [
        "---\n",
        "**Resumen**\n",
        "\n",
        "Los bucles se usan para repetir una acción. \n",
        "\n",
        "**for** variable **in** iterable: \n",
        "  accción\n",
        "\n",
        "Los condicionales nos sirven para tomar decisiones. \n",
        "\n",
        "**if** condicion: \n",
        "  acción 1 \n",
        "**elif**: \n",
        "  acción 2 \n",
        "**else**: \n",
        "  acción 3\n",
        "\n",
        "Las funciones nos sirven para repetir la misma linea de codigo en nuestro programa sin necesidad de escribir todo de nuevo. \n",
        "\n",
        "**def** mi_funcion(a,b):\n",
        "  c = a*b\n",
        "  return c\n",
        "\n",
        "Recordar la importancia de indentar en python\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2EtOy_9QecHO"
      },
      "source": [
        "# RESUMEN DEL DÍA 1-1\n",
        "\n",
        "Con este ejercicio ya sabes:\n",
        "\n",
        "* Cuales son los tipos de datos que se pueden usar en python y como usarlos\n",
        "\n",
        "* Importar librerías, documentación y funciones\n",
        "\n",
        "* Usar las librerías os para acceder, buscar rutas y directorios\n",
        "\n",
        "* Usar bucles y condicionales\n",
        "\n",
        "* Crear funciones"
      ]
    }
  ]
}