Created
July 11, 2022 21:02
-
-
Save Scot3004/c5a562df9ca6509820f6320b5e4c6900 to your computer and use it in GitHub Desktop.
Introducción a python.ipynb
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "nbformat": 4, | |
| "nbformat_minor": 0, | |
| "metadata": { | |
| "colab": { | |
| "name": "Introducción a python.ipynb", | |
| "provenance": [], | |
| "collapsed_sections": [], | |
| "authorship_tag": "ABX9TyOag5VvwggcC/Rw1HfnDir9", | |
| "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/gist/Scot3004/c5a562df9ca6509820f6320b5e4c6900/introducci-n-a-python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Saludo\n", | |
| "\n", | |
| "Hola, El dia de hoy vamos a estar aprendiendo a programar en **python** usando **jupyter notebook**, esto para ir directo al código sin preocuparnos sobre como instalamos python localmente.\n", | |
| "En el mundo de la ciencia de datos es muy común usar dicha herramienta para hacer scripts de prueba y compartir las notas sobre lo que se va desarrollando." | |
| ], | |
| "metadata": { | |
| "id": "z74-K0dggw1U" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Adicionar nuevos bloques\n", | |
| "\n", | |
| "en jupyter existen 2 tipos de bloques, texto y código\n", | |
| "\n", | |
| "Para adicionar uno nuevo en collab colocamos el mouse en el espacio en blanco entre los bloques donde se quiere agregar y este nos va a preguntar el tipo de bloque a ser adicionado\n", | |
| "\n", | |
| "\n", | |
| "Cuando selecccionamos **Text**, podemos agregar markdown para la edición\n", | |
| "\n", | |
| "Cuando seleccionamos **Code**, podemos agregar un fragmento de código\n", | |
| "\n" | |
| ], | |
| "metadata": { | |
| "id": "Q-a-SqrGSuy4" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Que es python\n", | |
| "\n", | |
| "Python es un lenguaje de programación interpretado creado por Guido Van Rossum por alla en los años 90 el cual es destaca por su facilidad de lectura y escritura, python puede ser usado tanto para la web, como la automatización de tareas repetitivas (si, las pruebas entran en esta categoria), tambien como herramienta para procesar datos masivos\n", | |
| "\n" | |
| ], | |
| "metadata": { | |
| "id": "BWcuH3xq_Yr7" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Paradigmas de programación en python\n", | |
| "\n", | |
| "El paradigma también se puede denominar como un método para resolver algunos problemas o realizar algunas tareas. Un paradigma de programación es un enfoque para resolver el problema usando algún lenguaje de programación o también podemos decir que es un método para resolver un problema usando herramientas y técnicas que están disponibles para nosotros siguiendo algún enfoque." | |
| ], | |
| "metadata": { | |
| "id": "EyyCCrvAz5FK" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Hola mundo\n", | |
| "\n", | |
| "Como buena introducción a cualquier lenguaje de programación, aprender a imprimir un mensaje en pantalla es de las primeras cosas aprendemos, ademas de servir para corroborar que la herramienta quedo instalada satisfactoriamente, vamos a iniciar con uno de mis programas favoritos \"Hola mundo\", para lo cual nos apoyaremos en la función `print` la cual nos imprime por consola lo que escribamos entre comillas.\n", | |
| "\n", | |
| "A continuación tenemos un ejemplo de código, prueba a colocar tu nombre dentro de las comillas y presiona el botón para ejecutar el código  para que veas que sucede en tu pantalla\n" | |
| ], | |
| "metadata": { | |
| "id": "nL_FgrKm_h9g" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": null, | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "pzOVDKtvgfSS", | |
| "outputId": "9eaca486-1776-417b-c72e-e88deaa82ebb" | |
| }, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "hola\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "print(\"hola\")" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Variables\n", | |
| "\n", | |
| "En python podemos definir variables que nos permitan representar los valores que vamos necesitando en nuestros scripts\n", | |
| "\n", | |
| "por ejemplo podemos definir una variable llamada nombre para luego imprimir nuestro nombre en pantalla" | |
| ], | |
| "metadata": { | |
| "id": "KFbkqt7VoWJD" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "nombre = \"Sergio\"\n", | |
| "print(\"Hola \" + nombre)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "Ou_7RNgdoaCl", | |
| "outputId": "0f7f2a8f-3876-4a88-a911-8621ef5f8055" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "Hola Sergio\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "\n", | |
| "\n", | |
| "## Tipos de datos\n", | |
| "\n", | |
| "Python es un lenguaje de programación fuertemente tipado de tipado dinamico, esto quiere decir que podemos crear variables con cualquier tipo de datos sin preocuparnos por declarar explicitamente el tipo\n", | |
| "\n", | |
| "> Python posee un mecanismo ([Type hints](https://peps.python.org/pep-0484/)) con el que se puede definir los tipos que se van a usar, algo asi como lo que se hace con typescript." | |
| ], | |
| "metadata": { | |
| "id": "zSLPKLxGm9-a" | |
| } | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Cadenas de caracteres\n", | |
| "\n", | |
| "En los ejemplos anteriores hemos estado usando cadenas de caracteres para imprimir nuestro nombre en pantalla, estas cadenas de caracteres en python tienen el tipo de dato `str`" | |
| ], | |
| "metadata": { | |
| "id": "9yGNvP6zpykx" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "type(nombre)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "jNBXR2ehqBgr", | |
| "outputId": "7023fde4-1658-4fef-e2e0-142a78d6f387" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "str" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 8 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "### Format\n", | |
| "En lo personal para concatenar cadenas recomiendo usar la función format en lugar del operador +, esta nos permite incluso definir formato para la salida de las variables" | |
| ], | |
| "metadata": { | |
| "id": "Kp-0NZKMv4ox" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "print(\"Hola {}\".format(nombre))" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "VHBPZbKxv5X0", | |
| "outputId": "2072b1ac-de7d-4981-9d63-917f9618a36b" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "Hola Sergio\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## **Números**\n", | |
| "\n", | |
| "Python tambien puede trabajar con números y soporta las operaciones básicas como la suma `+`, resta `-`, multiplicación `*`, división`/`, división entera `//`, exponenciación `**`" | |
| ], | |
| "metadata": { | |
| "id": "J6fRY6mXq6Ka" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "1 + 2 " | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "DeKZQnP_rXoB", | |
| "outputId": "77dd50c1-cef6-437b-9614-b3b32f80310d" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "3" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 9 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "3 - 2" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "77UNOgb6ra1k", | |
| "outputId": "d51d2c3d-efcf-485f-d777-f1fd0f927610" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "1" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 10 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "7 * 3" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "S57oUq01rhPK", | |
| "outputId": "b2ccdf5f-b6e5-42cf-d574-f832c3e801db" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "21" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 11 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "2 ** 3" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "4XIDVbblruTI", | |
| "outputId": "761ac54d-d2ab-459f-8acb-b30a29e5f975" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "8" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 16 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "30 / 4" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "siYOV1Whrj8E", | |
| "outputId": "0787ca04-3748-482f-9a92-25f1a80ec1ab" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "7.5" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 15 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "30 // 4" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "jlO4KyDcrlmu", | |
| "outputId": "e8a7f43a-8c0c-4305-b089-48859793c9e9" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "7" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 14 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "En cuanto a los numeros de coma flotante (float) recomiendo ser muy cuidadoso, dado que en python por defecto estos se representan en base 2, por lo cual al igual que en otros lenguajes de programación sumar `0.1 + 0.2` puede no dar el resultado esperado `0.3`" | |
| ], | |
| "metadata": { | |
| "id": "RjS1lvH2sKnJ" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "type(0.1)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "dBXApyfQscdm", | |
| "outputId": "67630575-c766-4778-efec-1d2a8f42d60c" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "float" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 18 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "0.1 + 0.2" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "Dnyvy4posShz", | |
| "outputId": "fbec62f4-fc4a-4823-f0a0-09b6dff0ed3e" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "0.30000000000000004" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 17 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Python tambien tiene soporte a números complejos" | |
| ], | |
| "metadata": { | |
| "id": "WfKk5VLe3pof" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "complex_number = 1 + 2j\n", | |
| "print(complex_number)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "7VMwjvzr3uyM", | |
| "outputId": "765936cf-4afa-46eb-9645-e4cac200c178" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "(1+2j)\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "1j**2" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "4QF_zo_N375p", | |
| "outputId": "8263e22c-aba8-4ec7-f478-c04164f71bfe" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "(-1+0j)" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 50 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Import\n", | |
| "\n", | |
| "Hay veces que los tipos de datos que vienen pre cargados en python no nos son suficientes para lo cual necesitamos importar \"objetos\" externos por ejemplo funciones o bien clases, en python el código esta organizado en paquetes y módulos\n", | |
| "\n", | |
| "\n", | |
| "Recuerdan ese ejemplo donde intentabamos sumar `0.1 + 0.2`, bueno para poderlo resolver vamos a importar la clase `Decimal` del módulo `decimal` el cual nos va a permitir operar sobre números en base 10" | |
| ], | |
| "metadata": { | |
| "id": "aNDDuUI1xEou" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "from decimal import Decimal\n", | |
| "Decimal('0.1') + Decimal('0.2')" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "RdLjbGhhs3HB", | |
| "outputId": "efa1a847-b25e-4655-f828-a95752d93fcf" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "Decimal('0.3')" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 87 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "En python podemos importar el módulo completo" | |
| ], | |
| "metadata": { | |
| "id": "owNPK7utCYE6" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "import decimal\n", | |
| "decimal.Decimal('0.1') + decimal.Decimal('0.2')" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "q81F-HBBCN2j", | |
| "outputId": "58f17dc0-02fa-42b9-db02-e238d8985404" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "Decimal('0.3')" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 88 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Incluso podemos poner alias con la palabra `as`" | |
| ], | |
| "metadata": { | |
| "id": "GpnqbqPMCfjs" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "import decimal as dec\n", | |
| "dec.Decimal('0.1') + dec.Decimal('0.2')" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "HhVMTHU9CUJX", | |
| "outputId": "269532d9-7ba8-4e1a-c93f-88c0df41f568" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "Decimal('0.3')" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 89 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Listas\n", | |
| "\n", | |
| "en python podemos tener colecciones de objetos donde tengamos un listado de elementos donde necesitemos agregar o quitar valores (es decir mutables) para lo cual podemos usar listas (list) representadas con corchetes " | |
| ], | |
| "metadata": { | |
| "id": "66IOKVu30w1R" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "lista = [\"a\", \"b\", \"c\", \"a\"]\n", | |
| "print(lista)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "0HKXXxCl1Eze", | |
| "outputId": "153f2c56-0fe2-4b02-e5f8-87e061fa3dd9" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "['a', 'b', 'c', 'a']\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "print(type(lista))" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "_20alw3b1pxH", | |
| "outputId": "4e746218-bab2-44ba-f8fb-5059dad7935c" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "<class 'list'>\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "lista.append(\"z\")\n", | |
| "print(lista)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "m1joKzi216_i", | |
| "outputId": "cfddda7b-f7cc-4b79-c821-37c81e1ae996" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "['a', 'b', 'c', 'a', 'z']\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "En algunos escenarios no vamos a querer que los elementos de nuestra lista sea mutable para lo cual lo mas recomendable es usar una tupla (tuple)\n", | |
| "\n" | |
| ], | |
| "metadata": { | |
| "id": "x_BYDTRd1J5M" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "tupla = (\"a\", \"b\", \"c\", \"a\")\n", | |
| "print(tupla)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "319fdAyn1SdA", | |
| "outputId": "82becb64-6996-4f72-f515-bce266ca1823" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "('a', 'b', 'c', 'a')\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "type(tupla)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "QFSlwoY_2d_5", | |
| "outputId": "7b9e79ea-254f-4880-ea9a-955addd1dea7" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "tuple" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 38 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "## Diccionarios\n", | |
| "En algunos escenarios, podriamos a llegar a necesitar collecciones de clave valor, para lo cual podemos usar diccionarios (dict)" | |
| ], | |
| "metadata": { | |
| "id": "fMCv_8U52mKs" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "sergio_orozco = {\"nombre\": \"Sergio\", \"apellido\": \"Orozco\", \"listado\": [1, 2, 3]}\n", | |
| "\n", | |
| "print(sergio_orozco)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "TLqubihI2k-c", | |
| "outputId": "6fc1041a-c132-47d1-ee52-bf4c911451b1" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "{'nombre': 'Sergio', 'apellido': 'Orozco', 'listado': [1, 2, 3]}\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "type(sergio_orozco)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "hLeZPXOB3YyA", | |
| "outputId": "f789d6d1-b8b6-4125-ed64-cd6f12784f2b" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "dict" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 45 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Crear Funciones\n", | |
| "\n", | |
| "Podemos crear funciones usando la palabra reservada def con el nombre de la función que deseamos crear, por ejemplo crearemos una función suma" | |
| ], | |
| "metadata": { | |
| "id": "ZjWZgkob4nDH" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "def suma(a, b):\n", | |
| " return a + b\n", | |
| "\n", | |
| "print(suma(3, 4))\n", | |
| "print(suma(-1, 4))" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "1VT1rItM41Ow", | |
| "outputId": "f7a1fa8e-af31-47df-e973-b6fdc4fc9ffc" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "7\n", | |
| "3\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Condicionales\n", | |
| "\n", | |
| "En python podemos hacer uso de condicionales para ejecutar o no un fragmento de código" | |
| ], | |
| "metadata": { | |
| "id": "964Xmzzs5Zoo" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "def mayor_de_edad(edad):\n", | |
| " if(edad >= 18):\n", | |
| " print(\"nos tomamos unas polas?\")\n", | |
| " elif(edad>=2):\n", | |
| " print(\"quieres un helado?\")\n", | |
| " else:\n", | |
| " print(\"quien es un bebe bonito?\")\n", | |
| " \n", | |
| "mayor_de_edad(21)\n", | |
| "mayor_de_edad(12)\n", | |
| "mayor_de_edad(1)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "nb6KLY0k5iuY", | |
| "outputId": "6c75c282-672d-47f8-8280-8c2cd23baa57" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "nos tomamos unas polas?\n", | |
| "quieres un helado?\n", | |
| "quien es un bebe bonito?\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Ciclos\n", | |
| "\n", | |
| "En python podemos usar ciclos repetitivos para iterar una colección, por ejemplo podemos usar un **for** para sacar los cuadrados de una lista" | |
| ], | |
| "metadata": { | |
| "id": "eXe5rdqs6dQf" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "numeros = [2, 3, 6, 8]\n", | |
| "cuadrados = []\n", | |
| "\n", | |
| "for numero in numeros:\n", | |
| " cuadrados.append(numero**2)\n", | |
| "\n", | |
| "print(cuadrados)" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "wWijA7nL6i8S", | |
| "outputId": "e0cbc24f-2199-4b6a-e1db-810e0d1ad1f4" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "name": "stdout", | |
| "text": [ | |
| "[4, 9, 36, 64]\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Claro, que tambien hay una forma condensada de hacer el ejercicio anterior que puede ser usando list comprehension" | |
| ], | |
| "metadata": { | |
| "id": "DaYLn6PL67N2" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "[numero ** 2 for numero in numeros]" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "CdU6CMuf7BgR", | |
| "outputId": "7be47d0d-3107-46e7-b458-d52736ba209c" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "output_type": "execute_result", | |
| "data": { | |
| "text/plain": [ | |
| "[4, 9, 36, 64]" | |
| ] | |
| }, | |
| "metadata": {}, | |
| "execution_count": 62 | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Tambien se puede crear un ciclo repetitivo **while**, por ejemplo podemos seguir preguntando siempre si nos dan un valor distinto de 's'" | |
| ], | |
| "metadata": { | |
| "id": "MMuRV4fx9gVi" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "respuesta = 's'\n", | |
| "while respuesta == 's':\n", | |
| " respuesta = input(\"Desea continuar? \")" | |
| ], | |
| "metadata": { | |
| "colab": { | |
| "base_uri": "https://localhost:8080/" | |
| }, | |
| "id": "5Px-8Ait9tTk", | |
| "outputId": "0424235f-322c-4401-c194-205ae3a52d91" | |
| }, | |
| "execution_count": null, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "Desea continuar? s\n", | |
| "Desea continuar? s\n", | |
| "Desea continuar? s\n", | |
| "Desea continuar? n\n" | |
| ] | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "# Conclusión\n", | |
| "\n", | |
| "Python es un lenguaje bastante potente en el cual puedes realizar entre otras cosas automatizaciones de tareas repetitivas, o bien practicar tu lógica en programación, de hecho seria interesante si en este ultimo bloque escribes una funcion que te diga si una palabra es palidroma o no, (se lee igual si escribes los caracteres al reves), y un conversor de temperaturas" | |
| ], | |
| "metadata": { | |
| "id": "ClNnCaiQhl2u" | |
| } | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "def palindrome(n):\n", | |
| " pass" | |
| ], | |
| "metadata": { | |
| "id": "io0WGF02iQTz" | |
| }, | |
| "execution_count": null, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "source": [ | |
| "def temp_in_farenheit(degrees):\n", | |
| " pass" | |
| ], | |
| "metadata": { | |
| "id": "RLrScrvZpfqS" | |
| }, | |
| "execution_count": null, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "source": [ | |
| "Codecamp es una plataforma que sirve para aprender a programar (está en ingles)echa\n", | |
| "https://www.datacamp.com/courses/intro-to-python-for-data-science\n", | |
| "\n", | |
| "Refactoring guru es un sitio donde se pueden encontrar ejemplos de como implementar patrones de código en distintos lenguajes de programación\n", | |
| "https://refactoring.guru/es/design-patterns/python\n", | |
| "\n", | |
| "Curso de python para principiantes de microsoft\n", | |
| "\n", | |
| "https://docs.microsoft.com/es-es/shows/intro-to-python-development/" | |
| ], | |
| "metadata": { | |
| "id": "HrTw-TtZTR4b" | |
| } | |
| } | |
| ] | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment