30 Proyectos de Python Geniales, Fáciles y Divertidos + Código Fuente [2023]
Hemos cubierto 30 proyectos divertidos de Python para darte práctica práctica de codificación, desde hacer un chatbot de IA hasta un conversor de moneda.
Independientemente de tu nivel de habilidad actual, aprender a construir proyectos en Python es una manera infalible de mejorar tus habilidades y mejorar tu portafolio. ¡Nada supera ensuciarse las manos con algo de programación real y construir proyectos en Python!
Además, convertirse en un maestro en Python en 2023 puede abrir muchas puertas en tu carrera, permitiéndote acceder a algunas de las mejores oportunidades laborales del planeta, sin mencionar los atractivos salarios superiores a $100,000 al año.
En este artículo, hemos incluido 30 interesantes proyectos en Python, que van desde proyectos simples para principiantes hasta proyectos intermedios y avanzados, que puedes utilizar para desafiarte a ti mismo o mejorar tus habilidades de programación en Python.
Además, si estás buscando un poco de ayuda adicional, acabamos de lanzar nuestro propio curso, Python con el Dr. Johns, donde adoptamos un enfoque académico para enseñar y al mismo tiempo construimos proyectos en Python dignos de tu portafolio.
¿Qué debería construir usando Python?
Esta es una gran pregunta, especialmente si eres completamente nuevo en la programación en Python.
Bueno, primero y principal, debes saber que hay tantas aplicaciones en Python en varias disciplinas, por lo que tienes muchas opciones.
Por supuesto, Python se ha ganado una sólida reputación en ciencia de datos, análisis de datos, aprendizaje automático e inteligencia artificial, pero no se limita a eso.
También es genial en desarrollo web, gracias a populares marcos de aplicaciones web como Django y Flask.
Asimismo, también es ideal para automatizar tareas repetitivas, de ahí su origen como lenguaje de script.
En pocas palabras, puedes construir muchas cosas con Python, pero si estás buscando inspiración, ¡estás en el lugar correcto!
He reunido 30 proyectos en Python para que te sumerjas, desde principiantes hasta avanzados.
¡Así que pongámonos manos a la obra!
Proyectos en Python para principiantes
Empecemos con una variedad de proyectos para principiantes, que es ideal si estás empezando y quieres aprender Python. Dicho esto, si estás ansioso por meterte en algo un poco más desafiante, baja para ver proyectos más avanzados.
1. Generador de Mad Libs
Este es uno de los proyectos más divertidos para principiantes en Python, sin mencionar que te permite practicar cómo utilizar cadenas, variables y concatenación, que son habilidades esenciales para todas las aplicaciones en Python en todos los niveles de habilidad.
El Generador de Mad Libs recopila y manipula datos de entrada del usuario, como un adjetivo, un pronombre y un verbo. El programa toma estos datos y los organiza para construir una historia.
Código fuente:
'''Generador de Mad Libs-------------------------------------------------------------'''# Preguntas para que el usuario responda
noun = input('Elige un sustantivo: ')
p_noun = input('Elige un sustantivo en plural: ')
noun2 = input('Elige un sustantivo: ')
place = input('Di un lugar: ')
adjective = input('Elige un adjetivo (Palabra descriptiva): ')
noun3 = input('Elige un sustantivo: ')
# Imprime una historia a partir de la entrada del usuario
print('------------------------------------------')
print('Sé amable con tu', noun, '- pisado', p_noun)
print('Porque un pato puede ser el', noun2, 'de alguien,')
print('Sé amable con tus', p_noun, 'en', place)
print('Donde el clima es siempre', adjective, '. \n')
print('Puedes pensar que esto es el', noun3, ',')
print('Bueno, lo es.')
print('------------------------------------------')2. Adivinar el número
Este proyecto en Python para principiantes es un juego divertido que genera un número aleatorio (en un rango determinado) que el usuario debe adivinar después de recibir pistas. Por cada intento incorrecto que haga el usuario, recibirá pistas adicionales pero a costa de reducir su puntuación final.
Este programa es una excelente manera de experimentar con la biblioteca estándar de Python, ya que utiliza el módulo de Python llamado random para generar números aleatorios. También puedes practicar con declaraciones condicionales, formato de impresión, funciones definidas por el usuario y varios operadores de Python.
Código Fuente:
'''Juego de Adivinar el Número-------------------------------------------------------------'''import randomlista_de_intentos = []def mostrar_puntuacion(): if not lista_de_intentos: print('Actualmente no hay una puntuación alta,' ' ¡es tuya para tomarla!') else: print(f'La puntuación alta actual es' f' de {min(lista_de_intentos)} intentos')def comenzar_juego(): intentos = 0 numero_aleatorio = random.randint(1, 10) print('¡Hola viajero! ¡Bienvenido al juego de adivinanzas!') nombre_jugador = input('¿Cuál es tu nombre? ') jugar = input( f'Hola, {nombre_jugador}, ¿te gustaría jugar ' f'al juego de adivinar? (Escribe Si/No): ') if jugar.lower() != 'si': print('¡Está bien, gracias!') exit() else: mostrar_puntuacion() while jugar.lower() == 'si': try: adivinanza = int(input('Elige un número entre 1 y 10: ')) if adivinanza < 1 or adivinanza > 10: raise ValueError( 'Por favor, adivina un número dentro del rango dado') intentos += 1 lista_de_intentos.append(intentos) if adivinanza == numero_aleatorio: print('¡Genial! ¡Lo lograste!') print(f'Te tomó {intentos} intentos') jugar = input( '¿Te gustaría jugar de nuevo? (Escribe Si/No): ') if jugar.lower() != 'si': print('¡Está bien, que tengas un buen día!') break else: intentos = 0 numero_aleatorio = random.randint(1, 10) mostrar_puntuacion() continue else: if adivinanza > numero_aleatorio: print('Es menor') elif adivinanza < numero_aleatorio: print('Es mayor') except ValueError as err: print('¡Oh no!, ese no es un valor válido. Intenta de nuevo...') print(err)if __name__ == '__main__': comenzar_juego()3. Piedra, Papel o Tijeras
Este programa de Piedra, Papel o Tijeras simula el juego popular universal con funciones y declaraciones condicionales. Entonces, ¿qué mejor manera de adquirir estos conceptos críticos? También estarás usando la lista de Python para almacenar una colección de respuestas válidas, que luego podrás usar para crear una declaración condicional elegante y propia de Python.
Como uno de los muchos proyectos de programación en Python que importa bibliotecas adicionales, este programa utiliza los módulos estándar de la biblioteca random, os y re.
Echa un vistazo al código a continuación, y verás que esta idea de proyecto en Python le pide al usuario que haga el primer movimiento pasando un carácter para representar piedra, papel o tijeras. Después de evaluar la cadena de entrada, la lógica condicional verifica quién gana.
Código Fuente:
'''Piedra, Papel o Tijeras-------------------------------------------------------------'''import randomimport osimport refuncion verificar_estado_del_juego(): respuestas_validas = ['si', 'no'] while True: try: respuesta = input('¿Quieres jugar de nuevo? (Si o No): ') if respuesta.lower() not in respuestas_validas: raise ValueError('Solo Si o No') if respuesta.lower() == 'si': return True else: os.system('cls' if os.name == 'nt' else 'clear') print('¡Gracias por jugar!') exit() except ValueError as err: print(err)def jugar_ppt(): jugar = True while jugar: os.system('cls' if os.name == 'nt' else 'clear') print('') print('Piedra, Papel, Tijeras - ¡Dispara!') eleccion_usuario = input('Elige tu arma' ' [P]iedra], [P]apel, o [T]ijeras: ') if not re.match("[PpTt]", eleccion_usuario): print('Por favor elige una letra:') print('[P]iedra, [P]apel o [T]ijeras') continue print(f'Elegiste: {eleccion_usuario}') elecciones = ['P', 'P', 'T'] eleccion_oponente = random.choice(elecciones) print(f'Elegí: {eleccion_oponente}') if eleccion_oponente == eleccion_usuario.upper(): print('¡Empate!') jugar = verificar_estado_del_juego() elif eleccion_oponente == 'P' and eleccion_usuario.upper() == 'T': print('La piedra vence a las tijeras, ¡Yo gano!') jugar = verificar_estado_del_juego() elif eleccion_oponente == 'T' and eleccion_usuario.upper() == 'P': print('Las tijeras vencen al papel, ¡Yo gano!') jugar = verificar_estado_del_juego() elif eleccion_oponente == 'P' and eleccion_usuario.upper() == 'R': print('El papel vence a la piedra, ¡Yo gano!') jugar = verificar_estado_del_juego() else: print('¡Tú ganas!\n') jugar = verificar_estado_del_juego()if __name__ == '__main__': jugar_ppt()4. Generador de lanzamientos de dados
Como uno de los proyectos de Python más relacionables para principiantes con código, este programa simula lanzar uno o dos dados. También es una excelente manera de consolidar tu comprensión de las funciones definidas por el usuario, bucles y declaraciones condicionales. Estas son habilidades fundamentales para principiantes en Python y es probable que sean algunas de las primeras cosas que aprenderías, ya sea en un curso en línea o en un libro de Python.
Como uno de nuestros proyectos sencillos de Python, es un programa bastante simple que utiliza el módulo aleatorio de Python para replicar la naturaleza aleatoria de lanzar dados. También notarás que usamos el módulo os para borrar la pantalla después de que hayas lanzado los dados.
Ten en cuenta que puedes cambiar el valor máximo del dado a cualquier número, lo que te permite simular dados poliédricos que se usan con frecuencia en muchos juegos de mesa y de rol.
Código fuente:
'''Generador de lanzamientos de dados-------------------------------------------------------------'''import randomimport osdef num_die(): while True: try: num_dice = input('Número de dados: ') valid_responses = ['1', 'one', 'two', '2'] if num_dice not in valid_responses: raise ValueError('Solo 1 o 2') else: return num_dice except ValueError as err: print(err)def roll_dice(): min_val = 1 max_val = 6 roll_again = 's' while roll_again.lower() == 's' or roll_again.lower() == 'si': os.system('cls' if os.name == 'nt' else 'clear') amount = num_die() if amount == '2' or amount == 'two': print('Lanzando los dados...') dice_1 = random.randint(min_val, max_val) dice_2 = random.randint(min_val, max_val) print('Los valores son:') print('Dado Uno: ', dice_1) print('Dado Dos: ', dice_2) print('Total: ', dice_1 + dice_2) roll_again = input('¿Lanzar de nuevo? ') else: print('Lanzando el dado...') dice_1 = random.randint(min_val, max_val) print(f'El valor es: {dice_1}') roll_again = input('¿Lanzar de nuevo? ')if __name__ == '__main__': roll_dice()5. Juego del Ahorcado
Esta es una idea de proyecto Python divertida para imitar el juego de adivinanzas de palabras, el Ahorcado. Hemos utilizado una lista predefinida de palabras para la parte de la adivinanza, pero siéntete libre de mejorar esto usando una API de diccionario de terceros.
Este proyecto de Python utiliza bucles, funciones y formato de cadena para imprimir el progreso del ahorcado. También te permite experimentar con los módulos random, time y os de la biblioteca estándar.
En concreto, hemos utilizado el módulo random para seleccionar la palabra a adivinar, el módulo os para borrar la pantalla y la función .sleep() del módulo time para introducir pausas y mejorar el flujo del juego.
Si estás tomando actualmente un curso de Python y eres nuevo en el lenguaje, este es un proyecto de tamaño mediano ideal para desafiarte a ti mismo.
Código fuente:
'''Juego del Ahorcado-------------------------------------------------------------'''import randomimport timeimport osdef jugar_nuevamente(): pregunta = '¿Quieres jugar de nuevo? s = sí, n = no \n' jugar = input(pregunta) while jugar.lower() not in ['s', 'n']: jugar = input(pregunta) if jugar.lower() == 's': return True else: return Falsedef ahorcado(palabra): display = '_' * len(palabra) count = 0 limite = 5 letras = list(palabra) adivinadas = [] while count < limite: adivina = input(f'Palabra Ahorcada: {display} Ingresa tu respuesta: \n').strip() while len(adivina) == 0 or len(adivina) > 1: print('Entrada inválida. Ingresa una sola letra\n') adivina = input( f'Palabra Ahorcada: {display} Ingresa tu respuesta: \n').strip() if adivina in adivinadas: print('¡Ups! Ya intentaste esa respuesta, ¡inténtalo de nuevo!\n') continue if adivina in letras: letras.remove(adivina) índice = palabra.find(adivina) display = display[:índice] + adivina + display[índice + 1:] else: adivinadas.append(adivina) count += 1 if count == 1: time.sleep(1) print(' _____ \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Respuesta incorrecta: te quedan {limite - count} intentos\n') elif count == 2: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Respuesta incorrecta: te quedan {limite - count} intentos\n') elif count == 3: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Respuesta incorrecta: te quedan {limite - count} intentos\n') elif count == 4: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | \n' ' | \n' '__|__\n') print(f'Respuesta incorrecta: te quedan {limite - count} intentos\n') elif count == 5: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | /|\ \n' ' | / \ \n' '__|__\n') print('Respuesta incorrecta. ¡Has sido ahorcado!!!\n') print(f'La palabra era: {palabra}') if display == palabra: print(f'¡Felicidades! ¡Has adivinado la palabra \'{palabra}\' correctamente!') breakdef jugar_ahorcado(): print('\nBienvenido/a al Ahorcado\n') nombre = input('Ingresa tu nombre: ') print(f'¡Hola {nombre}! ¡Buena suerte!') time.sleep(1) print('¡El juego está por comenzar!\n¡Juguemos al Ahorcado!') time.sleep(1) os.system('cls' if os.name == 'nt' else 'clear') palabras_a_adivinar = [ 'enero', 'frontera', 'imagen', 'película', 'promesa', 'niños', 'pulmones', 'muñeca', 'rima', 'daño', 'plantas', 'hola', 'mundo' ] jugar = True while jugar: palabra = random.choice(palabras_a_adivinar) ahorcado(palabra) jugar = jugar_nuevamente() print('¡Gracias por jugar! ¡Esperamos verte de nuevo!') exit()if __name__ == '__main__': jugar_ahorcado()6. Comprobador de fortaleza de contraseñas
Si te interesa aprender cómo crear una aplicación, este proyecto de Python podría ser una excelente adición, ya que te permite verificar si tu contraseña es lo suficientemente fuerte.
Para esto, el proyecto verifica la cantidad de letras, números, caracteres especiales y espacios en blanco en una contraseña dada, y genera una puntuación en función de estos resultados. Es otra excelente manera de aprender sobre declaraciones condicionales, funciones y formato de cadenas.
También utilizamos los módulos de cadena y getpass de la biblioteca estándar de Python. Esto nos permite acceder a la gama completa de caracteres de cadena para comparar con la composición de caracteres de nuestra contraseña, mientras que la función .getpass() nos permite ocultar nuestra contraseña cuando la ingresamos.
Código fuente:
'''Comprobador de fortaleza de contraseñas-------------------------------------------------------------'''import stringimport getpassdef check_password_strength(): password = getpass.getpass('Ingrese la contraseña: ') strength = 0 remarks = '' lower_count = upper_count = num_count = wspace_count = special_count = 0 for char in list(password): if char in string.ascii_lowercase: lower_count += 1 elif char in string.ascii_uppercase: upper_count += 1 elif char in string.digits: num_count += 1 elif char == ' ': wspace_count += 1 else: special_count += 1 if lower_count >= 1: strength += 1 if upper_count >= 1: strength += 1 if num_count >= 1: strength += 1 if wspace_count >= 1: strength += 1 if special_count >= 1: strength += 1 if strength == 1: remarks = ('Esa es una contraseña muy mala.' ' Cambiala lo antes posible.') elif strength == 2: remarks = ('Esa es una contraseña débil.' ' Deberías considerar usar una contraseña más fuerte.') elif strength == 3: remarks = 'Tu contraseña está bien, pero se puede mejorar.' elif strength == 4: remarks = ('Tu contraseña es difícil de adivinar.' ' Pero podrías hacerla aún más segura.') elif strength == 5: remarks = ('¡Esa es una contraseña realmente fuerte!' ' ¡Los hackers no tienen la menor oportunidad de adivinar esa contraseña!') print('Tu contraseña tiene:-') print(f'{lower_count} letras minúsculas') print(f'{upper_count} letras mayúsculas') print(f'{num_count} números') print(f'{wspace_count} espacios en blanco') print(f'{special_count} caracteres especiales') print(f'Puntuación de la contraseña: {strength / 5}') print(f'Observaciones: {remarks}')def check_pwd(another_pw=False): valid = False if another_pw: choice = input( '¿Quieres verificar la fortaleza de otra contraseña (s/n) : ') else: choice = input( '¿Quieres verificar la fortaleza de tu contraseña (s/n) : ') while not valid: if choice.lower() == 's': return True elif choice.lower() == 'n': print('Saliendo...') return False else: print('Entrada inválida...por favor intenta de nuevo. \n')if __name__ == '__main__': print('===== Bienvenido al Comprobador de Fortaleza de Contraseñas =====') check_pw = check_pwd() while check_pw: check_password_strength() check_pw = check_pwd(True)7. Número a Palabras
Esta idea de proyecto en Python convierte un número entero proporcionado a través de la entrada del usuario a su equivalente en palabras. Este programa está configurado para manejar números con un máximo de 12 dígitos, pero siéntete libre de modificar el programa para manejar números más grandes (pista: requiere declaraciones condicionales y bucles).
Como un ejemplo fácil de entender de proyectos básicos de Python, este programa simple pero efectivo puede expandir tus habilidades con bucles, entrada de usuario y declaraciones condicionales, además de las tuplas y listas en Python.
También podrás experimentar con algunas operaciones matemáticas que tal vez sean nuevas para ti, como el operador módulo (%) para obtener el resto de la división entera.
Si alguna de estas técnicas es nueva para ti, es posible que desees considerar instalar un asistente de codificación de IA en tu IDE de Python para recibir ayuda con cualquier bloque de código que te resulte difícil de entender.
Código fuente:
'''Números a Palabras-----------------------------------------------------------'''ones = ( 'Cero', 'Uno', 'Dos', 'Tres', 'Cuatro', 'Cinco', 'Seis', 'Siete', 'Ocho', 'Nueve' )twos = ( 'Diez', 'Once', 'Doce', 'Trece', 'Catorce', 'Quince', 'Dieciséis', 'Diecisiete', 'Dieciocho', 'Diecinueve' )tens = ( 'Veinte', 'Treinta', 'Cuarenta', 'Cincuenta', 'Sesenta', 'Setenta', 'Ochenta', 'Noventa', 'Cien' )suffixes = ( '', 'Mil', 'Millón', 'Mil Millones' )def fetch_words(number, index): if number == '0': return 'Cero' number = number.zfill(3) hundreds_digit = int(number[0]) tens_digit = int(number[1]) ones_digit = int(number[2]) words = '' if number[0] == '0' else ones[hundreds_digit] if words != '': words += ' Ciento ' if tens_digit > 1: words += tens[tens_digit - 2] words += ' ' words += ones[ones_digit] elif(tens_digit == 1): words += twos[((tens_digit + ones_digit) % 10) - 1] elif(tens_digit == 0): words += ones[ones_digit] if(words.endswith('Cero')): words = words[:-len('Cero')] else: words += ' ' if len(words) != 0: words += suffixes[index] return wordsdef convert_to_words(number): length = len(str(number)) if length > 12: return 'Este programa soporta un máximo de números de 12 dígitos.' count = length // 3 if length % 3 == 0 else length // 3 + 1 copy = count words = [] for i in range(length - 1, -1, -3): words.append(fetch_words( str(number)[0 if i - 2 < 0 else i - 2 : i + 1], copy - count)) count -= 1 final_words = '' for s in reversed(words): final_words += (s + ' ') return final_wordsif __name__ == '__main__': number = int(input('Ingresa cualquier número: ')) print('%d en palabras es: %s' %(number, convert_to_words(number)))8. Juego de Tic-Tac-Toe
Tic-Tac-Toe es un clásico juego de dos jugadores que implica una cuadrícula de nueve cuadrados. Cada jugador marca alternadamente su espacio con una O o una X, y el jugador que logre marcar tres Os o Xs en diagonal, horizontal o verticalmente gana. Cada jugador también debe bloquear a su oponente mientras intenta formar su cadena.
Este es un proyecto de Python realmente divertido y único para principiantes, ya que utiliza la programación orientada a objetos.
Este es uno de los conceptos más esenciales de Python que aprenderás, y en este proyecto, crearás una nueva clase llamada TicTacToe. Luego usaremos esto para representar las características del juego a través de los atributos y métodos de la clase.
Estudia cuidadosamente estos métodos para ver cómo podemos usar la programación orientada a objetos para empaquetar de manera ordenada los diversos comportamientos necesarios para simular este juego.
Algunos aspectos nuevos de esta idea de proyecto en Python para principiantes incluyen bucles anidados para verificar las columnas, filas y diagonales de la cuadrícula en busca de un estado ganador, junto con el tipo de datos de conjunto de Python, que se utiliza para contener valores únicos. Este programa también utiliza el módulo aleatorio de Python para seleccionar un jugador al azar para comenzar el juego, pero esto es más familiar para ti ahora.
Código Fuente:
'''Tic Tac Toe-------------------------------------------------------------'''import randomclass TicTacToe: def __init__(self): self.board = [] def create_board(self): for i in range(3): row = [] for j in range(3): row.append('-') self.board.append(row) def get_random_first_player(self): return random.randint(0, 1) def fix_spot(self, row, col, player): self.board[row][col] = player def has_player_won(self, player): n = len(self.board) board_values = set() # check rows for i in range(n): for j in range(n): board_values.add(self.board[i][j]) if board_values == {player}: return True else: board_values.clear() # check cols for i in range(n): for j in range(n): board_values.add(self.board[j][i]) if board_values == {player}: return True else: board_values.clear() # check diagonals for i in range(n): board_values.add(self.board[i][i]) if board_values == {player}: return True else: board_values.clear() board_values.add(self.board[0][2]) board_values.add(self.board[1][1]) board_values.add(self.board[2][0]) if board_values == {player}: return True else: return False def is_board_filled(self): for row in self.board: for item in row: if item == '-': return False return True def swap_player_turn(self, player): return 'X' if player == 'O' else 'O' def show_board(self): for row in self.board: for item in row: print(item, end=' ') print() def start(self): self.create_board() player = 'X' if self.get_random_first_player() == 1 else 'O' game_over = False while not game_over: try: self.show_board() print(f'\nTurno del Jugador {player}') row, col = list( map(int, input( 'Ingresa los números de fila y columna para fijar el lugar: ').split())) print() if col is None: raise ValueError( 'no hay suficientes valores para desempaquetar (se esperaban 2, se obtuvo 1)') self.fix_spot(row - 1, col - 1, player) game_over = self.has_player_won(player) if game_over: print(f'¡El Jugador {player} gana el juego!') continue game_over = self.is_board_filled() if game_over: print('¡Empate!') continue player = self.swap_player_turn(player) except ValueError as err: print(err) print() self.show_board()if __name__ == '__main__': tic_tac_toe = TicTacToe() tic_tac_toe.start()9. Calculadora
Otro de nuestros proyectos sencillos de Python, este programa crea una aplicación básica de calculadora con funciones de suma, resta, multiplicación y división.
Este es uno de los proyectos de práctica de Python que son ideales para aprender a utilizar bucles, funciones, declaraciones condicionales, entrada de usuario y formato de cadenas. También hemos utilizado el módulo os de Python para limpiar la pantalla después de que el usuario complete sus acciones de cálculo.
Una vez que tengas los conceptos dominados con este proyecto, considera formas de ampliar las características para incluir la potenciación u otros cálculos más complicados.
Si estás utilizando un asistente de codificación de IA como GitHub Copilot o Amazon CodeWhisperer, también puedes experimentar con esto para agregar nuevas características. ¡Pero intenta hacerlo tú mismo primero!
Código de ejemplo:
'''Calculadora-------------------------------------------------------------'''import osdef suma(): os.system('cls' if os.name == 'nt' else 'clear') print('Suma') continuar_calc = 's' num_1 = float(input('Ingresa un número: ')) num_2 = float(input('Ingresa otro número: ')) ans = num_1 + num_2 valores_ingresados = 2 print(f'Resultado actual: {ans}') while continuar_calc.lower() == 's': continuar_calc = (input('Ingrese más (s/n): ')) while continuar_calc.lower() not in ['s', 'n']: print('Por favor ingrese \'s\' o \'n\'') continuar_calc = (input('Ingrese más (s/n): ')) if continuar_calc.lower() == 'n': break num = float(input('Ingresa otro número: ')) ans += num print(f'Resultado actual: {ans}') valores_ingresados += 1 return [ans, valores_ingresados]def resta(): os.system('cls' if os.name == 'nt' else 'clear') print('Resta') continuar_calc = 's' num_1 = float(input('Ingresa un número: ')) num_2 = float(input('Ingresa otro número: ')) ans = num_1 - num_2 valores_ingresados = 2 print(f'Resultado actual: {ans}') while continuar_calc.lower() == 's': continuar_calc = (input('Ingrese más (s/n): ')) while continuar_calc.lower() not in ['s', 'n']: print('Por favor ingrese \'s\' o \'n\'') continuar_calc = (input('Ingrese más (s/n): ')) if continuar_calc.lower() == 'n': break num = float(input('Ingresa otro número: ')) ans -= num print(f'Resultado actual: {ans}') valores_ingresados += 1 return [ans, valores_ingresados]def multiplicacion(): os.system('cls' if os.name == 'nt' else 'clear') print('Multiplicación') continuar_calc = 's' num_1 = float(input('Ingresa un número: ')) num_2 = float(input('Ingresa otro número: ')) ans = num_1 * num_2 valores_ingresados = 2 print(f'Resultado actual: {ans}') while continuar_calc.lower() == 's': continuar_calc = (input('Ingrese más (s/n): ')) while continuar_calc.lower() not in ['s', 'n']: print('Por favor ingrese \'s\' o \'n\'') continuar_calc = (input('Ingrese más (s/n): ')) if continuar_calc.lower() == 'n': break num = float(input('Ingresa otro número: ')) ans *= num print(f'Resultado actual: {ans}') valores_ingresados += 1 return [ans, valores_ingresados]def division(): os.system('cls' if os.name == 'nt' else 'clear') print('División') continuar_calc = 's' num_1 = float(input('Ingresa un número: ')) num_2 = float(input('Ingresa otro número: ')) while num_2 == 0.0: print('Por favor ingresa un segundo número > 0') num_2 = float(input('Ingresa otro número: ')) ans = num_1 / num_2 valores_ingresados = 2 print(f'Resultado actual: {ans}') while continuar_calc.lower() == 's': continuar_calc = (input('Ingrese más (s/n): ')) while continuar_calc.lower() not in ['s', 'n']: print('Por favor ingrese \'s\' o \'n\'') continuar_calc = (input('Ingrese más (s/n): ')) if continuar_calc.lower() == 'n': break num = float(input('Ingresa otro número: ')) while num == 0.0: print('Por favor ingrese un número > 0') num = float(input('Ingresa otro número: ')) ans /= num print(f'Resultado actual: {ans}') valores_ingresados += 1 return [ans, valores_ingresados]def calculadora(): salir = False while not salir: resultados = [] print('¡Calculadora simple en Python!') print('Ingresa \'a\' para suma') print('Ingresa \'r\' para resta') print('Ingresa \'m\' para multiplicación') print('Ingresa \'d\' para división') print('Ingresa \'q\' para salir') eleccion = input('Selección: ') if eleccion == 'q': salir = True continue if eleccion == 'a': resultados = suma() print('Ans = ', resultados[0], ' total de entradas: ', resultados[1]) elif eleccion == 'r': resultados = resta() print('Ans = ', resultados[0], ' total de entradas: ', resultados[1]) elif eleccion == 'm': resultados = multiplicacion() print('Ans = ', resultados[0], ' total de entradas: ', resultados[1]) elif eleccion == 'd': resultados = division() print('Ans = ', resultados[0], ' total de entradas: ', resultados[1]) else: print('Lo siento, caracter inválido')if __name__ == '__main__': calculadora()10. Reloj de cuenta regresiva y temporizador
¡Esta idea de proyecto de Python es divertida! Aquí, hemos creado un temporizador de cuenta regresiva que solicita al usuario un número de segundos a través de la entrada del usuario, y luego cuenta atrás, segundo a segundo, hasta que muestra un mensaje.
Hemos utilizado la función .sleep() del módulo de tiempo de Python para hacer pausas en intervalos de 1 segundo. Combinamos esto con un formato de cadena ingenioso para producir la visualización de cuenta regresiva.
Código Fuente:
'''Countdown Timer-------------------------------------------------------------'''import timedef countdown(user_time): while user_time >= 0: mins, secs = divmod(user_time, 60) timer = '{:02d}:{:02d}'.format(mins, secs) print(timer, end='\r') time.sleep(1) user_time -= 1 print('¡Despegue!')if __name__ == '__main__': user_time = int(input("Ingrese un tiempo en segundos: ")) countdown(user_time)Proyectos intermedios de Python con código fuente
11. Algoritmo de búsqueda binaria
¡Es un rito de paso para todos los aspirantes a programadores abordar la Búsqueda Binaria en uno de sus proyectos de programación en Python en algún momento! Sé que cuando estaba comenzando, algunos de mis errores más comunes en Python involucraban algoritmos clásicos como este.
Este proyecto de Python para búsqueda binaria toma una lista ordenada (array) y luego compara continuamente un valor de búsqueda con el valor central del array.
Dependiendo de si el valor de búsqueda es menor o mayor que el valor central, la lista se divide (estrategia de dividir y conquistar) para reducir el espacio de búsqueda, lo que se centra en el valor de búsqueda dado. Esta división continua resulta en una complejidad de tiempo logarítmica.
Si observas el código a continuación, verás que hemos implementado dos soluciones: bucles condicionales y recursión. Ambos enfoques son elegantes, así que siéntete libre de experimentar con cada uno.
Si eres nuevo en la recursión, esta es una gran introducción, ya que demuestra cómo “reducimos” el tamaño del problema con cada llamada recursiva, es decir, dividiendo la lista en un lado del elemento medio actual.
También hemos definido el caso base recursivo como el punto en el que el elemento medio es igual al elemento de búsqueda. En este caso, la recursión se detendrá y devolverá el valor True a través de la pila de llamadas.
Si todo esto te suena ajeno, considera usar algo como GitHub Copilot para entender mejor este algoritmo clásico.
Código Fuente:
'''Búsqueda Binaria-------------------------------------------------------------'''def binary_search(a_list, an_item): first = 0 last = len(a_list) - 1 while first <= last: mid_point = (first + last) // 2 if a_list[mid_point] == an_item: return True else: if an_item < a_list[mid_point]: last = mid_point - 1 else: first = mid_point + 1 return Falsedef binary_search_rec(a_list, first, last, an_item): if len(a_list) == 0: return False else: mid_point = (first + last) // 2 if a_list[mid_point] == an_item: return True else: if an_item < a_list[mid_point]: last = mid_point - 1 return binary_search_rec(a_list, first, last, an_item) else: first = mid_point + 1 return binary_search_rec(a_list, first, last, an_item)if __name__ == '__main__': a_list = [1, 4, 7, 10, 14, 19, 102, 2575, 10000] print('Búsqueda Binaria:', binary_search(a_list, 4)) print('Búsqueda Binaria Recursiva:', binary_search_rec(a_list, 0, len(a_list) -1, 4))12. Algoritmo de Ordenamiento por Mezcla
El Ordenamiento por Mezcla es otro desafío de programación popular al que se enfrentan los aspirantes a programadores cuando buscan cosas que hacer en Python.
Esta estrategia de dividir y conquistar utiliza la división para separar una lista de números en partes iguales y luego se ordenan recursivamente antes de volver a combinarse para generar una lista ordenada.
Si acabas de terminar el ejemplo de Búsqueda Binaria, es posible que notes algunas similitudes con la división y la reducción del tamaño de un problema. Y tendrías razón, lo que significa que probablemente te has dado cuenta de que necesitamos usar la recursión.
Esta implementación de Merge Sort en Python utiliza recursión para manejar el proceso de divide y conquista. La reducción continua del tamaño del problema permite que el problema se resuelva cuando se alcanza el caso base recursivo, es decir, cuando el tamaño del problema es de un elemento o menos.
En esencia, este programa en Python continúa dividiendo recursivamente la lista hasta que alcanza el caso base. En este punto, comienza a ordenar las partes más pequeñas del problema, lo que resulta en matrices ordenadas más pequeñas que se combinan nuevamente para generar finalmente una matriz completamente ordenada. Si estás familiarizado con la notación Big O, te interesará saber que Merge Sort tiene un Big O de (n logn).
Código fuente:
'''Merge Sort-------------------------------------------------------------'''def merge_sort(a_list): print("Dividiendo ", a_list) if len(a_list) > 1: mitad = len(a_list)//2 mitad_izq = a_list[:mitad] mitad_der = a_list[mitad:] merge_sort(mitad_izq) merge_sort(mitad_der) i=0 j=0 k=0 while i < len(mitad_izq) and j < len(mitad_der): if mitad_izq[i] <= mitad_der[j]: a_list[k] = mitad_izq[i] i += 1 else: a_list[k] = mitad_der[j] j += 1 k += 1 while i < len(mitad_izq): a_list[k] = mitad_izq[i] i += 1 k += 1 while j < len(mitad_der): a_list[k] = mitad_der[j] j += 1 k += 1 print("Combinando ", a_list)if __name__ == '__main__': a_list = [45, 7, 85, 24, 60, 25, 38, 63, 1] merge_sort(a_list) print(a_list)13. Generador de Contraseñas
Este es un interesante proyecto en Python que utiliza los módulos secrets y string para generar una contraseña fuerte y segura, similar a lo que puedes hacer con gestores de contraseñas populares.
El módulo string obtiene todas las letras, dígitos y caracteres especiales posibles, mientras que el módulo secrets nos permite obtener contraseñas criptográficamente seguras.
El código de este proyecto es relativamente sencillo, ya que utiliza un bucle para generar continuamente contraseñas hasta que contengan al menos un carácter especial y dos dígitos. ¡Por supuesto, puedes modificar esto para que se ajuste a tus propias reglas de contraseña súper fuerte!
Código fuente:
'''Generador de Contraseñas-------------------------------------------------------------'''import secretsimport stringdef crear_contraseña(longitud_contraseña=12): letras = string.ascii_letters dígitos = string.digits caracteres_especiales = string.punctuation alfabeto = letras + dígitos + caracteres_especiales contraseña = '' contraseña_fuerte = False while not contraseña_fuerte: contraseña = '' for i in range(longitud_contraseña): contraseña += ''.join(secrets.choice(alfabeto)) if (any(char in caracteres_especiales for char in contraseña) and sum(char in dígitos for char in contraseña) >= 2):
contraseña_fuerte = True return contraseñaif __name__ == '__main__': print(crear_contraseña())14. Convertidor de Moneda
Este es uno de varios proyectos de Python que requieren la instalación de una de las bibliotecas de Python más populares, que en este caso es el módulo requests. Este no está incluido en la biblioteca estándar de Python, así que utiliza el comando pip que se muestra en el código fuente para instalarlo en tu sistema.
Con el módulo requests, podemos realizar solicitudes HTTP a la API de Fixer, lo que nos permite convertir una moneda a otra. Probablemente te darás cuenta de que estamos utilizando una API de terceros, por lo que deberás registrarte para obtener una clave de API gratuita. Luego puedes ingresar tu clave de API en el campo que se muestra en el código fuente, ¡y estarás listo para empezar!
Este proyecto te permite practicar más con bucles y entrada de usuario, pero amplía esto con solicitudes HTTP para obtener datos de la API en formato JSON.
Si no estás familiarizado con JSON, es muy similar a un diccionario de Python, lo que significa que podemos acceder a pares clave-valor para obtener los datos que buscamos. En este caso, estamos buscando el resultado de la conversión de moneda de la llamada a la API.
Consulta la documentación del sitio de la API de Fixer para obtener más detalles sobre los diferentes datos que puedes obtener.
Código fuente:
'''Convertidor de monedas-------------------------------------------------------------pip install requests'''import requestsdef convertir_moneda(): moneda_inicial = input('Ingrese una moneda inicial: ') moneda_objetivo = input('Ingrese una moneda objetivo: ') while True: try: cantidad = float(input('Ingrese la cantidad: ')) except: print('¡La cantidad debe ser un valor numérico!') continue if not cantidad > 0: print('La cantidad debe ser mayor que 0') continue else: break url = ('https://api.apilayer.com/fixer/convert?to=' + moneda_objetivo + '&from=' + moneda_inicial + '&amount=' + str(cantidad)) payload = {} headers = {'apikey': 'TU API KEY'} response = requests.request('GET', url, headers=headers, data=payload) codigo_estado = response.status_code if codigo_estado != 200: print('Ups, hubo un problema. Por favor, intente de nuevo más tarde') quit() resultado = response.json() print('Resultado de la conversión: ' + str(resultado['result']))if __name__ == '__main__': convertir_moneda()15. Envío automático de correos de cumpleaños
Este proyecto en Python utiliza los módulos estándar smtplib, EmailMessage y datetime, además de pandas y openpyxl (estos deben ser instalados con pip, como se muestra a continuación), para enviar correos electrónicos de cumpleaños automatizados.
Este programa lee de una hoja de Excel que contiene los detalles de todos tus amigos (ver el formato de la hoja de Excel en el código fuente a continuación). Luego les envía un correo electrónico si hoy es su gran día antes de hacer una nota en tu hoja de cálculo para indicar que han recibido su correo electrónico.
Hemos utilizado los módulos smtplib y EmailMessage para crear una conexión SSL con nuestra cuenta de correo electrónico y el mensaje. Luego hemos utilizado un dataframe de pandas para almacenar datos con formato de hoja de cálculo dentro del programa de Python (una habilidad esencial para los científicos de datos). Por último, hemos utilizado el formato de fecha con la función .strftime() del módulo datetime.
¡Así que hay muchas habilidades nuevas para dominar!
Nota importante: desde mayo de 2022, Google ha restringido el acceso de las “aplicaciones menos seguras” a Gmail. Para utilizar este código con tu cuenta de Gmail, deberás seguir algunos pasos adicionales. Pero no te preocupes, son fáciles de hacer y los hemos enumerado para ti.
- Ve a la página de “gestionar cuenta” de tu cuenta de Google
- Haz clic en Seguridad
- Activa la verificación en dos pasos (utiliza el método que prefieras)
- Haz clic en “Contraseñas de aplicaciones”
- Haz clic en “Seleccionar aplicación” y elige “Correo”
- Haz clic en “Seleccionar dispositivo” y selecciona “Otro (nombre personalizado)”, ingresa “Aplicación de cumpleaños en Python”
- Haz clic en “Generar” y guarda esta contraseña
Ahora puedes utilizar esta contraseña de la aplicación en el código a continuación para acceder a tu cuenta de Gmail sin problemas.
Código fuente:
'''Remitente automático de correos de cumpleaños-------------------------------------------------------------pip install pandas openpyxlexcel archivo columnas: Nombre, Correo electrónico, Cumpleaños (MM/DD/AAAA), Último envío (AAAA)'''import pandas as pdfrom datetime import datetimeimport smtplibfrom email.message import EmailMessagedef enviar_correo(destinatario, asunto, msg): GMAIL_ID = 'tu_correo_aquí' GMAIL_PWD = 'tu_contraseña_aquí' correo = EmailMessage() correo['Subject'] = asunto correo['From'] = GMAIL_ID correo['To'] = destinatario correo.set_content(msg) with smtplib.SMTP_SSL('smtp.gmail.com', 465) as obj_gmail: obj_gmail.ehlo() obj_gmail.login(GMAIL_ID, GMAIL_PWD) obj_gmail.send_message(correo) print('Correo enviado a ' + str(destinatario) + ' con asunto: \'' + str(asunto) + '\' y Mensaje: \'' + str(msg) + '\'')def enviar_correos_cumpleaños(archivo_cumpleaños): df_cumpleaños = pd.read_excel(archivo_cumpleaños) hoy = datetime.now().strftime('%m-%d') año_actual = datetime.now().strftime('%Y') indice_enviados = [] for idx, item in df_cumpleaños.iterrows(): cumpleaños = item['Cumpleaños'].to_pydatetime().strftime('%m-%d') if (hoy == cumpleaños) and año_actual not in str(item['Último envío']): msg = '¡Feliz cumpleaños ' + str(item['Nombre'] + '!!') enviar_correo(item['Correo electrónico'], 'Feliz cumpleaños', msg) indice_enviados.append(idx) for idx in indice_enviados: df_cumpleaños.loc[df_cumpleaños.index[idx], 'Último envío'] = str(año_actual) df_cumpleaños.to_excel(archivo_cumpleaños, index=False)if __name__ == '__main__': enviar_correos_cumpleaños(archivo_cumpleaños='tu_lista_cumpleaños.xlsx')16. Cola
Este proyecto de Python crea una nueva clase para implementar una Cola. Esta es una estructura de datos común en ciencias de la computación cuando se necesita manejar escenarios de Primero en Entrar, Primero en Salir (FIFO), como colas de mensajes, tareas de CPU, etc.
El código es directo y ofrece más práctica con la programación orientada a objetos. Prueba la cola para entender cómo funciona y luego estarás listo para usar esta estructura de datos en tus otros proyectos.
Código fuente:
'''Estructura de datos Cola-------------------------------------------------------------'''class Cola: def __init__(self): self.elementos = [] def __repr__(self): return f'Objeto Cola: datos={self.elementos}' def esta_vacia(self): return not self.elementos def agregar(self, elemento): self.elementos.append(elemento) def eliminar(self): return self.elementos.pop(0) def tamanio(self): return len(self.elementos) def ver_primero(self): return self.elementos[0]if __name__ == '__main__': c = Cola() print(c.esta_vacia()) c.agregar('Primero') c.agregar('Segundo') print(c) print(c.eliminar()) print(c) print(c.tamanio()) print(c.ver_primero())17. Triángulo de Pascal
Este proyecto de Python imprime el Triángulo de Pascal utilizando declaraciones condicionales y bucles. También utiliza el módulo de matemáticas de la biblioteca estándar y la función factorial para evaluar la ecuación “número de combinaciones” utilizada para generar los valores en el triángulo.
Experimenta con el número inicial para el triángulo para examinar cómo se utiliza la ecuación de “combinaciones” para generar los valores sucesivos en el triángulo.
Código fuente:
'''Triángulo de Pascal-------------------------------------------------------------Número de combinaciones a través de "n elegir k" o nCk = n! / [k! * (n-k)!]'''from math import factorialdef triangulo_pascal(n): for i in range(n): for j in range(n-i+1): print(end=' ') for j in range(i+1): print(factorial(i)//(factorial(j)*factorial(i-j)), end=' ') print()if __name__ == '__main__': triangulo_pascal(5)18. Blackjack
Como uno de los proyectos más geniales de Python, esto atraerá a cualquiera que disfrute de los juegos de cartas, ya que emularemos el Blackjack. Este es un juego de cartas muy popular con reglas relativamente simples: lo más importante es que necesitas sumar 21 para ganar, o necesitas tener una puntuación más alta que la del crupier sin pasarte de 21.
Este es el proyecto más grande en la lista hasta ahora. Combina la mayoría de las habilidades que hemos cubierto anteriormente en proyectos anteriores, incluyendo la creación de clases, bucles, declaraciones condicionales, la importación de módulos, la aceptación de entrada del usuario y el formateo de cadenas.
Tómate tu tiempo para trabajar en las diferentes secciones de este código y relacionarlo con los proyectos anteriores para ver cómo funcionan las diferentes técnicas juntas. No hay nada que no hayas visto antes; simplemente se ha empaquetado de manera ligeramente diferente y se ha combinado para crear un emulador de juego completamente funcional.
Y debemos decir, ¡trata de no pasar todo el día jugando con esto! ¡Pero entendemos completamente si lo haces!
Código fuente:
'''Blackjack-------------------------------------------------------------'''import randomimport osclass Carta: def __init__(self, cara_carta, valor, simbolo): self.cara_carta = cara_carta self.valor = valor self.simbolo = simbolodef mostrar_cartas(cartas, ocultas): s = '' for carta in cartas: s = s + '\t ________________' if ocultas: s += '\t ________________' print(s) s = '' for carta in cartas: s = s + '\t| |' if ocultas: s += '\t| |' print(s) s = '' for carta in cartas: if carta.cara_carta in ['J', 'Q', 'K', 'A']: s = s + '\t| {} |'.format(c19. Bot de Reddit
Este proyecto en Python crea un bot automatizado de Reddit con algunos módulos nuevos, especialmente praw y enchant (ver los comandos de instalación de pip).
Es un concepto bastante simple, ya que el programa verifica cada comentario en un subreddit seleccionado y luego responde a cualquier comentario que contenga una "frase desencadenante" predefinida. Para hacer esto, utilizamos el módulo praw para interactuar con Reddit y enchant para generar palabras similares al comentario, lo que nos permite hacer una respuesta adecuada.
Esta idea es realmente útil si estás buscando proyectos en Python para aprender cómo responder preguntas en tu propio subreddit. Solo necesitarías expandir este código para incluir respuestas automáticas para preguntas predefinidas (probablemente ya hayas notado que otros lo están usando en Reddit).
Nota importante: Debes consultar estas instrucciones para obtener un client_id, client_secret, username, password y user_agent. Necesitarás esta información para hacer comentarios en Reddit a través de la interfaz de la API.
Código fuente:
'''Bot de Respuesta en Reddit-------------------------------------------------------------pip install praw pyenchant'''import prawimport enchantdef reddit_bot(sub, trigger_phrase): reddit = praw.Reddit( client_id='tu_client_id', client_secret='tu_client_secret', username='tu_username', password='tu_pw', user_agent='tu_user_agent' ) subreddit = reddit.subreddit(sub) dict_suggest = enchant.Dict('en_US') for comment in subreddit.stream.comments(): if trigger_phrase in comment.body.lower(): word = comment.body.replace(trigger_phrase, '') reply_text = '' similar_words = dict_suggest.suggest(word) for similar in similar_words: reply_text += (similar + ' ') comment.reply(reply_text)if __name__ == '__main__': reddit_bot(sub='Python', trigger_phrase='bot útil')
20. Generador de Fibonacci
Los números de Fibonacci pueden ser algunos de los números más importantes en nuestras vidas, ya que aparecen tan a menudo en la naturaleza.
El código Python que se muestra a continuación genera los números de Fibonacci hasta una cierta longitud utilizando recursión (sí, más recursión!). Para evitar que los tiempos de cálculo se salgan de control, hemos implementado memoización para almacenar en caché los valores a medida que los calculamos.
Observarás que para este algoritmo recursivo, el caso base se establece para verificar si el valor dado de la secuencia de Fibonacci ya está almacenado en la memoria caché. Si es así, devuelve este valor (lo cual es una operación de complejidad temporal constante), lo cual ahorra una cantidad tremenda de tiempo de cálculo.
Código fuente:
'''Secuencia de Fibonacci-------------------------------------------------------------'''fib_cache = {}def fib_memo(input_val): if input_val in fib_cache: return fib_cache[input_val] if input_val == 0: val = 0 elif input_val < 2: val = 1 else: val = fib_memo(input_val - 1) + fib_memo(input_val - 2) fib_cache[input_val] = val return valif __name__ == '__main__': print('======== Serie de Fibonacci ========') for i in range(1, 11): print(f'Fibonacci ({i}) : {fib_memo(i)}')
Ideas avanzadas de proyectos en Python
21. Chatbot
Este proyecto en Python utiliza el módulo chatterbot (ver instrucciones de instalación de pip a continuación) para entrenar un chatbot automatizado que responde a cualquier pregunta que le hagas. ¡Sí, ahora estamos utilizando inteligencia artificial!
Verás que el programa es uno de los proyectos en Python relativamente pequeños de esta lista, pero si deseas aprender más o expandir las características del código, no dudes en explorar la documentación de ChatterBot junto con el campo más amplio de los chatbots de IA.
Si esto despierta tu interés por construir chatbots de IA, echa un vistazo a nuestro curso de chatbot de Python de 24 horas para aprender cómo construir un chatbot alimentado por IA con las mismas herramientas que alimentan al ChatGPT de OpenAI.
Y si tienes más hambre de bondades de IA, echa un vistazo a la última característica de OpenAI que te permite crear tu propio GPT.
Nota importante: ChatterBot ya no se está manteniendo activamente. Esto significa que debes realizar un pequeño cambio en el archivo tagging.py ubicado en el directorio 'Lib/site-packages/chatterbot' de la carpeta de instalación de Python.
```html
No te preocupes; es muy sencillo de hacer, y hemos incluido el código fuente exacto que necesitas usar, como se muestra a continuación.
Código Fuente:
'''Chat Bot-------------------------------------------------------------1) pip install ChatterBot chatterbot-corpus spacy2) python3 -m spacy download en_core_web_sm O... elige el idioma que prefieras3) Navega hasta tu directorio de Python34) Modifica Lib/site-packages/chatterbot/tagging.py para cargar adecuadamente 'en_core_web_sm''''from chatterbot import ChatBotfrom chatterbot.trainers import ChatterBotCorpusTrainerdef create_chat_bot(): chatbot = ChatBot('Chattering Bot') trainer = ChatterBotCorpusTrainer(chatbot) trainer.train('chatterbot.corpus.english') while True: try: bot_input = chatbot.get_response(input()) print(bot_input) except (KeyboardInterrupt, EOFError, SystemExit): breakif __name__ == '__main__': create_chat_bot()
Modifica tagging.py:
Encuentra el primer fragmento de código, que es parte del método __init__ de la clase PosLemmaTagger. Reemplázalo con la declaración if/else.
Nota: este ejemplo es para la biblioteca en inglés que usamos en nuestro ejemplo, pero si lo prefieres, siéntete libre de cambiarlo por otro idioma.
# Reemplaza esto:self.nlp = spacy.load(self.language.ISO_639_1.lower())# Con esto:if self.language.ISO_639_1.lower() == 'en': self.nlp = spacy.load('en_core_web_sm')else: self.nlp = spacy.load(self.language.ISO_639_1.lower())
22. Texto a Voz
Este proyecto de Python utiliza una serie de nuevas bibliotecas para convertir un artículo existente en un archivo mp3 que se puede reproducir. Necesitarás instalar nltk (kit de herramientas de lenguaje natural), newspaper3k y gtts (consulta las instrucciones de pip install).
Verás que el programa es simple, simplemente pasamos una URL de un artículo para convertirlo, y luego dejamos que la función que hemos definido maneje la conversión de texto a voz con nuestros nuevos módulos instalados.
Así que considera la posibilidad de probar esto la próxima vez que quieras convertir un artículo en un podcast reproducible, ¡definitivamente es uno de los códigos Python geniales para copiar!
Código Fuente:
'''Texto a Voz-------------------------------------------------------------pip install nltk newspaper3k gtts'''import nltkfrom newspaper import Articlefrom gtts import gTTSdef text_to_speech(url): article = Article(url) article.download() article.parse() nltk.download('punkt') article.nlp() article_text = article.text language = 'en' my_obj = gTTS(text=article_text, lang=language, slow=False) my_obj.save("read_article.mp3")if __name__ == '__main__': text_to_speech( url='https://hackr.io/blog/top-tech-companies-hiring-python-developers' )
23. Sistema de Gestión de Biblioteca
Como uno de los proyectos de Python más avanzados, este programa utiliza la programación orientada a objetos para simular un sistema de gestión de bibliotecas.
En este ejemplo, creamos una clase Library (Biblioteca) y Student (Estudiante), que podemos usar para crear nuestro sistema bibliotecario y sus usuarios. Luego, hemos implementado una interfaz de usuario sencilla que solicita a los usuarios que elijan entre una variedad de acciones bibliotecarias estándar, como tomar prestados o devolver libros.
Este es un ejemplo simple pero poderoso de cómo puedes construir sistemas del mundo real a través de Python y la programación orientada a objetos. Siéntete libre de ampliar las clases para incluir otras características útiles, como IDs de libros únicos, múltiples copias del mismo libro, fechas de devolución, cargos por devolución tardía de libros o cualquier otra característica que creas que debería tener una biblioteca.
Código Fuente:
'''Library-------------------------------------------------------------'''class Library: def __init__(self, books): self.books = books def show_avail_books(self): print('Nuestra Biblioteca Puede Ofrecerte los Siguientes Libros:') print('================================================') for book, borrower in self.books.items(): if borrower == 'Free': print(book) def lend_book(self, requested_book, name): if self.books[requested_book] == 'Free': print( f'{requested_book} ha sido marcado como' f' \'Prestado\' por: {name}') self.books[requested_book] = name return True else: print( f'Lo siento, el {requested_book} se encuentra' f' actualmente prestado a: {self.books[requested_book]}') return False def return_book(self, returned_book): self.books[returned_book] = 'Free' print(f'Gracias por devolver {returned_book}')class Student: def __init__(self, name, library): self.name = name self.books = [] self.library = library def view_borrowed(self): if not self.books: print('No has prestado ningún libro') else: for book in self.books: print(book) def request_book(self): book = input( 'Ingresa el nombre del libro que te gustaría tomar prestado >> ') if self.library.lend_book(book, self.name): self.books.append(book) def return_book(self): book = input( 'Ingresa el nombre del libro que te gustaría devolver >> ') if book in self.books: self.library.return_book(book) else: print('No has prestado ese libro, intenta con otro...')def create_lib(): books = { 'La Última Batalla': 'Free', 'Los Juegos del Hambre': 'Free', 'Cracking the Coding Interview': 'Free' } library = Library(books) student_example = Student('Tu Nombre', library) while True: print(''' ==========MENÚ DE LA BIBLIOTECA=========== 1. Mostrar Libros Disponibles 2. Tomar Prestado un Libro 3. Devolver un Libro 4. Ver Tus Libros 5. Salir''' ) choice = int(input('Ingresa la opción: ')) if choice == 1: print() library.show_avail_books() elif choice == 2: print() student_example.request_book() elif choice == 3: print() student_example.return_book() elif choice == 4: print() student_example.view_borrowed() elif choice == 5: print('Adiós') exit()if __name__ == '__main__': create_lib()
```
24. Juego de Pong Arcade
¡Este es un proyecto realmente divertido e interesante, ya que hemos utilizado el módulo turtle de Python para emular el clásico juego de arcade Pong!
Hemos utilizado varios métodos del módulo turtle para crear los componentes del juego y detectar las colisiones de la pelota con las paletas del jugador. También hemos definido una serie de asignaciones de teclas para establecer los controles del usuario para las paletas de los jugadores izquierdo y derecho. Siéntete libre de experimentar con la configuración del juego para comprender mejor cómo funciona cada ajuste y cómo afecta al juego en general.
Además de estas nuevas funciones de gráficos de tortuga introducidas, hemos utilizado el formateo de cadenas para mostrar la puntuación actual y las funciones definidas por el usuario para mantener nuestro código ordenado. Estos son conceptos con los que deberías estar familiarizado en esta etapa.
Código Fuente:
'''Juego de Pong Arcade-------------------------------------------------------------'''import turtledef actualizar_puntuacion(puntuacion_izq, puntuacion_der, jugador, marcador): if jugador == 'l': puntuacion_izq += 1 else: puntuacion_der += 1 marcador.clear() marcador.write('Jugador Izquierdo: {} -- Jugador Derecho: {}'.format( puntuacion_izq, puntuacion_der), align='center', font=('Arial', 24, 'normal')) return puntuacion_izq, puntuacion_der, marcadordef configurar_juego(): pantalla = turtle.Screen() pantalla.title('Juego de Pong Arcade') pantalla.bgcolor('white') pantalla.setup(width=1000, height=600) paleta_izq = turtle.Turtle() paleta_izq.speed(0) paleta_izq.shape('square') paleta_izq.color('red') paleta_izq.shapesize(stretch_wid=6, stretch_len=2) paleta_izq.penup() paleta_izq.goto(-400, 0) paleta_der = turtle.Turtle() paleta_der.speed(0) paleta_der.shape('square') paleta_der.color('black') paleta_der.shapesize(stretch_wid=6, stretch_len=2) paleta_der.penup() paleta_der.goto(400, 0) pelota = turtle.Turtle() pelota.speed(40) pelota.shape('circle') pelota.color('blue') pelota.penup() pelota.goto(0, 0) pelota.dx = 5 pelota.dy = -5 marcador = turtle.Turtle() marcador.speed(0) marcador.color('blue') marcador.penup() marcador.hideturtle() marcador.goto(0, 260) marcador.write('Jugador Izquierdo: 0 -- Jugador Derecho: 0', align='center', font=('Arial', 24, 'normal')) return pantalla, pelota, paleta_izq, paleta_der, marcadordef juego_pong(): componentes_juego = configurar_juego() pantalla = componentes_juego[0] pelota = componentes_juego[1] paleta_izq = componentes_juego[2] paleta_der = componentes_juego[3] marcador = componentes_juego[4] puntuacion_izq = 0 puntuacion_der = 0 def paleta_izq_arriba(): paleta_izq.sety(paleta_izq.ycor() + 20) def paleta_izq_abajo(): paleta_izq.sety(paleta_izq.ycor() - 20) def paleta_der_arriba(): paleta_der.sety(paleta_der.ycor() + 20) def paleta_der_abajo(): paleta_der.sety(paleta_der.ycor() - 20) pantalla.listen() pantalla.onkeypress(paleta_izq_arriba, 'e') pantalla.onkeypress(paleta_izq_abajo, 'x') pantalla.onkeypress(paleta_der_arriba, 'Up') pantalla.onkeypress(paleta_der_abajo, 'Down') while True: pantalla.update() pelota.setx(pelota.xcor()+pelota.dx) pelota.sety(pelota.ycor()+pelota.dy) if pelota.ycor() > 280: pelota.sety(280) pelota.dy *= -1 if pelota.ycor() < -280: pelota.sety(-280) pelota.dy *= -1 if pelota.xcor() > 500: pelota.goto(0, 0) pelota.dy *= -1 puntuacion_izq, puntuacion_der, marcador = actualizar_puntuacion( puntuacion_izq, puntuacion_der, 'l', marcador) continue elif pelota.xcor() < -500: pelota.goto(0, 0) pelota.dy *= -1 puntuacion_izq, puntuacion_der, marcador = actualizar_puntuacion( puntuacion_izq, puntuacion_der, 'r', marcador) continue if ((pelota.xcor() > 360) and (pelota.xcor() < 370) and (pelota.ycor() < paleta_der.ycor()+40) and (pelota.ycor() > paleta_der.ycor()-40)): pelota.setx(360) pelota.dx *= -1 if ((pelota.xcor() < -360) and (pelota.xcor() > -370) and (pelota.ycor() < paleta_izq.ycor()+40) and (pelota.ycor() > paleta_izq.ycor()-40)): pelota.setx(-360) pelota.dx *= -1if __name__ == '__main__': juego_pong()
25. Prueba de velocidad de escritura
Este es un interesante proyecto de Python que prueba qué tan rápido puedes escribir correctamente una oración.
Este programa requiere que creemos una interfaz gráfica de usuario (GUI) a través del módulo tkinter. Si eres nuevo en las GUIs, este ejemplo es una buena introducción, ya que utilizamos una variedad de etiquetas simples, botones y campos de entrada para crear una ventana. También hemos utilizado el módulo timeit de Python para manejar el aspecto del tiempo de nuestra prueba de escritura y el módulo random para seleccionar aleatoriamente una frase de prueba.
Hemos agregado solo dos frases de prueba a este ejemplo, pero siéntete libre de experimentar con más o incluso integrar un diccionario de terceros para obtener una variedad más amplia de ejemplos.
Código Fuente:
'''Prueba de velocidad de escritura----------------------------------------------'''import tkinterfrom timeit import default_timer as timerimport randomdef prueba_de_velocidad(): frases_de_prueba = [ 'Esta es una oración al azar para verificar la velocidad.', 'Velocidad, soy lightning mcqueen.' ] frase = random.choice(frases_de_prueba) inicio = timer() ventana_principal = tkinter.Tk() ventana_principal.geometry('600x400') etiqueta_1 = tkinter.Label(ventana_principal, text=frase, font='times 20') etiqueta_1.place(x=150, y=10) etiqueta_2 = tkinter.Label(ventana_principal, text='Comienza a escribir', font='times 20') etiqueta_2.place(x=10, y=50) entrada = tkinter.Entry(ventana_principal) entrada.place(x=280, y=55) def verificar_resultado(): if entrada.get() == frase: fin = timer() etiqueta_3.configure(text=f'Tiempo: {round((fin-inicio), 4)}s') else: etiqueta_3.configure(text='Entrada incorrecta') boton_1 = tkinter.Button(ventana_principal, text='Listo', command=verificar_resultado, width=12, bg='grey') boton_1.place(x=150, y=100) boton_2 = tkinter.Button(ventana_principal, text='Intentar de nuevo', command=prueba_de_velocidad, width=12, bg='grey') boton_2.place(x=250, y=100) etiqueta_3 = tkinter.Label(ventana_principal, text='', font='times 20') etiqueta_3.place(x=10, y=300) ventana_principal.mainloop()if __name__ == '__main__': prueba_de_velocidad()
26. Editor de Texto
Basado en nuestro último ejemplo de tkinter, este divertido proyecto de Python crea una GUI para simular nuestro propio editor de texto. Este ejemplo también utiliza componentes de GUI estándar, como etiquetas, botones y campos de entrada.
Sin embargo, también hemos agregado la capacidad de abrir y guardar archivos como en un editor de texto real. Si eres nuevo en el manejo de archivos, este proyecto de Python es una excelente manera de comprender cómo leer y guardar archivos.
Experimenta con el siguiente código para solidificar tu comprensión y verifica si puedes expandir este código para crear otras funciones que estés acostumbrado a usar con un editor de texto, como una función de búsqueda de palabras.
Código Fuente:
'''Editor de Texto-------------------------------------------------------------'''import tkinter as tkfrom tkinter.filedialog import askopenfilename, asksaveasfilenamedef editor_de_texto(): def abrir_archivo(): archivo = askopenfilename( filetypes=[('Archivos de Texto', '*.txt'), ('Todos los archivos', '*.*')] ) if not archivo: return txt_edit.delete(1.0, tk.END) with open(archivo, 'r') as archivo_entrada: texto = archivo_entrada.read() txt_edit.insert(tk.END, texto) ventana.title(f'Editor de Texto - {archivo}') def guardar_archivo(): archivo = asksaveasfilename( defaultextension='txt', filetypes=[('Archivos de Texto', '*.txt'), ('Todos los archivos', '*.*')], ) if not archivo: return with open(archivo, 'w') as archivo_salida: texto = txt_edit.get(1.0, tk.END) archivo_salida.write(texto) ventana.title(f'Editor de Texto - {archivo}') ventana = tk.Tk() ventana.title('Editor de Texto') ventana.rowconfigure(0, minsize=800, weight=1) ventana.columnconfigure(1, minsize=800, weight=1) txt_edit = tk.Text(ventana) fr_botones = tk.Frame(ventana, relief=tk.RAISED, bd=2) btn_abrir = tk.Button(fr_botones, text='Abrir', command=abrir_archivo) btn_guardar = tk.Button(fr_botones, text='Guardar como...', command=guardar_archivo) btn_abrir.grid(row=0, column=0, sticky='ew', padx=5, pady=5) btn_guardar.grid(row=1, column=0, sticky='ew', padx=5) fr_botones.grid(row=0, column=0, sticky='ns') txt_edit.grid(row=0, column=1, sticky='nsew') ventana.mainloop()if __name__ == '__main__': editor_de_texto()
27. Solucionador de Sudoku
Este proyecto de Python utiliza la biblioteca pygame (ver instrucciones de instalación de pip) para implementar una interfaz gráfica de usuario (GUI) para resolver automáticamente puzzles de sudoku. Utilizamos varias funciones definidas por el usuario para crear la GUI, como se muestra a continuación.
Para resolver un puzzle de sudoku, este programa utiliza un algoritmo de retroceso que verifica incrementalmente soluciones, adoptando o abandonando la solución actual si no es viable.
Este paso de abandonar una solución es la característica definitoria de un enfoque de retroceso, ya que el programa retrocede para probar una nueva solución hasta que encuentra una válida. Este proceso se lleva a cabo de manera incremental hasta que se ha llenado correctamente toda la cuadrícula.
Siéntase libre de experimentar con diferentes problemas de sudoku e incluso pensar en expandir el tamaño de la cuadrícula del problema (necesitará una nueva imagen base si hace esto).
Código Fuente:
'''Solucionador de Sudoku-------------------------------------------------------------pip install pygameimage link:https://www.pngitem.com/pimgs/m/210-2106648_empty-sudoku-grid-grid-6x6-png-transparent-png.png'''import pygamepygame.font.init()screen = pygame.display.set_mode((600, 600))pygame.display.set_caption('SOLUCIONADOR DE SUDOKU UTILIZANDO RETROCESO')img = pygame.image.load('icon.png')pygame.display.set_icon(img)font1 = pygame.font.SysFont('comicsans', 40)font2 = pygame.font.SysFont('comicsans', 20)x = 0y = 0dif = 500 / 9val = 0# Tablero de Sudoku predeterminadogrid = [ [7, 8, 0, 4, 0, 0, 1, 2, 0], [6, 0, 0, 0, 7, 5, 0, 0, 9], [0, 0, 0, 6, 0, 1, 0, 7, 8], [0, 0, 7, 0, 4, 0, 2, 6, 0], [0, 0, 1, 0, 5, 0, 9, 3, 0], [9, 0, 4, 0, 6, 0, 0, 0, 5], [0, 7, 0, 3, 0, 0, 0, 1, 2], [1, 2, 0, 0, 0, 7, 4, 0, 0], [0, 4, 9, 2, 0, 6, 0, 0, 7]]def obtener_coordenada(pos): x = pos[0] // dif y = pos[1] // difdef dibujar_caja(): for i in range(2): pygame.draw.line(screen, (255, 0, 0), (x * dif-3, (y + i) * dif), (x * dif + dif + 3, (y + i)*dif), 7) pygame.draw.line(screen, (255, 0, 0), ((x + i) * dif, y * dif), ((x + i) * dif, y * dif + dif), 7)def dibujar(): for i in range(9): for j in range(9): if grid[i][j] != 0: pygame.draw.rect(screen, (0, 153, 153), (i * dif, j * dif, dif + 1, dif + 1)) text1 = font1.render(str(grid[i][j]), 1, (0, 0, 0)) screen.blit(text1, (i * dif + 15, j * dif + 15)) for i in range(10): if i % 3 == 0: thick = 7 else: thick = 1 pygame.draw.line(screen, (0, 0, 0), (0, i * dif), (500, i * dif), thick) pygame.draw.line(screen, (0, 0, 0), (i * dif, 0), (i * dif, 500), thick)def dibujar_valor(val): text1 = font1.render(str(val), 1, (0, 0, 0)) screen.blit(text1, (x * dif + 15, y * dif + 15))def mostrar_error_1(): text1 = font1.render('¡INCORRECTO!', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def mostrar_error_2(): text1 = font1.render('¡Incorrecto! No es una tecla válida', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def valido(m, i, j, val): for it in range(9): if m[i][it] == val: return False if m[it][j] == val: return False it = i // 3 jt = j // 3 for i in range(it * 3, it * 3 + 3): for j in range(jt * 3, jt * 3 + 3): if m[i][j] == val: return False return Truedef solucionar(grid, i, j): while grid[i][j] != 0: if i < 8: i += 1 elif i == 8 and j < 8: i = 0 j += 1 elif i == 8 and j == 8: return True pygame.event.pump() for it in range(1, 10): if valido(grid, i, j, it) == True: grid[i][j] = it x = i y = j screen.fill((255, 255, 255)) dibujar() dibujar_caja()28. Comprobador de Conectividad del Sitio
Este proyecto de Python utiliza los módulos urllib y tkinter para probar la conectividad de un sitio web.
Hemos utilizado el módulo tkinter para crear una interfaz gráfica que permite a los usuarios ingresar una dirección web. Al igual que en ejemplos anteriores, esto incluye etiquetas, botones y campos de entrada.
Después de recopilar la dirección web del usuario, pasamos esta información a nuestra función definida por el usuario para obtener el código de estado HTTP del sitio web actual utilizando la función .getcode() del módulo urllib.
En este ejemplo, simplemente determinamos si el código HTTP es 200. Si es así, sabemos que el sitio está en funcionamiento; de lo contrario, informamos al usuario que no está disponible.
Puedes ampliar este código para considerar un enfoque más detallado para manejar los diferentes códigos de respuesta HTTP, ¡así que siéntete libre de agregarlo!
Código Fuente:
'''Comprobador de Conectividad del Sitio-------------------------------------------------------------Ingresa sitios web como http(s)://www.tusitio.com'''import urllib.requestimport tkinter as tkdef test_connectivity(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='Comprobador de Conectividad del Sitio Web', font=('Calibri 15')) head.pack(pady=20) def check_url(): web = (url.get()) status_code = urllib.request.urlopen(web).getcode() website_is_up = status_code == 200 if website_is_up: tk.Label(window, text='Sitio Web Disponible', font=('Calibri 15')).place(x=260, y=200) else: tk.Label(window, text='Sitio Web No Disponible', font=('Calibri 15')).place(x=260, y=200) url = tk.StringVar() tk.Entry(window, textvariable=url).place(x=200, y=80, height=30, width=280) tk.Button(window, text='Comprobar', command=check_url).place(x=285, y=150) window.mainloop()if __name__ == '__main__': test_connectivity()
29. Detector de Idioma
Este proyecto de Python utiliza el módulo langdetect (consulta las instrucciones de instalación de pip) para ayudarnos a identificar el idioma ingresado. Esto puede ser realmente útil si no estás seguro de qué idioma estás tratando.
Este es otro ejemplo en el que hemos utilizado tkinter para crear una interfaz gráfica simple que involucra etiquetas, botones y un campo de entrada. Luego podemos recopilar el texto del campo de entrada y procesarlo con langdetect para determinar qué idioma se ingresó. Finalmente, mostramos este resultado en la interfaz gráfica para que el usuario conozca el resultado.
Ten en cuenta que los resultados devueltos por langdetect son códigos de idioma abreviados. Por ejemplo, si ingresamos texto en inglés, veremos 'en' como valor de retorno.
Código Fuente:
'''Detector de Idioma-------------------------------------------------------------pip install langdetect'''from langdetect import detectimport tkinter as tkdef detect_lang(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='Detector de Idioma', font=('Calibri 15')) head.pack(pady=20) def check_language(): new_text = text.get() lang = detect(str(new_text)) tk.Label(window, text=lang, font=('Calibri 15')).place(x=260, y=200) text = tk.StringVar() tk.Entry(window, textvariable=text).place( x=200, y=80, height=30, width=280) tk.Button(window, text='Detectar Idioma', command=check_language).place(x=285, y=150) window.mainloop()if __name__ == '__main__': detect_lang()
30. Sistema de Recomendación de Netflix
Para finalizar, hemos guardado un proyecto de Python especialmente emocionante para el final. ¡Este es un sistema de recomendación de Netflix, ideal para aspirantes a científicos de datos! De hecho, si estás considerando un curso de aprendizaje automático, este es un gran proyecto para reforzar tus nuevas habilidades.
Para crear este proyecto, deberás importar una variedad de módulos, incluyendo tkinter, re, nltk, pandas y numpy (consulta las instrucciones de instalación de pip para los nuevos módulos). También necesitarás descargar un conjunto de datos de Kaglge que contenga películas y programas de televisión de Netflix.
Usaremos tkinter para crear nuestra interfaz gráfica, que utilizará etiquetas, botones y campos de entrada. Luego, el usuario podrá ingresar un programa de televisión o película que haya disfrutado en Netflix para recibir recomendaciones basadas en sus gustos.
El motor de recomendaciones utiliza el reparto, el director, las calificaciones, el país y los géneros como "características" de aprendizaje automático (ML). El código luego utiliza el enfoque de "similitud del coseno" para encontrar resultados similares basados en la entrada del usuario. Esto utiliza extensivamente pandas y numpy para limpiar los datos y prepararlos para el procesamiento.
Hay mucho que desempaquetar en este ejemplo, ya que utiliza muchos conceptos de Python para la ciencia de datos.
El mejor enfoque es trabajar lentamente a través del código y luego llevar a cabo una investigación adicional sobre Aprendizaje Automático (ML), "características" y "similitud del coseno".
Luego podrás entender cómo usar un conjunto de datos para obtener recomendaciones basadas en similitudes. Si eres un aspirante a científico de datos, ¡este es un proyecto excelente para mojarse los pies!
Código fuente:
'''Motor de recomendación de Netflix-------------------------------------------------------------pip install pandas numpy nltk'''from nltk.tokenize import word_tokenizeimport numpy as npimport pandas as pdimport reimport nltkimport tkinter as tkfrom nltk.corpus import stopwordsnltk.download('stopwords')data = pd.read_csv('netflixData.csv')data = data.dropna(subset=['Cast', 'Production Country', 'Rating'])movies = data[data['Content Type'] == 'Movie'].reset_index()movies = movies.drop(['index', 'Show Id', 'Content Type', 'Date Added', 'Release Date', 'Duration', 'Description'], axis=1)movies.head()tv = data[data['Content Type'] == 'TV Show'].reset_index()tv = tv.drop(['index', 'Show Id', 'Content Type', 'Date Added', 'Release Date', 'Duration', 'Description'], axis=1)tv.head()actors = []for i in movies['Cast']: actor = re.split(r', \s*', i) actors.append(actor)flat_list = []for sublist in actors: for item in sublist: flat_list.append(item)actors_list = sorted(set(flat_list))binary_actors = [[0] * 0 for i in range(len(set(flat_list)))]for i in movies['Cast']: k = 0 for j in actors_list: if j in i: binary_actors[k].append(1.0) else: binary_actors[k].append(0.0) k += 1binary_actors = pd.DataFrame(binary_actors).transpose()directors = []for i in movies['Director']: if pd.notna(i): director = re.split(r', \s*', i) directors.append(director)flat_list_2 = []for sublist in directors: for item in sublist: flat_list_2.append(item)directors_list = sorted(set(flat_list_2))binary_directors = [[0] * 0 for i in range(len(set(flat_list_2)))]for i in movies['Director']: k = 0 for j in directors_list: if pd.isna(i): binary_directors[k].append(0.0) elif j in i: binary_directors[k].append(1.0) else: binary_directors[k].append(0.0) k += 1binary_directors = pd.DataFrame(binary_directors).transpose()countries = []for i in movies['Production Country']: country = re.split(r', \s*', i) countries.append(country)flat_list_3 = []for sublist in countries: for item in sublist: flat_list_3.append(item)countries_list = sorted(set(flat_list_3))binary_countries = [[0] * 0 for i in range(len(set(flat_list_3)))]for i in movies['Production Country']: k = 0 for j in countries_list: if j in i: binary_countries[k].append(1.0) else: binary_countries[k].append(0.0) k += 1binary_countries = pd.DataFrame(binary_countries).transpose()genres = []for i in movies['Genres']: genre = re.split(r', \s*', i) genres.append(genre)flat_list_4 = []for sublist in genres: for item in sublist: flat_list_4.append(item)genres_list = sorted(set(flat_list_4))binary_genres = [[0] * 0 for i in range(len(set(flat_list_4)))]for i in movies['Genres']: k = 0 for j in genres_list: if j in i: binary_genres[k].append(1.0) else: binary_genres[k].append(0.0) k += 1binary_genres = pd.DataFrame(binary_genres).transpose()ratings = []for i in movies['Rating']: ratings.append(i)ratings_list = sorted(set(ratings))binary_ratings = [[0] * 0 for i in range(len(set(ratings_list)))]for i in movies['Rating']: k = 0 for j in ratings_list: if j in i: binary_ratings[k].append(1.0) else: binary_ratings[k].append(0.0) k += 1binary_ratings = pd.DataFrame(binary_ratings).transpose()binary = pd.concat([binary_actors, binary_directors, binary_countries, binary_genres], axis=1, ignore_index=True)actors_2 = []for i in tv['Cast']: actor2 = re.split(r', \s*', i) actors_2.append(actor2)flat_list_5 = []for sublist in actors_2: for item in sublist: flat_list_5.append(item)actors_list_2 = sorted(set(flat_list_5))binary_actors_2 = [[0] * 0 for i in range(len(set(flat_list_5)))]for i in tv['Cast']: k = 0 for j in actors_list_2: if j in i: binary_actors_2[k].append(1.0) else: binary_actors_2[k].append(0.0) k += 1binary_actors_2 = pd.DataFrame(binary_actors_2).transpose()countries_2 = []for i in tv['Production Country']: country2 = re.split(r
Dónde comenzar con Python
Hoy en día, estamos experimentando una adopción cada vez mayor de la Inteligencia Artificial (IA), el Aprendizaje Automático (ML) y la ciencia de datos en la gran mayoría de los sectores empresariales. Una de las principales cosas que estos campos tienen en común es que utilizan el lenguaje de programación Python de una forma u otra.
Cuando se trata de aprender Python en 2023, tienes tantas opciones, ya sea construyendo los proyectos de Python que hemos enumerado o buscando tutoriales útiles de Python.
Además, si prefieres una experiencia de aprendizaje profunda e interactiva, también recomendamos nuestro nuevo curso de Python.
Conclusión
Y ahí lo tienes. 30 proyectos de Python geniales, divertidos y emocionantes con código fuente que van desde lo simple hasta lo avanzado.
No importa lo que quieras construir, nuestros proyectos de Python deberían tener algo para ti, ya que hemos incluido juegos, programación orientada a objetos, interfaces gráficas de usuario (GUI), inteligencia artificial (IA), aprendizaje automático (ML), APIs, bots, módulos de biblioteca estándar y diversas bibliotecas de terceros.
Y lo único que cada uno de nuestros proyectos de Python tiene en común es que te exigen poner en práctica tus habilidades teóricas. Esta es una excelente manera de probarte a ti mismo y mejorar tus habilidades de Python a medida que das pasos para convertirte en un mejor programador práctico.
¿Disfrutaste abordando estos proyectos de Python y estás listo para profundizar en Python? Echa un vistazo a:
Preguntas frecuentes
1. ¿Es Python adecuado para proyectos grandes?
Aunque hay argumentos de que Python es más lento que otros lenguajes populares como C y C++, Python sigue siendo ampliamente utilizado por muchas de las principales empresas tecnológicas porque es muy versátil, fácil de mantener y ofrece una gran cantidad de bibliotecas y el apoyo de la comunidad.
2. ¿Cuál debería ser mi primer proyecto de Python?
¡Echa un vistazo a cualquiera de los proyectos para principiantes de Python que hemos cubierto anteriormente, incluyendo Mad Libs, Piedra Papel Tijera, Ahorcado o Tic-Tac-Toe!
Las personas también están leyendo:
- Preguntas de entrevista de Python
- Guía de Web Scraping con Python
- Frameworks de Python
- Bucle While en Python
- Operadores de Python Is y Equality
- Declaraciones Condicionales de Python
- Cheat Sheet de RegEx en Python
- Intérpretes de Python
Leave a Reply