Crear códigos eficientes en Python implica buenas prácticas de programación y utilizar técnicas que optimicen el rendimiento del código.[br]1. Vectorización[br]2. Preasignar memoria[br]3. Evitar el uso excesivo de variables temporales.[br]4. Utilizar funciones y scripts[br]5. Aprovechar las funciones y algoritmos incorporados[br]6. Perfilado de código[br]7. Utilizar tipos de datos adecuados[br]8. Almacenamiento eficiente[br]9. Preasignación de memoria[br]10. Evita operaciones innecesarias[br]11. Utiliza funciones nativas y optimizadas[br]12. Carga de datos eficiente[br]13. Perfilado y optimización[br]14. Paralelización[br]15. Evita el uso excesivo de bucles anidados[br]16. Actualiza Python

Buenas prácticas para escribir código más legible, mantenible y eficiente:[br]1. Comentarios[br]2. Nombres de variables[br]3. Modularidad[br]4. Estilo de codificación consistente[br]5. Evita la duplicación de código[br]6. Uso de vectores y matrices[br]7. Control de errores y excepciones[br]8. Pruebas y depuración[br]9. Documentación[br]10. Mantén tu entorno de trabajo organizado

Buenas prácticas para escribir código más legible, mantenible y eficiente:[br][br]1. Utiliza nombres de variables descriptivos y significativos.[br]2. Divide el código en funciones o métodos más pequeños y reutilizables.[br]3. Evita la duplicación de código utilizando funciones o clases.[br]4. Comenta tu código para explicar su funcionamiento y propósito.[br]5. Utiliza sangría y espacios en blanco adecuados para mejorar la legibilidad.[br]6. Evita líneas de código demasiado largas, intenta mantenerlas por debajo de 80 caracteres.[br]7. Utiliza nombres de funciones y variables en minúsculas con palabras separadas por guiones bajos (snake_case).[br]8. Utiliza nombres de clases en CamelCase.[br]9. Evita el uso excesivo de abreviaturas en los nombres de variables y funciones.[br]10. Utiliza constantes en lugar de valores literales para mejorar la legibilidad y facilitar los cambios futuros.[br]11. Utiliza comentarios para explicar el propósito y la lógica detrás de secciones de código complejas.[br]12. Evita el uso de comentarios innecesarios o redundantes.[br]13. Utiliza estructuras de control claras y concisas, evitando anidaciones excesivas.[br]14. Utiliza nombres de archivos y directorios descriptivos y significativos.[br]15. Organiza tu código en módulos o paquetes lógicos.[br]16. Utiliza espacios en blanco adicionales para separar secciones de código relacionadas.[br]17. Utiliza convenciones de nomenclatura consistentes en todo el código.[br]18. Evita el uso de variables globales siempre que sea posible.[br]19. Utiliza excepciones y manejo de errores adecuados para evitar fallas inesperadas.[br]20. Utiliza pruebas unitarias para verificar el funcionamiento correcto del código.[br]21. Evita la repetición de código utilizando bucles y estructuras de datos adecuadas.[br]22. Utiliza bibliotecas y módulos existentes en lugar de reinventar la rueda.[br]23. Utiliza el principio DRY (Don't Repeat Yourself) para evitar la duplicación de código.[br]24. Utiliza el principio KISS (Keep It Simple, Stupid) para mantener el código simple y fácil de entender.[br]25. Utiliza el principio SOLID para diseñar código modular y extensible.[br]26. Evita el uso excesivo de comentarios en línea, a menos que sea necesario.[br]27. Utiliza nombres de funciones verbales y descriptivos que indiquen claramente su propósito.[br]28. Evita el uso de variables globales mutables, ya que pueden causar efectos secundarios inesperados.[br]29. Utiliza constantes en lugar de números mágicos para mejorar la legibilidad y facilitar los cambios futuros.[br]30. Utiliza el control de versiones para realizar un seguimiento de los cambios en el código y facilitar la colaboración.[br]31. Evita la duplicación de código utilizando herencia o composición.[br]32. Utiliza comentarios para documentar el código y proporcionar ejemplos de uso.[br]33. Utiliza nombres de variables y funciones que sean fáciles de pronunciar y recordar.[br]34. Evita el uso de variables globales compartidas entre diferentes partes del código.[br]35. Utiliza nombres de variables y funciones que sean consistentes con el dominio del problema.[br]36. Utiliza el principio YAGNI (You Ain't Gonna Need It) para evitar agregar funcionalidad innecesaria.[br]37. Evita el uso de código muerto o no utilizado.[br]38. Utiliza nombres de variables y funciones que sean lo más cortos posible sin perder claridad.[br]39. Evita el uso de comentarios obvios o redundantes que no agreguen información adicional.[br]40. Utiliza nombres de variables y funciones que sean lo más largos necesarios para ser descriptivos.[br]41. Evita el uso de código duplicado utilizando funciones o clases genéricas.[br]42. Utiliza nombres de variables y funciones que sean consistentes con las convenciones de la comunidad o el lenguaje de programación.[br]43. Evita el uso de variables globales que puedan ser modificadas por diferentes partes del código.[br]44. Utiliza nombres de variables y funciones que sean fáciles de buscar y reemplazar en todo el código.[br]45. Evita el uso de comentarios innecesarios que no agreguen información útil.[br]46. Utiliza nombres de variables y funciones que sean lo más descriptivos posible.[br]47. Utiliza estructuras de datos adecuadas para almacenar y manipular información.[br]48. Evita el uso de código duplicado utilizando funciones de biblioteca o utilidades.[br]49. Utiliza herramientas de análisis estático de código para identificar posibles problemas y mejorar la calidad del código.

######################################################[br]#5 Ejemplos de tuplas en Python[br][br]tupla1 = (3, 5)[br]print(tupla1)[br]tupla2 = ("hola", 7.8, True)[br]print(tupla2)[br]tupla3 = ("manzana", "naranja", "plátano")[br]print(tupla3)[br]tupla4 = (1, "dos", [3, 4])[br]print(tupla4)[br]tupla5 = (("a", 1), ("b", 2), ("c", 3))[br]print(tupla5)

####################################################[br]#30 ejemplos de operaciones con tuplas en Python:[br][br]#1. Crear una tupla vacía: [br]my_tuple = ()[br]#2. Crear una tupla con elementos: [br]my_tuple = (1, 2, 3)[br]#3. Acceder a un elemento de una tupla: [br]print(my_tuple[0])[br]#4. Acceder a varios elementos de una tupla: [br]print(my_tuple[1:3])[br]#5. Concatenar dos tuplas: [br]new_tuple = my_tuple + (4, 5, 6)[br]print(new_tuple)[br]#6. Repetir una tupla varias veces: [br]new_tuple = my_tuple * 3[br]print(new_tuple)[br]#7. Obtener la longitud de una tupla: [br]print(len(my_tuple))[br]#8. Verificar si un elemento está en una tupla: [br]print(3 in my_tuple)[br]#9. Verificar si un elemento no está en una tupla: [br]print(4 not in my_tuple)[br]#10. Convertir una lista en una tupla: [br]my_list = [1, 2, 3]; [br]my_tuple = tuple(my_list)[br]print(my_tuple)[br]#11. Convertir una tupla en una lista: [br]my_list = list(my_tuple)[br]print(my_list)[br]#12. Obtener el máximo valor de una tupla: [br]print(max(my_tuple))[br]#13. Obtener el mínimo valor de una tupla: [br]print(min(my_tuple))[br]#14. Obtener la suma de los valores de una tupla: [br]print(sum(my_tuple))[br]#15. Obtener la media de los valores de una tupla: [br]print(sum(my_tuple)/len(my_tuple))[br]#16. Obtener la mediana de los valores de una tupla: [br]sorted_list = sorted(my_tuple); [br]median = sorted_list[len(sorted_list)//2][br]print(median)[br]#17. Obtener la moda de los valores de una tupla: [br]from statistics import mode; [br]print(mode(my_tuple))[br]#18. Obtener la desviación estándar de los valores de una tupla: [br]from statistics import stdev; [br]print(stdev(my_tuple))[br]#19. Obtener la varianza de los valores de una tupla: [br]from statistics import variance; [br]print(variance(my_tuple))[br]#20. Contar el número de veces que aparece un elemento en una tupla: [br]print(my_tuple.count(3))[br]#21. Encontrar el índice de la primera aparición de un elemento en una tupla: [br]print(my_tuple.index(3))[br]#22. Ordenar una tupla: [br]sorted_tuple = sorted(my_tuple)[br]print(sorted_tuple)[br]#23. Obtener una tupla inversa: [br]reversed_tuple = my_tuple[::-1][br]print(reversed_tuple)[br]#24. Obtener una tupla ordenada inversa: [br]sorted_tuple = sorted(my_tuple, reverse=True)[br]print(sorted_tuple)[br]#25. Obtener una tupla con elementos únicos: [br]unique_tuple = tuple(set(my_tuple))[br]print(unique_tuple)[br]#26. Obtener una tupla con elementos comunes entre dos tuplas: [br]common_tuple = tuple(set(my_tuple) & set(other_tuple))[br]print(common_tuple)[br]#27. Obtener una tupla con elementos únicos en una tupla pero no en otra: [br]unique_tuple = tuple(set(my_tuple) - set(other_tuple))[br]print(unique_tuple)[br]#28. Obtener una tupla con elementos en una tupla pero no en otra: [br]diff_tuple = tuple(set(my_tuple).symmetric_difference(set(other_tuple)))[br]print(diff_tuple)[br]#29. Obtener una tupla con elementos que aparecen en ambas tuplas: [br]union_tuple = tuple(set(my_tuple).union(set(other_tuple)))[br]print(union_tuple)[br]#30. Obtener una tupla con elementos que aparecen en una tupla pero no en otra, y viceversa: [br]diff_tuple = tuple(set(my_tuple).difference(set(other_tuple))) + tuple(set(other_tuple).difference(set(my_tuple)))[br]print(diff_tuple)

import random[br]a=3; [br]b=8;[br]x = random.randint(1, 10)[br][br]if x == a:[br] print("x == a")[br]else:[br] print("x != a")[br][br]if x != a:[br] print("x != a")[br]else:[br] print("x == a")[br][br]if x > a:[br] print("x > a")[br]else:[br] print("x <= a")[br][br]if x <= a:[br] print("x <= a")[br]else:[br] print("x > a")[br][br]if x >= a:[br] print("x >= a")[br]else:[br] print("x < a")[br][br]if x < a:[br] print("x < a")[br]else:[br] print("x >= a")[br][br]######################[br]#Conversión de Negaciones[br]#De conjunción A disyunción [br]#por Ley de Morgan[br][br]if x > a and x < b:[br] print("x > a and x < b")[br]else:[br] print("x <= a or x >= b")[br][br]if x >= a and x <= b:[br] print("x >= a and x <= b")[br]else:[br] print("x < a or x > b")[br][br]if x >= a and x < b:[br] print("x >= a and x < b")[br]else:[br] print("x < a or x >= b")[br][br]if x > a and x <= b:[br] print("x > a and x <= b")[br]else:[br] print("x <= a or x> b")[br][br]#######################[br]#Conversión de Negaciones[br]#De disyunción A conjunción [br]#por Ley de Morgan[br][br]if x <= a or x>= b:[br] print("x <= a or x>= b")[br]else:[br] print("x > a and x < b")[br][br]if x < a or x > b:[br] print("x < a or x > b")[br]else:[br] print("x >= a and x <= b")[br][br]if x < a or x >= b:[br] print("x < a or x >= b")[br]else:[br] print("x >= a and x < b")[br][br]if x <= a or x > b:[br] print("x <= a or x > b")[br]else:[br] print("x > a and x <= b")

import random[br]a=3; [br]b=8;[br]x = random.randint(1, 10)[br][br]if x == a:[br] print(f"{x:0.0f} == {a:0.0f}")[br]else:[br] print(f"{x:0.0f} != {a:0.0f}")[br][br]if x != a:[br] print(f"{x:0.0f} != {a:0.0f}")[br]else:[br] print(f"{x:0.0f} == {a:0.0f}")[br][br]if x > a:[br] print(f"{x:0.0f} > {a:0.0f}")[br]else:[br] print(f"{x:0.0f} <= {a:0.0f}")[br][br]if x <= a:[br] print(f"{x:0.0f} <= {a:0.0f}")[br]else:[br] print(f"{x:0.0f} > {a:0.0f}")[br][br]if x >= a:[br] print(f"{x:0.0f} >= {a:0.0f}")[br]else:[br] print(f"{x:0.0f} < {a:0.0f}")[br][br]if x < a:[br] print(f"{x:0.0f} < {a:0.0f}")[br]else:[br] print(f"{x:0.0f} >= {a:0.0f}")[br][br]######################[br]#Conversión de Negaciones[br]#De conjunción A disyunción [br]#por Ley de Morgan[br][br]if x > a and x < b:[br] print(f"{x:0.0f} > {a:0.0f} and {x:0.0f} < {b:0.0f}")[br]else:[br] print(f"{x:0.0f} <= {a:0.0f} or {x:0.0f} >= {b:0.0f}")[br][br]if x >= a and x <= b:[br] print(f"{x:0.0f} >= {a:0.0f} and {x:0.0f} <= {b:0.0f}")[br]else:[br] print(f"{x:0.0f} < {a:0.0f} or {x:0.0f} > {b:0.0f}")[br][br]if x >= a and x < b:[br] print(f"{x:0.0f} >= {a:0.0f} and {x:0.0f} < {b:0.0f}")[br]else:[br] print(f"{x:0.0f} < {a:0.0f} or {x:0.0f} >= {b:0.0f}")[br][br]if x > a and x <= b:[br] print(f"{x:0.0f} > {a:0.0f} and {x:0.0f} <= {b:0.0f}")[br]else:[br] print(f"{x:0.0f} <= {a:0.0f} or {x:0.0f} > {b:0.0f}")[br][br]#######################[br]#Conversión de Negaciones[br]#De disyunción A conjunción [br]#por Ley de Morgan[br][br]if x <= a or x>= b:[br] print(f"{x:0.0f} <= {a:0.0f} or {x:0.0f} >= {b:0.0f}")[br]else:[br] print(f"{x:0.0f} > {a:0.0f} and {x:0.0f} < {b:0.0f}")[br][br]if x < a or x > b:[br] print(f"{x:0.0f} < {a:0.0f} or {x:0.0f} > {b:0.0f}")[br]else:[br] print(f"{x:0.0f} >= {a:0.0f} and {x:0.0f} <= {b:0.0f}")[br][br]if x < a or x >= b:[br] print(f"{x:0.0f} < {a:0.0f} or {x:0.0f} >= {b:0.0f}")[br]else:[br] print(f"{x:0.0f} >= {a:0.0f} and {x:0.0f} < {b:0.0f}")[br][br]if x <= a or x > b:[br] print(f"{x:0.0f} <= {a:0.0f} or {x:0.0f} > {b:0.0f}")[br]else:[br] print(f"{x:0.0f} > {a:0.0f} and {x:0.0f} <= {b:0.0f}")

#######################################################[br]#10 Ejemplos utilizando la sentencia assert en Python.[br][br]#1. Verificar que una variable sea igual a un valor específico:[br]x = 5[br]assert x == 5[br][br]#2. Verificar que una lista tenga un número específico de elementos:[br]lista = [1, 2, 3, 4, 5][br]assert len(lista) == 5[br][br]#3. Verificar que una cadena de texto contenga un carácter específico:[br]cadena = "Hola mundo"[br]assert "o" in cadena[br][br]#4. Verificar que un diccionario tenga una clave específica:[br]diccionario = {"nombre": "Juan", "edad": 30}[br]assert "nombre" in diccionario[br][br]#5. Verificar que un número sea mayor que otro:[br]x = 5[br]y = 3[br]assert x > y[br][br]#6. Verificar que una función devuelva un valor específico:[br]def suma(a, b):[br] return a + b[br]assert suma(2, 3) == 5[br][br]#7. Verificar que una lista esté ordenada de forma ascendente:[br]lista = [1, 2, 3, 4, 5][br]assert lista == sorted(lista)[br][br]#8. Verificar que una lista no tenga elementos duplicados:[br]lista = [1, 2, 3, 4, 5][br]assert len(lista) == len(set(lista))[br][br][br]#9. Verificar que una variable sea de un tipo específico:[br]x = "Hola mundo"[br]assert isinstance(x, str)[br][br]#10. Verificar que una expresión sea verdadera:[br]x = 5[br]y = 3[br]assert (x + y) == 8[br]

###########################################[br]#13 ejemplos de formatos print en Python:[br][br]#1. Imprimir un string:[br]print("Hola, mundo!")[br][br]#2. Imprimir una variable:[br]numero = 5[br]print(numero)[br][br]#3. Imprimir dos variables separadas por un espacio:[br]nombre = "Juan"[br]edad = 25[br]print(nombre, edad)[br][br]#4. Imprimir una variable dentro de un string:[br]nombre = "Juan"[br]print(f"Hola, me llamo {nombre}")[br][br]#5. Imprimir un número con formato decimal:[br]numero = 3.1416[br]print(f"El número es: {numero:.2f}")[br][br]#6. Imprimir un número con formato de porcentaje:[br]porcentaje = 0.75[br]print(f"El porcentaje es: {porcentaje:.2%}")[br][br]#7. Imprimir un número con formato de coma flotante:[br]numero = 1000000[br]print(f"El número es: {numero:,}")[br][br]#8. Imprimir una lista con formato personalizado:[br]lista = [1, 2, 3, 4][br]print("La lista es: ", end="")[br]for elemento in lista:[br] print(elemento, end="-")[br][br]#9. Imprimir un diccionario con formato personalizado:[br]diccionario = {"nombre": "Juan", "edad": 25}[br]for clave, valor in diccionario.items():[br] print(f"{clave}: {valor}")[br][br]#10. Imprimir un mensaje de error en rojo:[br]mensaje = "Error: no se pudo conectar al servidor"[br]print("\033[91m{}\033[00m".format(mensaje))[br][br]#11. Insertar valores en una cadena:[br]nombre = "Juan"[br]edad = 30[br]print("Me llamo {} y tengo {} años.".format(nombre, edad))[br][br]#12. Especificar el orden de los argumentos:[br]nombre = "Juan"[br]edad = 30[br]print("Me llamo {1} y tengo {0} años.".format(edad, nombre))[br][br]#13. Nombrar argumentos para mayor claridad:[br]print("Me llamo {nombre} y tengo {edad} años.".format(nombre="Juan", edad=30))[br][br]###############################################################[br]#5 Ejemplos en Python repitiendo una cadena N veces con el operador *.[br][br]#1. Repitiendo una cadena 3 veces: [br]cadena = "Hola "[br]n = 3[br]resultado = cadena * n[br]print(resultado)[br]##Resultado: "Hola Hola Hola "[br][br]#2. Repitiendo una cadena 5 veces: [br]cadena = "Python "[br]n = 5[br]resultado = cadena * n[br]print(resultado)[br]##Resultado: "Python Python Python Python Python "[br][br]#3. Repitiendo una cadena vacía 2 veces:[br]cadena = ""[br]n = 2[br]resultado = cadena * n[br]print(resultado)[br]##Resultado: ""[br][br]#4. Repitiendo una cadena con números 4 veces: [br]cadena = "123 "[br]n = 4[br]resultado = cadena * n[br]print(resultado)[br]#Resultado: "123 123 123 123 "[br][br]#5. Repitiendo una cadena con caracteres especiales 6 veces:[br]cadena = "@#* "[br]n = 6[br]resultado = cadena * n[br]print(resultado)[br]#Resultado: "@#* @#* @#* @#* @#* @#* "[br][br]########################################################[br]#10 Ejemplos utilizando secuencias de escape en Python.[br][br]#1. Imprimir una cadena con una nueva línea:[br]print("Hola\nMundo")[br][br]#2. Imprimir una cadena con una comilla simple:[br]print('La palabra "Python" se refiere a un tipo de serpiente')[br][br]#3. Imprimir una cadena con una comilla doble:[br]print("El módulo \"math\" es muy útil para cálculos matemáticos")[br][br]#4. Imprimir una cadena con una barra invertida:[br]print("La ruta del archivo es C:\\Users\\Usuario\\Documentos")[br][br]#5. Imprimir una cadena con un tabulador:[br]print("Nombre\tEdad\tCiudad")[br]print("Juan\t25\tMadrid")[br]print("María\t30\tBarcelona")[br][br]#6. Imprimir una cadena con un retorno de carro:[br]print("Esto es un ejemplo\rde retorno de carro")[br][br]#7. Imprimir una cadena con un retroceso:[br]print("Esto es un ejemplo\bde retroceso")[br][br]#8. Imprimir una cadena con un avance de página:[br]print("Esto es un ejemplo\fde avance de página")[br][br]#9. Imprimir una cadena con caracteres unicode:[br]print("\u00C1rbol") # Árbol[br]print("\u263A Cara sonriente") # ☺ Cara sonriente[br][br]#10. Imprimir una cadena con caracteres octales y hexadecimales:[br]print("\141\142\143") # abc (usando octal)[br]print("\x61\x62\x63") # abc (usando hexadecimal)

#41 Ejemplos de Funciones sobre Cálculos y Operaciones Matemáticas[br][br]#1. Factorial usando recursividad:[br]def factorial(n):[br] if n == 0:[br] return 1[br] else:[br] return n * factorial(n-1)[br][br]#2. Calcular el factorial de un número usando un bucle:[br]def factorial(n):[br] result = 1[br] for i in range(1, n+1):[br] result *= i[br] return result[br][br]#3. Calcula la suma de una lista de números usando un bucle:[br]def sum_list(arr):[br] result = 0[br] for i in range(len(arr)):[br] result += arr[i][br] return result[br][br]#4. Calcula el producto de una lista de números usando un bucle:[br]def product_list(arr):[br] result = 1[br] for i in range(len(arr)):[br] result *= arr[i][br] return result[br][br]#5. Calcular la media de una lista de números:[br]def mean(arr):[br] return sum(arr) / len(arr)[br][br]#6. Calcular la mediana de una lista de números:[br]def median(arr):[br] n = len(arr)[br] arr.sort()[br] if n % 2 == 0:[br] return (arr[n//2] + arr[n//2-1]) / 2[br] else:...[br] return arr[n//2][br][br]#7. Calcular la moda de una lista de números:[br]def mode(arr):[br] freq = {}[br] for i in arr:[br] if i in freq:[br] freq[i] += 1[br] else:[br] freq[i] = 1[br] max_freq = max(freq.values())[br] mode = [k for k, v in freq.items() if v == max_freq][br] return mode[br] [br]#8. Calcular la suma de las cifras de un número:[br]def sum_digits(n):[br] return sum(int(d) for d in str(n))[br][br]#9. Calcular el producto de las cifras de un número:[br]def product_digits(n):[br] result = 1[br] for d in str(n):[br] result *= int(d)[br] return result [br] [br]#10. Calcular el MCD de dos números:[br]def gcd(a, b):[br] while b:[br] a, b = b, a % b[br] return a[br][br]#11. Calcular el MCM de dos números:[br]def lcm(a, b):[br] return a * b // gcd(a, b)[br][br]#12. Calcular la potencia de un número usando la recursividad:[br]def power(base, exponent):[br] if exponent == 0:[br] return 1[br] elif exponent % 2 == 0:[br] return power(base, exponent//2)**2[br] else:[br] return base * power(base, exponent-1)[br][br]#13. Calcula la raíz cuadrada de un número usando el método de Newton:[br]def square_root(n):[br] x = n[br] if n == 0:[br] return 0[br] guess = n/2[br] while True:[br] new_guess = (guess + n/guess)/2[br] if abs(guess - new_guess) < 1e-10:[br] return new_guess[br] guess = new_guess[br][br]#14. Calcular la distancia entre dos puntos (x1, y1) y (x2, y2): [br]import math[br]x1, y1 = 0, 0[br]x2, y2 = 3, 4 [br]distance = math.hypot(x2 - x1, y2 - y1)[br]print(distance)[br][br]#15. Calcular la distancia entre un punto (x, y) [br]#y una línea que pasa por dos puntos (x1, y1) y (x2, y2):[br]import math[br]x, y = 3, 4[br]x1, y1 = 0, 0[br]x2, y2 = 6, 0[br]distance = abs((y2 - y1) * x - (x2 - x1) * y + x2 * y1 - y2 * x1) / math.hypot(x2 - x1, y2 - y1)[br]print(distance)[br] [br]#16. Calcular la proyección de un vector (x1, y1) sobre otro vector (x2, y2):[br]import math[br]x1, y1 = 3, 4[br]x2, y2 = 1, 1[br]projection = ((x1 * x2 + y1 * y2) / (x2 ** 2 + y2 ** 2)) * x2, ((x1 * x2 + y1 * y2) / (x2 ** 2 + y2 ** 2)) * y2[br]print(projection)[br][br]#17. Convertir coordenadas polares (r, theta) a coordenadas cartesianas (x, y): [br]import math[br]r = 5[br]theta = math.pi / 4 [br]x = r * math.cos(theta)[br]y = r * math.sin(theta)[br]print(x, y)[br][br]#Ejemplos de Funciones sobre Cálculos Matemáticos.[br][br]#18. Calcula el número pi utilizando el método de Monte Carlo.[br]import random[br]def monte_carlo_pi(num_samples):[br] inside_circle = 0[br] for i in range(num_samples):[br] x = random.uniform(-1, 1)[br] y = random.uniform(-1, 1)[br] if x**2 + y**2 <= 1:[br] inside_circle += 1[br] pi = 4 * inside_circle / num_samples[br] return pi[br][br]#19. Calcula la integral de una función utilizando el método de Simpson.[br]def simpson_1_3(f, a, b, n):[br] """[br] Calcula la integral de la función f en el intervalo [a, b] utilizando la regla de Simpson 1/3 con n subintervalos.[br] """[br] h = (b - a) / n[br] x = [a + i * h for i in range(n+1)][br] y = [f(xi) for xi in x][br] integral = y[0] + y[-1] + sum([4*yi for i, yi in enumerate(y) if i % 2 == 1]) + sum([2*yi for i, yi in enumerate(y) if i % 2 == 0 and i > 0])[br] integral *= h/3[br] return integral[br][br]#20. Calcula el área bajo una curva utilizando el método del trapecio.[br]def trapecio(f, a, b, n):[br] """[br] Calcula el área bajo la curva de la función f en el intervalo [a, b] utilizando el método del trapecio con n subintervalos.[br] """[br] h = (b - a) / n[br] x = [a + i * h for i in range(n+1)][br] y = [f(xi) for xi in x][br] area = sum([(y[i] + y[i+1]) * h / 2 for i in range(n)])[br] return area[br][br]#21. Calcula el número de Euler utilizando la serie de Taylor.[br]def euler(n):[br] """[br] Calcula el número de Euler utilizando la serie de Taylor con n términos.[br] """[br] e = 0[br] for i in range(n):[br] e += 1 / factorial(i)[br] return e[br][br]#e = 1/0! + 1/1! + 1/2! + 1/3! + ... + 1/n![br]from math import factorial[br]factorial(5) # devuelve 120[br][br]#22. Calcula el logaritmo natural de un número utilizando la serie de Taylor.[br]def ln(x, n):[br] """[br] Calcula el logaritmo natural de x utilizando la serie de Taylor con n términos.[br] """[br] if x <= 0:[br] return float('-inf')[br] elif x == 1:[br] return 0[br] else:[br] ln_x = 0[br] for i in range(1, n+1):[br] ln_x += ((-1)**(i+1)) * ((x-1)**i) / i[br] return ln_x[br][br]#ln(x) = (x-1) - (x-1)^2/2 + (x-1)^3/3 - (x-1)^4/4 + ... + (-1)^(n+1) * (x-1)^n / n[br][br]#23. Calcula la función exponencial de un número utilizando la serie de Taylor.[br]def exp(x, n):[br] """[br] Calcula la función exponencial de x utilizando la serie de Taylor con n términos.[br] """[br] exp_x = 0[br] for i in range(n):[br] exp_x += x**i / factorial(i)[br] return exp_x[br][br]#exp(x) = 1 + x + x^2/2! + x^3/3! + ... + x^n/n![br]from math import factorial[br]factorial(5) # devuelve 120[br][br]#24. Calcula la función de Ackermann de dos números enteros.[br]def ackermann(m, n):[br] """[br] Calcula la función de Ackermann de dos números enteros m y n.[br] """[br] if m == 0:[br] return n + 1[br] elif m > 0 and n == 0:[br] return ackermann(m-1, 1)[br] elif m > 0 and n > 0:[br] return ackermann(m-1, ackermann(m, n-1))[br][br]#25. Calcula la función de Ackermann generalizada de tres números enteros.[br]def ackermann_generalizada(m, n, p):[br] """[br] Calcula la función de Ackermann generalizada de tres números enteros m, n y p.[br] """[br] if m == 0:[br] return n + p[br] elif m > 0 and n == 0:[br] return ackermann_generalizada(m-1, p, 1)[br] elif m > 0 and n > 0:[br] return ackermann_generalizada(m-1, ackermann_generalizada(m, n-1, p), p)[br][br]#26. Calcula la función de Jacobsthal de un número entero.[br]def jacobsthal(n):[br] """[br] Calcula la función de Jacobsthal de un número entero n.[br] """[br] if n == 0:[br] return 0[br] elif n == 1:[br] return 1[br] else:[br] return jacobsthal(n-1) + 2*jacobsthal(n-2)[br][br]#J(0) = 0[br]#J(1) = 1[br]#J(n) = J(n-1) + 2*J(n-2) para n > 1[br][br]#27. Calcula la función de Euler de un número entero en Python.[br]def euler_func(n):[br] """[br] Calcula la función de Euler de un número entero n.[br] """[br] phi = n[br] p = 2[br] while p * p <= n:[br] if n % p == 0:[br] phi -= phi // p[br] while n % p == 0:[br] n //= p[br] p += 1[br] if n > 1:[br] phi -= phi // n[br] return phi[br][br]#phi(n) = n * (1 - 1/p1) * (1 - 1/p2) * ... * (1 - 1/pk)[br][br]#28. Calcula el número de Bell de un número entero en Python.[br]def bell_number(n):[br] """[br] Calcula el número de Bell de un número entero n.[br] """[br] bell = [[0 for i in range(n+1)] for j in range(n+1)][br] bell[0][0] = 1[br] for i in range(1, n+1):[br] bell[i][0] = bell[i-1][i-1][br] for j in range(1, i+1):[br] bell[i][j] = bell[i-1][j-1] + bell[i][j-1][br] return bell[n][0][br][br]#B(0) = 1[br]#B(n) = sum_{k=0}^{n-1} binomial(n-1, k) * B(k)[br][br]#29. Calcula el número de Stirling de primer tipo de un número entero en Python.[br]def stirling_first(n, k):[br] """[br] Calcula el número de Stirling de primer tipo de n y k.[br] """[br] if n == 0 and k == 0:[br] return 1[br] elif n == 0 or k == 0:[br] return 0[br] else:[br] return (n-1)*stirling_first(n-1, k) + stirling_first(n-1, k-1)[br][br]s(n, k) = (n-1)*s(n-1, k) + s(n-1, k-1)[br][br]#30. Calcula el número de Stirling de segundo tipo de un número entero en Python.[br]def stirling_second(n, k):[br] """[br] Calcula el número de Stirling de segundo tipo de n y k.[br] """[br] if n == 0 and k == 0:[br] return 1[br] elif n == 0 or k == 0:[br] return 0[br] else:[br] return k*stirling_second(n-1, k) + stirling_second(n-1, k-1)[br][br]#S(n, k) = k*S(n-1, k) + S(n-1, k-1)[br][br]#31. Calcula el coeficiente binomial de dos números enteros en Python.[br]def binomial_coef(n, k):[br] """[br] Calcula el coeficiente binomial de n y k.[br] """[br] if k == 0 or k == n:[br] return 1[br] elif k > n:[br] return 0[br] else:[br] return binomial_coef(n-1, k-1) + binomial_coef(n-1, k)[br][br]#C(n, k) = 1 si k = 0 o k = n[br]#C(n, k) = 0 si k > n[br]#C(n, k) = C(n-1, k-1) + C(n-1, k) si 0 < k < n[br]#C(n, k) = C(n-1, k-1) * n / k[br][br]#32. Calcula el número de Catalan de un número entero en Python.[br]def catalan_number(n):[br] """[br] Calcula el número de Catalan de un número entero n.[br] """[br] if n <= 1:[br] return 1[br] else:[br] catalan = [0]*(n+1)[br] catalan[0] = 1[br] catalan[1] = 1[br] for i in range(2, n+1):[br] for j in range(i):[br] catalan[i] += catalan[j] * catalan[i-j-1][br] return catalan[n][br][br]#C(0) = 1[br]#C(n) = sum_{i=0}^{n-1} C(i) * C(n-i-1) para n > 0[br][br]#33. Calcula el número de Bonacci de un número entero en Python.[br]def bonacci_number(n, m):[br] """[br] Calcula el número de Bonacci de un número entero n y un entero m.[br] """[br] if n < m:[br] return 0[br] elif n == m or m == 1:[br] return 1[br] else:[br] bonacci = [0]*(n+1)[br] for i in range(m-1):[br] bonacci[i] = 0[br] bonacci[m-1] = 1[br] for i in range(m, n+1):[br] bonacci[i] = sum(bonacci[i-m:i])[br] return bonacci[n][br][br]#B(m) = 1 para 1 <= m <= k[br]#B(n) = sum_{i=n-k}^{n-1} B(i) para n > k[br][br]#34. Calcule el número de Pell de un número entero en Python.[br]def pell_number(n):[br] """[br] Calcula el número de Pell de un número entero n.[br] """[br] if n == 0:[br] return 0[br] elif n == 1:[br] return 1[br] else:[br] pell = [0]*(n+1)[br] pell[0] = 0[br] pell[1] = 1[br] for i in range(2, n+1):[br] pell[i] = 2*pell[i-1] + pell[i-2][br] return pell[n][br][br]#P(0) = 0[br]#P(1) = 1[br]#P(n) = 2*P(n-1) + P(n-2) para n > 1[br][br]#35. Calcula el número de Lucas de un número entero en Python.[br]def lucas_number(n):[br] """[br] Calcula el número de Lucas de un número entero n.[br] """[br] if n == 0:[br] return 2[br] elif n == 1:[br] return 1[br] else:[br] lucas = [0]*(n+1)[br] lucas[0] = 2[br] lucas[1] = 1[br] for i in range(2, n+1):[br] lucas[i] = lucas[i-1] + lucas[i-2][br] return lucas[n][br][br]#L(0) = 2[br]#L(1) = 1[br]#L(n) = L(n-1) + L(n-2) para n > 1[br][br]#36. Calcula el número de Mersenne de un número entero en Python.[br]def mersenne_number(n):[br] """[br] Calcula el número de Mersenne de un número entero n.[br] """[br] if n == 0:[br] return 0[br] else:[br] return 2**n - 1[br][br]#M(n) = 2^n - 1[br][br]#37. Calcula el producto de dos matrices en Python.[br]def multiply_matrix(A, B):[br] """[br] Calcula el producto de dos matrices A y B.[br] """[br] if len(A[0]) == len(B):[br] C = [[0 for j in range(len(B[0]))] for i in range(len(A))][br] for i in range(len(A)):[br] for j in range(len(B[0])):[br] for k in range(len(B)):[br] C[i][j] += A[i][k] * B[k][j][br] return C[br] else:[br] print("Las matrices no tienen las dimensiones adecuadas para la multiplicación.")[br][br]#38. Calcula el determinante de una matriz en Python.[br]def determinant(A):[br] """[br] Calcula el determinante de una matriz A.[br] """[br] n = len(A)[br] det = 0[br] if n == 1:[br] det = A[0][0][br] elif n == 2:[br] det = A[0][0]*A[1][1] - A[0][1]*A[1][0][br] else:[br] for j in range(n):[br] sign = (-1)**j[br] submatrix = [[A[i][k] for k in range(n) if k != j] for i in range(1, n)][br] det += sign * A[0][j] * determinant(submatrix)[br] return det[br][br]#det(A) = a_{1,1} * det(A_{1,1}) - a_{1,2} * det(A_{1,2}) + ... + (-1)^{1+n} * a_{1,n} * det(A_{1,n})[br][br]#39. Calcula la inversa de una matriz en Python.[br]def inverse_matrix(A):[br] """[br] Calcula la inversa de una matriz A.[br] """[br] n = len(A)[br] A_inv = [[0 for j in range(n)] for i in range(n)][br] det = determinant(A)[br] if det == 0:[br] print("La matriz no es invertible.")[br] return None[br] else:[br] for i in range(n):[br] for j in range(n):[br] sign = (-1)**(i+j)[br] submatrix = [[A[k][l] for l in range(n) if l != j] for k in range(n) if k != i][br] A_inv[j][i] = sign * determinant(submatrix) / det[br] return A_inv[br][br]#40. Calcula el alineamiento óptimo entre dos secuencias en Python.[br]def optimal_alignment(s1, s2, match=1, mismatch=-1, gap=-1):[br] """[br] Calcula el alineamiento óptimo entre dos secuencias s1 y s2.[br] """[br] n = len(s1)[br] m = len(s2)[br] score = [[0 for j in range(m+1)] for i in range(n+1)][br] for i in range(n+1):[br] score[i][0] = i * gap[br] for j in range(m+1):[br] score[0][j] = j * gap[br] for i in range(1, n+1):[br] for j in range(1, m+1):[br] if s1[i-1] == s2[j-1]:[br] diagonal = score[i-1][j-1] + match[br] else:[br] diagonal = score[i-1][j-1] + mismatch[br] up = score[i-1][j] + gap[br] left = score[i][j-1] + gap[br] score[i][j] = max(diagonal, up, left)[br] align1 = ""[br] align2 = ""[br] i = n[br] j = m[br] while i > 0 and j > 0:[br] if score[i][j] == score[i-1][j-1] + (match if s1[i-1] == s2[j-1] else mismatch):[br] align1 = s1[i-1] + align1[br] align2 = s2[j-1] + align2[br] i -= 1[br] j -= 1[br] elif score[i][j] == score[i-1][j] + gap:[br] align1 = s1[i-1] + align1[br] align2 = "-" + align2[br] i -= 1[br] else:[br] align1 = "-" + align1[br] align2 = s2[j-1] + align2[br] j -= 1[br] while i > 0:[br] align1 = s1[i-1] + align1[br] align2 = "-" + align2[br] i -= 1[br] while j > 0:[br] align1 = "-" + align1[br] align2 = s2[j-1] + align2[br] j -= 1[br] return align1, align2, score[n][m][br][br]#41. Calcula la distancia de Levenshtein entre dos cadenas en Python.[br]def levenshtein_distance(s1, s2):[br] """[br] Calcula la distancia de Levenshtein entre dos cadenas s1 y s2.[br] """[br] n = len(s1)[br] m = len(s2)[br] d = [[0 for j in range(m+1)] for i in range(n+1)][br] for i in range(n+1):[br] d[i][0] = i[br] for j in range(m+1):[br] d[0][j] = j[br] for j in range(1, m+1):[br] for i in range(1, n+1):[br] if s1[i-1] == s2[j-1]:[br] substitution_cost = 0[br] else:[br] substitution_cost = 1[br] d[i][j] = min(d[i-1][j] + 1, d[i][j-1] + 1, d[i-1][j-1] + substitution_cost)[br] return d[n][m]

#1. Define las preguntas y respuestas:[br]#Crea una lista de preguntas y sus respectivas respuestas.[br]#Cada pregunta debe tener una respuesta correcta y varias respuestas incorrectas.[br]# Una Lista de Diccionarios: un diccionario por cada pregunta[br]preguntas = [[br] {[br] "pregunta": "¿Cuál es el término que describe un polígono de cinco lados?",[br] "respuestas": ["Triángulo",[br] "Cuadrado",[br] "Pentágono",[br] "Hexágono"],[br] "respuesta_correcta": "Pentágono"[br] },[br] {[br] "pregunta": "¿Cuál es el término que describe un polígono de seis lados?",[br] "respuestas": ["Heptágono",[br] "Octágono",[br] "Hexágono",[br] "Triángulo"],[br] "respuesta_correcta": "Hexágono"[br] },[br] {[br] "pregunta": "¿Cuál es el término que describe un polígono de ocho lados?",[br] "respuestas": ["Octágono",[br] "Heptágono",[br] "Hexágono",[br] "Nonágono"],[br] "respuesta_correcta": "Octágono"[br] },[br] {[br] "pregunta": "¿Cuál es el término que describe un polígono de diez lados?",[br] "respuestas": ["Decágono",[br] "Nonágono",[br] "Dodecágono",[br] "Heptágono"],[br] "respuesta_correcta": "Decágono"[br] },[br] {[br] "pregunta": "¿Cuál es el término que describe un polígono de doce lados?",[br] "respuestas": ["Dodecágono",[br] "Decágono",[br] "Octágono",[br] "Hexágono"],[br] "respuesta_correcta": "Dodecágono"[br] },[br] # Agrega más preguntas aquí[br]][br]#preguntas[br][br]#2. Importa el módulo random: Necesitarás el módulo random[br]# para mezclar las respuestas de cada pregunta.[br]import random[br][br]#3. Inicializa el generador de números aleatorios.[br]random.seed(10)[br]#Mezcla las respuestas: Utiliza la función random.shuffle()[br]#para mezclar las respuestas de cada pregunta.[br]for pregunta in preguntas:[br] random.shuffle(pregunta["respuestas"])[br] [br]#4. Presenta las preguntas y opciones de respuesta: Utiliza un bucle for[br]#para recorrer la lista de preguntas y mostrarlas junto con las opciones[br]#de respuesta.[br]for i, pregunta in enumerate(preguntas):[br] print(f"Pregunta {i+1}: {pregunta['pregunta']}")[br] for j, respuesta in enumerate(pregunta["respuestas"]):[br] print(f"{j+1}. {respuesta}")[br] print() [br][br]#5. Solicita la respuesta del usuario: Pide al usuario que ingrese el número[br]#de la opción de respuesta que cons[br]respuestas_usuario = [][br]for i, pregunta in enumerate(preguntas):[br] print(f"Pregunta {i+1}: {pregunta['pregunta']}")[br] for j, respuesta in enumerate(pregunta["respuestas"]):[br] print(f"{j+1}. {respuesta}")[br] respuesta_usuario = input("Ingrese la palabra de la respuesta correcta:")[br] respuestas_usuario.append(respuesta_usuario)[br][br]#6. Verifica las respuestas: Compara las respuestas del usuario[br]#con las respuestas correctas y muestra el puntaje obtenido.[br]puntaje = 0[br]for i, pregunta in enumerate(preguntas):[br] if respuestas_usuario[i] == pregunta["respuesta_correcta"]:[br] puntaje += 1[br] [br]#print(f"Tu puntaje es: {puntaje}/{len(preguntas)}")[br]vTC=puntaje;[br]vTI=len(preguntas)-vTC;[br]print("Cantidad de Respuestas Correctas:",vTC)[br]print("Porciento de Respuestas Correctas:",round((vTC/len(preguntas)*100),0),'%')[br]print("Cantidad de Respuestas Incorrectas:",vTI)[br]print("Porciento de Respuestas Incorrectas:",round((vTI/len(preguntas)*100),0),'%')

#####################################################[br]#Importar el módulo sys[br]import sys[br]print(sys.modules.keys())[br]# devuelve la lista horizontal de todos los módulos que se han importado.[br]import sys[br]print('\n'.join(sys.modules.keys()))[br]# devuelve la lista vertical de todos los módulos que se han importado.[br]#####################################################[br]import sys[br]# Obtener una lista de los nombres de los módulos importados[br]module_names = list(sys.modules.keys()) [br]# Ordenar la lista alfabéticamente[br]module_names_sorted = sorted(module_names)[br]module_names2 = [cadena for cadena in module_names_sorted if cadena.isalnum()][br]# devuelve la lista de todos los módulos alfanuméricos que se han importado[br]print('\n'.join(module_names2))[br]# devuelve la lista vertical de todos los módulos alfanuméricos que se han importado[br]print(len(module_names2))[br]# devuelve la cantidad de módulos alfanuméricos que se han importado[br]#####################################################[br]#Importar el módulo ggb[br]import ggb[br]#Imprimiendo todas las funciones en el módulo ggb usando dir[br]print(dir(ggb))[br]"""[br]['Boolean', 'Circle', 'ClearConsole', 'Distance', 'Ellipse', [br]'Function', 'If', 'Intersect', 'Line', 'Number', 'Parabola', [br]'Point', 'Polygon', 'Rotate', 'Segment', 'Slider', 'Vector', [br]'__doc__', '__name__', '__package__', 'interruptible_sleep', [br]'on_temperature_report'][br]############[br]import ggb[br]module_names = dir(ggb)[br]# Ordenar la lista alfabéticamente[br]module_names_sorted = sorted(module_names)[br]module_names2 = [cadena for cadena in module_names_sorted if cadena.isalnum()][br]# devuelve la lista de todos los módulos alfanuméricos que se han importado[br]print('\n'.join(module_names2))[br]# devuelve la lista vertical de todos los módulos alfanuméricos que se han importado[br]print(len(module_names2))[br]# devuelve la cantidad de módulos alfanuméricos que se han importado[br]#####################################################[br]#Importar el módulo time[br]import time[br]#Imprimiendo todas las funciones en el módulo time usando dir[br]print(dir(time))[br]"""[br]['__doc__', '__name__', '__package__', 'accept2dyear', [br]'altzone', 'asctime', 'clock', 'ctime', 'daylight', [br]'gmtime', 'localtime', 'mktime', 'sleep', 'strftime', [br]'strptime', 'struct_time', 'time', 'timezone', [br]'tzname', 'tzset'][br]"""[br]#####################################################[br]#Importar el módulo array[br]import array[br]#Imprimiendo todas las funciones en el módulo array usando dir[br]print(dir(array))[br]"""[br]['__doc__', '__name__', '__package__', 'array'][br]"""[br]#####################################################[br]#Importar el módulo collections[br]import collections[br]#Imprimiendo todas las funciones en el módulo collections usando dir[br]print(dir(collections))[br]"""[br]['Counter', 'OrderedDict', '__all__', '__doc__', '__name__', [br]'__package__', '_chain', '_iskeyword', '_itemgetter', '_repeat', [br]'_starmap', 'defaultdict', 'deque', 'namedtuple'][br]"""[br]#####################################################[br]#Importar el módulo keyword[br]import keyword[br]#Imprimiendo todas las funciones en el módulo keyword usando dir[br]print(dir(keyword))[br]"""[br]['__all__', '__doc__', '__file__', '__name__', [br]'__package__', 'iskeyword', 'kwlist'][br]"""[br]#####################################################[br]#Importar el módulo itertools[br]import itertools[br]#Imprimiendo todas las funciones en el módulo itertools usando dir[br]print(dir(itertools))[br]"""[br]['__doc__', '__name__', '__package__', '_grouper', 'accumulate', [br]'chain', 'combinations', 'combinations_with_replacement', [br]'compress', 'count', 'cycle', 'dropwhile', 'filterfalse', [br]'groupby', 'islice', 'permutations', 'product', 'repeat', [br]'starmap', 'takewhile', 'tee', 'zip_longest'][br]"""[br]#####################################################[br]#Importar el módulo operator[br]import operator[br]#Imprimiendo todas las funciones en el módulo operator usando dir[br]print(dir(operator))[br]"""[br]['__abs__', '__add__', '__all__', '__and__', '__concat__', [br]'__contains__', '__delitem__', '__div__', '__doc__', '__eq__', [br]'__floordiv__', '__ge__', '__getitem__', '__gt__', '__iadd__', [br]'__iand__', '__iconcat__', '__ifloordiv__', '__ilshift__', [br]'__imatmul__', '__imod__', '__imul__', '__index__', '__inv__', [br]'__invert__', '__ior__', '__ipow__', '__irshift__', '__isub__', [br]'__itruediv__', '__ixor__', '__le__', '__lshift__', '__lt__', [br]'__matmul__', '__mod__', '__mul__', '__name__', '__ne__', '__neg__', [br]'__not__', '__or__', '__package__', '__pos__', '__pow__', [br]'__rshift__', '__setitem__', '__sub__', '__truediv__', '__xor__', [br]'_abs', 'abs', 'add', 'and_', 'attrgetter', 'concat', 'contains', [br]'countOf', 'delitem', 'div', 'eq', 'floordiv', 'ge', 'getitem', [br]'gt', 'iadd', 'iand', 'iconcat', 'ifloordiv', 'ilshift', 'imatmul', [br]'imod', 'imul', 'index', 'indexOf', 'inv', 'invert', 'ior', 'ipow', [br]'irshift', 'is_', 'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', [br]'le', 'length_hint', 'lshift', 'lt', 'matmul', 'methodcaller', 'mod', [br]'mul', 'ne', 'neg', 'not_', 'or_', 'pos', 'pow', 'rshift', 'setitem', [br]'sub', 'truediv', 'truth', 'xor'][br]"""[br]#####################################################[br]#Importar el módulo datetime[br]import datetime[br]#Imprimiendo todas las funciones en el módulo datetime usando dir[br]print(dir(datetime))[br]"""[br]['MAXYEAR', 'MINYEAR', '_DAYNAMES', '_DAYS_BEFORE_MONTH', [br]'_DAYS_IN_MONTH', '_DI100Y', '_DI400Y', '_DI4Y', '_MAX_DELTA_DAYS', [br]'_MINYEARFMT', '_MONTHNAMES', '_SECONDS_PER_DAY', '_SENTINEL', [br]'_US_PER_DAY', '_US_PER_HOUR', '_US_PER_MINUTE', '_US_PER_MS', [br]'_US_PER_SECOND', '_US_PER_US', '_US_PER_WEEK', '__class__', [br]'__doc__', '__file__', '__name__', '__package__', '_accum', [br]'_build_struct_time', '_check_date_fields', '_check_int_field', [br]'_check_time_fields', '_check_tzinfo_arg', '_check_tzname', [br]'_check_utc_offset', '_cmp', '_cmperror', '_date_class', [br]'_days_before_month', '_days_before_year', '_days_in_month', [br]'_format_time', '_is_leap', '_isoweek1monday', '_math', [br]'_normalize_date', '_normalize_datetime', '_normalize_pair', [br]'_ord2ymd', '_round', '_time', '_time_class', '_tzinfo_class', [br]'_wrap_strftime', '_ymd2ord', 'date', 'datetime', 'sys', [br]'time', 'timedelta', 'tzinfo', 'unicode'][br]"""[br]#####################################################[br]#Importar el módulo math[br]import math[br]#Imprimiendo todas las funciones en el módulo math usando dir[br]print(dir(math))[br]"""[br]['__doc__', '__name__', '__package__', 'acos', 'acosh', [br]'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', [br]'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', [br]'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', [br]'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', [br]'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', [br]'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', [br]'sqrt', 'tan', 'tanh', 'tau', 'trunc'][br]"""[br]#####################################################[br]#Importar el módulo sys[br]import sys[br]#Imprimiendo todas las funciones en el módulo sys usando dir[br]print(dir(sys))[br]"""[br]['__doc__', '__name__', '__package__', '__stdin__', '__stdout__', [br]'argv', 'copyright', 'debug', 'getExecutionLimit', 'getYieldLimit', [br]'maxint', 'maxsize', 'modules', 'path', 'resetTimeout', [br]'setExecutionLimit', 'setYieldLimit', 'stdin', 'stdout', [br]'version', 'version_info'][br]"""[br]#####################################################[br]#Importar el módulo document[br]import document[br]#Imprimiendo todas las funciones en el módulo document usando dir[br]print(dir(document))[br]"""[br]['Element', '__doc__', '__name__', '__package__', [br]'createElement', 'currentDiv', 'getElementById', [br]'getElementsByClassName', 'getElementsByName', [br]'getElementsByTagName'][br]"""[br]#####################################################[br]#Importar el módulo image[br]import image[br]#Imprimiendo todas las funciones en el módulo image usando dir[br]print(dir(image))[br]"""[br]['EmptyImage', 'Image', 'ImageWin', 'Pixel', [br]'__doc__', '__name__', '__package__'][br]"""[br]#####################################################[br]#Importar el módulo platform[br]import platform[br]#Imprimiendo todas las funciones en el módulo platform usando dir[br]print(dir(platform))[br]"""[br]['__doc__', '__name__', '__package__', 'architecture', 'machine', [br]'node', 'processor', 'python_implementation', 'python_version', [br]'release', 'system', 'version'][br]"""[br]#####################################################[br]#Importar el módulo processing[br]import processing[br]#Imprimiendo todas las funciones en el módulo processing usando dir[br]print(dir(processing))[br]"""[br]['A', 'AB', 'ADD', 'AG', 'ALPHA', 'ALPHA_MASK', 'ALT', 'AMBIENT', [br]'AR', 'ARC', 'ARGB', 'ARROW', 'B', 'BACKSPACE', 'BASELINE', [br]'BEEN_LIT', 'BEVEL', 'BEZIER_VERTEX', 'BLEND', 'BLUE_MASK', [br]'BLUR', 'BOTTOM', 'BOX', 'BREAK', 'BURN', 'CAPSLK', 'CENTER', [br]'CLOSE', 'CLOSESHAPE', 'CMYK', 'CODED', 'CONTROL', 'CORNER', [br]'CORNERS', 'CROSS', 'CURVE_VERTEX', 'CUSTOM', 'DA', 'DARKEST', [br]'DB', 'DEG_TO_RAD', 'DELETE', 'DG', 'DIAMETER', 'DIFFERENCE', [br]'DILATE', 'DIRECTIONAL', 'DISABLE_ACCURATE_TEXTURES', [br]'DISABLE_DEPTH_SORT', 'DISABLE_DEPTH_TEST', 'DISABLE_OPENGL_2X_SMOOTH', [br]'DISABLE_OPENGL_ERROR_REPORT', 'DODGE', 'DOWN', 'DR', 'DXF', 'EB', [br]'EDGE', 'EG', 'ELLIPSE', 'ENABLE_ACCURATE_TEXTURES', 'ENABLE_DEPTH_SORT', [br]'ENABLE_DEPTH_TEST', 'ENABLE_NATIVE_FONTS', 'ENABLE_OPENGL_2X_SMOOTH', [br]'ENABLE_OPENGL_4X_SMOOTH', 'ENABLE_OPENGL_ERROR_REPORT', 'END', 'ENTER',[br]'EPSILON', 'ER', 'ERODE', 'ESC', 'EXCLUSION', 'Environment', 'F1', 'F10', [br]'F11', 'F12', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'G', [br]'GEOMETRY', 'GIF', 'GRAY', 'GREEN_MASK', 'GROUP', 'HALF_PI', 'HAND', [br]'HARD_LIGHT', 'HINT_COUNT', 'HOME', 'HSB', 'IMAGE', 'INSERT', 'INVERT', [br]'JAVA2D', 'JPEG', 'Keyboard', 'LEFT', 'LIGHTEST', 'LINE', 'LINES', [br]'LINUX', 'MAXOSX', 'MAX_FLOAT', 'MAX_INT', 'MAX_LIGHTS', 'META', [br]'MIN_FLOAT', 'MIN_INT', 'MITER', 'MODEL', 'MOVE', 'MULTIPLY', 'Mouse', [br]'NOCURSOR', 'NORMAL', 'NORMALIZED', 'NORMAL_MODE_AUTO', 'NORMAL_MODE_SHAPE', [br]'NORMAL_MODE_VERTEX', 'NUMLK', 'NX', 'NY', 'NZ', 'OPAQUE', 'OPEN', 'OPENGL', [br]'ORTHOGRAPHIC', 'OTHER', 'OVERLAY', 'P2D', 'P3D', 'PATH', 'PDF', [br]'PERSPECTIVE', 'PFont', 'PGDN', 'PGUP', 'PGraphics', 'PI', 'PImage', [br]'POINT', 'POINTS', 'POLYGON', 'POSTERIZE', 'PRECISIONB', 'PRECISIONF', [br]'PREC_ALPHA_SHIFT', 'PREC_MAXVAL', 'PREC_RED_SHIFT', 'PRIMITIVE', 'PROJECT', [br]'PShapeSVG', 'PVector', 'QUAD', 'QUADS', 'QUAD_STRIP', 'QUARTER_PI', 'R', [br]'RADIUS', 'RAD_TO_DEG', 'RECT', 'RED_MASK', 'REPLACE', 'RETURN', 'RGB', [br]'RIGHT', 'ROUND', 'SA', 'SB', 'SCREEN', 'SG', 'SHAPE', 'SHIFT', 'SHINE', [br]'SINCOS_LENGTH', 'SOFT_LIGHT', 'SPB', 'SPG', 'SPHERE', 'SPOT', 'SPR', 'SQUARE', [br]'SR', 'SUBTRACT', 'SW', 'Screen', 'TAB', 'TARGA', 'TAU', 'TEXT', 'THIRD_PI', [br]'THRESHOLD', 'TIFF', 'TOP', 'TRIANGLE', 'TRIANGLES', 'TRIANGLE_FAN', [br]'TRIANGLE_STRIP', 'TWO_PI', 'TX', 'TY', 'TZ', 'U', 'UP', 'V', 'VERTEX', [br]'VERTEX_FIELD_COUNT', 'VW', 'VX', 'VY', 'VZ', 'WAIT', 'WEBGL', [br]'WHITESPACE', 'WINDOWS', 'X', 'Y', 'Z', '__doc__', '__name__', [br]'__package__', 'alpha', 'ambient', 'ambientLight', 'applyMatrix', [br]'arc', 'background', 'beginCamera', 'beginShape', 'bezier', [br]'bezierDetail', 'bezierPoint', 'bezierTangent', 'bezierVertex', [br]'blend', 'blendColor', 'blue', 'box', 'brightness', 'camera', 'color', [br]'colorMode', 'constrain', 'copy', 'createFont', 'createGraphics', [br]'createImage', 'cursor', 'curve', 'curveDetail', 'curvePoint', [br]'curveTangent', 'curveTightness', 'curveVertex', 'day', 'degrees', [br]'directionalLight', 'dist', 'ellipse', 'ellipseMode', 'emissive', [br]'endCamera', 'endShape', 'environment', 'exitp', 'fill', 'filter', [br]'frameRate', 'frustum', 'get', 'green', 'height', 'hint', 'hour', [br]'hue', 'image', 'imageMode', 'keyboard', 'lerp', 'lerpColor', [br]'lightFalloff', 'lightSpecular', 'lights', 'line', 'loadBytes', [br]'loadFont', 'loadImage', 'loadPixels', 'loadShape', 'loadStrings', [br]'loop', 'mag', 'map', 'millis', 'minute', 'modelX', 'modelY', 'modelZ', [br]'month', 'mouse', 'mouseX', 'mouseY', 'noCursor', 'noFill', 'noLights', [br]'noLoop', 'noSmooth', 'noStroke', 'noTint', 'noise', 'noiseDetail', 'noiseSeed', [br]'norm', 'normal', 'ortho', 'p', 'perspective', 'pmouseX', 'pmouseY', 'point', [br]'pointLight', 'popMatrix', 'printCamera', 'printMatrix', 'printProjection', [br]'println', 'processing', 'pushMatrix', 'quad', 'radians', 'random', [br]'randomSeed', 'rect', 'rectMode', 'red', 'renderMode', 'requestImage', [br]'resetMatrix', 'rotate', 'rotateX', 'rotateY', 'rotateZ', 'run', 'saturation', [br]'save', 'saveFrame', 'saveStrings', 'scale', 'screen', 'screenX', 'screenY', [br]'screenZ', 'second', 'set', 'shape', 'shapeMode', 'shininess', 'size', [br]'smooth', 'specular', 'sphere', 'sphereDetail', 'spotLight', 'sq', 'status', [br]'stroke', 'strokeCap', 'strokeJoin', 'strokeWeight', 'text', 'textAlign', [br]'textAscent', 'textDescent', 'textFont', 'textLeading', 'textMode', 'textSize', [br]'textWidth', 'texture', 'textureMode', 'tint', 'translate', 'triangle', [br]'updatePixels', 'vertex', 'width', 'year'][br]"""[br]#####################################################[br]#Importar el módulo random[br]import random[br]#Imprimiendo todas las funciones en el módulo random usando dir[br]print(dir(random))[br]"""[br]['__doc__', '__name__', '__package__', 'choice', 'expovariate', [br]'gauss', 'lognormvariate', 'normalvariate', 'randint', 'random', [br]'randrange', 'sample', 'seed', 'shuffle', 'triangular', 'uniform'][br]"""[br]#####################################################[br]#Importar el módulo re[br]import re[br]#Imprimiendo todas las funciones en el módulo re usando dir[br]print(dir(re))[br]"""[br]['I', 'IGNORECASE', 'M', 'MULTILINE', 'MatchObject', 'RegexObject',[br]'__doc__', '__name__', '__package__', '_findre', 'compile', 'findall', [br]'match', 'purge', 'search', 'split'][br]"""[br]#####################################################[br]#Importar el módulo signal[br]import signal[br]#Imprimiendo todas las funciones en el módulo signal usando dir[br]print(dir(signal))[br]"""[br]['CTRL_BREAK_EVENT', 'CTRL_C_EVENT', 'NSIG', 'SIGABRT', [br]'SIGBREAK', 'SIGFPE', 'SIGHUP', 'SIGILL', 'SIGKILL', 'SIGNINT', [br]'SIGSEGV', 'SIGTERM', 'SIG_DFL', 'SIG_IGN', '__doc__', [br]'__name__', '__package__', 'pause', 'signal'][br]"""[br]#####################################################[br]#Importar el módulo string[br]import string[br]#Imprimiendo todas las funciones en el módulo string usando dir[br]print(dir(string))[br]"""[br]['__doc__', '__name__', '__package__', 'ascii_letters', [br]'ascii_lowercase', 'ascii_uppercase', 'capitalize', 'capwords', [br]'digits', 'hexdigits', 'join', 'letters', 'lowercase', 'octdigits', [br]'printable', 'punctuation', 'split', 'uppercase', 'whitespace'][br]"""[br]#####################################################[br]#Importar el módulo token[br]import token[br]#Imprimiendo todas las funciones en el módulo token usando dir[br]print(dir(token))[br]"""[br]['AMPER', 'AMPEREQUAL', 'ASYNC', 'AT', 'ATEQUAL', 'AWAIT', [br]'CIRCUMFLEX', 'CIRCUMFLEXEQUAL', 'COLON', 'COMMA', 'COMMENT', [br]'DEDENT', 'DOT', 'DOUBLESLASH', 'DOUBLESLASHEQUAL', 'DOUBLESTAR', [br]'DOUBLESTAREQUAL', 'ELLIPSIS', 'ENCODING', 'ENDMARKER', 'EQEQUAL', [br]'EQUAL', 'ERRORTOKEN', 'GREATER', 'GREATEREQUAL', 'INDENT', 'ISEOF', [br]'ISNONTERMINAL', 'ISTERMINAL', 'LBRACE', 'LEFTSHIFT', 'LEFTSHIFTEQUAL', [br]'LESS', 'LESSEQUAL', 'LPAR', 'LSQB', 'MINEQUAL', 'MINUS', 'NAME', [br]'NEWLINE', 'NL', 'NOTEQUAL', 'NT_OFFSET', 'NUMBER', 'N_TOKENS', 'OP', [br]'PERCENT', 'PERCENTEQUAL', 'PLUS', 'PLUSEQUAL', 'RARROW', 'RBRACE', [br]'RIGHTSHIFT', 'RIGHTSHIFTEQUAL', 'RPAR', 'RSQB', 'SEMI', 'SLASH', [br]'SLASHEQUAL', 'STAR', 'STAREQUAL', 'STRING', 'TILDE', 'VBAR', [br]'VBAREQUAL', '__doc__', '__file__', '__name__', '__package__', [br]'tok_name'][br]"""[br]#####################################################[br]#Importar el módulo tokenize[br]import tokenize[br]#Imprimiendo todas las funciones en el módulo tokenize usando dir[br]print(dir(tokenize))[br]"""[br]['__doc__', '__name__', '__package__', 'tokenize'][br]"""[br]#####################################################[br]#Importar el módulo webbrowser[br]import webbrowser[br]#Imprimiendo todas las funciones en el módulo webbrowser usando dir[br]print(dir(webbrowser))[br]""" [br]['DefaultBrowser', '__doc__', '__name__', '__package__', 'get', [br]'open', 'open_new', 'open_new_tab'][br]"""[br]#Importar el módulo bisect[br]import bisect[br]#Imprimiendo todas las funciones en el módulo bisect usando dir[br]print(dir(bisect))[br]'''[br]['__doc__', '__file__', '__name__', '__package__', 'bisect', 'bisect_left', [br]'bisect_right', 'insort', 'insort_left', 'insort_right'][br]'''[br]#Importar el módulo copy[br]import copy[br]#Imprimiendo todas las funciones en el módulo copy usando dir[br]print(dir(copy))[br]'''[br]['Error', '_EmptyClass', '__doc__', '__file__', '__name__', '__package__', [br]'_copy_inst', '_deepcopy_atomic', '_deepcopy_dict', '_deepcopy_dispatch', [br]'_deepcopy_frozenset', '_deepcopy_inst', '_deepcopy_list', '_deepcopy_set', [br]'_deepcopy_tuple', '_keep_alive', '_reconstruct', 'copy', 'deepcopy', 'error', [br]'long'][br]'''[br]#Importar el módulo numbers[br]import numbers[br]#Imprimiendo todas las funciones en el módulo numbers usando dir[br]print(dir(numbers))[br]'''[br]['Complex', 'Integral', 'Number', '__doc__', '__file__', [br]'__name__', '__package__'][br]'''[br]#Importar el módulo textwrap[br]import textwrap[br]#Imprimiendo todas las funciones en el módulo textwrap usando dir[br]print(dir(textwrap))[br]'''[br]['TextWrapper', '__all__', '__doc__', '__file__', '__name__', '__package__', [br]'_whitespace', 'dedent', 'fill', 'indent', 're', 'shorten', 'string', 'wrap'][br]'''[br]#Importar el módulo types[br]import types[br]#Imprimiendo todas las funciones en el módulo types usando dir[br]print(dir(types))[br]'''[br]['BooleanType', 'BufferType', 'BuiltinFunctionType', 'BuiltinMethodType', [br]'ClassMethodDescriptorType', 'ClassType', 'ComplexType', 'DictType', [br]'DictionaryType', 'FileType', 'FloatType', 'FunctionType', 'GeneratorType', [br]'InstanceType', 'IntType', 'LambdaType', 'ListType', 'MappingProxyType', [br]'MethodDescriptorType', 'MethodType', 'MethodWrapperType', 'ModuleType', [br]'NoneType', 'NotImplementedType', 'ObjectType', 'SliceType', 'StringType', [br]'StringTypes', 'TupleType', 'TypeType', 'UnboundMethodType', [br]'WrapperDescriptorType', '__all__', '__doc__', '__file__', '__name__', [br]'__package__'][br]'''[br]