{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "o14mTyL1N9O9", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "## Datos\n", "\n", "Los datos que utilizan los programas se guardan en la memoria principal y pueden ser literales o estar identificados mediante lo que llamamos como **variables**. Como su nombre indica, una variable puede cambiar de contenido a lo largo de la ejecución de un programa.\n", "\n", "Las variables tienen tres características que las definen por completo: su nombre, su tipo y su valor.\n", "\n", "### Nombre\n", "\n", "Es una combinación de caracteres, dígitos y el signo de subrayado que permiten identificar una variable de modo único. Todo nombre debe empezar por un carácter.\n", "\n", "* **Ejemplos de nombres válidos**: x, y, pi, var2, var_2, precio_de_coste\n", "\n", "* **Ejemplos de nombres inválidos**: 14_de_mayo , 35a , +set, capitol 14\n", "\n", "Es muy recomendable que las variables empiecen con minúscula." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "3QZN1Z8NV9XM", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "subslide" } }, "source": [ "Debemos pensar que hay una serie de nombres que `Python` utiliza como parte del lenguaje y, por tanto, no son válidos como nombre de variable, ya que pueden darnos resultados inesperados. A continuación se pueden ver:\n", "\n", "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
Palabras clave en Python
Falsedefifraise
Nonedelimportreturn
Trueelifintry
andelseiswhile
asexceptlambdawith
assertfinallynonlocalyield
breakfornot
classfromor
continueglobalpass
\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "QYmFrq7ESkUi", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "### Tipo\n", "\n", "El tipo define la naturaleza de los valores que puede tener una variable. También limita las operaciones que se pueden realizar con ellas.\n", "\n", "Los tipos de datos elementales son: carácter, entero, real y booleano:\n", "\n", "**Carácter** permite representar información referente a caracteres simples y a secuencias de caracteres, se representan entre comas, ya sean simples \\' o dobles \\\". En el mundo de la programación conocemos una secuencia de caracteres con el nombre de _String_ (_str_). Python considera los caracteres como _strings_ de longitud 1.\n", "\n", "- Ejemplos de caracteres: 'a', 'b', '\\n'.\n", "- Ejemplos de _String_: '3', \"llonguet\", \"Josep\".\n", "\n", "**Entero** (*int*) permite representar valores numéricos tanto positivos como negativos.\n", "\n", "- Ejemplos de enteros: -33, 14, 28 o 8545445.\n", "\n", "**Real** (*float*): este tipo designa un número de coma flotante. Estos valores se especifican con un punto decimal. Opcionalmente, se puede añadir el carácter _e_ o _E_ seguido de un entero positivo o negativo para especificar el número en notación\n", "científica.\n", "\n", "- Ejemplos de números reales: -1.2, 3.1416, -0.26989, 4. , 3e7 (3000000.0), 1.6e-4 (0.00016).\n", "\n", "**Complejo**: valores numéricos en formato complejo. Se especifican como +j.\n", "\n", "- Ejemplos de números complejos: 2+3j, 33+0j.\n", "\n", "**Booleano**: valores lógicos. Pueden tener únicamente dos valores: verdad (`True`) o falso (`False`).\n", "\n", "El valor máximo y mínimo que podemos guardar en una variable de tipo entero o real no están definidos, como ocurre en otros lenguajes, dependen de la máquina donde ejecutan el código.\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "_gJ5wONJT3FD", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "### Declaraciones de variables\n", "\n", "Durante el transcurso del programa, el programador debe especificar cada una de las variables que necesitará. La especificación de estas variables se llama una declaración.\n", "\n", "Normalmente, estas declaraciones se realizan al inicio del programa. Como mínimo, debe definirse el nombre y asignarse un valor inicial. Si no se quiere (o no se puede) asignar un valor, en `Python` tenemos el valor nulo: **None**.\n", "\n", "A continuación tiene la primera muestra de código, declaramos una variable de cada uno de los diferentes tipos de datos que hemos descrito en la sección anterior:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "pycharm": { "name": "#%%\n" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "\n", "\n", "\n", "\n" ] } ], "source": [ "caracter = 'a'\n", "estring = \"Hello!\"\n", "enter = 123\n", "decimal = 1.23\n", "complexe = 1+23j\n", "logic = False\n", "\n", "\n", "#Este código no es relevante para nosotros, solamente el resultado\n", "print(type(caracter))\n", "print(type(estring))\n", "print(type(enter))\n", "print(type(decimal))\n", "print(type(complexe))\n", "print(type(logic))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "6S0DUax1URt3", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "### Operadores i operandos\n", "En `Python`, los **operadores** son símbolos especiales que indican que es necesario realizar algún tipo de computación. Los valores con los que actúa un operador se llaman **operandos**.\n", "\n", "Lo entenderemos con un pequeño ejemplo:\n", "```\n", "x = 10.0\n", "y = 5\n", "resultado = x + y\n", "```\n", "En este caso, el operador `+` nos permite sumar los operandos `x` y `y` juntos y guardar el resultado en la variable del mismo nombre. Debemos destacar que en este código hemos necesitado definir tres variables distintas.\n", "\n", "Un operando puede ser una variable o literal. Definimos los **literales** en un programa como la idea de expresar un valor que no cambia en el código fuente, estos deben ser de uno de los diferentes tipos de datos que hemos descrito\n", "anteriormente.\n", "\n", "A continuación tenemos otro fragmento de código en el que usamos otros operadores y literales de tipo entero:\n", "```\n", "a = 10\n", "b = 20\n", "x = 45\n", "r = (a + b - 5) + (x + 10 + 20)\n", "```" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "1hT4qF0g68Bb", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "subslide" } }, "source": [ "Una secuencia de operandos y operadores, como + b - 5, se llama **expresión**. `Python` admite muchos operadores diferentes para combinar operandos de diferentes tipos, esto nos permitirá crear expresiones diferentes para solucionar los diferentes problemas que se presenten." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "xAOOjalo7Q9a", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "\n", "#### Operadores aritméticos\n", "\n", "La siguiente tabla lista los operadores aritméticos compatibles con `Python`:\n", "\n", "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
OperadorEjemploDefiniciónResultado
+ (unari)+aUnario Positivoa Realmente no hace nada. Existe para complementar la negación unaria.
+ (binari)a + bSumaSuma a i b
- (unari)-aNegació unària El mismo valor que a pero con el signo opuesto
- (binari)a - bRestaResultado de restar b al operando a
* a * bMultiplicaciónProducto de a y b
/a / bDivisiónCociente de a dividido por b.
El resultado siempre es del tipo float float.
%a % bMóduloResto de a dividido por b
//a // bDivisión entera Cociente de dividir a entre b, redondeado al siguiente número entero más pequeño
**a ** bExponentea elevado a b
\n", "\n", "Aquí tenéis algunos ejemplos de su uso:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1.5\n" ] } ], "source": [ "division_decimal = 3 / 2\n", "print(division_decimal)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "division_entera = 3 // 2\n", "division_entera" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "mIyp79mW9S0B", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operadores de comparación\n", "Los operadores de comparación se utilizan normalmente en contextos booleanos como los que nos sirven para controlar el flujo del programa, como veremos más adelante. El resultado de usar un operador de comparación es siempre del tipo _booleano_.\n", "\n", "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
OperadorEjemploDefiniciónResultado
==a == bIgualTrue si el valor de a es igual al valor de b
False de lo contrario
!=a != bDiferenteTrue si el valor de a es diferente a b
False de lo contrario
<a < bMenorTrue si el valor de a es menor que b
False de lo contrario
<=a <= bMenor o igual a True si el valor de aes menor o igual a b
False de lo contrario
>a > bMayorTrue si el valor de a es mayor en b
False de lo contrario
>=a >= bMayor o igual aTrue si el valor de a es mayor o igual a b
False de lo contrario
\n", "
\n", "\n", "\n", "El valor almacenado internamente para una variable en coma flotante puede no ser lo que uno pensaría que iba a ser. Por este motivo es poco práctico comparar variables del tipo coma flotante con el operador de igualdad exacta `==`.\n", "\n", "Aquí tenéis algunos ejemplos de su uso:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = 5.3\n", "y = 5.5\n", "comparacion_1 = x < y\n", "comparacion_1" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "letra_a = 'a'\n", "letra_b = 'b'\n", "\n", "comparacion_2 = letra_a != letra_b\n", "comparacion_2" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "letra_a = 'a'\n", "letra_b = 'b'\n", "\n", "comparacion_3 = letra_a > letra_b\n", "comparacion_3" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "YlJBrldmJHSH", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operadores lógicos\n", "\n", "Los operadores lógicos _not_, _or_ y _and_ modifican y unen expresiones evaluadas en un contexto booleano y nos permiten crear condiciones más complejas.\n", "\n", "**Expresiones lógicas que incluyen operandos booleanos**\n", "\n", "Como ha visto, algunas expresiones de `Python` son, en realidad, de tipo booleano. Es decir, son iguales a uno de los valores `Python` `True` or `False`.\n", "\n", "Por ejemplo:" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "7ZLUCGl8VTFx", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "subslide" } }, "source": [ "A continuación tenéis la tabla de operadores:\n", "\n", "
\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "\n", "
OperadorEjemploSignificado
notnot xTrue si x es False
False si x es True
orx or yTrue si x o y es True
False en caso contrario
andx and yTrue si x y y son True
False en caso contrario
\n", "\n", "Para ver su uso, pero sobre todo el resultado de la aplicación de estos operadores en variables del tipo booleano, en continuación tiene un conjunto de ejemplos de su aplicación:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "verdadero = True\n", "falso = False" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "operador_not = not verdadero\n", "operador_not" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "operador_or = verdadero or falso\n", "operador_or\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "operador_or = falso or falso\n", "operador_or" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "False" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "operador_and = verdadero and falso\n", "operador_and" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "operador_and = verdadero and verdadero\n", "operador_and" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ao85rcLYdD7f", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "#### Operadores de asignación aumentada\n", "\n", "Antes hemos visto que un signo igual (=) se utiliza para asignar un valor a una variable. Es, por supuesto, perfectamente viable que el valor de la derecha de la asignación sea una expresión que contenga otras variables. Si realizamos la operación sobre una misma variable podemos hacer lo siguiente:\n", "\n", "`x = y` es lo mismo que hacer ` x = x y`\n", "\n", "\n", "Es decir:\n", "```\n", "x = 4\n", "y = 5\n", "\n", "x += y\n", "```\n", "Es lo mismo que hacer:\n", "\n", "```\n", "x = x + y\n", "```" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "9lzzG0HpEGp2", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "### Comentarios en el código\n", "\n", "En el mundo de la programación, un comentario es una explicación o anotación legible por el programador en el código fuente de un programa de ordenador. Se escriben con el propósito de facilitar la comprensión del código fuente para futuras lecturas del mismo programador o por otros programadores, son ignorados por los intérpretes.\n", "\n", "Muchas veces también usaremos los comentarios para prevenir la ejecución de una parte del código cuando queremos evaluar el funcionamiento de nuestro propio código. En **Python** los comentarios se expresan con el símbolo `#`. A continuación veremos dos ejemplos de su uso:\n", "```\n", "# Esto es un comentario que me ayuda a explicar el blog de código\n", "\n", "x = y +3 # Aquí también puedo poner un comentario para describir la expresión\n", "```\n", "\n", "Es recomendable comentar el código que realizamos, en particular aquellas partes más relevantes o que presentan\n", "cierta dificultad." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "78\n" ] } ], "source": [ "# COMENTARIO\n", "variable = 45\n", "resultado = variable + 33\n", "print(resultado)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "3Gz46PWWGRtj", "pycharm": { "name": "#%% md\n" }, "slideshow": { "slide_type": "slide" } }, "source": [ "### Salida de información\n", "\n", "Para poder mostrar información por pantalla, utilizaremos la función `print`. Esta función puede mostrar cualquier texto (*string*) separado entre comas.\n", "\n", "A continuación tiene varios ejemplos:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", "id": "H4vuloNBHDcV", "pycharm": { "name": "#%%\n" }, "slideshow": { "slide_type": "subslide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hola mon!\n", "Esto es un texto el cual concatenam con otro texto\n", "También lo podemos hacer así a b\n", "Texto concatenado con un número \"3\"\n" ] } ], "source": [ "print(\"Hola mon!\")\n", "\n", "print(\"Esto es un texto\" + \" el cual concatenam con otro texto\")\n", "\n", "a = 'a' + \" \" + 'b'\n", "\n", "print(\"También lo podemos hacer así \" + a)\n", "\n", "num = 3\n", "print(f'Texto concatenado con un número \"{num}\"')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } }, "source": [ "### Funciones\n", "\n", "Una función se define por cuatro aspectos:\n", "\n", "* El **nombre** de la función: es la manera de poder identificar cada uno de los subprogramas.\n", "* Los argumentos o **parámetros**: es la información adicional que podemos suministrar a las funciones. Usualmente, se indica como una lista de valores separada por comas entre paréntesis.\n", "* El **tipo de valor resultado**: es el tipo de información que la función puede suministrar como resultado de la su ejecución. El valor que devuelve la función se genera con la instrucción `return`. En el lenguaje `Python` no debemos especificar cuál es el tipo del valor resultado.\n", "\n", "Hay que notar que en `Python` existe la palabra reservada `def` para determinar que un bloque de código se corresponde a una función. Su esquema es el siguiente:\n", "\n", "```\n", "def (, , ..., ):\n", " \n", "```\n", "\n", "El conjunto de líneas de código también se conoce con el número de _cuerpo del subprograma_. El cuerpo del subprograma debe estar identado.\n", "\n", "A continuación veremos cómo se implementa una **función** que transforma una cantidad de metros a centímetros. Esta función que se llama `m_a_cm` recibe un parámetro llamado `m` el cual esperamos que contenga un número sea entero o decimal. Esta función utiliza el parámetro en una expresión y posteriormente devuelve el valor calculado." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "def m_a_cm(metros):\n", " centimetros = metros * 100\n", " return centimetros" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } }, "source": [ "La palabra reservada `return` nos sirve para explicitar el valor que debe devolver la función.\n", "\n", "Veamos ejemplos de uso de la función definida anteriormente. Es interesante fijarse en cómo usamos el valor devuelto por la función y lo guardamos en la variable `transformado`:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "33 metros son 3300 cm\n" ] } ], "source": [ "# La variable transformado recoge el valor de la función m_a_cm\n", "# podemos usar este valor para otras tareas en nuestro programa\n", "m = 33\n", "transformado = m_a_cm(m)\n", "\n", "print(f'{m} metros son {transformado} cm')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } }, "source": [ "### Ejercicios\n", "\n", "La idea es que con ellos consolides los conceptos trabajados hasta este momento: creación de variables y uso de operadores.\n", "\n", "1. Realizar un conjunto de expresiones en `Python` que nos calcule el índice de masa corporal (IMC) de una persona que mide 2 m i pesa 60 Kg. Se calcula dividiendo el peso entre la altura al cuadrado (en cm).\n", "2. Realizar un conjunto de expresiones en `Python` para resolver una ecuación de primer grado de la forma ax+b= 0. Los valores de `a` y `b` los pondremos directamente en el código y mostrar la solución por pantalla.\n", "3. Crear una función que recibe un número entero que representa un año y nos devuelve un valor _booleano_ que representa si es un año bisiesto o no. Comprueba la corrección de tu función usándola.\n", "4. Realizar una función que recibe los parámetros (números enteros): a, b y c. resuelve una ecuación de segundo grado y devuelve sus soluciones. Ejemplo, la ecuación: $2x^2 + 20x + 3 = 0$ debe dar -0.1523201 ; -9.8476799. Para calcular la raíz cuadrada podéis usar la función _sqrt_. Comprueba la corrección de tu función usándola.\n", "\n", "Ejemplo de uso de la función:\n", "\n", "```\n", "import math # Al principio del script\n", "\n", "math.sqrt(4)\n", "```" ] } ], "metadata": { "colab": { "collapsed_sections": [], "name": "Tema2", "provenance": [], "version": "0.3.2" }, "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.9.7 (default, May 11 2022, 11:18:00) \n[Clang 13.1.6 (clang-1316.0.21.2.3)]" }, "vscode": { "interpreter": { "hash": "1dd6de46b7c7be538353ccdeaa948031a5b4d43665739a26f55ca28b247c53cc" } } }, "nbformat": 4, "nbformat_minor": 1 }