├── .gitignore ├── LICENSE ├── README.md ├── class-solved ├── MODULE_1-python_introduction-solved │ ├── 10.01_VariablesOperadores-solved.ipynb │ ├── 10.02_CondicionesBucles-solved.ipynb │ ├── 10.03_Funciones-solved.ipynb │ ├── 10.04_ProgramacionPython-solved.ipynb │ └── 10.05_comprehension_list_exercises.py └── MODULE_2-Work_with_data-solved │ └── 02.01_Expresiones Regulares en Python-solved.ipynb ├── class ├── MODULE_1-python_introduction │ ├── 10.01_VariablesOperadores.ipynb │ ├── 10.02_CondicionesBucles.ipynb │ ├── 10.03_Funciones.ipynb │ ├── 10.04_ProgramacionPython.ipynb │ ├── 10.08_Ejercicios.ipynb │ ├── 10.09_Ejercicios_extra.ipynb │ ├── 10.10_ExamenInformaticaDic2014.ipynb │ ├── 10.10_vectoresEquilibrados.txt │ ├── funcionesDEMO.py │ └── hw.txt ├── MODULE_2-Work_with_data │ ├── 02.01_Expresiones Regulares en Python.ipynb │ ├── 02.02_Input_Output.ipynb │ ├── 02.03_dataScience-pandas.ipynb │ ├── 02.40_PANDAS_LAB_BANCO │ │ ├── 02.40_PANDAS_LAB_Banco.ipynb │ │ ├── 02.40_PANDAS_LAB_Banco_dataframe_style_PRO.ipynb │ │ └── Banco.xlsx │ ├── data │ │ ├── Salaries.csv │ │ └── flights.csv │ └── img │ │ ├── dfAtributes.PNG │ │ └── dfMethods.PNG └── MODULE_3-data_visualization │ ├── CORONAVIRUS.xlsx │ └── Practica_extra_coronavirus.ipynb └── docs ├── 01.01IntroPython.pdf ├── 01.02PythonForDataScience.pdf ├── 02.01_python-cheatsheets-ds.pdf ├── 02.02pandas_cheat_sheet.pdf ├── Git summary.png └── Git summary_2.png /.gitignore: -------------------------------------------------------------------------------- 1 | 2019-2020/ 2 | docs-private/ 3 | class-private/ 4 | class/10.20_numpy.ipynb 5 | class/10.30_excercises_numpy.ipynb 6 | .vscode 7 | 8 | class-solved/MODULE_1-python_introduction-solved/.ipynb_checkpoints/ 9 | class/MODULE_1-python_introduction/__pycache__/ 10 | class/MODULE_1-python_introduction/.ipynb_checkpoints/ 11 | # class-solved/MODULE_1-python_introduction-solved/10.02_CondicionesBucles-solved.ipynb 12 | # class-solved/MODULE_1-python_introduction-solved/10.03_Funciones-solved.ipynb 13 | # class-solved/MODULE_1-python_introduction-solved/10.04_ProgramacionPython-solved.ipynb 14 | class-solved/MODULE_1-python_introduction-solved/10.08_Ejercicios-solved.ipynb 15 | class-solved/MODULE_1-python_introduction-solved/10.10_ExamenInformaticaDic2014-solved.ipynb 16 | class-solved/MODULE_1-python_introduction-solved/10.10_vectoresEquilibrados.txt 17 | class-solved/MODULE_1-python_introduction-solved/Ej1_ExamenInformaticaDic2014_resuelto.pdf 18 | class-solved/MODULE_1-python_introduction-solved/__pycache__/ 19 | class-solved/MODULE_1-python_introduction-solved/funcionesDEMO.py 20 | class-solved/MODULE_1-python_introduction-solved/hw.txt 21 | class-solved/MODULE_1-python_introduction-solved/hwx3.txt 22 | class-solved/MODULE_1-python_introduction-solved/numpy_solved.ipynb 23 | class-solved/MODULE_1-python_introduction-solved/resultados.txt 24 | class-solved/MODULE_1-python_introduction-solved/soluciones_airbnb.py 25 | class-solved/MODULE_1-python_introduction-solved/spyder_funcionEj1.py 26 | class-solved/MODULE_1-python_introduction-solved/spyder_resolucionEj1.py 27 | class-solved/MODULE_1-python_introduction-solved/spyder_resultados.txt 28 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 Fernando Carazo 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Introduccion-a-Python 2 | 3 | ## 1. Contents 4 | 5 | Curso de Introducción a la Programación en Python - Impartido en TECNUN Universidad de Navarra. 6 | 7 | A continuación se detallan los contenidos y archivos que se utilizarán en clase: 8 | 9 | | Día | Clase | Tema | Documentos/archivos utilizados | Práctica | 10 | | :--------: | :------: | :---------------------------: | :-------------------------------------------------------------------: | :------: | 11 | | 2020-01-26 | Clase 1 | Anaconda y jupyter | docs/10.01IntroPython.pdf | | 12 | | 2020-02-02 | Clase 2 | Tipos de variables | - class/10.01_VariablesOper.ipynb | | 13 | | 2020-02-09 | Clase 3 | Bucles y condiciones | - class/10.02_CondiBucl.ipynb
- docs/10.02PythonForDataScience.pdf | | 14 | | 2020-02-16 | Clase 4 | Funciones, Python Exercises | - class/10.03_Funciones
- class/10.08_Ejercicios.ipynb | 10.08 | 15 | | 2020-02-23 | Clase 5 | Progamación específica | - class/10.04_ProgramacionPython.ipynb | 10.05 | 16 | | 2020-03-02 | Clase 6 | Regular Expressions | - class/02.01_Expresiones_Regulares | | 17 | | 2020-03-09 | Clase 7 | Reguex II, input output & git | https://regexone.com/ -
- 02.02_input_output | | 18 | | 2020-03-16 | Clase 8 | Introduction to Pandas | class/02.03_dataScience-salary-pandas
- docs/02.01, 02.02 | | 19 | | 2020-03-23 | Clase 9 | | | | 20 | | 2020-04-13 | Clase 10 | Pandas Lab 1 | 02.40_PANDAS_LAB_BANCO | 02.40 | 21 | | 2020-04-20 | Clase 11 | Pandas Lab 2 + apply | 02.40_PANDAS_LAB_Banco_dataframe_style_PRO | 02.50 | 22 | | 2020-04-27 | Clase 12 | | | | 23 | | 2020-05-04 | Clase 13 | | | | 24 | | 2020-05-11 | Clase 14 | | | | 25 | -------------------------------------------------------------------------------- /class-solved/MODULE_1-python_introduction-solved/10.01_VariablesOperadores-solved.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 1- Variables y Operadores\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra\n" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "El objetivo de este documento es conocer algunos tipos de variables y operadores empleados en Python." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## Hello, world!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "Pero, antes de entrar en materia, vamos a iniciarnos con la línea de código con la que empieza todo el mundo.\n", 31 | "\n", 32 | "El comando *print()* nos muestra por pantalla lo que le pasemos como argumento. En este caso, queremos ver por pantalla el texto \"Hello, world!\"." 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "output_type": "stream", 42 | "name": "stdout", 43 | "text": [ 44 | "Hello, world!\nHello, world!\n" 45 | ] 46 | } 47 | ], 48 | "source": [ 49 | "print('Hello, world!')\n", 50 | "print(\"Hello, world!\")" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 4, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "import numpy as np" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 5, 65 | "metadata": {}, 66 | "outputs": [ 67 | { 68 | "output_type": "execute_result", 69 | "data": { 70 | "text/plain": [ 71 | "array([1, 2, 3])" 72 | ] 73 | }, 74 | "metadata": {}, 75 | "execution_count": 5 76 | } 77 | ], 78 | "source": [ 79 | "np.array([1,2,3])" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "Obsérvese que podemos emplear tanto comillas simples como dobles para trabajar con cadenas de caracteres." 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "## Variables numéricas y operadores" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "Vamos a empezar por las variables numéricas. Las más empleadas son las variables enteras (**int**) y flotantes (**float**). Con las primeras podremos representar los números enteros, y, con las segundas, cualquier número con decimales." 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 6, 106 | "metadata": {}, 107 | "outputs": [ 108 | { 109 | "output_type": "stream", 110 | "name": "stdout", 111 | "text": [ 112 | "1\n1.0\n" 113 | ] 114 | } 115 | ], 116 | "source": [ 117 | "entero = 1\n", 118 | "flotante = 1.0\n", 119 | "\n", 120 | "print(entero)\n", 121 | "print(flotante)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "Podemos operar con los dos tipos de variables de la misma manera utilizando los operadores suma (**\\+**), resta (**\\-**), multiplicación (**\\***) y división (**\\/**). Debemos tener en cuenta que el resultado de cualquier operación realizada con variables flotantes será otra variable flotante. El resultado de cualquier operación realizada con variables enteras, por el contrario, será otra variable entera, a excepción de la división, que será flotante." 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 7, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "output_type": "stream", 138 | "name": "stdout", 139 | "text": [ 140 | "5\n-3\n4\n4.0\n\n\n5.0\n-3.0\n4.0\n4.0\n" 141 | ] 142 | } 143 | ], 144 | "source": [ 145 | "int1 = 1\n", 146 | "int2 = 4\n", 147 | "float1 = 1.0\n", 148 | "float2 = 4.0\n", 149 | "\n", 150 | "print(int1 + int2)\n", 151 | "print(int1 - int2)\n", 152 | "print(int1 * int2)\n", 153 | "print(int2 / int1)\n", 154 | "print('\\n')\n", 155 | "print(float1 + float2)\n", 156 | "print(float1 - float2)\n", 157 | "print(float1 * float2)\n", 158 | "print(float2 / float1)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "Python también permite mezclar variables enteras y flotantes en la misma operación. En este caso, el resultado siempre será flotante." 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 8, 171 | "metadata": {}, 172 | "outputs": [ 173 | { 174 | "output_type": "stream", 175 | "name": "stdout", 176 | "text": [ 177 | "5.0\n-3.0\n4.0\n4.0\n" 178 | ] 179 | } 180 | ], 181 | "source": [ 182 | "print(int1 + float2)\n", 183 | "print(int1 - float2)\n", 184 | "print(int1 * float2)\n", 185 | "print(float2 / int1)" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "Existen otros tres operadores que nos pueden resultar de utilidad: la potencia (**\\*\\***), la división entera (**//**) y el residuo de la división(**%**). El resultado de estas operaciones mantiene la naturaleza de las variables con las que estamos operando." 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 9, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "output_type": "stream", 202 | "name": "stdout", 203 | "text": [ 204 | "8\n1.5\n1\n1\n\n\n8.0\n1.5\n1.0\n1.0\n" 205 | ] 206 | } 207 | ], 208 | "source": [ 209 | "int1 = 2\n", 210 | "int2 = 3\n", 211 | "float1 = 2.0\n", 212 | "float2 = 3.0\n", 213 | "\n", 214 | "print(int1 ** int2)\n", 215 | "print(int2 / int1)\n", 216 | "print(int2 // int1)\n", 217 | "print(int2 % int1)\n", 218 | "print('\\n')\n", 219 | "print(float1 ** float2)\n", 220 | "print(float2 / float1)\n", 221 | "print(float2 // float1)\n", 222 | "print(float2 % float1)" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "Para terminar con las variables numéricas, introduciremos la función **type()**. Esta función nos mostrará el tipo de variable que estamos utilizando y se puede emplear para cualquier tipo de variable." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 10, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "output_type": "stream", 239 | "name": "stdout", 240 | "text": [ 241 | "\n\n" 242 | ] 243 | } 244 | ], 245 | "source": [ 246 | "print(type(2))\n", 247 | "print(type(2.0))" 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "## Cadenas de caracteres y operadores" 255 | ] 256 | }, 257 | { 258 | "cell_type": "markdown", 259 | "metadata": {}, 260 | "source": [ 261 | "Como hemos comentado más arriba, las cadenas de caracteres (string) puede escribirse con comillas simples o dobles." 262 | ] 263 | }, 264 | { 265 | "cell_type": "code", 266 | "execution_count": 11, 267 | "metadata": {}, 268 | "outputs": [ 269 | { 270 | "output_type": "stream", 271 | "name": "stdout", 272 | "text": [ 273 | "Hello\nworld\n" 274 | ] 275 | } 276 | ], 277 | "source": [ 278 | "h = 'Hello'\n", 279 | "w = \"world\"\n", 280 | "\n", 281 | "print(h)\n", 282 | "print(w)" 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "De la misma forma que hemos hecho con las variables numéricas, podemos emplear los operadores suma (**\\+**) y multiplicación (**\\***) para operar con las cadenas de caracteres. Con el primer operador concatenaremos las cadenas que estamos \"sumando\", mientras que con el segundo repetiremos la cadena tantas veces como el número que la multiplica." 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 12, 295 | "metadata": {}, 296 | "outputs": [ 297 | { 298 | "output_type": "stream", 299 | "name": "stdout", 300 | "text": [ 301 | "Hello, world!\nHelloHelloHello\n" 302 | ] 303 | } 304 | ], 305 | "source": [ 306 | "print(h + ', ' + w + '!')\n", 307 | "print(3*h)" 308 | ] 309 | }, 310 | { 311 | "source": [ 312 | "Hay que tener mucho cuidado con los tipos de variable con los que estamos trabajando al hacer este tipo de operaciones. Véase un ejemplo:" 313 | ], 314 | "cell_type": "markdown", 315 | "metadata": {} 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": 14, 320 | "metadata": {}, 321 | "outputs": [ 322 | { 323 | "output_type": "stream", 324 | "name": "stdout", 325 | "text": [ 326 | "4\n22\n" 327 | ] 328 | } 329 | ], 330 | "source": [ 331 | "int_a = 2\n", 332 | "str_a = \"2\"\n", 333 | "\n", 334 | "print(int_a + int_a)\n", 335 | "print(str_a + str_a)\n", 336 | "# print(int_a + str_a) #Esta línea de código da error." 337 | ] 338 | }, 339 | { 340 | "cell_type": "markdown", 341 | "metadata": {}, 342 | "source": [ 343 | "El poder emplear las comillas simples o dobles para crear las cadenas de caracteres facilita la inclusión de estos símbolos en el texto." 344 | ] 345 | }, 346 | { 347 | "cell_type": "code", 348 | "execution_count": 15, 349 | "metadata": {}, 350 | "outputs": [ 351 | { 352 | "output_type": "stream", 353 | "name": "stdout", 354 | "text": [ 355 | "Como la cadena ha sido creada con comillas simples, las comillas dobles (\") aparecerán en el texto sin problema.\nComo la cadena ha sido creada con comillas dobles, las comillas simples (') aparecerán en el texto sin problema.\n" 356 | ] 357 | } 358 | ], 359 | "source": [ 360 | "print('Como la cadena ha sido creada con comillas simples, las comillas dobles (\") aparecerán en el texto sin problema.')\n", 361 | "print(\"Como la cadena ha sido creada con comillas dobles, las comillas simples (') aparecerán en el texto sin problema.\")" 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "Al igual que otros lenguajes de programación, Python permite acceder a los elementos de las cadenas de caracteres. Para ello, hay que tener en cuenta que el primer elemento de la cadena está ubicado en la posición 0." 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": 16, 374 | "metadata": {}, 375 | "outputs": [ 376 | { 377 | "output_type": "stream", 378 | "name": "stdout", 379 | "text": [ 380 | "H\ne\nd\n" 381 | ] 382 | } 383 | ], 384 | "source": [ 385 | "texto = 'Hello, world!'\n", 386 | "\n", 387 | "print(texto[0])\n", 388 | "print(texto[1])\n", 389 | "print(texto[11])" 390 | ] 391 | }, 392 | { 393 | "cell_type": "markdown", 394 | "metadata": {}, 395 | "source": [ 396 | "## Conversión de tipos de variables" 397 | ] 398 | }, 399 | { 400 | "cell_type": "markdown", 401 | "metadata": {}, 402 | "source": [ 403 | "Utilizando las funciones **int()**, **float()** y **str()**, se pueden convertir las variables de un tipo a otro. De todas formas, hay que tener cuidado al convertir flotantes a enteros, o cadenas de caracteres a enteros o flotantes." 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": 17, 409 | "metadata": {}, 410 | "outputs": [ 411 | { 412 | "output_type": "stream", 413 | "name": "stdout", 414 | "text": [ 415 | "1.0\n1\n\n\n1\n1.9\n\n\n1\n1.0\n\n\n1.0\n1\n\n\n" 416 | ] 417 | } 418 | ], 419 | "source": [ 420 | "entero = 1\n", 421 | "flotante = 1.9\n", 422 | "cadena = '1'\n", 423 | "cadena2 = '1.0'\n", 424 | "cadena3 = 'Hello, world!'\n", 425 | "\n", 426 | "print(float(entero))\n", 427 | "print(str(entero))\n", 428 | "print('\\n')\n", 429 | "print(int(flotante))\n", 430 | "print(str(flotante))\n", 431 | "print('\\n')\n", 432 | "print(int(cadena))\n", 433 | "print(float(cadena))\n", 434 | "print('\\n')\n", 435 | "print(float(cadena2))\n", 436 | "# print(int(cadena2)) #Esta línea de código da error.\n", 437 | "print(int(float(cadena2)))\n", 438 | "print('\\n')\n", 439 | "# print(int(cadena3)) #Esta línea de código da error.\n", 440 | "# print(float(cadena3)) #Esta línea de código da error." 441 | ] 442 | }, 443 | { 444 | "cell_type": "markdown", 445 | "metadata": {}, 446 | "source": [ 447 | "## Listas " 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": {}, 453 | "source": [ 454 | "Las listas son un tipo de variable que contienen distintas variables de cualquier tipo en su interior." 455 | ] 456 | }, 457 | { 458 | "cell_type": "code", 459 | "execution_count": 18, 460 | "metadata": {}, 461 | "outputs": [ 462 | { 463 | "output_type": "stream", 464 | "name": "stdout", 465 | "text": [ 466 | "[1, 2, 3, 4]\n[1.5, 6.3, 7.9]\n['Hello', 'world']\n" 467 | ] 468 | } 469 | ], 470 | "source": [ 471 | "lista1 = [1, 2, 3, 4]\n", 472 | "lista2 = [1.5, 6.3, 7.9]\n", 473 | "lista3 = ['Hello', 'world']\n", 474 | "\n", 475 | "print(lista1)\n", 476 | "print(lista2)\n", 477 | "print(lista3)" 478 | ] 479 | }, 480 | { 481 | "cell_type": "markdown", 482 | "metadata": {}, 483 | "source": [ 484 | "Las listas pueden contener elementos de distinta naturaleza." 485 | ] 486 | }, 487 | { 488 | "cell_type": "code", 489 | "execution_count": 19, 490 | "metadata": {}, 491 | "outputs": [ 492 | { 493 | "output_type": "stream", 494 | "name": "stdout", 495 | "text": [ 496 | "[1, 'Hello, world!', 3.5]\n" 497 | ] 498 | } 499 | ], 500 | "source": [ 501 | "lista4 = [1, 'Hello, world!', 3.5]\n", 502 | "\n", 503 | "print(lista4)" 504 | ] 505 | }, 506 | { 507 | "cell_type": "markdown", 508 | "metadata": {}, 509 | "source": [ 510 | "De la misma manera que con los elementos de las cadenas de caracteres, se puede acceder a los elementos de las listas de la siguiente manera:" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": 20, 516 | "metadata": {}, 517 | "outputs": [ 518 | { 519 | "output_type": "stream", 520 | "name": "stdout", 521 | "text": [ 522 | "1\nHello, world!\n3.5\n" 523 | ] 524 | } 525 | ], 526 | "source": [ 527 | "print(lista4[0])\n", 528 | "print(lista4[1])\n", 529 | "print(lista4[2])" 530 | ] 531 | }, 532 | { 533 | "cell_type": "markdown", 534 | "metadata": {}, 535 | "source": [ 536 | "## Otras variables " 537 | ] 538 | }, 539 | { 540 | "cell_type": "markdown", 541 | "metadata": {}, 542 | "source": [ 543 | "Aunque no entraremos en detalle, vamos a introducir tres tipos de variables más: los diccionarios, las tuplas y los conjuntos." 544 | ] 545 | }, 546 | { 547 | "cell_type": "code", 548 | "execution_count": 21, 549 | "metadata": {}, 550 | "outputs": [ 551 | { 552 | "output_type": "stream", 553 | "name": "stdout", 554 | "text": [ 555 | "{'Asignatura 1': 'Ciencia de Datos en Python', 2: ['a', 2, 3.0], 3.0: 'Machine Learning', 'Asignatura 4': 10}\nCiencia de Datos en Python\n['a', 2, 3.0]\nMachine Learning\n10\n\n\n('CDPy', 2, 5.0, 'DP')\n5.0\n\n\n{2, 3.0, 'a'}\n{2, 3.0, 'a'}\n{2, 'a'}\n{2, 3.0, 4.0, 'a'}\n{3.0}\n{3.0, 4.0}\n" 556 | ] 557 | } 558 | ], 559 | "source": [ 560 | "dictionary = {'Asignatura 1' : 'Ciencia de Datos en Python', 2 : ['a', 2, 3.0], 3.0 : 'Machine Learning', 'Asignatura 4' : 10}\n", 561 | "tupla = ('CDPy', 2, 5.0, 'DP')\n", 562 | "conjunto1 = {'a', 2, 3.0}\n", 563 | "conjunto2 = {'a', 2, 4.0}\n", 564 | "\n", 565 | "print(dictionary)\n", 566 | "print(dictionary['Asignatura 1'])\n", 567 | "print(dictionary[2])\n", 568 | "print(dictionary[3.0])\n", 569 | "print(dictionary['Asignatura 4'])\n", 570 | "# print(dictionary[0]) #Esta línea de código da error.\n", 571 | "print('\\n')\n", 572 | "print(tupla)\n", 573 | "print(tupla[2])\n", 574 | "print('\\n')\n", 575 | "print(conjunto1)\n", 576 | "# print(conjunto[0]) #Esta línea de código da error.\n", 577 | "conjunto1.add('a')\n", 578 | "print(conjunto1)\n", 579 | "print(conjunto1 & conjunto2)\n", 580 | "print(conjunto1 | conjunto2)\n", 581 | "print(conjunto1 - conjunto2)\n", 582 | "print(conjunto1 ^ conjunto2)" 583 | ] 584 | }, 585 | { 586 | "cell_type": "markdown", 587 | "metadata": {}, 588 | "source": [ 589 | "## Cortes de cadenas/listas " 590 | ] 591 | }, 592 | { 593 | "cell_type": "markdown", 594 | "metadata": {}, 595 | "source": [ 596 | "Como hemos comentado antes, las posiciones en las cadenas de caracteres y listas empiezan a contar desde 0.\n", 597 | "\n", 598 | "El operador **:** se emplea para obtener los valores guardados en más de una posición del vector (corte del vector)." 599 | ] 600 | }, 601 | { 602 | "cell_type": "code", 603 | "execution_count": 22, 604 | "metadata": {}, 605 | "outputs": [ 606 | { 607 | "output_type": "stream", 608 | "name": "stdout", 609 | "text": [ 610 | "abcd\n['a', 'b', 'c', 'd']\n\n\nabcd\n['a', 'b', 'c', 'd']\n" 611 | ] 612 | } 613 | ], 614 | "source": [ 615 | "cadena4 = 'abcdefg'\n", 616 | "lista5 = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n", 617 | "\n", 618 | "print(cadena4[0:4])\n", 619 | "print(lista5[0:4])\n", 620 | "print('\\n')\n", 621 | "print(cadena4[:4])\n", 622 | "print(lista5[:4])" 623 | ] 624 | }, 625 | { 626 | "cell_type": "markdown", 627 | "metadata": {}, 628 | "source": [ 629 | "En este caso, a pesar de poner **[0:4]** estamos extrayendo los elementos guardados en las posiciones 0, 1, 2 y 3. **Es muy importante tener en cuenta que el primer valor (0) sí que se extraerá, pero no así el último**.\n", 630 | "\n", 631 | "Aparte de acceder a los vectores por el primer elemento, también podemos acceder a ellos desde el último empleando el operador **-**." 632 | ] 633 | }, 634 | { 635 | "cell_type": "code", 636 | "execution_count": 23, 637 | "metadata": {}, 638 | "outputs": [ 639 | { 640 | "output_type": "stream", 641 | "name": "stdout", 642 | "text": [ 643 | "ef\n['e', 'f']\n\n\nefg\n['e', 'f', 'g']\n" 644 | ] 645 | } 646 | ], 647 | "source": [ 648 | "print(cadena4[-3:-1])\n", 649 | "print(lista5[-3:-1])\n", 650 | "print('\\n')\n", 651 | "print(cadena4[-3:])\n", 652 | "print(lista5[-3:])" 653 | ] 654 | }, 655 | { 656 | "cell_type": "markdown", 657 | "metadata": {}, 658 | "source": [ 659 | "También podemos extraer elementos a saltos, por ejemplo, aquellos elementos que están en posiciones pares. Para ello, volvemos a emplear el operador **:** junto con un tercer número que indica el paso." 660 | ] 661 | }, 662 | { 663 | "cell_type": "code", 664 | "execution_count": 24, 665 | "metadata": {}, 666 | "outputs": [ 667 | { 668 | "output_type": "stream", 669 | "name": "stdout", 670 | "text": [ 671 | "aceg\n['a', 'c', 'e', 'g']\n" 672 | ] 673 | } 674 | ], 675 | "source": [ 676 | "print(cadena4[0:7:2])\n", 677 | "print(lista5[0:7:2])" 678 | ] 679 | }, 680 | { 681 | "cell_type": "markdown", 682 | "metadata": {}, 683 | "source": [ 684 | "Para terminar, también con el operador **-** podemos darle la vuelta al vector." 685 | ] 686 | }, 687 | { 688 | "cell_type": "code", 689 | "execution_count": 25, 690 | "metadata": {}, 691 | "outputs": [ 692 | { 693 | "output_type": "stream", 694 | "name": "stdout", 695 | "text": [ 696 | "gfedcba\n['g', 'f', 'e', 'd', 'c', 'b', 'a']\n\n\ngf\n['g', 'f']\n" 697 | ] 698 | } 699 | ], 700 | "source": [ 701 | "print(cadena4[::-1])\n", 702 | "print(lista5[::-1])\n", 703 | "print('\\n')\n", 704 | "print(cadena4[6:4:-1])\n", 705 | "print(lista5[6:4:-1])" 706 | ] 707 | }, 708 | { 709 | "source": [ 710 | "## Ejercicio clase" 711 | ], 712 | "cell_type": "markdown", 713 | "metadata": {} 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": 9, 718 | "metadata": {}, 719 | "outputs": [ 720 | { 721 | "output_type": "stream", 722 | "name": "stdout", 723 | "text": [ 724 | "bcd\nace\ngfedcba\ngfedcba\ngec\n" 725 | ] 726 | } 727 | ], 728 | "source": [ 729 | "cadena4 = \"abcdefg\"\n", 730 | "\n", 731 | "\"b, c, d\"\n", 732 | "print(cadena4[1:4])\n", 733 | "\n", 734 | "\"a, c, e\"\n", 735 | "print(cadena4[0:5:2])\n", 736 | "\n", 737 | "\"dar la vuelta\"\n", 738 | "print(cadena4[6::-1])\n", 739 | "print(cadena4[::-1])\n", 740 | "\n", 741 | "\"g, e, c\"\n", 742 | "print(cadena4[:1:-2])\n" 743 | ] 744 | } 745 | ], 746 | "metadata": { 747 | "kernelspec": { 748 | "display_name": "Python 3", 749 | "language": "python", 750 | "name": "python3" 751 | }, 752 | "language_info": { 753 | "codemirror_mode": { 754 | "name": "ipython", 755 | "version": 3 756 | }, 757 | "file_extension": ".py", 758 | "mimetype": "text/x-python", 759 | "name": "python", 760 | "nbconvert_exporter": "python", 761 | "pygments_lexer": "ipython3", 762 | "version": "3.6.8-final" 763 | } 764 | }, 765 | "nbformat": 4, 766 | "nbformat_minor": 2 767 | } -------------------------------------------------------------------------------- /class-solved/MODULE_1-python_introduction-solved/10.02_CondicionesBucles-solved.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 2- Condiciones y Bucles\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "En este documento nos centraremos en la creación de condiciones y bucles. A diferencia de otros lenguajes de programación no se utilizan llaves o sentencias *end* para determinar lo que está incluido dentro de la condición o el bucle. En Python, todo esto se hace mediante indentación. A continuación veremos unos ejemplos." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## Condiciones" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "La sintaxis general de las condiciones es la siguiente:" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": 1, 36 | "metadata": {}, 37 | "outputs": [ 38 | { 39 | "output_type": "stream", 40 | "name": "stdout", 41 | "text": [ 42 | "La variable \"a\" vale 1.\n" 43 | ] 44 | } 45 | ], 46 | "source": [ 47 | "a = 1\n", 48 | "\n", 49 | "if a == 1:\n", 50 | " print('La variable \"a\" vale 1.')\n", 51 | "elif a == 2:\n", 52 | " print('La variable \"a\" no vale 1, sino 2.')\n", 53 | "else:\n", 54 | " print('La variable \"a\" no vale 1 ni 2.')" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "Los comandos que se emplean para comparar son los siguientes:\n", 62 | "\n", 63 | "- **==** y **!=** para comprobar igualdad o desigualdad, respectivamente.\n", 64 | "- **\\>** y **<** para comprobar si un elemento es estrictamente mayor o estrictamente menor que otro, respectivamente.\n", 65 | "- **>=** y **<=** para comprobar si un elemento es mayor o igual, o menor o igual que otro, respectivamente.\n", 66 | "\n", 67 | "En el caso de cumplir la condición, la comprobación devolverá una variable booleana *True* y ejecutará las líneas correspondientes a dicha condición. Si, por el contrario, la condición no se satisface, obtendremos una variable booleana *False* y no se ejecutaran las lineas correspondientes a la condición.\n", 68 | "\n", 69 | "En el caso de que fuera necesario comprobar si se cumplen varias condiciones a la vez se pueden utilizar los operadores booleanos **and** y **or**." 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 2, 75 | "metadata": {}, 76 | "outputs": [ 77 | { 78 | "output_type": "stream", 79 | "name": "stdout", 80 | "text": [ 81 | "Las variables \"a\" y \"b\" valen 2 y 5, respectivamente.\n\nLa variable \"a\" vale 2 o la variable \"b\" vale 5.\n" 82 | ] 83 | } 84 | ], 85 | "source": [ 86 | "a = 2\n", 87 | "b = 5\n", 88 | "\n", 89 | "if a == 2 and b == 5:\n", 90 | " print('Las variables \"a\" y \"b\" valen 2 y 5, respectivamente.\\n')\n", 91 | "else:\n", 92 | " print('La variable \"a\" no vale 2 o la variable \"b\" no vale 5.\\n')\n", 93 | "\n", 94 | "if a == 2 or b == 5:\n", 95 | " print('La variable \"a\" vale 2 o la variable \"b\" vale 5.')\n", 96 | "else:\n", 97 | " print('La variable \"a\" no vale 2 y la variable \"b\" no vale 5.')" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "Aparte de este tipo de comprobaciones, se puede mirar si una lista contiene un elemento empleando el comando **in**." 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 3, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "output_type": "stream", 114 | "name": "stdout", 115 | "text": [ 116 | "El elemento \"b\" está contenido en \"lista\".\n" 117 | ] 118 | } 119 | ], 120 | "source": [ 121 | "lista = ['a', 'b', 'd']\n", 122 | "\n", 123 | "if 'b' in lista:\n", 124 | " print('El elemento \"b\" está contenido en \"lista\".')\n", 125 | "else:\n", 126 | " print('El elemento \"b\" no está contenido en \"lista\".')" 127 | ] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "En el caso de querer negar condiciones, se puede emplear el operador booleano **not**." 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 4, 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "output_type": "stream", 143 | "name": "stdout", 144 | "text": [ 145 | "La variable \"a\" vale 2.\n" 146 | ] 147 | } 148 | ], 149 | "source": [ 150 | "a = 2\n", 151 | "\n", 152 | "if not a == 2:\n", 153 | " print('La variable \"a\" no vale 2.')\n", 154 | "else:\n", 155 | " print('La variable \"a\" vale 2.')" 156 | ] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "Siempre y cuando tenga sentido, estos operadores se pueden emplear con cualquier tipo de variables." 163 | ] 164 | }, 165 | { 166 | "cell_type": "code", 167 | "execution_count": 5, 168 | "metadata": {}, 169 | "outputs": [ 170 | { 171 | "output_type": "stream", 172 | "name": "stdout", 173 | "text": [ 174 | "La variable no contiene un coche.\nLa variable contiene la lista [1, 2, 3]\n" 175 | ] 176 | } 177 | ], 178 | "source": [ 179 | "a = \"casa\"\n", 180 | "b = [1, 2, 3]\n", 181 | "\n", 182 | "if a != 'coche':\n", 183 | " print('La variable no contiene un coche.')\n", 184 | "else:\n", 185 | " print('La variable contiene un coche.')\n", 186 | "\n", 187 | "if b == [1, 2, 3]:\n", 188 | " print('La variable contiene la lista [1, 2, 3]')\n", 189 | "else:\n", 190 | " print('La variable no contiene la lista [1, 2, 3]')" 191 | ] 192 | }, 193 | { 194 | "source": [ 195 | "## Range" 196 | ], 197 | "cell_type": "markdown", 198 | "metadata": {} 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 1, 203 | "metadata": {}, 204 | "outputs": [ 205 | { 206 | "output_type": "stream", 207 | "name": "stdout", 208 | "text": [ 209 | "Help on class range in module builtins:\n\nclass range(object)\n | range(stop) -> range object\n | range(start, stop[, step]) -> range object\n | \n | Return an object that produces a sequence of integers from start (inclusive)\n | to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.\n | start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.\n | These are exactly the valid indices for a list of 4 elements.\n | When step is given, it specifies the increment (or decrement).\n | \n | Methods defined here:\n | \n | __bool__(self, /)\n | self != 0\n | \n | __contains__(self, key, /)\n | Return key in self.\n | \n | __eq__(self, value, /)\n | Return self==value.\n | \n | __ge__(self, value, /)\n | Return self>=value.\n | \n | __getattribute__(self, name, /)\n | Return getattr(self, name).\n | \n | __getitem__(self, key, /)\n | Return self[key].\n | \n | __gt__(self, value, /)\n | Return self>value.\n | \n | __hash__(self, /)\n | Return hash(self).\n | \n | __iter__(self, /)\n | Implement iter(self).\n | \n | __le__(self, value, /)\n | Return self<=value.\n | \n | __len__(self, /)\n | Return len(self).\n | \n | __lt__(self, value, /)\n | Return self integer -- return number of occurrences of value\n | \n | index(...)\n | rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.\n | Raise ValueError if the value is not present.\n | \n | ----------------------------------------------------------------------\n | Data descriptors defined here:\n | \n | start\n | \n | step\n | \n | stop\n\n" 210 | ] 211 | } 212 | ], 213 | "source": [ 214 | "help(range)" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 12, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "output_type": "execute_result", 224 | "data": { 225 | "text/plain": [ 226 | "range(0, 10)" 227 | ] 228 | }, 229 | "metadata": {}, 230 | "execution_count": 12 231 | } 232 | ], 233 | "source": [ 234 | "range(10)" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": 14, 240 | "metadata": {}, 241 | "outputs": [ 242 | { 243 | "output_type": "execute_result", 244 | "data": { 245 | "text/plain": [ 246 | "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" 247 | ] 248 | }, 249 | "metadata": {}, 250 | "execution_count": 14 251 | } 252 | ], 253 | "source": [ 254 | "list(range(10))" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": 16, 260 | "metadata": {}, 261 | "outputs": [ 262 | { 263 | "output_type": "execute_result", 264 | "data": { 265 | "text/plain": [ 266 | "[2, 3, 4, 5, 6, 7, 8, 9]" 267 | ] 268 | }, 269 | "metadata": {}, 270 | "execution_count": 16 271 | } 272 | ], 273 | "source": [ 274 | "list(range(2,10))" 275 | ] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "## Bucles *for* " 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "La sintaxis general de los bucles *for* es la siguiente:" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 19, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "output_type": "stream", 298 | "name": "stdout", 299 | "text": [ 300 | "1\n2\n3\n" 301 | ] 302 | } 303 | ], 304 | "source": [ 305 | "for i in [1,2,3]:\n", 306 | " print(i)" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 6, 312 | "metadata": {}, 313 | "outputs": [ 314 | { 315 | "output_type": "stream", 316 | "name": "stdout", 317 | "text": [ 318 | "0\n1\n2\n" 319 | ] 320 | } 321 | ], 322 | "source": [ 323 | "for i in range(0, 3):\n", 324 | " print(i)" 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "Es importante darse cuenta de que el comando *range(0, 3)* crea una **sucesión de números entre 0 y 2**." 332 | ] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "metadata": {}, 337 | "source": [ 338 | "Los comandos *break* y *continue* pueden resultar muy útiles. El primero termina el bucle en el instante de su ejecución, y el segundo termina la iteración actual del bucle y pasa a la siguiente." 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": 7, 344 | "metadata": {}, 345 | "outputs": [ 346 | { 347 | "output_type": "stream", 348 | "name": "stdout", 349 | "text": [ 350 | "0\n1\n3\n4\n5\n6\n" 351 | ] 352 | } 353 | ], 354 | "source": [ 355 | "for i in range(0, 10):\n", 356 | " if i == 2:\n", 357 | " continue\n", 358 | " if i == 7:\n", 359 | " break\n", 360 | " print(i) " 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "De la misma manera que ocurre con las condiones, las variables que empleamos como contador en los bucles no tienen por qué ser numéricas." 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": 8, 373 | "metadata": {}, 374 | "outputs": [ 375 | { 376 | "output_type": "stream", 377 | "name": "stdout", 378 | "text": [ 379 | "a\nb\nc\nd\ne\nf\ng\n" 380 | ] 381 | } 382 | ], 383 | "source": [ 384 | "a = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n", 385 | "for i in a:\n", 386 | " print(i)" 387 | ] 388 | }, 389 | { 390 | "cell_type": "markdown", 391 | "metadata": {}, 392 | "source": [ 393 | "## Bucles *while* " 394 | ] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "La sintaxis general de los bucles *while* es la siguiente:" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": 9, 406 | "metadata": {}, 407 | "outputs": [ 408 | { 409 | "output_type": "stream", 410 | "name": "stdout", 411 | "text": [ 412 | "1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n" 413 | ] 414 | } 415 | ], 416 | "source": [ 417 | "i = 1\n", 418 | "while i <= 10:\n", 419 | " print(i)\n", 420 | " i += 1" 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "El operador **+=** aumenta el valor de la variable i en el valor que escribamos a su derecha en cada iteración. Por el contrario, el operador **-=** lo disminuye." 428 | ] 429 | }, 430 | { 431 | "cell_type": "code", 432 | "execution_count": 10, 433 | "metadata": {}, 434 | "outputs": [ 435 | { 436 | "output_type": "stream", 437 | "name": "stdout", 438 | "text": [ 439 | "10\n8\n6\n4\n2\n0\n" 440 | ] 441 | } 442 | ], 443 | "source": [ 444 | "i = 10\n", 445 | "while i >= 0:\n", 446 | " print(i)\n", 447 | " i -= 2" 448 | ] 449 | }, 450 | { 451 | "cell_type": "markdown", 452 | "metadata": {}, 453 | "source": [ 454 | "Al igual que con los bucles *for*, los operadores *break* y *continue* son válidos en estos bucles." 455 | ] 456 | }, 457 | { 458 | "cell_type": "code", 459 | "execution_count": 11, 460 | "metadata": {}, 461 | "outputs": [ 462 | { 463 | "output_type": "stream", 464 | "name": "stdout", 465 | "text": [ 466 | "0\n1\n3\n4\n5\n6\n" 467 | ] 468 | } 469 | ], 470 | "source": [ 471 | "i = -1\n", 472 | "while i <= 10:\n", 473 | " i += 1\n", 474 | " if i == 2:\n", 475 | " continue\n", 476 | " if i == 7:\n", 477 | " break\n", 478 | " print(i) " 479 | ] 480 | } 481 | ], 482 | "metadata": { 483 | "kernelspec": { 484 | "display_name": "Python 3", 485 | "language": "python", 486 | "name": "python3" 487 | }, 488 | "language_info": { 489 | "codemirror_mode": { 490 | "name": "ipython", 491 | "version": 3 492 | }, 493 | "file_extension": ".py", 494 | "mimetype": "text/x-python", 495 | "name": "python", 496 | "nbconvert_exporter": "python", 497 | "pygments_lexer": "ipython3", 498 | "version": "3.6.8-final" 499 | } 500 | }, 501 | "nbformat": 4, 502 | "nbformat_minor": 2 503 | } -------------------------------------------------------------------------------- /class-solved/MODULE_1-python_introduction-solved/10.03_Funciones-solved.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 3- Creación de Funciones\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "El objetivo de este documento es mostrar cuál es la sintaxis para la creación de funciones en Python." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "A modo de ejemplo, vamos a crear una función que opere con dos números, de forma que nos devuelva la suma y la resta. La sintaxis es la siguiente:" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "def operar(a, b):\n", 33 | " suma = a+b\n", 34 | " resta = a-b\n", 35 | " return suma, resta" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Es importante que las variables de salida vienen definidas por la sentencia **return**, no se incluyen en la definición de la función. En el caso de que la función que hemos creado no contenga ningún argumento de salida no se emplea el operador **return**.\n", 43 | "\n", 44 | "Para llamar a la función sólo tendríamos que escribir lo siguiente:" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [ 53 | "num_1 = 6\n", 54 | "num_2 = 3.5\n", 55 | "\n", 56 | "s, r = operar(num_1, num_2)\n", 57 | "print(s, r)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": {}, 63 | "source": [ 64 | "## Funciones como objetos" 65 | ] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "Una peculiaridad de Python es que permite operar con funciones como objetos. Por ejemplo, en las líneas de código que siguen guardamos la función **operar** que acabamos de crear en la variable *suma_resta* y la utilizamos desde ahí." 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [ 80 | "suma_resta = operar\n", 81 | "\n", 82 | "s_2, r_2 = suma_resta(num_1, num_2)\n", 83 | "print(s_2, r_2)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "Además, las funciones se puede emplear como variables de entrada de otras funciones." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [ 99 | "def print_operar(func, x, y):\n", 100 | " s_xy, r_xy = func(x, y)\n", 101 | " print(s_xy, r_xy)\n", 102 | "\n", 103 | "print_operar(suma_resta, num_1, num_2)" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "En este concepto de emplear funciones como argumentos de otras funciones se basa el paradigma de Programación Funcional, donde pueden emplearse las funciones Lambda. Por ahora, no vamos a profundizar más en esta temática." 111 | ] 112 | } 113 | ], 114 | "metadata": { 115 | "kernelspec": { 116 | "display_name": "Python 3", 117 | "language": "python", 118 | "name": "python3" 119 | }, 120 | "language_info": { 121 | "codemirror_mode": { 122 | "name": "ipython", 123 | "version": 3 124 | }, 125 | "file_extension": ".py", 126 | "mimetype": "text/x-python", 127 | "name": "python", 128 | "nbconvert_exporter": "python", 129 | "pygments_lexer": "ipython3", 130 | "version": "3.7.3" 131 | } 132 | }, 133 | "nbformat": 4, 134 | "nbformat_minor": 2 135 | } -------------------------------------------------------------------------------- /class-solved/MODULE_1-python_introduction-solved/10.05_comprehension_list_exercises.py: -------------------------------------------------------------------------------- 1 | from /u/cscanlin 2 | 3 | #Find all of the numbers from 1-1000 that are divisible by 7 4 | results = [num for num in range(1000) if num % º 7 == 0] 5 | #print(results) 6 | 7 | #Find all of the numbers from 1-1000 that have a 3 in them 8 | results = [num for num in range(1000) if '3' in list(str(num))] 9 | #print(results) 10 | 11 | #Count the number of spaces in a string 12 | teststring = 'Find all of the words in a string that are less than 4 letters' 13 | #print teststring.count(' ') # normally I'd just do this, but for the practice.... 14 | results = [character for character in teststring if character == ' '] 15 | #print(len(results)) 16 | 17 | #Remove all of the vowels in a string [make a list of the non-vowels] 18 | teststring = 'Find all of the words in a string that are less than 4 letters' 19 | vowels = ['a','e','i','o','u',' '] 20 | results = [letter for letter in teststring if letter.lower() not in vowels] 21 | #print(results) 22 | 23 | #Find all of the words in a string that are less than 4 letters 24 | teststring = 'Find all of the words in a string that are less than 4 letters' 25 | results = [word for word in teststring.split() if len(word) < 4] 26 | #print(results) 27 | 28 | # CHALLENGE! 29 | #Use a dictionary comprehension to count the length of each word in a sentence. 30 | sentence = 'Use a dictionary comprehension to count the length of each word in a sentence' 31 | results = {word:len(word) for word in sentence.split()} 32 | #print(results) 33 | 34 | #Use a nested list comprehension to find all of the numbers from 1-1000 that 35 | #are divisible by any single digit besides 1 (2-9) 36 | # comprehension testing truth for divisibilty: [True for divisor in range(2,10) if number % divisor == 0] 37 | results = [number for number in range(1,1001) if True in [True for divisor in range(2,10) if number % divisor == 0]] 38 | #print(results) 39 | 40 | #For all the numbers 1-1000, use a nested list/dictionary comprehension to 41 | #find the highest single digit any of the numbers is divisible by. 42 | # List comprehension for providing a list of all of the numbers a number is divisible by: divisor_list: 43 | # [divisor for divisor in range(1,1001) if number % divisor == 0] 44 | results = {number:max([divisor for divisor in range(1,10) if number % divisor == 0]) for number in range(1,1001)} 45 | #print(results) -------------------------------------------------------------------------------- /class-solved/MODULE_2-Work_with_data-solved/02.01_Expresiones Regulares en Python-solved.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Uno de los problemas más comunes con que nos solemos encontrar al desarrollar cualquier programa informático, es el de procesamiento de texto. Esta tarea puede resultar bastante trivial para el cerebro humano, ya que nosotros podemos detectar con facilidad que es un número y que una letra, o cuales son palabras que cumplen con un determinado patrón y cuales no; pero estas mismas tareas no son tan fáciles para una computadora. Es por esto, que el procesamiento de texto siempre ha sido uno de los temas más relevantes en las ciencias de la computación. Luego de varias décadas de investigación se logró desarrollar un poderoso y versátil lenguaje que cualquier computadora puede utilizar para reconocer patrones de texto; este lenguale es lo que hoy en día se conoce con el nombre de expresiones regulares; las operaciones de validación, búsqueda, extracción y sustitución de texto ahora son tareas mucho más sencillas para las computadoras gracias a las expresiones regulares." 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## ¿Qué son las Expresiones Regulares?\n", 15 | "\n", 16 | "Las expresiones regulares, a menudo llamada también regex, son unas secuencias de caracteres que forma un patrón de búsqueda, las cuales son formalizadas por medio de una sintaxis específica. Los patrones se interpretan como un conjunto de instrucciones, que luego se ejecutan sobre un texto de entrada para producir un subconjunto o una versión modificada del texto original. Las expresiones regulares pueden incluir patrones de coincidencia literal, de repetición, de composición, de ramificación, y otras sofisticadas reglas de reconocimiento de texto . Las expresiones regulares deberían formar parte del arsenal de cualquier buen programador ya que un gran número de problemas de procesamiento de texto pueden ser fácilmente resueltos con ellas." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import re" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "pat = r\"(Jaime)\"\n", 35 | "m = re.findall(pat, \"Jaime Rodriguez irá con Jaime Perez al cine.\")\n" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Esta es una expresión regular que busca un patrón de correo electrónico:\n", 43 | "\n", 44 | "`/[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,4}/`\n", 45 | "\n", 46 | "Pero, no te preocupes ... no tienes que entenderlo ahora. La buena noticia es que una expresión regular compleja es simplemente la combinación de varias expresiones regulares muy simples. \"¡Divide y vencerás!\"" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "| abc… | Letters |\n", 54 | "|-|-|\n", 55 | "| 123… | Digits |\n", 56 | "| \\d | Any Digit |\n", 57 | "| \\D | Any Non-digit character |\n", 58 | "| . | Any Character |\n", 59 | "| \\. | Period |\n", 60 | "| [abc] | Only a, b, or c |\n", 61 | "| [^abc] | Not a, b, nor c |\n", 62 | "| [a-z] | Characters a to z |\n", 63 | "| [0-9] | Numbers 0 to 9 |\n", 64 | "| \\w | Any Alphanumeric character |\n", 65 | "| \\W | Any Non-alphanumeric character |\n", 66 | "| {m} | m Repetitions |\n", 67 | "| {m,n} | m to n Repetitions |\n", 68 | "| * | Zero or more repetitions |\n", 69 | "| + | One or more repetitions |\n", 70 | "| ? | Optional character |\n", 71 | "| \\s | Any Whitespace |\n", 72 | "| \\S | Any Non-whitespace character |\n", 73 | "| ^…$ | Starts and ends |\n", 74 | "| (…) | Capture Group |\n", 75 | "| (a(bc)) | Capture Sub-group |\n", 76 | "| (.*) | Capture all |\n", 77 | "| (abc\\|def) | Matches abc or def |" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "## Raw strings\n", 85 | "\n", 86 | "Los *raw strings* de Python son strings usuales a los que les antecede una r. Por ejemplo ``r\"SciData\"`` es un raw string. Su caraterística principal es que no consideran el símbolo `\\` como un escape." 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 4, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "name": "stdout", 96 | "output_type": "stream", 97 | "text": [ 98 | "Hola\n", 99 | "Mundo.\tYa casi terminamos\n" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "saludo = \"Hola\\nMundo.\\tYa casi terminamos\"\n", 105 | "print(saludo)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 5, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "name": "stdout", 115 | "output_type": "stream", 116 | "text": [ 117 | "Hola\\nMundo.\\tYa casi terminamos\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "r_saludo = r\"Hola\\nMundo.\\tYa casi terminamos\"\n", 123 | "print(r_saludo)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "## Findall: Encontrar todos los patrones en un string y que devuelva todas las coincidencias." 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 6, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "pat = r\"Python\"\n", 140 | "txt = \"Programamos en Python con los módulos pytorch y numpy.\"" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 7, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "name": "stdout", 150 | "output_type": "stream", 151 | "text": [ 152 | "['Python']\n" 153 | ] 154 | } 155 | ], 156 | "source": [ 157 | "matchs = re.findall(pat, txt)# r is for raw strings\n", 158 | "print(matchs)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 8, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "data": { 168 | "text/plain": [ 169 | "['py', 'py']" 170 | ] 171 | }, 172 | "execution_count": 8, 173 | "metadata": {}, 174 | "output_type": "execute_result" 175 | } 176 | ], 177 | "source": [ 178 | "pat2 = r\"py\"\n", 179 | "re.findall(pat2, txt)\n" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": 9, 185 | "metadata": {}, 186 | "outputs": [ 187 | { 188 | "data": { 189 | "text/plain": [ 190 | "['Py', 'py', 'py']" 191 | ] 192 | }, 193 | "execution_count": 9, 194 | "metadata": {}, 195 | "output_type": "execute_result" 196 | } 197 | ], 198 | "source": [ 199 | "pat3 = r\"[Pp]y\"\n", 200 | "re.findall(pat3, txt)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 47, 206 | "metadata": {}, 207 | "outputs": [ 208 | { 209 | "data": { 210 | "text/plain": [ 211 | "['6', '1', '0', '7', '4', '2', '8', '6', '4', '5']" 212 | ] 213 | }, 214 | "execution_count": 47, 215 | "metadata": {}, 216 | "output_type": "execute_result" 217 | } 218 | ], 219 | "source": [ 220 | "mensaje = \"Mi número es 610-742-8645\"\n", 221 | "pat4 = \"[0-9]\"\n", 222 | "re.findall(pat4, mensaje)\n" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": 10, 228 | "metadata": {}, 229 | "outputs": [ 230 | { 231 | "data": { 232 | "text/plain": [ 233 | "['6', '1', '0', '7', '4', '2', '8', '6', '4', '5']" 234 | ] 235 | }, 236 | "execution_count": 10, 237 | "metadata": {}, 238 | "output_type": "execute_result" 239 | } 240 | ], 241 | "source": [ 242 | "mensaje = \"Mi número es 610-742-8645\"\n", 243 | "pat4 = \"\\d\"\n", 244 | "re.findall(pat4, mensaje)\n" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 11, 250 | "metadata": {}, 251 | "outputs": [ 252 | { 253 | "data": { 254 | "text/plain": [ 255 | "['610-742-8645']" 256 | ] 257 | }, 258 | "execution_count": 11, 259 | "metadata": {}, 260 | "output_type": "execute_result" 261 | } 262 | ], 263 | "source": [ 264 | "mensaje = \"Mi número es 610-742-8645\"\n", 265 | "pat4 = r\"\\d\\d\\d-\\d\\d\\d-\\d\\d\\d\\d\"\n", 266 | "re.findall(pat4, mensaje)" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 12, 272 | "metadata": {}, 273 | "outputs": [ 274 | { 275 | "data": { 276 | "text/plain": [ 277 | "['610-742-865']" 278 | ] 279 | }, 280 | "execution_count": 12, 281 | "metadata": {}, 282 | "output_type": "execute_result" 283 | } 284 | ], 285 | "source": [ 286 | "mensaje = \"Mi número es 610-742-865\"\n", 287 | "pat4 = r\"\\d{3}-\\d{3}-\\d{3}\"\n", 288 | "re.findall(pat4, mensaje)" 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": 13, 294 | "metadata": {}, 295 | "outputs": [ 296 | { 297 | "data": { 298 | "text/plain": [ 299 | "['610-742-845', '663852642']" 300 | ] 301 | }, 302 | "execution_count": 13, 303 | "metadata": {}, 304 | "output_type": "execute_result" 305 | } 306 | ], 307 | "source": [ 308 | "txt2 = \"Mis números son 610-742-845 y 663852642\"\n", 309 | "pat4 = r\"\\d{3}-?\\d{3}-?\\d{3}\"\n", 310 | "re.findall(pat4, txt2)\n" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": {}, 316 | "source": [ 317 | "## Group: to get the matched string" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 44, 323 | "metadata": {}, 324 | "outputs": [ 325 | { 326 | "data": { 327 | "text/plain": [ 328 | "'610'" 329 | ] 330 | }, 331 | "execution_count": 44, 332 | "metadata": {}, 333 | "output_type": "execute_result" 334 | } 335 | ], 336 | "source": [ 337 | "txt2 = \"Mis números son 610-742-845 y 663852642\"\n", 338 | "pat4 = r\"(\\d{3})-?(\\d{3})-?(\\d{3})\"\n", 339 | "m = re.findall(pat4, txt2)\n", 340 | "m[0]\n", 341 | "m[0][0]" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 14, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "name": "stdout", 351 | "output_type": "stream", 352 | "text": [ 353 | "['casa', 'caja', 'cama']\n" 354 | ] 355 | } 356 | ], 357 | "source": [ 358 | "txt = \"casa, caja, cama\"\n", 359 | "result3 = re.findall(\"ca[sjm]a\", txt)\n", 360 | "print(result3)" 361 | ] 362 | }, 363 | { 364 | "cell_type": "markdown", 365 | "metadata": {}, 366 | "source": [ 367 | "## ? Character: a lo más una coincidencia" 368 | ] 369 | }, 370 | { 371 | "cell_type": "code", 372 | "execution_count": 26, 373 | "metadata": {}, 374 | "outputs": [], 375 | "source": [ 376 | "expr = re.compile(r'Pyt(ho)?n')" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 27, 382 | "metadata": {}, 383 | "outputs": [ 384 | { 385 | "data": { 386 | "text/plain": [ 387 | "'Python'" 388 | ] 389 | }, 390 | "execution_count": 27, 391 | "metadata": {}, 392 | "output_type": "execute_result" 393 | } 394 | ], 395 | "source": [ 396 | "match = expr.search(\"Python! a great language.\")\n", 397 | "match.group()" 398 | ] 399 | }, 400 | { 401 | "cell_type": "code", 402 | "execution_count": 28, 403 | "metadata": {}, 404 | "outputs": [ 405 | { 406 | "data": { 407 | "text/plain": [ 408 | "'Pytn'" 409 | ] 410 | }, 411 | "execution_count": 28, 412 | "metadata": {}, 413 | "output_type": "execute_result" 414 | } 415 | ], 416 | "source": [ 417 | "match = expr.search(\"Pytn! a great language.\")\n", 418 | "match.group()" 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": 29, 424 | "metadata": {}, 425 | "outputs": [ 426 | { 427 | "name": "stdout", 428 | "output_type": "stream", 429 | "text": [ 430 | "None\n" 431 | ] 432 | } 433 | ], 434 | "source": [ 435 | "match = expr.search(\"Pythohon a great language\")\n", 436 | "print(match)" 437 | ] 438 | }, 439 | { 440 | "cell_type": "markdown", 441 | "metadata": {}, 442 | "source": [ 443 | "## * Character: cero o más coincidencias" 444 | ] 445 | }, 446 | { 447 | "cell_type": "markdown", 448 | "metadata": {}, 449 | "source": [ 450 | "## + Character: al menos una coincidencia" 451 | ] 452 | }, 453 | { 454 | "cell_type": "markdown", 455 | "metadata": {}, 456 | "source": [ 457 | "## {} : n coincidencias" 458 | ] 459 | }, 460 | { 461 | "cell_type": "markdown", 462 | "metadata": {}, 463 | "source": [ 464 | "## {m,n} entre m y n coincidencias (máximo de coincidencias)" 465 | ] 466 | }, 467 | { 468 | "cell_type": "markdown", 469 | "metadata": {}, 470 | "source": [ 471 | "## Match the exact number of characters" 472 | ] 473 | }, 474 | { 475 | "cell_type": "code", 476 | "execution_count": 35, 477 | "metadata": {}, 478 | "outputs": [ 479 | { 480 | "name": "stdout", 481 | "output_type": "stream", 482 | "text": [ 483 | "['22/10/2019']\n" 484 | ] 485 | } 486 | ], 487 | "source": [ 488 | "string = 'The date is 22/10/2019'\n", 489 | "lst = re.findall('[0-9]{1,2}\\/[0-9]{1,2}\\/[0-9]{4}', string)\n", 490 | "print(lst)" 491 | ] 492 | }, 493 | { 494 | "cell_type": "markdown", 495 | "metadata": {}, 496 | "source": [ 497 | "## ^ start and end $" 498 | ] 499 | }, 500 | { 501 | "cell_type": "code", 502 | "execution_count": 37, 503 | "metadata": {}, 504 | "outputs": [ 505 | { 506 | "data": { 507 | "text/plain": [ 508 | "['T', 'h', ' ', 'l', 'n', 'g', 'g', ' ', 's', ' ', 'P', 'y', 't', 'h', 'n']" 509 | ] 510 | }, 511 | "execution_count": 37, 512 | "metadata": {}, 513 | "output_type": "execute_result" 514 | } 515 | ], 516 | "source": [ 517 | "regex = re.compile(r'[^aeiouAEIOU]')\n", 518 | "string = \"The language is PythOn\"\n", 519 | "regex.findall(string)" 520 | ] 521 | }, 522 | { 523 | "cell_type": "markdown", 524 | "metadata": {}, 525 | "source": [ 526 | "## Escaping Special Characters" 527 | ] 528 | }, 529 | { 530 | "cell_type": "code", 531 | "execution_count": 20, 532 | "metadata": {}, 533 | "outputs": [ 534 | { 535 | "name": "stdout", 536 | "output_type": "stream", 537 | "text": [ 538 | "['S', 'e', 'n', 't', 'e', 'n', 'c', 'e', 's', ' ', 'h', 'a', 'v', 'e', ' ', 'd', 'o', 't', 's', '.', 'H', 'o', 'w', ' ', 'd', 'o', ' ', 'w', 'e', ' ', 'e', 's', 'c', 'a', 'p', 'e', ' ', 't', 'h', 'e', 'm', '?']\n" 539 | ] 540 | } 541 | ], 542 | "source": [ 543 | "str = 'Sentences have dots.How do we escape them?\\n'\n", 544 | "lst = re.findall('.', str)\n", 545 | "print(lst)" 546 | ] 547 | }, 548 | { 549 | "cell_type": "code", 550 | "execution_count": 21, 551 | "metadata": {}, 552 | "outputs": [ 553 | { 554 | "name": "stdout", 555 | "output_type": "stream", 556 | "text": [ 557 | "['\\n', '\\n']\n" 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "lst1 = re.findall('\\n', str)\n", 563 | "print(lst1)" 564 | ] 565 | }, 566 | { 567 | "cell_type": "markdown", 568 | "metadata": {}, 569 | "source": [ 570 | "[Tutorial](https://regexone.com/lesson/introduction_abcs)\n", 571 | "\n", 572 | "[Problems](https://regexone.com/problem/matching_decimal_numbers)" 573 | ] 574 | }, 575 | { 576 | "cell_type": "markdown", 577 | "metadata": {}, 578 | "source": [ 579 | "## Reference:\n", 580 | "\n", 581 | "https://docs.python.org/3/library/re.html" 582 | ] 583 | }, 584 | { 585 | "cell_type": "code", 586 | "execution_count": null, 587 | "metadata": {}, 588 | "outputs": [], 589 | "source": [] 590 | }, 591 | { 592 | "cell_type": "code", 593 | "execution_count": null, 594 | "metadata": {}, 595 | "outputs": [], 596 | "source": [] 597 | }, 598 | { 599 | "cell_type": "code", 600 | "execution_count": null, 601 | "metadata": {}, 602 | "outputs": [], 603 | "source": [] 604 | }, 605 | { 606 | "cell_type": "code", 607 | "execution_count": null, 608 | "metadata": {}, 609 | "outputs": [], 610 | "source": [] 611 | } 612 | ], 613 | "metadata": { 614 | "kernelspec": { 615 | "display_name": "Python 3", 616 | "language": "python", 617 | "name": "python3" 618 | }, 619 | "language_info": { 620 | "codemirror_mode": { 621 | "name": "ipython", 622 | "version": 3 623 | }, 624 | "file_extension": ".py", 625 | "mimetype": "text/x-python", 626 | "name": "python", 627 | "nbconvert_exporter": "python", 628 | "pygments_lexer": "ipython3", 629 | "version": "3.7.3" 630 | }, 631 | "toc": { 632 | "base_numbering": 1, 633 | "nav_menu": {}, 634 | "number_sections": true, 635 | "sideBar": true, 636 | "skip_h1_title": false, 637 | "title_cell": "Table of Contents", 638 | "title_sidebar": "Contents", 639 | "toc_cell": false, 640 | "toc_position": {}, 641 | "toc_section_display": true, 642 | "toc_window_display": false 643 | }, 644 | "varInspector": { 645 | "cols": { 646 | "lenName": 16, 647 | "lenType": 16, 648 | "lenVar": 40 649 | }, 650 | "kernels_config": { 651 | "python": { 652 | "delete_cmd_postfix": "", 653 | "delete_cmd_prefix": "del ", 654 | "library": "var_list.py", 655 | "varRefreshCmd": "print(var_dic_list())" 656 | }, 657 | "r": { 658 | "delete_cmd_postfix": ") ", 659 | "delete_cmd_prefix": "rm(", 660 | "library": "var_list.r", 661 | "varRefreshCmd": "cat(var_dic_list()) " 662 | } 663 | }, 664 | "types_to_exclude": [ 665 | "module", 666 | "function", 667 | "builtin_function_or_method", 668 | "instance", 669 | "_Feature" 670 | ], 671 | "window_display": false 672 | } 673 | }, 674 | "nbformat": 4, 675 | "nbformat_minor": 2 676 | } 677 | -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.01_VariablesOperadores.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 1- Variables y Operadores\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "El objetivo de este documento es conocer algunos tipos de variables y operadores empleados en Python." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## Hello, world!" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "Pero, antes de entrar en materia, vamos a iniciarnos con la línea de código con la que empieza todo el mundo.\n", 31 | "\n", 32 | "El comando *print()* nos muestra por pantalla lo que le pasemos como argumento. En este caso, queremos ver por pantalla el texto \"Hello, world!\"." 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": null, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "Obsérvese que podemos emplear tanto comillas simples como dobles para trabajar con cadenas de caracteres." 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Variables numéricas y operadores" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "Vamos a empezar por las variables numéricas. Las más empleadas son las variables enteras (**int**) y flotantes (**float**). Con las primeras podremos representar los números enteros, y, con las segundas, cualquier número con decimales." 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "Podemos operar con los dos tipos de variables de la misma manera utilizando los operadores suma (**\\+**), resta (**\\-**), multiplicación (**\\***) y división (**\\/**). Debemos tener en cuenta que el resultado de cualquier operación realizada con variables flotantes será otra variable flotante. El resultado de cualquier operación realizada con variables enteras, por el contrario, será otra variable entera, a excepción de la división, que será flotante." 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "Python también permite mezclar variables enteras y flotantes en la misma operación. En este caso, el resultado siempre será flotante." 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "Existen otros tres operadores que nos pueden resultar de utilidad: la potencia (**\\*\\***), la división entera (**//**) y el residuo de la división(**%**). El resultado de estas operaciones mantiene la naturaleza de las variables con las que estamos operando." 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": null, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "Para terminar con las variables numéricas, introduciremos la función **type()**. Esta función nos mostrará el tipo de variable que estamos utilizando y se puede emplear para cualquier tipo de variable." 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": null, 122 | "metadata": {}, 123 | "outputs": [], 124 | "source": [] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "## Cadenas de caracteres y operadores" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "Como hemos comentado más arriba, las cadenas de caracteres (string) puede escribirse con comillas simples o dobles." 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "De la misma forma que hemos hecho con las variables numéricas, podemos emplear los operadores suma (**\\+**) y multiplicación (**\\***) para operar con las cadenas de caracteres. Con el primer operador concatenaremos las cadenas que estamos \"sumando\", mientras que con el segundo repetiremos la cadena tantas veces como el número que la multiplica." 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "Hay que tener mucho cuidado con los tipos de variable con los que estamos trabajando al hacer este tipo de operaciones. Véase un ejemplo:" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": {}, 172 | "outputs": [], 173 | "source": [] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "El poder emplear las comillas simples o dobles para crear las cadenas de caracteres facilita la inclusión de estos símbolos en el texto." 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "Al igual que otros lenguajes de programación, Python permite acceder a los elementos de las cadenas de caracteres. Para ello, hay que tener en cuenta que el primer elemento de la cadena está ubicado en la posición 0." 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "metadata": {}, 206 | "source": [ 207 | "## Conversión de tipos de variables" 208 | ] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "Utilizando las funciones **int()**, **float()** y **str()**, se pueden convertir las variables de un tipo a otro. De todas formas, hay que tener cuidado al convertir flotantes a enteros, o cadenas de caracteres a enteros o flotantes." 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "## Listas " 229 | ] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "Las listas son un tipo de variable que contienen distintas variables de cualquier tipo en su interior." 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "Las listas pueden contener elementos de distinta naturaleza." 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "De la misma manera que con los elementos de las cadenas de caracteres, se puede acceder a los elementos de las listas de la siguiente manera:" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": {}, 276 | "source": [ 277 | "## Otras variables " 278 | ] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "Aunque no entraremos en detalle, vamos a introducir tres tipos de variables más: los diccionarios, las tuplas y los conjuntos." 285 | ] 286 | }, 287 | { 288 | "cell_type": "code", 289 | "execution_count": null, 290 | "metadata": {}, 291 | "outputs": [], 292 | "source": [] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "## Cortes de cadenas/listas " 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "metadata": {}, 304 | "source": [ 305 | "Como hemos comentado antes, las posiciones en las cadenas de caracteres y listas empiezan a contar desde 0.\n", 306 | "\n", 307 | "El operador **:** se emplea para obtener los valores guardado en más de una posición del vector (corte del vector)." 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [] 316 | }, 317 | { 318 | "cell_type": "markdown", 319 | "metadata": {}, 320 | "source": [ 321 | "En este caso, a pesar de poner **[0:4]** estamos extrayendo los elementos guardados en las posiciones 0, 1, 2 y 3. **Es muy importante tener en cuenta que el primer valor (0) sí que se extraerá, pero no así el último**.\n", 322 | "\n", 323 | "Aparte de acceder a los vectores por el primer elemento, también podemos acceder a ellos desde el último empleando el operador **-**." 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": null, 329 | "metadata": {}, 330 | "outputs": [], 331 | "source": [] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": {}, 336 | "source": [ 337 | "También podemos extraer elementos a saltos, por ejemplo, aquellos elementos que están en posiciones pares. Para ello, volvemos a emplear el operador **:** junto con un tercer número que indica el paso." 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": {}, 344 | "outputs": [], 345 | "source": [] 346 | }, 347 | { 348 | "cell_type": "markdown", 349 | "metadata": {}, 350 | "source": [ 351 | "Para terminar, también con el operador **-** podemos darle la vuelta al vector." 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [] 360 | } 361 | ], 362 | "metadata": { 363 | "kernelspec": { 364 | "display_name": "Python 3", 365 | "language": "python", 366 | "name": "python3" 367 | }, 368 | "language_info": { 369 | "codemirror_mode": { 370 | "name": "ipython", 371 | "version": 3 372 | }, 373 | "file_extension": ".py", 374 | "mimetype": "text/x-python", 375 | "name": "python", 376 | "nbconvert_exporter": "python", 377 | "pygments_lexer": "ipython3", 378 | "version": "3.7.3" 379 | } 380 | }, 381 | "nbformat": 4, 382 | "nbformat_minor": 2 383 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.02_CondicionesBucles.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 2- Condiciones y Bucles\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "En este documento nos centraremos en la creación de condiciones y bucles. A diferencia de otros lenguajes de programación no se utilizan llaves o sentencias *end* para determinar lo que está incluido dentro de la condición o el bucle. En Python, todo esto se hace mediante indentación. A continuación veremos unos ejemplos." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "## Condiciones" 24 | ] 25 | }, 26 | { 27 | "cell_type": "markdown", 28 | "metadata": {}, 29 | "source": [ 30 | "La sintaxis general de las condiciones es la siguiente:" 31 | ] 32 | }, 33 | { 34 | "cell_type": "code", 35 | "execution_count": null, 36 | "metadata": {}, 37 | "outputs": [], 38 | "source": [] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "Los comandos que se emplean para comparar son los siguientes:\n", 45 | "\n", 46 | "- **==** y **!=** para comprobar igualdad o desigualdad, respectivamente.\n", 47 | "- **\\>** y **\\<** para comprobar si un elemento es estrictamente mayor o estrictamente menor que otro, respectivamente.\n", 48 | "- **>=** y **<=** para comprobar si un elemento es mayor o igual, o menor o igual que otro, respectivamente.\n", 49 | "\n", 50 | "En el caso de cumplir la condición, la comprobación devolverá una variable booleana *True* y ejecutará las líneas correspondientes a dicha condición. Si, por el contrario, la condición no se satisface, obtendremos una variable booleana *False* y no se ejecutaran las lineas correspondientes a la condición.\n", 51 | "\n", 52 | "En el caso de que fuera necesario comprobar si se cumplen varias condiciones a la vez se pueden utilizar los operadores booleanos **and** y **or**." 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "Aparte de este tipo de comprobaciones, se puede mirar si una lista contiene un elemento empleando el comando **in**." 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "En el caso de querer negar condiciones, se puede emplear el operador booleano **not**." 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "Siempre y cuando tenga sentido, estos operadores se pueden emplear con cualquier tipo de variables." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "## Bucles *for* " 109 | ] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "La sintaxis general de los bucles *for* es la siguiente:" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": null, 121 | "metadata": {}, 122 | "outputs": [], 123 | "source": [] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "Es importante darse cuenta de que el comando *range(0, 3)* crea una **sucesión de números entre 0 y 2**." 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "Los comandos *break* y *continue* pueden resultar muy útiles. El primero termina el bucle en el instante de su ejecución, y el segundo termina la iteración actual del bucle y pasa a la siguiente." 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "De la misma manera que ocurre con las condiones, las variables que empleamos como contador en los bucles no tienen por qué ser numéricas." 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": {}, 163 | "source": [ 164 | "## Bucles *while* " 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "La sintaxis general de los bucles *while* es la siguiente:" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "El operador **+=** aumenta el valor de la variable i en el valor que escribamos a su derecha en cada iteración. Por el contrario, el operador **-=** lo disminuye." 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "Al igual que con los bucles *for*, los operadores *break* y *continue* son válidos en estos bucles." 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": {}, 206 | "outputs": [], 207 | "source": [ 208 | " " 209 | ] 210 | } 211 | ], 212 | "metadata": { 213 | "kernelspec": { 214 | "display_name": "Python 3", 215 | "language": "python", 216 | "name": "python3" 217 | }, 218 | "language_info": { 219 | "codemirror_mode": { 220 | "name": "ipython", 221 | "version": 3 222 | }, 223 | "file_extension": ".py", 224 | "mimetype": "text/x-python", 225 | "name": "python", 226 | "nbconvert_exporter": "python", 227 | "pygments_lexer": "ipython3", 228 | "version": "3.7.3" 229 | } 230 | }, 231 | "nbformat": 4, 232 | "nbformat_minor": 2 233 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.03_Funciones.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 3- Creación de Funciones\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "El objetivo de este documento es mostrar cuál es la sintaxis para la creación de funciones en Python." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "A modo de ejemplo, vamos a crear una función que opere con dos números, de forma que nos devuelva la suma y la resta. La sintaxis es la siguiente:" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "Es importante que las variables de salida vienen definidas por la sentencia **return**, no se incluyen en la definición de la función. En el caso de que la función que hemos creado no contenga ningún argumento de salida no se emplea el operador **return**.\n", 38 | "\n", 39 | "Para llamar a la función sólo tendríamos que escribir lo siguiente:" 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "## Funciones como objetos" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "Una peculiaridad de Python es que permite operar con funciones como objetos. Por ejemplo, en las líneas de código que siguen guardamos la función **operar** que acabamos de crear en la variable *suma_resta* y la utilizamos desde ahí." 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "Además, las funciones se puede emplear como variables de entrada de otras funciones." 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "En este concepto de emplear funciones como argumentos de otras funciones se basa el paradigma de Programación Funcional, donde pueden emplearse las funciones Lambda. Por ahora, no vamos a profundizar más en esta temática." 89 | ] 90 | } 91 | ], 92 | "metadata": { 93 | "kernelspec": { 94 | "display_name": "Python 3", 95 | "language": "python", 96 | "name": "python3" 97 | }, 98 | "language_info": { 99 | "codemirror_mode": { 100 | "name": "ipython", 101 | "version": 3 102 | }, 103 | "file_extension": ".py", 104 | "mimetype": "text/x-python", 105 | "name": "python", 106 | "nbconvert_exporter": "python", 107 | "pygments_lexer": "ipython3", 108 | "version": "3.7.3" 109 | } 110 | }, 111 | "nbformat": 4, 112 | "nbformat_minor": 2 113 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.04_ProgramacionPython.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# 4- Programación en Python\n", 8 | "\n", 9 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 10 | ] 11 | }, 12 | { 13 | "cell_type": "markdown", 14 | "metadata": {}, 15 | "source": [ 16 | "## Funciones y Métodos" 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "Python contiene varias funciones que nos permiten operar con distintas variables. Por ejemplo, podemos calcular el número de elementos que contiene una lista, el máximo, etc." 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": {}, 36 | "source": [ 37 | "Aparte de esto, las variables en Python tienen, por defecto, asignadas unas funciones que varían según el tipo de variable que estemos empleando. A estas funciones se les llama métodos, siguiendo el paradigma de la Programación Orientada a Objetos. Vamos a ver unos pocos ejemplos:" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": null, 43 | "metadata": {}, 44 | "outputs": [], 45 | "source": [] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": null, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "Para cualquier cuestión referente al empleo de métodos la función *help()* aclara muchas dudas. Se emplea de la siguiente manera." 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": null, 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "## Módulos y Funciones propias" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "Existen módulos que han sido creados para distintos usos. Más adelante nos tocará utilizarlos. Pero para ello, primero hay que cargarlos en nuestro entorno de trabajo. Para ello existen distintas opciones:" 115 | ] 116 | }, 117 | { 118 | "cell_type": "code", 119 | "execution_count": null, 120 | "metadata": {}, 121 | "outputs": [], 122 | "source": [] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "De esta manera, estamos cargando el módulo *numpy* que se emplea para trabajar con vectores, matrices, etc." 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": null, 134 | "metadata": {}, 135 | "outputs": [], 136 | "source": [] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "En este caso, estamos cargando el módulo *pandas* y lo etiquetamos como *pd* de forma que, cuando tengamos que usar funciones de dicho módulo, podamos acceder a ella escribiendo *pd* en lugar de *pandas*." 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": null, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "Con la sentencia de arriba, estamos cargando únicamente la función *pyplot* del módulo *matplotlib*." 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "Si queremos acceder a funciones que tenemos en ficheros .py aparte emplearemos la misma sintaxis. Por ejemplo:" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "Otra forma de utilizar funciones es definiéndolas al comienzo del archivo .py que vamos a ejecutar." 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "## Listas por comprensión, *all()* y *any()*" 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "Las listas por comprensión se emplean para, por ejemplo, aplicar la misma función a todos los elementos de una lista. La sintaxis es la siguiente:\n", 199 | "\n", 200 | " [ for in ]\n", 201 | "\n", 202 | "A continuación convertiremos los elementos de la lista de cadenas de caracteres a números:" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "También se pueden tener en cuenta condiciones al trabajar con listas por comprension. Se hace siguiendo la siguiente expresión:\n", 217 | "\n", 218 | " [ for in if ]" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [] 227 | }, 228 | { 229 | "cell_type": "markdown", 230 | "metadata": {}, 231 | "source": [ 232 | "Las funciones *all()* y *any()* toman listas como argumento y comprueban si la condición que queremos comprobar se cumple en todos o en alguno de los elementos, respectivamente. " 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": {}, 245 | "source": [ 246 | "## Manejo de excepciones " 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "Los comandos *try* y *except* nos permiten manejar las excepciones (errores) que podemos encontrarnos en el código. De esta manera, se consigue que, en el caso de encontrar un error en el código de la sentencia *try*, éste siga ejecutándose en la sentencia *except*. En el caso de no haber empleado la sentencia *except*, el código seguirá ejecutándose fuera de la sentencia *try*." 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "Además, se puede jugar con los tipos de errores que esperamos para manejar las excepciones de una forma más precisa" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [] 276 | }, 277 | { 278 | "cell_type": "markdown", 279 | "metadata": {}, 280 | "source": [ 281 | "## Función *print()* y formateo de cadenas de caracteres" 282 | ] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "Antes hemos visto cómo se utiliza la función *print()* para mostrar por pantalla la frase \"Hello, world!\". A continuación veremos cómo se puede emplear para mostrar por pantalla texto y variables que hayamos calculado." 289 | ] 290 | }, 291 | { 292 | "cell_type": "code", 293 | "execution_count": null, 294 | "metadata": {}, 295 | "outputs": [], 296 | "source": [] 297 | }, 298 | { 299 | "cell_type": "markdown", 300 | "metadata": {}, 301 | "source": [ 302 | "En definitiva:\n", 303 | "\n", 304 | "- %d es la representación en cadena de caracteres de una variable entera.\n", 305 | "- %f es la representación en cadena de caracteres de una variable flotante.\n", 306 | "- %.'x'f es la representación en cadena de caracteres de una variable flotante donde 'x' es el número de decimales a mostrar.\n", 307 | "- %s es la representación en cadena de caracteres de cualquier variable." 308 | ] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "metadata": {}, 313 | "source": [ 314 | "Podemos obtener el mismo resultado mediante la función *format()*." 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": null, 320 | "metadata": {}, 321 | "outputs": [], 322 | "source": [] 323 | }, 324 | { 325 | "cell_type": "markdown", 326 | "metadata": {}, 327 | "source": [ 328 | "## Archivos de texto " 329 | ] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": {}, 334 | "source": [ 335 | "En este apartado vamos a introducir brevemente una forma de realizar la lectura y escritura de archivos de texto.\n", 336 | "\n", 337 | "Primero, tenemos que abrir el archivo de texto mediante la función *open()*. Utilizaremos la entrada **\"r\"** (read) si queremos leer el archivo y la entrada **\"w\"** (write) si queremos escribir sobre él." 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": {}, 344 | "outputs": [], 345 | "source": [] 346 | }, 347 | { 348 | "cell_type": "markdown", 349 | "metadata": {}, 350 | "source": [ 351 | "Para leer el archivo emplearemos el método read()." 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": null, 357 | "metadata": {}, 358 | "outputs": [], 359 | "source": [] 360 | }, 361 | { 362 | "cell_type": "markdown", 363 | "metadata": {}, 364 | "source": [ 365 | "Como lo único que queríamos hacer era leer el archivo de texto, vamos a proceder a cerrarlo." 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": null, 371 | "metadata": {}, 372 | "outputs": [], 373 | "source": [] 374 | }, 375 | { 376 | "cell_type": "markdown", 377 | "metadata": {}, 378 | "source": [ 379 | "A continuación crearemos un archivo de texto nuevo que llamaremos *\"hwx3.txt\"* donde guardaremos el texto que hemos leído repetido en 3 líneas diferentes." 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": null, 385 | "metadata": {}, 386 | "outputs": [], 387 | "source": [] 388 | }, 389 | { 390 | "cell_type": "markdown", 391 | "metadata": {}, 392 | "source": [ 393 | "## Expresiones regulares " 394 | ] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "Las expresiones regulares se emplean para la manipulación de cadenas. En python, se acceden mediante el módulo *re*. Lo cargaremos a continuación." 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": null, 406 | "metadata": {}, 407 | "outputs": [], 408 | "source": [] 409 | }, 410 | { 411 | "cell_type": "markdown", 412 | "metadata": {}, 413 | "source": [ 414 | "Vamos a presentar 4 funciones para trabajar con expresiones regulares.\n", 415 | "- *re.match()*: Comprueba si el comienzo de la cadena sigue un patrón determinado.\n", 416 | "- *re.search()*: Comprueba si un patrón determinado está contenido en la cadena.\n", 417 | "- *re.findall()*: Devuelve todas las veces en las que un patrón determinado está contenido en la cadena.\n", 418 | "- *re.sub()*: Sustituye una parte de una cadena por otra." 419 | ] 420 | }, 421 | { 422 | "cell_type": "code", 423 | "execution_count": null, 424 | "metadata": {}, 425 | "outputs": [], 426 | "source": [] 427 | }, 428 | { 429 | "cell_type": "markdown", 430 | "metadata": {}, 431 | "source": [ 432 | "Es importante mencionar que, para evitar problemas, es mejor trabajar las expresiones regulares con cadenas puras (**r\"\"**)." 433 | ] 434 | }, 435 | { 436 | "cell_type": "markdown", 437 | "metadata": {}, 438 | "source": [ 439 | "Los metacaracteres juegan un papel muy importante a la hora de trabajar con expresiones regulares, ya que permiten representar conceptos. A continuación presentamos varios de ellos:\n", 440 | "- **.**: Cualquier carácter.\n", 441 | "- **^**: Comienzo.\n", 442 | "- **$**: Final.\n", 443 | "- **\\***: Cero o más repeticiones.\n", 444 | "- **+**: Una o más repeticiones.\n", 445 | "- **?**: Cero o una repetición.\n", 446 | "- **{x, y}**: Entre x e y repeticiones." 447 | ] 448 | }, 449 | { 450 | "cell_type": "code", 451 | "execution_count": null, 452 | "metadata": {}, 453 | "outputs": [], 454 | "source": [] 455 | }, 456 | { 457 | "cell_type": "markdown", 458 | "metadata": {}, 459 | "source": [ 460 | "Para terminar con las expresiones regulares, vamos a introducir el concepto de clases de caracteres. De esta manera, podemos comprobar si existe coincidencia entre la cadena y sólo 1 de los elementos de la clase de caracteres. En este caso, el operador **^** se emplea para negar la clase." 461 | ] 462 | }, 463 | { 464 | "cell_type": "code", 465 | "execution_count": null, 466 | "metadata": {}, 467 | "outputs": [], 468 | "source": [] 469 | }, 470 | { 471 | "cell_type": "markdown", 472 | "metadata": {}, 473 | "source": [ 474 | "## Función *input()* " 475 | ] 476 | }, 477 | { 478 | "cell_type": "markdown", 479 | "metadata": {}, 480 | "source": [ 481 | "Esta función nos permitirá solicitar información al usuario, información que la función nos devolverá como una cadena de caracteres." 482 | ] 483 | }, 484 | { 485 | "cell_type": "code", 486 | "execution_count": null, 487 | "metadata": {}, 488 | "outputs": [], 489 | "source": [] 490 | } 491 | ], 492 | "metadata": { 493 | "kernelspec": { 494 | "display_name": "Python 3", 495 | "language": "python", 496 | "name": "python3" 497 | }, 498 | "language_info": { 499 | "codemirror_mode": { 500 | "name": "ipython", 501 | "version": 3 502 | }, 503 | "file_extension": ".py", 504 | "mimetype": "text/x-python", 505 | "name": "python", 506 | "nbconvert_exporter": "python", 507 | "pygments_lexer": "ipython3", 508 | "version": "3.7.3" 509 | } 510 | }, 511 | "nbformat": 4, 512 | "nbformat_minor": 2 513 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.08_Ejercicios.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicios - 16 septiembre\n", 8 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 9 | ] 10 | }, 11 | { 12 | "source": [ 13 | "## Creacción diccionario" 14 | ], 15 | "cell_type": "markdown", 16 | "metadata": {} 17 | }, 18 | { 19 | "source": [ 20 | "1. Crear un diccionario donde las claves sean los días de la semana y los valores sean cuántos de esos dias hay en septiembre.\n", 21 | "2. Del diccionario anterior, convertir todas las claves mayúsculas.\n", 22 | "\n", 23 | "EXTRA: Utiliza una tupla para los días de la semana." 24 | ], 25 | "cell_type": "markdown", 26 | "metadata": {} 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## Cambiar el orden de las palabras" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "Pide al usuario que introduzca una frase y que el algoritmo la muestre por pantalla pero con las palabras en orden inverso. Por ejemplo:\n", 47 | "\n", 48 | " Me gusta analizar datos -> datos analizar gusta Me" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "## Piedra - Papel - Tijera" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "Crea un algoritmo que pida a dos usuarios si eligen piedra, papel o tijera y muestra por pantalla un mensaje para el ganador. En caso de empate, seguirán jugando hasta desempatar." 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [] 78 | }, 79 | { 80 | "source": [ 81 | "## Calculadora" 82 | ], 83 | "cell_type": "markdown", 84 | "metadata": {} 85 | }, 86 | { 87 | "source": [ 88 | "Hacer una función para un programa al que le entregues dos números `x` y `y` un parámetro `t` tal que\n", 89 | "\n", 90 | "- Si t = b. debe devolver $x - y$\n", 91 | "- Si t = c, debe devolver $x + y$\n", 92 | "- Si t = d, debe devolver $x/y$\n", 93 | "- Si t = e, debe devolver $x^{y+1}$\n", 94 | "\n", 95 | "EXTRA. Intenta utilizar un lista.\n" 96 | ], 97 | "cell_type": "markdown", 98 | "metadata": {} 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [] 106 | }, 107 | { 108 | "source": [ 109 | "## Estaciones" 110 | ], 111 | "cell_type": "markdown", 112 | "metadata": {} 113 | }, 114 | { 115 | "source": [ 116 | "Hacer un script para un programa al que le entregues un parámetro mes. Según el mes que introduzca el usuario, el programa debe devolver: PRIMAVERA, VERANO, OTOÑO o INVIERNO.\n", 117 | "EXTRA. Intenta utilizar un diccionario." 118 | ], 119 | "cell_type": "markdown", 120 | "metadata": {} 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [] 128 | } 129 | ], 130 | "metadata": { 131 | "kernelspec": { 132 | "display_name": "Python 3", 133 | "language": "python", 134 | "name": "python3" 135 | }, 136 | "language_info": { 137 | "codemirror_mode": { 138 | "name": "ipython", 139 | "version": 3 140 | }, 141 | "file_extension": ".py", 142 | "mimetype": "text/x-python", 143 | "name": "python", 144 | "nbconvert_exporter": "python", 145 | "pygments_lexer": "ipython3", 146 | "version": "3.7.3-final" 147 | } 148 | }, 149 | "nbformat": 4, 150 | "nbformat_minor": 2 151 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.09_Ejercicios_extra.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ejercicios - 16 septiembre\n", 8 | "Curso Introducción a Python - Tecnun, Universidad de Navarra" 9 | ] 10 | }, 11 | { 12 | "source": [ 13 | "## Creacción diccionario" 14 | ], 15 | "cell_type": "markdown", 16 | "metadata": {} 17 | }, 18 | { 19 | "source": [ 20 | "1. Crear un diccionario donde las claves sean los días de la semana y los valores sean cuántos de esos dias hay en septiembre.\n", 21 | "2. Del diccionario anterior, convertir todas las claves mayúsculas.\n", 22 | "\n", 23 | "EXTRA: Utiliza una tupla para los días de la semana." 24 | ], 25 | "cell_type": "markdown", 26 | "metadata": {} 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "## Cambiar el orden de las palabras" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "Pide al usuario que introduzca una frase y que el algoritmo la muestre por pantalla pero con las palabras en orden inverso. Por ejemplo:\n", 47 | "\n", 48 | " Me gusta analizar datos -> datos analizar gusta Me" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "## Piedra - Papel - Tijera" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "Crea un algoritmo que pida a dos usuarios si eligen piedra, papel o tijera y muestra por pantalla un mensaje para el ganador. En caso de empate, seguirán jugando hasta desempatar." 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": null, 75 | "metadata": {}, 76 | "outputs": [], 77 | "source": [] 78 | }, 79 | { 80 | "source": [ 81 | "## Calculadora" 82 | ], 83 | "cell_type": "markdown", 84 | "metadata": {} 85 | }, 86 | { 87 | "source": [ 88 | "Hacer una función para un programa al que le entregues dos números `x` y `y` un parámetro `t` tal que\n", 89 | "\n", 90 | "- Si t = b. debe devolver $x - y$\n", 91 | "- Si t = c, debe devolver $x + y$\n", 92 | "- Si t = d, debe devolver $x/y$\n", 93 | "- Si t = e, debe devolver $x^{y+1}$\n", 94 | "\n", 95 | "EXTRA. Intenta utilizar un lista.\n" 96 | ], 97 | "cell_type": "markdown", 98 | "metadata": {} 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [] 106 | }, 107 | { 108 | "source": [ 109 | "## Estaciones" 110 | ], 111 | "cell_type": "markdown", 112 | "metadata": {} 113 | }, 114 | { 115 | "source": [ 116 | "Hacer un script para un programa al que le entregues un parámetro mes. Según el mes que introduzca el usuario, el programa debe devolver: PRIMAVERA, VERANO, OTOÑO o INVIERNO.\n", 117 | "EXTRA. Intenta utilizar un diccionario." 118 | ], 119 | "cell_type": "markdown", 120 | "metadata": {} 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "## El ahorcado (EXTRA)" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "Crea el juego del ahorcado.\n", 141 | "\n", 142 | "Primero se le pedirá al usuario que introduzca una palabra. Después, otro usuario irá introduciendo letras, una a una, de forma que cada vez que introduce una, la pantalla muestre signos de interrogación en las posiciones de las letras que no se han acertado todavía y las letras en las posiciones de las que se han acertado. Asímismo, se mostrarán las letras que se han empleado pero no son correctas. Sólo se permitirán 6 fallos.\n", 143 | "\n", 144 | "En el caso de adivinar la palabra, se felicitará al usuario y, en el caso de no hacerlo, se mostrará \"GAME OVER\" por pantalla." 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "## Validación de contraseñas (EXTRA)" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "Crea una función que tome como argumento de entrada una propuesta de contraseña y compruebe si es segura o no. Una contraseña segura ha de cumplir las siguientes condiciones:\n", 166 | "- Debe tener al menos 8 caracteres.\n", 167 | "- Debe tener al menos una letra minúscula, una letra mayúscula, un número y un carácter no alfanumérico.\n", 168 | "- No puede tener espacios en blanco.\n", 169 | "\n", 170 | "Si la contraseña es segura, deberá mostrarse *True* por pantalla y, si no lo es, se mostrará *False*.\n", 171 | "\n", 172 | "Puedes aprovechar para practicar las expresiones regulares." 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [] 181 | } 182 | ], 183 | "metadata": { 184 | "kernelspec": { 185 | "display_name": "Python 3", 186 | "language": "python", 187 | "name": "python3" 188 | }, 189 | "language_info": { 190 | "codemirror_mode": { 191 | "name": "ipython", 192 | "version": 3 193 | }, 194 | "file_extension": ".py", 195 | "mimetype": "text/x-python", 196 | "name": "python", 197 | "nbconvert_exporter": "python", 198 | "pygments_lexer": "ipython3", 199 | "version": "3.7.3-final" 200 | } 201 | }, 202 | "nbformat": 4, 203 | "nbformat_minor": 2 204 | } -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/10.10_vectoresEquilibrados.txt: -------------------------------------------------------------------------------- 1 | 2 7 7 0 0 0 0 0 0 2 | 8 4 2 1 1 1 1 1 1 3 | 5 2 1 1 2 1 0 0 0 4 | 5 1 1 1 2 1 0 0 0 5 | 1 9 0 0 0 0 0 0 0 6 | 5 9 5 1 9 4 0 0 0 -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/funcionesDEMO.py: -------------------------------------------------------------------------------- 1 | def suma(a, b): 2 | return a+b 3 | 4 | def resta(a, b): 5 | return a-b -------------------------------------------------------------------------------- /class/MODULE_1-python_introduction/hw.txt: -------------------------------------------------------------------------------- 1 | Hello, world! -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/02.01_Expresiones Regulares en Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "Uno de los problemas más comunes con que nos solemos encontrar al desarrollar cualquier programa informático, es el de procesamiento de texto. Esta tarea puede resultar bastante trivial para el cerebro humano, ya que nosotros podemos detectar con facilidad que es un número y que una letra, o cuales son palabras que cumplen con un determinado patrón y cuales no; pero estas mismas tareas no son tan fáciles para una computadora. Es por esto, que el procesamiento de texto siempre ha sido uno de los temas más relevantes en las ciencias de la computación. Luego de varias décadas de investigación se logró desarrollar un poderoso y versátil lenguaje que cualquier computadora puede utilizar para reconocer patrones de texto; este lenguale es lo que hoy en día se conoce con el nombre de expresiones regulares; las operaciones de validación, búsqueda, extracción y sustitución de texto ahora son tareas mucho más sencillas para las computadoras gracias a las expresiones regulares." 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "## ¿Qué son las Expresiones Regulares?\n", 15 | "\n", 16 | "Las expresiones regulares, a menudo llamada también regex, son unas secuencias de caracteres que forma un patrón de búsqueda, las cuales son formalizadas por medio de una sintaxis específica. Los patrones se interpretan como un conjunto de instrucciones, que luego se ejecutan sobre un texto de entrada para producir un subconjunto o una versión modificada del texto original. Las expresiones regulares pueden incluir patrones de coincidencia literal, de repetición, de composición, de ramificación, y otras sofisticadas reglas de reconocimiento de texto . Las expresiones regulares deberían formar parte del arsenal de cualquier buen programador ya que un gran número de problemas de procesamiento de texto pueden ser fácilmente resueltos con ellas." 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 1, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import re" 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": 2, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [ 34 | "pat = r\"(Jaime)\"\n", 35 | "m = re.findall(pat, \"Jaime Rodriguez irá con Jaime Perez al cine.\")\n" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "Esta es una expresión regular que busca un patrón de correo electrónico:\n", 43 | "\n", 44 | "`/[\\w._%+-]+@[\\w.-]+\\.[a-zA-Z]{2,4}/`\n", 45 | "\n", 46 | "Pero, no te preocupes ... no tienes que entenderlo ahora. La buena noticia es que una expresión regular compleja es simplemente la combinación de varias expresiones regulares muy simples. \"¡Divide y vencerás!\"" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "| abc… | Letters |\n", 54 | "|-|-|\n", 55 | "| 123… | Digits |\n", 56 | "| \\d | Any Digit |\n", 57 | "| \\D | Any Non-digit character |\n", 58 | "| . | Any Character |\n", 59 | "| \\. | Period |\n", 60 | "| [abc] | Only a, b, or c |\n", 61 | "| [^abc] | Not a, b, nor c |\n", 62 | "| [a-z] | Characters a to z |\n", 63 | "| [0-9] | Numbers 0 to 9 |\n", 64 | "| \\w | Any Alphanumeric character |\n", 65 | "| \\W | Any Non-alphanumeric character |\n", 66 | "| {m} | m Repetitions |\n", 67 | "| {m,n} | m to n Repetitions |\n", 68 | "| * | Zero or more repetitions |\n", 69 | "| + | One or more repetitions |\n", 70 | "| ? | Optional character |\n", 71 | "| \\s | Any Whitespace |\n", 72 | "| \\S | Any Non-whitespace character |\n", 73 | "| ^…$ | Starts and ends |\n", 74 | "| (…) | Capture Group |\n", 75 | "| (a(bc)) | Capture Sub-group |\n", 76 | "| (.*) | Capture all |\n", 77 | "| (abc\\|def) | Matches abc or def |" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "## Raw strings\n", 85 | "\n", 86 | "Los *raw strings* de Python son strings usuales a los que les antecede una r. Por ejemplo ``r\"SciData\"`` es un raw string. Su caraterística principal es que no consideran el símbolo `\\` como un escape." 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 4, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "name": "stdout", 96 | "output_type": "stream", 97 | "text": [ 98 | "Hola\n", 99 | "Mundo.\tYa casi terminamos\n" 100 | ] 101 | } 102 | ], 103 | "source": [ 104 | "saludo = \"Hola\\nMundo.\\tYa casi terminamos\"\n", 105 | "print(saludo)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 5, 111 | "metadata": {}, 112 | "outputs": [ 113 | { 114 | "name": "stdout", 115 | "output_type": "stream", 116 | "text": [ 117 | "Hola\\nMundo.\\tYa casi terminamos\n" 118 | ] 119 | } 120 | ], 121 | "source": [ 122 | "r_saludo = r\"Hola\\nMundo.\\tYa casi terminamos\"\n", 123 | "print(r_saludo)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "## Findall: Encontrar todos los patrones en un string y que devuelva todas las coincidencias." 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": 6, 136 | "metadata": {}, 137 | "outputs": [], 138 | "source": [ 139 | "pat = r\"Python\"\n", 140 | "txt = \"Programamos en Python con los módulos pytorch y numpy.\"" 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": 47, 146 | "metadata": {}, 147 | "outputs": [ 148 | { 149 | "data": { 150 | "text/plain": [ 151 | "['6', '1', '0', '7', '4', '2', '8', '6', '4', '5']" 152 | ] 153 | }, 154 | "execution_count": 47, 155 | "metadata": {}, 156 | "output_type": "execute_result" 157 | } 158 | ], 159 | "source": [ 160 | "mensaje = \"Mi número es 610-742-8645\"\n", 161 | "\n" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": {}, 175 | "outputs": [], 176 | "source": [] 177 | }, 178 | { 179 | "cell_type": "code", 180 | "execution_count": null, 181 | "metadata": {}, 182 | "outputs": [], 183 | "source": [] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": null, 188 | "metadata": {}, 189 | "outputs": [], 190 | "source": [] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": null, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [] 198 | }, 199 | { 200 | "cell_type": "markdown", 201 | "metadata": {}, 202 | "source": [ 203 | "## Group: to get the matched string" 204 | ] 205 | }, 206 | { 207 | "cell_type": "code", 208 | "execution_count": 44, 209 | "metadata": {}, 210 | "outputs": [ 211 | { 212 | "data": { 213 | "text/plain": [ 214 | "'610'" 215 | ] 216 | }, 217 | "execution_count": 44, 218 | "metadata": {}, 219 | "output_type": "execute_result" 220 | } 221 | ], 222 | "source": [ 223 | "txt2 = \"Mis números son 610-742-845 y 663852642\"\n", 224 | "pat4 = r\"(\\d{3})-?(\\d{3})-?(\\d{3})\"\n", 225 | "m = re.findall(pat4, txt2)\n", 226 | "m[0]\n", 227 | "m[0][0]" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": 14, 233 | "metadata": {}, 234 | "outputs": [ 235 | { 236 | "name": "stdout", 237 | "output_type": "stream", 238 | "text": [ 239 | "['casa', 'caja', 'cama']\n" 240 | ] 241 | } 242 | ], 243 | "source": [ 244 | "txt = \"casa, caja, cama\"\n", 245 | "result3 = re.findall(\"ca[sjm]a\", txt)\n", 246 | "print(result3)" 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "## ? Character: a lo más una coincidencia" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 26, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [ 262 | "expr = re.compile(r'Pyt(ho)?n')" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 27, 268 | "metadata": {}, 269 | "outputs": [ 270 | { 271 | "data": { 272 | "text/plain": [ 273 | "'Python'" 274 | ] 275 | }, 276 | "execution_count": 27, 277 | "metadata": {}, 278 | "output_type": "execute_result" 279 | } 280 | ], 281 | "source": [ 282 | "match = expr.search(\"Python! a great language.\")\n", 283 | "match.group()" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "## * Character: cero o más coincidencias" 291 | ] 292 | }, 293 | { 294 | "cell_type": "markdown", 295 | "metadata": {}, 296 | "source": [ 297 | "## + Character: al menos una coincidencia" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "## {} : n coincidencias" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "## {m,n} entre m y n coincidencias (máximo de coincidencias)" 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "## Match the exact number of characters" 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": 35, 324 | "metadata": {}, 325 | "outputs": [ 326 | { 327 | "name": "stdout", 328 | "output_type": "stream", 329 | "text": [ 330 | "['22/10/2019']\n" 331 | ] 332 | } 333 | ], 334 | "source": [ 335 | "string = 'The date is 22/10/2019'\n", 336 | "lst = re.findall('[0-9]{1,2}\\/[0-9]{1,2}\\/[0-9]{4}', string)\n", 337 | "print(lst)" 338 | ] 339 | }, 340 | { 341 | "cell_type": "markdown", 342 | "metadata": {}, 343 | "source": [ 344 | "## ^ start and end $" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 37, 350 | "metadata": {}, 351 | "outputs": [ 352 | { 353 | "data": { 354 | "text/plain": [ 355 | "['T', 'h', ' ', 'l', 'n', 'g', 'g', ' ', 's', ' ', 'P', 'y', 't', 'h', 'n']" 356 | ] 357 | }, 358 | "execution_count": 37, 359 | "metadata": {}, 360 | "output_type": "execute_result" 361 | } 362 | ], 363 | "source": [ 364 | "regex = re.compile(r'[^aeiouAEIOU]')\n", 365 | "string = \"The language is PythOn\"\n", 366 | "regex.findall(string)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "## Escaping Special Characters" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 51, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "name": "stdout", 383 | "output_type": "stream", 384 | "text": [ 385 | "['Sentences have dots.']\n" 386 | ] 387 | } 388 | ], 389 | "source": [ 390 | "str = 'Sentences have dots.How do we escape them?\\n'\n", 391 | "lst = re.findall('\\D+\\.', str)\n", 392 | "print(lst)" 393 | ] 394 | }, 395 | { 396 | "cell_type": "markdown", 397 | "metadata": {}, 398 | "source": [ 399 | "[Tutorial](https://regexone.com/lesson/introduction_abcs)\n", 400 | "\n", 401 | "[Problems](https://regexone.com/problem/matching_decimal_numbers)" 402 | ] 403 | }, 404 | { 405 | "cell_type": "markdown", 406 | "metadata": {}, 407 | "source": [ 408 | "## Reference:\n", 409 | "\n", 410 | "https://docs.python.org/3/library/re.html" 411 | ] 412 | }, 413 | { 414 | "cell_type": "code", 415 | "execution_count": null, 416 | "metadata": {}, 417 | "outputs": [], 418 | "source": [] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [] 426 | }, 427 | { 428 | "cell_type": "code", 429 | "execution_count": null, 430 | "metadata": {}, 431 | "outputs": [], 432 | "source": [] 433 | }, 434 | { 435 | "cell_type": "code", 436 | "execution_count": null, 437 | "metadata": {}, 438 | "outputs": [], 439 | "source": [] 440 | } 441 | ], 442 | "metadata": { 443 | "kernelspec": { 444 | "display_name": "Python 3", 445 | "language": "python", 446 | "name": "python3" 447 | }, 448 | "language_info": { 449 | "codemirror_mode": { 450 | "name": "ipython", 451 | "version": 3 452 | }, 453 | "file_extension": ".py", 454 | "mimetype": "text/x-python", 455 | "name": "python", 456 | "nbconvert_exporter": "python", 457 | "pygments_lexer": "ipython3", 458 | "version": "3.7.3" 459 | }, 460 | "toc": { 461 | "base_numbering": 1, 462 | "nav_menu": {}, 463 | "number_sections": true, 464 | "sideBar": true, 465 | "skip_h1_title": false, 466 | "title_cell": "Table of Contents", 467 | "title_sidebar": "Contents", 468 | "toc_cell": false, 469 | "toc_position": {}, 470 | "toc_section_display": true, 471 | "toc_window_display": false 472 | }, 473 | "varInspector": { 474 | "cols": { 475 | "lenName": 16, 476 | "lenType": 16, 477 | "lenVar": 40 478 | }, 479 | "kernels_config": { 480 | "python": { 481 | "delete_cmd_postfix": "", 482 | "delete_cmd_prefix": "del ", 483 | "library": "var_list.py", 484 | "varRefreshCmd": "print(var_dic_list())" 485 | }, 486 | "r": { 487 | "delete_cmd_postfix": ") ", 488 | "delete_cmd_prefix": "rm(", 489 | "library": "var_list.r", 490 | "varRefreshCmd": "cat(var_dic_list()) " 491 | } 492 | }, 493 | "types_to_exclude": [ 494 | "module", 495 | "function", 496 | "builtin_function_or_method", 497 | "instance", 498 | "_Feature" 499 | ], 500 | "window_display": false 501 | } 502 | }, 503 | "nbformat": 4, 504 | "nbformat_minor": 2 505 | } 506 | -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/02.02_Input_Output.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "# Input-Output\n", 15 | "\n", 16 | "En esta sección explicaremos cómo leer y escribir archivos\n", 17 | "\n", 18 | "Utilizaremos el paquete os.\n", 19 | "\n", 20 | "``import os``" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "## Creación de carpetas\n", 28 | "\n", 29 | "Podemos creer carpetas con *os.makedirs()*\n", 30 | "\n", 31 | "``os.makedirs(\"RUTA DONDE SE CREARÁ LA CARPETA/NOMBRE DE LA CARPETA\", exist_ok = True)``\n", 32 | "\n", 33 | "El parámetro ``exist_ok`` acepta booleanos como argumento. Si es ``True`` creará una carpeta sin importarle si existe o no (cuidado con eso). Si es ``False`` no permitirá crearla si ya existe una con ese nombre.\n", 34 | "\n" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Con la función *os.listdir()* podemos ver qué hay en alguna carpeta.\n", 42 | "\n", 43 | "``os.listdir(\"RUTA Y NOMBRE DE LA CARPETA\")``" 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "## Leer y escribir archivos\n", 51 | "\n", 52 | "Podemos usar open para abrir archivos. Si el archivo no existe, dará un error.\n", 53 | "\n", 54 | "``archivo_inexistente = open(\"RUTA DONDE ESCRIBIREMOS EL ARCHIVO/NOMBRE DEL ARCHICO A ABRIR.EXTENSIÓN\")``\n", 55 | "\n", 56 | "Por ejemplo, \n", 57 | "\n", 58 | "``archivo_inexistente = open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\")`` \n", 59 | "\n", 60 | "nos dará un error si el archivo *usuarios.txt* no existe en la dirección *C:/Users/hp master/Documents/SciData/Py_CDD/*\n", 61 | "\n" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "Si queremos crear un archivo para escribir, debemos especificar argumento \"w\"\n", 69 | "\n", 70 | "``archivo_para_escribir = open(\"RUTA DONDE ESCRIBIREMOS EL ARCHIVO/NOMBRE DEL ARCHICO A ABRIR.EXTENSIÓN\",\"w\")``\n", 71 | "\n", 72 | "Por ejemplo, \n", 73 | "\n", 74 | "``archivo_para_escribir = open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\", \"w\")`` \n", 75 | "\n", 76 | "creará el archivo *usuarios.txt* si no existe en la dirección *C:/Users/hp master/Documents/SciData/Py_CDD/*\n", 77 | "\n", 78 | "**REGlA GENERAL: siempre mantén cerrado en el ordenador cualquier archivo que esté siendo ocupado\n", 79 | "por Python** \n", 80 | "\n" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": {}, 86 | "source": [ 87 | "Para escribir en él usamos el método write.\n", 88 | "\n", 89 | "``archivo_para_escribir.write(\"hola mundo.\")``\n", 90 | "``archivo_para_escribir.write(\"¿Cómo están todos?\")``\n", 91 | "\n", 92 | "Y no se escribe nada hasta que lo cerremos.\n", 93 | "\n", 94 | "``archivo_para_escribir.close()``\n", 95 | "\n" 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "Si usamos el argumento \"w\", reescribiremos el archivo\n", 103 | "\n", 104 | "``archivo_para_escribir = open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\",\"w\")``\n", 105 | "\n", 106 | "``archivo_para_escribir.write(\"Bienvenidos a CDD_Py de SciData.\")``\n", 107 | "\n", 108 | "``archivo_para_escribir.close()``\n", 109 | "\n" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "Podemos usar el método \"a\" para escribir sin borrar el original\n", 117 | "\n", 118 | "``archivo_para_escribir = open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\",\"a\")\n", 119 | "archivo_para_escribir.write(\"\\nEsperamos que les guste el curso.\")\n", 120 | "archivo_para_escribir.close()``\n", 121 | "\n" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "Usar el método de open-close no es ideal, pues si ocurre un error entre los dos estados podemos perder \n", 129 | "o dañar el archivo original.\n", 130 | "\n", 131 | "La manera más recomendable es usando \"with\"\n", 132 | "\n", 133 | "\n", 134 | "``guerreros_z = [\"Gokú\",\"Vegueta\",\"Krilin\",\"Yamcha\",\"Ten Chin Han\",\"Pikoro\",\"Gohan\"]``\n", 135 | "\n", 136 | "``with open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\",\"w\") as archivo_para_escribir:\n", 137 | " for guerrero in guerreros_z:\n", 138 | " archivo_para_escribir.write(f\"{guerrero} \")``\n", 139 | " \n", 140 | "\n" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "Si quisieramos escribir cada elemento en un renglón diferente solo añadimos el \\n\n", 148 | "\n", 149 | "``with open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\",\"w\") as archivo_para_escribir:\n", 150 | " for guerrero in guerreros_z:\n", 151 | " archivo_para_escribir.write(f\"{guerrero}\\n\")``\n", 152 | " \n" 153 | ] 154 | }, 155 | { 156 | "cell_type": "markdown", 157 | "metadata": {}, 158 | "source": [ 159 | "## LECTURA\n", 160 | "\n", 161 | "También podemos leer archivos muy fácilmente.\n", 162 | "\n", 163 | "``with open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\") as archivo_para_leer:\n", 164 | " datos = archivo_para_leer.read()``\n", 165 | " \n", 166 | "``print(datos)``\n", 167 | "\n", 168 | "``type(datos)`` \n", 169 | " \n" 170 | ] 171 | }, 172 | { 173 | "cell_type": "markdown", 174 | "metadata": {}, 175 | "source": [ 176 | "Si queremos leer cada línea del archivo por separado, usamos el método readlines(), que va leyendo de forma iterativa (y consume menos memoria)\n", 177 | "\n", 178 | "``cada_linea = []``\n", 179 | " \n", 180 | "``with open(\"C:/Users/hp master/Documents/SciData/Py_CDD/usuarios.txt\") as archivo_para_leer:\n", 181 | " lineas = archivo_para_leer.readlines()\n", 182 | " for linea in lineas:\n", 183 | " cada_linea.append(linea.strip(\"\\n\"))``\n", 184 | " \n", 185 | "``print(lineas)\n", 186 | "print(cada_linea)\n", 187 | "type(lineas)\n", 188 | "type(cada_linea)``" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "## Escritura de tablas csv a partir de un diccionario.\n", 196 | "\n", 197 | "Los archivos csv son una forma de almacenar datos con cada columna separada por una coma.\n", 198 | "\n", 199 | "Por ejemplo, tomemos el diccionario\n", 200 | "\n", 201 | "``{\"nombre\":[\"Antonio\",\"Miguel\",\"Julian\",\"Andres\"],\"edad\":[45,40,22,34],\"ciudad\":[\"Ciudad de México\",\"Puebla\",\"Mexicali\",\"Aguascalientes\"]}``\n", 202 | "\n", 203 | "Dicho diccionario en csv se vería como\n", 204 | "\n", 205 | "nombre,edad,ciudad\n", 206 | "\n", 207 | "Antonio,45,Ciudad de México\n", 208 | "\n", 209 | "Miguel,40,Puebla\n", 210 | "\n", 211 | "Julián,22,Mexicali\n", 212 | "\n", 213 | "Andrés,34,Aguascalientes" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "En Python, es posible escribir archivos csv a partir de diccionarios:\n", 221 | "\n", 222 | "``datos = {\"nombre\":[\"Antonio\",\"Miguel\",\"Julian\",\"Andres\"],\n", 223 | " \"edad\":[\"45\",\"40\",\"22\",\"34\"],\n", 224 | " \"ciudad\":[\"Ciudad de México\",\"Puebla\",\"Mexicali\",\"Aguascalientes\"]\n", 225 | " }``\n", 226 | "\n", 227 | "``claves = list(datos.keys())\n", 228 | "n_items = len(datos[claves[0]])``\n", 229 | "\n", 230 | "``with open(\"C:/Users/hp master/Documents/SciData/Py_CDD/DiccionarioACSV.csv\", \"w\") as nombre_archivo:\n", 231 | " nombre_archivo.write(','.join(claves)+\"\\n\")\n", 232 | " for i in range(n_items):\n", 233 | " fila = \",\".join([str(datos[clave][i]) for clave in claves])\n", 234 | " nombre_archivo.write(fila+\"\\n\")``" 235 | ] 236 | } 237 | ], 238 | "metadata": { 239 | "kernelspec": { 240 | "display_name": "Python 3", 241 | "language": "python", 242 | "name": "python3" 243 | }, 244 | "language_info": { 245 | "codemirror_mode": { 246 | "name": "ipython", 247 | "version": 3 248 | }, 249 | "file_extension": ".py", 250 | "mimetype": "text/x-python", 251 | "name": "python", 252 | "nbconvert_exporter": "python", 253 | "pygments_lexer": "ipython3", 254 | "version": "3.7.7" 255 | } 256 | }, 257 | "nbformat": 4, 258 | "nbformat_minor": 4 259 | } 260 | -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/02.40_PANDAS_LAB_BANCO/02.40_PANDAS_LAB_Banco.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Práctica Pandas: \n", 8 | "# INFORME SOBRE CUENTAS BANCARIAS DE LOS AÑOS 2010 Y 2011\n", 9 | "\n", 10 | "Introducción a la Programación en Python 2021\n", 11 | "by Fernando Carazo\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "%config IPCompleter.greedy=True\n", 21 | "import pandas as pd" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "### Load data" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 37, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "data": { 38 | "text/html": [ 39 | "
\n", 40 | "\n", 53 | "\n", 54 | " \n", 55 | " \n", 56 | " \n", 57 | " \n", 58 | " \n", 59 | " \n", 60 | " \n", 61 | " \n", 62 | " \n", 63 | " \n", 64 | " \n", 65 | " \n", 66 | " \n", 67 | " \n", 68 | " \n", 69 | " \n", 70 | " \n", 71 | " \n", 72 | " \n", 73 | " \n", 74 | " \n", 75 | " \n", 76 | " \n", 77 | " \n", 78 | " \n", 79 | " \n", 80 | " \n", 81 | " \n", 82 | " \n", 83 | " \n", 84 | " \n", 85 | " \n", 86 | " \n", 87 | " \n", 88 | " \n", 89 | " \n", 90 | " \n", 91 | " \n", 92 | " \n", 93 | " \n", 94 | " \n", 95 | " \n", 96 | " \n", 97 | " \n", 98 | " \n", 99 | " \n", 100 | " \n", 101 | " \n", 102 | " \n", 103 | " \n", 104 | " \n", 105 | " \n", 106 | " \n", 107 | " \n", 108 | " \n", 109 | " \n", 110 | " \n", 111 | " \n", 112 | "
AñoMesSucursalTipo CtaNuevo ClienteImporte
02011EneroMadridCorrienteSí2500
12011EneroBarcelonaFondo InversiónSí10000
22011EneroSalamancaCorrienteSí3500
32011FebreroBarcelonaFondo InversiónNo75000
42011FebreroBarcelonaFondo InversiónNo100000
\n", 113 | "
" 114 | ], 115 | "text/plain": [ 116 | " Año Mes Sucursal Tipo Cta Nuevo Cliente Importe\n", 117 | "0 2011 Enero Madrid Corriente Sí 2500\n", 118 | "1 2011 Enero Barcelona Fondo Inversión Sí 10000\n", 119 | "2 2011 Enero Salamanca Corriente Sí 3500\n", 120 | "3 2011 Febrero Barcelona Fondo Inversión No 75000\n", 121 | "4 2011 Febrero Barcelona Fondo Inversión No 100000" 122 | ] 123 | }, 124 | "execution_count": 37, 125 | "metadata": {}, 126 | "output_type": "execute_result" 127 | } 128 | ], 129 | "source": [ 130 | "data = pd.read_excel(\"Banco.xlsx\")\n", 131 | "data = pd.DataFrame(data)\n", 132 | "data.head()" 133 | ] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "### 0. Numero de cuentas por año. ¿Y por mes y año?" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "### 1.\tCantidad total de importe de clientes por año" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "### 2.\t¿Cuánto ha aumentado /disminuido 2011 vs 2010? ¿Y según tipo de cuenta?\n" 154 | ] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "### 3.\t¿Cómo se distribuye el importe según las sucursales? ¿y en porcentajes? ¿Qué sucursal ha ingresado más?" 161 | ] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "### 4.\t¿Y por tipo de cuenta bancaria? ¿Qué tipo de cuenta habría que fortalecer?" 168 | ] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "### 5.\t¿Cómo se distribuyen los tipos de cuenta según ciudad? " 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "### 6.\t¿Qué tipo de cuenta es la más fuerte en cada ciudad?" 182 | ] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "### 7.\t¿Qué cuenta habría que fortalecer en Barcelona? ¿Y en Madrid?" 189 | ] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "### 8.\t¿Cuántos nuevos clientes se han conseguido en 2010? ¿y en 2011? " 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "### 9.\tHaga un análisis de los nuevos clientes. Si usted fuera el director del banco, ¿Dónde le gustaría mejorar?" 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [] 211 | } 212 | ], 213 | "metadata": { 214 | "kernelspec": { 215 | "display_name": "Python 3", 216 | "language": "python", 217 | "name": "python3" 218 | }, 219 | "language_info": { 220 | "codemirror_mode": { 221 | "name": "ipython", 222 | "version": 3 223 | }, 224 | "file_extension": ".py", 225 | "mimetype": "text/x-python", 226 | "name": "python", 227 | "nbconvert_exporter": "python", 228 | "pygments_lexer": "ipython3", 229 | "version": "3.6.8" 230 | } 231 | }, 232 | "nbformat": 4, 233 | "nbformat_minor": 2 234 | } -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/02.40_PANDAS_LAB_BANCO/Banco.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/class/MODULE_2-Work_with_data/02.40_PANDAS_LAB_BANCO/Banco.xlsx -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/data/Salaries.csv: -------------------------------------------------------------------------------- 1 | rank,discipline,phd,service,sex,salary 2 | Prof,B,56,49,Male,186960 3 | Prof,A,12,6,Male,93000 4 | Prof,A,23,20,Male,110515 5 | Prof,A,40,31,Male,131205 6 | Prof,B,20,18,Male,104800 7 | Prof,A,20,20,Male,122400 8 | AssocProf,A,20,17,Male,81285 9 | Prof,A,18,18,Male,126300 10 | Prof,A,29,19,Male,94350 11 | Prof,A,51,51,Male,57800 12 | Prof,B,39,33,Male,128250 13 | Prof,B,23,23,Male,134778 14 | AsstProf,B,1,0,Male,88000 15 | Prof,B,35,33,Male,162200 16 | Prof,B,25,19,Male,153750 17 | Prof,B,17,3,Male,150480 18 | AsstProf,B,8,3,Male,75044 19 | AsstProf,B,4,0,Male,92000 20 | Prof,A,19,7,Male,107300 21 | Prof,A,29,27,Male,150500 22 | AsstProf,B,4,4,Male,92000 23 | Prof,A,33,30,Male,103106 24 | AsstProf,A,4,2,Male,73000 25 | AsstProf,A,2,0,Male,85000 26 | Prof,A,30,23,Male,91100 27 | Prof,B,35,31,Male,99418 28 | Prof,A,38,19,Male,148750 29 | Prof,A,45,43,Male,155865 30 | AsstProf,B,7,2,Male,91300 31 | Prof,B,21,20,Male,123683 32 | AssocProf,B,9,7,Male,107008 33 | Prof,B,22,21,Male,155750 34 | Prof,A,27,19,Male,103275 35 | Prof,B,18,18,Male,120000 36 | AssocProf,B,12,8,Male,119800 37 | Prof,B,28,23,Male,126933 38 | Prof,B,45,45,Male,146856 39 | Prof,A,20,8,Male,102000 40 | AsstProf,B,4,3,Male,91000 41 | Prof,B,18,18,Female,129000 42 | Prof,A,39,36,Female,137000 43 | AssocProf,A,13,8,Female,74830 44 | AsstProf,B,4,2,Female,80225 45 | AsstProf,B,5,0,Female,77000 46 | Prof,B,23,19,Female,151768 47 | Prof,B,25,25,Female,140096 48 | AsstProf,B,11,3,Female,74692 49 | AssocProf,B,11,11,Female,103613 50 | Prof,B,17,17,Female,111512 51 | Prof,B,17,18,Female,122960 52 | AsstProf,B,10,5,Female,97032 53 | Prof,B,20,14,Female,127512 54 | Prof,A,12,0,Female,105000 55 | AsstProf,A,5,3,Female,73500 56 | AssocProf,A,25,22,Female,62884 57 | AsstProf,A,2,0,Female,72500 58 | AssocProf,A,10,8,Female,77500 59 | AsstProf,A,3,1,Female,72500 60 | Prof,B,36,26,Female,144651 61 | AssocProf,B,12,10,Female,103994 62 | AsstProf,B,3,3,Female,92000 63 | AssocProf,B,13,10,Female,103750 64 | AssocProf,B,14,7,Female,109650 65 | Prof,A,29,27,Female,91000 66 | AssocProf,A,26,24,Female,73300 67 | Prof,A,36,19,Female,117555 68 | AsstProf,A,7,6,Female,63100 69 | Prof,A,17,11,Female,90450 70 | AsstProf,A,4,2,Female,77500 71 | Prof,A,28,7,Female,116450 72 | AsstProf,A,8,3,Female,78500 73 | AssocProf,B,12,9,Female,71065 74 | Prof,B,24,15,Female,161101 75 | Prof,B,18,10,Female,105450 76 | AssocProf,B,19,6,Female,104542 77 | Prof,B,17,17,Female,124312 78 | Prof,A,28,14,Female,109954 79 | Prof,A,23,15,Female,109646 80 | -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/img/dfAtributes.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/class/MODULE_2-Work_with_data/img/dfAtributes.PNG -------------------------------------------------------------------------------- /class/MODULE_2-Work_with_data/img/dfMethods.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/class/MODULE_2-Work_with_data/img/dfMethods.PNG -------------------------------------------------------------------------------- /class/MODULE_3-data_visualization/CORONAVIRUS.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/class/MODULE_3-data_visualization/CORONAVIRUS.xlsx -------------------------------------------------------------------------------- /docs/01.01IntroPython.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/01.01IntroPython.pdf -------------------------------------------------------------------------------- /docs/01.02PythonForDataScience.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/01.02PythonForDataScience.pdf -------------------------------------------------------------------------------- /docs/02.01_python-cheatsheets-ds.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/02.01_python-cheatsheets-ds.pdf -------------------------------------------------------------------------------- /docs/02.02pandas_cheat_sheet.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/02.02pandas_cheat_sheet.pdf -------------------------------------------------------------------------------- /docs/Git summary.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/Git summary.png -------------------------------------------------------------------------------- /docs/Git summary_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FernandoCarazoMelo/introduccion-a-python/6c4f4b2e5e2be82b2f7c2fec7766014067b7b406/docs/Git summary_2.png --------------------------------------------------------------------------------