Semana_1_1_Introduccion_al_Entorno_de_Programacion.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y9dsTp15PcVE"
      },
      "source": [
        "![Data Science Black@300x.png](https://i.imgur.com/eJKkh5m.png)\n",
        "\n",
        "# ¡Bienvenidos al taller \"Learning to Code with Dell Technologies\"!\n",
        "\n",
        "En este taller estaremos aprendiendo el Lenguaje de programación Python muy versátil y divertido para muchas cosas.\n",
        "\n",
        "El entorno que estas viendo se llama CoLab y esta basado en \"notebooks\" o libretas que permite ejecutar tu código en la nube.\n",
        "\n",
        "## ¿Que es Python y Colab?\n",
        "\n",
        "Python es un lenguaje de programación que permite ejecutar las instrucciones que le indiques.\n",
        "\n",
        "Colab es el entorno que ejecuta el codigo Python y te lo muestra en pantalla de manera interactiva.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ndwVRcbr7vWs"
      },
      "source": [
        "En Colab tenemos campos de contenido como este que estamos leyendo, pero ademas tiene campos de codigo python como el que vez abajo:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JUT9RytI7umb"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VeWvNU2S8Axs"
      },
      "source": [
        "En los campos de codigo puedes escribir codigo Python y presional en el boton de ejecutar para ver el resultado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VAeIyvgR8KMk",
        "outputId": "bcb60066-c917-418d-cd70-933f6c220218"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "1+1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HdlaZmsihnl1",
        "outputId": "584a5e35-72d7-4162-f943-6114d8d2e308"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "2+2\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qqmKcJMN-fZt"
      },
      "source": [
        "En Python adicionalmente tenemos la caracteristica de colocar comentarios explicativos que no afectan la ejecucion del programa. Estos se escriben dentro del código utilizando el caracter '#':\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j6sl3bOo-uWe"
      },
      "outputs": [],
      "source": [
        "# Este es un comentario dentro de Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kJkv8aDH7tgt"
      },
      "source": [
        "# ¿Que es programar?\n",
        "\n",
        "\"Programar es el simple acto de escribir instrucciones para que una computadora las ejecute\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kvwFByHgRUkn",
        "outputId": "c62074fc-d6fb-4f56-e288-c55901176bf0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Hola Mundo!!!!!\n"
          ]
        }
      ],
      "source": [
        "print(\"Hola Mundo!!!!!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GHpHTj0LRdmV"
      },
      "source": [
        "# ¿Que es eso que acabo de escribir?\n",
        "\n",
        "Viéndolo paso a paso primero tenemos la instruccion \"print\" que significa en español \"imprimir\"\n",
        "\n",
        "Luego tenemos paréntesis que representan la forma que Python utiliza para asignar datos a una instruccion.\n",
        "\n",
        "Luego abrimos comillas y escribimos el mensaje que quiere imprimir en pantalla\n",
        "\n",
        "Al final, tenemos un bonito \"Hola Mundo\" como tipo de dato de texto solamente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZmrkiWvCTu9_"
      },
      "source": [
        "# ¿Qué son los tipos de datos?\n",
        "\n",
        "En cualquier lenguaje de programación de alto nivel se manejan tipos de datos. Los tipos de datos definen un conjunto de valores que tienen una serie de características y propiedades determinadas.\n",
        "\n",
        "Para saber el tipo de un dato en python utilizamos la instrucción **type()**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yjYQY4AM0YA8"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QuZJwCs2TxCA"
      },
      "source": [
        "## Tipo cadena de texto\n",
        "\n",
        "Conocido en Python como String o en su abreviacion\t**str**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jHWLUAS30hOV",
        "outputId": "65bd022d-29b6-47cf-ee77-e49ddc4ec2ff"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(\"este es un texto\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "WhZAHghYTy9-",
        "outputId": "32fc2a9f-9be0-4f98-f78b-a0811a8670d3"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Este es un tipo texto'"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "'Este es un tipo cadena de texto en comillas simples'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "o0dkZMZ3xw2J",
        "outputId": "971fa90e-e830-4074-a005-4dfc6e6f3e44"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Tambien puedo escribir un tipo texto en comillas dobles'"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"Tambien puedo escribir un tipo texto en comillas dobles\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rfepDCoJx74p"
      },
      "source": [
        "Tambien puedes escribir tipo texto que tenga varias lineas, donde el caracter especial '\\n' se refiere al caracter nueva linea"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "CMHGm43Qxpli",
        "outputId": "76b865ab-999b-42d9-ea36-2832af493d5b"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'\\nEste es un tipo texto\\nque puedo escribir en varias lineas\\n'"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\"\n",
        "Este es un tipo texto\n",
        "que puedo escribir en varias lineas\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NmMaVSSGyyBL"
      },
      "source": [
        "## Tipo Numero\n",
        "\n",
        "En Python representamos los números segun su tipo:\n",
        "\n",
        "- Entero\n",
        "- Flotante\n",
        "- Imaginarios"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p8pmRE-U0Ap1"
      },
      "source": [
        "### Enteros\n",
        "\n",
        "Para un entero podemos escribir el numero solamente y Python lo va a aceptar como válido:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e6im5j56T5B-",
        "outputId": "f6fc9ab3-eb05-40cb-a80b-09bea096e41e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PlgCdaxK0sQd",
        "outputId": "746cd3df-a776-4a1d-e0fb-e457bb09abd6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "412312"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "412312"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1RVrEg-sGC7D"
      },
      "source": [
        "Tambien los numeros pueden ser negativos, utilizando el simbolo '-'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CGoq0UVWGIe4",
        "outputId": "58283115-13f4-4510-d182-ce628c91feca"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "-1"
            ]
          },
          "execution_count": 36,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "-1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jPJKjGNn1yMx"
      },
      "source": [
        "Los enteros los podemos escribir tambien en 3 formas especiales adicionales que son binario, hexadecimal y octal."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bgm-SOT44h64",
        "outputId": "d67669d7-92f1-43a4-891c-a8f02f60cda8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "0b101010"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J5H0wEPa0vFH"
      },
      "source": [
        "### Flotante\n",
        "\n",
        "Para un flotante, nos estamos refiriendo a un numero con punto decimal:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pEtH0KuI0t_9",
        "outputId": "e78263cb-d952-4d10-bbf1-82613f4e314e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(3.141516)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I537C50h04Tt",
        "outputId": "46a32318-38af-49f1-eb9f-3cd283561fe8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2.728127"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "2.728127"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VAUUZ3eL0_md"
      },
      "source": [
        "Para un número imaginario colocamos la letra 'j' al lado del número:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "15bwdBwW1Qd2",
        "outputId": "ba6c3169-134f-48f5-baf6-2c2aac154983"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "2j"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "2j"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d1Zi3yjs1Z3e"
      },
      "source": [
        "## Tipo Boleano\n",
        "\n",
        "Con el tipo booleano nos referimos al concepto de si algo es cierto o falso.\n",
        "\n",
        "En Python el tipo booleano principalmente se refiere a **True** o **False**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aVvHwxOy1qe-",
        "outputId": "53796d8d-d0b1-4786-b58d-774f919ea909"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "frEAVi7e1toe",
        "outputId": "0fd44495-63c7-4224-c2f6-5158ef2fda2c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KN4NrvmY9Yx7"
      },
      "source": [
        "## Conversiones de Tipos de Datos\n",
        "\n",
        "Algunos de los tipos de datos que mencionamos anteriormente, pueden ser convertidos entre ellos siempre y cuando sea posible:\n",
        "\n",
        "- Para convertir a entero usamos la instruccion **int()**\n",
        "- Para convertir a flotante utilizamos la instruccion **float()**\n",
        "- Para convertir a cadena de texto utilizamos la instruccion **str()**\n",
        "\n",
        "Por ejemplo, podemos convertir el numero flotante 3.141516 a entero de la siguiente manera:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RJh8ippV-Ug-",
        "outputId": "5e98095d-eea6-495c-c14d-aca400ef3b04"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "int(3.141516)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4e9NrtbU-ZTs"
      },
      "source": [
        "Tambien podemos convertir del tipo cadena a flotante utilizando str() y vicevesa con float()\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "U1tvyP1tClHi",
        "outputId": "2476bbbc-0b96-4275-8d66-5f08d43a6fb3"
      },
      "outputs": [
        {
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'3.141516'"
            ]
          },
          "execution_count": 34,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "str(3.141516)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oo8Lxl19CvT4",
        "outputId": "ff1270c4-02a5-48b0-a522-b7644459760f"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "3.141516"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "float(\"3.141516\") # Nótese las comillas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQW2K8kxUD19"
      },
      "source": [
        "# Entendiendo errores en el Entorno de Programacion\n",
        "\n",
        "Cuando hay un error, Python muestra el tipo de error y su definición.\n",
        "\n",
        "Ademas muestra en que linea necesitas corregir.\n",
        "\n",
        "Por ejemplo abajo se nos muestra una error de division por 0."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 169
        },
        "id": "MuxgSCsaT0z3",
        "outputId": "f1b4ab4d-9ca6-48b2-fec4-5586bbc92b4c"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-9e1622b385b6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ],
      "source": [
        "1/0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EK9R9CXDTezN"
      },
      "source": [
        "# Talleres\n",
        "\n",
        "Ahora pondremos este conocimiento en practica y veremos algunos ejercicios juntos de los tipos basicos de datos en Python e interactuaremos con el entorno:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gUuLkStNAvPv"
      },
      "source": [
        "2. ¿Cuál es el tipo de dato de **8.1238812**?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XE05OEx9AtMS"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q0ja5FvfA5b4"
      },
      "source": [
        "3. ¿Cual es el tipo de dato de un emoji **'😊'**?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r61SIHx8BGHH"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QMYAfhu-BceQ"
      },
      "source": [
        "5. ¿Que tipo de dato es **False**?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ktopWNB3BnOg"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Semana_1.1_Introduccion al Entorno de Programacion.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}