{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "markdown", "source": [ "# Ampliando conocimientos de Python\n", "Este cuaderno forma parte del curso de [Iniciación a la programación con Python](https://campusvirtual.ull.es/ocw/course/view.php?id=179) del programa de Open Course Ware (OCW) de la Universidad de La Laguna.\n", "\n" ], "metadata": { "id": "-dhKWovwXoe0" } }, { "cell_type": "markdown", "source": [ "## Condicionales\n", "\n", "Las estructuras condicionales permiten tomar decisiones en función de ciertas condiciones. Se utilizan para ejecutar diferentes bloques de código dependiendo de si una condición dada es verdadera o falsa.\n", "\n", "En Python se utiliza la palabra `if` para comenzar el condicional, `elif` para establecer una condición si las condiciones anteriores no son `True` y `else` si ninguna de las condiciones anteriores se cumplen. Por ejemplo:\n", "\n", "```python\n", "x=4\n", "y=9\n", "if x>y:\n", " print(\"x es mayor que y\") #Se ejecuta cuando el valor de x (4) es mayor que y (9).\n", "elif x<9:\n", " print(\"x es menor que 9\") #Se ejecuta cuando el valor de x (4) sea menor que 9.\n", "else:\n", " print(\"x no es mayor que y ni menor que 9\") #Se ejecuta cuando ninguna de las condiciones anteriores se cumpla.\n", "```\n", "\n", "Puedes también colocar un condicional dentro de otro condicional:\n", "```python\n", "x=7\n", "y=2\n", "if x>y:\n", " print(\"x es mayor que y\") #Se ejecuta cuando el valor de x (4) es mayor que y (9).\n", " if x>5:\n", " print(\"x es mayor que 5\") #Se ejecuta cuando se cumpla la condición anterior y si el valor de x (7) es mayor que 5.\n", "elif x<9:\n", " print(\"x es menor que 9\") #Se ejecuta cuando el valor de x (4) sea menor que 9.\n", "else:\n", " print(\"x no es mayor que y ni menor que 9\") #Se ejecuta cuando ninguna de las condiciones anteriores se cumpla.\n", "```\n", "\n", "Puedes probar este tema en la siguiente celda de código." ], "metadata": { "id": "D7NBdmlg74IR" } }, { "cell_type": "code", "source": [ "a=7.9\n", "b=2\n", "c=6\n", "if a>bc:\n", " print(b,\"es mayor que\",c) #Se ejecuta cuando no se cumple ni la primera condición ni la segunda y b es mayor que c.\n", "else:\n", " print(\"Los valores introducidos no cumplen ninguna condición\") #Se ejecuta cuando no se cumple ninguna de las condiciones, por ejemplo, que los tres números sean iguales." ], "metadata": { "id": "_Wc6EJ0W_BfP" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Listas\n", "\n", "Las listas permiten almacenar varios datos en una única variable. Los elementos se almacenan ordenados, pueden cambiar los valores almacenados y permiten valores duplicados.\n", "\n", "Las listas se definen utilizando corchetes `[]`. Por ejemplo:\n", "\n", "```python\n", "x=[1,3.4,5]\n", "print(x) #Sale por pantalla [1, 3.4, 5].\n", "```\n", "\n", "Es posible diferentes tipos de datos en la misma lista.\n", "\n", "Para acceder a un elemento concreto, se utilizan también corchetes. Es necesario indicar la posición con un número entero. Los índices empiezan en `0`. Por ejemplo:\n", "\n", "```python\n", "x=[12,\"hola\",4.5,9]\n", "print(x[1]) #Sale por pantalla 'hola'.\n", "print(x[-1]) #Sale por pantalla el último elemento, 9 en este caso.\n", "print(x[1:3]) #Sale por pantalla el elemento con índice 1 (inclusivo), y el elemento con índice 3 (exclusivo), ['hola', 4.5] en este caso.\n", "print(x[:3]) #Sale por pantalla desde el primer elemento (índice 0), hasta el segundo, [12, 'hola', 4.5] en este caso.\n", "```\n", "\n", "Con las listas es posible realizar una serie de funciones como:\n", "* `append()`: agregar elemento al final de la lista.\n", "* `insert()`: insertar un elemento en una posición concreta.\n", "* `remove()`: eliminar el primer elemento cuyo valor coincida.\n", "* `sort()`: ordena una lista. Por defecto, este orden es alfanumérico de manera ascendente.\n", "* `reverse()`: revierte el orden de los elementos dentro de la lista.\n", "* `len()`: devuelve la cantidad de elemento almacenados en una lista.\n", "* `max()`: devuelve el elemento con el valor más alto.\n", "* `min()`: devuelve el elemento con el valor más bajo.\n", "* `sum()`: devuelve la suma de todos los elementos de la lista.\n", "\n", "Un ejemplo de estas funciones:\n", "\n", "```python\n", "mi_lista = [] #Lista vacía.\n", "\n", "mi_lista.append(5)\n", "mi_lista.append(2)\n", "mi_lista.append(8)\n", "print(mi_lista) #Sale por pantalla [5, 2, 8].\n", "\n", "mi_lista.insert(1, 10)\n", "print(mi_lista) #Sale por pantalla [5, 10, 2, 8].\n", "\n", "mi_lista.remove(2)\n", "print(mi_lista) #Sale por pantalla [5, 10, 8].\n", "\n", "mi_lista.sort()\n", "print(mi_lista) #Sale por pantalla [5, 8, 10].\n", "\n", "mi_lista.reverse()\n", "print(mi_lista) #Sale por pantalla [10, 8, 5].\n", "\n", "print(len(mi_lista)) #Sale por pantalla 3.\n", "print(max(mi_lista)) #Sale por pantalla 10.\n", "print(min(mi_lista)) #Sale por pantalla 5.\n", "print(sum(mi_lista)) #Sale por pantalla 23.\n", "```\n", "\n", "Es posible conocer si un elemento se encuentra dentro de una lista utilizando el operador `in`. Por ejemplo:\n", "\n", "```python\n", "nombres = [\"Diego\", \"Antonio\", \"Pilar\", \"Lucía\"]\n", "print(\"Diego\" in nombres) #Devuelve True.\n", "print(\"Celia\" in nombres) #Devuelve False.\n", "```\n", "\n", "Puedes probar este tema en la siguiente celda de código." ], "metadata": { "id": "RHafdHSz4Iuf" } }, { "cell_type": "code", "source": [ "mi_lista = [3, 3, \"Python\"] #Lista nueva con valores de diferentes tipos.\n", "\n", "mi_lista.append(7)\n", "mi_lista.append(\"Hola\") #Añadir 7 y 'Hola' al final de la lista.\n", "\n", "mi_lista.insert(2, 2.0) #Añadir 2.0 en el tercer elemento.\n", "\n", "mi_lista.remove(3) #Eliminar el primer 3 que aparece.\n", "\n", "mi_lista.reverse() #Revertir la lista.\n", "\n", "longitud = len(mi_lista) #Obtener la cantidad de elementos de la lista.\n", "\n", "primer_elemento = mi_lista[0] #Obtener el primer elemento de la lista.\n", "tercer_elemento = mi_lista[2] #Obtener el tercer elemento de la lista.\n", "\n", "primeros_dos = mi_lista[:2] #Obtener los dos primeros elementos de la lista.\n", "ultimos_dos = mi_lista[-2:] #Obtener los dos últimos elementos de la lista.\n", "\n", "print(\"Lista resultante:\", mi_lista)\n", "print(\"Longitud de la lista:\", longitud)\n", "print(\"Primer elemento:\", primer_elemento)\n", "print(\"Tercer elemento:\", tercer_elemento)\n", "print(\"Primeros dos elementos:\", primeros_dos)\n", "print(\"Últimos dos elementos:\", ultimos_dos)\n", "\n", "numeros = [3, 7, 2]\n", "\n", "print(\"El elemento más grande de la lista es:\", max(numeros))\n", "print(\"El elemento más pequeño de la lista es:\", min(numeros))\n", "print(\"La suma de los elementos de la lista es:\", sum(numeros))\n", "print(\"¿Está el número 7 en la lista?\", 7 in numeros)\n", "print(\"¿Está el número 21.3 en la lista?\", 21.3 in numeros)" ], "metadata": { "id": "WM2GXcoZNGr3" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Rangos\n", "\n", "Son secuencias inmutables de números que se utilizan habitualmente en los bucles y para generar secuencias numéricas. Se utiliza la palabra `range()` para trabajar con ellos. Por ejemplo:\n", "\n", "```python\n", "x=range(6) #Crea un rango del 0 al 5 (0,1,2,3,4,5).\n", "x=range(1,6) #Crea un rango del 1 al 5 (1,2,3,4,5).\n", "x=range(1,9,2) #Crea un rango del 1 al 7, de 2 en 2 (1,3,5,7).\n", "```\n", "\n", "Puedes probar este tema en la siguiente celda de código." ], "metadata": { "id": "Rx_hkfzEN9Ug" } }, { "cell_type": "code", "source": [ "x=range(4,80,5)\n", "for i in x:\n", " print(i) #Sale por pantalla desde el 4 al 80 (no inclusivo) de 5 en 5, `(4,9,14,24,29,34,39,44,49,54,59,64,69,74,79)`." ], "metadata": { "id": "lQEooQ6kf-9n" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Bucles\n", "\n", "Son estructuras de control que permiten ejecutar un bloque de código repetidamente, mientras se cumpla una condición o en función de una secuencia que le pasemos al bucle. En la celta de código anterior, se usó un bucle para imprimir por pantalla cada uno de los elementos del rango generado.\n", "\n", "Existen dos tipos de bucles en Python.\n", "\n", "### Bucles for\n", "\n", "Sirven para iterar sobre una secuencia, como son las cadena de texto, los rangos, las listas o cualquier objeto que sea iterable. El bucle `for` recorre cada elemento de la secuencia y ejecuta un bloque de código para cada elemento. Por ejemplo:\n", "\n", "```python\n", "x=[\"Yaiza\", \"Ayoze\", \"Gara\"]\n", "\n", "for i in x:\n", " print(\"¡Hola,\", i, \"!\") #Sale por pantalla `¡Hola, Yaiza !`; `¡Hola, Ayoze !` y `¡Hola, Gara !`.\n", "\n", "```\n", "\n", "En el bucle anterior, la variable `i` contiene en la primera iteración el primer elemento de la lista `x`, es decir, \"Yaiza\". En la segunda iteración la `i` valdrá \"Ayoze\". En la tercera iteración la `i` valdrá \"Gara\". Al llegar al final de la lista, terminará la ejecución del bucle.\n", "\n", "### Bucles while\n", "\n", "Este tipo de bucle se ejecuta mientras una condición dada sea verdadera. El bucle `while` verifica la condición tras cada iteración y termina la ejecución si la condición es falsa. Por ejemplo:\n", "\n", "```python\n", "cnt=0\n", "while cnt<3:\n", " print(\"Este bucle se ha ejecutado\",cnt+1,\"vez/veces.\") #Sale por pantalla 'Este bucle se ha ejecutado 1 vez/veces.'; 'Este bucle se ha ejecutado 2 vez/veces.' y 'Este bucle se ha ejecutado 3 vez/veces.'.\n", " cnt+=1\n", "```\n", "\n", "### Bucles anidados\n", "\n", "Al igual que los condicionales, es posible ejecutar un bucle dentro de otro (anidados). Por ejemplo:\n", "\n", "```python\n", "x=[\"Yaiza\", \"Ayoze\"]\n", "y=[\"Arucas\", \"Curbelo\", \"Chinea\"]\n", "for nombre in x:\n", " for apellido in y:\n", " print(\"¡Hola,\", nombre, apellido, \"!\") #Sale por pantalla `¡Hola, Yaiza Arucas !`; `¡Hola, Yaiza Curbelo !`; `¡Hola, Yaiza Chinea !`; `¡Hola, Ayoze Arucas !`; `¡Hola, Ayoze Curbelo !` y `¡Hola, Ayoze Chinea !`.\n", "```\n", "\n", "### Else, break y continue\n", "\n", "La palabra `else` permite ejecutar un fragmento de código cuando termina la ejecución del bucle, bien porque haya terminado de iterar o bien porque la condición ya no se cumpla. Por ejemplo:\n", "\n", "```python\n", "n=range(2,11,2) #[2, 4, 6, 8, 10]\n", "suma=0\n", "for i in n:\n", " suma+=n\n", "else:\n", " print(\"La suma de los números pares es:\", suma) #Sale por pantalla la suma de 2+4+6+8+10=30, `La suma de los números pares es: 30` cuando finaliza la ejecución del bucle.\n", "\n", "cnt = 0\n", "while cnt < 5:\n", " print(\"Contador:\", cnt) #Sale por pantalla la iteración del bucle como `Contador: 0`; `Contador: 1`; `Contador: 2`; `Contador: 3` y `Contador: 4`.\n", " cnt += 1\n", "else:\n", " print(\"El contador ha alcanzado\", cnt, \"y el bucle while ha terminado\") #Sale por pantalla, cuando finaliza el bucle, `El contador ha alcanzado 5 y el bucle while ha terminado`.\n", "\n", "```\n", "\n", "La palabra `break` permite terminar la ejecución de un bucle sin que este haya finalizado o aunque se siga cumpliendo la condición de parada. Por ejemplo:\n", "\n", "```python\n", "frutas = [\"manzana\", \"banana\", \"cereza\", \"uva\"]\n", "for i in frutas:\n", " if i == \"cereza\":\n", " break #Termina el bucle si aparece la palabra cereza.\n", " print(i) #Sale por pantalla `manzana` y `banana`.\n", "\n", "n = 1\n", "while n <= 5:\n", " if n == 3:\n", " break #Termina el bucle si aparece el número 3.\n", " print(n) #Sale por pantalla `1` y `2`.\n", " n += 1\n", "```\n", "\n", "Si se ejecuta un `break` dentro de un bucle, y este tiene un `else`, este último fragmento de código no se llegará a ejecutar. Por ejemplo:\n", "\n", "```python\n", "frutas = [\"manzana\", \"banana\", \"cereza\", \"uva\"]\n", "for i in frutas:\n", " if i == \"cereza\":\n", " break #Termina el bucle si aparece la palabra cereza.\n", " print(i) #Sale por pantalla `manzana` y `banana`.\n", "else:\n", " print(\"He terminado de imprimir la lista de frutas.\") #Este texto nunca saldrá por pantalla si cereza está en la lista.\n", "```\n", "\n", "La palabra `continue` permite saltar la iteración actual en la que se encuentra un bucle, pasando a la siguiente y sin ejecutar el código que se encuentre bajo la palabra. Por ejemplo:\n", "\n", "```python\n", "frutas = [\"manzana\", \"banana\", \"cereza\", \"uva\"]\n", "for i in frutas:\n", " if i == \"cereza\":\n", " continue #Salta a la siguiente iteración si aparece la palabra cereza.\n", " print(i) #Sale por pantalla `manzana`, `banana` y `uva`.\n", "\n", "n = 1\n", "while n <= 5:\n", " if n == 3:\n", " continue #Salta a la siguiente iteración del bucle si aparece el número 3.\n", " print(n) #Sale por pantalla `1`, `2`, `4` y `5`.\n", " n += 1\n", "```\n", "\n", "Puedes probar este tema en la siguiente celda de código." ], "metadata": { "id": "HTtqyqu7gfNx" } }, { "cell_type": "code", "source": [ "for i in range(1, 6):\n", " if i == 3:\n", " continue #Salta la iteración actual cuando i sea igual a 3.\n", " elif i == 5:\n", " break #Sale del bucle cuando i sea igual a 5.\n", " print(\"Bucle for - Iteración:\", i)\n", "\n", "j = 0\n", "while j < 5:\n", " j += 1\n", " if j == 2:\n", " continue #Salta la iteración actual cuando j sea igual a 2.\n", " elif j == 4:\n", " break #Sale del bucle cuando j sea igual a 4.\n", " print(\"Bucle while - Iteración:\", j)" ], "metadata": { "id": "BAh71izwuruq" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "## Funciones\n", "\n", "Una función se define como una porción de código reutilizable dentro de un programa. En Python se definen utilizando la palabra `def`, seguido de paréntesis. Las funciones pueden tomar entradas, denominadas argumentos, y devolver algún dato, valor de retorno, aunque no siempre es necesario. Por ejemplo:\n", "\n", "```python\n", "def saludar():\n", " return \"¡Hola, Mundo!\" #Definición de la función saludar que no recibe argumentos y devuelve el texto `¡Hola, Mundo!`.\n", "\n", "print(saludar()) #Llamada a la función saludar para que se ejecute. Sale por pantalla `¡Nola, Mundo!`.\n", "\n", "```\n", "\n", "A la función es posible pasarle argumentos para poder ejecutar instrucciones con esos datos. Estos se ponen entre los paréntesis y se trabaja con ellos como si fuesen variables. Por ejemplo:\n", "\n", "```python\n", "def saludar(nombre):\n", " return \"¡Hola, \"+nombre+\"!\" #Devuelve el texto `¡Hola,` junto con el texto que ponga el usuario en el argumento, seguido de `!`.\n", "\n", "print(saludar(\"Jorge\")) #Llamada a la función saludar con el argumento `Jorge`. Sale por pantalla el texto `¡Hola, Jorge!`.\n", "```\n", "\n", "También es posible pasar más de un argumento, para lo que se deben separar cada uno por comas. Por ejemplo:\n", "\n", "```python\n", "def sumar(a, b, c):\n", " return a+b+c #Devuelve la suma de 3 números o concatena 3 cadenas de texto.\n", "\n", "print(\"La suma es:\", sumar(3, 5.8, 7)) #Llamada a la función sumar. Sale por pantalla 15.8.\n", "```\n", "\n", "Es posible establecer valores por defecto para los argumentos. Por ejemplo:\n", "\n", "```python\n", "def saludar(nombre=\"Desconocido\"):\n", " return \"¡Hola, \"+nombre+\"!\" #Devuelve el texto `¡Hola,` junto con el texto que ponga el usuario en el argumento, seguido de `!`. En caso de que no llame a la función con un argumento, devolverá la cadena `¡Hola, Desconocido!`.\n", "\n", "print(saludar(\"Jorge\")) #Llamada a la función saludar con el argumento `Jorge`. Sale por pantalla el texto `¡Hola, Jorge!`.\n", "print(saludar()) #Llamada a la función saludar sin argumentos. Sale por pantalla el texto `¡Hola, Desconocido!`.\n", "```\n", "\n", "Puedes probar este tema en la siguiente celda de código." ], "metadata": { "id": "VInruzpBvEUW" } }, { "cell_type": "code", "source": [ "def area(base, altura):\n", " return base*altura #Devuelve el área de un rectángulo.\n", "\n", "def par(n):\n", " return n%2==0 #Devuelve si el número es par o no.\n", "\n", "print(\"Área del rectángulo:\", area(5,8)) #Sale por pantalla `Área del rectángulo: 40`.\n", "print(\"Área del cuadrado:\", area(5,5)) #Sale por pantalla `Área del cuadrado: 25`.\n", "\n", "n = 7\n", "if par(n):\n", " print(n, \"es un número par.\") #Si n (7) fuese par, saldría por pantalla `7 es un número par`.\n", "else:\n", " print(n, \"no es un número par.\") #Sale por pantalla `7 no es un número par`." ], "metadata": { "id": "MIfZyhfMyedv" }, "execution_count": null, "outputs": [] } ] }