![\"Licencia](\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\")
Esta obra está bajo una licencia de Creative Commons Reconocimiento-CompartirIgual 4.0 Internacional
Autor: Pablo Cerrillo Ruiz.
Última modificación: 26 de junio de 2019.
Jupyter Notebook es un entorno de trabajo interactivo que permite desarrollar código de manera dinámica. Ahora mismo nos encontramos en el cuaderno UD Estructuras de datos, cuya finalidad es enseñar al alumno las diferentes estructuras de datos en Python y la utilidad que éstas tienen en el mundo de la programación.
" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/menu_superior_jupyter_notebook.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Recuerde que para ejecutar el contenido de una celda basta con pulsar el botón Run del panel de control. También puede pulsar al mismo tiempo las teclas Mayúsculas+Enter
" }, { "metadata": {}, "cell_type": "markdown", "source": "\nLa repetición de código es uno de los mayores problemas que se encuentran en el mundo de la programación. Uno de los problemas que surge cuando repetimos el mismo código en diferentes partes de nuestro programa es cuando tenemos que realizar una actualización de dicho código. En primer lugar, dicho código deberá ser cambiado en todo el programa; y segundo, que al aparecer en más de un sitio, es posible que el programador cometa el error de no actualizarlo en alguna parte del código. Por ejemplo, imagine que tenemos el siguiente código que calcula el máximo de tres números y a continuación, calculará el maximo de otros tres números diferentes:
\n" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "\na = 5\nb = 2\nc = 1\n\nif a >= b:\n if a >= c:\n print(a)\n else:\n print(c)\nelse:\n if b >= c:\n print(b)\n else:\n print(c)\n\na = 4\nb = 4\nc = 8\n\nif a >= b:\n if a >= c:\n print(a)\n else:\n print(c)\nelse:\n if b >= c:\n print(b)\n else:\n print(c)", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, si realizamos un cambio en el cálculo del máximo, deberiamos realizar dos cambios. Realizar eso en una aplicación de varios ficheros sería inviable. Python proporciona mecanismos para poder reutilizar varias veces nuestro código definiendolo una sola vez. Dicho mecanismo se basa en la creación de funciones. Crear funciones permite a programador reutilizar código y eliminar todo el código redundante de nuestra aplicación. Vamos a resolver ahora el problema anterior creando una función.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Vamos a resolver ahora el problema anterior creando una función.
" }, { "metadata": { "trusted": true }, "cell_type": "code", "source": "def max(a,b,c):\n if a >= b:\n if a >= c:\n print(a)\n else:\n print(c)\n else:\n if b >= c:\n print(b)\n else:\n print(c)\n\nmax(5,2,1)\nmax(4,4,8)\n", "execution_count": null, "outputs": [] }, { "metadata": {}, "cell_type": "markdown", "source": "Como podemos observar, mediante la creación de funciones podemos reutilizar nuestro código de forma sencilla. El uso de funciones hace que nuestro programa sea más compacto, debido a al ahorro de líneas que supone su uso; legible, facilita la lectura del código y robusto, minimizamos la probabilidad de fallos.
" }, { "metadata": {}, "cell_type": "markdown", "source": "\nUna vez introducido el concepto de función, vamos a definir formalmente que es una función y como se define en Python una. Una función es un bloque de código al que le proporcionamos un nombre. Dicha función puede recibir de entrada cero o más parámetros denominados argumentos y opcionalmente puede devolver un valor si lo necesitase. En la imagen siguiente podemos ver la sintaxis en Python para crear funciones:
\n\n" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_funciones/sintaxis_funciones.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Donde:
\nLlegados a este punto, vamos a realizar paso a paso la creación de una función que nos convierta una cantidad de euros en libras para nuestro próximo viaje de estudios.
\n\n\n" }, { "metadata": {}, "cell_type": "markdown", "source": "![](\"./images/ud_funciones/euro_to_pound.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Para ello, vamos a seguir una serie de pasos:
\n\nPaso 1: Pensar en un nombre para la función.
" }, { "metadata": {}, "cell_type": "markdown", "source": "A continuación se proponen diferentes nombres para nuestra función y escogeremos el que mejor refleje la finalidad de nuestra función:
\nVamos a escoger la opción número 3: Conversor_de_euros_a_libras
\n" }, { "metadata": {}, "cell_type": "markdown", "source": "Paso 2: Dar diferentes ejemplos de llamada a la función y lo que nos debería devolver.
" }, { "metadata": {}, "cell_type": "markdown", "source": "Aunque la función no este definida, vamos a dar ejemplos de llamada a la función Conversor_de_euros_a_libras para ver como funcionaría.
\n\n>>> Conversor_de_euros_a_libras(1)\n0.86\n>>> Conversor_de_euros_a_libras(10)\n8.6\n>>> Conversor_de_euros_a_libras(100)\n86"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Como podemos observar, nuestra función va a necesitar como parámetro de entrada un valor númerico, el cuál representará la cantidad de euros, y devolverá un valor que representará el número de libras.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Paso 3: Escribir la cabecera de la función utilizando la sentencia def.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Una vez seleccionado el nombre de la función y conocido el número de argumentos de la función, nos disponemos de definirla. Para ello, escribiremos la cabecera mediante la sentencia def. Además, añadiremos un comentario acerca de los tipos de datos de entrada y los tipos de datos de salida. Al igual que hicimos con el nombre de la función, debemos escoger un nombre para los argumentos de manera que su nombre especifique lo que representa.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "def Conversor_de_euros_a_libras(euros):\n '''\n euros(number) -> number Indicamos que euros es un número y la salida de la función es otro número.\n \n >>> Conversor_de_euros_a_libras(1)\n 0.86\n >>> Conversor_de_euros_a_libras(10)\n 8.6\n >>> Conversor_de_euros_a_libras(100)\n 86\n '''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Paso 4: Escribir una definición de lo que realiza nuestra función.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Realizamos un pequeño comentario sobre la funcionalidad de la función.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "def Conversor_de_euros_a_libras(euros):\n '''\n euros(number) -> number Indicamos que euros es un número y la salida de la función es otro número.\n \n Convierte una cantidad de euros en libras.\n \n >>> Conversor_de_euros_a_libras(1)\n 0.86\n >>> Conversor_de_euros_a_libras(10)\n 8.6\n >>> Conversor_de_euros_a_libras(100)\n 86\n '''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Paso 5: Escribir el código que contendrá el cuerpo de la función.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Dado que un euro son 0.86 libras, lo que hacemos es multiplicar nuestra cantidad de euros por 0.86 y lo devolvemos mediante la sentencia return.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "def Conversor_de_euros_a_libras(euros):\n '''\n euros(number) -> number Indicamos que euros es un número y la salida de la función es otro número.\n \n Convierte una cantidad de euros en libras.\n \n >>> Conversor_de_euros_a_libras(1)\n 0.86\n >>> Conversor_de_euros_a_libras(10)\n 8.6\n >>> Conversor_de_euros_a_libras(100)\n 86\n '''\n libras = euros * 0.86\n return libras",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Paso 6: Realizar diferentes pruebas de nuestra función.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Comprobamos si obtenemos los mismos resultados que los obtenidos en el paso número 1.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "Conversor_de_euros_a_libras(1)",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "Conversor_de_euros_a_libras(10)",
"execution_count": null,
"outputs": []
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "Conversor_de_euros_a_libras(100)",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "¡PRUEBA TÚ!
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Vamos a practicar la creación de funciones. Siguiendo los pasos vistos anteriormente, crear una función que permita convertir los grados centígrados en kelvin.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/ud_funciones/celsius_to_kelvin.png\")
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\n2.1 Valor por defecto de los argumentos.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Es posible que tengamos la necesidad de definir valores por defecto de entrada a una función. Python permite definir para cada argumento un valor que tendrá por defecto en caso de no ser proporcionado por el usuario a la hora de llamar a la función.
\n"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/ud_funciones/sintaxis_funciones_valor_defecto.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Como podemos observar, la sintaxis es la misma. La única diferencia es que se indica junto al argumento el operador = junto al valor por defecto deseado. Cabe destacar que no todos los argumentos tienen porque tener valor por defecto.
\n"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Ejemplo: Creación de funciones con argumentos que tienen valor por defecto.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Función que calcula el área de un paralelogramo (base * altura) '''\n\ndef area_paralelogramo( base = 1, altura = 1):\n print(\"El valor de la base es: \", base)\n print(\"El valor de la altura es: \", altura)\n print(\"El área del palalelogramo es: \", base * altura)\n\narea_paralelogramo() # al llamarla sin argumento, se toman los valores por defecto indicados.\nprint(\"\\n\")\narea_paralelogramo(5) # al llamarla con un argumento, base tomará el valor 5 y altura el valor por defecto 1.\nprint(\"\\n\")\narea_paralelogramo(2,3) # al llamarla con dos argumentos, no se utilizarán los valores por defecto.\n",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "¡Cuidado! Los argumentos que tienen un valor por defecto deben colocarse detrás de los que no lo tienen. En caso contrario, Python devolverá un error de sintáxis.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Función que calcula el área de un paralelogramo '''\n\ndef area_paralelogramo(base = 1, altura):\n print(\"El área del palalelogramo es: \",base*altura)\n",
"execution_count": 1,
"outputs": [
{
"output_type": "error",
"ename": "SyntaxError",
"evalue": "non-default argument follows default argument (, line 3)",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m def area_paralelogramo(base = 1, altura):\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
]
}
]
},
{
"metadata": {},
"cell_type": "markdown",
"source": "¡PRUEBA TÚ!
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Vamos a practicar las llamadas a funciones. Para ello, completar el siguiente código.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Llamada a funciones con argumentos que tienen valor por defecto '''\n\n# función que resuelve ecuaciones del tipo a*x + b = 0\ndef ecuacion_primer_grado(a = 1, b = 0):\n print(\"El valor de a es: \",a)\n print(\"El valor de b es: \",b)\n print(\"El valor de x es: \",-b/a)\n\n# llamar a la función ecuacion_primer_grado de tres diferentes formas\n",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\n2.2 Indicando el valor del argumento mediante su nombre.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Hasta ahora, cada vez que llamábamos a una función con argumentos, el valor de cada uno de los argumentos se iban asignando por la posición de de éstos.. Veamos un ejemplo.
\n"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Ejemplo: Asignación de valores a los argumentos de la función por posición.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Función que permite saludar a un usuario '''\n\ndef saludar(saludo, nombre):\n print(saludo + \" \" + nombre)\n\nsaludar(\"Hola\",\"Pablo\") # Hola se asigna a la variable saludo y Pablo a la variable nombre",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Si observamos la llamada a la función anterior, vemos que la cadena de texto \"Hola\" se asigna a la variable saludo y \"Pablo\" a la variable nombre. Python permite además de realizar la asignación del valor por la posición, por el nombre de la varible. Esto permite que pasar los argumentos en el orden que deseemos.
\n"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Ejemplo: Asignación de valores a los argumentos de la función por nombre.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Función que permite saludar a un usuario '''\n\ndef saludar(saludo, nombre):\n print(saludo + \" \" + nombre)\n\nsaludar(nombre = \"Pablo\", saludo = \"Buenas\") # Hola se asigna a la variable saludo y Pablo a la variable nombre",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Ahora podemos llamar a funciones que tenian diferentes valores por defecto en una posición que es diferente a la primera, indicando el nombre de la variable.
\n"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Función que calcula el área de un paralelogramo '''\n\ndef area_paralelogramo( base = 1, altura = 1):\n print(\"El valor de la base es: \", base)\n print(\"El valor de la altura es: \", altura)\n print(\"El área del palalelogramo es: \", base * altura)\n\narea_paralelogramo(5) \nprint(\"\\n\")\narea_paralelogramo(altura = 5) \n",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "¡PRUEBA TÚ!
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Vamos a practicar las llamadas a funciones indicando el nombre de los argumentos. Para ello, completar el siguiente código.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' llamada a funciones indicando el nombre del argumento '''\n\n# Creación de una función llamada holaMundo, sin parámetros y cuyo contenido es la salida por pantalla de la cadena de texto '¡Hola Mundo!'\ndef realizar_pedido(tipo = 'margarita', bebida = 'fanta de limón', postre = 'helado'):\n print('Su pedido es:')\n print(' - Su pedido es: ', tipo)\n print(' - Su pedido es: ', bebida)\n print(' - Postre: ', postre)\n\n# llamar a la función realizar_pedido de 3 formas diferentes, indicando el nombre de los argumentos en la llamada",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\n3. Librerías de funciones.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Una librería es un conjunto de funciones organizadas. En Python dichas librerías se denominan módulos. Los módulos son archivos .py que contienen código escrito en Python y que son importados para su posterior uso en diferentes programas.
\n"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Los módulos se encuentran alojados en una carpeta. Dicha carpeta que contiene un conjunto de módulos se denomina paquete."
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/ud_funciones/ejemplo_paquete.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "
Podemos importar un módulo mediante la sentencia import. A continuación se muestra la sintaxis:"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/ud_funciones/sentencia_import.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\n
3.1 El módulo Math.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "El módulo math es uno de los paquetes de la librería estándar que contiene constantes y métodos para calcular el valor de diversas funciones matemáticas. Para importar el módulo math utilizamos la siguiente sentencia:
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "import math",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Vamos a comprobar el contenido del paquete math mediante la función dir:
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "dir(math)",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "La función dir devuelve las funciones dentro de un módulo o los módulos dentro de un paquete. Podemos obtener información de una función gracias a la funcion help.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "help(math.sqrt)",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "A continuación se especifican las constantes y funciones más utilizados del módulo math.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "\n \n \n Variable / Método \n Descripción \n \n \n \n \n pi \n Devuelve el valor de la constante PI cuyo valor aproximado es 3.14159. \n \n \n e \n Devuelve el valor de la constante E cuyo valor aproximado es 2.718281. \n \n \n sqrt(x) \n Devuelve la raíz cuadrada de X. \n \n \n pow(x,y) \n Devuelve X elevado a Y. El tipo de dato devuelto es float. \n \n \n exp(x) \n Devuelve la constante E elevado a X. El tipo de dato devuelto es float. \n \n \n log10(x) \n Devuelve el logaritmo en base 10 de x. \n \n \n log(x,b) \n Devuelve el logaritmo en base b de x. \n \n \n
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Ejemplo: Uso del módulo math. Fíjese en que antes de utilizar cada elemento de la librería es necesario escribir math.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "''' Uso del módulo math '''\n\nprint(\"\\n El valor de la constante E es: \", math.e)\nprint(\"\\n El valor de la constante PI es: \", math.pi)\nprint(\"\\n La raíz cuadrada de 16 es : \", math.sqrt(16))\nprint(\"\\n 2 elevado a 3 es: \", math.pow(2,3))\nprint(\"\\n El logaritmo en base 10 de 100 es: \", math.log10(100))",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": " 4. ¿Qué hemos aprendido?.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/resumen.jpg\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "Una vez terminado el cuaderno, vamos a realizar un pequeño resumen acerca de lo visto hasta ahora:
\n\n - La reutilización de código es necesaria si queremos tener como resultado final un código compacto, legible y robusto.
\n - Python permite reutilizar código mediante la creación de funciones.
\n - Para crear funciones utilizamos la sentencia def. Junto a dicha sentencia se proporciona el nombre de la función, opcionalmente un conjunto de varibles denominadas argumentos de la función, la sentencias que contendrán dicha función y una sentencia return en caso de devolver algún valor.
\n - Podemos establecer valores por defecto a los argumentos de la función. Dichos valores serán tenidos en cuenta cuando no se proporcionan valores para dichas argumentos en la llamada a la función.
\n - Podemos cambiar el orden de los parámetros en la llamada de la función. Si lo hacemos asi, hay que indicar el nombre del argumento en la llamada para que se asignen correctamente los valores.
\n - Python proporciona librerías en su código con el fin de facilitar a los programadores el desarrollo de programas. Para importar algún paquete o módulo proporcionado por Python o creado por nosotros, utilizamos la sentencia import.
\n - Math es uno de los módulos que contiene Python para realizar cálculos matemáticos. Para ver el contenido de un módulo o paquete utilizamos la sentencia dir y para obtener información más deteallada la sentencia help
\n
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": " 5. Relación de ejercicios.
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "![](\"./images/ejercicios.png\")
"
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 1:Para la siguiente función escrita en Python:
\n\n def es_primo(num = 1):\n primo = True;\n\n for x in range(2, num // 2):\n if num % x == 0:\n primo = False\n \n return primo\n\nIdentificar los componentes de la función:
\n\n - Nombre de la función.
\n - Número de argumentos de la función.
\n - Nombre de cada argumento y tipo de dato.
\n - Valor por defecto de los argumentos de la función.
\n - Valor devuelto y tipo de dato.
\n - ¿Sabrías decir cuál es la funcionalidad de esta función?.
\n"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\n1.\n2.\n3.\n4.\n5.\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 2: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\n\ndef menor(a,b):\n if a <= b:\n return a\n else:\n return b\n\n\nprint(menor(5,4))\nprint(menor(6,6))\nprint(menor(menor(5,2),3)))\n\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 3: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\ndef tabla(a = 2):\n for x in range(1,11):\n print(x, \" por \", a , \" = \", a*x)\n\ntabla()\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 4: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\ndef tabla(a = 2):\n for x in range(1,11):\n print(x, \" por \", a , \" = \", a*x)\n\ntabla(5)\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 5: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\ndef info_division_entera(dividendo,divisor):\n print(\"Dividendo: \",dividendo)\n print(\"Divisor: \",divisor)\n print(\"Cociente: \",dividendo // dividendo)\n print(\"Resto: \",dividendo % divisor)\n\ninfo_division_entera(12, 10)\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 6: ¿Sabrías decir cuál es la salida del siguiente código sin ejecutarlo?.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "'''\n\ndef info_division_entera(dividendo,divisor):\n print(\"Dividendo: \",dividendo)\n print(\"Divisor: \",divisor)\n print(\"Cociente: \",dividendo // dividendo)\n print(\"Resto: \",dividendo % divisor)\n\ninfo_division_entera(divisor = 6, dividendo = 12)\n\n'''",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 7: Crear una función llamada es_par que reciba un parámetros de entrada (num) y muestre por pantalla el mensaje \"Es par\" en caso de ser par o \"Es impar\" en caso contrario .
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "",
"execution_count": null,
"outputs": []
},
{
"metadata": {},
"cell_type": "markdown",
"source": "EJERCICIO 8: Crear una función para obtener la solución de una ecuación de segundo grado del tipo ax^2 + bx + c = 0. Dicha función tomará como argumento los valores a, b y c.Los valores por defecto de cada argumento sera 1. Utiliza el módulo math para realizar las operaciones que estimes oportunas.
"
},
{
"metadata": {
"trusted": true
},
"cell_type": "code",
"source": "",
"execution_count": null,
"outputs": []
}
],
"metadata": {
"kernelspec": {
"name": "python3",
"display_name": "Python 3",
"language": "python"
},
"language_info": {
"mimetype": "text/x-python",
"nbconvert_exporter": "python",
"name": "python",
"pygments_lexer": "ipython3",
"version": "3.5.4",
"file_extension": ".py",
"codemirror_mode": {
"version": 3,
"name": "ipython"
}
}
},
"nbformat": 4,
"nbformat_minor": 2
}