├── test.py ├── test.ipynb └── README.md /test.py: -------------------------------------------------------------------------------- 1 | cadena = ' soy una comilla doble " ' 2 | print(cadena) -------------------------------------------------------------------------------- /test.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "def newton(num, root):\n", 10 | " for iter in range(50):\n", 11 | " if iter == 0:\n", 12 | " x = 1 \n", 13 | " f = x**root - num\n", 14 | " g = root*(x**(root-1))\n", 15 | " x = x - (f/g)\n", 16 | " return x\n" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 3, 22 | "metadata": {}, 23 | "outputs": [ 24 | { 25 | "name": "stdout", 26 | "output_type": "stream", 27 | "text": [ 28 | "729.1159029948531 729.1159029948531\n" 29 | ] 30 | } 31 | ], 32 | "source": [ 33 | "print(newton(531610, 2),531610**0.5)" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "https://plainenglish.io/blog/6-amazing-algorithms-to-get-the-square-root-and-any-root-of-any-number-in-python-3c976ad1ca04#2-approximation-with-binary-search-any-root\n", 41 | "https://en.wikipedia.org/wiki/Methods_of_computing_square_roots" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 2, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "name": "stdout", 51 | "output_type": "stream", 52 | "text": [ 53 | "10\n" 54 | ] 55 | } 56 | ], 57 | "source": [ 58 | "n : int = 10\n", 59 | "if n >= 2 and n <= 5:\n", 60 | " print(\"El numero \" + str(n)+ \" esta entre 2 y 5\")\n", 61 | "print(n)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 4, 67 | "metadata": {}, 68 | "outputs": [ 69 | { 70 | "name": "stdout", 71 | "output_type": "stream", 72 | "text": [ 73 | "80\n" 74 | ] 75 | } 76 | ], 77 | "source": [ 78 | "n : int \n", 79 | "n = int(input(\"Ingrese un numero entero: \"))\n", 80 | "if n >= 2 and n <= 5:\n", 81 | " print(\"El numero \" + str(n)+ \" esta entre 2 y 5\")\n", 82 | "print(n)" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 7, 88 | "metadata": {}, 89 | "outputs": [ 90 | { 91 | "name": "stdout", 92 | "output_type": "stream", 93 | "text": [ 94 | "El numero 4 esta entre 2 y 5\n", 95 | "4\n" 96 | ] 97 | } 98 | ], 99 | "source": [ 100 | "n : int \n", 101 | "n = int(input(\"Ingrese un numero entero: \")) # Conversion a entero\n", 102 | "if n >= 2 and n <= 5:\n", 103 | " print(\"El numero \" + str(n)+ \" esta entre 2 y 5\")\n", 104 | "else:\n", 105 | " if n < 2:\n", 106 | " print(\"El numero \" + str(n)+ \" es menor que 2\")\n", 107 | " if n > 5:\n", 108 | " print(\"El numero \" + str(n)+ \" es mayor que 5\")\n", 109 | "print(n)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 9, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "name": "stdout", 119 | "output_type": "stream", 120 | "text": [ 121 | "5.0 5.0\n" 122 | ] 123 | } 124 | ], 125 | "source": [ 126 | "a = float(input(\"Ingrese el primer numero: \")) \n", 127 | "b = float(input(\"Ingrese el segundo numero: \")) \n", 128 | "if a == b:\n", 129 | " print(a,b)\n", 130 | "else:\n", 131 | " if a > b:\n", 132 | " print(a)\n", 133 | " if b > a:\n", 134 | " print(b)" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 10, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "El numero 5.0 es positivo\n" 147 | ] 148 | } 149 | ], 150 | "source": [ 151 | "a : float\n", 152 | "a = float(input(\"Ingrese el primer numero: \")) \n", 153 | "if a >= 0:\n", 154 | " print(\"El numero \"+str(a)+\" es positivo\")\n", 155 | "else:\n", 156 | " print(\"El numero \"+str(a)+\" es negativo\")" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 11, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "El valor absoluto es 10.0\n" 169 | ] 170 | } 171 | ], 172 | "source": [ 173 | "a : float\n", 174 | "a = float(input(\"Ingrese el primer numero: \")) \n", 175 | "if a >= 0:\n", 176 | " print(\"El valor absoluto es \"+str(a))\n", 177 | "else:\n", 178 | " print(\"El valor absoluto es \"+str(-a))" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 13, 184 | "metadata": {}, 185 | "outputs": [ 186 | { 187 | "name": "stdout", 188 | "output_type": "stream", 189 | "text": [ 190 | "El valor absoluto es 10.0\n" 191 | ] 192 | } 193 | ], 194 | "source": [ 195 | "a : float\n", 196 | "valor_abs : float\n", 197 | "a = float(input(\"Ingrese un numero: \")) \n", 198 | "valor_abs = a if a >= 0 else -a\n", 199 | "print(\"El valor absoluto es \"+str(valor_abs))" 200 | ] 201 | }, 202 | { 203 | "cell_type": "code", 204 | "execution_count": null, 205 | "metadata": {}, 206 | "outputs": [], 207 | "source": [ 208 | "cantidadestudiantes = 1\n", 209 | "def cantidad():\n", 210 | " return None" 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 14, 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [ 219 | "# Declarar variable\n", 220 | "x : int\n", 221 | "# Inicializar variable\n", 222 | "x = 10 \n", 223 | "# Declarar e inicializar variable\n", 224 | "x : int = 10" 225 | ] 226 | }, 227 | { 228 | "cell_type": "code", 229 | "execution_count": 15, 230 | "metadata": {}, 231 | "outputs": [ 232 | { 233 | "name": "stdout", 234 | "output_type": "stream", 235 | "text": [ 236 | "10\n" 237 | ] 238 | } 239 | ], 240 | "source": [ 241 | "print(x)" 242 | ] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "# Soy markdown" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 22, 254 | "metadata": {}, 255 | "outputs": [ 256 | { 257 | "name": "stdout", 258 | "output_type": "stream", 259 | "text": [ 260 | "65\n", 261 | "0b10000000000000000000000000000000000000000000000001011110100000000\n" 262 | ] 263 | } 264 | ], 265 | "source": [ 266 | "# Declarar e inicializar variable\n", 267 | "x : int = 18446744073709600000\n", 268 | "# Cantidad de bits\n", 269 | "print(x.bit_length())\n", 270 | "# Representacion binaria \n", 271 | "print(bin(x)) " 272 | ] 273 | }, 274 | { 275 | "cell_type": "code", 276 | "execution_count": 23, 277 | "metadata": {}, 278 | "outputs": [ 279 | { 280 | "name": "stdout", 281 | "output_type": "stream", 282 | "text": [ 283 | "6.02214129e+23\n" 284 | ] 285 | } 286 | ], 287 | "source": [ 288 | "Avogadro : float = +6.02214129e+23\n", 289 | "print(Avogadro)" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 25, 295 | "metadata": {}, 296 | "outputs": [ 297 | { 298 | "name": "stdout", 299 | "output_type": "stream", 300 | "text": [ 301 | "True\n" 302 | ] 303 | } 304 | ], 305 | "source": [ 306 | "print(0==False)" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": 36, 312 | "metadata": {}, 313 | "outputs": [ 314 | { 315 | "data": { 316 | "text/plain": [ 317 | "49" 318 | ] 319 | }, 320 | "execution_count": 36, 321 | "metadata": {}, 322 | "output_type": "execute_result" 323 | } 324 | ], 325 | "source": [ 326 | "ord(\"1\")" 327 | ] 328 | }, 329 | { 330 | "cell_type": "code", 331 | "execution_count": 34, 332 | "metadata": {}, 333 | "outputs": [ 334 | { 335 | "data": { 336 | "text/plain": [ 337 | "' '" 338 | ] 339 | }, 340 | "execution_count": 34, 341 | "metadata": {}, 342 | "output_type": "execute_result" 343 | } 344 | ], 345 | "source": [ 346 | "chr(32)" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 39, 352 | "metadata": {}, 353 | "outputs": [ 354 | { 355 | "name": "stdout", 356 | "output_type": "stream", 357 | "text": [ 358 | "Cadena con una comilla simple', una comilla doble y una diagonal invertida \n" 359 | ] 360 | } 361 | ], 362 | "source": [ 363 | "cadena = \"Cadena con una comilla simple', una comilla doble y una diagonal invertida \"\n", 364 | "print(cadena) " 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 40, 370 | "metadata": {}, 371 | "outputs": [ 372 | { 373 | "name": "stdout", 374 | "output_type": "stream", 375 | "text": [ 376 | " soy una comilla sencila ' \n" 377 | ] 378 | } 379 | ], 380 | "source": [ 381 | "cadena = \" soy una comilla sencila ' \"\n", 382 | "print(cadena)" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": 41, 388 | "metadata": {}, 389 | "outputs": [ 390 | { 391 | "name": "stdout", 392 | "output_type": "stream", 393 | "text": [ 394 | " soy una comilla doble \" \n" 395 | ] 396 | } 397 | ], 398 | "source": [ 399 | "cadena = ' soy una comilla doble \" '\n", 400 | "print(cadena)" 401 | ] 402 | }, 403 | { 404 | "cell_type": "code", 405 | "execution_count": null, 406 | "metadata": {}, 407 | "outputs": [], 408 | "source": [ 409 | "cadena = ' soy una comilla doble \" '" 410 | ] 411 | }, 412 | { 413 | "cell_type": "code", 414 | "execution_count": 1, 415 | "metadata": {}, 416 | "outputs": [ 417 | { 418 | "name": "stdout", 419 | "output_type": "stream", 420 | "text": [ 421 | "Serás un cientifico de datos\n" 422 | ] 423 | } 424 | ], 425 | "source": [ 426 | "lang = input(\"Que lenguaje de programacion desea aprender? \")\n", 427 | "\n", 428 | "match lang:\n", 429 | " case \"JavaScript\":\n", 430 | " print(\"Serás un desarrollador web full stack.\")\n", 431 | "\n", 432 | " case \"Python\":\n", 433 | " print(\"Serás un cientifico de datos\")\n", 434 | "\n", 435 | " case \"PHP\":\n", 436 | " print(\"Serás un desarrollador backend\")\n", 437 | " \n", 438 | " case \"Matlab\":\n", 439 | " print(\"Serás la burla del resto de programadores\")\n", 440 | "\n", 441 | " case \"Java\":\n", 442 | " print(\"Serás un desarrollador de apps moviles\")\n", 443 | " case _:\n", 444 | " print(\"Lo importante no es el lenguaje, es la habilidad de resolver problemas.\")" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": 2, 450 | "metadata": {}, 451 | "outputs": [ 452 | { 453 | "name": "stdout", 454 | "output_type": "stream", 455 | "text": [ 456 | "Serás un cientifico de datos\n" 457 | ] 458 | } 459 | ], 460 | "source": [ 461 | "lang = input(\"Que lenguaje de programacion desea aprender? \")\n", 462 | "\n", 463 | "if lang == \"JavaScript\":\n", 464 | " print(\"Serás un desarrollador web full stack.\")\n", 465 | "elif lang == \"Python\":\n", 466 | " print(\"Serás un cientifico de datos\")\n", 467 | "elif lang == \"PHP\":\n", 468 | " print(\"Serás un desarrollador backend\")\n", 469 | "elif lang == \"Matlab\":\n", 470 | " print(\"Serás la burla del resto de programadores\")\n", 471 | "elif lang == \"Java\":\n", 472 | " print(\"Serás un desarrollador de apps moviles\")\n", 473 | "else:\n", 474 | " print(\"Lo importante no es el lenguaje, es la habilidad de resolver problemas.\")" 475 | ] 476 | }, 477 | { 478 | "cell_type": "code", 479 | "execution_count": 2, 480 | "metadata": {}, 481 | "outputs": [ 482 | { 483 | "name": "stdout", 484 | "output_type": "stream", 485 | "text": [ 486 | "El número 10 no corresponde a una vocal minúscula en código ASCII\n" 487 | ] 488 | } 489 | ], 490 | "source": [ 491 | "x : int\n", 492 | "x = int(input(\"Ingrese un número entero: \"))\n", 493 | "if x==97 or x==101 or x==105 or x==111 or x==117:\n", 494 | " print(\"El número \" + str(x) + \" corresponde a una vocal minúscula en código ASCII\")\n", 495 | "else:\n", 496 | " print(\"El número \" + str(x) + \" no corresponde a una vocal minúscula en código ASCII\")" 497 | ] 498 | }, 499 | { 500 | "cell_type": "code", 501 | "execution_count": 2, 502 | "metadata": {}, 503 | "outputs": [ 504 | { 505 | "name": "stdout", 506 | "output_type": "stream", 507 | "text": [ 508 | "El cuadrado de 10.0 es 100.0\n" 509 | ] 510 | } 511 | ], 512 | "source": [ 513 | "def elevarCuadrado(x:float):\n", 514 | " return x**2\n", 515 | "\n", 516 | "if __name__ == \"__main__\":\n", 517 | " x = float(input(\"Ingrese un numero real:\"))\n", 518 | " xSquared = elevarCuadrado(x)\n", 519 | " print(\"El cuadrado de \" + str(x) + \" es \" +str(xSquared))" 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": 3, 525 | "metadata": {}, 526 | "outputs": [ 527 | { 528 | "name": "stdout", 529 | "output_type": "stream", 530 | "text": [ 531 | "El area del rectagulo es 50.0\n" 532 | ] 533 | } 534 | ], 535 | "source": [ 536 | "def calcularAreaRectangulo(base:float, altura:float) -> float:\n", 537 | " areaRectangulo = base*altura\n", 538 | " return areaRectangulo\n", 539 | "\n", 540 | "if __name__ == \"__main__\":\n", 541 | " base = float(input(\"Ingrese base del rectangulo:\"))\n", 542 | " altura = float(input(\"Ingrese altura del rectangulo:\"))\n", 543 | " area = calcularAreaRectangulo(base, altura)\n", 544 | " print(\"El area del rectagulo es \" + str(area))" 545 | ] 546 | }, 547 | { 548 | "cell_type": "code", 549 | "execution_count": 12, 550 | "metadata": {}, 551 | "outputs": [ 552 | { 553 | "name": "stdout", 554 | "output_type": "stream", 555 | "text": [ 556 | "300\n", 557 | "300\n" 558 | ] 559 | } 560 | ], 561 | "source": [ 562 | "x = 300\n", 563 | "\n", 564 | "def myfunc():\n", 565 | " print(x)\n", 566 | "\n", 567 | "myfunc()\n", 568 | "\n", 569 | "print(x)\n" 570 | ] 571 | }, 572 | { 573 | "cell_type": "code", 574 | "execution_count": 13, 575 | "metadata": {}, 576 | "outputs": [ 577 | { 578 | "name": "stdout", 579 | "output_type": "stream", 580 | "text": [ 581 | "200\n", 582 | "300\n" 583 | ] 584 | } 585 | ], 586 | "source": [ 587 | "x = 300\n", 588 | "\n", 589 | "def myfunc():\n", 590 | " x = 200\n", 591 | " print(x)\n", 592 | "\n", 593 | "myfunc()\n", 594 | "\n", 595 | "print(x)" 596 | ] 597 | }, 598 | { 599 | "cell_type": "code", 600 | "execution_count": 14, 601 | "metadata": {}, 602 | "outputs": [ 603 | { 604 | "name": "stdout", 605 | "output_type": "stream", 606 | "text": [ 607 | "300\n" 608 | ] 609 | } 610 | ], 611 | "source": [ 612 | "def myfunc():\n", 613 | " global x\n", 614 | " x = 300\n", 615 | "\n", 616 | "myfunc()\n", 617 | "\n", 618 | "print(x)" 619 | ] 620 | }, 621 | { 622 | "cell_type": "code", 623 | "execution_count": 15, 624 | "metadata": {}, 625 | "outputs": [ 626 | { 627 | "name": "stdout", 628 | "output_type": "stream", 629 | "text": [ 630 | "200\n" 631 | ] 632 | } 633 | ], 634 | "source": [ 635 | "x = 300\n", 636 | "\n", 637 | "def myfunc():\n", 638 | " global x\n", 639 | " x = 200\n", 640 | "\n", 641 | "myfunc()\n", 642 | "\n", 643 | "print(x)" 644 | ] 645 | }, 646 | { 647 | "cell_type": "code", 648 | "execution_count": 16, 649 | "metadata": {}, 650 | "outputs": [ 651 | { 652 | "name": "stdout", 653 | "output_type": "stream", 654 | "text": [ 655 | "Variable local Hola local\n" 656 | ] 657 | } 658 | ], 659 | "source": [ 660 | "def saludar():\n", 661 | " mensaje = \"Hola local\"\n", 662 | " print(\"Variable local\", mensaje)\n", 663 | "\n", 664 | "if __name__ == \"__main__\":\n", 665 | " saludar()" 666 | ] 667 | }, 668 | { 669 | "cell_type": "code", 670 | "execution_count": 17, 671 | "metadata": {}, 672 | "outputs": [ 673 | { 674 | "name": "stdout", 675 | "output_type": "stream", 676 | "text": [ 677 | "Variable global Hola global\n" 678 | ] 679 | } 680 | ], 681 | "source": [ 682 | "def saludar():\n", 683 | " global mensaje\n", 684 | " mensaje = \"Hola global\"\n", 685 | "\n", 686 | "if __name__ == \"__main__\":\n", 687 | " saludar()\n", 688 | " print(\"Variable global\", mensaje)" 689 | ] 690 | }, 691 | { 692 | "cell_type": "code", 693 | "execution_count": 18, 694 | "metadata": {}, 695 | "outputs": [ 696 | { 697 | "name": "stdout", 698 | "output_type": "stream", 699 | "text": [ 700 | "Variable local Hola global\n", 701 | "Variable global Hola global\n" 702 | ] 703 | } 704 | ], 705 | "source": [ 706 | "mensaje = \"Hola global\"\n", 707 | "def saludar():\n", 708 | " print(\"Variable local\", mensaje)\n", 709 | "\n", 710 | "if __name__ == \"__main__\":\n", 711 | " saludar()\n", 712 | " print(\"Variable global\", mensaje)" 713 | ] 714 | }, 715 | { 716 | "cell_type": "code", 717 | "execution_count": 19, 718 | "metadata": {}, 719 | "outputs": [ 720 | { 721 | "name": "stdout", 722 | "output_type": "stream", 723 | "text": [ 724 | "Variable local Hola local\n" 725 | ] 726 | } 727 | ], 728 | "source": [ 729 | "def saludar():\n", 730 | " mensaje = \"Hola local\"\n", 731 | " print(\"Variable local\", mensaje)\n", 732 | "\n", 733 | "if __name__ == \"__main__\":\n", 734 | " saludar()\n", 735 | " # print(\"Variable global\", mensaje) Quitar comentario y probar" 736 | ] 737 | }, 738 | { 739 | "cell_type": "code", 740 | "execution_count": null, 741 | "metadata": {}, 742 | "outputs": [], 743 | "source": [] 744 | }, 745 | { 746 | "cell_type": "code", 747 | "execution_count": null, 748 | "metadata": {}, 749 | "outputs": [], 750 | "source": [] 751 | }, 752 | { 753 | "cell_type": "code", 754 | "execution_count": null, 755 | "metadata": {}, 756 | "outputs": [], 757 | "source": [] 758 | } 759 | ], 760 | "metadata": { 761 | "kernelspec": { 762 | "display_name": "Python 3.10.10 64-bit", 763 | "language": "python", 764 | "name": "python3" 765 | }, 766 | "language_info": { 767 | "codemirror_mode": { 768 | "name": "ipython", 769 | "version": 3 770 | }, 771 | "file_extension": ".py", 772 | "mimetype": "text/x-python", 773 | "name": "python", 774 | "nbconvert_exporter": "python", 775 | "pygments_lexer": "ipython3", 776 | "version": "3.10.10" 777 | }, 778 | "orig_nbformat": 4, 779 | "vscode": { 780 | "interpreter": { 781 | "hash": "26de051ba29f2982a8de78e945f0abaf191376122a1563185a90213a26c5da77" 782 | } 783 | } 784 | }, 785 | "nbformat": 4, 786 | "nbformat_minor": 2 787 | } 788 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Programación de Computadores - UNAL 2 | 3 | ## Tabla de Contenidos 4 | - [Identificadores y Variables](#identificadores-variables-y-operadores) 5 | - [Formas de Escribir Identificadores](#formas-de-escribir-idenfificadores-en-python) 6 | - [Ejemplos de Identificadores](#ejemplos-de-identificadores-válidos) 7 | - [Convenciones de Nomenclatura](#casing) 8 | - [Lowercase](#lowercase) 9 | - [Uppercase](#uppercase) 10 | - [Camelcase](#camelcase) 11 | - [Snakecase](#snakecase) 12 | - [Variables](#variables) 13 | - [Variables en Python](#variables-en-python) 14 | - [Tipado en Python](#tipado-estático-vs-tipado-dinámico) 15 | - [Tipos de Datos](#tipos-de-datos) 16 | - [Enteros](#enteros) 17 | - [Flotantes](#flotantes) 18 | - [Constantes](#constantes) 19 | - [Booleanos](#booleanos) 20 | - [Caracteres y Strings](#caracteres-y-cadenas-de-caracteres) 21 | - [Operadores](#operadores) 22 | - [Operadores Aritméticos](#operadores-aritméticos) 23 | - [Operadores de Asignación](#operadores-de-asignación) 24 | - [Operadores Lógicos](#operadores-lógicos) 25 | - [Operadores Relacionales](#operadores-relacionales) 26 | - [Precedencia de Operaciones](#precedencia-de-opearaciones) 27 | 28 | ## Identificadores, variables y operadores 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 |
Definición
Un identificador es una secuencia de símbolos que se utilizan como nombres de variables, funciones, arreglos, clases y otras estructuras de los lenguajes de programación.
37 | 38 | Formas de escribir idenfificadores en Python: 39 | + secuencias de caracteres alfanuméricos del alfabeto inglés 40 | + Usando ( _ ) *underscore* - *guión bajo* 41 | + No usar espacios 42 | + No usar caracteres especiales ($, &, *, #) 43 | + No iniciar con valores numéricos y de *preferencia* no incorporarlos 44 | + NO ser una palabra reservada del lenguaje. 45 | 46 |
47 |

48 |
Palabras reservadas de Python
49 |
50 | 51 |
Ejemplos de identificadores válidos

52 | 53 | 54 | 73 | 74 |
55 |

56 | i
57 | x
58 | n
59 | suma
60 | sumando1
61 | sumando2
62 | Edad
63 | paisDeNacimiento
64 | _nombre
65 | area_circulo
66 | false
67 | Variable
68 | snake_case
69 | MACRO_CASE
70 | camelCase
71 | CapWords
72 |

75 |


76 | 77 |
Ejemplos de identificadores inválidos

78 | 79 | 80 | 91 | 92 |
81 |

82 | 1er_mes
83 | primer nombre
84 | while
85 | p@dre
86 | día
87 | velocidad-maxima
88 | True
89 | Var#1
90 |

93 |


94 | 95 | ## Casing 96 | Es el uso de mayusculas y minusculas (así como otros caracteres). Python es *sensitive case*, lo que significa que distingue entre mayúsculas y minúsculas., *e.g.* No es o mismo variable a VARIABLE. 97 | 98 | ### Lowercase 99 | Es el uso exclusivo de mínusculas. 100 | 101 | ### Uppercase 102 | Es el uso exclusivo de mayusculas. 103 | 104 | ### Camelcase 105 | Consiste en la capitalización de la inicial de cada palabra compuesta excepto la inicial. El cambio entre minúsculas y mayúsculas se asemeja a las jorobas de un camello. 106 | 107 | Ejemplos: 108 | + soyUnNumero 109 | + cantidadEstudiantesClase 110 | + letrasAlfabeto 111 | + sumaElementosInternos 112 | + linAlgebraDotProduct 113 | 114 | Esta notación se usa principalmente en C, C++, Java, JavaScript y hay un debate pero en Python también. 115 | 116 | ### Snakecase 117 | Consite en el uso de *underscore* para separar las palabras en una entidad compuesta, la cual estará siempre en minúscula. Las secciones se asemejan a las partes de una serpiente (?. 118 | 119 | Ejemplos: 120 | + soy_un_numero 121 | + cantidad_estudiantes_clase 122 | + letras_alfabeto 123 | + suma_elementos_internos 124 | + lin_algebra_dot_product 125 | 126 | Esta notación se usa principalmente en Ruby, PHP y hay un debate pero en Python también. 127 | 128 | Hay otra que se llama *kebab case*, así que revisen. 129 | 130 | **Entonces,** cúal usar?....para Python **snake-case**. 131 | 132 | ## Variables 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 |
Definición
Una variable es un espacio de memoria donde se almacena un dato, un espacio donde se guarda la información necesaria para realizar las acciones que ejecutan los programas.
141 | 142 |
143 |

144 |
Representación física de una variable.
145 |
146 | 147 | ### Variables en python 148 | Para declarar una variable se necesitan principalmente dos componentes: 149 | el nombre y el tipo de dato. 150 | 151 | ```python 152 | nombre_variable : 153 | ``` 154 | ### Tipado estático vs tipado dinámico 155 | Ya que python es un lenguaje interpretado soporta tipado dinámico, esto es, para que un programa funcione *no* es necesario especificar el tipo de la variable, porque en tiempo de ejecución se va cambiando el espacio en memoria necesario para alojar la información. 156 | 157 | Para el programador esto se puede considerar algo *sencillo*, ya que solo declara variables y el interprete hace el resto, sin embargo esto es una *mala práctica*. Por lectura, por eficiencia, por elegancia, es mejor hacer tipado estático, es decir especificar el tipo de variable, para reservar el espacio adecuado en memoria. La mayoría de lenguajes compilados usa tipado estático. 158 | 159 | **Pro tip:** Una buena práctica de programación∗ es asignarle el nombre a una variable de tal manera que indique por un lado el papel que desempeña dicha variable en el algoritmo y por otro los posibles valores que almacena. 160 | 161 |
162 |

163 |
Ejemplos de nombres para variables.
164 |
165 | 166 | ## Tipos de datos 167 | ### Enteros 168 | Si x es una variable algebraica que varia en el conjunto Z, para definir x 169 | en el lenguaje Python se utiliza la expresión: 170 | 171 | ```python 172 | x : int 173 | ``` 174 | ### Declarar vs Inicializar 175 | **Declarar:** Consiste en nombrar la variable y *declarar* su tipo, sin especificar un valor inicial. 176 | 177 | **Inicializar:** Consiste en dar un valor inicial luego de declarar una variable. 178 | 179 | ```python 180 | # Declarar variable 181 | x : int 182 | # Inicializar variable 183 | x = 10 184 | # Declarar e inicializar variable 185 | x : int = 10 186 | ``` 187 | **Pro tip:** Para dar valor a una variable, se utiliza el operador de *asignación*, un = (signo igual). 188 | 189 | **Pro tip:** Para poner comentarios en el código de python se utiliza # (asterisco), todo lo que está comentado no será tenido en cuenta en el programa. Comentar es **FUNDAMENTAL** para entender el code. 190 | 191 | En Python no hay una distinción tan clara de la cantidad de espacio que usa un entero, en lenguajes como C se tienen `int8`, `uint16`, `long`, donde se especifican la cantidad de bits para almacenar la variable. Si se quiere consultar la cantidad de bits y la representación binaria se puede usar. 192 | 193 | ```python 194 | # Declarar e inicializar variable 195 | x : int = 10 196 | # Cantidad de bits 197 | print(x.bit_length) 198 | # Representacion binaria 199 | print(bin(x)) 200 | ``` 201 | ### Flotantes 202 | Si x es una variable algebraica que varia en el conjunto R, para definir x 203 | en el lenguaje Python se utiliza la expresión: 204 | 205 | ```python 206 | x : float 207 | ``` 208 | 209 | El subconjunto de los n´umeros reales que pueden ser representados en el lenguaje Python, es un subconjunto propio de los racionales, que se representan con 64 bits (8 bytes) y que usan un tipo de codificación definida por el IEEE standard for Binary Floating-Point Arithmetic 754 de 1985, los valores distintos de 0 de este conjunto varían en el rango: 210 | 211 | $$−1.7976931348623157\cdot10^{+308} ≤ x ≤ −2.2250738585072014\cdot10^{−308}$$ 212 | 213 | y 214 | 215 | $$2.2250738585072014\cdot10^{−308} ≤ x ≤ 1.7976931348623157\cdot10^{+308}$$ 216 | 217 | Los n´umeros reales de máquina son finitos y por lo tanto, existen n´umeros 218 | reales que no se pueden representar. Además, la mayoría de los n´umeros se acumulan alrededor del 0 y hacia los extremos superior e inferior se encuentran más dispersos. 219 | 220 | Ejemplos de flotantes: 221 | ```python 222 | e = 2.7182818284 223 | gamma : float = 0.577215664901 224 | phi = +1.61803398874989 225 | X = -1.0 226 | const_Boltzmann = 1.3806488e-23 227 | Luz : float = 2.998e+8 228 | Avogadro = +6.02214129e+23 229 | G : float = 6.67384e-11 230 | Plank = 6.62606896e-34 231 | ``` 232 | 233 | ### Constantes 234 | A diferencia de C, Java o Javascript, en Python no hay constantes perse, se suele declarar una variable global en *snake case* mayúsculas para indicar que se trata de un valor persistente. 235 | 236 | ```python 237 | MAIN_VALUE = 10 238 | CONST_FREQ = 500.56 239 | ``` 240 | 241 | ### Booleanos 242 | Si x es una variable algebraica que varia en el conjunto B, para definir x 243 | en el lenguaje Python se utiliza la expresión: 244 | 245 | ```python 246 | x : bool 247 | ``` 248 | 249 | El conjunto de los booleanos tiene dos componentes: $$B = \{V,F\}$$ 250 | 251 | En python: 252 | $$V\rightarrow True \ \ \ \ \ \ \ F\rightarrow False $$ 253 | 254 | Ejemplos de booleanos: 255 | ```python 256 | b = True 257 | flag: bool = True 258 | exp = False 259 | isPrime: bool = False 260 | ``` 261 | 262 | **Pro trip:** En Python la representación interna de los valores booleanos se hace mediante el uso de valores enteros int de 32 bits de la siguiente manera: 263 | el valor lógico F se representa con el entero 0 (cero) y el valor lógico V se representa con cualquier entero distinto de 0, por costumbre se usa el entero 1 (uno). De lo anterior se obtienen las siguientes equivalencias lógicas: 264 | 265 | $$True \Longleftrightarrow 1 \ \ \ \ \ \ \ \ False \Longleftrightarrow 0$$ 266 | 267 | ### Caracteres y cadenas de caracteres 268 | Un carácter es el elemento mínimo de información usado para representar, 269 | controlar, transmitir y visualizar datos. Al conjunto de caracteres usados 270 | con este fin se le llama Esquema de codificación. Los esquemas de 271 | codificación en general usan un n´umero de bits o bytes fijos. Por ahora solo 272 | consideraremos el ASCII. En Python son representados como cadenas de 273 | caracteres de un sólo carácter. 274 | 275 |
276 |

277 |
Tabla de caracteres con equivalente en ASCII.
278 |
279 | 280 | Código Estadounidense Estándar para el Intercambio de Información 281 | (American Standard Code for Information Interchange): 282 | 283 | + En su versión original usa 7 bits, definiendo 128 caracteres. 284 | + En la versión extendida usa 8 bits (esto es 1 byte), definiendo 256 caracteres. 285 | + Es la base de los archivos de texto plano (o sin formato). 286 | + Es el esquema base para la escritura de programas en casi todos los lenguajes de programación (incluido Python) 287 | 288 | Las variables tipo caracter se definen usando comillas dobles ("") o sencillas (''). 289 | 290 | Ejemplos: 291 | ```python 292 | char1 = "a" 293 | char2 = 'x' 294 | ``` 295 | Para convertir de caracter a ASCII se emplea la función *ord()* y para convertir de ASCII a caracter *chr()*. 296 | 297 | ```python 298 | ord('a') 299 | ``` 300 | 301 | ```python 302 | chr(97) 303 | ``` 304 | 305 | ### Cadenas de caracteres o Strings 306 | Una **cadena de caracteres** *str* es una secuencia de cero o más caracteres. Una cadena de caracteres se delimita por el carácter ' o por el carácter ". Una cadena de caracteres es una estructura de datos **inmutable**, esto significa que no puede ser cambiada. 307 | 308 | + 'ejemplo de cadena' 309 | + "Cadena con un tabulado \t y una nueva \n línea" 310 | + 'Cadena con un carácter unicode \u01F4 y una comilla doble"' 311 | + "Cadena con una comilla simple \’, una comilla doble \" y una diagonal invertida \\" 312 | + La cadena vacía "" o '' 313 | 314 | **Pro tip:** Diferencia entre "" y '', en general se utiliza doble comilla en caso que el string contenga comillas sencillas. 315 | 316 | ## Operadores 317 | Es la manera de establecer relaciones (operaciones) entre los tipos de variables. 318 | 319 | + **Operadores infijos:** Se aplican entre los operandos. 320 | + **Operadores prefijos:** Se aplica antes del operando. 321 | + **Operadores sufijos:** Se aplica después del operando. 322 | 323 | ### Operadores aritméticos 324 | Se aplican a los datos de tipo numérico (luego veremos que algunos se pueden sobrecargar a otras estructuras de datos). 325 | 326 | + **Suma:** Usa el simbolo (+) y obtiene la suma de dos o más valores. 327 | ```python 328 | # Suma de dos numeros 329 | 4 + 1 # Entero + Entero = Entero 330 | 4.0 + 1 # Real + lo que sea = Real 331 | ``` 332 | + **Resta:** Usa el simbolo (-), representa la sustracción cuando está entre dos operandos (infijo) o la negación (cambio de signo) cuando predece al oeprando (prefijo). 333 | ```python 334 | # Sustacción de dos numeros 335 | 4 - 1 # Entero - Entero = Entero 336 | -1 # Cambio de signo 337 | ``` 338 | + **Multiplicación:** Usa el simbolo (*) y obtiene el producto entre dos o más valores. 339 | ```python 340 | # Producto de dos numeros 341 | 4 * 2.0 # Entero * Real = ? 342 | ``` 343 | + **División:** Usa el símbolo (/) y retorna la división exacta. 344 | ```python 345 | # División de dos numeros 346 | 4 / 2 # Entero / Entero = ? 347 | 4.0 / 2 # Real / Entero =? 348 | 4.0 / 0 # Tan tan tan 349 | ``` 350 | + **División Entera:** Usa el símbolo (//) y retorna la parte entera de la división exacta. 351 | ```python 352 | # División exactas de dos numeros 353 | 5 // 2 # Entero / Entero = ? 354 | 5.0 // 2 # Real / Entero =? 355 | ``` 356 | + **Módulo:** Usa el símbolo (%) y retorna el residuo de la divisón entre dos números. 357 | $$m \ \text{mod} \ n = r \Longrightarrow \frac{m}{n}=c+r$$ 358 | ```python 359 | # modulo entre dos números 360 | 10 % 2 # Entero % Entero = ? 361 | 5.0 % 2 # Real / Entero =? 362 | ``` 363 | + **Potencia:** Usa el símbolo (**) y retorna elevar a una cierta potencia un operando. Importante: NO se usa el símbolo (^) -> Acento circunflejo (Hay gente que le dice el sombrerito...que falta de nivel). 364 | ```python 365 | # potencias entre dos números 366 | 5**2 # Cuadrados 367 | 5**3 # Cubos 368 | 81**0.5 # Raíces 369 | ``` 370 | ### Operadores de asignación 371 | + **Asignación:** Usa el simbolo (=). La parte de la izquierda que debe ser una variable. Sirve para almacenar un dato en una variable. Asigna el valor de evaluar la parte de la derecha a la variable de la parte de la izquierda. 372 | ```python 373 | pi : float = 3.14169265 374 | ``` 375 | + **Asignación con suma:** Usa el simbolo (+=). La parte de la izquierda debe ser una variable. Suma la evaluación de parte de la derecha con el valor almacenado en la variable definida en la parte de la izquierda y guarda el resultado en la variable de parte de la izquierda. 376 | ```python 377 | x : int = 1 378 | x += 1 # Equivalente a x = x + 1 379 | ``` 380 | Las asignaciones con operación no se pueden utilizar dentro de uan expresión (e.g. un ciclo), son operaciones en sí mismas. 381 | 382 | + **Asignación con resta:** Usa el simbolo (-=). La parte de la izquierda debe ser una variable. Resta al valor almacenado en la variable definida en la parte de la izquierda el resultado de la evaluación de parte de la derecha y guarda el resultado en la variable de parte de la izquierda. 383 | ```python 384 | x : int = 2 385 | x -= 1 # Equivalente a x = x - 1 386 | ``` 387 | + **Asignación con multiplicación:** Usa el simbolo (*=). La parte de la izquierda debe ser una variable. Multiplica el valor almacenado en la variable definida en la parte de la izquierda con la evaluación de parte de la derecha y guarda el producto en la variable de parte de la izquierda. 388 | ```python 389 | x : int = 4 390 | x *= 3 # Equivalente a x = x * 3 391 | ``` 392 | + **Asignación con división:** Usa el simbolo (/=). La parte de la izquierda debe ser una variable. Divide el valor almacenado en la variable definida en la parte de la izquierda entre el valor de la evaluación de la parte de la derecha y guarda el resultado en la variable de parte de la izquierda. 393 | ```python 394 | x : int = 4 395 | x /= 2 # Equivalente a x = x / 2 396 | ``` 397 | + **Asignación con división entera:** Usa el simbolo (//=). La parte de la izquierda debe ser una variable. Divide de forma entera el valor almacenado en la variable definida en la parte de la izquierda entre el valor de la evaluación de la parte de la derecha y guarda el resultado entero en la variable de parte de la izquierda. 398 | ```python 399 | x : int = 8 400 | x //= 4 # Equivalente a x = x // 4 401 | ``` 402 | + **Asignación con residuo:** Usa el simbolo (%=). La parte de la izquierda debe ser una variable. Calcula el residuo de dividir el valor almacenado en la variable definida en la parte de la izquierda entre el valor de la evaluación de la parte de la derecha y guarda el resultado en la variable de parte de la izquierda. 403 | ```python 404 | x : int = 8 405 | x %= 4 # Equivalente a x = x % 4 406 | ``` 407 | 408 | **Ejemplo:** Calcular la fuerza de atracción entre la tierra y un cuerpo sobre su superficie. 409 | $$\text{Ley de la gravitación universal:} \ =G\frac{m_1 \cdot m_2}{r^2}$$ 410 | 411 | ```python 412 | G : float = 6.67384e-11 # Constante de Cavendish [Nm^2/kg^2] 413 | m1 : float = 5.972e+24 # Masa de la Tierra [kg] 414 | m2 : float = 58 # Masa de alguna victima 415 | r : float = 6400e3 # Radio de la Tierra [m] 416 | ``` 417 | 418 | ```python 419 | # Solución 1 420 | F = G * m1 * m2 / r * r 421 | ``` 422 | ```python 423 | # Solución 2 424 | F = G * m1 * m2 / r^2 425 | ``` 426 | ```python 427 | # Solución 3 428 | F = G * m1 * m2 / r**2 429 | ``` 430 | ### Operadores lógicos 431 | Permiten determinar juicios de valor sobre proposiciones lógicas, su resultando es un booleano. 432 | 433 | + **Igualdad:** Evalua si dos variables son iguales. Se usa el simbolo (==). 434 | $$ \alpha == \beta \Longleftrightarrow \alpha = \beta$$ 435 | ```python 436 | alpha : int = 10 437 | beta : int = 10 438 | alpha == beta 439 | ``` 440 | 441 | + **Diferencia:** Evalua si dos variables son diferentes. Se usa el simbolo (!=). 442 | $$\alpha\ != \beta \Longleftrightarrow \alpha \neq \beta$$ 443 | ```python 444 | alpha : int = 10 445 | beta : int = 11 446 | alpha != beta 447 | ``` 448 | 449 | + **Mayor estricto:** Evalua si la variable de la izquierda es mayor que la de la derecha. Se usa el simbolo (>). 450 | $$\alpha\ > \beta \Longleftrightarrow \alpha > \beta$$ 451 | ```python 452 | alpha : int = 10 453 | beta : int = 11 454 | alpha > beta 455 | ``` 456 | 457 | + **Menor estricto:** Evalua si la variable de la izquierda es menor que la de la derecha. Se usa el simbolo (<). 458 | $$\alpha\ < \beta \Longleftrightarrow \alpha < \beta$$ 459 | ```python 460 | alpha : int = 10 461 | beta : int = 11 462 | alpha < beta 463 | ``` 464 | 465 | + **Mayor igual:** Evalua si la variable de la izquierda es mayor o igual que la de la derecha. Se usa el simbolo (>=). 466 | $$\alpha\ >= \beta \Longleftrightarrow \alpha \geq \beta$$ 467 | ```python 468 | alpha : int = 10 469 | beta : int = 10 470 | alpha >= beta 471 | ``` 472 | 473 | + **Menor igual:** Evalua si la variable de la izquierda es menor o igual que la de la derecha. Se usa el simbolo (<=). 474 | $$\alpha\ <= \beta \Longleftrightarrow \alpha \leq \beta$$ 475 | ```python 476 | alpha : int = 9 477 | beta : int = 10 478 | alpha <= beta 479 | ``` 480 | ### Operadores relacionales 481 | Permiten aplicar operaciones boolenas (no se preocupen en Digital lo van a ver en detalle), en general es evaluar juicios de valor compuestos. 482 | 483 | + **Conjunción/AND:** Permite evaluar la operación *and* (y en español). Se utiliza la palabra reservada *and*. 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 |
ABAND(A,B)
000
010
100
111
511 | 512 | ```python 513 | 1 and 0 514 | True and False 515 | ``` 516 | **Pro tip:** Los que hayan programado en otros lenguajes sabran que el simbolo & (ampersand) representa la operación AND, pero en Python es a un nivel binario, esto es si se aplica con valores numéricos, estos se transformarán a bits y se aplicará la operación. 517 | 518 | + **Disyunción/OR:** Permite evaluar la operación *or* (o en español). Se utiliza la palabra reservada *or*. 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 |
ABOR(A,B)
000
011
101
111
547 | 548 | ```python 549 | 1 or 0 550 | True or False 551 | ``` 552 | 553 | **Pro tip:** Los que hayan programado en otros lenguajes sabrán que el simbolo | (vertical line) representa la operación OR, pero en Python es a un nivel binario, esto es si se aplica con valores numéricos, estos se transformarán a bits y se aplicará la operación. 554 | 555 | + **Negación/NOT:** Permite evaluar la operación *not*. Se utiliza la palabra reservada *not*. 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 |
ANOT(A)
01
10
570 | 571 | ```python 572 | not 0 573 | not False 574 | ``` 575 | 576 | **Pro tip:** Los que hayan programado en otros lenguajes sabran que el simbolo ~ (virgulilla) representa la operación NOT, pero en Python es a un nivel binario, esto es si se aplica con valores numéricos, estos se transformarán a bits y se aplicará la operación. 577 | 578 | **Ejemplo:** Establecer la relación lógica que permita determinar si un una pareja ordenada `(a,b)` pertenece al conjunto `[-2,3.5) x (-1.25,1.5] U {(x,y):x^2+y^2 <= 1}`. 579 |
580 |

581 |
582 |
583 | 584 | ```python 585 | # Lo que está dentro del rectangulo 586 | a > -2 and a <= 3.5 587 | b >= -1.25 and b < 1.5 588 | # Lo que está fuera del circulo 589 | a * a + b * b >= 1 590 | # Uniendo los dos conjuntos 591 | (a > -2 and a <= 3.5 and b >= -1.25 and b < 1.5) and (a * a + b * b >= 1) 592 | ``` 593 | 594 | ### Precedencia de opearaciones 595 | En la siguiente tabla se presenta la prioridad de los principales operadores 596 | de Python, la prioridad más alta es la 1 y la más baja es la 9. Si dos operaciones tienen la misma prioridad se resuelve de izquierda a derecha. 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 |

Operador(es)

Prioridad
()1
not       -(signo menos)       +(signo más)       **(potencia)2
*       /       //       %3
+       -4
<       >       <=       >=5
==       ~=6
and7
or8
=       +=       -=       *=       /=       //=       %=9
640 | 641 | **Ejemplos:** 642 | 1. Resolver la expresión `42 // 6 + 7 * 3 - 39` y determinar el orden de cada operación. 643 | 644 | ```python 645 | 42 // 6 + 7 * 3 - 39 646 | # // y * prioridad 3 647 | # + y - prioridad 4 648 | # 42 // 6 + 7 * 3 - 39 -> (((42 // 6) + (7 * 3)) - 39) 649 | # Paso 1 650 | 42 // 6 # Resultado 7 651 | # Paso 2 652 | 7 * 3 # Resultado 21 653 | # Paso 3 654 | 7 + 21 - 39 # Resultado -11 655 | ``` 656 | 657 | 2. Resolver la expresión `12.0 * 3 - -4.0 + 8 // 2 % 3` y determinar el orden de cada operación. 658 | 659 | ```python 660 | 12.0 * 3 - -4.0 + 8 // 2 % 3 661 | # -(signo menos) prioridad 2 662 | # *, //, y % prioridad 3 663 | # - y + prioridad 4 664 | # 12.0 * 3 - -4.0 + 8 // 2 % 3 -> (((12.0 * 3) - (-4.0)) + ((8 // 2) % 3)) 665 | # Paso 1 666 | -(-4.0) # Resultado +4.0 667 | # Paso 2 668 | 12.0 * 3 # Resultado 36.0 669 | # Paso 3 670 | 8 // 2 # Resultado 4 671 | # Paso 4 672 | 4 % 3 # Resultado 1 673 | # Paso 5 674 | 36.0 + 4.0 + 1 # Resultado 41.0 675 | ``` 676 | 677 | 3. Resolver la expresión `(-2 + 5 % 3 * 4) // 4 + 2` y determinar el orden de cada operación. 678 | 679 | ```python 680 | (-2 + 5 % 3 * 4) // 4 + 2 # Resultado 3.0 681 | ``` 682 | 683 | ----- 684 | 685 | ### Información adicional 686 | - [Python Documentation](https://docs.python.org/3/) 687 | 688 | ### Guías de Estilo y Buenas Prácticas 689 | - [PEP 8 - Style Guide for Python Code](https://peps.python.org/pep-0008/) 690 | - [Convenciones de Nomenclatura](https://peps.python.org/pep-0008/#naming-conventions) 691 | - [Comentarios](https://peps.python.org/pep-0008/#comments) 692 | 693 | ------ 694 | 695 | ### Ejercicios recomendados: 696 | 697 | - [Operadores Aritmeticos](https://www.hackerrank.com/challenges/python-arithmetic-operators/problem?isFullScreen=true) 698 | - [Division](https://www.hackerrank.com/challenges/python-division/problem?isFullScreen=true) 699 | 700 | 701 | --------------------------------------------------------------------------------