├── Cap1 ├── Ejemplo 1_1.py ├── Ejemplo 1_2.py ├── Ejemplo 1_3.py ├── Ejemplo 1_4.py ├── Ejemplo 1_5.py ├── Ejemplo 1_6.py ├── Ejemplo 1_7.py ├── Ejemplo 1_8.py ├── Ejemplo 1_9.py ├── Programa 1_1.py ├── Programa 1_10.py ├── Programa 1_11.py ├── Programa 1_12.py ├── Programa 1_13.py ├── Programa 1_14.py ├── Programa 1_15.py ├── Programa 1_16.py ├── Programa 1_17.py ├── Programa 1_18.py ├── Programa 1_2.py ├── Programa 1_3.py ├── Programa 1_4.py ├── Programa 1_5.py ├── Programa 1_6.py ├── Programa 1_7.py ├── Programa 1_8.py ├── Programa 1_9.py ├── Tabla del -8 ├── Tabla del 0 ├── Tabla del 3_4 ├── Tabla del 5 ├── escritores ├── invitados └── lista_final ├── Cap2 ├── Ejemplo 2_1.py ├── Ejemplo 2_2.py ├── Ejemplo 2_3.py ├── Ejemplo 2_4.py ├── Ejemplo 2_5.py ├── Programa 2_1.py ├── Programa 2_10.py ├── Programa 2_11.py ├── Programa 2_12.py ├── Programa 2_2.py ├── Programa 2_3.py ├── Programa 2_4.py ├── Programa 2_5.py ├── Programa 2_6.py ├── Programa 2_7.py ├── Programa 2_8.py ├── Programa 2_9.py ├── basquetbol ├── delirio ├── esping ├── fox ├── futbol ├── kiwi ├── volei └── voleibol ├── Cap3 ├── Ejemplo 3_1.py ├── Ejemplo 3_10.py ├── Ejemplo 3_11.py ├── Ejemplo 3_2.py ├── Ejemplo 3_3.py ├── Ejemplo 3_4.py ├── Ejemplo 3_5.py ├── Ejemplo 3_6.py ├── Ejemplo 3_7.py ├── Ejemplo 3_8.py ├── Ejemplo 3_9.py ├── Escribe_en_archivos.py ├── Programa 3_1.py ├── Programa 3_10.py ├── Programa 3_11.py ├── Programa 3_12.py ├── Programa 3_13.py ├── Programa 3_14.py ├── Programa 3_15.py ├── Programa 3_16.py ├── Programa 3_17.py ├── Programa 3_2.py ├── Programa 3_3.py ├── Programa 3_4.py ├── Programa 3_5.py ├── Programa 3_6.py ├── Programa 3_7.py ├── Programa 3_8.py ├── Programa 3_9.py └── nombres ├── Cap4 ├── Ejemplo 4_1.py ├── Ejemplo 4_2.py ├── Ejemplo 4_3.py ├── Ejemplo 4_4.py ├── Ejemplo 4_5.py ├── Programa 4_1.py ├── Programa 4_10.py ├── Programa 4_11.py ├── Programa 4_12.py ├── Programa 4_13.py ├── Programa 4_14.py ├── Programa 4_15.py ├── Programa 4_16.py ├── Programa 4_17.py ├── Programa 4_18.py ├── Programa 4_19.py ├── Programa 4_2.py ├── Programa 4_20.py ├── Programa 4_21.py ├── Programa 4_22.py ├── Programa 4_23.py ├── Programa 4_24.py ├── Programa 4_25.py ├── Programa 4_26.py ├── Programa 4_27.py ├── Programa 4_28.py ├── Programa 4_3.py ├── Programa 4_4.py ├── Programa 4_5.py ├── Programa 4_6.py ├── Programa 4_7.py ├── Programa 4_8.py ├── Programa 4_9.py ├── __pycache__ │ ├── arreglo.cpython-37.pyc │ ├── matrices.cpython-37.pyc │ └── matrices.cpython-38.pyc ├── arreglo.py ├── claves ├── edades ├── letras ├── matrices.py ├── numeros ├── pares ├── precios ├── puntajes ├── temperaturas ├── yoga └── yoga_verano └── README.md /Cap1/Ejemplo 1_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_1 5 | Declaración e inicialización de variables de tipo list. 6 | """ 7 | 8 | # ============================================================================= 9 | # Usando los [] y dando valores para inicializar las listas. 10 | # ============================================================================= 11 | dias_laborables = ["lunes", "martes", "miércoles", "jueves", "viernes"] 12 | print('Lista de días laborables:', dias_laborables) 13 | colores_primarios = ['rojo', 'verde', 'azul'] 14 | print('Lista de colores:', colores_primarios) 15 | precios = [205.30, 107.18, 25, 450, 310.89, 170.23, 340] 16 | print('Lista de precios:', precios) 17 | print('El tipo es:', type(precios)) 18 | mezcolanza = [12, 'octubre', 1492, 'llegó Colón'] 19 | print('Lista con diferentes tipos de datos:', mezcolanza) 20 | vacia1 = [] 21 | print('\nLista vacía-1:', vacia1) 22 | 23 | # Se genera una lista vacía usando el constructor list() sin parámetros. 24 | vacia2 = list() 25 | print('Lista vacía-2:', vacia2) 26 | 27 | # Se genera una lista a partir de un rango. 28 | pares = list(range(0, 30, 2)) 29 | print('\nPares menores a 30:', pares) 30 | impares = list(range(29, 0, -2)) 31 | print('\nImpares menores a 30:', impares) 32 | 33 | # Se genera una lista con los caracteres de una cadena de caracteres. 34 | caracteres = list('2020 es bisiesto') 35 | print('\nLista de caracteres:', caracteres) 36 | 37 | # Se genera una lista con subcadenas de una cadena de caracteres. 38 | frase = '''La emigración no solo se hace para huir de la opresión en casa, 39 | sino también para llegar a lo más hondo de nuestra alma.''' # Autor: Orhan Pamuk 40 | palabras = frase.split() # Si no se da parámetro, se toma el ' '. 41 | print('\nLista de palabras:', palabras) 42 | 43 | # Se genera una lista con los elementos de una tupla. 44 | con_tuplas = list((6, 3, 8, 12, 15)) 45 | print('\nLista con los elementos de la tupla:', con_tuplas) 46 | 47 | # Se genera una lista con los elementos de otra lista. 48 | otra_lista = list(precios) 49 | print('\nTengo lo mismo, pero soy otra lista:', otra_lista) 50 | 51 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_2 5 | Operaciones con listas. 6 | """ 7 | 8 | dias_laborables = ["lunes", "martes", "miércoles", "jueves", "viernes"] 9 | colores_primarios = ['rojo', 'verde', 'azul'] 10 | precios = [205.30, 107.18, 25, 450, 310.89, 170.23, 340] 11 | 12 | # ============================================================================= 13 | # Acceso a los elementos de las listas. 14 | # ============================================================================= 15 | print('\nPrimer elemento:', dias_laborables[0]) # Imprime 'lunes'. 16 | print('Último elemento:', dias_laborables[-1]) # Imprime 'viernes'. 17 | print('Último desde la derecha:', dias_laborables[-5]) # Imprime 'lunes'. 18 | # print(dias_laborables[-100]) # IndexError: list index out of range 19 | 20 | # ============================================================================= 21 | # Ejemplos de uso de los operadores + y *. 22 | # ============================================================================= 23 | fin_semana = ['sábado', 'domingo'] 24 | # Concatena las listas en el orden dado. 25 | semana = fin_semana + dias_laborables 26 | # Repite los elementos. El número debe ser un entero. 27 | colores_repetidos = colores_primarios * 2 28 | # TypeError: can't multiply sequence by non-int of type 'float' 29 | # precios_repetidos = precios * 3.5 30 | print('\nListas concatenadas:', semana) 31 | print('Elementos repetidos:', colores_repetidos) 32 | 33 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_3 5 | Funciones predefinidas para trabajar con listas. 6 | Ejemplos de uso. 7 | """ 8 | 9 | dias_laborables = ["lunes", "martes", "miércoles", "jueves", "viernes"] 10 | colores_primarios = ['rojo', 'verde', 'azul'] 11 | precios = [205.30, 107.18, 25, 450, 310.89, 170.23, 340] 12 | pares = list(range(0, 30, 2)) 13 | impares = list(range(29, 0, -2)) 14 | colores_repetidos = colores_primarios * 2 15 | 16 | # ============================================================================= 17 | # Algunas funciones para el manejo de listas. 18 | # ============================================================================= 19 | dias_laborables.append('sábado') # Agrega sábado al final de la lista. 20 | print('\nSemana laborable con un día extra =', dias_laborables) 21 | # Cuenta el número de veces que aparece lunes en la lista. 22 | print(f"\nEl lunes aparece = {dias_laborables.count('lunes')} vez (veces).") 23 | # Regresa el total de elementos que tiene la lista. 24 | print('Total de precios =', len(precios)) 25 | # Agrega en la primera posición el valor blanco. 26 | colores_primarios.insert(0, 'blanco') 27 | print('\nLista con un nuevo elemento:', colores_primarios) 28 | # No existe la posición 10. Lo inserta al final. 29 | colores_primarios.insert(10, 'amarillo') 30 | print('Lista con un nuevo elemento:', colores_primarios) 31 | # Agrega al final de la lista todos los elementos de la lista impares. 32 | pares.extend(impares) 33 | print('\nLista de pares extendida con la lista impares:', pares) 34 | # Quita el valor sábado de la lista. 35 | dias_laborables.remove('sábado') 36 | print('\nVolviendo a la normalidad =', dias_laborables) 37 | # Regresa la posición de rojo dentro de la lista. 38 | print('\nPosición del rojo:', colores_primarios.index('rojo')) 39 | print('Posición del segundo azul:', colores_repetidos.index('azul', 3)) 40 | # Da el error: ValueError: 'gris' is not in list 41 | # print('Posición del gris:', colores_repetidos.index('gris')) 42 | # Ordena los elementos de la lista de menor a mayor. 43 | precios.sort() 44 | print('\nPrecios ordenados de menor a mayor:', precios) 45 | # Ordena los elementos de la lista de mayor a menor. 46 | colores_repetidos.sort(reverse = True) 47 | print('Colores ordenados de mayor a menor:', colores_repetidos) 48 | # Genera una nueva lista ordenada, sin alterar la lista original. 49 | lista_ordenada = sorted(dias_laborables) 50 | lis_ord_long = sorted(dias_laborables, key = len) 51 | print('\nDías laborables sin alterar:', dias_laborables) 52 | print('Días laborables ordenados:', lista_ordenada) 53 | print('Días laborables ordenados por longitud:', lis_ord_long) 54 | # Invierte el orden de los elementos de la lista. 55 | impares.reverse() 56 | print('\nImpares en orden inverso:', impares) 57 | # Quita y regresa el elemento de la posición 0. 58 | quitado = colores_primarios.pop(0) 59 | print('\nEl elemento quitado es:', quitado) 60 | print('La lista quedó:', colores_primarios) 61 | rescatado = dias_laborables.pop() # Sin posición: quita el último. 62 | print('Se rescató para el fin de semana:', rescatado) 63 | print('Los días laborables quedaron:', dias_laborables) 64 | # print(precios.pop(10)) # IndexError: pop index out of range 65 | # Quita todos los elementos de la lista, dejándola vacía. 66 | precios.clear() 67 | print('\nLa lista de precios quedó vacía:', precios) 68 | # print(precios.pop()) IndexError: pop from empty list 69 | # Quita el segundo elemento de la lista. 70 | del colores_primarios[1] 71 | print('\nColores primarios luego de quitar el segundo elemento:', colores_primarios) -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_4 5 | Ejemplos de partición de listas. 6 | """ 7 | 8 | # Se crea una lista de números enteros. 9 | lista1 = [1, 2, 3, 4, 5, 6] 10 | print('\nLista:', lista1) 11 | # Sublista formada con los elementos de las posiciones 0 a la 2 inclusive. 12 | l1 = lista1[0:3] 13 | print('Del primero al tercero:', l1) 14 | # Sublista formada con los elementos de las posiciones 0 a la 3 inclusive. 15 | l2 = lista1[:4] 16 | print('Del primero al cuarto:', l2) 17 | # Sublista formada con los elementos de las posiciones 3 a la 5 inclusive. 18 | l3 = lista1[3:] 19 | print('Del cuarto al último:', l3) 20 | # Sublista formada con los elementos desde el inicio hasta el final, 21 | # con un salto de 2. 22 | l4= lista1[::2] 23 | print('De izquierda a derecha, tomando 1 cada 2:', l4) 24 | # Sublista formada con los elementos desde el final hasta el inicio, 25 | # con un salto de 3. 26 | l5 = lista1[-1::-3] 27 | print('De derecha a izquierda, tomando 1 cada 3:', l5) 28 | # Quita los elementos de la posición 0 a la última inclusive. 29 | del lista1[:] 30 | print('Luego de quitar todos los elementos', lista1) 31 | 32 | # Se crea una lista de cadenas de caracteres. 33 | lista2 = list('abcdefghij') 34 | print('\nLista:', lista2) 35 | # Reemplaza los elementos de las posiciones 0 y 1 por los valores dados. 36 | lista2[0:2] = ['rojo', 'verde'] 37 | print('Se reemplazaron los 2 primeros valores:', lista2) 38 | # Quita los elementos de las posiciones 4 a la 8 inclusive. 39 | lista2[4:9] = [] 40 | print('Se quitaron del 5to al 9no dato:', lista2) 41 | # Agrega los valores de la lista en la posición 0, reemplazando el valor 42 | # de esa posición y desplazando hacia la derecha todos los demás. 43 | lista2[0:1] = ['azul', 'gris', 'blanco'] 44 | print('Luego de agregar 3 colores:', lista2) 45 | # Agrega todos sus elementos al inicio. 46 | lista2[:0] = lista2 47 | print('Luego de agregar sus propios elementos:', lista2) 48 | # Vacía la lista. 49 | lista2[:] = [] 50 | print('Luego de vaciar la lista:', lista2) 51 | 52 | 53 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_5 5 | Copia de listas: ejemplo de uso de funciones del módulo copy. 6 | """ 7 | import copy 8 | 9 | # ============================================================================= 10 | # Ejemplos de copias superficiales y profundas de listas con datos inmutables. 11 | # ============================================================================= 12 | dias_laborables = ["lunes", "martes", "miércoles", "jueves", "viernes"] 13 | precios = [205.30, 107.18, 25, 450, 310.89] 14 | 15 | dias = copy.copy(dias_laborables) # Copiado superficial. 16 | print('\nListas luego de la copia superficial'.upper()) 17 | print('Lista original:', dias_laborables) 18 | print('Copia:', dias) 19 | 20 | # Se modifica la lista original y la copia. 21 | dias_laborables.pop(0) 22 | dias.remove('viernes') 23 | tit1 = '''\nListas luego de hacer modificaciones en ambas: 24 | cada una conserva sus cambios.'''.upper() 25 | print(tit1) 26 | print('Lista original:', dias_laborables) 27 | print('Copia:', dias) 28 | 29 | copia_precios = copy.deepcopy(precios) # Copiado profundo. 30 | print('\nListas luego de la copia profunda'.upper()) 31 | print('Lista original:', precios) 32 | print('Copia:', copia_precios) 33 | 34 | # Se modifica la lista original y la copia. 35 | precios.append(720.14) 36 | copia_precios.pop(2) 37 | print(tit1) 38 | print('Lista original:', precios) 39 | print('Copia:', copia_precios) 40 | 41 | # ============================================================================= 42 | # Ejemplos de copias superficiales y profundas de listas con datos 43 | # mutables (listas). 44 | # ============================================================================= 45 | lista1 = [[2, 3], [9, 8]] # Lista formada por elementos mutables. 46 | copial1= copy.copy(lista1) # Copiado superficial. 47 | print('\nListas luego de la copia superficial'.upper()) 48 | print('Lista original:', lista1) 49 | print('Copia:', copial1) 50 | 51 | # Se modifica el primer elemento de la lista que es, a su vez, 52 | # el primer elemento de lista1. El valor 2 se reemplaza por el valor 25. 53 | lista1[0][0] = 25 54 | tit2 = '''\nListas luego de la modificación de la lista original: 55 | ambas listas reflejan el cambio'''.upper() 56 | print(tit2) 57 | print('Lista original:', lista1) 58 | print('Copia:', copial1) 59 | 60 | lista2 = [['verde', 'rojo'], ['blanco', 'azul']] 61 | copial2= copy.deepcopy(lista2) # Copiado profundo. 62 | print('\nListas luego de la copia profunda'.upper()) 63 | print('Lista original:', lista2) 64 | print('Copia:', copial2) 65 | 66 | # Se modifica el primer elemento de la lista que es, a su vez, el primer 67 | # elemento de lista2: el valor verde se reemplaza por el valor amarillo. 68 | lista2[0][0] = 'amarillo' 69 | tit3 = '''\nListas luego de la modificación de la lista original: 70 | solo la original se afectó'''.upper() 71 | print(tit3) 72 | print('Lista original:', lista2) 73 | print('Copia:', copial2) 74 | 75 | # ============================================================================= 76 | # Copiado de listas por medio de partir o dividir listas (slice). 77 | # Igual efecto que el copiado superficial. 78 | # ============================================================================= 79 | lis1 = lista1[:] 80 | print('\nListas luego del slice'.upper()) 81 | print('Lista original:', lista1) 82 | print('Copia:', lis1) 83 | 84 | lista1[0][0] = 92 85 | print(tit2) 86 | print('Lista original:', lista1) 87 | print('Copia:', lis1) -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_6 5 | Ejemplos del uso de operadores relacionales, de membresía y 6 | de identidad con listas. 7 | """ 8 | import copy 9 | 10 | precios = [205.30, 107.18, 25, 450, 310.89, 170.23, 340] 11 | vacia = [] 12 | colores_primarios = ['rojo', 'verde', 'azul'] 13 | colores = ['verde', 'azul', 'amarillo', 'blanco'] 14 | 15 | if precios: 16 | print('Lista precios: no vacía') # Imprime. 17 | else: 18 | print('Lista precios: vacía') 19 | 20 | if not vacia: 21 | print('Lista vacía: vacía') # Imprime. 22 | else: 23 | print('Lista vacía: no vacía') 24 | 25 | # Operadores relacionales. 26 | otra_lista = precios # Asigna la lista a otra variable. 27 | if precios == otra_lista: 28 | print('Las listas son iguales') # Imprime. 29 | else: 30 | print('Las listas no son iguales') 31 | 32 | if precios == colores_primarios: 33 | print('precios y colores: son iguales') 34 | else: 35 | print('precios y colores: no son iguales') # Imprime. 36 | 37 | if colores_primarios != colores: 38 | print('Listas colores y colores_primarios: distintas') # Imprime. 39 | 40 | if colores_primarios < colores: 41 | print('Lista colores_primarios es menor que lista colores') # Imprime. 42 | 43 | if colores_primarios > colores: 44 | print('Lista colores_primarios es mayor que lista colores') # No imprime. 45 | 46 | ''' 47 | Se lanza la excepción: 48 | TypeError: '<' not supported between instances of 'float' and 'str' 49 | if precios < colores_primarios: 50 | print('precios y colores: son iguales') 51 | else: 52 | print('precios y colores: no son iguales') 53 | ''' 54 | 55 | # Operadores de identidad. 56 | if precios is otra_lista: 57 | print('precios y otra_lista: son la misma lista') # Imprime. 58 | else: 59 | print('No son la misma lista') 60 | 61 | copia = copy.copy(precios) # Hace una copia de la lista. Es otro objeto. 62 | if precios is copia: 63 | print('Son la misma lista') 64 | else: 65 | print('precios y copia: no son la misma lista') # Imprime. 66 | 67 | if colores is not colores_primarios: 68 | print('colores y colores_primarios: no son la misma lista') # Imprime. 69 | 70 | # Operadores de membresía. 71 | if 'rojo' in colores_primarios: 72 | print('El rojo es un color primario') # Imprime. 73 | 74 | if 'dorado' not in colores_primarios: 75 | print('El dorado no es un color primario') # Imprime. 76 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_7 5 | Ejemplo de listas anidadas. 6 | """ 7 | 8 | colores = ['azul', 'rojo', 'blanco'] 9 | pares = [2, 4, 6, 8] 10 | dias = ['lun', 'mar', 'mie', 'jue', 'vie'] 11 | # Lista de listas. 12 | lista1 = [colores, pares, dias] 13 | print('\nLista de listas:', lista1) 14 | print('\nPrimer elemento de la lista:', lista1[0]) 15 | 16 | # Agrega a la segunda lista el número 10. 17 | lista1[1].append(10) 18 | print('\nLuego de agregar el 10 a la segunda lista:', lista1) 19 | print('Lista "pares" también se modificó:', pares) 20 | # Modifica el tercer elemento de la segunda lista. 21 | lista1[1][2] = 24 22 | print('\nLuego de reemplazar el 6 por 24:', lista1) 23 | print('Lista "pares" también se modificó:', pares) 24 | # Pasa a mayúsculas el quinto elemento de la tercera lista. 25 | lista1[2][4] = lista1[2][4].upper() 26 | print('\nLuego de pasar a mayúsculas a "vie":', lista1) 27 | print('Lista "dias" también se modificó:', dias) 28 | 29 | # Se define una lista con un nivel mayor de anidamiento. 30 | lista2 = [lista1, [[20, 30, 40], [-20, -30, -40]]] 31 | print('\nLista de listas de listas:', lista2) 32 | # Eleva al cuadrado al quinto elemento del segundo 33 | # elemento (que es una lista) del primer elemento (también lista) 34 | # de la lista2. 35 | lista2[0][1][4] = lista2[0][1][4] ** 2 36 | print('\nLuego de elevar al cuadrado:', lista2[0][1]) 37 | print('\nLista "pares" también se modificó:', pares) 38 | 39 | # Acceso a los elementos por medio de índices cuyos valores 40 | # están controlados por ciclos for. 41 | print('\nElementos de lista2:\n') 42 | for i in range(0, len(lista2)): 43 | for j in range(0, len(lista2[i])): 44 | for k in range(0, len(lista2[i][j])): 45 | print(lista2[i][j][k], end = ' ') 46 | print('') 47 | print('') 48 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1.8 5 | Ejemplos de listas por comprensión. 6 | """ 7 | 8 | # A partir de una cadena de caracteres. 9 | frase = 'listas' 10 | lista_mayusculas = [letra.upper() for letra in frase] 11 | print('\nA partir de una cadena:\n', lista_mayusculas) 12 | # A partir de una tupla. 13 | tupla = (2, 5, 8, 10) 14 | lista_cuadrados = [numero ** 2 for numero in tupla] 15 | print('A partir de una tupla:\n', lista_cuadrados) 16 | # A partir de una lista. 17 | lista_pares = [2, 4, 6, 8, 10] 18 | lista_cubos_pares = [par ** 3 for par in lista_pares] 19 | print('A partir de una lista:\n', lista_cubos_pares) 20 | 21 | # Con condiciones. 22 | varios = [2, 'calor', 4, 5, 7, 'verde', 'vacaciones', -3, 1.25] 23 | solo_int = [num ** 2 for num in varios if type(num) == int] 24 | print('\nSolo con enteros:', solo_int) 25 | int_o_float = [num ** 2 for num in varios if type(num) == int or type(num) == float] 26 | print('Con enteros o reales:', int_o_float) 27 | 28 | # Genera lista de listas a partir de una tupla. 29 | lista1 = [[num, num ** 2] for num in tupla] 30 | print('\nLista de listas:', lista1) 31 | # Genera lista de tuplas a partir de una lista. 32 | lista2 = [(num, num / 2, num * 2) for num in lista_pares] 33 | print('Lista de tuplas:', lista2) 34 | # Genera lista de listas a partir de una cadena. 35 | lista3 = [[letra, letra.upper()] for letra in frase] 36 | print('Lista de listas:', lista3) 37 | 38 | # Genera una lista operando con elementos de una lista y de una tupla. 39 | lista4 = [x + y for x in tupla for y in lista_pares] 40 | print('\nLista a partir de tupla y lista:', lista4) 41 | # A partir de una lista de listas deja todos los elementos al mismo nivel. 42 | lista5 = [x + 1 for sublista in lista1 for x in sublista] 43 | print('Se pierde el anidamiento de listas:', lista5) 44 | # Conserva los niveles de anidamiento que hay en la lista de listas. 45 | lista6 = [[x + 1 for x in sublista] for sublista in lista1] 46 | print('Se mantiene el nivel de anidamiento:', lista6) 47 | 48 | # Se genera una lista de listas sin usar listas por comprensión. 49 | lista7 = [] 50 | for sublista in lista1: 51 | lista = [] 52 | for x in sublista: 53 | lista.append(x + 1) 54 | lista7.append(lista) 55 | print('\nLista generada con 2 ciclos for:', lista7) 56 | -------------------------------------------------------------------------------- /Cap1/Ejemplo 1_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 1_9. 5 | Ejemplos de uso de las funciones flter(), map() y zip(). 6 | """ 7 | 8 | def multiplo_de4(numero): 9 | return numero % 4 == 0 10 | 11 | def cubo(x): 12 | return x ** 3 13 | 14 | def es_mayusc(c): 15 | return c.isupper() 16 | 17 | def conv_mayus(c): 18 | res = c 19 | if c.islower(): 20 | res = c.upper() 21 | return res 22 | 23 | numeros = [2, 5, 8, 3, 12, 20, 31, 4, 16] 24 | potencias = [4, 2, 2, 3, 2, 2, 1] 25 | cadena = 'Juan baila' 26 | 27 | # Uso del filter. 28 | fil_lista = list(filter(multiplo_de4, numeros)) 29 | print('\n"Filter" aplicado a una lista:', fil_lista) 30 | fil_cadena = list(filter(es_mayusc, cadena)) 31 | print('"Filter" aplicado a una cadena:', fil_cadena) 32 | 33 | # Uso del map. 34 | map_lista = list(map(cubo, numeros)) 35 | print('\n"Map" aplicado a una lista:', map_lista) 36 | print('"Map" aplicado a una cadena: ', end = '') 37 | for i in map(conv_mayus, cadena): 38 | print(i, end = '') 39 | print('\n"Map" usando una función con 2 parámetros: ', end = '') 40 | for n in map(pow, numeros, potencias): 41 | print(n, end = ' ') 42 | 43 | # Uso del zip. 44 | print('\n\nEjemplos de uso del zip'.upper()) 45 | preguntas = ['Nombre del abuelo', 'Comida preferida', 'Lugar de vacaciones'] 46 | respuestas = ['Alberto', 'risotto', 'playa'] 47 | for pre, resp in zip(preguntas, respuestas): 48 | print(f'¿{pre}?: {resp}') 49 | ferreteria = ['martillo', 'clavo', 'tenaza', 'destornillador', 'taladro'] 50 | precios = [250, 1.2, 380.5, 195.3, 1500] 51 | precio_max = 0 52 | for material, precio in zip(ferreteria, precios): 53 | if precio > precio_max: 54 | precio_max = precio 55 | mat_max = material 56 | print(f'\nEl/la {mat_max} es la herramienta más cara. Cuesta ${precio_max}.') 57 | num_pot = [valor for valor in zip(numeros, potencias)] 58 | print('\n"Zip" aplicado a dos listas de diferente longitud:', num_pot) 59 | tupla = tuple(ele for ele in zip((1, 3, 5), (2, 4, 6))) 60 | print('\n"Zip" aplicado a dos tuplas:', tupla) 61 | resul = '' 62 | for c1, c2 in zip('AEIOU', 'aeiou'): 63 | resul += c1 + '-' + c2 + ' ' 64 | print('\n"Zip" aplicado a dos cadenas:', resul) 65 | 66 | -------------------------------------------------------------------------------- /Cap1/Programa 1_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.1 5 | """ 6 | 7 | def primero_y_ultimo(lista): 8 | """ Obtiene el primero y el último elemento de la lista. 9 | Parámetro: 10 | lista: de tipo list. 11 | Regresa: 12 | Una tupla formada con el primero y el último elemento de la lista. 13 | Lanza: 14 | ValueError: cuando el parámetro recibido no es una lista o cuando no 15 | tiene, al menos, 2 elementos. 16 | """ 17 | if lista: 18 | if len(lista) >= 2: 19 | return (lista[0], lista[-1]) 20 | raise ValueError('La lista no tiene elementos suficientes.') 21 | raise ValueError('No es un dato válido.') 22 | 23 | # ============================================================================= 24 | # Algunas pruebas para la función primero_y_ultimo() 25 | # ============================================================================= 26 | # CP1: lista con varios elementos. 27 | lista1 = [1, 2, 3, 4] 28 | print('\nCP1:', primero_y_ultimo(lista1)) 29 | 30 | # CP2: lista con solo 2 elementos. 31 | lista2 = [1, 2] 32 | print('CP2:', primero_y_ultimo(lista2)) 33 | # CP3: lista con 1 solo elemento. 34 | lista3 = [1] 35 | try: 36 | print('CP3:', primero_y_ultimo(lista3)) 37 | except Exception as error: 38 | print('CP3:', error) 39 | # CP4: No se proporciona una lista. 40 | lista4 = None 41 | try: 42 | print('CP4:', primero_y_ultimo(lista4)) 43 | except Exception as error: 44 | print('CP4:', error) -------------------------------------------------------------------------------- /Cap1/Programa 1_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.10 5 | """ 6 | 7 | def nombres_sin_espacios(lista): 8 | """ Genera una lista con los elementos de la lista recibida 9 | que no contengan espacios en blanco. 10 | Parámetro: 11 | lista: de tipo list. Almacena cadenas de caracteres. 12 | Regresa: 13 | Una lista que almacena cadenas de caracteres. 14 | """ 15 | resultado = [ele for ele in lista if ele.find(' ') == -1] 16 | return resultado 17 | 18 | # ======================================================================= 19 | # Algunas pruebas de la función nombres_sin_espacios() 20 | # ======================================================================= 21 | # CP1: algunas cadenas contienen espacios en blanco. 22 | ciudades = ['Bogotá', 'Buenos Aires', 'México', 'Caracas', 'San Salvador', 'Río de Janeiro'] 23 | print('\nCP1:', nombres_sin_espacios(ciudades)) 24 | # CP2: algunas cadenas contienen espacios en blanco. 25 | platillos = ['mousse de chocolate', 'sopa', 'hamburguesa', 'papas fritas', 'cocido'] 26 | print('CP2:', nombres_sin_espacios(platillos)) 27 | # CP3: las cadenas no contienen espacios en blanco. 28 | colores = ['rojo', 'verde', 'blanco', 'amarillo'] 29 | print('CP3:', nombres_sin_espacios(colores)) 30 | # CP4: se proporciona una lista vacía. 31 | vacia = [] 32 | print('CP4:', nombres_sin_espacios(vacia)) 33 | -------------------------------------------------------------------------------- /Cap1/Programa 1_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.11 5 | """ 6 | 7 | def genera_tabla_multiplicar(numero, limite): 8 | """ Genera una lista de listas que almacena la tabla de 9 | multiplicar de número desde 1 hasta el límite. 10 | Parámetro: 11 | numero: de tipo int o float que representa un multiplicando. 12 | limite: de tipo int > 0 que indica el máximo valor 13 | por el cual se multiplicará el multiplicando. 14 | Regresa: 15 | Una lista de listas, donde cada una de ellas almacena el resultado 16 | de una multiplicación. 17 | """ 18 | oper1 = [numero] 19 | oper2 = [valor for valor in range(1, limite + 1)] 20 | resultado = [[n1, n2, n1 * n2] for n1 in oper1 for n2 in oper2] 21 | return resultado 22 | 23 | def guarda_tabla_multiplicar(archivo, lista): 24 | """ Guarda en un archivo el contenido de la lista. 25 | Parámetro: 26 | archivo: de tipo str. Se usa para nombrar al archivo. 27 | lista: de tipo list. Lista de listas de tres elementos. 28 | Lanza: 29 | FileNotFoundError: si no se puede abrir el archivo. 30 | """ 31 | try: 32 | with open(archivo, 'w') as arch: 33 | titulo = f'Tabla de multiplicar del: {lista[0][0]} \n\n'.upper() 34 | arch.write(titulo) 35 | for terna in lista: 36 | linea = f'{terna[0]} x {terna[1]:2d} = {terna[2]:.2f}' 37 | arch.write(linea + '\n') 38 | except FileNotFoundError: 39 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 40 | 41 | # ============================================================================= 42 | # Algunas pruebas de las funciones genera_tabla_multiplicar() y 43 | # guarda_tabla_multiplicar() 44 | # ============================================================================= 45 | # CP1: con un entero positivo y nombre de archivo adecuado. 46 | t5 = genera_tabla_multiplicar(5, 10) 47 | guarda_tabla_multiplicar('Tabla del 5', t5) 48 | # CP2: con un real positivo y nombre de archivo adecuado. 49 | t3_4 = genera_tabla_multiplicar(3.4, 10) 50 | guarda_tabla_multiplicar('Tabla del 3_4', t3_4) 51 | # CP3: con un entero negativo y nombre de archivo adecuado. 52 | t_8 = genera_tabla_multiplicar(-8, 15) 53 | guarda_tabla_multiplicar('Tabla del -8', t_8) 54 | # CP4: con cero y nombre de archivo adecuado. 55 | t0 = genera_tabla_multiplicar(0, 5) 56 | guarda_tabla_multiplicar('Tabla del 0', t0) 57 | # CP5: igual que el CP1 pero dando un nombre no válido para el archivo. 58 | try: 59 | guarda_tabla_multiplicar('', t5) 60 | except FileNotFoundError as error: 61 | print('\n', error) # Imprime error. -------------------------------------------------------------------------------- /Cap1/Programa 1_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.12 5 | """ 6 | 7 | def genera_lista_pares(lista): 8 | """Genera una lista con los números pares almacenados en lista. 9 | Parámetro: 10 | lista: de tipo list. Almacena números enteros. 11 | Regresa: 12 | Una lista con números enteros pares. 13 | Lanza: 14 | ValueError: cuando la lista recibida no almacena ningún número par. 15 | """ 16 | pares = [num for num in lista if num % 2 == 0] 17 | if len(pares) == 0: 18 | raise ValueError('No hay pares en la lista recibida.') 19 | return pares 20 | 21 | # ============================================================================= 22 | # Algunas pruebas de la función genera_lista_pares 23 | # ============================================================================= 24 | # CP1: se da una lista que tiene pares e impares. 25 | lista1 = [13, 45, 64, 32, 11, 17, -14, 81] 26 | print('\nCP1:', genera_lista_pares(lista1)) 27 | # CP2: se da una lista que tiene solo pares. 28 | lista2 = [130, 48, 64, 32, 10, 174, -14, 88] 29 | print('CP2:', genera_lista_pares(lista2)) 30 | # CP3: se da una lista que tiene solo impares. 31 | lista3 = [13, 45, 61, 321, 101, 173, -11, 87] 32 | try: 33 | print('CP3:', genera_lista_pares(lista3)) 34 | except ValueError as error: 35 | print('CP3:', error) 36 | # CP4: se da una lista vacía. 37 | lista4 = [] 38 | try: 39 | print('CP4:', genera_lista_pares(lista4)) 40 | except ValueError as error: 41 | print('CP4:', error) -------------------------------------------------------------------------------- /Cap1/Programa 1_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.13 5 | """ 6 | 7 | def lista_filtrada(lista): 8 | """ Genera una lista con todos los elementos de la lista 9 | recibida que tengan un valor. 10 | Parámetro: 11 | lista: de tipo list. Almacena cualquier tipo de datos. 12 | Regresa: 13 | Una lista formada solo con elementos no vacíos. 14 | """ 15 | return list(filter(None, lista)) 16 | 17 | # CP1: se proporciona una lista de cadenas con algunas cadenas vacías. 18 | lis_cadenas = ['verde', 'azul', '', 'rojo', '', '', 'blanco'] 19 | filtrada1 = lista_filtrada(lis_cadenas) 20 | print('\nCP1: lista de cadenas -->', filtrada1) 21 | # CP2: se proporciona una lista de números con algunos 0. 22 | lis_numeros = [23, 0, 17, 15, 0, 0, 56] 23 | filtrada2 = lista_filtrada(lis_numeros) 24 | print('CP2: lista de números -->', filtrada2) 25 | # CP3: se proporciona una lista de tuplas, algunas de las cuales están vacías. 26 | lis_tuplas = [(2, 4), (), (3, 9), (), (), (), (8, 64)] 27 | filtrada3 = lista_filtrada(lis_tuplas) 28 | print('CP3: lista de tuplas -->', filtrada3) 29 | # CP4: se proporciona una lista de listas, algunas de las cuales están vacías. 30 | lis_listas = [[], [], ['sol', 'luna'], [35.6], [], [2, 80]] 31 | filtrada4 = lista_filtrada(lis_listas) 32 | print('CP4: lista de listas -->', filtrada4) 33 | # CP5: se proporciona una lista vacía. 34 | vacia = [] 35 | filtrada5 = lista_filtrada(vacia) 36 | print('CP5: lista vacía -->', filtrada5) 37 | 38 | -------------------------------------------------------------------------------- /Cap1/Programa 1_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.14 5 | """ 6 | 7 | 8 | def calcula_long(frase): 9 | """ Genera una lista con la longitud de cada una de las 10 | palabras que forman la frase. 11 | Parámetro: 12 | frase: de tipo str. Las palabras están separadas por espacios en blanco. 13 | Regresa: 14 | Una lista de enteros. 15 | """ 16 | return list(map(len, frase.split())) 17 | 18 | # CP1: se proporciona una frase con varias palabras. 19 | frase = 'Mi perro se llama Charrúa y es adorable' 20 | print('\nCP1: frase con varias palabras -->', calcula_long(frase)) 21 | # CP2: se proporciona una frase con una sola palabra. 22 | print('CP2: frase con una sola palabra -->', calcula_long('sol')) 23 | # CP3: se proporciona una cadena vacía. 24 | print('CP3: cadena vacía -->', calcula_long('')) -------------------------------------------------------------------------------- /Cap1/Programa 1_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.15 5 | """ 6 | 7 | def mezcla(lista1, lista2): 8 | """ Genera una lista de tuplas formadas por elementos de las listas. 9 | Parámetros: 10 | lista1: de tipo list. 11 | lista2: de tipo list. 12 | Regresa: 13 | Una lista de tuplas con elementos de las listas tomados de 14 | manera alternada. 15 | """ 16 | return list((x, y) for x, y in zip(lista1[::2], lista2[1::2])) 17 | 18 | # CP1: se proporcionan dos listas de enteros de igual longitud. 19 | l1 = list(range(1, 20, 2)) 20 | l2 = list(range(2, 21, 2)) 21 | print('\nCP1: listas de igual longitud -->', mezcla(l1, l2)) 22 | # CP2: se proporcionan dos listas de cadenas de diferentes longitudes. 23 | l3 = list('electroencefalografista') 24 | l4 = list('extraterritorialidad'.upper()) 25 | print('CP2: listas de diferentes longitudes -->', mezcla(l3, l4)) 26 | # CP3: se proporcionan dos listas vacías. 27 | print('CP3: listas vacías -->', mezcla([], [])) 28 | # CP4: se proporcionan dos listas de datos de diferente tipo. 29 | print('CP4: listas de diferente tipo -->', mezcla(l1, l3)) -------------------------------------------------------------------------------- /Cap1/Programa 1_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.16 5 | """ 6 | 7 | 8 | def quita_todos(lista, valor): 9 | """ Genera una lista con los elementos de la lista que no son iguales al 10 | valor. 11 | Parámetros: 12 | lista: de tipo list. Representa una lista. 13 | valor: representa el dato que no debe aparecer en la nueva lista. 14 | Regresa: 15 | Un lista. 16 | """ 17 | return [elemento for elemento in lista if elemento != valor] 18 | 19 | # CP1: se proporciona una lista y un valor que se encuentra varias veces. 20 | numeros = [30, 50, 30, 30, 25, 41, 18, 30] 21 | print('\nCP1: luego de quitar el 30 -->', quita_todos(numeros, 30)) 22 | # CP2: se proporciona una lista y un valor que no está en la lista. 23 | vocales = list('aeiou') 24 | print('CP2: el valor no está en la lista -->', quita_todos(vocales, 'g')) 25 | # CP3: se proporciona una lista con todos sus elementos iguales y un 26 | # valor igual a estos. 27 | repetidos = [6, 6, 6, 6, 6, 6, 6, 6, 6] 28 | print('CP3: elementos iguales al dado -->', quita_todos(repetidos, 6)) 29 | # CP4: se proporciona una lista vacía. 30 | print('CP4: lista vacía -->', quita_todos([], 6)) 31 | # CP5: se proporciona una lista y un valor de distinto tipo. 32 | print('CP5: lista y valor de distinto tipo -->', quita_todos(vocales, 6)) 33 | 34 | -------------------------------------------------------------------------------- /Cap1/Programa 1_17.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.17 5 | """ 6 | 7 | def genera_cadena(lista1, lista2, separador): 8 | """ Genera una cadena con el contenido de las listas: 9 | el primero de lista1 con el último de lista2, 10 | el segundo de lista1 con el penúltimo de lista2, 11 | etc. 12 | Parámetros: 13 | lista1: de tipo list. 14 | lista2: de tipo list. 15 | separador: de tipo str. Se usa para separar cada par de datos. 16 | Regresa: 17 | Una cadena con el contenido de las listas 18 | Lanza: 19 | ValueError: si las listas tienen distinta longitud. 20 | """ 21 | if len(lista1) == len(lista2): 22 | resultado = '' 23 | for el1, el2 in zip(lista1, lista2[::-1]): 24 | resultado += str(el1) + separador + str(el2) + '\n' 25 | return resultado 26 | raise ValueError('Las listas tienen distintas longitudes.') 27 | 28 | # CP1: se proporcionan dos listas de igual longitud. 29 | ferreteria = ['martillo', 'clavo', 'tenaza', 'destornillador', 'taladro'] 30 | precios = [1500, 195.3, 380.5, 1.2, 250] 31 | cad1 = genera_cadena(ferreteria, precios, ': $') 32 | print('\nCP1 --> listas de igual longitud: \n', cad1) 33 | # CP2: se proporcionan dos listas de igual longitud. 34 | l1 = [1, 2, 3, 4, 5, 6, 7] 35 | l2 = [49, 36, 25, 16, 9, 4, 1] 36 | cad2 = genera_cadena(l1, l2, ' -- ') 37 | print('CP2 --> listas de igual longitud: \n', cad2) 38 | # CP3: se proporcionan dos listas de distinta longitud. 39 | l3 = [36, 25, 16, 9, 4, 1] 40 | try: 41 | cad3 = genera_cadena(l1, l3, ' - ') 42 | print('CP3 --> listas de distinta longitud: \n', cad3) 43 | except Exception as error: 44 | print('CP3 -->', error) 45 | # CP4: se proporcionan dos listas vacías. 46 | print('CP4 --> listas vacías: \n', genera_cadena([], [],', ')) 47 | 48 | -------------------------------------------------------------------------------- /Cap1/Programa 1_18.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.18 5 | """ 6 | 7 | def uno_y_uno(lista1, lista2, separador): 8 | """ Genera una nueva lista mezclando los elementos 9 | de las listas dadas y separador por los caracteres almacenados en separador. 10 | Parámetros: 11 | lista1: de tipo list. 12 | lista2: de tipo list. 13 | separador: de tipo str. Se utiliza para separar pares de elementos. 14 | Regresa: 15 | Una lista de cadenas. 16 | """ 17 | return list(str(el1) + separador + str(el2) for el1, el2 in zip(lista1, lista2)) 18 | 19 | 20 | 21 | def todos_con_todos(lista1, lista2, separador): 22 | """ Genera una nueva lista mezclando cada elemento de lista1 23 | con cada uno de los elementos de lista2. A cada par los 24 | separa con los caracteres almacenados en separador. 25 | Parámetros: 26 | lista1: de tipo list. 27 | lista2: de tipo list. 28 | separador: de tipo str. Se utiliza para separar pares de elementos. 29 | Regresa: 30 | Una lista de cadenas. 31 | """ 32 | return [str(el1) + separador + str(el2) for el1 in lista1 for el2 in lista2] 33 | 34 | print('\nPruebas de la función uno_y_uno()'.upper()) 35 | # CP1: se proporcionan dos listas de cadenas que representan sílabas. 36 | lis1 = ['ver', 'ro', 'a', 'blan'] 37 | lis2 = ['de', 'jo', 'zul', 'co'] 38 | print('\nCP1 (listas de igual longitud):', uno_y_uno(lis1, lis2, '')) 39 | # CP2: se proporcionan dos listas de cadenas de diferente longitud. 40 | lis3 = ['so', 'ma', 'la'] 41 | print('CP2 (diferente longitud):', uno_y_uno(lis1, lis3, '')) 42 | # CP3: se proporcionan dos listas de números. 43 | num = [1, 2, 3, 4] 44 | cubo = [1, 8, 27, 64] 45 | print('CP3 (listas de números):', uno_y_uno(num, cubo, ' --> ')) 46 | 47 | print('\nPruebas de la función todos_con_todos()'.upper()) 48 | # CP4: se proporcionan dos listas de cadenas de diferente longitud. 49 | saludos = ['Buenos días', 'Buenas tardes', 'Buenas noches', 'Hola'] 50 | titulo = ['Sra.', 'Sr.', 'Srta.'] 51 | print('\nCP4 (diferente longitud):', todos_con_todos(saludos, titulo, ' ')) 52 | # CP5: se proporcionan dos listas una de las cuales está vacía. 53 | print('CP5 (con una vacía):', todos_con_todos(saludos, [], ' ')) 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /Cap1/Programa 1_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.2 5 | """ 6 | 7 | def carga_lista(nom_arch): 8 | """ Lee los datos de un archivo de texto y los guarda en una lista. 9 | Cada dato se encuentra en una línea diferente del archivo. 10 | Parámetro: 11 | nom_arch: de tipo str. Indica el nombre del archivo del 12 | cual se leerán los datos. 13 | Regresa: 14 | Una lista con los datos leídos del archivo. 15 | Lanza: 16 | FileNotFoundError: si no se pudo abrir el archivo. 17 | """ 18 | try: 19 | resultado = [] 20 | with open(nom_arch, 'r') as arch: 21 | for dato in arch: 22 | resultado.append(dato.strip()) # Quita el salto de línea. 23 | return resultado 24 | except FileNotFoundError: 25 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 26 | 27 | # ============================================================================= 28 | # Algunas pruebas para la función carga_lista() 29 | # ============================================================================= 30 | 31 | # CP1: se proporciona el nombre de un archivo que tiene valores válidos. 32 | lista1 = carga_lista('escritores') 33 | print('\nCP1:', lista1) 34 | # CP2: se proporciona el nombre de un archivo vacío. 35 | lista2 = carga_lista('pintores') 36 | print('CP2:', lista2) 37 | # CP3: se proporciona el nombre de un archivo que no fue creado. 38 | try: 39 | lista3 = carga_lista('escultores') 40 | print('CP3:', lista3) 41 | except Exception as error: 42 | print('CP3:', error) -------------------------------------------------------------------------------- /Cap1/Programa 1_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.3 5 | """ 6 | 7 | def cuenta_positivos(lista): 8 | """ Cuenta el total de números positivos que contiene la lista. 9 | Parámetro: 10 | lista: de tipo list. Todos sus elementos son del mismo tipo. 11 | Regresa: 12 | La cantidad de números positivos almacenados en la lista. 13 | Lanza: 14 | ValueError: si el parámetro recibido no es una lista o si 15 | sus elementos no son números. 16 | """ 17 | if lista and (type(lista[0]) == int or type(lista[0]) == float): 18 | positivos = 0 19 | for numero in lista: 20 | if numero > 0: 21 | positivos += 1 22 | return positivos 23 | raise ValueError('Error en los datos: no es un dato válido o no tiene números.') 24 | 25 | # ============================================================================= 26 | # Algunas pruebas de la función cuenta_positivos(). 27 | # ============================================================================= 28 | # CP1: se proporciona una lista de números enteros. 29 | lista1 = [405, -107, 210, 5, -23, -45, 87] 30 | print('\nCP1 - Total de positivos =', cuenta_positivos(lista1)) 31 | # CP2: se proporciona una lista de números reales negativos. 32 | lista2 = [-35.61, -10.17, -15.99, -8.5] 33 | print('CP2 - Total de positivos =', cuenta_positivos(lista2)) 34 | # CP3: se proporciona una lista de cadenas de caracteres. 35 | lista3 = ['Costa Rica', 'Colombia', 'Canadá', 'Chile'] 36 | try: 37 | print('CP3 - Total de positivo s=', cuenta_positivos(lista3)) 38 | except ValueError as error: 39 | print('CP3 -', error) 40 | # CP4: no se proporciona una lista. 41 | lista4 = None 42 | try: 43 | print('CP4 - Total de positivos =', cuenta_positivos(lista4)) 44 | except ValueError as error: 45 | print('CP4 -', error) 46 | -------------------------------------------------------------------------------- /Cap1/Programa 1_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.4 5 | """ 6 | 7 | def todos_son_multiplos(lista1, lista2): 8 | """ Determina si cada uno de los elementos de lista2 es múltiplo del 9 | correspondiente elemento de lista1 y, además, si las listas tienen la 10 | misma longitud. 11 | Parámetros: 12 | lista1: de tipo list. Almacena números. 13 | lista2: de tipo list. Almacena números. 14 | Regresa: 15 | True si se cumplen las 2 condiciones, False en caso contrario. 16 | """ 17 | if len(lista1) == len(lista2): 18 | limite = len(lista1) 19 | indice = 0 20 | while indice < limite and lista1[indice] % lista2[indice] == 0: 21 | indice += 1 22 | respuesta = indice == limite 23 | else: 24 | respuesta = False 25 | return respuesta 26 | 27 | def calcula_promedio(lista, n): 28 | """ Calcula y regresa el promedio de los números que están en posiciones 29 | que son múltiplos de n. 30 | Parámetros: 31 | lista: de tipo list. Almacena números enteros o reales. 32 | n: de tipo int y es > 0. 33 | Regresa: 34 | El promedio de algunos números, elegidos por su posición. 35 | Lanza: 36 | ArithmeticError si no se puede calcular el promedio. 37 | """ 38 | suma = 0 39 | contador = 0 40 | for i, elemento in enumerate(lista): 41 | if i % n == 0: 42 | suma += elemento 43 | contador += 1 44 | try: 45 | promedio = suma / contador 46 | return promedio 47 | except: 48 | raise ArithmeticError('No se puede calcular el promedio.') 49 | 50 | # ============================================================================= 51 | # Algunas pruebas de las funcion todos_son_multiplos(). 52 | # ============================================================================= 53 | # CP1: se proporcionan dos listas de números, que cumplen con las condiciones. 54 | lista1 = [9, 16, 15, 8, 21] 55 | lista2 = [3, 2, 5, 8, 7] 56 | if todos_son_multiplos(lista1, lista2): 57 | print('\nCP1: Sí cumplen las condiciones.') 58 | else: 59 | print('\nCP1: No cumplen las condiciones.') 60 | # CP2: se proporcionan dos listas de números con distinta cantidad de elementos. 61 | lista3 = [3, 2, 5, 8] 62 | if todos_son_multiplos(lista1, lista3): 63 | print('CP2: Sí cumplen las condiciones.') 64 | else: 65 | print('CP2: No cumplen las condiciones.') 66 | # CP3: se proporcionan dos listas de números, de igual longitud, pero no todos 67 | # son múltiplos. 68 | lista4 = [4, 2, 5, 8, 7] 69 | if todos_son_multiplos(lista1, lista4): 70 | print('CP3: Sí cumplen las condiciones.') 71 | else: 72 | print('CP3: No cumplen las condiciones.') 73 | # ============================================================================= 74 | # Algunas pruebas de la función calcula_promedio(). 75 | # ============================================================================= 76 | # CP4: se proporciona una lista de números enteros. 77 | lista1 = [11, -20, -7, 45, 10, -16, 14, 17] 78 | prom1 = calcula_promedio(lista1, 2) 79 | print('\nCP4 --> Promedio de enteros =', prom1) 80 | # CP5: se proporciona una lista de números reales. 81 | lista2 = [3.5, -2.8, 2.4, 1.5, -2.3, -3.1, -4.5, 5.2, 3.8, 6.0] 82 | prom2 = calcula_promedio(lista2, 3) 83 | print('CP5 --> Promedio de reales =', prom2) 84 | # CP6: se proporciona una lista vacía. 85 | lista3 = [] 86 | try: 87 | prom3 = calcula_promedio(lista3, 3) 88 | print('CP6 --> Promedio (lista vacía) =', prom3) 89 | except ArithmeticError as error: 90 | print('CP6 -->', error) 91 | -------------------------------------------------------------------------------- /Cap1/Programa 1_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.5 5 | """ 6 | 7 | def determina_minimo_2cadenas(lista): 8 | """ Determina si en la lista hay, por lo menos, dos datos tipo 9 | cadena de caracteres (str). 10 | Parámetro: 11 | lista: de tipo list. Almacena datos que pueden ser de cualquier tipo. 12 | Regresa: 13 | True si se encuentran los datos solicitados, False caso contrario. 14 | """ 15 | limite = len(lista) 16 | indice = 0 17 | contador = 0 18 | while indice < limite and contador < 2: 19 | if type(lista[indice]) == str: 20 | contador += 1 21 | indice += 1 22 | return contador == 2 23 | 24 | # ============================================================================= 25 | # Algunas pruebas de la función determina_minimo_2cadenas() 26 | # ============================================================================= 27 | # CP1: se da una lista con 4 cadenas. 28 | colores = ['rojo', 'verde', 'blanco', 'amarillo'] 29 | if determina_minimo_2cadenas(colores): 30 | print('\nCP1: sí hay, mínimo, 2 cadenas.') # Imprime. 31 | else: 32 | print('\nCP1: no hay, mínimo, 2 cadenas.') 33 | # CP2: se da una lista con 2 cadenas. 34 | lista_mezcla = [305.23, True, 'blanco', 108, 30, 'azul'] 35 | if determina_minimo_2cadenas(lista_mezcla): 36 | print('CP2: sí hay, mínimo, 2 cadenas.') # Imprime. 37 | else: 38 | print('CP2: no hay, mínimo, 2 cadenas.') 39 | # CP3: se da una lista con 1 cadena. 40 | lista_mezcla.pop(5) 41 | if determina_minimo_2cadenas(lista_mezcla): 42 | print('CP3: sí hay, mínimo, 2 cadenas.') 43 | else: 44 | print('CP3: no hay, mínimo, 2 cadenas.') # Imprime. 45 | # CP4: se da una lista de números. 46 | pares = [2, 4, 6, 8] 47 | if determina_minimo_2cadenas(pares): 48 | print('CP4: sí hay, mínimo, 2 cadenas.') 49 | else: 50 | print('CP4: no hay, mínimo, 2 cadenas.') # Imprime. 51 | # CP5: se da una lista vacía. 52 | vacia = [] 53 | if determina_minimo_2cadenas(vacia): 54 | print('CP5: sí hay, mínimo, 2 cadenas.') 55 | else: 56 | print('CP5: no hay, mínimo, 2 cadenas.') # Imprime. 57 | -------------------------------------------------------------------------------- /Cap1/Programa 1_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.6 5 | """ 6 | 7 | def busca(elemento, lista): 8 | """ Busca el elemento en la lista. 9 | Parámetro: 10 | lista: de tipo list. Formada por elementos del mismo tipo. 11 | elemento: dato del mismo tipo que los elementos de la lista. 12 | Regresa: 13 | La posición (índice) del elemento en la lista o -1 si no lo encuentra. 14 | """ 15 | indice = 0 16 | limite = len(lista) 17 | while indice < limite and lista[indice] != elemento: 18 | indice += 1 19 | if indice == limite: # elemento no está en la lista 20 | indice = -1 21 | return indice 22 | 23 | # ============================================================================= 24 | # Algunas pruebas de la función busca() 25 | # ============================================================================= 26 | # CP1: se da una lista de nombres y un nombre que está en la lista. 27 | lista1 = ['David', 'Alicia', 'Dolores', 'Manuel', 'Clara'] 28 | print('\nCP1 - ¿Manuel está en la lista? Posición =', busca('Manuel', lista1)) 29 | # CP2: se da una lista de nombres y un nombre que no está en la lista. 30 | print('CP2 - ¿Pedro está en la lista? Posición =', busca('Pedro', lista1)) 31 | # CP3: se da una lista vacía y un nombre. 32 | lista2 = [] 33 | print('CP3 - ¿Juan está en la lista? Posición =', busca('Juan', lista2)) 34 | -------------------------------------------------------------------------------- /Cap1/Programa 1_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.7 5 | """ 6 | 7 | def busca_copia_ordenada(elemento, lista): 8 | """ Busca el elemento en la lista, luego de generar una copia de esta con 9 | todos sus elementos ordenados crecientemente. 10 | Parámetro: 11 | lista: de tipo list. Formada por elementos del mismo tipo. 12 | elemento: dato del mismo tipo que los elementos de la lista. 13 | Regresa: 14 | La posición del elemento en la lista o -1 si no lo encuentra. 15 | """ 16 | limite = len(lista) 17 | indice = 0 18 | copia = sorted(lista) 19 | while indice < limite and copia[indice] < elemento: 20 | indice += 1 21 | # Casos en los que elemento no está en la lista. 22 | if indice == limite or copia[indice] > elemento: 23 | indice = -1 24 | return indice 25 | 26 | # ============================================================================= 27 | # Algunas pruebas de la función busca_copia_ordenada() 28 | # ============================================================================= 29 | # CP1: se proporciona una lista de nombres y un nombre que está en 30 | # la lista. 31 | lista1 = ['David', 'Alicia', 'Dolores', 'Manuel', 'Clara'] 32 | posicion = busca_copia_ordenada('Manuel', lista1) 33 | if posicion >= 0: 34 | print('\nCP1: Manuel está en la lista') 35 | # CP2: se proporciona una lista de nombres y un nombre que, una vez 36 | # ordenada la lista, debería estar al inicio de esta. 37 | posicion = busca_copia_ordenada('Alan', lista1) 38 | if posicion >= 0: 39 | print('CP2: Alan está en la lista') 40 | else: 41 | print('CP2: Alan no está en la lista') 42 | # CP3: se proporciona una lista de nombres y un nombre que, una vez 43 | # ordenada la lista, debería estar al final de esta. 44 | posicion = busca_copia_ordenada('Samuel', lista1) 45 | if posicion >= 0: 46 | print('CP3: Samuel está en la lista') 47 | else: 48 | print('CP3: Samuel no está en la lista') 49 | # CP4: se proporciona una lista de nombres y un nombre que, una vez 50 | # ordenada la lista, debería estar en una posición intermedia de esta. 51 | posicion = busca_copia_ordenada('Elena', lista1) 52 | if posicion >= 0: 53 | print('CP4: Elena está en la lista') 54 | else: 55 | print('CP4: Elena no está en la lista') 56 | # CP5: se proporciona una lista vacía y un nombre. 57 | lista2 = [] 58 | posicion = busca_copia_ordenada('Jacinto', lista2) 59 | if posicion >= 0: 60 | print('CP5: Jacinto está en la lista') 61 | else: 62 | print('CP5: Jacinto no está en la lista') 63 | -------------------------------------------------------------------------------- /Cap1/Programa 1_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.8 5 | """ 6 | import bisect 7 | 8 | def busca_binaria(elemento, lista): 9 | """ Busca el elemento en la lista. 10 | Parámetro: 11 | lista: de tipo list. Formada por elementos del mismo tipo, 12 | ordenados de menor a mayor. 13 | elemento: dato del mismo tipo que los elementos de la lista. 14 | Regresa: 15 | Una tupla en la que el primer valor (tipo bool) indica si elemento 16 | está o no en la lista y el segundo valor (tipo int) indica la 17 | posición en la que está o en la que debería estar. 18 | """ 19 | izquierdo = 0 20 | derecho = len(lista) - 1 21 | centro = (izquierdo + derecho) // 2 22 | while izquierdo <= derecho and lista[centro] != elemento: 23 | if lista[centro] > elemento: 24 | derecho = centro - 1 25 | else: 26 | izquierdo = centro + 1 27 | centro = (izquierdo + derecho) // 2 28 | if izquierdo > derecho: 29 | esta = False 30 | posicion = izquierdo 31 | else: 32 | esta = True 33 | posicion = centro 34 | return esta, posicion 35 | 36 | # ============================================================================= 37 | # Algunas pruebas de la función busca_binaria() 38 | # ============================================================================= 39 | # CP1: se da una lista ordenada y un dato que está en la lista. 40 | lista1 = ['Alicia', 'Clara', 'David', 'Dolores', 'Luisa', 'Manuel', 'Pedro'] 41 | res1 = busca_binaria('Clara', lista1) 42 | if res1[0]: 43 | print('\nCP1: Clara está en la lista. Posición =', res1[1]) 44 | # CP2: se da una lista ordenada y un dato que no está. 45 | res2 = busca_binaria('Alan', lista1) 46 | if res2[0]: 47 | print('CP2: Alan está en la lista. Posición =', res2[1]) 48 | else: 49 | print('CP2: Alan no está en la lista. Debería estar en:', res2[1]) 50 | # CP3: se da una lista ordenada y un dato que no está. 51 | res3 = busca_binaria('Samuel', lista1) 52 | if res3[0]: 53 | print('CP3: Samuel está en la lista. Posición =', res3[1]) 54 | else: 55 | print('CP3: Samuel no está en la lista. Debería estar en:', res3[1]) 56 | # CP4: se da una lista ordenada y un dato que no está. 57 | res4 = busca_binaria('Elena', lista1) 58 | if res4[0]: 59 | print('CP4: Elena está en la lista. Posición =', res4[1]) 60 | else: 61 | print('CP4: Elena no está en la lista. Debería estar en:', res4[1]) 62 | # CP5: se proporciona una lista vacía y un nombre. 63 | lista2 = [] 64 | res5 = busca_binaria('Irene', lista2) 65 | if res5[0]: 66 | print('CP5: Irene está en la lista. Posición =', res5[1]) 67 | else: 68 | print('CP5: Irene no está en la lista. Debería estar en:', res5[1]) 69 | 70 | -------------------------------------------------------------------------------- /Cap1/Programa 1_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 1.9 5 | """ 6 | 7 | def guarda_invitados(nom_arch, mensaje, lista): 8 | """ Guarda los elementos de la lista en un archivo. 9 | Parámetro: 10 | nom_arch: de tipo str. Indica el nombre del archivo 11 | en el cual se escribirán los elementos de la lista. 12 | mensaje: de tipo str. Es un título para el archivo. 13 | lista: de tipo list. 14 | Lanza: 15 | FileNotFoundError: si no se puede abrir el archivo. 16 | """ 17 | try: 18 | with open(nom_arch, 'w') as arch: 19 | arch.write(mensaje + '\n\n') 20 | for dato in lista: 21 | arch.write(dato + '\n') 22 | except FileNotFoundError: 23 | raise FileNotFoundError('Error: archivo de salida.'.upper()) 24 | 25 | def carga_lista_ordenada(nom_arch): 26 | """ Lee los datos de un archivo de texto y los guarda en 27 | una lista, dejándola ordenada de menor a mayor. 28 | Cada dato se encuentra en una línea diferente del archivo. 29 | Parámetro: 30 | nom_arch: de tipo str. Indica el nombre del archivo. 31 | Regresa: 32 | La lista con los datos leídos, guardados en orden creciente. 33 | Lanza: 34 | FileNotFoundError: si no se puede abrir el archivo. 35 | """ 36 | try: 37 | invitados = [] 38 | with open(nom_arch, 'r') as arch: 39 | for dato in arch: 40 | dato = dato.strip().upper() 41 | res = busca_binaria(dato, invitados) 42 | if not res[0]: 43 | invitados.insert(res[1], dato) 44 | return invitados 45 | except FileNotFoundError: 46 | raise FileNotFoundError('Error: archivo de lectura.'.upper()) 47 | 48 | def busca_binaria(elemento, lista): 49 | """... 50 | """ 51 | izquierdo = 0 52 | derecho = len(lista) - 1 53 | centro = (izquierdo + derecho) // 2 54 | while izquierdo <= derecho and lista[centro] != elemento: 55 | if lista[centro] > elemento: 56 | derecho = centro - 1 57 | else: 58 | izquierdo = centro + 1 59 | centro = (izquierdo + derecho) // 2 60 | if izquierdo > derecho: 61 | esta = False 62 | posicion = izquierdo 63 | else: 64 | esta = True 65 | posicion = centro 66 | return esta, posicion 67 | 68 | # ============================================================================= 69 | # Uso de las funciones para dar solución al problema 1.9 70 | # ============================================================================= 71 | archivo = input('Ingrese el nombre del archivo de invitados: ') 72 | try: 73 | cumple = carga_lista_ordenada(archivo) 74 | nombre = input('Ingrese otro invitado (para terminar, dé enter): ') 75 | while nombre: 76 | nombre = nombre.upper() 77 | res = busca_binaria(nombre, cumple) 78 | if not res[0]: 79 | cumple.insert(res[1], nombre) 80 | nombre = input('Ingrese otro invitado (para terminar, dé enter): ') 81 | archivo = input('Ingrese el nombre del archivo donde se guardará la lista: ') 82 | titulo = input('Ingrese el título de la lista: ') 83 | try: 84 | guarda_invitados(archivo, titulo.upper(), cumple) 85 | except FileNotFoundError as error: 86 | print('\n', error) 87 | except FileNotFoundError as error: 88 | print('\n', error) 89 | 90 | 91 | -------------------------------------------------------------------------------- /Cap1/Tabla del -8: -------------------------------------------------------------------------------- 1 | TABLA DE MULTIPLICAR DEL: -8 2 | 3 | -8 x 1 = -8.00 4 | -8 x 2 = -16.00 5 | -8 x 3 = -24.00 6 | -8 x 4 = -32.00 7 | -8 x 5 = -40.00 8 | -8 x 6 = -48.00 9 | -8 x 7 = -56.00 10 | -8 x 8 = -64.00 11 | -8 x 9 = -72.00 12 | -8 x 10 = -80.00 13 | -8 x 11 = -88.00 14 | -8 x 12 = -96.00 15 | -8 x 13 = -104.00 16 | -8 x 14 = -112.00 17 | -8 x 15 = -120.00 18 | -------------------------------------------------------------------------------- /Cap1/Tabla del 0: -------------------------------------------------------------------------------- 1 | TABLA DE MULTIPLICAR DEL: 0 2 | 3 | 0 x 1 = 0.00 4 | 0 x 2 = 0.00 5 | 0 x 3 = 0.00 6 | 0 x 4 = 0.00 7 | 0 x 5 = 0.00 8 | -------------------------------------------------------------------------------- /Cap1/Tabla del 3_4: -------------------------------------------------------------------------------- 1 | TABLA DE MULTIPLICAR DEL: 3.4 2 | 3 | 3.4 x 1 = 3.40 4 | 3.4 x 2 = 6.80 5 | 3.4 x 3 = 10.20 6 | 3.4 x 4 = 13.60 7 | 3.4 x 5 = 17.00 8 | 3.4 x 6 = 20.40 9 | 3.4 x 7 = 23.80 10 | 3.4 x 8 = 27.20 11 | 3.4 x 9 = 30.60 12 | 3.4 x 10 = 34.00 13 | -------------------------------------------------------------------------------- /Cap1/Tabla del 5: -------------------------------------------------------------------------------- 1 | TABLA DE MULTIPLICAR DEL: 5 2 | 3 | 5 x 1 = 5.00 4 | 5 x 2 = 10.00 5 | 5 x 3 = 15.00 6 | 5 x 4 = 20.00 7 | 5 x 5 = 25.00 8 | 5 x 6 = 30.00 9 | 5 x 7 = 35.00 10 | 5 x 8 = 40.00 11 | 5 x 9 = 45.00 12 | 5 x 10 = 50.00 13 | -------------------------------------------------------------------------------- /Cap1/escritores: -------------------------------------------------------------------------------- 1 | Ernesto Sabato 2 | Elena Garro 3 | Ruben Dario 4 | Julio Cortazar 5 | Santiago Gamboa 6 | Gabriel Garcia Marquez 7 | Octavio Paz 8 | Carlos Fuentes 9 | Gabriela Mistral 10 | -------------------------------------------------------------------------------- /Cap1/invitados: -------------------------------------------------------------------------------- 1 | Lea 2 | Nera 3 | Bala 4 | Rabito 5 | Tom 6 | Pelusa 7 | Nana 8 | Boby 9 | Pancho 10 | Luna 11 | Meli 12 | Gala -------------------------------------------------------------------------------- /Cap1/lista_final: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro2-python/44fd4209b9e3a82b13c7ebcec1a75293bcce8847/Cap1/lista_final -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_1 5 | Conjuntos: definición y algunas operaciones. 6 | """ 7 | # Definición por medio de {} y listado de elementos. 8 | vocales = {'a', 'e', 'i', 'o', 'u'} 9 | print('\nConjunto de las vocales:', vocales) 10 | print('Tipo de dato:', type(vocales)) 11 | 12 | lista = [2, 24, 6, 8, 2] 13 | cadena = 'un granito de sal' 14 | tupla = ('a', 'g', 'k', 'b', 'a') 15 | # Usando el constructor set(). 16 | conj_lis = set(lista) 17 | print('\nA partir de una lista:', conj_lis) 18 | conj_cad = set(cadena) 19 | print('A partir de una cadena:', conj_cad) 20 | conj_tup = set(tupla) 21 | print('A partir de una tupla:', conj_tup) 22 | vacio = set() 23 | print(f'\nConjunto vacío: {vacio} \nCardinalidad = {len(vacio)}') 24 | 25 | # Cardinalidad del conjunto: total de elementos. 26 | print('\nCardinalidad:', len(conj_lis)) 27 | 28 | # Operador de membresía: pertenencia al conjunto. 29 | if 2 in conj_lis: 30 | print('\nEl 2 pertenece al conjunto.') 31 | if 'm' not in vocales: 32 | print('La "m" no pertenece a las vocales.') 33 | -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_2 5 | Operaciones de inserción y eliminación de elementos. 6 | """ 7 | # Se definen algunos conjuntos. 8 | lista = [2, 24, 6, 8, 2] 9 | cadena = 'un granito de sal' 10 | vocales = {'a', 'e', 'i', 'o', 'u'} 11 | conj_lis = set(lista) 12 | conj_cad = set(cadena) 13 | vacio = set() 14 | 15 | # Agrega un elemento al conjunto, siempre que no esté. 16 | print('\nConjunto original:', conj_lis) 17 | conj_lis.add(16) 18 | print('Luego de agregar el 16:', conj_lis) 19 | conj_lis.add(16) # No lo agrega. 20 | print('Luego de intentar con el segundo 16:', conj_lis) 21 | conj_lis.add(64) 22 | conj_lis.add(10) 23 | print('Luego de agregar el 64 y el 10:', conj_lis) 24 | # Agrega todos los elementos del conjunto parámetro. 25 | vocales.update(conj_cad) 26 | print('Luego de agregar otro conjunto:', vocales) 27 | 28 | # Quita aleatoriamente un elemento y lo regresa. 29 | print('\nResultado del pop():', conj_lis.pop()) 30 | print('Resultado del pop():', conj_cad.pop()) 31 | # Genera: KeyError: 'pop from an empty set' 32 | # print('Resultado del pop():', vacio.pop()) 33 | 34 | # Quita un elemento del conjunto. 35 | conj_lis.remove(8) 36 | print('\nLuego de quitar el 8:', conj_lis) 37 | # conj_tup.remove('d') # Provoca: KeyError: 'd' 38 | 39 | vocales.discard('d') # No provoca error. 40 | conj_cad.discard('a') 41 | print('\nLuego de quitar la "a":', conj_cad) 42 | 43 | # Borra todos los elementos del conjunto. 44 | vocales.clear() 45 | print('\nLuego de eliminar todos los elementos:', vocales) 46 | 47 | -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_3 5 | Operaciones entre conjuntos. 6 | """ 7 | 8 | vocales = {'a', 'e', 'i', 'o', 'u'} 9 | letras1 = {'g', 'o', 'm', 'b', 'e', 'a', 'u', 'i'} 10 | letras2 = {'u', 'm', 'b', 'o', 'e', 'i', 'g', 'a'} 11 | consonantes = {'g', 'r', 'd', 's'} 12 | 13 | # Unión de conjuntos. 14 | union1 = vocales.union(consonantes) 15 | union2 = vocales | consonantes 16 | union3 = vocales | letras1 | letras2 | consonantes 17 | print('\nUnión - CP1:', union1) 18 | print('Unión - CP2:', union2) 19 | print('Unión - CP3:', union3) 20 | 21 | # Intersección de conjuntos. 22 | inter1 = letras1.intersection(consonantes) 23 | inter2 = letras1 & vocales 24 | inter3 = vocales.intersection(consonantes) 25 | print('\nIntersección - CP1:', inter1) 26 | print('Intersección - CP2:', inter2) 27 | print('Intersección - CP3:', inter3) 28 | 29 | # Diferencia de conjuntos. 30 | dif1 = letras2.difference(vocales) 31 | dif2 = letras1 - letras2 # Debe quedar vacío. 32 | print('\nDiferencia - CP1:', dif1) 33 | print('Diferencia - CP2:', dif2) 34 | 35 | # Diferencia simétrica de conjuntos. 36 | difsim1 = consonantes.symmetric_difference(letras2) 37 | difsim2 = vocales ^ letras1 38 | print('\nDiferencia simétrica - CP1:', difsim1) 39 | print('Diferencia simétrica - CP2:', difsim2) 40 | 41 | # Igualdad de conjuntos. 42 | if letras1 == letras2: 43 | print('\nSon conjuntos iguales.') # Imprime. 44 | 45 | # Conjuntos distintos. 46 | if vocales != letras1: 47 | print('\nSon conjuntos distintos.') # Imprime. 48 | 49 | # Relación de subconjunto. 50 | if vocales <= letras1: 51 | print('\nSubconjunto - CP1: es un subconjunto.') 52 | else: 53 | print('\nSubconjunto - CP1: no es un subconjunto.') 54 | if vocales.issubset(consonantes): 55 | print('Subconjunto - CP2: es un subconjunto.') 56 | else: 57 | print('Subconjunto - CP2: no es un subconjunto.') 58 | 59 | # Relación de super conjunto. 60 | if letras2 >= vocales: 61 | print('\nSuper conjunto - CP1: es un super conjunto.') 62 | else: 63 | print('\nSuper conjunto - CP1: no es un super conjunto.') 64 | 65 | if letras2.issuperset(consonantes): 66 | print('Super conjunto - CP2: es un super conjunto.') 67 | else: 68 | print('Super conjunto - CP2: no es un super conjunto.') 69 | 70 | # Conjuntos disjuntos. 71 | if vocales.isdisjoint(consonantes): 72 | print('\nSon disjuntos.') # Imprime. 73 | 74 | # Copia de conjuntos. 75 | copia_voc = vocales.copy() 76 | print(f'\nConjunto de vocales: {vocales} y su copia: {copia_voc}') -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_4 5 | Comnbinación del método update() con las operaciones de 6 | intersección, diferencia y diferencia simétrica. 7 | """ 8 | 9 | colores_primarios = {'rojo', 'verde', 'azul'} 10 | colores = {'gris', 'verde', 'azul', 'blanco', 'amarillo', 'negro'} 11 | vocales = {'a', 'e', 'i', 'o', 'u'} 12 | letras = {'g', 'o', 'm', 'b', 'e', 'a', 't', 'y', 'r', 'p', 'c', 'j'} 13 | 14 | # Actualiza el conjunto con el resultado de la intersección. 15 | colores.intersection_update(colores_primarios) 16 | print('\nActualización con intersección:', colores) 17 | 18 | # Actualiza el conjunto con el resultado de la diferencia simétrica. 19 | vocales.symmetric_difference_update(letras) 20 | print('\nActualización con diferencia simétrica:', vocales) 21 | 22 | # Actualiza el conjunto con el resultado de la diferencia. 23 | letras.difference_update(vocales) 24 | print('\nActualización con diferencia:', letras) -------------------------------------------------------------------------------- /Cap2/Ejemplo 2_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 2_5 5 | Ejemplos de conjuntos creados con el tipo frozenset. 6 | """ 7 | 8 | # A partir de una cadena. 9 | vocales = frozenset('aeiou') 10 | # A partir de un conjunto. 11 | colores_primarios = frozenset({'rojo', 'verde', 'azul'}) 12 | # A partir de una tupla. 13 | primos_hasta10 = frozenset((1, 2, 3, 5, 7)) 14 | print('\nUsando una cadena:', vocales) 15 | print('Usando un conjunto:', colores_primarios) 16 | print('Usando una tupla:', primos_hasta10) 17 | print('\nTipo:', type(vocales)) 18 | 19 | # Operación de pertenencia. 20 | if 'verde' in colores_primarios: 21 | print('\nEl verde es un color primario.') 22 | # Operación de cardinalidad. 23 | print('\nCardinalidad de vocales:', len(vocales)) 24 | 25 | # Intento de agregar un elemento, provoca: 26 | # AttributeError: 'frozenset' object has no attribute 'add' 27 | # vocales.add('ü') 28 | 29 | # Operaciones con frozensets. 30 | union1 = vocales | colores_primarios 31 | print('\nUnión de 2 frozensets:', union1) 32 | inter1 = vocales & colores_primarios 33 | print('Intersección de 2 frozensets:', inter1) 34 | 35 | numeros = {1, 25, 53, 18, 32} # Tipo set. 36 | # Unión combinando set y frozenset. 37 | union2 = numeros | primos_hasta10 # Resultado: tipo set. 38 | union3 = primos_hasta10 | numeros # Resultado: tipo frozenset. 39 | print('\nTipo al unir set y frozenset:', type(union2)) 40 | print('Tipo al unir frozenset y set:',type(union3)) 41 | # Comparación entre set y frozenset. 42 | if numeros.isdisjoint(primos_hasta10): 43 | print('\nSon conjuntos disjuntos.') 44 | else: 45 | print('\nNo son conjuntos disjuntos.') 46 | c1 = set('amor') 47 | c2 = frozenset('roma') 48 | if c1 == c2: 49 | print('\nIguales: por contenido.') 50 | else: 51 | print('\nDistintos: por contenido.') 52 | 53 | # Conjuntos de conjuntos. 54 | # Se crea un frozenset con 2 elementos tipo frozenset. 55 | vocales_acentuadas = frozenset({'á', 'é', 'í', 'ó', 'ú'}) 56 | mas_vocales = frozenset((vocales, vocales_acentuadas)) 57 | print('\nConjunto de conjuntos-1:'.upper(), 'tipo', type(mas_vocales)) 58 | print(mas_vocales) 59 | if vocales in mas_vocales: 60 | print('\nLas vocales sí están en el conjunto.') 61 | 62 | # Se crea un set con 2 elementos tipo frozenset. 63 | mezcla = {vocales, colores_primarios} 64 | print('\nConjunto de conjuntos-2:'.upper(), 'tipo', type(mezcla)) 65 | print(mezcla) 66 | mezcla.add('hola') # Permite el cambio. 67 | print('\nLuego de agregar "hola" queda:', mezcla) 68 | print('\nCon una cardinalidad =', len(mezcla)) 69 | -------------------------------------------------------------------------------- /Cap2/Programa 2_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.1 5 | """ 6 | 7 | def contiene_mismos_caract(frase1, frase2): 8 | """ Determina si dos frases tienen los mismos caracteres, sin 9 | importar si se repiten o el orden. 10 | Parámetros: 11 | frase1: de tipo str. 12 | frase2: de tipo str. 13 | Regresa: 14 | True si las frases cumplen con la condición y False en caso contrario. 15 | """ 16 | conj1 = set(frase1) 17 | conj2 = set(frase2) 18 | return conj1 == conj2 19 | 20 | # ============================================================================= 21 | # Uso de la función contiene_mismos_caract(). 22 | # ============================================================================= 23 | frase1 = input('Ingrese una frase: ') 24 | frase2 = input('Ingrese otra frase: ') 25 | if contiene_mismos_caract(frase1, frase2): 26 | print('\nSí tienen los mismos caracteres.') 27 | else: 28 | print('\nNo tienen los mismos caracteres.') 29 | 30 | 31 | -------------------------------------------------------------------------------- /Cap2/Programa 2_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.10 5 | """ 6 | 7 | def quita_repetidos_y_ordena(lista): 8 | """ Genera una lista sin elementos repetidos y ordenada crecientemente. 9 | Parámetro: 10 | lista: de tipo list. 11 | Regresa: 12 | Una lista ordenada y sin elementos repetidos. 13 | """ 14 | sin_repetidos = set(lista) 15 | ordenada = sorted(list(sin_repetidos)) 16 | return ordenada 17 | 18 | # CP1: se proporciona una lista con elementos repetidos y desordenados. 19 | lis1 = [1, 5, 8, 1, 5, 7, 8, 7, 7, 9, 1] 20 | res1 = quita_repetidos_y_ordena(lis1) 21 | print('\nCP1: quita repetidos y ordena -->', res1) 22 | # CP2: se proporciona una lista sin repetidos y ordenada. 23 | lis2 = ['a', 'e', 'i', 'o', 'u'] 24 | res2 = quita_repetidos_y_ordena(lis2) 25 | print('CP2: sin cambios -->', res2) 26 | # CP3: se proporciona una con todos sus elementos iguales. 27 | lis3 = [23, 23, 23, 23, 23, 23, 23] 28 | res3 = quita_repetidos_y_ordena(lis3) 29 | print('CP3: queda un elemento -->', res3) 30 | # CP4: se proporciona una lista vacía. 31 | lis4 = [] 32 | res4 = quita_repetidos_y_ordena(lis4) 33 | print('CP4: lista vacía -->', res4) 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /Cap2/Programa 2_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.11 5 | """ 6 | 7 | def diferencia_subconjunto(conjunto1, conjunto2): 8 | """ Le quita al segundo conjunto los elementos del primero, 9 | solo si el primero es un subconjunto del segundo. 10 | Parámetros: 11 | conjunto1: de tipo set. 12 | conjunto2: de tipo set. 13 | """ 14 | if conjunto1.issubset(conjunto2): 15 | conjunto2 -= conjunto1 16 | 17 | # CP1: se proporcionan un conjunto y un subconjunto de este. 18 | c1 = {1, 3, 5, 7, 9} 19 | c2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 20 | diferencia_subconjunto(c1, c2) 21 | print('\nCP1: conjunto y subconjunto -->', c2) 22 | # CP2: se proporcionan dos conjuntos iguales. 23 | c3 = {'a', 'e', 'i', 'o', 'u'} 24 | c4 = {'o', 'e', 'i', 'a', 'u'} 25 | diferencia_subconjunto(c3, c4) 26 | print('CP2: dos conjuntos iguales -->', c4) 27 | # CP3: se proporcionan un conjunto y un subconjunto vacío. 28 | vacio = set() 29 | diferencia_subconjunto(vacio, c3) 30 | print('CP3: conjunto y uno vacío -->', c3) 31 | # CP4: se proporcionan dos conjuntos sin relación entre ellos. 32 | diferencia_subconjunto(c1, c3) 33 | print('CP4: dos conjuntos sin relación -->', c3) 34 | 35 | -------------------------------------------------------------------------------- /Cap2/Programa 2_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.12 5 | """ 6 | 7 | 8 | def essubconj(conjunto1, conjunto2): 9 | """ Determina si el conjunto1 es un subconjunto del conjunto2. 10 | Parámetros: 11 | conjunto1: de tipo set o frozenset. 12 | conjunto2: de tipo set o frozenset. 13 | Regresa: 14 | True si se cumple la condición y False en caso contrario. 15 | """ 16 | n1 = len(conjunto1) 17 | if n1 <= len(conjunto2): 18 | resp = True 19 | for el in conjunto1: 20 | if el not in conjunto2: 21 | resp = False 22 | break 23 | else: 24 | resp = False 25 | return resp 26 | 27 | def diferencia(conjunto2, conjunto1): 28 | """ Quita al conjunto2 los elementos del conjunto1. 29 | Parámetros: 30 | conjunto1: de tipo set. 31 | conjunto2: de tipo set. 32 | """ 33 | for el in conjunto1: 34 | conjunto2.discard(el) 35 | 36 | def diferencia_subconjunto(conjunto1, conjunto2): 37 | """ Le quita al segundo conjunto los elementos del primero, 38 | solo si el primero es un subconjunto del segundo. 39 | Parámetros: 40 | conjunto1: de tipo set. 41 | conjunto2: de tipo set. 42 | """ 43 | if essubconj(conjunto1, conjunto2): 44 | diferencia(conjunto2, conjunto1) 45 | 46 | # CP1: se proporcionan un conjunto y un subconjunto de este. 47 | c1 = {1, 3, 5, 7, 9} 48 | c2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 49 | diferencia_subconjunto(c1, c2) 50 | print('\nCP1: conjunto y subconjunto -->', c2) 51 | # CP2: se proporcionan dos conjuntos iguales. 52 | c3 = {'a', 'e', 'i', 'o', 'u'} 53 | c4 = {'o', 'e', 'i', 'a', 'u'} 54 | diferencia_subconjunto(c3, c4) 55 | print('CP2: dos conjuntos iguales -->', c4) 56 | # CP3: se proporcionan un conjunto y un subconjunto vacío. 57 | vacio = set() 58 | diferencia_subconjunto(vacio, c3) 59 | print('CP3: conjunto y uno vacío -->', c3) 60 | # CP4: se proporcionan dos conjuntos sin relación entre ellos. 61 | diferencia_subconjunto(c1, c3) 62 | print('CP4: dos conjuntos sin relación -->', c3) 63 | -------------------------------------------------------------------------------- /Cap2/Programa 2_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.2 5 | """ 6 | 7 | def realiza_encuesta(ingles, chino, frances, otros): 8 | """ Despliega la encuesta y pide la respuesta. 9 | Agrega la respuesta al grupo que corresponda. 10 | Parámetros: 11 | ingles: de tipo set. Se guardarán los documentos de los que dominan inglés. 12 | chino: de tipo set. Lo mismo para el chino. 13 | frances: de tipo set. Lo mismos para el francés. 14 | otros: de tipo list. Se guardarán los documentos de las 15 | personas que dominen otros idiomas. 16 | """ 17 | idioma = contesta() 18 | while idioma != 'T': 19 | docum = input('Ingrese su documento de identidad: ') 20 | if idioma == 'I': 21 | ingles.add(docum) 22 | elif idioma == 'C': 23 | chino.add(docum) 24 | elif idioma == 'F': 25 | frances.add(docum) 26 | else: 27 | otros.append(docum) 28 | idioma = contesta() 29 | 30 | def contesta(): 31 | """ Solicita el idioma que domina el encuestado. 32 | Regresa: 33 | Una letra que indica el idioma que domina el encuestado. 34 | """ 35 | print('\n¿Qué idioma extranjero domina?'.upper()) 36 | print('I-Inglés, C-Chino, F-Francés, O-Otros') 37 | print(f'\n-Ingrese uno a la vez. Si domina más de uno, diferente' 38 | f' de los 3 nombrados, vuelva a contestar la encuesta.') 39 | print(f'-Para terminar la encuesta ingrese T') 40 | resp = input('Opción elegida: ') 41 | return resp.upper() 42 | 43 | # Inicialmente están los conjuntos y la lista vacíos. 44 | ingles = set() 45 | chino = set() 46 | frances = set() 47 | otros = list() 48 | # Se capturan las respuestas de los encuestados. 49 | realiza_encuesta(ingles, chino, frances, otros) 50 | conj_otros = set(otros) # Favorece algunas operaciones. 51 | # Inciso 1. 52 | print('\nTotal de personas que dominan inglés:', len(ingles)) 53 | print('Total de personas que dominan chino:', len(chino)) 54 | print('Total de personas que dominan francés:', len(frances)) 55 | # Inciso 2. 56 | union_de3 = ingles.union(frances, chino) 57 | respuesta = union_de3.intersection(conj_otros) 58 | print(f'\nTotal de encuestados que dominan, por lo menos, uno de los 3' 59 | f' y uno de los otros:', len(respuesta)) 60 | # Inciso 3. 61 | dos_otros = set() 62 | for doc in otros: 63 | if otros.count(doc) >= 2: 64 | dos_otros.add(doc) 65 | print('\nTotal de encuestados que dominan, por lo menos, dos de los ' 66 | f'otros idiomas:', len(dos_otros)) 67 | # Inciso 4. 68 | chi_ing = chino.difference(ingles) 69 | if len(chi_ing) == 0: 70 | print(f'\nTodos los encuestados que dominan chino también ' 71 | f'dominan inglés.') 72 | else: 73 | print(f'\nNo todos los encuestados que dominan chino también ' 74 | f'dominan inglés.') 75 | # Inciso 5. 76 | solo_otros = conj_otros.difference(union_de3) 77 | total_solo_otros = len(solo_otros) 78 | if total_solo_otros > 0: 79 | print(f'\nHay {total_solo_otros} encuestados que dominan idiomas ' 80 | f'diferentes a: inglés, chino y francés.') 81 | 82 | 83 | 84 | -------------------------------------------------------------------------------- /Cap2/Programa 2_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.3 5 | """ 6 | 7 | def cuenta_comunes(conj1, conj2): 8 | """ Obtiene el total de elementos comunes entre los 2 conjuntos. 9 | Parámetros: 10 | conj1: de tipo set o frozenset. 11 | conj2: de tipo set o frozenset. 12 | Regresa: 13 | La cantidad (tipo int) de elementos comunes a ambos conjuntos. 14 | """ 15 | comunes = 0 16 | if len(conj1) < len(conj2): 17 | arecorrer = conj1 18 | otro = conj2 19 | else: 20 | arecorrer = conj2 21 | otro = conj1 22 | for ele in arecorrer: 23 | if ele in otro: 24 | comunes += 1 25 | return comunes 26 | 27 | # ============================================================================= 28 | # Algunas pruebas de la función cuenta_comunes() 29 | # ============================================================================= 30 | vocales = {'a', 'e', 'i', 'o', 'u'} 31 | letras = {'g', 'o', 'm', 'b', 'e', 'a', 'u', 'i'} 32 | vacio = {} 33 | consonantes = {'g', 'r', 'd', 's'} 34 | vocales_completas = frozenset('áéíóúüaeiou') 35 | # CP1: se proporcionan conjuntos que tienen elementos en común. 36 | print('\nCP1:', cuenta_comunes(vocales, letras)) 37 | # CP2: se proporcionan conjuntos que no tienen elementos en común. 38 | print('CP2:', cuenta_comunes(vocales, consonantes)) 39 | # CP3: se proporcionan un conjunto vacío y otro con elementos. 40 | print('CP3:', cuenta_comunes(consonantes, vacio)) 41 | # CP4: se proporcionan un set y un frozenset que tienen elementos en común. 42 | print('CP4:', cuenta_comunes(vocales, vocales_completas)) -------------------------------------------------------------------------------- /Cap2/Programa 2_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.4 5 | """ 6 | 7 | # Solución 1: regresando una tupla de conjuntos. 8 | def pares_impares1(conj): 9 | """ Genera dos subconjuntos, uno formado por números pares 10 | y otro con números impares. 11 | Parámetro: 12 | conj: de tipo set. Almacena números enteros. 13 | Regresa: 14 | Una tupla formada por dos conjuntos. 15 | """ 16 | pares = set() 17 | impares = set() 18 | for num in conj: 19 | if num % 2 == 0: 20 | pares.add(num) 21 | else: 22 | impares.add(num) 23 | return pares, impares 24 | 25 | # Solución 2: usando 2 de los parámetros para guardar los resultados. 26 | def pares_impares2(conj, pares, impares): 27 | """... 28 | Parámetros: 29 | conj: de tipo set. Almacena números enteros. 30 | pares: de tipo set. Llega vacío y almacenará los números pares. 31 | impares: de tipo set. Llega vacío y almacenará los números impares. 32 | """ 33 | for num in conj: 34 | if num % 2 == 0: 35 | pares.add(num) 36 | else: 37 | impares.add(num) 38 | 39 | # ============================================================================= 40 | # Algunas pruebas de la función pares_impares1(). 41 | # ============================================================================= 42 | numeros = {1, 25, 53, 18, 32, 17, 41, 84, 46, 38, 52, 13, 57} 43 | solopares = {22, 30, 18, 46, 54, 74} 44 | vacio = set() 45 | # CP1: se proporciona un conjunto con números pares e impares. 46 | pares1, impares1 = pares_impares1(numeros) 47 | print(f'\nCP1 --> Pares: {pares1} - Impares: {impares1}') 48 | # CP2: se proporciona un conjunto solo con números pares. 49 | pares2, impares2 = pares_impares1(solopares) 50 | print(f'CP2 --> Pares: {pares2} - Impares: {impares2}') 51 | # CP3: se proporciona un conjunto vacío. 52 | pares3, impares3 = pares_impares1(vacio) 53 | print(f'CP3 --> Pares: {pares3} - Impares: {impares3}') 54 | 55 | # ============================================================================= 56 | # Algunas pruebas de la función pares_impares2(). 57 | # ============================================================================= 58 | # CP1: se proporciona un conjunto con números pares e impares. 59 | pares1 = set() 60 | impares1 = set() 61 | pares_impares2(numeros, pares1, impares1) 62 | print(f'\nCP1 --> Pares: {pares1} - Impares: {impares1}') 63 | # CP2: se proporciona un conjunto solo con números pares. 64 | pares2 = set() 65 | impares2 = set() 66 | pares_impares2(solopares, pares2, impares2) 67 | print(f'CP2 --> Pares: {pares2} - Impares: {impares2}') 68 | # CP3: se proporciona un conjunto vacío. 69 | pares3 = set() 70 | impares3 = set() 71 | pares_impares2(vacio, pares3, impares3) 72 | print(f'CP3 --> Pares: {pares3} - Impares: {impares3}') 73 | -------------------------------------------------------------------------------- /Cap2/Programa 2_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.5 5 | """ 6 | 7 | def lectura(archivo): 8 | """ Lee desde un archivo los nombres de estudiantes que practican cierto 9 | deporte y los guarda en un conjunto. 10 | Parámetro: 11 | archivo: de tipo str. Representa el nombre del archivo. 12 | Regresa: 13 | Un conjunto que almacena cadenas (nombres de los estudiantes). 14 | Lanza: 15 | FileNotFoundError: si no se puede abrir el archivo. 16 | """ 17 | try: 18 | dep = set() 19 | with open(archivo, 'r') as lee: 20 | alum = lee.readline().strip() 21 | while alum != '': 22 | dep.add(alum) 23 | alum = lee.readline().strip() 24 | return dep 25 | except FileNotFoundError: 26 | raise FileNotFoundError('No se pudo abrir el archivo.'.upper()) 27 | 28 | def estudiantes_por_deporte(titulo, jugadores): 29 | """ Genera una cadena con el contenido de un conjunto. 30 | Parámetros: 31 | titulo: de tipo str. Es un mensaje que quiere 32 | incluirse en el encabezado de la cadena que se forma. 33 | jugadores: de tipo set. Almacena nombres de jugadores. 34 | Regresa: 35 | Una cadena con un título y nombres de jugadores. 36 | """ 37 | res = ('\nLista de jugadores que practican ' + titulo + '\n').upper() 38 | for jug in jugadores: 39 | res += jug + '\n' 40 | return res 41 | 42 | # Lectura de los nombres de los estudiantes, por deporte. 43 | fut = lectura('futbol') 44 | basq = lectura('basquetbol') 45 | vol = lectura('voleibol') # Usar archivo "volei" para probar el inciso 5. 46 | 47 | # Inciso 1: nombres de estudiantes que practican voleibol. 48 | print(estudiantes_por_deporte('Voleibol', vol)) 49 | # Inciso 2: cantidad de estudiantes que solo practican un deporte. 50 | union_de3 = fut | basq | vol 51 | inter_de3 = fut & basq & vol 52 | solo_un_dep = union_de3 - inter_de3 53 | print('Total de estudiantes que solo practican 1 deporte:', len(solo_un_dep)) 54 | # Inciso 3: nombre de los estudiantes que practican los 3 deportes. 55 | print(estudiantes_por_deporte('los 3 deportes', inter_de3)) 56 | # Inciso 4: nombre de los que solo practican fútbol. 57 | solo_fut = fut - basq - vol 58 | print(estudiantes_por_deporte('solo fútbol', solo_fut)) 59 | # Inciso 5: nombre del deporte que practican estudiantes como 60 | # único deporte. 61 | if len(fut & basq) == 0 and len(fut & vol) == 0: 62 | print('Todos los que practican fútbol no practican otro deporte.') 63 | elif len(basq & fut) == 0 and len(basq & vol) == 0: 64 | print('Todos los que practican basquetbol no practican otro deporte.') 65 | elif len(vol & fut) == 0 and len(vol & basq) == 0: 66 | print('Todos los que practican voleibol no practican otro deporte.') 67 | else: 68 | print(f'En todos los deportes participa, al menos, un jugador que ' 69 | f'practica un segundo deporte.') 70 | 71 | -------------------------------------------------------------------------------- /Cap2/Programa 2_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.6 5 | """ 6 | 7 | def es_panvocalica(palabra): 8 | """ Determina si la palabra es panvocálica. 9 | Parámetro: 10 | palabra: de tipo str. 11 | Regresa: 12 | True si la palabra es panvocálica y False en caso contrario. 13 | """ 14 | n = len(palabra) 15 | if n >= 5: 16 | vocales = {'a', 'e', 'i', 'o', 'u'} 17 | panvo = set() 18 | indice = 0 19 | resp = True 20 | while indice < n and resp: 21 | letra = palabra[indice] 22 | if letra in vocales: 23 | if letra not in panvo: 24 | panvo.add(letra) 25 | else: 26 | resp = False # Porque se repite. 27 | indice += 1 28 | resp = resp and len(panvo) == 5 # Están las 5 vocales sin repetir. 29 | else: 30 | resp = False 31 | return resp 32 | 33 | # ============================================================================= 34 | # Algunas pruebas de la función es_panvocálica 35 | # ============================================================================= 36 | # CP1: se da una palabra panvocálica. 37 | if es_panvocalica('enunciado'): 38 | print('\nCP1: la palabra "enunciado" es panvocálica.') 39 | else: 40 | print('\nCP1: la palabra "enunciado" no es panvocálica.') 41 | # CP2: se da una palabra con las 5 vocales, pero hay repetidas. 42 | if es_panvocalica('ayuntamiento'): 43 | print('CP2: la palabra "ayuntamiento" es panvocálica.') 44 | else: 45 | print('CP2: la palabra "ayuntamiento" no es panvocálica.') 46 | # CP3: se da una palabra que no tiene las 5 vocales. 47 | if es_panvocalica('detergente'): 48 | print('CP3: la palabra "detergente" es panvocálica.') 49 | else: 50 | print('CP3: la palabra "detergente" no es panvocálica.') 51 | # CP4: se da una palabra panvocálica. 52 | if es_panvocalica('pauperismo'): 53 | print('CP4: la palabra "pauperismo" es panvocálica.') 54 | else: 55 | print('CP4: la palabra "pauperismo" no es panvocálica.') 56 | # CP5: se da una palabra de longitud menor a 5. 57 | if es_panvocalica('miau'): 58 | print('CP5: la palabra "miau" es panvocálica.') 59 | else: 60 | print('CP5: la palabra "miau" no es panvocálica.') 61 | 62 | -------------------------------------------------------------------------------- /Cap2/Programa 2_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.7 5 | """ 6 | 7 | # Alternativa de solución 1 (presentada en el libro y en el vídeo). 8 | def es_pangrama(alfabeto, texto): 9 | """ Determina si el texto es un pangrama. 10 | Parámetros: 11 | alfabeto: de tipo set. Almacena todos los caracteres de un alfabeto. 12 | texto: de tipo str. Es el texto que debe analizarse. 13 | Regresa: 14 | True si el texto es un pangrama y False en caso contrario. 15 | """ 16 | long_tex = len(texto) 17 | resp = False 18 | if long_tex >= len(alfabeto): 19 | indice = 0 20 | while indice < long_tex and len(alfabeto) > 0: 21 | if texto[indice] in alfabeto: 22 | alfabeto.remove(texto[indice]) 23 | indice += 1 24 | resp = len(alfabeto) == 0 25 | return resp 26 | 27 | # Alternativa de solución 2. 28 | def es_pangrama_2(alfabeto, texto): 29 | for caracter in alfabeto: 30 | if caracter not in texto: 31 | return False 32 | return True 33 | 34 | # Alternativa de solución 3: utiliza solo conjuntos. 35 | def es_pangrama_3(alfabeto, texto): 36 | conj_texto = set(texto) 37 | return conj_texto.issuperset(alfabeto) 38 | 39 | arch_alf = input('\nIngrese nombre del archivo con el alfabeto: ') 40 | arch_tex = input('Ingrese nombre del archivo con el texto: ') 41 | try: 42 | conj_alf = set() 43 | with open(arch_alf, 'r') as alf: 44 | for letra in alf: 45 | conj_alf.add(letra.strip().lower()) 46 | with open(arch_tex, 'r') as tex: 47 | texto = tex.read().lower() 48 | except FileNotFoundError: 49 | print('\nNo se pudo abrir uno o ninguno de los archivos.') 50 | else: 51 | if es_pangrama(conj_alf, texto): 52 | print('\nEs un pangrama.'.upper()) 53 | else: 54 | print('\nNo es un pangrama.'.upper()) 55 | 56 | -------------------------------------------------------------------------------- /Cap2/Programa 2_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.8 5 | """ 6 | 7 | def conjunto_tuplas(lista1, lista2): 8 | """ Genera un conjunto de tuplas con pares de elementos de las listas. 9 | Parámetros: 10 | lista1: de tipo list. 11 | lista2: de tipo list. 12 | Regresa: 13 | Un conjunto formado por tuplas de pares de elementos de las listas. 14 | Lanza: 15 | ValueError: si las listas tienen distinta longitud. 16 | """ 17 | if len(lista1) != len(lista2): 18 | raise ValueError('Listas de diferente longitud.') 19 | mezcla = zip(lista1, lista2) 20 | return set(mezcla) 21 | 22 | # CP1: se proporcionan dos listas de igual longitud. 23 | l1 = list('aeiou') 24 | l2 = list('AEIOU') 25 | print('\nCP1:', conjunto_tuplas(l1, l2)) 26 | # CP2: se proporcionan dos listas vacías. 27 | l3 = [] 28 | l4 = [] 29 | print('CP2:', conjunto_tuplas(l3, l4)) 30 | # CP3: se proporcionan dos listas de distinto tamaño. 31 | l5 = [12, 35, 78] 32 | try: 33 | print('CP3:', conjunto_tuplas(l1, l5)) 34 | except ValueError as error: 35 | print('CP3:', error) 36 | 37 | -------------------------------------------------------------------------------- /Cap2/Programa 2_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 2.9 5 | """ 6 | 7 | 8 | def aparece_dos_veces(palabra): 9 | """ Determina si todas las letras de la palabra están exactamente 2 veces. 10 | Parámetro: 11 | palabra: de tipo str. 12 | Regresa: 13 | True si la palabra cumple la condición y False en caso contrario. 14 | """ 15 | n = len(palabra) 16 | # Debe tener, por lo menos, dos caracteres y un número par de 17 | # caracteres para poder cumplir con la propiedad que se pide. 18 | if n > 1 and n % 2 == 0: 19 | primera = set() 20 | segunda = set() 21 | indice = 0 22 | resp = True 23 | while indice < n and resp: 24 | letra = palabra[indice] 25 | if letra not in primera: 26 | primera.add(letra) 27 | else: 28 | if letra not in segunda: 29 | segunda.add(letra) 30 | else: 31 | resp = False # Está más de 2 veces. 32 | indice += 1 33 | resp = resp and len(primera) == len(segunda) 34 | else: 35 | resp = False 36 | return resp 37 | 38 | # Algunas pruebas de la función. 39 | print('\nCP1: la palabra "papa" -->', aparece_dos_veces('papa')) 40 | print('CP2: la palabra "nenes" -->', aparece_dos_veces('nenes')) 41 | print('CP3: la palabra "detergente" -->', aparece_dos_veces('detergente')) 42 | print('CP4: la palabra "tratar" -->', aparece_dos_veces('tratar')) 43 | # Se quitó el acento a termómetro. 44 | print('CP5: la palabra "termometro" -->', aparece_dos_veces('termometro')) 45 | print('CP6: una cadena vacía -->', aparece_dos_veces('')) 46 | -------------------------------------------------------------------------------- /Cap2/basquetbol: -------------------------------------------------------------------------------- 1 | Luis 2 | Juan 3 | Pedro 4 | Carlos 5 | Marcos 6 | David 7 | Omar 8 | Walter 9 | Francisco 10 | Leonardo 11 | Ricardo 12 | Javier 13 | -------------------------------------------------------------------------------- /Cap2/delirio: -------------------------------------------------------------------------------- 1 | Al fin y al cabo era desagradable y misteriosa la existencia de un extranjero en una habitacion familiar. 2 | Fue una mujer abnegada que viajo con la yegua mas vieja que solo pesaba sesenta kilos. 3 | -------------------------------------------------------------------------------- /Cap2/esping: -------------------------------------------------------------------------------- 1 | a 2 | b 3 | c 4 | d 5 | e 6 | f 7 | g 8 | h 9 | i 10 | j 11 | k 12 | l 13 | m 14 | n 15 | o 16 | p 17 | q 18 | r 19 | s 20 | t 21 | u 22 | v 23 | w 24 | x 25 | y 26 | z 27 | -------------------------------------------------------------------------------- /Cap2/fox: -------------------------------------------------------------------------------- 1 | the quick brown fox jumps over the lazy dog -------------------------------------------------------------------------------- /Cap2/futbol: -------------------------------------------------------------------------------- 1 | Luis 2 | Juan 3 | Pedro 4 | Carlos 5 | Marcos 6 | Lucas 7 | David 8 | Omar 9 | Walter 10 | Ramiro 11 | Gonzalo 12 | Francisco 13 | Leonardo 14 | Julio 15 | Ricardo 16 | Javier 17 | -------------------------------------------------------------------------------- /Cap2/kiwi: -------------------------------------------------------------------------------- 1 | el kiwi de nueva zelanda es un exquisito manjar para hombres que estan bastante fatigados y con angustia -------------------------------------------------------------------------------- /Cap2/volei: -------------------------------------------------------------------------------- 1 | Daniel 2 | Paco 3 | Alejandro 4 | Felipe 5 | Pablo 6 | Mario 7 | Horacio 8 | Eduardo -------------------------------------------------------------------------------- /Cap2/voleibol: -------------------------------------------------------------------------------- 1 | Luis 2 | Marcos 3 | David 4 | Walter 5 | Ramiro 6 | Gonzalo 7 | Manuel 8 | Ricardo 9 | Javier 10 | Bernardo 11 | Guillermo 12 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_1 5 | Construcción de diccionarios. 6 | """ 7 | 8 | # La clave es una cadena. 9 | num_meses = {'enero': 1, 'febrero': 2, 'marzo': 3, 'abril': 4, 'mayo': 5, 'junio': 6} 10 | print('\n', num_meses) 11 | # La clave es un entero. 12 | nom_meses = {1: 'enero', 2: 'febrero', 3: 'marzo', 4: 'abril', 5: 'mayo', 6: 'junio'} 13 | print(nom_meses) 14 | # Genera un diccionario con las claves tomadas de la lista y el valor 5. 15 | puntaje = {}.fromkeys(['futbol', 'basquetbol', 'tenis', 'natación'], 5) 16 | print(puntaje) 17 | frutas = {'manzana': 34, 'pera': 45} 18 | print('\nEl tipo es:', type(frutas)) # Imprime 19 | 20 | # Uso del constructor dict para construir diccionarios. 21 | # Por medio de una lista de tuplas. 22 | dic1 = dict([('La Paz', 13), ('Lima', 27), ('Caracas', 30), ('Montevideo', 23)]) 23 | print('\nCon lista de tuplas:', dic1) 24 | # Por medio de una lista por comprensión. 25 | dpares = dict([(n, n ** 3) for n in range(1, 5)]) 26 | print('Con lista por comprensión:', dpares) 27 | # Usando parámetros de palabras claves. 28 | dic2 = dict(juan = 56287041, irene = 98741245) 29 | print('Con parámetros de palabras claves:', dic2) 30 | # Por medio de un diccionario. 31 | dic3 = dict({'irene': 98741245, 'juan': 56287041}) 32 | print('Con un diccionario:', dic3) 33 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_10 5 | Diccionarios y conjuntos. 6 | """ 7 | 8 | # Se crean 4 diccionarios. 9 | menu1 = {'ensalada': 35, 'sopa': 28, 'pollo': 40, 'fruta': 15} 10 | menu2 = {'ensalada': 35, 'pollo': 40, 'gelatina': 20} 11 | menu3 = {'ensalada': 35, 'sopa': 28, 'ternera': 50, 'pastel': 30} 12 | menu4 = {'ensalada': 35, 'sopa': 28, 'cerdo': 45, 'pastel': 30} 13 | 14 | # Vistas de claves (tratadas como conjuntos) de 3 diccionarios. 15 | claves1 = menu1.keys() 16 | claves2 = menu2.keys() 17 | claves3 = menu3.keys() 18 | claves4 = set(menu4) # Se crea un conjunto a partir de un diccionario. 19 | 20 | # Todos los platillos que se sirven: unión de conjuntos. 21 | platillos = claves1 | claves2 | claves3 | claves4 22 | print('\nLos platillos que se sirven son:', platillos) 23 | # Platillo que se repite en todos los menús: intersección de conjuntos. 24 | lo_comun = claves1 & claves2 & claves3 & claves4 25 | print('\nEn todos los menús se sirve:', lo_comun) 26 | 27 | # Vistas de ítems (tratadas como conjuntos) de 2 diccionarios. 28 | pla_pre1 = menu1.items() 29 | pla_pre2 = menu2.items() 30 | 31 | # Platillo y precio que está en el menú1 pero no en el menú2: 32 | # diferencia de conjuntos. 33 | no_estan = pla_pre1 - pla_pre2 34 | print('\nLos platillos que se sirven en el menú1 y no en el menú2:', no_estan) 35 | 36 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_11 5 | Diccionarios y la función enumerate. 6 | """ 7 | 8 | # Se crea un diccionario con los meses del primer semestre del año y los 9 | # números que los identifican. 10 | primer_semestre = ['enero', 'febrero', 'marzo', 'abril', 'mayo', 'junio'] 11 | mapeo = {} 12 | for i, elemento in enumerate(primer_semestre, 1): # Se enumera a partir del 1. 13 | mapeo[elemento] = i 14 | print('\nMeses-número:\n', mapeo) 15 | 16 | # Se crea un diccionario con las letras del abecedario y los valores decimales 17 | # que les corresponden según el código ASCII. 18 | abecedario = 'abcdefghijklmnopqrstuvwxyz' # Se omite la ñ. 19 | letras = {} 20 | for i, elemento in enumerate(abecedario, 97): # Se enumera a partir del 97. 21 | letras[elemento] = i 22 | print('\nLetras-código ASCII:\n', letras) 23 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_2 5 | Algunas operaciones con diccionarios. 6 | """ 7 | nom_meses = {1: 'enero', 2: 'febrero', 3: 'marzo', 4: 'abril', 5: 'mayo', 6: 'junio'} 8 | puntaje = {}.fromkeys(['futbol', 'basquetbol', 'tenis', 'natación'], 5) 9 | frutas = {'manzana': 34, 'pera': 45} 10 | 11 | # Agrega un nuevo par clave: valor 12 | frutas['cereza'] = 90 13 | print('\nLuego de agregar cereza: 90 -->', frutas) 14 | # Modifica el valor correspondiente a la clave. 15 | frutas['manzana'] = 37 # Como la clave ya está, asigna este valor. 16 | print('Luego de modificar el valor de manzana -->', frutas) 17 | # Agrega los ítems de un diccionario a otro. 18 | nuevo = {} 19 | nuevo.update(puntaje) 20 | print('\nUsando update-1:', nuevo) 21 | nuevo.update(frutas) 22 | print('\nUsando update-2:', nuevo) 23 | frutas['guayaba'] = 32 24 | nuevo.update(frutas) 25 | print('\nUsando update-3:', nuevo) 26 | 27 | # Acceso y modificación a un elemento por medio de su clave. 28 | print('\nEl valor de pera es:', frutas['pera']) 29 | frutas['cereza'] += 10 # Le suma 10 al valor actual. 30 | # frutas['mango'] += 5 # Da KeyError: 'mango' 31 | # Consulta el valor, dada una clave. 32 | print('El valor de cereza:', frutas.get('cereza')) # Regresa el valor. 33 | print('El valor de banana:', frutas.get('banana')) # Regresa None. 34 | 35 | # Elimina el par correspondiente a la clave dada. 36 | del frutas['pera'] 37 | print('\nLuego de quitar pera: 45 -->', frutas) 38 | # del d['higo'] # Da KeyError: 'higo' 39 | elem = nom_meses.pop(1) # Quita el elemento y regresa solo su valor. 40 | print(f'Luego de quitar {elem} -->', nom_meses) 41 | # Quita arbitrariamente un elemento y lo regresa. 42 | elem = nom_meses.popitem() 43 | print(f'Luego de quitar {elem} -->', nom_meses) 44 | nom_meses.clear() # Vacía el diccionario. 45 | print(f'Luego de quitar todos los elementos -->', nom_meses) 46 | 47 | # Uso del operador de membresía: in. Es solo para claves. 48 | if 'cereza' in frutas: 49 | print('\nSí está cereza en el diccionario.') # Imprime. 50 | else: 51 | print('No está cereza en el diccionario.') 52 | if 'uva' not in frutas: 53 | print('No está uva en el diccionario.') # Imprime. 54 | else: 55 | print('Sí está uva en el diccionario.') 56 | if 100 in frutas: # Membresía de un valor. 57 | print('Sí está el 100 en el diccionario.') 58 | else: 59 | print('No está el 100 en el diccionario.') # Imprime. -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_3 5 | Diccionarios: aplicación de funciones predefinidas y operadores. 6 | """ 7 | # Se importa el módulo operator para poder ordenar por valor. 8 | import operator 9 | 10 | num_meses = {'ene': 1, 'feb': 2, 'mar': 3, 'abr': 4, 'may': 5, 'jun': 6} 11 | nom_meses = {1: 'enero', 2: 'febrero', 3: 'marzo', 4: 'abril', 5: 'mayo', 6: 'junio'} 12 | d1 = {1: 'azul', 2: 'rojo', 3: 'verde'} 13 | d2 = {} 14 | d3 = {2: 'rojo', 1: 'azul', 3: 'verde'} 15 | d4 = {0: 'amarillo', 1: 'azul', 2: 'rojo', 3: 'verde'} 16 | 17 | # Regresa el total de elementos del diccionario. 18 | print('\nTotal de elementos del diccionario:', len(num_meses)) 19 | 20 | # Evalúa si todas las claves son True. 21 | print('\nCP1: Resultado de "all" con d1 -->', all(d1)) 22 | print('CP2: Resultado de "all" con d4 -->', all(d4)) 23 | print('CP3: Resultado de "all" con diccionario vacío -->', all(d2)) 24 | # Evalúa si alguna clave es True. 25 | print('\nCP1: Resultado de "any" con d1 -->', any(d1)) 26 | print('CP2: Resultado de "any" con diccionario vacío -->', any(d2)) 27 | 28 | # Regresa una lista de claves ordenadas de mayor a menor. 29 | ordenado = sorted(num_meses, reverse = True) 30 | print('\nClaves ordenadas:', ordenado) 31 | menu = {'helado': 25, 'tarta': 43, 'galleta': 12, 'merengue': 18} 32 | # Genera un diccionario ordenado por valor. 33 | menu_ord = dict(sorted(menu.items(), key = operator.itemgetter(1))) 34 | print('Menú ordenado por precio:', menu_ord) 35 | 36 | # Compara los elementos de dos diccionarios. No importa el orden. 37 | if num_meses == nom_meses: 38 | print('\nSí son iguales.') 39 | else: 40 | print('\nNo son iguales.') # Imprime. 41 | if d1 == d3: 42 | print('Sí son iguales.') # Imprime. 43 | else: 44 | print('No son iguales.') 45 | if d1 != d2: 46 | print('Sí son diferentes.') # Imprime. 47 | else: 48 | print('No son diferentes.') 49 | 50 | 51 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_4 5 | Recorrido de los elementos de un diccionario. 6 | Métodos: keys(), values(), items(). 7 | Diccionarios y listas. 8 | """ 9 | 10 | num_meses = {'ene': 1, 'feb': 2, 'mar': 3, 'abr': 4, 'may': 5, 'jun': 6} 11 | menu = {'helado': 25, 'tarta': 43, 'galleta': 12, 'merengue': 18} 12 | 13 | # Recorrido de diccionarios usando el ciclo for. 14 | for mes in num_meses: 15 | print(mes, ' ', end = '') 16 | suma = 0 17 | for postre in menu: 18 | suma += menu[postre] 19 | print('\nSuma de los precios de los postres: $', suma) 20 | 21 | # Métodos: keys(), values(), items(). 22 | claves = menu.keys() 23 | print('\nTipo de keys():', type(claves)) 24 | print('Claves 1-:', claves) 25 | menu['gelatina'] = 24 # Agrega un ítem al diccionario. 26 | print('Claves 2-:', claves) # Modificado por la inserción de arriba. 27 | 28 | valores = menu.values() 29 | print('\nTipo de values():', type(valores)) 30 | print('Valores 1-', valores) 31 | menu['galleta'] = 16 # Modifica el valor. 32 | print('Valores 2-', valores) # Modificado por la actualización de arriba. 33 | 34 | items = num_meses.items() 35 | print('\nTipo de items():', type(items)) 36 | print('Items 1-', items) 37 | del num_meses['mar'] # Borra el ítem. 38 | print('Items 2-', items) # Modificado por la eliminación de arriba. 39 | 40 | # Regresa el total de elementos de la vista. 41 | print('\nTotal de claves:', len(claves)) 42 | print('Total de ítems:', len(items)) 43 | 44 | # Ordena los elementos de la vista de acuerdo con la clave. 45 | menu_ordenado = sorted(menu.items()) # Genera lista de tuplas. 46 | print('\nMenú ordenado:', menu_ordenado) 47 | # Otra manera de ordenar, usando el constructor dict. 48 | meses_ordenados = dict(sorted(num_meses.items())) # Genera diccionario. 49 | print('Meses ordenados:', meses_ordenados) 50 | 51 | # Uso del operador de membresía en las vistas. 52 | if 'galleta' in claves: # Valor posible de clave. 53 | print('\nSí hay galletas.') 54 | else: 55 | print('\nNo hay galletas.') 56 | if ('alfajor', 31) in items: # Valor posible de ítem. 57 | print('Sí hay alfajores a $31.') 58 | else: 59 | print('No hay alfajores a $31.') 60 | if ('gelatina', 31) in items: # Valor posible de ítem. 61 | print('Sí hay gelatinas a $31.') 62 | else: 63 | print('No hay gelatinas a $31.') 64 | 65 | # Iteración usando clave y valor de cada ítem. 66 | print() 67 | for mes, num in items: 68 | print(f'El mes {mes} es el {num} del año.') 69 | suma_precios = 0 70 | for precio in valores: 71 | suma_precios += precio 72 | print('\nSuma de los precios de los postres = $', suma_precios) 73 | 74 | # Constructor list() aplicado al diccionario. 75 | lista_menu = list(menu) 76 | print('\nLista generada con el diccionario:',lista_menu) 77 | 78 | # Construcción de listas a partir de las vistas de diccionarios. 79 | lista_claves = list(claves) # Genera lista de cadenas. 80 | print('\nLista de claves:', lista_claves) 81 | lista_items = list(items) # Genera lista de tuplas. 82 | print('Lista de ítems:', lista_items) 83 | 84 | # Se obtienen listas ordenadas de menor a mayor. 85 | claves_ord = sorted(lista_claves) 86 | print('\nLista de claves ordenadas:', claves_ord) 87 | valores_ord = sorted(valores) 88 | print('Lista de valores ordenados:', valores_ord) 89 | items_ord = sorted(lista_items) 90 | print('Lista de ítems ordenados:', items_ord) 91 | 92 | 93 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_5 5 | Copia de diccionarios. 6 | """ 7 | 8 | import copy 9 | 10 | num_meses = {'ene': 1, 'feb': 2, 'mar': 3, 'abr': 4, 'may': 5, 'jun': 6} 11 | 12 | # Usando métodos del módulo copy. 13 | copia_meses1 = copy.copy(num_meses) 14 | copia_meses2 = copy.deepcopy(num_meses) 15 | 16 | # Usando la función copy(). 17 | copia_meses = num_meses.copy() 18 | 19 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_6 5 | Creación de diccionarios usando otros datos estructurados. 6 | """ 7 | 8 | # Diccionarios con diccionarios. 9 | alumnos = {'juan': {'matematica': 9.5, 'biologia': 7.5, 'literatura': 8.7, 'fisica': 8.0}, 10 | 'ines': {'matematica': 9.0, 'biologia': 8.5, 'literatura': 6.5, 'fisica': 9.0}, 11 | 'luis': {'matematica': 9.5, 'biologia': 7.5, 'literatura': 8.7, 'fisica': 8.0}} 12 | solo_juan = alumnos['juan'] 13 | print('\nMaterias de Juan:', solo_juan) 14 | calif = solo_juan.values() 15 | prom = sum(calif) / len(calif) 16 | print('Promedio:', prom) 17 | 18 | # Diccionario con listas 19 | pract_dep = {'juan': ['futbol', 'basquetbol'], 'ines': ['tenis', 'voleibol'], 20 | 'luis': ['natacion', 'futbol', 'boxeo']} 21 | deportes = list(pract_dep.values()) 22 | print('\nDeportes practicados por los alumnos:', deportes) 23 | # Iterando sobre la vista de valores. 24 | fut = 0 25 | for dep in deportes: 26 | if 'futbol' in dep: 27 | fut += 1 28 | print('\n(1)Total de alumnos que practican fútbol =', fut) 29 | # Usando listas por comprensión. 30 | lis_dep = [dep for lis in deportes for dep in lis] 31 | print('(2)Total de alumnos que practican fútbol =', lis_dep.count('futbol')) 32 | 33 | # Diccionario con tuplas. 34 | # Tuplas como claves. 35 | equipos = {('pat', 'lara'): 85, ('jorge', 'ines'): 80, ('luis', 'leti'): 103} 36 | print('\nIntegrantes de los equipos y puntajes:', equipos) 37 | puntajes = equipos.values() 38 | ganador = max(puntajes) 39 | print('El mayor número de puntos obtenidos es:', ganador) 40 | # Tuplas como valores. 41 | temporadas = {'cereza': ('verano'), 'naranja': ('otoño', 'invierno', 'primavera', 'verano'), 42 | 'mango': ('primavera', 'verano')} 43 | print('\nLas frutas y sus temporadas'.upper()) 44 | for fruta in temporadas: 45 | print(f'La/el {fruta} se cosecha en: {temporadas[fruta]}') 46 | # Tuplas como claves y valores. 47 | dieta = {('desay', 'merienda'): ('lacteo', 'fruta'), 48 | ('comida', 'cena'): ('proteina', 'vegetal', 'granos', 'fruta')} 49 | resp = True 50 | for alim in dieta: 51 | if 'fruta' not in dieta[alim]: 52 | resp = False 53 | break 54 | if resp: 55 | print('\nSe debe comer fruta con todos los alimentos.') 56 | else: 57 | print('\nNo se debe comer fruta con todos los alimentos.') 58 | 59 | # Mezclando tipos de datos. 60 | dic_mez = {'lluvia': ['lun', 'juev', 'vie'], 25: 'mar'} 61 | print('\nDiversos tipos:', dic_mez) 62 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_7 5 | Definición de diccionarios por comprensión. 6 | """ 7 | 8 | # Ejemplo 1: a partir de un rango. 9 | cuadrados = {n: n*n for n in range(11)} 10 | print('\nCuadrados-1:', cuadrados) 11 | # Se pudo hacer: 12 | otros = {} 13 | for n in range(11): 14 | otros[n] = n * n 15 | print('Cuadrados-2:', otros) 16 | 17 | # Ejemplo 2: a partir de un diccionario. 18 | menu = {'helado': 25, 'tarta': 43, 'galleta': 12, 'merengue': 18} 19 | menu_ord = {pla: pre for pla, pre in sorted(menu.items())} 20 | print('\nMenú ordenado-1:', menu_ord) 21 | # Se pudo hacer: 22 | otro_menu = {} 23 | for pla, pre in sorted(menu.items()): 24 | otro_menu[pla] = pre 25 | print('Menú ordenado-2:', otro_menu) 26 | 27 | # Ejemplo 3: a partir de una lista de tuplas. 28 | lenguajes = [('python', 'medio'), ('java', 'medio'), ('ruby', 'fácil'), 29 | ('lisp', 'difícil')] 30 | leng_dic = {leng: dif for leng, dif in lenguajes} 31 | print('\nLenguajes y dificultad-1:', leng_dic) 32 | # Se pudo hacer: 33 | otro_leng = {} 34 | for leng, dif in lenguajes: 35 | otro_leng[leng] = dif 36 | print('Lenguajes y dificultad-2:', otro_leng) 37 | 38 | 39 | 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_8 5 | Paso de parámetros y diccionarios. 6 | """ 7 | 8 | def calcular(importe, descuento, iva): 9 | """ Calcula el importe final a pagar por una compra. 10 | Parámetros: 11 | importe: de tipo int o float. Indica el monto de la compra. 12 | descuento: de tipo int o float. Descuento que debe aplicarse. 13 | iva: de tipo int o float. % de IVA que debe retenerse. 14 | Regresa: 15 | El total a pagar. 16 | """ 17 | total = importe - (importe * descuento / 100) 18 | total *= 1 + iva / 100 19 | return total 20 | 21 | def suma_valores(**dic): 22 | """ Obtiene la suma de los valores de un diccionario. 23 | Parámetros: 24 | dic: de tipo dict en el cual el valor debe ser numérico. 25 | Regresa: 26 | La suma de los valores del diccionario. 27 | """ 28 | suma = 0 29 | for _, valor in dic.items(): 30 | suma += valor 31 | return suma 32 | 33 | # ============================================================================= 34 | # Algunas pruebas de la función calcular(). 35 | # ============================================================================= 36 | # CP1: se proporciona un diccionario de acuerdo a lo esperado. 37 | compra1 = {'descuento': 8.5, 'iva': 15, 'importe': 720} 38 | print(f'\nTotal a pagar = ${calcular(**compra1):.2f}') 39 | # CP2: falta un dato. Da TypeError. 40 | # compra2 = {'descuento': 8.5, 'importe': 720} 41 | # print(f'\nTotal a pagar = ${calcular(**compra2):.2f}') 42 | # CP3: se proporciona un dato extra. Da TypeError. 43 | # compra3 = {'descuento': 8.5, 'importe': 720, 'iva': 15, 'bono': 50} 44 | # print(f'\nTotal a pagar = ${calcular(**compra3):.2f}') 45 | # CP4: clave no coincide con parámetro. Da TypeError. 46 | # compra4 = {'desc': 8.5, 'importe': 720, 'iva': 15} 47 | # print(f'\nTotal a pagar = ${calcular(**compra4):.2f}') 48 | 49 | 50 | # ============================================================================= 51 | # Algunas pruebas de la función suma_puntos(). 52 | # ============================================================================= 53 | # CP1: se proporcionan 3 parámetros por nombre con sus valores. 54 | print('\nSuma-1:', suma_valores(eq1 = 76, eq2 = 45, eq3 = 81)) 55 | # CP2: se proporcionan 4 parámetros por nombre con sus valores. 56 | print('Suma-2:', suma_valores(a = 1, b = 2, c = 3, d = 4)) 57 | # CP3: se proporcionan 4 parámetros posicionales. Da TypeError. 58 | # print('Suma-3:', suma_valores(11, 35, 44, 28)) 59 | -------------------------------------------------------------------------------- /Cap3/Ejemplo 3_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 3_9 5 | Solución del problema 3.8 sin usar diccionarios. 6 | """ 7 | import random 8 | 9 | espanol = ['cero', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 10 | 'siete', 'ocho', 'nueve', 'diez'] 11 | ingles = ['zero','one', 'two', 'three', 'four', 'five', 'six', 'seven', 12 | 'eight', 'nine', 'ten'] 13 | italiano = ['zero', 'uno', 'due', 'tre', 'quattro', 'cinque', 'sei', 'sette', 14 | 'otto', 'nove', 'dieci'] 15 | frances = ['zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 16 | 'huit', 'neuve', 'dix'] 17 | traduc = list(zip(ingles, italiano, frances)) 18 | 19 | # En cada iteración del while se elige el idioma. 20 | texto = f'Idioma: (1)inglés, (2)italiano, (3)francés o (4)terminar: ' 21 | idioma = int(input(texto)) 22 | while idioma != 4: 23 | numero = random.randint(0, 10) 24 | nom_num = espanol[numero] 25 | respuesta = input(f'¿Cómo se escribe {nom_num}?: ') 26 | posibles_resp = traduc[numero] # Tupla con las 3 traducciones. 27 | traducida = posibles_resp[idioma - 1] # Según el idioma. 28 | if respuesta == traducida: 29 | print('Muy bien:)') 30 | else: 31 | print('Falta estudiar:(') 32 | idioma = int(input(texto)) 33 | 34 | -------------------------------------------------------------------------------- /Cap3/Escribe_en_archivos.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Auxiliar para la creación de archivos con datos leídos de la terminal. 5 | """ 6 | 7 | nom_arch = input('Ingrese el nombre del archivo: ') 8 | with open(nom_arch, 'w') as arch: 9 | dato = input('Dato: ') 10 | while dato != '': 11 | arch.write(dato + '\n') 12 | dato = input('Dato: ') 13 | -------------------------------------------------------------------------------- /Cap3/Programa 3_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.1 5 | """ 6 | 7 | def obtiene_elemento(dic, clave): 8 | """ Regresa una tupla con el elemento del diccionario correspondiente 9 | a clave. 10 | Parámetro: 11 | dic: de tipo dict. 12 | clave: representa una de las posibles claves del diccionario. 13 | Regresa: 14 | Una tupla formada por un ítem del diccionario (clave, valor). 15 | Lanza: 16 | ValueError: si la clave no está en el diccionario. 17 | """ 18 | valor = dic.get(clave) 19 | if valor == None: 20 | raise ValueError(f'La clave "{clave}" no está en el diccionario.') 21 | return clave, valor 22 | 23 | # ============================================================================= 24 | # Algunas pruebas de la función obtiene_elemento() 25 | # ============================================================================= 26 | num_meses = {'ene': 1, 'feb': 2, 'mar': 3, 'abr': 4, 'may': 5, 'jun': 6} 27 | # CP1: se da una clave que está en el diccionario. 28 | print('\nCP1:', obtiene_elemento(num_meses, 'abr')) 29 | # CP2: se da una clave que no está en el diccionario. 30 | try: 31 | print('CP2:', obtiene_elemento(num_meses, 'ago')) 32 | except ValueError as error: 33 | print('CP2:', error) 34 | # CP3: se da un diccionario vacío. 35 | dic = {} 36 | try: 37 | print('CP3:', obtiene_elemento(dic, 25)) 38 | except ValueError as error: 39 | print('CP3:', error) 40 | 41 | -------------------------------------------------------------------------------- /Cap3/Programa 3_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.10 5 | """ 6 | 7 | def cuenta_vocales(cadena): 8 | """ Cuenta el número de veces que aparece cada una de las 9 | vocales en una cadena de caracteres. 10 | Parámetro: 11 | cadena: de tipo str. 12 | Regresa: 13 | Un diccionario que almacena la frecuencia con la que aparece cada 14 | vocal en la cadena. 15 | """ 16 | vocales = {'a': 0, 'e': 0, 'i': 0, 'o': 0, 'u': 0} 17 | for c in cadena: 18 | if c in vocales: 19 | vocales[c] += 1 20 | return vocales 21 | 22 | # CP1: se proporciona una cadena con algunas de las vocales. 23 | cad1 = 'todos los perros se van al cielo' 24 | print('\nCP1: cadena con algunas de las vocales -->', cuenta_vocales(cad1)) 25 | # CP2: se proporciona una cadena con todas las vocales. 26 | cad2 = 'los bomberos se detuvieron junto a los autos' 27 | print('CP2: cadena con todas las vocales -->', cuenta_vocales(cad2)) 28 | # CP3: se proporciona una cadena sin vocales. 29 | cad3 = 'xxxxxxxxx' 30 | print('CP3: cadena sin vocales -->', cuenta_vocales(cad3)) 31 | # CP4: se proporciona una cadena vacía. 32 | cad4 = '' 33 | print('CP4: cadena vacía -->', cuenta_vocales(cad4)) 34 | 35 | 36 | -------------------------------------------------------------------------------- /Cap3/Programa 3_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.11 5 | """ 6 | 7 | def obtiene_largo_palabras(cadena): 8 | """ Obtiene y regresa la longitud de cada una de las palabras 9 | que aparecen en una cadena de caracteres. 10 | Parámetro: 11 | cadena: de tipo str. 12 | Regresa: 13 | Un diccionario que almacena la longitud de cada una de las 14 | palabras que forman la cadena. 15 | """ 16 | longitudes = dict() 17 | palabras = list(cadena.split()) 18 | for pal in palabras: 19 | longitudes[pal] = len(pal) 20 | return longitudes 21 | 22 | 23 | # Usando diccionarios por comprensión. 24 | # def obtiene_largo_palabras(cadena): 25 | # return {pal:len(pal) for pal in list(cadena.split())} 26 | 27 | 28 | # CP1: se proporciona una cadena con varias palabras. 29 | cad1 = 'todos los perros se van al cielo' 30 | print('\nCP1: cadena con varias palabras -->', obtiene_largo_palabras(cad1)) 31 | # CP2: se proporciona una cadena con palabras repetidas. 32 | cad2 = 'los bomberos dirigen a los peatones y a los conductores' 33 | print('\nCP2: cadena con palabras repetidas -->', obtiene_largo_palabras(cad2)) 34 | # CP3: se proporciona una cadena vacía. 35 | print('\nCP3: cadena vacía -->', obtiene_largo_palabras('')) -------------------------------------------------------------------------------- /Cap3/Programa 3_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.12 5 | Cuenta e imprime el número de veces que aparece cada dato de una lista. 6 | """ 7 | 8 | def llena_lista(nombre): 9 | """ Guarda en una lista los datos leídos de un archivo. 10 | Parámetro: 11 | nombre: de tipo str. Nombre del archivo de texto. 12 | Regresa: 13 | Una lista que almacena los datos leídos de un archivo. 14 | Lanza: 15 | FileNotFoundError si no pudo abrir el archivo. 16 | """ 17 | lista = list() 18 | try: 19 | with open(nombre, 'r') as arch: 20 | for elemento in arch: 21 | lista.append(elemento.strip()) 22 | return lista 23 | except FileNotFoundError: 24 | raise FileNotFoundError('No se pudo abrir el archivo.') 25 | 26 | def reporte_frecuencia(frecuencia): 27 | """ Genera un reporte con los datos de la frecuencia. 28 | Parámetro: 29 | frecuencia: de tipo dict. Almacena las frecuencias. 30 | Regresa: 31 | Una cadena con la información del diccionario. 32 | """ 33 | reporte = '\nFrecuencia con la que aparece cada dato de la lista:\n' 34 | items = frecuencia.items() 35 | for dato, frec in items: 36 | reporte += f'{dato} -- {frec} vez/veces\n' 37 | return reporte 38 | 39 | nom_arch = input('Ingrese el nombre del archivo: ') 40 | try: 41 | lista = llena_lista(nom_arch) 42 | except Exception as error: 43 | print(error) 44 | else: 45 | frecuencia = dict() 46 | for elemento in lista: 47 | if elemento in frecuencia: 48 | frecuencia[elemento] += 1 49 | else: 50 | frecuencia[elemento] = 1 51 | print(reporte_frecuencia(frecuencia)) 52 | 53 | 54 | 55 | 56 | -------------------------------------------------------------------------------- /Cap3/Programa 3_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.13 5 | """ 6 | 7 | def consulta_clave_par(diccionario): 8 | """ Obtiene el total de claves que son números pares. 9 | Parámetro: 10 | diccionario: de tipo dict. Las claves deben ser numéricas. 11 | Regresa: 12 | La cantidad de claves que son números pares. 13 | """ 14 | contador = 0 15 | for clave in diccionario: 16 | if clave % 2 == 0: 17 | contador += 1 18 | return contador 19 | 20 | 21 | # CP1: se ingresa un diccionario con claves pares e impares. 22 | dic1 = {2: 4, 3: 9, 4: 16, 5: 25, 6: 36} 23 | print('\nCP1:', consulta_clave_par(dic1)) 24 | # CP2: se ingresa un diccionario con claves impares. 25 | dic2 = {15: 20, 21: 7, 13: 19, 43: 16, 5: 25} 26 | print('CP2:', consulta_clave_par(dic2)) 27 | # CP3: se ingresa un diccionario vacío. 28 | dic3 = dict() 29 | print('CP3:', consulta_clave_par(dic3)) -------------------------------------------------------------------------------- /Cap3/Programa 3_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.14 5 | """ 6 | 7 | def busca_maximo_suma(diccionario): 8 | """ Obtiene el mayor valor luego de sumar los elementos 9 | clave y valor de un diccionario. 10 | Parámetro: 11 | diccionario: de tipo dict. Sus ítems deben estar formados 12 | por números. 13 | Regresa: 14 | El número más grande obtenido al sumar cada pareja: clave+valor. 15 | Lanza: 16 | ValueError: si el diccionario está vacío. 17 | """ 18 | if len(diccionario) >= 1: 19 | claves = list(diccionario.keys()) 20 | valores = list(diccionario.values()) 21 | suma = [c + v for c, v in zip(claves, valores)] 22 | return max(suma) 23 | raise ValueError('El diccionario está vacío.') 24 | 25 | # CP1: se ingresa un diccionario con 4 ítems diferentes. 26 | dic1 = {2: 4, 3: 9, 4: 16, 5: 25} 27 | print('\nCP1:', busca_maximo_suma(dic1)) 28 | # CP2: se ingresa un diccionario con 3 ítems cuyas sumas dan el mismo valor. 29 | dic2 = {15: 20, 5: 30, 13: 22} 30 | print('CP2:', busca_maximo_suma(dic2)) 31 | # CP3: se ingresa un diccionario vacío. 32 | dic3 = dict() 33 | try: 34 | print('CP3:', busca_maximo_suma(dic3)) 35 | except ValueError as error: 36 | print('CP3:', error) 37 | 38 | -------------------------------------------------------------------------------- /Cap3/Programa 3_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.15 5 | Elimina los elementos de una lista que no aparecen como valores 6 | en un diccionario. 7 | """ 8 | 9 | lista = [103, 87, 105, 98, 80, 104, 85, 54, 60] 10 | equipos = {('pat', 'lara'): 85, ('jorge', 'ines'): 80, ('luis', 'leti'): 103} 11 | 12 | lista = [item for item in lista if item in equipos.values()] 13 | print('\nLista luego de eliminar los valores:', lista) 14 | 15 | 16 | -------------------------------------------------------------------------------- /Cap3/Programa 3_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.16 5 | Quita de la lista aquellos elementos que no forman parte de 6 | las tuplas que son claves de un diccionario. 7 | """ 8 | 9 | 10 | equipos = {('pat', 'lara'): 85, ('jorge', 'ines'): 80, ('luis', 'leti'): 103} 11 | nombres = ['jose', 'pat', 'lara', 'alicia', 'ines'] 12 | 13 | solo_nom = list(equipos.keys()) 14 | nombres = [ele for tupla in solo_nom for ele in tupla if ele in nombres] 15 | print('\nLista modificada:', nombres) -------------------------------------------------------------------------------- /Cap3/Programa 3_17.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.17 5 | Genera e imprime la conjugación de verbos regulares 6 | del español en tiempo presente. 7 | """ 8 | 9 | # Diccionario con las declinaciones del presente. 10 | declin = {'ar': ['o', 'as', 'a', 'amos','áis', 'an'], 11 | 'er': ['o', 'es', 'e', 'emos', 'éis', 'en'], 12 | 'ir': ['o', 'es', 'e', 'imos', 'ís', 'en']} 13 | # Lista con los pronombres. 14 | pronom = ['yo', 'tú', 'él', 'nosotros', 'vosotros', 'ellos'] 15 | # Conjunto con las terminaciones de verbos. 16 | terminaciones = {'ar', 'er', 'ir'} 17 | 18 | verbo = input('Ingrese un verbo regular en infinitivo: ') 19 | n = len(verbo) - 2 20 | raiz = verbo[:n] 21 | ter = verbo[n:] 22 | if ter in terminaciones: 23 | dec = declin[ter] 24 | conjug = [raiz + car for car in dec] 25 | print(f'\nConjugación del verbo "{verbo}":'.upper()) 26 | for i in range(0, 6): 27 | print(pronom[i], conjug[i]) 28 | else: 29 | print('\nNo existe un verbo con esa terminación.') 30 | -------------------------------------------------------------------------------- /Cap3/Programa 3_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.2 5 | Construye un diccionario formado por ítems donde la clave son las letras 6 | mayúsculas del abecedario y el valor su correspondiente minúscula. 7 | """ 8 | 9 | # Usando listas por comprensión y el constructor dict. 10 | letras = dict([(chr(n), chr(n).lower()) for n in range(65, 91)]) 11 | print('\nDiccionario may:min -->'.upper(), letras) 12 | 13 | # Usando listas por comprensión, la función zip() y el constructor dict. 14 | mayusculas = [chr(n) for n in range(65, 91)] 15 | minusculas = [chr(n) for n in range(97, 123)] 16 | dic = dict(zip(mayusculas, minusculas)) 17 | print('\nSegunda solución -->'.upper(), dic) -------------------------------------------------------------------------------- /Cap3/Programa 3_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.3 5 | Se cuenta con un diccionario que representa claves y precios de productos. 6 | Se incrementan los precios de acuerdo a su clave y se genera un 7 | reporte de los productos. 8 | """ 9 | 10 | def aumenta_precio(dic, inferior, superior, aumento): 11 | """ Aumenta los precios de los elementos cuyas claves estén 12 | comprendidas en cierto intervalo. 13 | Parámetros: 14 | dic: de tipo dict. Almacena claves (int) y precios de productos. 15 | inferior: de tipo int. Límite inferior. 16 | superior: de tipo int. Límite superior. 17 | aumento: de tipo int o float. Es el aumento. 18 | """ 19 | aumento /= 100 20 | for clave in dic: 21 | if clave >= inferior and clave <= superior: 22 | dic[clave] *= (1 + aumento) 23 | 24 | def imprime_dic(dic, titulo): 25 | """ Genera un reporte con un título y el contenido de un diccionario, 26 | previamente ordenado. 27 | Parámetros: 28 | dic: de tipo dict. Lo que se va a incluir en el reporte. 29 | titulo: de tipo str. Es el título del reporte. 30 | Regresa: 31 | Una cadena que almacena las claves y los precios de los productos. 32 | Lanza: 33 | ValueError: si el diccionario está vacío. 34 | """ 35 | if len(dic) > 0: 36 | reporte = '\n\n' + titulo.upper() + '\n' 37 | reporte += '\nClaves: Precios:' 38 | items = sorted(dic.items()) 39 | for clave, precio in items: 40 | reporte += f'\n {clave} {precio:13.2f}$' 41 | else: 42 | raise ValueError('Diccionario vacío.') 43 | return reporte 44 | 45 | # ============================================================================= 46 | # Prueba de las funciones. 47 | # ============================================================================= 48 | # CP1: con un diccionario con datos. 49 | prod_prec = {101: 17, 209: 23, 108: 35, 135: 41, 206: 30, 180: 24, 220: 31, 50 | 240: 50, 170: 38} 51 | aumenta_precio(prod_prec, 150, 210, 5) 52 | print('\nCP1: con un diccionario con datos.', end = '') 53 | print(imprime_dic(prod_prec, 'Lista de precios actualizada')) 54 | # CP2: con un diccionario vacío. 55 | vacio = {} 56 | aumenta_precio(vacio, 150, 210, 5) 57 | try: 58 | print('\nCP2:', imprime_dic(vacio, 'Lista de precios actualizada')) 59 | except Exception as error: 60 | print('\nCP2:', error) 61 | 62 | -------------------------------------------------------------------------------- /Cap3/Programa 3_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.4 5 | Se tiene un diccionario con nombres y teléfonos de amigos: una agenda. 6 | El programa permite agregar amigos y teléfonos, cambiar y eliminar el 7 | teléfono de un amigo. 8 | """ 9 | 10 | def pide_opcion(): 11 | """ Despliega opciones de trabajo con la agenda. 12 | Regresa: 13 | Una cadena que almacena la opción de trabajo elegida. 14 | """ 15 | opciones = {'A', 'C', 'E', 'T', 'a', 'c', 'e', 't'} 16 | opc = '' 17 | while opc not in opciones: 18 | print('\n¿Qué quieres hacer?') 19 | print('A: Alta de un nuevo amigo y su teléfono.') 20 | print('C: Cambiar el teléfono de un amigo.') 21 | print('E: Eliminar el teléfono de un amigo.') 22 | print('T: Terminar.') 23 | opc = input('Ingresa la opción elegida: ') 24 | return opc 25 | 26 | amigos = {} 27 | opcion = pide_opcion() 28 | opcion = opcion.upper() 29 | while opcion != 'T': 30 | nombre = input('Nombre de tu amigo: ').upper() 31 | if opcion == 'A': 32 | telef = input('Teléfono de tu nuevo amigo: ') 33 | amigos[nombre] = telef 34 | else: 35 | if nombre in amigos: 36 | if opcion == 'C': 37 | telef = input('Nuevo teléfono: ') 38 | amigos[nombre] = telef 39 | else: 40 | amigos[nombre] = None 41 | else: 42 | print('\nEse nombre no está registrado.') 43 | opcion = pide_opcion().upper() 44 | print('\nLos amigos y sus teléfonos:', amigos) -------------------------------------------------------------------------------- /Cap3/Programa 3_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.5 5 | Dado un diccionario formado por nombres de materias y número de 6 | créditos, el programa genera un nuevo diccionario formada solo por 7 | las materias cuyos créditos sean menor o igual a un límite dado 8 | por el usuario. 9 | """ 10 | 11 | materias = {'matematica': 6, 'fisica': 8, 'biologia': 8, 'idioma': 4, 12 | 'quimica': 9, 'computacion': 8, 'historia': 4, 'civismo': 5} 13 | limite = int(input('Ingrese el máximo de créditos: ')) 14 | if limite > 0: 15 | elegidas = {} 16 | for mat, cred in materias.items(): 17 | if cred <= limite: 18 | elegidas[mat] = cred 19 | if len(elegidas) > 0: 20 | print('\nMaterias elegidas:', elegidas) 21 | else: 22 | print(f'\nNo hay materias con {limite} o menos créditos.') 23 | else: 24 | print('\nDebe ingresar un valor > 0.') 25 | 26 | 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /Cap3/Programa 3_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.6 5 | Dado un diccionario formado por equipos y puntajes obtenidos, se pide: 6 | - Los nombres de los integrantes del equipo que sacó más puntos. 7 | - Los nombres de los integrantes del equipo que sacó menos puntos. 8 | - Promedio de puntos obtenidos por todos los equipos. 9 | """ 10 | 11 | equipos = {('Pat', 'Lara'): 85, ('Jorge', 'Ines'): 80, ('Luis', 'Leti'): 103, 12 | ('Daniel', 'Paco'): 90, ('Mari', 'Tita'): 110, ('Juan', 'Javi'): 74} 13 | items = equipos.items() 14 | total_eq = len(items) 15 | if total_eq > 0: 16 | max_punt = -1 17 | min_punt = 121 18 | suma = 0 19 | for equi, puntaje in items: 20 | suma += puntaje 21 | if puntaje > max_punt: 22 | max_punt = puntaje 23 | equi_max = equi 24 | if puntaje < min_punt: 25 | min_punt = puntaje 26 | equi_min = equi 27 | promedio = suma / total_eq 28 | nombres = equi_max[0] + ' y ' + equi_max[1] 29 | print(f'\nEl máximo puntaje fue: {max_punt} obtenido por: {nombres}') 30 | nombres = equi_min[0] + ' y ' + equi_min[1] 31 | print(f'El mínimo puntaje fue: {min_punt} obtenido por: {nombres}') 32 | print(f'Promedio de puntos: {promedio:.2f}') 33 | else: 34 | print('\nNo hay equipos registrados.') 35 | -------------------------------------------------------------------------------- /Cap3/Programa 3_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.7 5 | Se define un diccionario para guardar los datos de los socios de un club. 6 | Además, el programa debe: 7 | 1. Dar de alta nuevos socios. 8 | 2. Dar de baja un socio. 9 | 3. Consultar los datos de un cierto socio. 10 | 4. Generar la lista completa de socios con todos sus datos. 11 | 5. Generar la lista de los socios honoríficos: nombre y teléfono. 12 | 13 | """ 14 | 15 | def alta_socio(socios, clave, nombre, telefono, correo, honor): 16 | """ Agrega un nuevo socio al diccionario. 17 | ... 18 | """ 19 | socios[clave] = {'Nombre': nombre, 'Teléfono': telefono, 'Correo': correo, 'Honor': honor} 20 | 21 | def baja_socio(socios, clave): 22 | """ Da de baja un socio, dada su clave. 23 | ... 24 | """ 25 | if socios.get(clave): 26 | del socios[clave] 27 | 28 | def reporte_socios(socios): 29 | """ Genera un reporte con los datos de todos los socios. 30 | ... 31 | """ 32 | reporte = '\nLISTA DE SOCIOS\n' 33 | items = socios.items() 34 | for cla, soc in items: 35 | linea = f'\nClave: {cla}' 36 | for dato in soc: 37 | linea += f'\n{dato}: {soc[dato]}' 38 | reporte += linea + '\n' 39 | return reporte 40 | 41 | def reporte_honorificos(socios): 42 | """ Genera un reporte de los socios honoríficos, incluyendo solo 43 | nombre y teléfono. 44 | ... 45 | """ 46 | reporte = '\nSOCIOS HONORÍFICOS\n' 47 | items = socios.items() 48 | for cla, soc in items: 49 | if soc['Honor']: 50 | for dato in soc: 51 | if dato == 'Nombre' or dato == 'Teléfono': 52 | reporte += f'\n{dato}: {soc[dato]}' 53 | return reporte 54 | 55 | def pide_opcion(): 56 | """ Despliega opciones de trabajo y lee la opción elegida. 57 | ... 58 | """ 59 | opciones = ('A', 'B', 'L', 'H', 'T') 60 | bandera = True 61 | while bandera: 62 | print('\n¿Qué quieres hacer?') 63 | print('A: Alta de un nuevo socio.') 64 | print('B: Baja de un socio.') 65 | print('L: Lista de socios.') 66 | print('H: Lista de socios honoríficos.') 67 | print('T: Terminar.') 68 | elec = input('Ingresa la opción elegida: ').upper() 69 | bandera = elec not in opciones 70 | return elec 71 | 72 | socios = {} 73 | opcion = pide_opcion() 74 | while opcion != 'T': 75 | if opcion == 'A': 76 | clave = int(input('Ingrese la clave del nuevo socio: ')) 77 | nombre = input('Ingrese el nombre: ') 78 | telefono = input('Ingrese el teléfono: ') 79 | correo = input('Ingrese el correo: ') 80 | honor = bool(input('¿Es socio honorífico? True/False: ')) 81 | alta_socio(socios, clave, nombre, telefono, correo, honor) 82 | elif opcion == 'B': 83 | clave = int(input('Ingrese la clave del socio a dar de baja: ')) 84 | baja_socio(socios, clave) 85 | elif opcion == 'L': 86 | print(reporte_socios(socios)) 87 | else: 88 | print(reporte_honorificos(socios)) 89 | opcion = pide_opcion() 90 | -------------------------------------------------------------------------------- /Cap3/Programa 3_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.8 5 | Programa que ayuda a aprender los números del 1 al 10 en 6 | diferentes idiomas: inglés, italiano y francés. 7 | """ 8 | import random 9 | 10 | # Lista con los nombres de los números del 0 al 10. 11 | numeros = ['cero', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 12 | 'siete', 'ocho', 'nueve', 'diez'] 13 | # Diccionario con las traducciones de los números a 3 idiomas: inglés, 14 | # italiano y francés, en ese orden. 15 | traduc = {'cero': ('zero', 'zero', 'zéro'), 'uno': ('one', 'uno', 'un'), 16 | 'dos': ('two', 'due', 'deux'), 'tres': ('three', 'tre', 'trois'), 17 | 'cuatro': ('four', 'quattro', 'quatre'), 18 | 'cinco': ('five', 'cinque', 'cinq'), 'seis': ('six', 'sei', 'six'), 19 | 'siete': ('seven', 'sette', 'sept'), 20 | 'ocho': ('eight', 'otto', 'huit'), 21 | 'nueve': ('nine', 'nove', 'neuve'), 'diez': ('ten', 'dieci', 'dix')} 22 | 23 | # En cada iteración del while se elige el idioma. 24 | texto = f'Idioma: (1)inglés, (2)italiano, (3)francés o (4)terminar: ' 25 | idioma = int(input(texto)) 26 | while idioma != 4: 27 | numero = random.randint(0, 10) 28 | nom_num = numeros[numero] 29 | respuesta = input(f'¿Cómo se escribe {nom_num}?: ') 30 | posibles_resp = traduc[nom_num] # Tupla con las 3 traducciones. 31 | traducida = posibles_resp[idioma - 1] # Según el idioma. 32 | if respuesta == traducida: 33 | print('Muy bien:)') 34 | else: 35 | print('Falta estudiar:(') 36 | idioma = int(input(texto)) 37 | 38 | 39 | -------------------------------------------------------------------------------- /Cap3/Programa 3_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 3.9 5 | Obtiene: 6 | 1. Palabras en común que existen entre: inglés-italiano, inglés-francés y 7 | francés-italiano. 8 | 2. Cantidad de palabras aprendidas (considerando los 3 idiomas). 9 | 3. Cantidad de palabras distintas aprendidas. 10 | """ 11 | 12 | traduc = {'cero': ('zero', 'zero', 'zéro'), 'uno': ('one', 'uno', 'un'), 13 | 'dos': ('two', 'due', 'deux'), 'tres': ('three', 'tre', 'trois'), 14 | 'cuatro': ('four', 'quattro', 'quatre'), 15 | 'cinco': ('five', 'cinque', 'cinq'), 16 | 'seis': ('six', 'sei', 'six'), 17 | 'siete': ('seven', 'sette', 'sept'), 18 | 'ocho': ('eight', 'otto', 'huit'), 19 | 'nueve': ('nine', 'nove', 'neuve'), 20 | 'diez': ('ten', 'dieci', 'dix')} 21 | 22 | valores = traduc.values() 23 | ingles = set() 24 | italiano = set() 25 | frances = set() 26 | for tupla in valores: 27 | ingles.add(tupla[0]) 28 | italiano.add(tupla[1]) 29 | frances.add(tupla[2]) 30 | 31 | # Inciso 1: palabras comunes entre idiomas. 32 | comuni_i = ingles & italiano 33 | if comuni_i: 34 | print('\nPalabras que comparte el inglés con el italiano:', comuni_i) 35 | else: 36 | print('\nNo hay palabras comunes entre el inglés y el italiano.') 37 | comuni_f = ingles & frances 38 | if comuni_f: 39 | print('\nPalabras que comparte el inglés con el francés:', comuni_f) 40 | else: 41 | print('\nNo hay palabras comunes entre el inglés y el francés.') 42 | comunf_i = frances & italiano 43 | if comunf_i: 44 | print('\nPalabras que comparte el francés con el italiano:', comunf_i) 45 | else: 46 | print('\nNo hay palabras comunes entre el francés y el italiano.') 47 | 48 | # Inciso 2: total de palabras aprendidas. 49 | total = len(ingles) + len(italiano) + len(frances) 50 | print('\nTotal de palabras que conoce en otros idiomas:', total) 51 | 52 | # Inciso 3: palabras diferentes. 53 | diferentes = ingles | frances | italiano 54 | print(f'\nConoce {len(diferentes)} palabras diferentes y son: ', diferentes) 55 | -------------------------------------------------------------------------------- /Cap3/nombres: -------------------------------------------------------------------------------- 1 | LUCAS 2 | ALICIA 3 | ALICIA 4 | PABLO 5 | JOSE 6 | MARIA 7 | CARLA 8 | CARLA 9 | CARLA 10 | MARIA 11 | ALICIA 12 | JOSE 13 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_1 5 | Declaración e inicialización de variables tipo arreglo. 6 | """ 7 | 8 | import array 9 | 10 | print('\nPosibles códigos de tipo:', array.typecodes) 11 | 12 | # Arreglo de enteros con signo, sin valores iniciales. 13 | impares = array.array('b') 14 | # Arreglo de enteros con signo. Valores iniciales a partir de una lista. 15 | pares = array.array('b', [4, 12, -34, 48, -18]) 16 | # Arreglo de caracteres. Valores iniciales a partir de una cadena. 17 | letras = array.array('u', 'hola') 18 | # Arreglo de números reales. Valores iniciales a partir de un conjunto. 19 | arre1 = array.array('f', {18, 5.6, 99, 12.5}) 20 | # Arreglo de números enteros. 21 | # Valores iniciales a partir de un diccionario: toma las claves. 22 | arre2 = array.array('i', {118: 'queso', 124: 'yogur', 110: 'crema'}) 23 | # Arreglo de números enteros. Valores iniciales a partir de otro arreglo. 24 | arre3 = array.array('i', arre2) 25 | 26 | print('\nTipo de dato:', type(pares)) 27 | print('Impresión de una variable tipo arreglo:', pares) 28 | print('Impresión del contenido de un arreglo: ', end = '') 29 | for num in pares: 30 | print(num, ' ', end = '') 31 | 32 | # Acceso a uno de los elementos del arreglo. 33 | print('\n\nPrimer elemento:', pares[0]) 34 | print('Último elemento:', pares[-1]) 35 | # Índice fuera de rango. Provoca: IndexError: array index out of range. 36 | # print('Octavo elemento:', pares[7]) 37 | 38 | 39 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_2 5 | Métodos para trabajar con arreglos. 6 | """ 7 | import array 8 | 9 | impares = array.array('b') 10 | pares = array.array('b', [4, 12, -34, 48, -18]) 11 | letras = array.array('u', 'hola') 12 | 13 | # Agrega al final del arreglo. 14 | letras.append('!') 15 | # letras.append(45.23) # TypeError: ... 16 | 17 | # Cantidad de elementos almacenados en el arreglo. 18 | print('\nTotal de elementos en "letras":', len(letras)) 19 | print('Total de elementos en "impares":', len(impares)) 20 | 21 | # Para conocer el código del tipo del arreglo. 22 | print('El código del tipo:', letras.typecode) 23 | # Para conocer el tamaño de un elemento del arreglo. 24 | print('El tamaño de un elemento:', letras.itemsize) 25 | 26 | # Cuenta el número de veces que el parámetro está en el arreglo. 27 | print('\nTotal de "h" en "letras":', letras.count('h')) 28 | 29 | # Agrega varios elementos a un arreglo. 30 | # A partir de una cadena. 31 | letras.extend('saludos') 32 | print('\n"letras" extendido: ', end = '') 33 | for c in letras: 34 | print(c, ' ', end = '') 35 | # A partir de una tupla y se extiende un arreglo vacío. 36 | impares.extend((13, 41, 87, 55, 37, 49)) 37 | print('\n"impares" extendido: ', end = '') 38 | for n in impares: 39 | print(n, ' ', end = '') 40 | 41 | # Regresa la posición del valor 48. 42 | posicion = pares.index(48) 43 | print('\n\nEl 48 está en la posición:', posicion) 44 | # indice = pares.index(101) # ValueError:... 45 | 46 | # Inserta el 7 en la posición 4: queda como 5to. elemento. 47 | impares.insert(4, 7) 48 | # Inserta el 17 al final. 49 | impares.insert(40, 17) 50 | # Posición negativa: se considera de derecha a izquierda. 51 | impares.insert(-4, 77) 52 | print('\n"impares" luego de insertar: 7, 17 y 77') 53 | for n in impares: 54 | print(n, ' ', end = '') 55 | 56 | # Quita y regresa el elemento de la posición dada. 57 | print('\n\nElemento quitado de "letras":', letras.pop(0)) # Primero. 58 | print('Elemento quitado de "impares":', impares.pop(-1)) # Último. 59 | print('Elemento quitado de "impares":', impares.pop()) # Último. 60 | 61 | # Quita la primera ocurrencia de 'a'. 62 | letras.remove('a') 63 | 64 | # Invierte el orden del arreglo. 65 | letras.reverse() 66 | print('\nLuego de quitar una "a" y de invertir el orden de "letras"') 67 | for c in letras: 68 | print(c, ' ', end = '') 69 | 70 | # Quita el primer elemento. 71 | del impares[0] 72 | print('\n\nLuego de quitar el primer elemento de "impares":') 73 | for n in impares: 74 | print(n, ' ', end = '') 75 | 76 | # Borra el arreglo completo. 77 | del impares 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_3 5 | Funciones y operadores con arreglos. 6 | Subdivisión de arreglos. 7 | """ 8 | import array 9 | import arreglo 10 | 11 | letras = array.array('u', 'susurros') 12 | pares = array.array('b', [4, 12, -34, 48, -18]) 13 | impares = array.array('b', [17, 21, 13, 5, 47, 53]) 14 | 15 | conv = pares.tobytes() 16 | print('\nLuego de convertir a bytes: ', end = '') 17 | print(arreglo.a_cadena(conv)) 18 | 19 | lista = letras.tolist() 20 | print('\nLista obtenida:', lista) 21 | 22 | # Genera un nuevo arreglo con los elementos de los 2 arreglos. 23 | numeros = pares + impares 24 | print('\nNuevo arreglo: pares + impares.') 25 | print(arreglo.a_cadena(numeros)) 26 | 27 | # Genera un nuevo arreglo con los elementos de impares repetidos 2 veces. 28 | nuevo = impares * 2 29 | print('\nNuevo arreglo: elementos de impares repetidos 2 veces.') 30 | print(arreglo.a_cadena(nuevo)) 31 | 32 | # Repite 3 veces los elementos de pares y modifica a pares. 33 | pares *= 3 34 | print('\nPares luego de repetir 3 veces su contenido.') 35 | print(arreglo.a_cadena(pares)) 36 | 37 | # Subdivisión o partición (slicing) de arreglos. 38 | print('\nDel tercero al quinto:', arreglo.a_cadena(nuevo[2:5])) 39 | print('\nDesde el primero (ignora los últimos 5):', arreglo.a_cadena(nuevo[:-5])) 40 | print('\nDesde el cuarto (ignora los últimos 5):', arreglo.a_cadena(nuevo[3:-5])) 41 | print('\nDesde el cuarto hasta el final:', arreglo.a_cadena(nuevo[3:])) 42 | print('\nTodo el arreglo:', arreglo.a_cadena(nuevo[:])) 43 | print('\nTomando de 2 en 2, del primero al último:', arreglo.a_cadena(nuevo[::2])) 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_4 5 | Arreglos y archivos binarios. 6 | """ 7 | 8 | import array 9 | 10 | # ============================================================================= 11 | # Ejemplo 1: se guarda un arreglo numérico en un archivo binario. 12 | # ============================================================================= 13 | arre = array.array('b') 14 | file_s = open('numeros', 'wb') 15 | n = int(input('\nTotal de números: ')) 16 | for _ in range (0, n): 17 | num = int(input('¿Números?: ')) 18 | arre.append(num) 19 | arre.tofile(file_s) 20 | file_s.close() 21 | 22 | # ============================================================================= 23 | # Ejemplo 2: se guarda un arreglo de caracteres en un archivo binario. 24 | # ============================================================================= 25 | letras = array.array('u', 'tres tristes tigres comen trigo') 26 | file_s = open('letras', 'wb') 27 | letras.tofile(file_s) 28 | file_s.close() 29 | 30 | # ============================================================================= 31 | # Ejemplo 3: se agregan al archivo de letras el contenido del arreglo 32 | # de vocales. 33 | # ============================================================================= 34 | vocales = array.array('u', 'aeiou') 35 | file_a = open('letras', 'ab') 36 | vocales.tofile(file_a) 37 | file_a.close() 38 | 39 | # ============================================================================= 40 | # Ejemplo 4: se lee un arreglo de números desde un archivo binario. 41 | # ============================================================================= 42 | numeros = array.array('b') 43 | file_e = open('numeros', 'rb') 44 | numeros.fromfile(file_e, n) 45 | print(numeros) 46 | 47 | # ============================================================================= 48 | # Ejemplo 5: se lee un arreglo de caracteres desde un archivo binario. 49 | # ============================================================================= 50 | caracteres = array.array('u') 51 | file_e = open('letras', 'rb') 52 | caracteres.fromfile(file_e, 36) 53 | print(caracteres) -------------------------------------------------------------------------------- /Cap4/Ejemplo 4_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Ejemplo 4_5 5 | Ejemplos de algunas operaciones con arreglos bidimensionales. 6 | """ 7 | 8 | import matrices 9 | 10 | # ============================================================================= 11 | # Construcción e inicialización de arreglos bidimensionales. 12 | # ============================================================================= 13 | f1 = int(input('\nIngrese total de filas: ')) 14 | c1 = int(input('Ingrese total de columnas: ')) 15 | m1 = matrices.forma_matriz_1(f1, c1) 16 | print(f'\nUsando la función 1:\n{matrices.a_cadena(m1)}') 17 | 18 | f2 = int(input('\nIngrese total de filas: ')) 19 | c2 = int(input('Ingrese total de columnas: ')) 20 | m2 = matrices.forma_matriz_2(f2, c2) 21 | print(f'\nUsando la función 2:\n{matrices.a_cadena(m2)}') 22 | 23 | f3 = int(input('\nIngrese total de filas: ')) 24 | c3 = int(input('Ingrese total de columnas: ')) 25 | m3 = matrices.forma_matriz_3(f3, c3) 26 | print(f'\nUsando la función 3:\n{matrices.a_cadena(m3)}') 27 | 28 | # ============================================================================= 29 | # Acceso a arreglos bidimensionales. 30 | # ============================================================================= 31 | # Se modifica el valor de la casilla del extremo superior izquierdo. 32 | m2[0][0] = 5 33 | 34 | # Se modifica el valor de la última fila. 35 | m2[f2 - 1] = [8, 9] 36 | 37 | # Se agrega una nueva fila. 38 | m2.insert(1, [2, 4]) 39 | print(f'\nLuego de modificar algunas casillas y de agregar una fila:\n' 40 | f'{matrices.a_cadena(m2)}') 41 | 42 | # Se elimina la primera fila. 43 | del m2[0] 44 | print(f'\nLuego de eliminar la primera fila:\n{matrices.a_cadena(m2)}') 45 | 46 | 47 | 48 | 49 | -------------------------------------------------------------------------------- /Cap4/Programa 4_1.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.1 5 | Determina si la frase contiene a las 5 vocales, cuántas veces la letra "m" 6 | está en la frase y, por último, quita todas las letras "t". 7 | """ 8 | import array 9 | 10 | frase = input('Ingrese la frase que quiere analizar: ') 11 | arreglo = array.array('u', frase) 12 | try: 13 | arreglo.index('a') 14 | arreglo.index('e') 15 | arreglo.index('i') 16 | arreglo.index('o') 17 | arreglo.index('u') 18 | respuesta = True 19 | except: 20 | respuesta = False 21 | if respuesta: 22 | print('\nLa frase contiene las 5 vocales.') 23 | else: 24 | print('\nLa frase no contiene las 5 vocales.') 25 | cuenta_m = arreglo.count('m') 26 | if cuenta_m > 0: 27 | print(f'La letra "m" aparece: {cuenta_m} veces.') 28 | else: 29 | print(f'La letra "m" no aparece en la frase.') 30 | cuenta_t = arreglo.count('t') 31 | for _ in range(0, cuenta_t): 32 | arreglo.remove('t') 33 | print('La frase luego de quitar todas las "t":'.upper()) 34 | for letra in arreglo: 35 | print(letra, end = '') 36 | 37 | 38 | 39 | 40 | -------------------------------------------------------------------------------- /Cap4/Programa 4_10.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.12 5 | Programa en el cual se lee un arreglo desde un archivo binario, se lo ordena 6 | y se lo utiliza para probar la solución de la función pedida en el problema 7 | 4.12. 8 | """ 9 | import arreglo 10 | import array 11 | 12 | arre = array.array('b') 13 | try: 14 | file_e = open('numeros', 'rb') 15 | arre.fromfile(file_e, 15) 16 | file_e.close() 17 | except Exception as error: 18 | print('\nHubo un error:', error) 19 | else: 20 | arreglo.ordena_crec(arre) 21 | print('\nArreglo:', arreglo.a_cadena(arre)) 22 | # CP1: se dan datos que no provocan errores. 23 | arreglo.cambia_ordenado(arre, 21, 25) 24 | print('\nCP1: se cambió 21 por 25 -->', arreglo.a_cadena(arre)) 25 | # CP2: el segundo dato altera el orden. 26 | try: 27 | arreglo.cambia_ordenado(arre, 14, 17) 28 | print('CP2: se cambió 14 por 17 -->', arreglo.a_cadena(arre)) 29 | except Exception as error: 30 | print('CP2: se intentó cambiar 14 por 17 -->', error) 31 | # CP3: el dato a cambiar no está en el arreglo. 32 | try: 33 | arreglo.cambia_ordenado(arre, 4, 3) 34 | print('CP3: se cambió 4 por 3 -->', arreglo.a_cadena(arre)) 35 | except Exception as error: 36 | print('CP3: se intentó cambiar 4 por 3 -->', error) 37 | # CP4: el dato que se va a cambiar es el primero. 38 | arreglo.cambia_ordenado(arre, 5, 3) 39 | print('CP4: se cambió 5 por 3 -->', arreglo.a_cadena(arre)) 40 | # CP5: el dato que se va a cambiar es el último. 41 | arreglo.cambia_ordenado(arre, 44, 51) 42 | print('CP5: se cambió 44 por 51 -->', arreglo.a_cadena(arre)) 43 | -------------------------------------------------------------------------------- /Cap4/Programa 4_11.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Pruebas de las soluciones de los problemas 4.13 y 4.14 5 | """ 6 | import array 7 | import arreglo 8 | 9 | # ============================================================================= 10 | # Algunas pruebas para el problema 4.13 11 | # ============================================================================= 12 | des1 = array.array('i', [2, 7, 8, 4, 1, 9]) 13 | des2 = array.array('i', [2, 7, 2, 2, 1, 9, 6, 7, 2, 2]) 14 | des3 = array.array('i', [2, 2, 2, 2]) 15 | des4 = array.array('i', [5, 7, 0, 1, 4]) 16 | des5 = array.array('i') 17 | # CP1: arreglo con una sola ocurrencia a eliminar. 18 | n = arreglo.elimina_todos_endesordenado(des1, 2) 19 | print(f'\nCP1: quita {n} vez/veces el 2 -->', arreglo.a_cadena(des1)) 20 | # CP2: arreglo con varias ocurrencias a eliminar. 21 | n = arreglo.elimina_todos_endesordenado(des2, 2) 22 | print(f'CP2: quita {n} vez/veces el 2 -->', arreglo.a_cadena(des2)) 23 | # CP3: arreglo con todos los elementos iguales al dato. 24 | n = arreglo.elimina_todos_endesordenado(des3, 2) 25 | print(f'CP3: quita {n} vez/veces el 2 -->', arreglo.a_cadena(des3)) 26 | # CP4: arreglo con todos los elementos distintos al dato. 27 | n = arreglo.elimina_todos_endesordenado(des4, 2) 28 | print(f'CP4: quita {n} vez/veces el 2 -->', arreglo.a_cadena(des4)) 29 | # CP5: arreglo vacío. 30 | n = arreglo.elimina_todos_endesordenado(des5, 2) 31 | print(f'CP5: quita {n} vez/veces el 2 -->', arreglo.a_cadena(des5)) 32 | 33 | # ============================================================================= 34 | # Algunas pruebas para el problema 4.14 35 | # ============================================================================= 36 | ord1 = array.array('i', [2, 6, 7, 9, 15, 22]) 37 | ord2 = array.array('i', [-3, 1, 2, 2, 2, 9, 16, 17, 20, 32]) 38 | ord3 = array.array('i', [-3, 1, 9, 16, 17, 20, 26, 26, 26, 26]) 39 | ord4 = array.array('i', [2, 2, 2, 2]) 40 | ord5 = array.array('i', [15, 27, 30, 31, 42]) 41 | ord6 = array.array('i') 42 | # CP1: arreglo con una sola ocurrencia a eliminar (inicio). 43 | n = arreglo.elimina_todos_enordenado(ord1, 2) 44 | print(f'\nCP1: quita {n} vez/veces el 2 -->', arreglo.a_cadena(ord1)) 45 | # CP2: arreglo con varias ocurrencia a eliminar (en el medio). 46 | n = arreglo.elimina_todos_enordenado(ord2, 2) 47 | print(f'CP2: quita {n} vez/veces el 2 -->', arreglo.a_cadena(ord2)) 48 | # CP3: arreglo con varias ocurrencia a eliminar (al final). 49 | n = arreglo.elimina_todos_enordenado(ord3, 26) 50 | print(f'CP3: quita {n} vez/veces el 26 -->', arreglo.a_cadena(ord3)) 51 | # CP4: arreglo con todos los elementos iguales al dato. 52 | n = arreglo.elimina_todos_enordenado(ord4, 2) 53 | print(f'CP4: quita {n} vez/veces el 2 -->', arreglo.a_cadena(ord4)) 54 | # CP5: arreglo con todos los elementos distintos al dato. 55 | n = arreglo.elimina_todos_enordenado(ord5, 2) 56 | print(f'CP5: quita {n} vez/veces el 2 -->', arreglo.a_cadena(ord5)) 57 | # CP6: arreglo vacío. 58 | n = arreglo.elimina_todos_enordenado(ord6, 2) 59 | print(f'CP6: quita {n} vez/veces el 2 -->', arreglo.a_cadena(ord6)) -------------------------------------------------------------------------------- /Cap4/Programa 4_12.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.15 5 | Obtiene e imprime la suma del producto de dos arreglos, recorriendo 6 | el primero de izquierda a derecha y el segundo de derecha a izquierda. 7 | """ 8 | 9 | import array 10 | import arreglo 11 | 12 | def calcula_suma(x, y, n): 13 | """ Calcula y regresa la suma de los elementos del arreglo x (izq a der) 14 | por los elementos del arreglo y (der a izq). 15 | """ 16 | suma = 0 17 | for i in range(0, n): 18 | suma += x[i] * y[n - 1 - i] 19 | return suma 20 | 21 | x = array.array('f') 22 | y = array.array('f') 23 | n = int(input('\nIngrese total de números: ')) 24 | print('\nIngrese los valores de x:'.upper()) 25 | arreglo.lectura(x, n, float, 'Ingrese un número: ') 26 | print('\nIngrese los valores de y:'.upper()) 27 | arreglo.lectura(y, n, float, 'Ingrese un número: ') 28 | suma = calcula_suma(x, y, n) 29 | print(f'\nResultado de la sumatoria = {suma:.2f}') -------------------------------------------------------------------------------- /Cap4/Programa 4_13.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.16 5 | Calcula e imprime la desviación estándard de un grupo de números. 6 | """ 7 | 8 | import array 9 | import arreglo 10 | 11 | datos = array.array('f') 12 | n = int(input('\nIngrese total de números: ')) 13 | arreglo.lectura(datos, n, float, 'Ingrese un número: ') 14 | try: 15 | ds = arreglo.desviacion_estandar(datos) 16 | print(f'\nLa desviación estándar es = {ds:.2f}') 17 | except Exception as error: 18 | print('\nLa desviación estándar no se calculó:', error) 19 | 20 | -------------------------------------------------------------------------------- /Cap4/Programa 4_14.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Auxiliar al problema 4.17 5 | """ 6 | import arreglo 7 | 8 | print('\nIngrese las claves de los participantes, en forma ordenada.'.upper()) 9 | arreglo.guarda_en_archivo('B', 'claves', 'Total de participantes', '¿Clave?:') 10 | print('\nIngrese los puntajes de acuerdo al orden dado a las claves.'.upper()) 11 | arreglo.guarda_en_archivo('B', 'puntajes', 'Total de participantes', '¿Puntaje?:') 12 | 13 | -------------------------------------------------------------------------------- /Cap4/Programa 4_15.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.17 5 | Procesa los datos de un concurso de pogramación: 6 | - clave del participante que sacó el puntaje más alto 7 | - clave del participante que sacó el puntaje más bajo. 8 | - promedio del puntaje obtenido por los participantes. 9 | - elimina a todos los participantes que hayan obtenido menos de 80 puntos. 10 | - total de participantes que pasan a la ronda final (80 o más puntos). 11 | """ 12 | 13 | import array 14 | import arreglo 15 | 16 | def elimina_menores_a_minimo(claves, puntajes, minimo): 17 | """ Elimina clave y puntaje de todos aquellos participantes que obtuvieron 18 | menos de una cierta cantidad mínima de puntos. 19 | No altera el orden de las claves. 20 | """ 21 | n = len(claves) - 1 22 | indice = 0 23 | while indice < n: 24 | if puntajes[indice] < minimo: 25 | for i in range(indice, len(puntajes) - 1): 26 | puntajes[i] = puntajes[i + 1] 27 | claves[i] = claves[i + 1] 28 | puntajes.pop() 29 | claves.pop() 30 | n -= 1 31 | else: 32 | indice += 1 33 | if puntajes[indice] < minimo: 34 | puntajes.pop() 35 | claves.pop() 36 | 37 | claves = array.array('B') 38 | puntajes = array.array('B') 39 | TOTAL = 10 40 | try: 41 | file_c = open('claves', 'rb') 42 | claves.fromfile(file_c, TOTAL) 43 | file_p = open('puntajes', 'rb') 44 | puntajes.fromfile(file_p, TOTAL) 45 | file_c.close() 46 | file_p.close() 47 | except Exception as error: 48 | print('\nHubo un error:', error) 49 | else: 50 | alto = arreglo.maximo(puntajes) 51 | print('\nClave del participante con más puntos:', claves[alto]) 52 | bajo = arreglo.minimo(puntajes) 53 | print('Clave del participante con menos puntos:', claves[bajo]) 54 | promedio = arreglo.suma_arreglo(puntajes) // TOTAL 55 | print(f'Promedio de puntos obtenidos en esta etapa = {promedio:.2f}') 56 | elimina_menores_a_minimo(claves, puntajes, 80) 57 | n = len(claves) 58 | if n > 0: 59 | print(f'A la ronda final pasan {n} participantes.') 60 | else: 61 | print('Ningún participante superó la ronda. ') 62 | 63 | 64 | 65 | -------------------------------------------------------------------------------- /Cap4/Programa 4_16.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.18 5 | Obtiene e imprime todos los números primos comprendidos entre 6 | 2 y n inclusive, por medio del método llamado Criba de Eratóstenes. 7 | """ 8 | 9 | import array 10 | 11 | def criba_eratostenes(n): 12 | """ Encuentra los números primos comprendidos entre 2 y n. 13 | Parámetro: 14 | n: de tipo int. Límite hasta el que se buscarán números primos. 15 | Regresa: 16 | Una lista con los números primos. 17 | """ 18 | lim = n + 1 19 | primos = array.array('B') 20 | primos.append(0) # Valor 0 para las 2 primeras casillas. 21 | primos.append(0) 22 | for _ in range(2, lim): # Valor 1 para las otras casillas. 23 | primos.append(1) 24 | for i in range(2, lim): 25 | if primos[i]: 26 | for j in range(i + 1, lim): 27 | if primos[j] and j % i == 0: 28 | primos[j] = 0 29 | res = [i for i in range(2, lim) if primos[i]] 30 | return res 31 | 32 | n = int(input('\n¿Hasta qué valor se buscarán números primos? ')) 33 | res = criba_eratostenes(n) 34 | print(f'\nLos números primos <= {n} son:'.upper(), res) -------------------------------------------------------------------------------- /Cap4/Programa 4_17.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.20 5 | Prueba las funciones que suman filas y columnas del módulo matrices. 6 | """ 7 | 8 | import matrices 9 | 10 | filas = int(input('\nIngrese total de filas: ')) 11 | columnas = int(input('Ingrese total de columnas: ')) 12 | matriz = matrices.forma_matriz_1(filas, columnas) 13 | matrices.lee(matriz, int) 14 | 15 | # Se dan datos correctos. Por razones de espacio no se usa try-except 16 | suma_fila = matrices.suma_fila(matriz, 1) 17 | print(f'\nCP1 --> Suma de la segunda fila = {suma_fila}') 18 | suma_columna = matrices.suma_columna(matriz, columnas - 1) 19 | print(f'CP2 --> Suma de la última columna = {suma_columna}') 20 | 21 | # Se dan datos fuera del rango del arreglo. 22 | try: 23 | suma_fila = matrices.suma_fila(matriz, 11) 24 | except IndexError as error: 25 | print(f'\nCP3 --> {error}') 26 | except TypeError as error: 27 | print(f'\nCP3 --> {error}') 28 | else: 29 | print(f'\nCP3 --> Suma de la segunda fila = {suma_fila}') 30 | try: 31 | suma_columna = matrices.suma_columna(matriz, columnas + 1) 32 | except IndexError as error: 33 | print(f'CP4 --> {error}') 34 | except TypeError as error: 35 | print(f'CP4 --> {error}') 36 | else: 37 | print(f'CP4 --> Suma de la última columna = {suma_columna}') 38 | 39 | 40 | -------------------------------------------------------------------------------- /Cap4/Programa 4_18.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.21 5 | Prueba las funciones que suman los elementos de las diagonales 6 | principal y secundaria del módulo matrices. 7 | """ 8 | 9 | import matrices 10 | 11 | filas = int(input('\nIngrese total de filas: ')) 12 | columnas = int(input('Ingrese total de columnas: ')) 13 | print('\nIngrese los datos del arreglo'.upper()) 14 | matriz1 = matrices.forma_matriz_2(filas, columnas) 15 | matrices.lee(matriz1, int) 16 | 17 | # Se dan datos correctos. Por razones de espacio no se usa try-except. 18 | suma_principal = matrices.suma_diagonal_principal(matriz1) 19 | print(f'\nCP1 --> Suma de la diagonal principal = {suma_principal}') 20 | suma_secundaria = matrices.suma_diagonal_secundaria(matriz1) 21 | print(f'CP2 --> Suma de la diagonal secundaria = {suma_secundaria}') 22 | 23 | # Se utiliza un arreglo que no es cuadrado. 24 | print('\nIngrese los datos del arreglo'.upper()) 25 | columnas = filas + 2 # Asegura no ser cuadrada. 26 | matriz2 = matrices.forma_matriz_2(filas, columnas) 27 | matrices.lee(matriz2, int) 28 | try: 29 | suma_principal = matrices.suma_diagonal_principal(matriz2) 30 | print(f'\nCP3 --> Suma de la diagonal principal = {suma_principal}') 31 | except IndexError as error: 32 | print(f'\nCP3 --> {error}') 33 | try: 34 | suma_secundaria = matrices.suma_diagonal_secundaria(matriz2) 35 | print(f'\nCP4 --> Suma de la diagonal secundaria = {suma_secundaria}') 36 | except IndexError as error: 37 | print(f'CP4 --> {error}') 38 | 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /Cap4/Programa 4_19.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.22 5 | Prueba las funciones del módulo matrices que buscan y regresan la posición del: 6 | - elemento más grande de una fila 7 | - elemento más grande una columna 8 | """ 9 | 10 | import matrices 11 | 12 | filas = int(input('\nIngrese total de filas: ')) 13 | columnas = int(input('Ingrese total de columnas: ')) 14 | print('\nIngrese los datos del arreglo'.upper()) 15 | matriz1 = matrices.forma_matriz_3(filas, columnas) 16 | matrices.lee(matriz1, int) 17 | 18 | # Se dan datos correctos. Por razones de espacio no se usa try-except. 19 | max_f = matrices.max_fila(matriz1, filas - 1) 20 | print(f'\nCP1 --> El máximo de la última fila está en la posición {max_f}') 21 | max_c = matrices.max_columna(matriz1, 0) 22 | print(f'CP2 --> El máximo de la primera columna está en la posición {max_c}') 23 | 24 | # Se utiliza un arreglo vacío. 25 | matriz2 = matrices.matriz_vacia() 26 | try: 27 | max_f = matrices.max_fila(matriz2, filas - 1) 28 | print(f'\nCP3 --> El máximo de la última fila está en la posición {max_f}') 29 | except IndexError as error: 30 | print(f'\nCP3 --> {error}') 31 | try: 32 | max_c = matrices.max_columna(matriz2, 0) 33 | print(f'\nCP4 --> El máximo de la primera columna está en la posición {max_c}') 34 | except IndexError as error: 35 | print(f'CP4 --> {error}') 36 | 37 | -------------------------------------------------------------------------------- /Cap4/Programa 4_2.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.2 5 | En un arreglo de números enteros agrega a cada número par su cuadrado 6 | a su derecha. Además, imprime el arreglo modificado. 7 | """ 8 | import array 9 | 10 | def agrega_cuadrados(arreglo): 11 | """ A cada número par del arreglo le agrega, a su derecha, su cuadrado. 12 | Parámetro: 13 | arreglo: de tipo array. Almacena números enteros. 14 | """ 15 | n = len(arreglo) 16 | indice = 0 17 | for _ in range(0, n): 18 | if numeros[indice] % 2 == 0: 19 | cuadrado = numeros[indice] ** 2 20 | indice += 1 21 | numeros.insert(indice, cuadrado) 22 | indice += 1 23 | 24 | # Entrada de datos, llamada a la función e impresión de resultado. 25 | numeros = array.array('i') 26 | n = int(input('\n¿Cuántos números? ')) 27 | for _ in range(0, n): 28 | num = int(input('Ingrese un número entero: ')) 29 | numeros.append(num) 30 | agrega_cuadrados(numeros) 31 | res = '\nArreglo luego de agregar cuadrados:\n' 32 | for num in numeros: 33 | res += str(num) + ' ' 34 | print(res) 35 | 36 | -------------------------------------------------------------------------------- /Cap4/Programa 4_20.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.23 5 | Prueba la función que suma matrices del módulo matrices. 6 | """ 7 | 8 | import matrices 9 | 10 | # CP1: se proporcionan matrices del mismo tamaño. 11 | matriz1 = [[3, 5, 7], [2, 4, 6], [1, 1, 1]] 12 | matriz2 = [[1, 2, 1], [5, 3, 2], [8, 0, 4]] 13 | try: 14 | matriz_suma = matrices.suma_matrices(matriz1, matriz2) 15 | print(f'\nCP1 --> Matriz resultado\n{matrices.a_cadena(matriz_suma)}') 16 | except IndexError as error: 17 | print(f'\nCP1 --> {error}') 18 | # CP2: se proporcionan matrices de diferente tamaño. 19 | matriz3 = [[6, 1, 7, 6], [1, 3, 5, 6], [3, 1, 9, 8]] 20 | try: 21 | matriz_suma = matrices.suma_matrices(matriz1, matriz3) 22 | print(f'CP2: Matriz resultado\n {matrices.a_cadena(matriz_suma)}') 23 | except IndexError as error: 24 | print(f'CP2 --> {error}') 25 | # CP3: se proporcionan matrices vacías. 26 | matriz4 = matrices.matriz_vacia() 27 | matriz5 = matrices.matriz_vacia() 28 | try: 29 | matriz_suma = matrices.suma_matrices(matriz4, matriz5) 30 | print(f'\nCP3 --> Matriz resultado\n {matrices.a_cadena(matriz_suma)}') 31 | except IndexError as error: 32 | print(f'CP3 --> {error}') -------------------------------------------------------------------------------- /Cap4/Programa 4_21.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.24 5 | Se obtiene e imprime la siguiente información del registro de temperaturas: 6 | - Temperatura máxima registrada en uno de los días 7 | - Promedio de todas las temperaturas registradas 8 | - Temperatura máxima registrada en un cierto horario 9 | - Días en los cuales todas las temperaturas registradas fueron menores a 10°C 10 | - Cantidad de días que tuvieron una temperatura mayor a 13°C a las 18 horas 11 | """ 12 | 13 | import matrices 14 | 15 | dias = {1, 2, 3, 4, 5, 6, 7} 16 | horarios = [0, 6, 12, 18] # Lista porque interesa posición 17 | horas_registros = {0: '0 h', 1: '6 h', 2: '12 h', 3: '18 h'} 18 | try: 19 | nombre = input('\nIngrese nombre del archivo de temperaturas: ') 20 | temp = matrices.lee_de_archivo(nombre, float) 21 | filas = len(temp) 22 | columnas = len(temp[0]) 23 | dia = int(input('Ingrese el día (1 a 7) para buscar la máxima temperatura: ')) 24 | if dia in dias: 25 | dia -= 1 # Adapta para que corresponda al índice de las filas. 26 | horario = matrices.max_fila(temp, dia) 27 | max_temp = temp[dia][horario] 28 | print(f'\nLa máxima temperatura es = {max_temp}°C', end = '') 29 | print(f' y fue registrada a las {horas_registros[horario]}.') 30 | else: 31 | print('\nEl número de día es incorrecto.') 32 | suma_temperaturas = 0 33 | for f in range(filas): 34 | suma_temperaturas += matrices.suma_fila(temp, f) 35 | promedio = suma_temperaturas / (filas * columnas) 36 | print(f'\nPromedio de temperaturas registradas en los 7 días es = {promedio}°C') 37 | hora = int(input('Ingrese la hora (0, 6, 12 o 18): ')) 38 | if hora in horarios: 39 | hora = horarios.index(hora) 40 | dia = matrices.max_columna(temp, hora) 41 | max_temp = temp[dia][hora] 42 | print(f'\nLa máxima temperatura es = {max_temp}°C', end = '') 43 | print(f' y fue registrada el día {dia + 1}.') 44 | else: 45 | print('\nEl horario de registro es incorrecto.') 46 | dias_men = matrices.todos_menores_que(temp, 10) 47 | long = len(dias_men) - 1 48 | if long >= 0: 49 | cad = '' 50 | for i in range(long): 51 | cad += str(dias_men[i] + 1) + ' - ' 52 | cad += str(dias_men[long] + 1) 53 | print(f'\nDías en los cuales todas las temperaturas < 10°C son: {cad}') 54 | cont = matrices.cuenta_por_columna_mayores_que(temp, 3, 13) 55 | print(f'\nCantidad de días con temperatura > 13°C a las 18 h = {cont}') 56 | except Exception: 57 | print('\nError en la lectura del archivo') -------------------------------------------------------------------------------- /Cap4/Programa 4_22.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.25 5 | Genera e imprime un cuadrado mágico. 6 | """ 7 | 8 | import matrices 9 | 10 | def cuadrado_magico(n): 11 | """ Genera un cuadrado mágico de tamaño n. 12 | Parámetro: 13 | n: de tipo int. Indica el total de filas y columnas del cuadrado. 14 | Debe ser impar y > 0. 15 | Regresa: 16 | Lista de listas que almacena el cuadrado mágico. 17 | """ 18 | cuadrado = matrices.forma_matriz_2(n, n) 19 | f = 0 20 | c = n // 2 21 | for i in range(1, n ** 2 + 1): 22 | cuadrado[f][c]= i 23 | if i % n != 0: 24 | f -= 1 25 | c += 1 26 | if f < 0: 27 | f = n - 1 28 | if c == n: 29 | c = 0 30 | else: 31 | f += 1 32 | return cuadrado 33 | 34 | def verifica_cuadrado_magico(cuadrado, n): 35 | """ Verifica que el cuadrado cumpla con la característica de que 36 | la suma de sus diagonales, filas y columnas son iguales. 37 | Parámetros: 38 | cuadrado: de tipo list. Lista de listas. Almacena el cuadrado mágico. 39 | n: de tipo int. Es el tamaño del cuadrado. 40 | Regresa: 41 | True si la matriz es un cuadrado mágico y False en otro caso. 42 | """ 43 | respuesta = False 44 | suma = matrices.suma_diagonal_principal(cuadrado) 45 | if suma == matrices.suma_diagonal_secundaria(cuadrado): 46 | fila = 0 47 | while fila < n and suma == matrices.suma_fila(cuadrado, fila): 48 | fila += 1 49 | if fila == n: 50 | col = 0 51 | while col < n and suma == matrices.suma_columna(cuadrado, col): 52 | col += 1 53 | respuesta = col == n 54 | return respuesta 55 | 56 | n = int(input('\nIngrese tamaño del cuadrado mágico: ')) 57 | if n > 0 and n % 2 != 0: 58 | c_magico = cuadrado_magico(n) 59 | if verifica_cuadrado_magico(c_magico, n): 60 | print(f'\nSe generó un cuadrado mágico de {n} x {n}\n'.upper()) 61 | print(matrices.a_cadena(c_magico)) 62 | else: 63 | print('\nEl cuadrado generado no reúne las características solicitadas.') 64 | else: 65 | print('\nDebe ingresar un número entero positivo impar.') 66 | -------------------------------------------------------------------------------- /Cap4/Programa 4_23.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.26 5 | Prueba la función que determina si una matriz es simétrica. 6 | """ 7 | 8 | import matrices 9 | 10 | # CP1: se proporciona una matriz simétrica. 11 | matriz1 = [[7, 3, 2, 8], [3, 4, 5, 6], [2, 5, 3, 1], [8, 6, 1, 9]] 12 | if matrices.es_simetrica(matriz1): 13 | print('\nCP1: la matriz es simétrica.') 14 | else: 15 | print('\nCP1: la matriz no es simétrica.') 16 | # CP2: se proporciona una matriz que no es simétrica. 17 | matriz2 = [[7, 1, 2, 8], [3, 4, 5, 6], [2, 5, 3, 1], [4, 6, 1, 9]] 18 | if matrices.es_simetrica(matriz2): 19 | print('CP2: la matriz es simétrica.') 20 | else: 21 | print('CP2: la matriz no es simétrica.') 22 | # CP3: se proporciona una matriz que no es cuadrada (tampoco simétrica). 23 | matriz3 = [[6, 1, 7, 6], [1, 3, 5, 6], [3, 1, 9, 8]] 24 | if matrices.es_simetrica(matriz3): 25 | print('CP3: la matriz es simétrica.') 26 | else: 27 | print('CP3: la matriz no es simétrica.') 28 | # CP4: se proporciona una matriz vacía. 29 | matriz4 = matrices.matriz_vacia() 30 | if matrices.es_simetrica(matriz4): 31 | print('CP4: la matriz es simétrica.') 32 | else: 33 | print('CP4: la matriz no es simétrica.') -------------------------------------------------------------------------------- /Cap4/Programa 4_24.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.27 5 | Prueba la función que genera la traspuesta de una matriz. 6 | """ 7 | 8 | import matrices 9 | 10 | # CP1: se proporciona una matriz de 4 x 4. 11 | matriz1 = [[7, 4, 2, 8], [3, 4, 7, 6], [1, 1, 1, 1], [4, 6, 0, 9]] 12 | trasp1 = matrices.traspuesta(matriz1) 13 | cadm1 = matrices.a_cadena(matriz1) 14 | cadt1 = matrices.a_cadena(trasp1) 15 | print(f'\nCP1 --> Matriz:\n{cadm1}\nMatriz traspuesta:\n{cadt1}') 16 | # CP2: se proporciona una matriz 3 x 4. 17 | matriz2 = [[6, 1, 7, 6], [1, 3, 5, 6], [3, 1, 9, 8]] 18 | trasp2 = matrices.traspuesta(matriz2) 19 | cadm2 = matrices.a_cadena(matriz2) 20 | cadt2 = matrices.a_cadena(trasp2) 21 | print(f'CP2 --> Matriz:\n{cadm2}\nMatriz traspuesta:\n{cadt2}') 22 | # CP3: se proporciona una matriz vacía. 23 | matriz3 = matrices.matriz_vacia() 24 | trasp3 = matrices.traspuesta(matriz3) 25 | cadm3 = matrices.a_cadena(matriz3) 26 | cadt3 = matrices.a_cadena(trasp3) 27 | print(f'CP3 --> Matriz:\n{cadm3}\nMatriz traspuesta:\n{cadt3}') 28 | # CP4: se proporciona una matriz de 2 x 3 de tipo str. 29 | matriz4 = [['d', 'g', 'p'], ['b', 'x', 't']] 30 | trasp4 = matrices.traspuesta(matriz4) 31 | cadm4 = matrices.a_cadena(matriz4) 32 | cadt4 = matrices.a_cadena(trasp4) 33 | print(f'CP4 --> Matriz:\n{cadm4}\nMatriz traspuesta:\n{cadt4}') -------------------------------------------------------------------------------- /Cap4/Programa 4_25.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.28 5 | Prueba la función que multiplica matrices del módulo matrices. 6 | """ 7 | 8 | import matrices 9 | 10 | # CP1: se proporcionan matrices que pueden multiplicarse (2 x 3 y 3 x 4). 11 | matriz1 = [[4, 2, 5], [6, 3, 1]] 12 | matriz2 = [[7, 1, 2, 4], [3, 4, 6, 1], [2, 5, 3, 2]] 13 | try: 14 | matriz_multi1 = matrices.multiplica_matrices(matriz1, matriz2) 15 | print(f'\nCP1: Matriz resultado\n{matrices.a_cadena(matriz_multi1)}') 16 | except Exception as error: 17 | print(f'\nCP1 --> {error}') 18 | # CP2: se proporcionan matrices que pueden multiplicarse (3 x 3 y 3 x 3). 19 | matriz3 = [[3, 5, 7], [2, 4, 6], [1, 4, 8]] 20 | matriz4 = [[1, 2, 1], [5, 3, 2], [8, 0, 4]] 21 | try: 22 | matriz_multi2 = matrices.multiplica_matrices(matriz3, matriz4) 23 | print(f'CP2: Matriz resultado\n{matrices.a_cadena(matriz_multi2)}') 24 | except Exception as error: 25 | print(f'CP2 --> {error}') 26 | # CP3: se proporcionan matrices que no pueden multiplicarse (3 x 4 y 3 x 3). 27 | try: 28 | matriz_multi3 = matrices.multiplica_matrices(matriz2, matriz3) 29 | print(f'CP3: Matriz resultado\n{matrices.a_cadena(matriz_multi3)}') 30 | except Exception as error: 31 | print(f'CP3 --> {error}') 32 | # CP4: se proporcionan matrices vacías. 33 | matriz4 = matrices.matriz_vacia() 34 | matriz5 = matrices.matriz_vacia() 35 | try: 36 | matriz_multi4 = matrices.multiplica_matrices(matriz4, matriz5) 37 | print(f'CP4: Matriz resultado\n {matrices.a_cadena(matriz_multi4)}') 38 | except Exception as error: 39 | print(f'CP4 --> {error}') -------------------------------------------------------------------------------- /Cap4/Programa 4_26.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.29 5 | Genera e imprime una espiral de tamaño n formada por los números 6 | del 1 a n*n, siguiendo los movimientos de las agujas de un reloj. 7 | """ 8 | import matrices 9 | 10 | def mueve_derecha(arre, inf, sup, fila, num): 11 | """ Asigna números en la fila desde la columna "inf" hasta la "sup", 12 | de izquierda a derecha. 13 | El número (num) se actualiza luego de cada asignación. 14 | Parámetros: 15 | arre: de tipo list. Lista de listas, es el arreglo bidimensional. 16 | inf: de tipo int. Indica la primera columna en la cual se asignará num. 17 | sup: de tipo int. Indica la última columna en la cual se asignará num. 18 | fila: de tipo int. Indica la fila en la cual se asignará num. 19 | num: de tipo int. Es el primer número que se asignará. 20 | Regresa: 21 | Un entero que indica el siguiente número que deberá asignarse. 22 | """ 23 | while inf <= sup: 24 | arre[fila][inf] = num 25 | num += 1 26 | inf += 1 27 | return num 28 | 29 | def mueve_izquierda(arre, inf, sup, fila, num): 30 | """ Asigna números en la fila desde la columna "sup" hasta la "inf", 31 | de derecha a izquierda. 32 | El número (num) se actualiza luego de cada asignación. 33 | Parámetros: 34 | arre: de tipo list. Lista de listas, es el arreglo bidimensional. 35 | inf: de tipo int. Indica la última columna en la cual se asignará 36 | el número (num). 37 | sup: de tipo int. Indica la primera columna en la cual se asignará 38 | el número (num). 39 | fila: de tipo int. Indica la fila en la cual se asignará el número. 40 | num: de tipo int. Es el primer número que se asignará. 41 | Regresa: 42 | Un entero que indica el siguiente número que deberá asignarse. 43 | """ 44 | while sup >= inf: 45 | arre[fila][sup] = num 46 | num += 1 47 | sup -= 1 48 | return num 49 | 50 | def mueve_abajo(arre, inf, sup, columna, num): 51 | """ Asigna números en la columna desde la fila "inf" hasta la "sup", 52 | de arriba hacia abajo. 53 | El número (num) se actualiza luego de cada asignación. 54 | Parámetros: 55 | arre: de tipo list. Lista de listas, es el arreglo bidimensional. 56 | inf: de tipo int. Indica la primera fila en la cual se asignará 57 | el número (num). 58 | sup: de tipo int. Indica la última fila en la cual se asignará 59 | el número (num). 60 | columna: de tipo int. Indica la columna en la cual se asignará el número. 61 | num: de tipo int. Es el primer número que se asignará. 62 | Regresa: 63 | Un entero que indica el siguiente número que deberá asignarse. 64 | """ 65 | while inf <= sup: 66 | arre[inf][columna] = num 67 | num += 1 68 | inf += 1 69 | return num 70 | 71 | def mueve_arriba(arre, inf, sup, columna, num): 72 | """ Asigna números en la columna desde la fila "sup" hasta la "inf", 73 | de abajo hacia arriba. 74 | El número (num) se actualiza luego de cada asignación. 75 | Parámetros: 76 | arre: de tipo list. Lista de listas, es el arreglo bidimensional. 77 | inf: de tipo int. Indica la última fila en la cual se asignará 78 | el número (num). 79 | sup: de tipo int. Indica la primera fila en la cual se asignará 80 | el número (num). 81 | columna: de tipo int. Indica la columna en la cual se asignará el número. 82 | num: de tipo int. Es el primer número que se asignará. 83 | Regresa: 84 | Un entero que indica el siguiente número que deberá asignarse. 85 | """ 86 | while sup >= inf: 87 | arre[sup][columna] = num 88 | num += 1 89 | sup -= 1 90 | return num 91 | 92 | n = int(input('\nIngrese el tamaño de la espiral (número impar > 0): ')) 93 | if n > 0 and n % 2 != 0: 94 | espiral = matrices.forma_matriz_2(n, n) 95 | limite = n ** 2 96 | i = n // 2 97 | j = n // 2 98 | espiral[i][j] = 1 99 | i_max = i + 1 100 | i_min = i - 1 101 | j_max = j + 1 102 | j_min = j - 1 103 | num = 2 104 | derecha = True # Indica desplazarse hacia la derecha. 105 | abajo = True # Indica desplazarse hacia abajo. 106 | while num <= limite: 107 | if derecha: 108 | j += 1 109 | if j_max == n: 110 | j_max -= 1 111 | num = mueve_derecha(espiral, j, j_max, i, num) 112 | j = j_max 113 | j_max += 1 114 | else: 115 | j -= 1 116 | num = mueve_izquierda(espiral, j_min, j, i, num) 117 | j = j_min 118 | j_min -= 1 119 | derecha = not derecha # Alterna el movimiento horizontal. 120 | if num < limite: 121 | if abajo: 122 | i += 1 123 | num = mueve_abajo(espiral, i, i_max, j, num) 124 | i = i_max 125 | i_max +=1 126 | else: 127 | i -= 1 128 | num = mueve_arriba(espiral, i_min, i, j, num) 129 | i = i_min 130 | i_min -= 1 131 | abajo = not abajo # Alterna el movimiento vertical. 132 | cadena = '' 133 | for f in range(0, n): 134 | for c in range(0, n): 135 | cadena += f'{espiral[f][c]}'.rjust(6) 136 | cadena += '\n' 137 | print(f'\nEspiral de {n} x {n}\n{cadena}') 138 | else: 139 | print('\nDato no válido.') 140 | 141 | -------------------------------------------------------------------------------- /Cap4/Programa 4_27.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | Problema 4.30 4 | @author: guardati 5 | Prueba las funciones que determinan si una matriz es triangular inferior y la 6 | que determina si una matriz es triangular superior. 7 | """ 8 | 9 | import matrices 10 | 11 | matriz1 = [[1, 2, 3, 4], [0, 5, 6, 7], [0, 0, 8, 9], [0, 0, 0, 10]] 12 | matriz2 = [[1, 0, 0, 0], [2, 3, 0, 0], [4, 5, 6, 0], [7, 8, 9, 10]] 13 | matriz3 = [[0, 8, 0, 1], [2, 3, 7, 0], [4, 5, 0, 6], [0, 0, 9, 10]] 14 | matriz4 = [[0, 8, 0, 1], [2, 3, 7, 0], [4, 5, 0, 6]] 15 | 16 | # CP1: se proporciona una matriz triangular superior. 17 | print(matrices.a_cadena(matriz1)) 18 | if matrices.es_triangular_superior(matriz1): 19 | print('CP1: La matriz es una matriz triangular superior.\n') 20 | 21 | # CP2: se proporciona una matriz triangular inferior. 22 | print(matrices.a_cadena(matriz2)) 23 | if matrices.es_triangular_inferior(matriz2): 24 | print('CP2: La matriz es una matriz triangular inferior.\n') 25 | 26 | # CP3: se proporciona una matriz cuadrada que no es triangular. 27 | print(matrices.a_cadena(matriz3)) 28 | if matrices.es_triangular_inferior(matriz3) or matrices.es_triangular_superior(matriz3): 29 | print('\nCP3: Es una matriz triangular inferior o superior.') 30 | else: 31 | print('CP3: No es una matriz triangular.\n') 32 | 33 | # CP4: se proporciona una matriz que no es cuadrada. 34 | print(matrices.a_cadena(matriz4)) 35 | try: 36 | matrices.es_triangular_superior(matriz4) 37 | except ValueError as error: 38 | print('CP4:', error) 39 | 40 | -------------------------------------------------------------------------------- /Cap4/Programa 4_28.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Pruebas aplicadas a la función del problema 4.10 5 | """ 6 | 7 | 8 | import array 9 | import arreglo 10 | 11 | arre = array.array('b', [4, 15, 12, -34, 48, -18, 11]) 12 | 13 | # CP1: se pide eliminar el dato de una posición que está en el arreglo. 14 | print('\nCP1: elemento quitado:', arreglo.elimina(arre, 3)) 15 | print('Luego de quitar el 4to elemento:', arreglo.a_cadena(arre)) 16 | 17 | # CP2: se pide eliminar el dato que está al final del arreglo. 18 | print('\nCP2: elemento quitado:', arreglo.elimina(arre, 5)) 19 | print('Luego de quitar el último elemento:', arreglo.a_cadena(arre)) 20 | 21 | # CP3: se pide eliminar el dato que está al inicio del arreglo. 22 | print('\nCP3: elemento quitado:', arreglo.elimina(arre, 0)) 23 | print('Luego de quitar el primer elemento:', arreglo.a_cadena(arre)) 24 | 25 | # CP4: se pide eliminar el dato que está en una posición fuera del arreglo. 26 | try: 27 | print('\nCP4: elemento quitado:', arreglo.elimina(arre, 12)) 28 | print('El arreglo luego de la eliminación:', arreglo.a_cadena(arre)) 29 | except IndexError as error: 30 | print('\nCP4:', error) 31 | 32 | # CP5: se pide eliminar un dato de un arreglo vacío. 33 | vacio = array.array('b') 34 | try: 35 | print('\nCP5: elemento quitado:', arreglo.elimina(vacio, 1)) 36 | print('El arreglo luego de la eliminación:', arreglo.a_cadena(vacio)) 37 | except IndexError as error: 38 | print('\nCP5:', error) -------------------------------------------------------------------------------- /Cap4/Programa 4_3.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.3 5 | Elimina del arreglo todos aquellos elementos que sean menores que el promedio 6 | de los valores almacenados, si el promedio es mayor o igual a 50. 7 | """ 8 | import array 9 | 10 | n = int(input('¿Cuántos participantes hay en el concurso de baile?: ')) 11 | if n > 0: 12 | puntajes = array.array('B') 13 | suma = 0 14 | for i in range(1, n + 1): 15 | puntos = int(input(f'Ingrese el puntaje del participante {i}: ')) 16 | puntajes.append(puntos) 17 | suma += puntos 18 | promedio = suma / n 19 | if promedio >= 50: 20 | indice = 0 21 | while indice < n: 22 | if puntajes[indice] < promedio: 23 | puntajes.pop(indice) 24 | n -= 1 25 | else: 26 | indice += 1 27 | print(f'\nQuedaron los {n} mejores puntajes y son: ') 28 | for i in range(0, n): 29 | print(puntajes[i], ' ', end = '') 30 | else: 31 | print(f'\nEl promedio es: {promedio:.2f}. No hubo cambios.') 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /Cap4/Programa 4_4.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.4 5 | """ 6 | 7 | import array 8 | 9 | def suma_arre1(arreglo): 10 | """ Suma los elementos de un arreglo numérico. 11 | Parámetro: 12 | arreglo: de tipo array. Almacena datos de tipo int o float. 13 | Regresa: 14 | La suma de los números contenidos en el arreglo. 15 | """ 16 | suma = 0 17 | for num in arreglo: 18 | suma += num 19 | return suma 20 | 21 | def suma_arre2(arreglo): 22 | """... 23 | """ 24 | suma = 0 25 | for indice in range(0, len(arreglo)): 26 | suma += arreglo[indice] 27 | return suma 28 | 29 | arre = array.array('f') 30 | n = int(input('¿Cuántos números va a ingresar? ')) 31 | for i in range(0, n): 32 | arre.append(float(input(f'Ingrese el número {i + 1}: '))) 33 | print(f'\nSuma por medio de la solución 1: {suma_arre1(arre):.2f}') 34 | print(f'Suma por medio de la solución 2: {suma_arre2(arre):.2f}') 35 | 36 | 37 | -------------------------------------------------------------------------------- /Cap4/Programa 4_5.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.6 5 | Procesa información de unidades vendidas en una agencia de autos, 6 | obteniendo: total de unidades, promedio, meses con ventas inferiores 7 | al promedio, mes con más ventas, mes con menos ventas y venta mínima 8 | mensual. 9 | """ 10 | 11 | import array 12 | import arreglo 13 | 14 | def lee_ventas(ventas): 15 | """ Lectura de las ventas por mes. """ 16 | for mes in range(0, 12): 17 | ventas.append(int(input(f'Autos vendidos en "{meses[mes]}": '))) 18 | 19 | meses = ['ene', 'feb', 'mar', 'abr', 'may', 'jun', 'jul', 'ago', 'set', 'oct', 20 | 'nov', 'dic'] 21 | ventas = array.array('B') 22 | lee_ventas(ventas) 23 | refer = int(input('Ingrese cantidad de referencia: ')) 24 | total = arreglo.suma_arreglo(ventas) 25 | promedio = total / 12 26 | print('\nCantidad de autos vendidos el año anterior:', total) 27 | print(f'Promedio mensual de unidades vendidas: {promedio:.2f}') 28 | contmes = arreglo.cuenta_menores_que(ventas, promedio) 29 | print('\nCantidad de meses con ventas inferiores al promedio:', contmes) 30 | menos = arreglo.minimo(ventas) 31 | print(f'\nMes en el que se vendieron menos autos: "{meses[menos]}",' 32 | f' con una venta total de {ventas[menos]} unidades.') 33 | mas = arreglo.maximo(ventas) 34 | print(f'Mes en el que se vendieron más autos: "{meses[mas]}",' 35 | f' con una venta total de {ventas[mas]} unidades.') 36 | if arreglo.mayores_o_iguales_que(ventas, refer): 37 | print(f'\nSí se vendieron, al menos, {refer} unidades todos los meses.') 38 | else: 39 | print(f'\nNo se vendieron, al menos, {refer} unidades todos los meses.') 40 | 41 | 42 | 43 | 44 | 45 | -------------------------------------------------------------------------------- /Cap4/Programa 4_6.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.7: algunas pruebas de la función de búsqueda 5 | que se encuentra en el módulo arreglo. 6 | """ 7 | 8 | import array 9 | import arreglo 10 | 11 | letras = array.array('u', 'tres tristes tigres, tragaban trigo en un trigal') 12 | numeros = array.array('i') 13 | 14 | # CP1: se busca en un arreglo con varias ocurrencias del dato. 15 | print('\nCP1: posiciones de la "t":', arreglo.busca_todos(letras, 't')) 16 | # CP2: se busca en un arreglo con una ocurrencia del dato. 17 | print('CP2: posiciones de la "u":', arreglo.busca_todos(letras, 'u')) 18 | # CP3: se busca en un arreglo que no contiene al dato. 19 | print('CP3: posiciones de la "p":', arreglo.busca_todos(letras, 'p')) 20 | # CP4: se busca en un arreglo vacío. 21 | print('CP4: posiciones del "12":', arreglo.busca_todos(numeros, 12)) 22 | -------------------------------------------------------------------------------- /Cap4/Programa 4_7.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.8 5 | A partir de un número entero, genera e imprime el mayor y el menor 6 | de los números que se pueden formar con los dígitos del número. 7 | """ 8 | 9 | import array 10 | import arreglo 11 | 12 | def forma_mayor(arre): 13 | """Genera y regresa un número entero a partir de los 14 | datos que almacena el arreglo, de izquierda a derecha. 15 | Parámetro: 16 | arre: de tipo array. Almacena números enteros de un dígito. 17 | Regresa: 18 | El mayor número entero que se puede formar con los dígitos que 19 | almacena el arreglo. 20 | """ 21 | numero = 0 22 | for n in arre: 23 | numero = numero * 10 + n 24 | return numero 25 | 26 | def forma_menor(arre): 27 | """Genera y regresa un número entero a partir de los 28 | datos que almacena el arreglo, de derecha a izquierda. 29 | Parámetro: 30 | arre: de tipo array. Almacena números enteros de un dígito. 31 | Regresa: 32 | El menor número entero que se puede formar con los dígitos que 33 | almacena el arreglo. 34 | """ 35 | numero = 0 36 | for i in range(len(arre) - 1, -1, -1): 37 | numero = numero * 10 + arre[i] 38 | return numero 39 | 40 | arre_digitos = array.array('b') 41 | numero = int(input('\nIngrese un número entero: ')) 42 | while numero > 0: 43 | digito = int(numero % 10) 44 | arre_digitos.append(digito) 45 | numero //= 10 46 | arreglo.ordena_decrec(arre_digitos) 47 | mayor = forma_mayor(arre_digitos) 48 | menor = forma_menor(arre_digitos) 49 | print('\nEl mayor número que puede formarse =', mayor) 50 | print('El menor número que puede formarse =', menor) -------------------------------------------------------------------------------- /Cap4/Programa 4_8.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.9 5 | Elimina los elementos de un arreglo que son múltiplos de un 6 | valor dado. 7 | Los datos del arreglo se leen de un archivo binario. 8 | """ 9 | 10 | import array 11 | import arreglo 12 | 13 | def elimina_multiplos(arrenum, numero): 14 | """ Elimina del arreglo todos los elementos que son múltiplos de numero. 15 | Parámetros: 16 | arrenum: de tipo array. Almacena datos numéricos. 17 | numero: número del mismo tipo que los elementos del arreglo. 18 | """ 19 | n = len(arrenum) 20 | if n > 0: 21 | n -= 1 22 | indice = 0 23 | while indice < n: 24 | if arrenum[indice] % numero == 0: 25 | arrenum[indice] = arrenum.pop() 26 | n -= 1 27 | else: 28 | indice += 1 29 | # El último elemento no se evalúa en el ciclo. 30 | if arrenum[indice] % numero == 0: 31 | arrenum.pop() 32 | 33 | # Existe un archivo llamado 'numeros' con, al menos, 10 números. 34 | arre = array.array('b') 35 | try: 36 | file_e = open('numeros', 'rb') 37 | arre.fromfile(file_e, 10) 38 | file_e.close() 39 | print('\nArreglo leído:', arreglo.a_cadena(arre)) 40 | elimina_multiplos(arre, 3) 41 | print('Luego de eliminar los múltiplos de 3:', arreglo.a_cadena(arre)) 42 | except Exception as error: 43 | print('\nHubo un error:', error) 44 | 45 | -------------------------------------------------------------------------------- /Cap4/Programa 4_9.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Problema 4.11 5 | Obtiene e imprime la media, la moda y la mediana de un grupo de edades. 6 | """ 7 | import arreglo 8 | import array 9 | 10 | 11 | arre = array.array('b') 12 | resp = input('\n¿Ya existe el archivo S/N? ') 13 | if resp.upper() == 'S': 14 | nombre = input('Nombre del archivo: ') 15 | n = int(input('Total de asistentes: ')) 16 | else: 17 | nombre = input('Nombre del archivo donde se guardarán las edades: ') 18 | n = arreglo.guarda_en_archivo('B', nombre, '¿Total de asistentes?', '¿Edad?') 19 | try: 20 | file_e = open(nombre, 'rb') 21 | arre.fromfile(file_e, n) 22 | file_e.close() 23 | except Exception as error: 24 | print('\nHubo un error:', error) 25 | else: 26 | arreglo.ordena_crec(arre) 27 | media = arreglo.suma_arreglo(arre) / n 28 | cen = n // 2 29 | if n % 2 != 0: 30 | mediana = arre[cen] 31 | else: 32 | mediana = (arre[cen] + arre[cen - 1]) / 2 33 | print(f'\nLa media de las edades es: {media:.2f}') 34 | try: 35 | moda = arreglo.calcula_moda(arre) 36 | print('La moda de las edades es:', moda) 37 | except Exception as error: 38 | print(error) 39 | print(f'La mediana de las edades es: {mediana:.2f}') 40 | -------------------------------------------------------------------------------- /Cap4/__pycache__/arreglo.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro2-python/44fd4209b9e3a82b13c7ebcec1a75293bcce8847/Cap4/__pycache__/arreglo.cpython-37.pyc -------------------------------------------------------------------------------- /Cap4/__pycache__/matrices.cpython-37.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro2-python/44fd4209b9e3a82b13c7ebcec1a75293bcce8847/Cap4/__pycache__/matrices.cpython-37.pyc -------------------------------------------------------------------------------- /Cap4/__pycache__/matrices.cpython-38.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro2-python/44fd4209b9e3a82b13c7ebcec1a75293bcce8847/Cap4/__pycache__/matrices.cpython-38.pyc -------------------------------------------------------------------------------- /Cap4/claves: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/ebookscg-python/Libro2-python/44fd4209b9e3a82b13c7ebcec1a75293bcce8847/Cap4/claves -------------------------------------------------------------------------------- /Cap4/edades: -------------------------------------------------------------------------------- 1 | $), -------------------------------------------------------------------------------- /Cap4/letras: -------------------------------------------------------------------------------- 1 | tres tristes tigres comen trigoaeiou -------------------------------------------------------------------------------- /Cap4/matrices.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """ 3 | @author: guardati 4 | Módulo: matrices 5 | """ 6 | 7 | def forma_matriz_1(filas, columnas): 8 | """ Construye y regresa un arreglo bidimensional inicializado en 0. 9 | Parámetros: 10 | filas: de tipo int. Indica total de filas del arreglo. 11 | columnas: de tipo int. Indica total de columnas del arreglo. 12 | Regresa: 13 | Una lista de listas (matriz) que contienen ceros. 14 | """ 15 | matriz = [] 16 | for f in range(0, filas): 17 | fila = [] 18 | for c in range(0, columnas): 19 | fila.append(0) 20 | matriz.append(fila) 21 | return matriz 22 | 23 | def forma_matriz_2(filas, columnas): 24 | """ Construye y regresa un arreglo bidimensional inicializado en 0. 25 | Parámetros: 26 | filas: de tipo int. Indica total de filas del arreglo. 27 | columnas: de tipo int. Indica total de columnas del arreglo. 28 | Regresa: 29 | Una lista de listas (matriz) que contienen ceros. 30 | """ 31 | matriz = [[0 for c in range(columnas)] for f in range(filas)] 32 | return matriz 33 | 34 | def forma_matriz_3(filas, columnas): 35 | """ Construye y regresa un arreglo bidimensional inicializado en 0. 36 | Parámetros: 37 | filas: de tipo int. Indica total de filas del arreglo. 38 | columnas: de tipo int. Indica total de columnas del arreglo. 39 | Regresa: 40 | Una lista de listas (matriz) que contienen ceros. 41 | """ 42 | matriz = [[0] * columnas for f in range(filas)] 43 | return matriz 44 | 45 | # ============================================================================= 46 | # Solución del problema 4.19 47 | # ============================================================================= 48 | def matriz_vacia(): 49 | """ Construye y regresa un arreglo bidimensional vacío. 50 | Regresa: 51 | Una lista de listas vacías (matriz vacía). 52 | """ 53 | matriz = [[]] 54 | return matriz 55 | 56 | # ============================================================================= 57 | # Solución del problema 4.20 58 | # ============================================================================= 59 | def suma_fila(matriz, fila): 60 | """ Suma y regresa los elementos de una fila del arreglo bidimensional. 61 | Parámetros: 62 | matriz: de tipo list. Es una lista de listas que guardan números. 63 | fila: de tipo int. Indica la fila de la cual se sumarán sus elementos. 64 | Regresa: 65 | La suma de los elementos de una fila del arreglo. 66 | Lanza: 67 | IndexError: si fila está fuera del rango del arreglo. 68 | TypeError: si matriz no es numérica. 69 | """ 70 | try: 71 | suma = 0 72 | columnas = len(matriz[0]) 73 | for c in range(columnas): 74 | suma += matriz[fila][c] 75 | return suma 76 | except IndexError: 77 | raise IndexError(f'El número de fila está fuera del arreglo.') 78 | except TypeError: 79 | raise TypeError('El arreglo no es numérico.') 80 | 81 | def suma_columna(matriz, columna): 82 | """ Suma y regresa los elementos de una columna del arreglo bidimensional. 83 | Parámetros: 84 | matriz: de tipo list. Es una lista de listas que guardan números. 85 | columna: de tipo int. Indica la columna de la cual se sumarán sus 86 | elementos. 87 | Regresa: 88 | La suma de los elementos de una columna del arreglo. 89 | Lanza: 90 | IndexError: si columna está fuera del rango del arreglo. 91 | TypeError: si matriz no es numérica. 92 | """ 93 | try: 94 | suma = 0 95 | filas = len(matriz) 96 | for f in range(filas): 97 | suma += matriz[f][columna] 98 | return suma 99 | except IndexError: 100 | raise IndexError(f'El número de columna está fuera del arreglo.') 101 | except TypeError: 102 | raise TypeError('El arreglo no es numérico.') 103 | 104 | # ============================================================================= 105 | # Solución del problema 4.21 106 | # ============================================================================= 107 | def suma_diagonal_principal(matriz): 108 | """ Suma y regresa los elementos de la diagonal principal 109 | de un arreglo bidimensional cuadrado. 110 | Parámetros: 111 | matriz: de tipo list. Es una lista de listas que guardan números. 112 | Regresa: 113 | La suma de los elementos de la diagonal principal. 114 | """ 115 | dimension = len(matriz) 116 | if dimension == len(matriz[0]): 117 | suma = 0 118 | for indice in range(dimension): 119 | suma += matriz[indice][indice] 120 | return suma 121 | else: 122 | raise IndexError('Error: no es un arreglo cuadrado.') 123 | 124 | def suma_diagonal_secundaria(matriz): 125 | """ Suma y regresa los elementos de la diagonal secundaria 126 | de un arreglo bidimensional cuadrado. 127 | Parámetros: 128 | matriz: de tipo list. Es una lista de listas que guardan números. 129 | Regresa: 130 | La suma de los elementos de la diagonal secundaria. 131 | """ 132 | dimension = len(matriz) 133 | if dimension == len(matriz[0]): 134 | suma = 0 135 | for indice in range(dimension): 136 | suma += matriz[indice][dimension - 1 - indice] 137 | return suma 138 | else: 139 | raise IndexError('Error: no es un arreglo cuadrado.') 140 | 141 | # ============================================================================= 142 | # Solución del problema 4.22 143 | # ============================================================================= 144 | def max_fila(matriz, fila): 145 | """ Obtiene y regresa la posición del elemento más grande de una 146 | fila del arreglo bidimensional. 147 | Parámetros: 148 | matriz: de tipo list. Es una lista de listas que guardan 149 | valores comparables. 150 | fila: de tipo int. Indica la fila en la cual se debe buscar 151 | el elemento más grande. 152 | Regresa: 153 | La columna en la cual está el valor más grande de la fila recibida. 154 | Lanza: 155 | IndexError: si el arreglo no tiene datos almacenados o los 156 | valores de fila o columnas están fueran del rango del arreglo. 157 | """ 158 | try: 159 | maximo = matriz[fila][0] 160 | posicion = 0 161 | columnas = len(matriz[0]) 162 | for c in range(1, columnas): 163 | if matriz[fila][c] > maximo: 164 | maximo = matriz[fila][c] 165 | posicion = c 166 | return posicion 167 | except: 168 | raise IndexError('El arreglo no tiene elementos.') 169 | 170 | def max_columna(matriz, columna): 171 | """ Obtiene y regresa la posición del elemento más grande de 172 | una columna del arreglo bidimensional. 173 | Parámetros: 174 | matriz: de tipo list. Es una lista de listas que guardan 175 | valores comparables. 176 | columna: de tipo int. Indica la columna en la cual se debe buscar 177 | el elemento más grande. 178 | Regresa: 179 | La fila en la cual está el valor más grande de la columna recibida. 180 | Lanza: 181 | IndexError: si el arreglo no tiene datos almacenados o los 182 | valores de filas o columna están fueran del rango del arreglo. 183 | """ 184 | try: 185 | maximo = matriz[0][columna] 186 | posicion = 0 187 | filas = len(matriz) 188 | for f in range(1, filas): 189 | if matriz[f][columna] > maximo: 190 | maximo = matriz[f][columna] 191 | posicion = f 192 | return posicion 193 | except: 194 | raise IndexError('El arreglo no tiene elementos.') 195 | 196 | # ============================================================================= 197 | # Solución del problema 4.23 198 | # ============================================================================= 199 | def suma_matrices(matriz1, matriz2): 200 | """ Suma dos matrices y regresa el resultado de la suma. 201 | Parámetros: 202 | matriz1: de tipo list. Es una lista de listas que guardan números. 203 | matriz2: de tipo list. Es una lista de listas que guardan números. 204 | Regresa: 205 | Una lista de listas que almacena la suma de las matrices. 206 | Lanza: 207 | IndexError: si las matrices recibidas no tienen el mismo tamaño. 208 | """ 209 | filas = len(matriz1) 210 | columnas = len(matriz1[0]) 211 | if filas == len(matriz2) and columnas == len(matriz2[0]): 212 | resultado = forma_matriz_2(filas, columnas) 213 | for f in range(filas): 214 | for c in range(columnas): 215 | resultado[f][c] = matriz1[f][c] + matriz2[f][c] 216 | return resultado 217 | else: 218 | raise IndexError('Las matrices no tienen el mismo tamaño.') 219 | 220 | # ============================================================================= 221 | # Solución del problema 4.26 222 | # ============================================================================= 223 | def es_simetrica(matriz): 224 | """ Determina si una matriz es simétrica. 225 | Parámetro: 226 | matriz: de tipo list. Lista de listas. 227 | Regresa: 228 | True si es simétrica, False en caso contrario. 229 | """ 230 | dimension = len(matriz) 231 | if dimension == len(matriz[0]): # Es cuadrada. 232 | f = 1 233 | simetrica = True 234 | while simetrica and f < dimension: 235 | c = 0 236 | while simetrica and c < f: 237 | simetrica = matriz[f][c] == matriz[c][f] 238 | c += 1 239 | f += 1 240 | else: 241 | simetrica = False 242 | return simetrica 243 | 244 | # ============================================================================= 245 | # Solución del problema 4.27 246 | # ============================================================================= 247 | def traspuesta(matriz): 248 | """ Obtiene la matriz traspuesta de la matriz recibida. 249 | Parámetro: 250 | matriz: de tipo list. Lista de listas. 251 | Regresa: 252 | La matriz traspuesta de la matriz recibida. Es de tipo list. 253 | """ 254 | filas = len(matriz) 255 | columnas = len(matriz[0]) 256 | trasp = forma_matriz_2(columnas, filas) 257 | for f in range(filas): 258 | for c in range(columnas): 259 | trasp[c][f] = matriz[f][c] 260 | return trasp 261 | 262 | # ============================================================================= 263 | # Solución del problema 4.28 264 | # ============================================================================= 265 | def multiplica_matrices(matriz1, matriz2): 266 | """ Multiplica dos matrices y regresa el resultado que es otra matriz. 267 | Parámetros: 268 | matriz1: de tipo list. Lista de listas. 269 | matriz2: de tipo list. Lista de listas. 270 | Regresa: 271 | La matriz resultado de la multiplicación de las matrices recibidas. 272 | """ 273 | filas1 = len(matriz1) 274 | columnas1 = len(matriz1[0]) 275 | filas2 = len(matriz2) 276 | columnas2 = len(matriz2[0]) 277 | if columnas1 == filas2: 278 | resultado = forma_matriz_2(filas1, columnas2) 279 | for i in range(filas1): 280 | for j in range(columnas2): 281 | acum = 0 282 | for k in range(columnas1): 283 | acum += matriz1[i][k] * matriz2[k][j] 284 | resultado[i][j] = acum 285 | return resultado 286 | else: 287 | raise ValueError('Las matrices no pueden multiplicarse.') 288 | 289 | # ============================================================================= 290 | # Solución del problema 4.30 291 | # ============================================================================= 292 | def es_triangular_superior(matriz): 293 | """ Determina si la matriz recibida es una matriz triangular superior. 294 | Parámetro: 295 | matriz: de tipo list. Lista de listas que guardan números. 296 | Regresa: 297 | True si la matriz cumple con la condición o False en caso contrario. 298 | Lanza: 299 | ValueError: si la matriz no es cuadrada. 300 | """ 301 | n = len(matriz) 302 | if n > 0 and n == len(matriz[0]): # Es cuadrada. 303 | respuesta = True 304 | fila = 1 305 | while respuesta and fila < n: 306 | columna = 0 307 | while respuesta and columna < fila: 308 | respuesta = matriz[fila][columna] == 0 309 | columna += 1 310 | fila += 1 311 | return respuesta 312 | raise ValueError('La matriz no es cuadrada.') 313 | 314 | def es_triangular_inferior(matriz): 315 | """ Determina si la matriz recibida es una matriz triangular inferior. 316 | Parámetro: 317 | matriz: de tipo list. Lista de listas que guardan números. 318 | Regresa: 319 | True si la matriz cumple con la condición o False en caso contrario. 320 | Lanza: 321 | ValueError: si la matriz no es cuadrada. 322 | """ 323 | n = len(matriz) 324 | if n > 0 and n == len(matriz[0]): # Es cuadrada. 325 | respuesta = True 326 | fila = 0 327 | una_antes = n - 1 328 | while respuesta and fila < una_antes: 329 | columna = fila + 1 330 | while respuesta and columna < n: 331 | respuesta = matriz[fila][columna] == 0 332 | columna += 1 333 | fila += 1 334 | return respuesta 335 | raise ValueError('La matriz no es cuadrada.') 336 | 337 | # ============================================================================= 338 | # Funciones auxiliares usadas en algunos de los problemas resueltos. 339 | # ============================================================================= 340 | def a_cadena(matriz): 341 | """ Genera una cadena con el contenido del arreglo. 342 | Parámetro: 343 | matriz: de tipo list (lista de listas). 344 | Representa un arreglo bidimensional. 345 | Regresa: 346 | Una cadena con el contenido del arreglo o una cadena vacía si 347 | el arreglo está vacío. 348 | """ 349 | cadena = '' 350 | filas = len(matriz) 351 | if filas > 0: 352 | columnas = len(matriz[0]) 353 | for f in range(0, filas): 354 | for c in range(0, columnas): 355 | cadena += str(matriz[f][c]) + ' ' 356 | cadena += '\n' 357 | return cadena 358 | 359 | def lee(matriz, tipo): 360 | """ Lee datos de la terminal y los almacena en un arreglo bidimensional, 361 | por filas. 362 | Parámetros: 363 | matriz: de tipo list. Es una lista de listas. 364 | tipo: de tipo str. Indica el tipo de datos que se leerá. 365 | """ 366 | filas = len(matriz) 367 | columnas = len(matriz[0]) 368 | for f in range(filas): 369 | for c in range(columnas): 370 | matriz[f][c] = tipo(input(f'Ingrese el elemento ({f}, {c}): ')) 371 | 372 | def lee_de_archivo(archivo, tipo): 373 | """ Lee números de un archivo de texto y los almacena en un 374 | arreglo bidimensional, por filas. El primer dato del archivo es el 375 | número de filas y, el segundo, es el número de columnas. 376 | Todos los valores guardados en el archivo se encuentran en líneas 377 | distintas. 378 | Parámetros: 379 | archivo: de tipo str. Es el nombre del archivo. 380 | tipo: de tipo str. Indica el tipo de dato que se leerá del archivo. 381 | Regresa: 382 | Una lista de listas (matriz). 383 | Lanza: 384 | Exception: si se produjo algún error (al abrir el archivo, al 385 | convertir a tipo, al acceder a una posición del arreglo, etc.) 386 | """ 387 | try: 388 | with open(archivo, 'r') as arch: 389 | filas = int(arch.readline()) 390 | columnas = int(arch.readline()) 391 | matriz = forma_matriz_3(filas, columnas) 392 | for f in range(filas): 393 | for c in range(columnas): 394 | matriz[f][c] = tipo(arch.readline().strip()) 395 | return matriz 396 | except Exception: 397 | raise Exception('Error al leer el archivo.') 398 | 399 | def todos_menores_que(matriz, referencia): 400 | """ Genera una lista con las filas cuyos valores son todos menores 401 | que el valor dado como referencia. 402 | Parámetros: 403 | matriz: de tipo list. Lista de listas de datos comparables. 404 | referencia: del mismo tipo que los datos de la matriz. 405 | Regresa: 406 | Una lista de enteros. 407 | """ 408 | resultado = [] 409 | filas = len(matriz) 410 | columnas = len(matriz[0]) 411 | for f in range(filas): 412 | bandera = True 413 | indice = 0 414 | while bandera and indice < columnas: 415 | bandera = matriz[f][indice] < referencia 416 | indice += 1 417 | if bandera: 418 | resultado.append(f) 419 | return resultado 420 | 421 | def cuenta_por_columna_mayores_que(matriz, columna, referencia): 422 | """ Cuenta los elementos de una columna que son mayores que el valor 423 | dado como referencia. 424 | Parámetros: 425 | matriz: de tipo list. Lista de listas de datos comparables. 426 | columna: de tipo int. Indica la columna que se analizará. 427 | referencia: del mismo tipo que los datos de la matriz. 428 | Regresa: 429 | Cantidad de elementos mayores que el valor recibido. 430 | Lanza: 431 | IndexError: si el arreglo no tiene datos almacenados o los 432 | valores de filas o columna están fueran del rango del arreglo. 433 | """ 434 | try: 435 | filas = len(matriz) 436 | contador = 0 437 | for f in range(filas): 438 | if matriz[f][columna] > referencia: 439 | contador += 1 440 | return contador 441 | except: 442 | raise IndexError(f'El número de columna está fuera del arreglo.') -------------------------------------------------------------------------------- /Cap4/numeros: -------------------------------------------------------------------------------- 1 |   ,( -------------------------------------------------------------------------------- /Cap4/pares: -------------------------------------------------------------------------------- 1 | susurros -------------------------------------------------------------------------------- /Cap4/precios: -------------------------------------------------------------------------------- 1 | 3 2 | 2 3 | 12.5 4 | 8.3 5 | 98.45 6 | 10.45 7 | 11 8 | 24.3 9 | -------------------------------------------------------------------------------- /Cap4/puntajes: -------------------------------------------------------------------------------- 1 | ZPKdn<2ndZ -------------------------------------------------------------------------------- /Cap4/temperaturas: -------------------------------------------------------------------------------- 1 | 7 2 | 4 3 | 6.5 4 | 5.0 5 | 9.0 6 | 7.0 7 | 6.0 8 | 5.5 9 | 11.0 10 | 9.0 11 | 5.0 12 | 4.6 13 | 9.3 14 | 7.1 15 | 6.2 16 | 5.6 17 | 11.2 18 | 9.3 19 | 7.3 20 | 6.6 21 | 13.1 22 | 11.4 23 | 8.2 24 | 7.0 25 | 16.5 26 | 17.1 27 | 10.1 28 | 9.5 29 | 18.5 30 | 16.4 31 | -------------------------------------------------------------------------------- /Cap4/yoga: -------------------------------------------------------------------------------- 1 | )$)) -------------------------------------------------------------------------------- /Cap4/yoga_verano: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Libro2-python 2 | Código de los ejemplos y programas del libro: "De cero al infinito. Colecciones de datos + algoritmos en Python". 3 | --------------------------------------------------------------------------------