PYTHON
2 PYTHON ÍNDICE INTRODUCCIÓN A PYTHON ................................................................................. 6 Conceptos básicos............................................................................................... 6 ¿Qué es Python? ............................................................................................. 6 ¿Qué es un lenguaje de programación? .......................................................... 7 Lenguaje de programación de bajo nivel.......................................................... 8 Lenguaje de programación de alto nivel........................................................... 8 Lenguaje de programación interpretado........................................................... 9 Lenguaje de programación compilado ............................................................. 9 Paradigmas de programación ........................................................................ 10 Código abierto................................................................................................ 10 Instalación de Python......................................................................................... 11 Página oficial de Python................................................................................. 11 Descargando Python:..................................................................................... 12 Instalando Python .......................................................................................... 12 Comprobar Instalación ................................................................................... 15 Python como una calculadora............................................................................ 15 Números......................................................................................................... 15 Variables ............................................................................................................ 17 Operaciones con variables............................................................................. 18 Obtener el área de un cuadrado .................................................................... 18 Obtener el área de un rectángulo................................................................... 19 Solución de la ecuación cuadrática................................................................ 19 Variable sin asignar valor............................................................................... 20 Recuperar último valor mostrado ................................................................... 20 Funciones básicas ............................................................................................. 21 Uso de funciones básicas .............................................................................. 22 Cadenas de caracteres ...................................................................................... 23 Comillas simples y dobles .............................................................................. 23 Carácter de escape........................................................................................ 23
3 PYTHON Función print( )............................................................................................... 24 Comentarios (#) ............................................................................................. 26 Operaciones básicas con cadenas de caracteres.......................................... 27 Función len( ) ................................................................................................. 30 Listas.................................................................................................................. 31 Editor PyCharm.................................................................................................. 34 CONTROL DE FLUJO .......................................................................................... 41 Bucle While ........................................................................................................ 41 La sentencia if ................................................................................................. 43 La sentencia for ............................................................................................... 44 La función range() .......................................................................................... 46 Sentencias break, continue, y else en bucles............................................. 48 La sentencia pass ............................................................................................. 49 La sentencia match........................................................................................... 50 FUNCIONES ......................................................................................................... 53 Definiendo funciones.......................................................................................... 53 Funciones matemáticas (math).......................................................................... 55 La librería de datos aleatorios (random) ............................................................ 57 Argumentos con valores por omisión................................................................. 58 Palabras claves como argumentos .................................................................... 60 Parámetros especiales....................................................................................... 62 Argumentos posicionales o de palabras claves ................................................. 62 Parámetros únicamente posicionales ............................................................ 62 Argumentos únicamente de palabras clave ................................................... 62 Ejemplos de Funciones...................................................................................... 63 Resumen del uso de funciones.......................................................................... 65 Listas de argumentos arbitrarios........................................................................ 65 Desempaquetando una lista de argumentos...................................................... 66 Expresiones lambda........................................................................................... 67 Cadenas de texto de documentación................................................................. 67 Anotación de funciones...................................................................................... 68 Estilo de codificación.......................................................................................... 69
4 PYTHON MÓDULOS ............................................................................................................ 70 Importar Módulos ............................................................................................... 71 Ejecutando módulos como scripts...................................................................... 73 El camino de búsqueda de los módulos............................................................. 73 Archivos «compilados» de Python ..................................................................... 74 Módulos estándar............................................................................................... 75 La función dir()............................................................................................... 76 Paquetes........................................................................................................ 79 Importando * desde un paquete......................................................................... 81 Referencias internas en paquetes ..................................................................... 82 Paquetes en múltiples directorios ...................................................................... 82 ENTRADAS Y SALIDAS ....................................................................................... 83 Formateo elegante de la salida.......................................................................... 83 Formatear cadenas literales............................................................................... 85 El método format() de cadenas.......................................................................... 86 Formateo manual de cadenas ........................................................................... 88 Viejo formateo de cadenas ................................................................................ 89 Leyendo y escribiendo archivos......................................................................... 89 Métodos de los objetos Archivo ......................................................................... 90 Guardar datos estructurados con json ............................................................... 92 ERRORES Y EXCEPCIONES .............................................................................. 94 Errores de sintaxis ............................................................................................. 94 Excepciones....................................................................................................... 94 Gestionando excepciones.................................................................................. 95 Lanzando excepciones ...................................................................................... 98 Encadenamiento de excepciones ...................................................................... 99 Excepciones definidas por el usuario............................................................... 100 Definiendo acciones de limpieza...................................................................... 101 Acciones predefinidas de limpieza................................................................... 102
5 PYTHON OBJETIVO GENERAL Se adquirirán las habilidades básicas de programación necesarias para realizar programas que resuelvan problemas comunes de alumnas y alumnos de nivel media superior. También se desarrollarán las habilidades lógicas matemáticas mediante la creación de programas, usando el lenguaje de programación Python. INTRODUCCIÓN Los lenguajes de programación son herramientas muy versátiles que podemos utilizarlas prácticamente en cualquier área del conocimiento. En este documento trataremos uno de los lenguajes más utilizados y de tendencia creciente en su uso en los últimos años. Hablamos del lenguaje de programación Python. Cuando programamos, y lo hacemos un hábito, se desarrolla la habilidad lógicamatemática debido a que siempre estamos pensando en la toma de decisiones y en algoritmos para resolver una problemática real. Los problemas que podemos resolver mediante la programación pueden ser tan sencillos como el llevar el control de flujo de una operación hasta la creación de videojuegos. Python es uno de los lenguajes más populares hoy en día y su área de aplicación es muy amplia y sigue creciendo. Lo podemos usar simplemente como una calculadora, pero también lo podríamos usar para desarrollar páginas web. Otras aplicaciones podrían ser la programación de Microcontroladores y Sistemas Embebidos, o por qué no, como ya se mencionó, para la creación de videojuegos. Como podemos ver el aprender Python o cualquier otro lenguaje de programación no puede dar una ventaja competitiva ya sea como estudiante o como trabajador en una empresa. Pero cuidado, puede ser adictivo. Hay personas que no saben que es un lenguaje de programación y por ese motivo no es una opción al momento de decidir que estudiar. Pero una vez que se tienen los conocimientos básicos y se empieza a tener conciencia de la importancia de saber programar el gusto por la programación aumenta al grado de convertirse en un hábito importante.
6 PYTHON INTRODUCCIÓN A PYTHON Conceptos básicos ¿Qué es Python? Python es un lenguaje de programación, de alto nivel, interpretado, multiparadigma y de código abierto.
7 PYTHON ¿Qué es un lenguaje de programación? Un lenguaje de programación es un programa con el cual podemos escribir instrucciones que una computadora entienda y las pueda ejecutar. Existen muchos lenguajes de programación para propósitos diferentes. Principales usos: Internet de las Cosas, Inteligencia Artificial, Backend y Ciencia de Datos. Dato importante: Muchos de los programas, sistemas operativos, navegadores web, video juegos, están escritos en C++. Se usa principalmente en el desarrollo de páginas web dinámicas. Principalmente se usa en FrontEnd Se usa principalmente en el desarrollo web del lado del servidor (BackEnd) https://www.tiobe.com/tiobe-index/
8 PYTHON Lenguaje de programación de bajo nivel Son lenguajes de programación que tienen una relación cercana con el hardware de la máquina que se está programando. Algunos podrán tener la idea de que como se les llama de bajo nivel son menos eficientes que los de alto nivel, pero sorpresa es, al contrario. Esto se debe a que al estar relacionado íntimamente al hardware tienen una mejor compatibilidad y menor tiempo de ejecución. Pero cabe mencionar que estos tipos de lenguaje son más difíciles de programar. La desventaja de los lenguajes de bajo nivel es que no son claramente legibles por las personas. Se requiere de personal calificado. Lenguaje de programación de alto nivel Son lenguajes de programación que tienen una buena comprensión por las personas debido a que la escritura de sus instrucciones son básicamente palabras cuyo sentido lo podemos entender de manera clara. Por esta razón cualquier persona puede aprender a utilizar lenguajes de alto nivel.
9 PYTHON Lenguaje de programación interpretado Los lenguajes de programación interpretados son aquellos donde las instrucciones se leen y se ejecutan en “tiempo real”. Lo que significa que no pasan por un proceso de compilación previa a la ejecución. Su principal ventaja es la portabilidad ya que el mismo programa puede ser ejecutado en diferentes plataformas. Su principal desventaja es la velocidad de ejecución ya que la conversión al lenguaje máquina se hace en tiempo de ejecución. Lenguaje de programación compilado Los lenguajes de programación compilados son aquellos que necesitan ser compilados para que puedan ejecutarse. La compilación es el proceso mediante el cual el código que escribimos es convertido a código máquina. En otras palabras, el código que está escrito de manera que nosotros podemos entenderlo es convertido a una manera en que la máquina lo pueda entender. La principal ventaja es su velocidad de ejecución debido a que cuando se ejecuta el programa las instrucciones ya están convertidas a lenguaje máquina y no pierden tiempo en realizar dicha conversión en tiempo de ejecución. La principal desventaja es que debido a que está compilado bajo una plataforma determinada solo puede ser ejecutado en dicha plataforma.
10 PYTHON Paradigmas de programación El paradigma de programación es una manera en la que se pueden clasificar los lenguajes de programación de acuerdo con sus características. Código abierto El código abierto se refiere a que dicho código es compartido o distribuido libremente y cualquiera puede hacerle modificaciones con el fin de mejorarlo a beneficio de la comunidad.
11 PYTHON Instalación de Python Página oficial de Python Inicio: https://www.python.org/ Descarga: https://www.python.org/downloads/
12 PYTHON Descargando Python: Instalando Python
13 PYTHON
14 PYTHON Online tutorial Documentation
15 PYTHON Comprobar Instalación Abrimos el PowerShell y escribimos “”py” o “python”. Como podemos ver después de colocar el comando “py” y dar ENTER, nos muestra la versión de Python que tenemos instalado. Esto nos indica que el programa fue correctamente instalado. Python como una calculadora Probemos en el PowerShell alguno cómo usar Python como una calculadora básica. Números Operaciones aritméticas básicas En la suma, resta o multiplicación nos dio como resultado números sin colocar el punto decimal, esto es porque los números que se usaron para estas tres primeras operaciones fueron enteros. En el caso de la división nos puso en el resultado el punto decimal, esto es porque la división siempre nos arrojara un número decimal sin importar si son enteros o no el divisor o el dividendo.
16 PYTHON Operaciones aritméticas con punto decimal Operaciones aritméticas haciendo uso de paréntesis Jerarquía de operadores aritméticos La jerarquía de los operadores nos ayuda a expresar de manera correcta una expresión matemática. El orden jerárquico es el siguiente: 1. Símbolos de agrupación. Por ejemplo: Paréntesis “( )”, Corchetes “[ ]” o llaves “{ }”. 2. Raíces y potencias. Por ejemplo: √16, 3 2 3. Multiplicación y división. Por ejemplo: 3*4 , 20/3 4. Sumas y restas. Por ejemplo 7+10, 14-3 Uso de potencias y raíces Para realizar operaciones que involucren potencia usamos el doble operador de multiplicación (**). Ejemplo: 3 2 , lo podemos escribir como 3**2. Del mismo modo podemos usar cualquier raíz haciendo uso del mismo operador de potencia. Por ejemplo: √16, lo podemos escribir como 16**(1/2). Recordemos que una raíz cuadrada es un exponente a la ½ y una raíz cúbica es un exponente a la 1/3, y así sucesivamente.
17 PYTHON Variables Las variables nos permiten almacenar información y usarla en cualquier parte del programa. En Python a diferencia de otros lenguajes de programación no es necesario declarar manualmente una variable. La variable toma la forma del elemento que va a guardar. Por ejemplo, si guardamos un número la variable será numérica, si se guarda un texto, la variable será de tipo texto (alfanumérico o string), si guardamos un número con punto flotante la variable tomará esa forma, y así sucesivamente. Para guardar un valor en una variable usamos el operador de asignación, el que conocemos como igual ( = ). Sintaxis de asignación de valor en una variable: Nombre_de_la variable = Valor_que_se_desea_guardar Podemos mostrar en pantalla el valor de la variable simplemente escribiendo el nombre de la variable.
18 PYTHON Operaciones con variables A las variables se les puede hacer las mismas operaciones que a cualquier valor. Podemos sumar, restar, multiplicar, dividir, exponentes, etc. Como podemos ver podemos se pueden usar espacios para que se vea más claro el operador. Obtener el área de un cuadrado
19 PYTHON Obtener el área de un rectángulo = ∗ Solución de la ecuación cuadrática 2 + + = 0 = − ± √ 2 − 4 2 Las cual se divide en: 1 = −+√ 2−4 2 y 2 = −−√ 2−4 2 Calcular: 2 2 + 3 + 1 = 0
20 PYTHON Variable sin asignar valor Si una variable no está «definida» (no se le ha asignado un valor), al intentar usarla dará un error: Recuperar último valor mostrado Cuando realizamos una operación y la mostramos en pantalla podemos acceder a dicho valor mediante el carácter de guion bajo “_”.
21 PYTHON Funciones básicas Las funciones son códigos preprogramados que podemos mandar llamar cuando las necesitemos. En la siguiente liga puedes encontrar las funciones que Python tiene ya definidas listas para ser usadas. https://docs.python.org/3/library/functions.html
22 PYTHON Uso de funciones básicas Veamos algunas de las funciones mostradas en la tabla anterior.
23 PYTHON Cadenas de caracteres Comillas simples y dobles Una cadena de caracteres es lo mismo que una cadena de texto. Para colocar texto lo debemos de poner ya sea entre comillas simples ( ‘…’ ) o dobles ( “…” ). Carácter de escape Un carácter de escape nos permite colocar caracteres especiales. El carácter de escape es la diagonal invertida ( \ ). Veamos cómo utilizarlo.
24 PYTHON Función print( ) La función print nos da una salida más legible ya que omite las comillas que encierran a la cadena de caracteres y es capaz de imprimir caracteres especiales y de escape. También puede imprimir variables. Es importante mencionar que se debe escribir la función en minúsculas, de lo contrario marcará error. Uso básico El texto que queramos desplegar lo podemos poner tanto en comillas simples como dobles. Uso del carácter de escape Si queremos insertar un ENTER dentro del texto que queremos desplegar necesitamos usar el carácter de escape y la legra n (“\n”) que significaría “nueva línea”. Y si queremos poner una tabulación sería “\t”. Deshabilitar caracteres de escape En ocasiones es necesario deshabilitar los caracteres de escape. Para hacerlo colocamos una letra "r" antes de la cadena de caracteres que deseamos deshabilitar los escapes.
25 PYTHON Uso de variables Solo una variable Dos o más variables Texto y variable Cuando queramos desplegar el valor de una variable precedida de una cadena de caracteres podemos colocar la cadena de caracteres encerrado entre comillas luego colocamos una coma y después el nombre de la variable.
26 PYTHON Uso de las comillas triples Las cadenas de texto pueden tener múltiples líneas. Una forma es usar triples comillas: """...""" o '''...'''. Comentarios (#) Los comentarios son porciones de texto que sirven para colocar información que necesita el programador. Los comentarios no se despliegan como resultado o salida de una operación y para el programa o código no tienen ninguna acción. Para colocar un comentario solo le colocamos antes del texto de comentario el carácter “#”.
27 PYTHON Operaciones básicas con cadenas de caracteres Operadores “+” y “∗” Las cadenas se pueden concatenar (pegar juntas) con el operador + y se pueden repetir con *, Dos o más cadenas literales (es decir, las encerradas entre comillas) una al lado de la otra se concatena automáticamente. Esto solo funciona con dos literales, no con variables. Si quieres concatenar variables o una variable y un literal, usa +:
28 PYTHON Caracteres indexados Las cadenas de texto se pueden indexar (subíndices). el primer carácter de la cadena tiene el índice 0. No hay un tipo de dato diferente para los caracteres; un carácter es simplemente una cadena de longitud uno: >>> word = 'Python' >>> word[0] # Caracter en posición 0 'P' >>> word[5] # Caracter en posición 5 'n' Los índices quizás sean números negativos, para empezar a contar desde la derecha: >>> word[-1] # ultimo caracter 'n' >>> word[-2] # penúltimo caracter 'o' >>> word[-6] 'P' Nota: que -0 es lo mismo que 0, los índices negativos comienzan desde -1. Además de los índices, las rebanadas también están soportadas. Mientras que los índices se utilizar para obtener caracteres individuales, las rebanadas te permiten obtener partes de las cadenas de texto: >>> word = 'Python' >>> word[0:2] # caracteres desde la posición 0 (incluido) a la posición 2 (excluido) 'Py' >>> word[2:5] # caracteres desde la posición 2 (incluido) a la 5 (excluido) 'tho' Los índices de las rebanadas tienen valores por defecto útiles; el valor por defecto para el primer índice es cero, el valor por defecto para el segundo índice es la longitud de la cadena a rebanar. >>> word[:2] # caracteres desde el inicio a la posición 2 (excluido) 'Py' >>> word[4:] # caracteres desde la posición 4 (includido) hasta el final de la cadena. 'on' >>> word[-2:] # caracteres desde la penultima letra (hasta el final.
29 PYTHON 'on' Nota: como el inicio siempre se incluye y el final siempre se excluye. Esto asegura que s[:i] + s[i:] siempre sea igual a s: >>> word = 'Python' >>> word[:2] + word[2:] 'Python' >>> word[:4] + word[4:] 'Python' Una forma de recordar cómo funcionan las rebanadas es pensar que los índices apuntan entre caracteres, con el borde izquierdo del primer carácter numerado 0. Luego, el punto derecho del último carácter de una cadena de n caracteres tiene un índice n, por ejemplo: +---+---+---+---+---+---+ | P | y | t | h | o | n | +---+---+---+---+---+---+ 0 1 2 3 4 5 6 -6 -5 -4 -3 -2 -1 La primera fila de números da la posición de los índices 0…6 en la cadena; La segunda fila da los correspondientes índices negativos. Para índices no negativos, la longitud de la rebanada es la diferencia de los índices, si ambos están dentro de los límites. Por ejemplo, la longitud de word[1:3] es 2. Intentar usar un índice que es muy grande resultará en un error: >>> word = 'Python' >>> word[42] # la palabra solo tiene 6 caracteres Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: string index out of range Sin embargo, los índices de rebanadas fuera de rango se manejan satisfactoriamente cuando se usan para rebanar: >>> word[4:42] 'on' >>> word[42:] ''
30 PYTHON Las cadenas de Python no se pueden modificar, son immutable. Por eso, asignar a una posición indexada de la cadena resulta en un error: >>> word[0] = 'J' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment >>> word[2:] = 'py' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'str' object does not support item assignment Si necesitas una cadena diferente, deberías crear una nueva: >>> 'J' + word[1:] 'Jython' >>> word[:2] + 'py' 'Pypy' Función len( ) La función incorporada len() retorna la longitud de una cadena: >>> s = 'supercalifragilisticexpialidocious' >>> len(s) 34 >
31 PYTHON Listas Python tiene varios tipos de datos compuestos, utilizados para agrupar otros valores. El más versátil es la lista, la cual puede ser escrita como una lista de valores separados por coma (ítems) entre corchetes. Las listas pueden contener ítems de diferentes tipos, pero usualmente los ítems son del mismo tipo. >>> squares = [1, 4, 9, 16, 25] >>> squares [1, 4, 9, 16, 25] Al igual que las cadenas (y todos los demás tipos integrados sequence), las listas se pueden indexar y segmentar: >>> squares[0] 1 >>> squares[-1] 25 >>> squares[-3:] [9, 16, 25] Todas las operaciones de rebanado retornan una nueva lista que contiene los elementos pedidos. Esto significa que la siguiente rebanada retorna una shallow copy de la lista: >>> squares[:] [1, 4, 9, 16, 25] Las listas también admiten operaciones como concatenación: >>> squares + [36, 49, 64, 81, 100] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] A diferencia de las cadenas, que son inmutables, las listas son de tipo mutable, es decir, es posible cambiar su contenido: >>> cubes = [1, 8, 27, 65, 125] >>> 4 ** 3 64 >>> cubes[3] = 64 >>> cubes [1, 8, 27, 64, 125]
32 PYTHON También puede agregar nuevos elementos al final de la lista, utilizando el método append(). >>> cubes.append(216) >>> cubes.append(7 ** 3) >>> cubes [1, 8, 27, 64, 125, 216, 343] También es posible asignar a una rebanada, y esto incluso puede cambiar la longitud de la lista o vaciarla totalmente: >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters ['a', 'b', 'c', 'd', 'e', 'f', 'g'] >>> letters[2:5] = ['C', 'D', 'E'] >>> letters ['a', 'b', 'C', 'D', 'E', 'f', 'g'] >>> letters[2:5] = [] >>> letters ['a', 'b', 'f', 'g'] >>> letters[:] = [] >>> letters [] La función predefinida len() también sirve para las listas >>> letters = ['a', 'b', 'c', 'd'] >>> len(letters) 4 Es posible anidar listas (crear listas que contengan otras listas), por ejemplo: >>> a = ['a', 'b', 'c'] >>> n = [1, 2, 3] >>> x = [a, n] >>> x [['a', 'b', 'c'], [1, 2, 3]] >>> x[0] ['a', 'b', 'c'] >>> x[0][1] 'b'
33 PYTHON
34 PYTHON Editor PyCharm PyCharm es un entorno de desarrollo integrado (IDE) utilizado en programación informática, concretamente para el lenguaje de programación Python. https://www.jetbrains.com/pycharm/
35 PYTHON
36 PYTHON
37 PYTHON
38 PYTHON
39 PYTHON
40 PYTHON
41 PYTHON CONTROL DE FLUJO Bucle While Por supuesto, podemos usar Python para tareas más complicadas que sumar dos y dos. Por ejemplo, podemos escribir una parte inicial de la serie de Fibonacci así: >>> # Fibonacci series: ... # the sum of two elements defines the next ... a, b = 0, 1 >>> while a < 10: ... print(a) ... a, b = b, a+b ... 0 1 1 2 3 5 8 Este ejemplo introduce varias características nuevas. • La primera línea contiene una asignación múltiple: las variables a y b obtienen simultáneamente los nuevos valores 0 y 1. En la última línea esto se usa nuevamente, demostrando que las expresiones de la derecha son evaluadas primero antes de que se realice cualquiera de las asignaciones. Las expresiones del lado derecho se evalúan de izquierda a derecha. • El bucle while se ejecuta mientras la condición (aquí: a < 10) sea verdadera. En Python, como en C, cualquier valor entero que no sea cero es verdadero; cero es falso. La condición también puede ser una cadena de texto o una lista, de hecho, cualquier secuencia; cualquier cosa con una longitud distinta de cero es verdadera, las secuencias vacías son falsas. La prueba utilizada en el ejemplo es una comparación simple. Los operadores de comparación estándar se escriben igual que en C: < (menor que), > (mayor que), == (igual a), <= (menor que o igual a), >= (mayor que o igual a) y != (distinto a).
42 PYTHON • El cuerpo del bucle está indentado: la indentación es la forma que usa Python para agrupar declaraciones. En el intérprete interactivo debes teclear un tabulador o espacio(s) para cada línea indentada. En la práctica vas a preparar entradas más complicadas para Python con un editor de texto; todos los editores de texto modernos tienen la facilidad de agregar la indentación automáticamente. Cuando se ingresa una instrucción compuesta de forma interactiva, se debe finalizar con una línea en blanco para indicar que está completa (ya que el analizador no puede adivinar cuando tecleaste la última línea). Nota que cada línea de un bloque básico debe tener una sangría de la misma forma. • La función print() escribe el valor de los argumentos que se le dan. Difiere de simplemente escribir la expresión que se quiere mostrar (como hicimos antes en los ejemplos de la calculadora) en la forma en que maneja múltiples argumentos, cantidades de punto flotante y cadenas. Las cadenas de texto son impresas sin comillas y un espacio en blanco se inserta entre los elementos, así puedes formatear cosas de una forma agradable: >>> i = 256*256 >>> print('The value of i is', i) The value of i is 65536 El parámetro nombrado end puede usarse para evitar el salto de línea al final de la salida, o terminar la salida con una cadena diferente: >>> a, b = 0, 1 >>> while a < 1000: ... print(a, end=',') ... a, b = b, a+b ... 0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987, Debido a que ** tiene una prioridad mayor que `-, -3**2 se interpretará como -(3**2), por lo tanto, dará como resultado -9. Para evitar esto y obtener 9, puedes usar (- 3)**2. A diferencia de otros lenguajes, caracteres especiales como \n tienen el mismo significado con simple ('...') y dobles ("...") comillas. La única diferencia entre las dos es que dentro de las comillas simples no existe la necesidad de escapar " (pero tienes que escapar \') y viceversa. Además de la sentencia while que acabamos de introducir, Python soporta las sentencias de control de flujo que podemos encontrar en otros lenguajes, con algunos cambios.
43 PYTHON La sentencia if Tal vez el tipo más conocido de sentencia sea el if. Por ejemplo: >>> x = int(input("Please enter an integer: ")) Please enter an integer: 42 >>> if x < 0: ... x = 0 ... print('Negative changed to zero') ... elif x == 0: ... print('Zero') ... elif x == 1: ... print('Single') ... else: ... print('More') ... More Puede haber cero o más bloques elif, y el bloque else es opcional. La palabra reservada “elif’ es una abreviación de “else if”, y es útil para evitar un sangrado excesivo. Una secuencia if … elif … elif … sustituye las sentencias switch o case encontradas en otros lenguajes. Ejemplo:
44 PYTHON La sentencia for La sentencia for en Python difiere un poco de lo que uno puede estar acostumbrado en lenguajes como C o Pascal. En lugar de siempre iterar sobre una progresión aritmética de números (como en Pascal) o darle al usuario la posibilidad de definir tanto el paso de la iteración como la condición de fin (como en C), la sentencia for de Python itera sobre los ítems de cualquier secuencia (una lista o una cadena de texto), en el orden que aparecen en la secuencia. Por ejemplo: >>> # Measure some strings: ... words = ['cat', 'window', 'defenestrate'] >>> for w in words: ... print(w, len(w)) ... cat 3 window 6 defenestrate 12 Código que modifica una colección mientras se itera sobre la misma colección puede ser complejo de hacer bien. Sin embargo, suele ser más directo iterar sobre una copia de la colección o crear una nueva colección: # Create a sample collection users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'} # Strategy: Iterate over a copy for user, status in users.copy().items(): if status == 'inactive': del users[user] # Strategy: Create a new collection active_users = {} for user, status in users.items(): if status == 'active': active_users[user] = status
45 PYTHON Ejemplo: Obtener información específica de una lista Roberto = ['Roberto','Matemáticas',9] María= ['Matía','Matemáticas',8] datos = [Roberto,María] datos.append(['Rebeca','Física',8]) datos.append(['Raúl','Matemáticas',9]) datos.append(['Violeta','Física',7]) resultado=[] for registro in datos: if registro[1] == 'Matemáticas': resultado.append(registro) print(resultado) Escriba sus comentarios: Ejemplo: Manejo de menús y registros opción = 1 lista = [] while opción != 2: print('MENU\n\tAgregar Registro (0)\n\tImprimir Lista (1)\n\tSalir (2)') opción = int(input('Elija una opción: ')) if opción == 0: nombre = input('Nombre del alumno: ') calificación = int(input('Calificación: ')) registro = [nombre,calificación] lista.append(registro) elif opción == 1: print(lista) for registro in lista: print(registro) elif opción == 2: print('Programa Finalizado Correctamente') else: print('Opción inválida') Escriba sus comentarios:
46 PYTHON La función range() Si se necesita iterar sobre una secuencia de números, es apropiado utilizar la función integrada range(), la cual genera progresiones aritméticas: >>> for i in range(5): ... print(i) ... 0 1 2 3 4 El valor final dado nunca es parte de la secuencia; range(10) genera 10 valores, los índices correspondientes para los ítems de una secuencia de longitud 10. Es posible hacer que el rango empiece con otro número, o especificar un incremento diferente (incluso negativo; algunas veces se lo llama “paso”): >>> list(range(5, 10)) [5, 6, 7, 8, 9] >>> list(range(0, 10, 3)) [0, 3, 6, 9] >>> list(range(-10, -100, -30)) [-10, -40, -70] Para iterar sobre los índices de una secuencia, puedes combinar range() y len() así: >>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Mary 1 had 2 a 3 little 4 lamb En la mayoría de los casos, sin embargo, conviene usar la función enumerate(). Algo extraño sucede si muestras un ` range`: >>> range(10) range(0, 10)
47 PYTHON De muchas maneras el objeto retornado por range() se comporta como si fuera una lista, pero no lo es. Es un objeto que retorna los ítems sucesivos de la secuencia deseada cuando iteras sobre él, pero realmente no construye la lista, ahorrando entonces espacio. Decimos que tal objeto es iterable; esto es, que se puede usar en funciones y construcciones que esperan algo de lo cual obtener ítems sucesivos hasta que se termine. Hemos visto que la declaración for es una de esas construcciones, mientras que un ejemplo de función que toma un iterable es la función sum(): >>> sum(range(4)) # 0 + 1 + 2 + 3 6 Ejemplo: Tabla de multiplicar numero = int(input('Qué tabla de multiplicar quiere desplegar: ')) for i in range(10): print(numero,' x ', i+1 ,' = ', (i+1)*numero) Ejemplo: Tabla de multiplicar numero = int(input('Qué tabla de multiplicar quiere desplegar: ')) contador = 1; for i in range(1,numero*10,numero): print(numero,' x ', contador,' = ', i) contador = contador + 1; Ejemplo: Tabla de multiplicar incompleta (Completar) numero = int(input('Qué tabla de multiplicar quiere desplegar: ')) contador = 1; for i in enumerate(range(numero,numero*10,numero)): print(numero, ' x ', i[0]+1, ' = ', i[1])
48 PYTHON Sentencias break, continue, y else en bucles La sentencia break, como en C, termina el bucle for o while más anidado. Las sentencias de bucle pueden tener una cláusula`!else` que es ejecutada cuando el bucle termina, después de agotar el iterable (con for) o cuando la condición se hace falsa (con while), pero no cuando el bucle se termina con la sentencia break. Se puede ver el ejemplo en el siguiente bucle, que busca números primos: >>> for n in range(2, 10): ... for x in range(2, n): ... if n % x == 0: ... print(n, 'equals', x, '*', n//x) ... break ... else: ... # loop fell through without finding a factor ... print(n, 'is a prime number') ... 2 is a prime number 3 is a prime number 4 equals 2 * 2 5 is a prime number 6 equals 2 * 3 7 is a prime number 8 equals 2 * 4 9 equals 3 * 3 (Sí, este es el código correcto. Fíjate bien: el else pertenece al ciclo for, no al if.) La declaración continue, también tomada de C, continua con la siguiente iteración del ciclo: >>> for num in range(2, 10): ... if num % 2 == 0: ... print("Found an even number", num) ... continue ... print("Found an odd number", num) ... Found an even number 2 Found an odd number 3 Found an even number 4 Found an odd number 5 Found an even number 6 Found an odd number 7 Found an even number 8 Found an odd number 9
49 PYTHON La sentencia pass La sentencia pass no hace nada. Se puede usar cuando una sentencia es requerida por la sintaxis pero el programa no requiere ninguna acción. Por ejemplo: >>> while True: ... pass # Busy-wait for keyboard interrupt (Ctrl+C) ... Se usa normalmente para crear clases en su mínima expresión: >>> class MyEmptyClass: ... pass ... Otro lugar donde se puede usar pass es como una marca de lugar para una función o un cuerpo condicional cuando estás trabajando en código nuevo, lo cual te permite pensar a un nivel de abstracción mayor. El pass se ignora silenciosamente: >>> def initlog(*args): ... pass # Remember to implement this! ...
50 PYTHON La sentencia match Una instrucción match toma una expresión y compara su valor con patrones sucesivos dados como uno o más bloques de mayúsculas y minúsculas. Esto es superficialmente similar a una instrucción switch en C, Java o JavaScript (y muchos otros lenguajes), pero también puede extraer componentes (elementos de secuencia o atributos de objeto) del valor en variables. La forma más simple compara un valor, el «sujeto», con uno o más literales: def http_error(status): match status: case 400: return "Bad request" case 404: return "Not found" case 418: return "I'm a teapot" case _: return "Something's wrong with the internet" Observa el último bloque: el «nombre de variable» _ funciona como un comodín y nunca fracasa la coincidencia. Si ninguno de los casos case coincide, ninguna de las ramas es ejecutada. Se pueden combinar varios literales en un solo patrón usando | («ó»): case 401 | 403 | 404: return "Not allowed" Los patrones pueden también verse como asignaciones que desempaquetan, y pueden usarse para ligar variables: # point is an (x, y) tuple match point: case (0, 0): print("Origin") case (0, y): print(f"Y={y}") case (x, 0): print(f"X={x}") case (x, y): print(f"X={x}, Y={y}") case _: raise ValueError("Not a point")