{ "cells": [ { "cell_type": "markdown", "id": "9109d18c-eaf3-42d3-b632-cf5e79917052", "metadata": {}, "source": [ "# B: Introducción a Python\n", "\n", "Python es un lenguaje de programación interpretado multipropósito que se está imponiendo como estándar para el análisis de datos.\n", "\n", "> **Lenguaje de programación:** Lenguaje artificial que se utiliza para programar (darle órdenes) a un ordenador sobre las acciones que tiene que realizar.\n", "\n", "> **Interpretado:** Un lenguaje interpretado utiliza un programa de ordenador *(intérprete)* que va leyendo línea a línea el programa de ordenador y traduciéndolo \"sobre la marcha\" a las instrucciones que utiliza el procesador para funcionar.\n", "\n", "> **Multipropósito:** Lenguaje que no está específicamente diseñado para un tipo de tareas. En principio se puede usar Python para programar \"cualquier cosa\".\n", "\n", "\n", "En este curso la mayoría de los ejemplos se desarrollan utilizando los ```notebooks``` de ```Jupyter```. Estos consisten en una página similar a una página web donde se pueden introducir pequeños scripts de Python directamente y que un interprete que integra un servidor web los puede ejecutar en línea. De hecho esto que ahora mismo estás leyendo es uno de esos ```notebooks``` (aunque puede que lo estés viendo como la versión \"página web\", es decir, sin la posibilidad de ejecutar los scripts directamente, sino con los resultados directamente mostrados. Si aún no has instalado Python ni Jupyter, consulta la [página de instalación](A-1-instalacion.ipynb).\n", "\n", "A continuacion ponemos algún enlace que puede venirte bien para ahondar en algunos de los conceptos que veremos:\n", "\n", "+ [Aprende Python](https://aprendepython.es/): Un curso de Python en general. Muy completito y en español\n", "\n", "A continuación haremos una muy breve introducción a Python mediante ejemplos sencillos." ] }, { "cell_type": "markdown", "id": "7cd29c0b-0781-4169-8ea6-e830848268b4", "metadata": {}, "source": [ "## ¡Hola Mundo!\n", "\n", "Cuando se enseña programación es típico comenzar con el ejemplo \"mínimo\" que se podría programar. Típicamente dicho programa lo único que hace es imprimir un texto: ```¡Hola mundo!```. Para ejecutar el siguiente código sitúate en la celda correspondiente y pulsa la tecla ```Play``` ▶ de la barra superior. Otra opción es pulsar ```Ctrl + INTRO``` estándo en una de las celdas." ] }, { "cell_type": "code", "execution_count": 1, "id": "15b365e7-0fb6-4fae-a5d9-f33692686166", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "¡Hola Mundo!\n" ] } ], "source": [ "print(\"¡Hola Mundo!\")" ] }, { "cell_type": "markdown", "id": "4ee2ec8b-042f-455e-9a42-4c380f8e7a8c", "metadata": {}, "source": [ "Este ejemplo minúsculo ya nos ofrece algo de información sobre este lenguaje de programación: existe una *función* (una rutina) que se llama ```print``` y que lo que hace es imprimir lo que le pasemos como *parámetro* (lo que aparece entre paréntesis. Además, como en este caso lo que queremos es imprimir una cadena de caracteres los debemos poner entre comillas dobles o simples. ```\"¡Hola Mundo!\"``` o ```'¡Hola Mundo!'```.\n", "\n", "Los programas de ordenador normalmente se compondrán de múltiples instrucciones sencillas. Por ejemplo, podemos hacer que nuestro programa imprima más cosas:" ] }, { "cell_type": "code", "execution_count": 2, "id": "c35f6240-7eb2-4d70-b917-0f4eef9f8b6a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Esto es un ejemplo en el que voy a imprimir varias líneas.\n", "Por ahora todo debe resultar trivial.\n", "Ya que solo es imprimir mensajitos.\n" ] } ], "source": [ "print(\"Esto es un ejemplo en el que voy a imprimir varias líneas.\")\n", "print(\"Por ahora todo debe resultar trivial.\")\n", "\n", "print(\"Ya que solo es imprimir mensajitos.\")" ] }, { "cell_type": "markdown", "id": "324e6cd0-653c-4687-8299-f183515e63bc", "metadata": {}, "source": [ "Como habrás apreciado cada instrucción ```print``` ha imprimido la línea que le habíamos escrito. Pese a que entre el segundo ```print``` y el tercero hemos dejado una línea en blanco en nuestro programa, eso no tiene efecto en la salida del mismo." ] }, { "cell_type": "markdown", "id": "1168ccb3-d76e-464e-a4c4-a27a8260ed59", "metadata": {}, "source": [ "## Variables\n", "\n", "Las variables son los \"almacenes de información\" que tenemos disponibles en nuestro programa. A fin de cuentas un programa de ordenador en esencia lo único que hace es transformar información. Las variables en un programa Python pueden llamarse de cualquier manera (usando letras mayúsculas y minúsculas, números y el símbolo ```_```, siempre y cuando no empiecen por un número). Hay que tener en cuenta que los nombres de variables son sensibles a las mayúsculas y minúsculas. Es decir ```variable```, ```Variable```, ```VARIABLE``` y ```VaRiABlE``` son 4 varaibles distintas (cada una contendrá su propia información). Por ejemplo:" ] }, { "cell_type": "code", "execution_count": 3, "id": "ba91a15c-79aa-408a-ac02-1e77bfd6c99c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "John McClane\n", "Luke Skywalker\n" ] } ], "source": [ "nombre = \"John McClane\"\n", "nomBre = \"Luke Skywalker\"\n", "\n", "print(nombre)\n", "print(nomBre)" ] }, { "cell_type": "markdown", "id": "6d9fd695-db74-4ebc-aa5e-f07ad9559da0", "metadata": {}, "source": [ "En este código hemos asignado el valor ```\"John McClane\"``` a una variable que hemos llamado ```nombre```. Para ello hemos utilizado el operador de **asignación** ```=``` para asignar a una variable un valor concreto. Cuando en la instrucción ```print``` le pasamos como parámetro una variable lo que hará será imprimir el valor de dicha variable. ¿Qué pasaría si hubieramos ejecutado lo siguiente?" ] }, { "cell_type": "code", "execution_count": 4, "id": "d306af09-d8c6-49d4-98f7-e7194fd1274d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "nombre\n" ] } ], "source": [ "print(\"nombre\")" ] }, { "cell_type": "markdown", "id": "b29b2131-6068-4127-8648-e99a7a1ee8f6", "metadata": {}, "source": [ "Las variables pueden guardar en su interior información de una naturaleza variada: \n", "+ números enteros (```-7```, ```0```, ```1```), \n", "+ en coma flotante (```-123.456```, ```32.00```), \n", "+ cadenas de caracteres (```\"John McClane\"```) ([30 funciones interesantes sobre cadenas](https://recursospython.com/guias-y-manuales/30-metodos-de-las-cadenas/)),\n", "+ booleanos (verdadero \\[```True```\\] o falso \\[```False```\\]),\n", "+ y otros *tipos* más complejos que veremos más adelante." ] }, { "cell_type": "code", "execution_count": 5, "id": "a6e64394-6663-46f8-9549-e43f3081deeb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "502.5\n" ] } ], "source": [ "precio = 100.5\n", "unidades = 5\n", "\n", "precio_total = precio * unidades\n", "\n", "print(precio_total)" ] }, { "cell_type": "markdown", "id": "881f812d-4d98-4a44-a57b-7c7f8cbaf3fb", "metadata": {}, "source": [ "**Nota interesante:** En Python no se \"debe\" hablar de variables tal y como se entienden en otros lenguajes. Sin embargo comunmente se habla de variables y podemos entendernos bien con ese concepto. Sin embargo hay diferencias que pueden ser sutiles y la gente con conocimientos en otros lenguajes de programación (especialmente los que estén acostumbrados a lenguajes orientados a objetos o a trabajar con \"punteros\"). Puedes [leer más al respecto](https://recursospython.com/guias-y-manuales/diferencia-entre-variables-en-python-y-otros-lenguajes/).\n", "\n", "**Nota interesante 2 sobre tipos y tipado en Python:** [Tipado dinámico y tipado fuerte](https://recursospython.com/guias-y-manuales/tipado-dinamico-y-tipado-fuerte/) es un pequeño artículo que versa sobre el tipado en Python y la herramienta de *anotaciones* que permite obtener algunas de las ventajas del chequeo estático de tipos (en tiempo de compilación) con herramientas adicionales. También en el artículo [Anotaciones en funciones](https://ellibrodepython.com/function-annotations) hablan un poco más del tema." ] }, { "cell_type": "markdown", "id": "121bcad8-84c0-4d45-89e5-64cce037962f", "metadata": {}, "source": [ "## Expresiones y operadores\n", "\n", "El ejemplo anterior asigna dos valores (uno en coma flotante y el otro un entero) a dos variables y utiliza una **expresión** para asignar el resultado de multiplicar ambos valores en la variable ```precio_total```. Las expresiones nos permiten hacer cálculos, llamar a otras funciones o evaluar condiciones lógicas. Algunos **operadores** básicos para componer expresiones:\n", "\n", "+ **Operadores aritméticos:**\n", " + Suma: ```+```\n", " + Resta: ```-```\n", " + Multiplicación: ```*```\n", " + División: ```/```\n", " + División entera: ```//```\n", " + Módulo (resto de la divisón entera): ```%```\n", " + Exponenciación: ```**```" ] }, { "cell_type": "code", "execution_count": 6, "id": "87cbdb5c-9256-496f-aeba-d01218c7fbe1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "82\n" ] } ], "source": [ "print(37 + 45)" ] }, { "cell_type": "code", "execution_count": 7, "id": "cf3ef645-d37d-40fa-a7e9-1c8e2523bdaa", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-8\n" ] } ], "source": [ "print(37 - 45)" ] }, { "cell_type": "code", "execution_count": 8, "id": "12aa01b8-6f2a-44df-a08f-1d9db34a241f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "35\n" ] } ], "source": [ "print(5 * 7)" ] }, { "cell_type": "code", "execution_count": 9, "id": "9abbedab-a536-40c1-ba28-d2e26e883bd2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.6\n" ] } ], "source": [ "print(23 / 5)" ] }, { "cell_type": "code", "execution_count": 10, "id": "fd26b3f3-d54b-477a-a5b4-21be520ee2bc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n" ] } ], "source": [ "print(23 // 5)" ] }, { "cell_type": "code", "execution_count": 11, "id": "7c3f983c-b937-45ee-b1b3-651f3c6ab435", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] } ], "source": [ "print(23 % 5)" ] }, { "cell_type": "code", "execution_count": 12, "id": "7a7f8b54-0148-486c-891d-8bc9f0765ce1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "81\n" ] } ], "source": [ "print(3 ** 4)" ] }, { "cell_type": "markdown", "id": "c657988c-aa49-481f-aa1c-fee8b5d3685c", "metadata": {}, "source": [ "***\n", "**Ejercicio B.1:**\n", "\n", "Calculemos el valor del polinomio $f(x) = a x^2 + bx + c$ (con valores $a$, $b$ y $c$) en un punto $x$ a su elección." ] }, { "cell_type": "code", "execution_count": 13, "id": "9c7b4a21-9473-487f-9572-e5c78f0a2308", "metadata": {}, "outputs": [], "source": [ "#a = \n", "#b =\n", "#c =\n", "#x =\n", "\n", "#resultado = \n", "\n", "#print(resultado)" ] }, { "cell_type": "markdown", "id": "6bceb963-fbe5-4951-90a1-ada506896f2d", "metadata": {}, "source": [ "***\n", "+ **Operadores de comparación:**\n", " + Igualdad: ```==```\n", " + Desigualdad: ```!=```\n", " + Mayor: ```>```\n", " + Menor: ```<```\n", " + Mayor o igual: ```>=```\n", " + Menor o igual: ```<=```" ] }, { "cell_type": "code", "execution_count": 14, "id": "32d26037-367e-4321-9a58-dd3de884884e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "print(3 == 4)" ] }, { "cell_type": "code", "execution_count": 15, "id": "4e433be1-2161-4502-b6a9-1798c1655e27", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(3 + 1 == 4)" ] }, { "cell_type": "code", "execution_count": 16, "id": "b6617199-cce3-49da-bab5-290b6a221cc1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(3 != 4)" ] }, { "cell_type": "code", "execution_count": 17, "id": "b7d78f6f-b43e-407c-832f-5da4baaeb2ab", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "print(3 > 4)" ] }, { "cell_type": "markdown", "id": "e8317888-b8cb-4a02-a219-611494c33e59", "metadata": {}, "source": [ "+ **Operadores lógicos:**\n", " + \"o\" (\"esto o aquello\"): ```or```\n", " + \"y\" (\"esto y aquello\"): ```and```\n", " + Negación (\"no esto\"): ```not```" ] }, { "cell_type": "code", "execution_count": 18, "id": "c0db3d82-ebfc-4a43-85b1-7f0a5efd7ed1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(3 > 4 or 5 == 5)" ] }, { "cell_type": "code", "execution_count": 19, "id": "56bc3427-854b-416e-9dfa-d6c755f23272", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "False\n" ] } ], "source": [ "print(3 > 4 and 5 == 5)" ] }, { "cell_type": "code", "execution_count": 20, "id": "5b19c939-8f33-4437-82d0-5c349c818244", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] } ], "source": [ "print(not(3 > 4))" ] }, { "cell_type": "markdown", "id": "fa87f1af-7e59-461c-b6b2-9ef241919a64", "metadata": {}, "source": [ "+ **Operadores sobre cadenas:**\n", " + Concatenación: ```+```\n", " + Repetición: ```*```" ] }, { "cell_type": "code", "execution_count": 21, "id": "53f3782f-f49d-485d-8cf7-7e4d2b40e968", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hola mundo\n", "Hola Hola Hola Hola Hola \n" ] } ], "source": [ "print(\"Hola \" + \"mundo\")\n", "print(\"Hola \" * 5)" ] }, { "cell_type": "markdown", "id": "54e9ea4e-e4d1-4eb5-9c67-461639172a61", "metadata": {}, "source": [ "Hagamos un pequeño ejemplo más \"complicado\". Supongamos que una foto astronómica tiene 4517 segundos de exposición. ¿Cuantas horas, minutos y segundos son?" ] }, { "cell_type": "code", "execution_count": 22, "id": "76431a82-ef52-4d59-ac81-d74013577c68", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7517 segundos son 2 horas, 5 minutos y 17 segundos\n" ] } ], "source": [ "seg_total = 7517\n", "minutos = seg_total // 60\n", "resto_seg = seg_total % 60\n", "hor = minutos // 60\n", "resto_min = minutos % 60\n", "\n", "print(f\"{seg_total} segundos son {hor} horas, {resto_min} minutos y {resto_seg} segundos\")" ] }, { "cell_type": "markdown", "id": "1ae20646-6c3d-4142-b6a5-2941cee9c6bd", "metadata": {}, "source": [ "En el ejemplo anterior hemos usado algunos operadores aritméticos así como una nueva manera de imprimir información, insertando variables en medio de una cadena. Para eso se utiliza una \"cadena-f\" (```f-string``` [Literal String Interpolation](https://www.python.org/dev/peps/pep-0498/)) donde podemos incluir expresiones dentro de una cadena de caracteres.\n" ] }, { "cell_type": "markdown", "id": "67b5aa6d-424d-471b-a79f-02200e38da2a", "metadata": {}, "source": [ "***\n", "**Ejercicio B.2:**\n", "\n", "Convierta una ascensión recta $ar = 23.572$ a grados $^{\\circ}$, minutos $'$ y segundos $''$." ] }, { "cell_type": "code", "execution_count": 23, "id": "1e12615c-479b-41d9-9b01-3aca4e7f3bd6", "metadata": {}, "outputs": [], "source": [ "#ar = 23.572\n", "#grados =\n", "#minutos =\n", "#segundos =\n", "\n", "#print( )" ] }, { "cell_type": "markdown", "id": "1b3db9b5-80fb-4346-a32a-7320fc27ca45", "metadata": {}, "source": [ "***\n", "## Sentencias condicionales (*if ... else ...*)\n", "\n", "Hasta ahora nuestros scripts están siendo muy \"lineales\", con una ristra de instrucciones que se ejecutan de manera secuencial. Sin embargo en ocasiones querremos que el código que dependiendo de una condición se ejecute un código u otro. Para eso se utiliza la sentencia condicional ```if```, cuya sintaxis básica es:\n", "\n", "```python\n", "if condicion:\n", " bloque de código\n", "```\n", "\n", "donde:\n", "\n", "+ ```if``` es una palabra reservada para este tipo de sentencias\n", "+ ```condicion``` es una expresión (típicamente lógica, que devuelva ```True``` o ```False```)\n", "+ ```:``` delimita el comienzo del bloque de código condicional\n", "+ ``` bloque de codigo``` son las sentencias que tienen que ejecutarse si se cumple la ```condicion```. Es **muy** importante que te des cuenta que el ``` bloque de codigo``` está indentado a la derecha (por ejemplo con un tabulador). Esta es la manera que tiene Python para saber cuales son las sentencias que deben ejecutarse si se cumple la condición o cuales pertenecen a la rama \"principal\" de ejecución. Un ejemplo:" ] }, { "cell_type": "code", "execution_count": 24, "id": "23bdd12d-cfe1-426a-a8a3-e22dad1a960f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "El número 37 es impar\n", "----\n", "Esto se imprime siempre\n" ] } ], "source": [ "num = 37\n", "\n", "# Para comprobar si un número es par obtenemos el resto de dividir por 2 y comprobamos si es 0.\n", "if num % 2 == 0:\n", " print(f\"El número {num} es par\")\n", " print(\"++++\")\n", " \n", "if num % 2 == 1:\n", " print(f\"El número {num} es impar\")\n", " print(\"----\")\n", " \n", "print(\"Esto se imprime siempre\")" ] }, { "cell_type": "markdown", "id": "3db74384-50a7-4d3a-8bd2-87044f02cdfd", "metadata": {}, "source": [ "En el ejemplo hemos incorporado un nuevo elemento. Los \"comentarios\" en el código. En Python, todo lo que venga a continuación del símbolo ```#``` se considera un comentario por lo que podemos incluir anotaciones para nuestro futuro yo que revise el código escrito. Para comentarios multilínea podemos utilizar las comillas triples: ```\"\"\" ... \"\"\"```\n", "\n", "La sentencia condicional tiene la posibilidad de indicar un bloque de código adicional para los casos en los que **no** se cumple la condición:" ] }, { "cell_type": "code", "execution_count": 25, "id": "a95a245d-aaf3-4cc4-a956-91888ea7b3e3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "El número 37 es impar\n", "----\n", "Esto se imprime siempre\n" ] } ], "source": [ "num = 37\n", "\n", "\"\"\"\n", "Para comprobar si un número es par obtenemos el resto\n", "de dividir por 2 y comprobamos si es 0.\n", "\"\"\"\n", "if num % 2 == 0:\n", " print(f\"El número {num} es par\")\n", " print(\"++++\")\n", "else: # Si no se cumple la condición anterior\n", " print(f\"El número {num} es impar\")\n", " print(\"----\")\n", " \n", "print(\"Esto se imprime siempre\")" ] }, { "cell_type": "markdown", "id": "21eeabaa-1cb2-46ea-aa1d-d6e0898044fc", "metadata": {}, "source": [ "Incluso podemos añadir múltiples condiciones para que se vayan comprobando si las anteriores condiciones no se cumplen:" ] }, { "cell_type": "code", "execution_count": 26, "id": "8ddec9ca-7279-49f7-bd6e-33e76029ea65", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "El número es positivo\n" ] } ], "source": [ "num = 37\n", "\n", "if num < 0:\n", " print(\"El número es negativo\")\n", "elif num > 0:\n", " print(\"El número es positivo\")\n", "else:\n", " print(\"El número es 0\")" ] }, { "cell_type": "markdown", "id": "9feec1ee-7a87-4a1e-a3da-3222cd6f3ab5", "metadata": {}, "source": [ "Por \"complicar\" un poco la cosa, el código anterior sería equivalente a \"anidar\" varias sentencias ```if``` (porque los bloques condicionales pueden tener más condiciones en su interior:" ] }, { "cell_type": "code", "execution_count": 27, "id": "671f2586-e336-4540-8e7b-be71cbd8ff70", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "El número es positivo\n" ] } ], "source": [ "num = 37\n", "\n", "if num < 0:\n", " print(\"El número es negativo\")\n", "else:\n", " if num > 0:\n", " print(\"El número es positivo\")\n", " else:\n", " print(\"El número es 0\")" ] }, { "cell_type": "markdown", "id": "f197e00b-02ee-4a6c-89d7-e19a7f059337", "metadata": {}, "source": [ "***\n", "**Ejercicio B.3:**\n", "\n", "Hagamos un bloque de código que identifique un grupo de edad para una edad expresada en años según las siguientes tabla:\n", "\n", "* Menor de 2 años: Bebé\n", "* Entre 2 y 11 años: Niño\n", "* Entre 11 y 18 años: Adolescente\n", "* Entre 18 y 40 años: Adulto joven\n", "* Entre 40 y 60 años: Adulto que se cree joven\n", "* Entre 60 y 100 años: Viejuno\n", "* Más de 100 años: ¿Qué come esta persona?\n" ] }, { "cell_type": "code", "execution_count": 28, "id": "132dc019-991d-4e4b-9a46-28deaa480609", "metadata": {}, "outputs": [], "source": [ "edad = 42 # Cambiar a distintos valores para comprobar nuestro código\n", "\n", "# Escribe aquí tu código" ] }, { "cell_type": "markdown", "id": "17c16f90-825e-420f-828b-a1d890d6f113", "metadata": {}, "source": [ "***\n", "## Más tipos de datos\n", "### Números complejos\n", "\n", "En Python existe de manera nativa el tipo **número complejo**. Para más detalles podemos consultar [Números complejos con Python](https://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/). Algunos ejemplos:" ] }, { "cell_type": "code", "execution_count": 29, "id": "afd5940a-136d-4c34-b488-1f582139384d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Suma: (1+2j)\n", "Multiplicación: (29+31j)\n", "División: (1+2j)\n", "Conjugado: (3+5j)\n", "Valor absoluto: 5.830951894845301\n", "Parte real: 3.0\n", "Parte imaginaria: -5.0\n" ] } ], "source": [ "c1 = 3 + -5j\n", "c2 = complex(-2, 7) # Manera alternativa de definirlos\n", "\n", "print(f\"Suma: {c1 + c2}\")\n", "print(f\"Multiplicación: {c1 * c2}\") \n", "print(f\"División: {c1 + c2}\") \n", "print(f\"Conjugado: {c1.conjugate()}\") \n", "print(f\"Valor absoluto: {abs(c1)}\") \n", "print(f\"Parte real: {c1.real}\") \n", "print(f\"Parte imaginaria: {c1.imag}\")" ] }, { "cell_type": "markdown", "id": "61d7230d-72de-4bae-a8c8-7b52b813b429", "metadata": {}, "source": [ "### Listas (y tuplas)\n", "\n", "Las **colecciones** son un tipo de dato compuesto que agrupa varios valores. Las **listas** son un tipo de colección. Se emplean los símbolos ```[``` y ```]``` para delimitarlos y poder acceder a los componentes individuales de cada lista. Por ejemplo:" ] }, { "cell_type": "code", "execution_count": 30, "id": "43fc6e9c-ee7c-42e2-a0f0-8323747fe99c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 5, 'Pera', (6+4j), 1.618]\n", "Primer elemento: 7\n", "Tercer elemento: Pera\n", "Segundo elemento empezando por el final: (6+4j)\n", "Longitud de la lista: 5\n" ] } ], "source": [ "mi_lista = [7, 5, \"Pera\", 6+4j, 1.6180]\n", "\n", "print(mi_lista)\n", "\n", "print(f\"Primer elemento: {mi_lista[0]}\")\n", "\n", "print(f\"Tercer elemento: {mi_lista[2]}\")\n", "\n", "print(f\"Segundo elemento empezando por el final: {mi_lista[-2]}\") # ¡Cuidado que esto despista!\n", "\n", "print(f\"Longitud de la lista: {len(mi_lista)}\")" ] }, { "cell_type": "code", "execution_count": 31, "id": "c0a3af1b-2645-4317-88a5-e51c9a8d4bdd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Recorte de lista desde el segundo al cuarto elemento: [5, 'Pera', (6+4j)]\n", "Recorte desde el principio hasta el tercero: [7, 5, 'Pera', (6+4j)]\n", "Recorte desde el tercero al final: ['Pera', (6+4j), 1.618]\n" ] } ], "source": [ "print(f\"Recorte de lista desde el segundo al cuarto elemento: {mi_lista[1:4]}\") # ¡Cuidado que esto tambien despista!\n", "\n", "print(f\"Recorte desde el principio hasta el tercero: {mi_lista[:4]}\")\n", "\n", "print(f\"Recorte desde el tercero al final: {mi_lista[2:]}\")" ] }, { "cell_type": "code", "execution_count": 32, "id": "4c940ddd-2625-4528-bf30-163d4daca537", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "¡La pera si está en la lista!\n" ] } ], "source": [ "# Condicional \"si está en la lista\"\n", "if \"Pera\" in mi_lista:\n", " print(\"¡La pera si está en la lista!\")" ] }, { "cell_type": "code", "execution_count": 33, "id": "651ce228-95be-492e-9a08-9495b813f387", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Elemento cambiado: Cthulhu\n" ] } ], "source": [ "# Reemplazar un valor\n", "mi_lista[1] = \"Cthulhu\"\n", "print(f\"Elemento cambiado: {mi_lista[1]}\")" ] }, { "cell_type": "code", "execution_count": 34, "id": "f829604b-84bc-4e03-b54e-aa1ff99e8056", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 'Cthulhu', 'Pera', (6+4j), 1.618, '56.34']\n" ] } ], "source": [ "# Añadir elementos al final de una lista\n", "mi_lista.append(\"56.34\")\n", "print(mi_lista)" ] }, { "cell_type": "code", "execution_count": 35, "id": "65d3a523-69a9-47be-89e9-ce873861dae9", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 'Cthulhu', 'Pera', 'Orion', (6+4j), 1.618, '56.34']\n" ] } ], "source": [ "# Añadir elementos en una posición (insertando en medio)\n", "mi_lista.insert(3, \"Orion\")\n", "print(mi_lista)" ] }, { "cell_type": "code", "execution_count": 36, "id": "6bf5536f-1d15-4d95-adc9-789acfa7c21e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Lista concatenada: [7, 'Cthulhu', 'Pera', 'Orion', (6+4j), 1.618, '56.34', 'Star', 33.45]\n" ] } ], "source": [ "# Concatenar listas\n", "otra_lista = [\"Star\", 33.45]\n", "mi_lista = mi_lista + otra_lista\n", "print(f\"Lista concatenada: {mi_lista}\")" ] }, { "cell_type": "code", "execution_count": 37, "id": "0a0bf153-64bd-4e7e-9c19-37d54c5c7f36", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 'Cthulhu', 'Orion', (6+4j), 1.618, '56.34', 'Star', 33.45]\n" ] } ], "source": [ "# Eliminar un elemento\n", "mi_lista.remove(\"Pera\")\n", "print(mi_lista)" ] }, { "cell_type": "code", "execution_count": 38, "id": "97af19e2-1cd7-45f1-a364-812d82533519", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 'Cthulhu', 'Orion', (6+4j), 1.618, '56.34', 33.45]\n" ] } ], "source": [ "# Eliminar un elemento que está en una posición\n", "mi_lista.pop(-2)\n", "print(mi_lista)" ] }, { "cell_type": "code", "execution_count": 39, "id": "6a0e91a8-238c-4564-a362-fbd196a995f7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[7, 'Cthulhu', 'Orion', (6+4j), 1.618, '56.34']\n" ] } ], "source": [ "# Eliminar el último elemento\n", "mi_lista.pop()\n", "print(mi_lista)" ] }, { "cell_type": "code", "execution_count": 40, "id": "cbe5bfa9-498e-402e-bed6-9eed5dcd2ad4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[]\n" ] } ], "source": [ "# Vaciar una lista\n", "mi_lista.clear()\n", "print(mi_lista)" ] }, { "cell_type": "markdown", "id": "e12822ad-eba1-4f29-b813-c80240e68686", "metadata": {}, "source": [ "***\n", "**Ejercicio B.4:**\n", "\n", "Para la lista dada más abajo consigue que quede con los Planetas ordenados (por proximidad al Sol) usando sustituciones, cortes, etc." ] }, { "cell_type": "code", "execution_count": 41, "id": "ae384665-b72e-4e8f-8129-d4e54de59113", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Mercurio', 'Venus', 'Plutón', 'Tierra', 'Júpiter', 'Saturno', 'Marte', 'Urano', 'Neptuno']\n" ] } ], "source": [ "planetas = [\"Mercurio\", \"Venus\", \"Plutón\", \"Tierra\", \"Júpiter\", \"Saturno\", \n", " \"Marte\", \"Urano\", \"Neptuno\"]\n", "\n", "# Inserta aquí las instrucciones necesarias para que al imprimir la lista salga con los Planetas ordenados\n", "\n", "print(planetas) " ] }, { "cell_type": "markdown", "id": "b09b11e5-e559-4402-9510-f33762fd67c2", "metadata": {}, "source": [ "***\n", "Existe otro tipo de dato básico similar a las listas que son las **tuplas**. En principio son iguales que las listas pero inmutables, es decir, ni sus elementos ni su tamaño se puede variar. Para crear una tupla lo haremos con ```(elem1, elem2, ...)```. " ] }, { "cell_type": "code", "execution_count": 42, "id": "c5a3adeb-3970-4635-bc92-2d3ad4a08202", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(123.2, 'Amstrong', (-31+4.15j))\n" ] } ], "source": [ "tupla = (123.2, \"Amstrong\", -31+4.15j)\n", "\n", "print(tupla)" ] }, { "cell_type": "markdown", "id": "8ac3de68-3aa8-487a-844e-a7890b8c3178", "metadata": {}, "source": [ "### Diccionarios\n", "\n", "Los **diccionarios** son estructuras de datos similares a las listas pero que en vez de estar ordenadas con un índice entero la identificación de los datos se hace mediante una **clave** (*key*) consistente en una cadena de caracteres. Dentro de un diccionario no puede haber dos elementos con la misma clave. Además, a los diccionarios **no** se puede acceder por posición, porque internamente los elementos no se guardan siguiendo un orden particular (al menos no necesariamente)." ] }, { "cell_type": "code", "execution_count": 43, "id": "09ff3d30-01b0-459c-8e3d-eff79b72c526", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'nombre': 'Sirius', 'magnitud': -1.46, 'distancia': 8.6}\n", "Magnitud de Sirius: -1.46\n", "{'nombre': 'Sirio', 'magnitud': -1.46, 'distancia': 8.6}\n" ] } ], "source": [ "estrella = {\n", " \"nombre\": \"Sirius\",\n", " \"magnitud\": -1.46,\n", " \"distancia\": 8.6\n", "}\n", "\n", "print(estrella)\n", "\n", "print(f\"Magnitud de {estrella['nombre']}: {estrella['magnitud']}\")\n", "\n", "# Cambiamos el valor de una clave del diccionario\n", "estrella['nombre'] = \"Sirio\"\n", "print(estrella)" ] }, { "cell_type": "code", "execution_count": 44, "id": "79335730-3b84-420f-87f6-75bf58ae06d4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Claves del diccionario: dict_keys(['nombre', 'magnitud', 'distancia'])\n", "Valores del diccionario: dict_values(['Sirio', -1.46, 8.6])\n" ] } ], "source": [ "print(f\"Claves del diccionario: {estrella.keys()}\")\n", "\n", "print(f\"Valores del diccionario: {estrella.values()}\")" ] }, { "cell_type": "code", "execution_count": 45, "id": "a676097b-2af5-4960-b3c0-d0a1a7a87d9f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'nombre': 'Sirio', 'magnitud': -1.46, 'distancia': 8.6, 'constelacion': 'Canis Maior'}\n", "{'nombre': 'Sirio', 'distancia': 8.6, 'constelacion': 'Canis Maior'}\n", "NO tenemos la magnitud de la estrella\n", "{}\n" ] } ], "source": [ "# Añadimos una nueva pareja clave/valor\n", "estrella['constelacion'] = \"Canis Maior\"\n", "print(estrella)\n", "\n", "# Borramos una pareja clave/valor\n", "estrella.pop(\"magnitud\")\n", "print(estrella)\n", "\n", "# Comprobamos si existe una clave\n", "if \"magnitud\" in estrella:\n", " print(\"SI tenemos la magnitud de la estrella\")\n", "else:\n", " print(\"NO tenemos la magnitud de la estrella\")\n", " \n", "# Vaciamos un diccionario\n", "estrella.clear()\n", "print(estrella)" ] }, { "cell_type": "markdown", "id": "31d8425f-b804-48fb-bd6b-2d8e57328a73", "metadata": {}, "source": [ "Por supuesto algo muy interesante es que las colecciones pueden tener como valores otras colecciones:" ] }, { "cell_type": "code", "execution_count": 46, "id": "68081378-82c4-40cc-a7fc-205933fac247", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] } ], "source": [ "# Una lista bidimensional\n", "lista_de_listas = [\n", " [1,2,3],\n", " [4,5,6],\n", " [7,8,9]\n", "]\n", "\n", "print(lista_de_listas[0][1])" ] }, { "cell_type": "code", "execution_count": 47, "id": "16945436-75f7-4f25-8575-8314b11d9476", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('16:00', 0)\n", "21:32\n" ] } ], "source": [ "# Un diccionario con diccionarios, tuplas y listas dentro\n", "meteorologia = {\n", " \"pluviosidad\": [(\"8:00\", 2), (\"12:00\", 5), (\"16:00\", 0)],\n", " \"descripcion\": \"Lluvioso, principalmente al medio día\",\n", " \"horasSol\": {\n", " \"salida\": \"07:43\",\n", " \"puesta\": \"21:32\"\n", " }\n", "}\n", "\n", "print(meteorologia[\"pluviosidad\"][2])\n", "print(meteorologia[\"horasSol\"][\"puesta\"])" ] }, { "cell_type": "markdown", "id": "9cb0c4af-b20a-4e82-b27d-7de8de71bad4", "metadata": {}, "source": [ "***\n", "**Ejercicio B.5:**\n", "\n", "Crear una lista llamada ```planetas``` que contenga diccionarios. Cada diccionario debe tener información sobre un planeta (nombre, distancia al Sol (en UAs), y si es terrestre o no. Por ejemplo, ```planetas[3]['terrestre']``` debe dar ```True``` y ```planetas[2]['distanciaSol']``` debe dar ```1.0```." ] }, { "cell_type": "code", "execution_count": 48, "id": "52eb8c75-ac70-4e6b-8c4d-9ae945e56597", "metadata": {}, "outputs": [], "source": [ "# planetas =\n", "\n", "# print(planetas[3]['terrestre'])\n", "#print(planetas[2]['distanciaSol'])\n" ] }, { "cell_type": "markdown", "id": "7b2e2392-d617-4c14-85e9-b2eb0c1d8cac", "metadata": {}, "source": [ "***\n", "## Bucles (iteraciones)\n", "\n", "### while (mientras)\n", "\n", "Existen otras sentencias de control que están destinadas a ejecutar de manera iterativa un bloque de instrucciones. Uno de ellos es ```while``` cuya sintaxis es:\n", "\n", "```python\n", "while condicion:\n", " bloque de instrucciones\n", "```\n", "\n", "donde:\n", "\n", "+ ```while``` es la palabra reservada para este bucle (*mientras*)\n", "+ ```condicion``` es la condición que se debe cumplir (mientras que se cumpla la ```condicion```\n", "+ ```:``` ya te lo sabes\n", "+ ``` bloque de instrucciones``` son las instrucciones que deben repetirse mientras que se cumpla una condición\n", "\n", "Veamos un ejemplo:" ] }, { "cell_type": "code", "execution_count": 49, "id": "4c279544-9c36-4bf5-94c2-a9aa57124798", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "¡Aprendamos la tabla de multiplicar!\n" ] }, { "name": "stdin", "output_type": "stream", "text": [ "Dime un número (7 por defecto) \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "7 x 0 = 0\n", "7 x 1 = 7\n", "7 x 2 = 14\n", "7 x 3 = 21\n", "7 x 4 = 28\n", "7 x 5 = 35\n", "7 x 6 = 42\n", "7 x 7 = 49\n", "7 x 8 = 56\n", "7 x 9 = 63\n", "7 x 10 = 70\n" ] } ], "source": [ "print(\"¡Aprendamos la tabla de multiplicar!\")\n", "numero = input(\"Dime un número (7 por defecto)\") or \"7\"\n", "\n", "numero = int(numero)\n", "\n", "n = 0\n", "while n <= 10:\n", " print(f\"{numero} x {n} = {numero*n}\")\n", " n += 1" ] }, { "cell_type": "markdown", "id": "44ea7833-0d41-4171-8f52-b758425b2427", "metadata": {}, "source": [ "Describamos algunas cosas adicionales de este nuevo código:\n", "+ La función ```input()``` nos permite nos permite obtener un valor que introduzca el usuario por teclado.\n", "+ La función ```int()``` convierte un valor (normalmente una cadena) a un valor de tipo número entero\n", "+ El operador ```+=``` es una abreviatura del operador de asignación ```=``` y el operador de suma ```+```. ```n += 1``` es totalmente equivalente a ```num = num + 1``` (incrementamos en ```1``` la variable ```num```.\n", "\n", "**Nota \"interesante\":** ¿Qué pasa si eliminamos (o comentamos) la instrucción ```numero = int(numero)```?. No te cortes y haz la prueba\n", "\n", "**Nota \"interesante\" 2:** ¿Qué pasa si eliminamos (o comentamos) la instrucción ``` n += 1```?. Antes de probarlo localiza el botón ```Stop``` ■ en la barra superior." ] }, { "cell_type": "markdown", "id": "0908246a-795f-4a57-97a3-8aa551274190", "metadata": {}, "source": [ "### for (para)\n", "\n", "El bucle ```for``` se utiliza normalmente para iterar un número predeterminado de veces o para recorrer todos los elementos de una colección. Su sintaxis es:\n", "\n", "```python\n", "for elemento in coleccion:\n", " bloque de instrucciones\n", "```\n", "\n", "donde:\n", "\n", "+ ```for``` es la palabra reservada para este tipo de bucle (*para*)\n", "+ ```elemento``` es una variable temporal (su ámbito de existencia es el ```bloque de instrucciones``` que contendrá cada elemento de la ```coleccion```, uno por cada iteración de bucle.\n", "+ ```in``` es otra palabra reservada para este tipo de bucle (*en*)\n", "+ ```coleccion``` es una lista, diccionario, tupla... sobre la que se iterará en el bucle\n", "+ ``` bloque de instrucciones``` son las instrucciones que deben repetirse para cada elemento de la colección.\n", "\n", "El bucle lo podemos entender como *\"para cada elemento en la colección ejecutar estas instrucciones\"*." ] }, { "cell_type": "code", "execution_count": 50, "id": "4b851744-e626-47c1-848b-e7b701aeccae", "metadata": {}, "outputs": [], "source": [ "# Para que este ejemplo funcione hay que haber solucionado el ejercicio B.5\n", "\n", "#for planeta in planetas:\n", "# print(f\"+ {planeta['nombre']}\")" ] }, { "cell_type": "code", "execution_count": 51, "id": "a46197cc-24e2-4073-b80e-a76b48732aa6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+ Nombre\n", "+ Año Nacimiento\n", "+ Año Defunción\n" ] } ], "source": [ "astronomo = {\n", " \"Nombre\": \"Johannes Kepler\",\n", " \"Año Nacimiento\": 1571,\n", " \"Año Defunción\": 1630,\n", "}\n", "\n", "# Iteramos por todas las claves\n", "for clave in astronomo:\n", " print(f\"+ {clave}\")" ] }, { "cell_type": "code", "execution_count": 52, "id": "59ada2af-59df-4f07-99e1-36a538b3a866", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+ Johannes Kepler\n", "+ 1571\n", "+ 1630\n" ] } ], "source": [ "# Iteramos por todos los valores\n", "for clave in astronomo:\n", " print(f\"+ {astronomo[clave]}\")" ] }, { "cell_type": "code", "execution_count": 53, "id": "6c7be9c4-95f9-49ac-865f-c630557e3793", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+ Johannes Kepler\n", "+ 1571\n", "+ 1630\n" ] } ], "source": [ "# Versión alternativa de iteración por todos los valores\n", "for valor in astronomo.values():\n", " print(f\"+ {valor}\")" ] }, { "cell_type": "code", "execution_count": 54, "id": "097b30e5-2024-4330-a2c9-0a401bb66f47", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+ Nombre - Johannes Kepler\n", "+ Año Nacimiento - 1571\n", "+ Año Defunción - 1630\n" ] } ], "source": [ "# Iteramos por sendas (clave,valor)\n", "for clave, valor in astronomo.items():\n", " print(f\"+ {clave} - {valor}\")" ] }, { "cell_type": "markdown", "id": "f064a5fe-960a-4a45-8394-f63169d990f2", "metadata": {}, "source": [ "***\n", "**Ejercicio B.6:**\n", "\n", "Dada una distancia en UAs imprimir el nombre del planeta cuya órbita está más cerca. Necesitamos el ejercicio B.5 resuelto." ] }, { "cell_type": "code", "execution_count": 55, "id": "77d48d4b-513f-40dd-898f-116110005bf8", "metadata": {}, "outputs": [], "source": [ "distancia = 3.76\n", "\n", "\n", "# Tu código aquí\n", "\n", "\n", "# print(planetaMasCercano['nombre'])" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.16" } }, "nbformat": 4, "nbformat_minor": 5 }