30 крутых, простых и веселых проектов на Python + исходный код [2023]
Мы рассмотрели 30 увлекательных проектов на Python, чтобы дать вам практику в программировании, от создания чат-бота AI до конвертера валют.
“`html
Независимо от вашего текущего уровня навыков, изучение создания проектов на Python – надежный способ повысить свои навыки и улучшить свое портфолио. Нет ничего лучше, чем попробовать свои силы в программировании и создании проектов на Python!
Кроме того, стать мастером Python в 2023 году открывает множество возможностей для вашей карьеры и позволяет получить лучшие рабочие места на планете, не говоря уже о привлекательной зарплате свыше $100 тысяч в год.
В этой статье мы представляем 30 интересных проектов на Python, начиная от простых проектов для новичков до промежуточных и продвинутых проектов, которые вы можете использовать для саморазвития или улучшения навыков программирования на Python.
Кроме того, если вам нужна дополнительная помощь, мы только что выпустили наш собственный курс Python с доктором Джонсом, где мы предлагаем академический подход к обучению, а также создание портфолио, основанного на проектах на Python.
Что я могу создать с помощью Python?
Это отличный вопрос, особенно если вы совсем новичок в программировании на Python.
Что ж, во-первых, вам следует знать, что существует множество приложений на Python в различных областях, поэтому у вас есть много вариантов.
<p, Конечно, Python уже зарекомендовал себя в сфере науки о данных, анализа данных, машинного обучения и искусственного интеллекта, но это еще не все.
Он также отлично подходит для веб-разработки благодаря популярным фреймворкам для веб-приложений, таким как Django и Flask.
Также он идеально подходит для автоматизации повторяющихся задач, поэтому он был создан как скриптовый язык.
Проще говоря, с помощью Python можно создавать очень многое, но если вы ищете вдохновение, то вы попали по адресу!
Я подготовил для вас 30 проектов на Python, с которыми можно взяться, начиная с новичков и заканчивая продвинутыми.
Итак, приступим!
Проекты на Python для начинающих
Начнем с некоторых проектов для начинающих, которые идеально подходят, если вы только начинаете и хотите изучить Python. Однако, если вы хотите попробовать что-то более сложное, прокрутите страницу ниже для более продвинутых проектов.
1. Генератор Mad Libs
Это один из самых увлекательных проектов для новичков на Python, который позволяет попрактиковаться в использовании строк, переменных и конкатенации, что является неотъемлемым навыком для всех приложений на Python на всех уровнях сложности.
Генератор Mad Libs собирает и обрабатывает данные, полученные от пользователя, в виде прилагательного, местоимения и глагола. Программа берет эти данные и строит историю.
Исходный код:
'''Генератор Mad Libs-------------------------------------------------------------'''# Вопросы для пользователяnoun = input('Выберите существительное: ')p_noun = input('Выберите существительное во множественном числе: ')noun2 = input('Выберите существительное: ')place = input('Назовите место: ')adjective = input('Выберите прилагательное (описательное слово): ')noun3 = input('Выберите существительное: ')# Вывод истории на основе составленных пользователем данныхprint('------------------------------------------')print('Будьте добры к вашему', noun, 'на ноге', p_noun)print('Ведь утка может быть чьей-то', noun2, ',')print('Будьте добры к вашим', p_noun, 'в', place)print('Где погода всегда', adjective, '. \n')print('Вы можете подумать, что это', noun3, ',')print('Ну, да, это так.')print('------------------------------------------')2. Угадай число
Этот проект для новичков на Python – это увлекательная игра, в которой генерируется случайное число (в определенном диапазоне), которое пользователь должен угадать, получая подсказки. За каждую неправильную догадку пользователь получает дополнительные подсказки, но это влияет на итоговый счет.
Эта программа – отличный способ попробовать работу с библиотекой стандартной библиотеки Python, так как она использует модуль random для генерации случайных чисел. Вы также можете получить практику с условными операторами, форматированием печати, определением пользовательских функций и различными операторами Python.
Исходный код:
'''Игра "Угадай число"-------------------------------------------------------------'''import randomattempts_list = []def show_score(): if not attempts_list: print('Пока нет рекорда,' ' вы можете его установить!') else: print(f'Текущий рекорд: ' f' {min(attempts_list)} попыток')def start_game(): attempts = 0 rand_num = random.randint(1, 10) print('Привет, путешественник! Добро пожаловать в игру угадывания чисел!') player_name = input('Как вас зовут? ') wanna_play = input( f'Привет, {player_name}, хотите сыграть ' f'в игру угадывания чисел? (Введите Да/Нет): ') if wanna_play.lower() != 'да': print('Хорошо, спасибо!') exit() else: show_score() while wanna_play.lower() == 'да': try: guess = int(input('Выберите число от 1 до 10: ')) if guess < 1 or guess > 10: raise ValueError( 'Пожалуйста, введите число в данном диапазоне') attempts += 1 attempts_list.append(attempts) if guess == rand_num: print('Отлично! Вы угадали!') print(f'Потребовалось {attempts} попыток') wanna_play = input( 'Хотите сыграть еще раз? (Введите Да/Нет): ') if wanna_play.lower() != 'да': print('Хорошо, до новых встреч!') break else: attempts = 0 rand_num = random.randint(1, 10) show_score() continue else: if guess > rand_num: print('Больше') elif guess < rand_num: print('Меньше') except ValueError as err: print('Ой, это недопустимое значение. Попробуйте еще раз...') print(err)if __name__ == '__main__': start_game()“`
3. Камень, Ножницы, Бумага
Эта программа “Камень, Ножницы, Бумага” имитирует всемирно популярную игру с использованием функций и условных операторов. Так что, какой лучший способ усвоить эти основные концепции? Вы также будете использовать Python list для хранения коллекции допустимых ответов, которые затем можно использовать для создания элегантного и питонического условного оператора.
Как один из множества проектов на языке Python, использующих дополнительные библиотеки, эта программа использует модули random, os и re из стандартной библиотеки.
Взгляните на код ниже, и вы увидите, что на этом проекте на языке Python предлагается пользователю сделать первый ход, передавая символ, представляющий камень, ножницы или бумагу. После оценки входной строки, условная логика проверяет наличие победителя.
Исходный код:
'''Rock Paper Scissors-------------------------------------------------------------'''import randomimport osimport redef check_play_status(): valid_responses = ['yes', 'no'] while True: try: response = input('Вы хотите сыграть еще раз? (Да или Нет): ') if response.lower() not in valid_responses: raise ValueError('Только Да или Нет') if response.lower() == 'yes': return True else: os.system('cls' if os.name == 'nt' else 'clear') print('Спасибо за игру!') exit() except ValueError as err: print(err)def play_rps(): play = True while play: os.system('cls' if os.name == 'nt' else 'clear') print('') print('Камень, Ножницы, Бумага - Бросаем!') user_choice = input('Выберите оружие:' ' [К]амень], [Н]ожницы или [Б]умага: ') if not re.match("[БНКбнк]", user_choice): print('Пожалуйста, выберите букву:') print('[К]амень, [Н]ожницы или [Б]умага') continue print(f'Вы выбрали: {user_choice}') choices = ['К', 'Н', 'Б'] opp_choice = random.choice(choices) print(f'Я выбрал: {opp_choice}') if opp_choice == user_choice.upper(): print('Ничья!') play = check_play_status() elif opp_choice == 'К' and user_choice.upper() == 'Н': print('Камень побеждает ножницы, я победил!') play = check_play_status() elif opp_choice == 'Н' and user_choice.upper() == 'Б': print('Ножницы побеждают бумагу! Я победил!') play = check_play_status() elif opp_choice == 'Б' and user_choice.upper() == 'К': print('Бумага побеждает камень, я победил!') play = check_play_status() else: print('Вы победили!\n') play = check_play_status()if __name__ == '__main__': play_rps()4. Генератор броска кубика
Как один из наиболее связанных с реальностью проектов на языке Python для начинающих с кодом, эта программа имитирует бросок одного или двух кубиков. Это также отличный способ укрепить ваше понимание пользовательских функций, циклов и условных операторов. Это фундаментальные навыки для начинающих на Python и, вероятно, это одно из первых вещей, которые вы изучите, будь то в онлайн-курсе или в Python книге.
Как один из наших простых проектов на Python, это довольно простая программа, которая использует модуль Python random для имитации случайности броска кубика. Вы также заметите, что мы используем модуль os, чтобы очистить экран после броска кубика.
Обратите внимание, что вы можете изменить максимальное значение кубика на любое число, позволяя вам имитировать поледральные кубики, часто используемые в различных настольных играх и ролевых играх.
Исходный код:
'''Dice Roll Generator-------------------------------------------------------------'''import randomimport osdef num_die(): while True: try: num_dice = input('Количество кубиков: ') valid_responses = ['1', 'один', 'два', '2'] if num_dice not in valid_responses: raise ValueError('Только 1 или 2') else: return num_dice except ValueError as err: print(err)def roll_dice(): min_val = 1 max_val = 6 roll_again = 'y' while roll_again.lower() == 'yes' or roll_again.lower() == 'y': os.system('cls' if os.name == 'nt' else 'clear') amount = num_die() if amount == '2' or amount == 'два': print('Бросаем кубики...') dice_1 = random.randint(min_val, max_val) dice_2 = random.randint(min_val, max_val) print('Значения:') print('Первый кубик: ', dice_1) print('Второй кубик: ', dice_2) print('Сумма: ', dice_1 + dice_2) roll_again = input('Бросить еще раз? ') else: print('Бросаем кубик...') dice_1 = random.randint(min_val, max_val) print(f'Значение: {dice_1}') roll_again = input('Бросить еще раз? ')if __name__ == '__main__': roll_dice()5. Игра в Виселицу
Это интересная идея проекта на Python, эмулирующая игру в угадывание слова — Виселица. Мы использовали заранее определенный список слов для аспекта угадывания, но вы можете улучшить его, используя сторонний словарь API.
Этот проект на Python использует циклы, функции и форматирование строк для печати прогресса игры. Он также позволяет вам экспериментировать с модулями стандартной библиотеки: random, time и os.
Конкретно, мы использовали модуль random для выбора слова для угадывания, модуль os для очистки экрана и функцию .sleep() модуля time для создания пауз для улучшения потока игры.
Если вы сейчас проходите курс по Python и все еще новичок в этом языке, это отличный проект среднего размера, чтобы проверить себя!
Исходный код:
'''Игра в Виселицу-------------------------------------------------------------'''import randomimport timeimport osdef play_again(): question = 'Хотите сыграть снова? y = да, n = нет \n' play_game = input(question) while play_game.lower() not in ['y', 'n']: play_game = input(question) if play_game.lower() == 'y': return True else: return Falsedef hangman(word): display = '_' * len(word) count = 0 limit = 5 letters = list(word) guessed = [] while count < limit: guess = input(f'Слово Виселицы: {display} Введите вашу догадку: \n').strip() while len(guess) == 0 or len(guess) > 1: print('Неверный ввод. Введите одну букву\n') guess = input( f'Слово Виселицы: {display} Введите вашу догадку: \n').strip() if guess in guessed: print('Упс! Вы уже пробовали эту догадку, попробуйте еще раз!\n') continue if guess in letters: letters.remove(guess) index = word.find(guess) display = display[:index] + guess + display[index + 1:] else: guessed.append(guess) count += 1 if count == 1: time.sleep(1) print(' _____ \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Неверная догадка: осталось {limit - count} попыток\n') elif count == 2: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Неверная догадка: осталось {limit - count} попыток\n') elif count == 3: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | \n' ' | \n' ' | \n' '__|__\n') print(f'Неверная догадка: осталось {limit - count} попыток\n') elif count == 4: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | \n' ' | \n' '__|__\n') print(f'Неверная догадка: осталось {limit - count} попыток\n') elif count == 5: time.sleep(1) print(' _____ \n' ' | | \n' ' | | \n' ' | | \n' ' | O \n' ' | /|\ \n' ' | / \ \n' '__|__\n') print('Неверная догадка. Вы повешены!!!\n') print(f'Было загадано слово: {word}') if display == word: print(f'Поздравляем! Вы угадали слово \'{word}\' правильно!') breakdef play_hangman(): print('\nДобро пожаловать в игру Виселица\n') name = input('Введите ваше имя: ') print(f'Привет, {name}! Удачи!') time.sleep(1) print('Игра начнется скоро!\nДавайте сыграем в Виселицу!') time.sleep(1) os.system('cls' if os.name == 'nt' else 'clear') words_to_guess = [ 'январь', 'граница', 'изображение', 'фильм', 'обещание', 'дети', 'легкие', 'кукла', 'рифма', 'повреждение', 'растения', 'привет', 'мир' ] play = True while play: word = random.choice(words_to_guess) hangman(word) play = play_again() print('Спасибо за игру! Мы ждем вас снова!') exit()if __name__ == '__main__': play_hangman()6. Проверка сложности пароля
Если вам интересно узнать как создать приложение, то этот проект на Python может быть отличным дополнением, так как он позволяет проверить, достаточно ли ваш пароль надежен.
Он делает это, проверяя количество букв, цифр, специальных символов и пробелов в заданном пароле и генерируя оценку на основе этих результатов. Так что это еще один отличный способ изучить условные операторы, функции и форматирование строк.
Мы также используем модули string и getpass из стандартной библиотеки Python. Это позволяет нам получить доступ к полному набору символов строки для сравнения с составом символов нашего пароля, а функция .getpass() позволяет скрыть пароль при его вводе.
Исходный код:
'''Проверка сложности пароля-------------------------------------------------------------'''import stringimport getpassdef check_password_strength(): password = getpass.getpass('Введите пароль: ') 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 = ('Это очень плохой пароль.' ' Измените его как можно скорее.') elif strength == 2: remarks = ('Это слабый пароль.' ' Вы должны рассмотреть использование более надежного пароля.') elif strength == 3: remarks = 'Ваш пароль нормальный, но его можно усовершенствовать.' elif strength == 4: remarks = ('Ваш пароль сложно угадать.' ' Но вы можете сделать его еще более безопасным.') elif strength == 5: remarks = ('Вот это крепкий пароль!!!' ' Хакеры не имеют шансов угадать этот пароль!') print('Ваш пароль содержит:-') print(f'{lower_count} строчных букв') print(f'{upper_count} заглавных букв') print(f'{num_count} цифр') print(f'{wspace_count} пробелов') print(f'{special_count} специальных символов') print(f'Оценка пароля: {strength / 5}') print(f'Замечания: {remarks}')def check_pwd(another_pw=False): valid = False if another_pw: choice = input( 'Хотите проверить сложность другого пароля (да/нет) : ') else: choice = input( 'Хотите проверить сложность своего пароля (да/нет) : ') while not valid: if choice.lower() == 'да': return True elif choice.lower() == 'нет': print('Выход...') return False else: print('Неверный ввод...попробуйте снова. \n')if __name__ == '__main__': print('===== Добро пожаловать в Проверку сложности пароля =====') check_pw = check_pwd() while check_pw: check_password_strength() check_pw = check_pwd(True)7. Число в слова
Этот проект на Python преобразует целое число, введенное пользователем, в его эквивалентные слова. Эта программа настроена для поддержки чисел с максимум 12 цифр, но вы можете изменить программу для работы с более большими числами (подсказка: потребуются условные операторы и циклы).
Как пример понятных базовых проектов на Python, эта простая, но эффективная программа может расширить ваши навыки работы с циклами, вводом пользователя и условными операторами, а также с кортежами и списками в Python.
Вы также сможете поэкспериментировать с некоторыми математическими операциями, которые могут быть вам незнакомы, например оператором остатка (%) для получения остатка от целочисленного деления.
Если какая-то из этих техник вам незнакома, вы можете рассмотреть установку AI кодового помощника в своей среде разработки Python, чтобы он мог предложить помощь при работе с любыми блоками кода, которые вам сложно понять.
Исходный код:
'''Числа в слова-------------------------------------------------------------'''ones = ( 'Ноль', 'Один', 'Два', 'Три', 'Четыре', 'Пять', 'Шесть', 'Семь', 'Восемь', 'Девять' )twos = ( 'Десять', 'Одиннадцать', 'Двенадцать', 'Тринадцать', 'Четырнадцать', 'Пятнадцать', 'Шестнадцать', 'Семнадцать', 'Восемнадцать', 'Девятнадцать' )tens = ( 'Двадцать', 'Тридцать', 'Сорок', 'Пятьдесят', 'Шестьдесят', 'Семьдесят', 'Восемьдесят', 'Девяносто', 'Сто' )suffixes = ( '', 'Тысяча', 'Миллион', 'Миллиард' )def fetch_words(number, index): if number == '0': return 'Ноль' 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 += ' Сотня ' 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('Ноль')): words = words[:-len('Ноль')] else: words += ' ' if len(words) != 0: words += suffixes[index] return wordsdef convert_to_words(number): length = len(str(number)) if length > 12: return 'Эта программа поддерживает только числа с максимум 12 цифрами.' 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('Введите любое число: ')) print('%d в словах: %s' %(number, convert_to_words(number)))8. Игра в крестики-нолики
Крестики-нолики – это классическая игра для двух игроков, которая включает в себя девять квадратов на игровом поле. Каждый игрок поочередно отмечает свое пространство крестиком или ноликом, и тот игрок, кто сумеет отметить три крестика или три нолика по диагонали, горизонтали или вертикали, побеждает. Каждый игрок также должен блокировать своего оппонента, пытаясь составить свою цепочку.
Это действительно интересный проект на Python, который уникален для начинающих, поскольку он использует объектно-ориентированное программирование.
Это одно из самых важных понятий Python, которые нужно изучить, и в этом проекте вы создадите новый класс с именем TicTacToe. Затем мы будем использовать его для представления функций игры через атрибуты и методы класса.
Тщательно изучите эти методы, чтобы понять, как мы можем использовать объектно-ориентированное программирование для компактной упаковки различных поведений, необходимых для симуляции этой игры.
Некоторые новые аспекты этой идеи проекта на Python для начинающих включают в себя вложенные циклы для проверки столбцов, строк и диагоналей игрового поля на наличие выигрышного состояния, а также тип данных set в Python, который используется для хранения уникальных значений. Эта программа также использует модуль random в Python для выбора случайного игрока, начинающего игру, но теперь это вам уже знакомо.
Исходный код:
'''Крестики-нолики-------------------------------------------------------------'''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() # проверка строк 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() # проверка столбцов 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() # проверка диагоналей 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'\nХод игрока {player}') row, col = list( map(int, input( 'Введите номер строки и столбца, чтобы поставить свой символ: ').split())) print() if col is None: raise ValueError( 'недостаточно значений для распаковки (ожидалось 2, получено 1)') self.fix_spot(row - 1, col - 1, player) game_over = self.has_player_won(player) if game_over: print(f'Игрок {player} победил!') continue game_over = self.is_board_filled() if game_over: print('Ничья!') 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. Калькулятор
Еще один из наших легких проектов на Python, эта программа создает простое приложение-калькулятор с функциями сложения, вычитания, умножения и деления.
Это один из проектов на Python для практики, который отлично подходит для изучения использования циклов, функций, условных операторов, пользовательского ввода и форматирования строк. Мы также использовали модуль os в Python для очистки экрана после того, как пользователь завершает свои действия по вычислению.
Когда вы овладеете основами этого проекта, подумайте о способах расширить функциональность, чтобы включить возведение в степень или другие более сложные вычисления.
Если вы уже используете помощника по кодированию на основе искусственного интеллекта, такого как GitHub Copilot или Amazon CodeWhisperer, вы также можете попробовать экспериментировать с ним, чтобы добавить новые функции. Попробуйте сделать это сами сначала!
Пример кода:
'''Калькулятор-------------------------------------------------------------'''import osdef addition(): os.system('cls' if os.name == 'nt' else 'clear') print('Сложение') continue_calc = 'y' num_1 = float(input('Введите число: ')) num_2 = float(input('Введите другое число: ')) ans = num_1 + num_2 values_entered = 2 print(f'Текущий результат: {ans}') while continue_calc.lower() == 'y': continue_calc = (input('Введите еще (y/n): ')) while continue_calc.lower() not in ['y', 'n']: print('Пожалуйста, введите \'y\' или \'n\'') continue_calc = (input('Введите еще (y/n): ')) if continue_calc.lower() == 'n': break num = float(input('Введите другое число: ')) ans += num print(f'Текущий результат: {ans}') values_entered += 1 return [ans, values_entered]def subtraction(): os.system('cls' if os.name == 'nt' else 'clear') print('Вычитание') continue_calc = 'y' num_1 = float(input('Введите число: ')) num_2 = float(input('Введите другое число: ')) ans = num_1 - num_2 values_entered = 2 print(f'Текущий результат: {ans}') while continue_calc.lower() == 'y': continue_calc = (input('Введите еще (y/n): ')) while continue_calc.lower() not in ['y', 'n']: print('Пожалуйста, введите \'y\' или \'n\'') continue_calc = (input('Введите еще (y/n): ')) if continue_calc.lower() == 'n': break num = float(input('Введите другое число: ')) ans -= num print(f'Текущий результат: {ans}') values_entered += 1 return [ans, values_entered]def multiplication(): os.system('cls' if os.name == 'nt' else 'clear') print('Умножение') continue_calc = 'y' num_1 = float(input('Введите число: ')) num_2 = float(input('Введите другое число: ')) ans = num_1 * num_2 values_entered = 2 print(f'Текущий результат: {ans}') while continue_calc.lower() == 'y': continue_calc = (input('Введите еще (y/n): ')) while continue_calc.lower() not in ['y', 'n']: print('Пожалуйста, введите \'y\' или \'n\'') continue_calc = (input('Введите еще (y/n): ')) if continue_calc.lower() == 'n': break num = float(input('Введите другое число: ')) ans *= num print(f'Текущий результат: {ans}') values_entered += 1 return [ans, values_entered]def division(): os.system('cls' if os.name == 'nt' else 'clear') print('Деление') continue_calc = 'y' num_1 = float(input('Введите число: ')) num_2 = float(input('Введите другое число: ')) while num_2 == 0.0: print('Пожалуйста, введите второе число > 0') num_2 = float(input('Введите другое число: ')) ans = num_1 / num_2 values_entered = 2 print(f'Текущий результат: {ans}') while continue_calc.lower() == 'y': continue_calc = (input('Введите еще (y/n): ')) while continue_calc.lower() not in ['y', 'n']: print('Пожалуйста, введите \'y\' или \'n\'') continue_calc = (input('Введите еще (y/n): ')) if continue_calc.lower() == 'n': break num = float(input('Введите другое число: ')) while num == 0.0: print('Пожалуйста, введите число > 0') num = float(input('Введите другое число: ')) ans /= num print(f'Текущий результат: {ans}') values_entered += 1 return [ans, values_entered]def calculator(): quit = False while not quit: results = [] print('Простой калькулятор на Python!') print('Введите \'a\' для сложения') print('Введите \'s\' для вычитания') print('Введите \'m\' для умножения') print('Введите \'d\' для деления') print('Введите \'q\' для выхода') choice = input('Выбор: ') if choice == 'q': quit = True continue if choice == 'a': results = addition() print('Результат = ', results[0], ' общее количество вводов: ', results[1]) elif choice == 's': results = subtraction() print('Результат = ', results[0], ' общее количество вводов: ', results[1]) elif choice == 'm': results = multiplication() print('Результат = ', results[0], ' общее количество вводов: ', results[1]) elif choice == 'd': results = division() print('Результат = ', results[0], ' общее количество вводов: ', results[1]) else: print('Извините, недопустимый символ')if __name__ == '__main__': calculator()10. Часы обратного отсчета и таймер
Это веселая идея для проекта на Python! Здесь мы создали обратный отсчет, который запрашивает у пользователя количество секунд с помощью ввода пользователя, а затем отсчитывает каждую секунду до вывода сообщения.
Мы используем функцию .sleep() модуля time для паузы в 1-секундных интервалах. Мы сочетаем это с форматированием строки для создания отображения обратного отсчета.
Исходный код:
'''Таймер обратного отсчета-------------------------------------------------------------'''import time
def обратный_отсчет(время):
while время >= 0:
минуты, секунды = divmod(время, 60)
таймер = '{:02d}:{:02d}'.format(минуты, секунды)
print(таймер, end='\r')
time.sleep(1)
время -= 1
print('Пуск!')
if __name__ == '__main__':
пользовательское_время = int(input("Введите время в секундах: "))
обратный_отсчет(пользовательское_время)Python-проекты с исходным кодом
11. Бинарный поиск
Бинарный поиск – это ритуал для всех начинающих разработчиков, которые хотят столкнуться с ним в одном из своих проектов на Python! Я знаю, когда я только начинал, некоторые из моих наиболее частых ошибок Python связаны с такими классическими алгоритмами, как этот.
Этот Python-проект для бинарного поиска принимает отсортированный список (массив) и затем постоянно сравнивает искомое значение со средним значением массива.
В зависимости от того, меньше или больше ли искомое значение среднего значения, список делится (стратегия “разделяй и властвуй”), чтобы уменьшить пространство поиска, сосредотачиваясь на заданном искомом значении. Это непрерывное деление приводит к логарифмической сложности по времени.
Если вы посмотрите на код ниже, вы увидите, что мы реализовали два решения: с условными циклами и рекурсией. Оба подхода элегантны, поэтому не стесняйтесь экспериментировать с каждым.
Если вы новичок в рекурсии, это отличное введение, так как оно демонстрирует, как мы ‘уменьшаем’ размер проблемы с каждым рекурсивным вызовом, а именно путем разделения списка на одну сторону текущего среднего элемента.
Мы также определили базовый случай рекурсии, когда средний элемент равен искомому элементу. В этом случае рекурсия остановится и вернет значение True через стек вызовов.
Если все это кажется вам чужим, рассмотрите использование чего-нибудь вроде GitHub Copilot, чтобы лучше понять этот классический алгоритм.
Исходный код:
'''Бинарный поиск-------------------------------------------------------------'''def бинарный_поиск(список, искомый_элемент):
первый = 0
последний = len(список) - 1
while первый <= последний:
средняя_точка = (первый + последний) // 2
if список[средняя_точка] == искомый_элемент:
return True
else:
if искомый_элемент < список[средняя_точка]:
последний = средняя_точка - 1
else:
первый = средняя_точка + 1
return False
def бинарный_поиск_рек(список, первый, последний, искомый_элемент):
if len(список) == 0:
return False
else:
средняя_точка = (первый + последний) // 2
if список[средняя_точка] == искомый_элемент:
return True
else:
if искомый_элемент < список[средняя_точка]:
последний = средняя_точка - 1
return бинарный_поиск_рек(список, первый, последний, искомый_элемент)
else:
первый = средняя_точка + 1
return бинарный_поиск_рек(список, первый, последний, искомый_элемент)
if __name__ == '__main__':
список = [1, 4, 7, 10, 14, 19, 102, 2575, 10000]
print('Бинарный поиск:', бинарный_поиск(список, 4))
print('Бинарный поиск (рекурсия):', бинарный_поиск_рек(список, 0, len(список) - 1, 4))12. Алгоритм сортировки слиянием
Сортировка слиянием – это еще одно популярное испытание для начинающих разработчиков, ищущих задачи на Python.
Эта стратегия “разделяй и властвуй” использует деление для разделения списка чисел на равные части, которые затем рекурсивно сортируются, прежде чем объединиться, чтобы сгенерировать отсортированный список.
Если вы только что закончили пример бинарного поиска, вы, возможно, заметите некоторые сходства с делением и уменьшением размера проблемы. Вы были правы, это означает, что вам нужно использовать рекурсию.
Эта реализация сортировки слиянием на языке Python использует рекурсию для обработки процесса разделения и покорения. Постоянное уменьшение размера проблемы позволяет решить проблему, когда достигается рекурсивный базовый случай, а именно когда размер проблемы составляет один элемент или меньше.
По сути, эта программа на Python продолжает рекурсивно делить список до достижения базового случая. В этот момент она начинает сортировать меньшие части проблемы, что приводит к получению меньших отсортированных массивов, которые объединяются для получения полностью отсортированного массива. Если вы знакомы с нотацией Big O, вам будет интересно знать, что сортировка слиянием имеет сложность O(n logn).
Исходный код:
'''Сортировка слиянием-------------------------------------------------------------'''def merge_sort(a_list): print("Деление ", a_list) if len(a_list) > 1: mid_point = len(a_list)//2 left_half = a_list[:mid_point] right_half = a_list[mid_point:] merge_sort(left_half) merge_sort(right_half) i=0 j=0 k=0 while i < len(left_half) and j < len(right_half): if left_half[i] <= right_half[j]: a_list[k] = left_half[i] i += 1 else: a_list[k] = right_half[j] j += 1 k += 1 while i < len(left_half): a_list[k] = left_half[i] i += 1 k += 1 while j < len(right_half): a_list[k] = right_half[j] j += 1 k += 1 print("Слияние ", a_list)if __name__ == '__main__': a_list = [45, 7, 85, 24, 60, 25, 38, 63, 1] merge_sort(a_list) print(a_list)13. Генератор паролей
Это интересный проект на языке Python, который использует модули secrets и string для генерации надежного и безопасного пароля, подобно тому, как это делают популярные менеджеры паролей.
Модуль string содержит все возможные буквы, цифры и специальные символы, а модуль secrets позволяет нам получить шифроустойчивые пароли.
Код для этого проекта довольно прост, поскольку он использует цикл для непрерывной генерации паролей, пока они не содержат как минимум один специальный символ и две цифры. Конечно, вы можете изменить это, чтобы соответствовать своим собственным требованиям к очень надежному паролю!
Исходный код:
'''Генератор паролей-------------------------------------------------------------'''import secretsimport stringdef create_pw(pw_length=12): letters = string.ascii_letters digits = string.digits special_chars = string.punctuation alphabet = letters + digits + special_chars pwd = '' pw_strong = False while not pw_strong: pwd = '' for i in range(pw_length): pwd += ''.join(secrets.choice(alphabet)) if (any(char in special_chars for char in pwd) and sum(char in digits for char in pwd) >= 2): pw_strong = True return pwdif __name__ == '__main__': print(create_pw())14. Конвертер валюты
Это одна из нескольких идей для проектов на языке Python, для реализации которых нам нужно установить одну из самых популярных библиотек Python, которая в данном случае является модулем requests. Он не включен в стандартную библиотеку Python, поэтому используйте команду pip, показанную в исходном коде, чтобы установить его на вашу систему.
С помощью модуля requests мы можем делать HTTP-запросы к API Fixer, что позволяет нам конвертировать одну валюту в другую. Вы, вероятно, заметите, что мы используем API сторонней компании, поэтому вам нужно будет зарегистрироваться, чтобы получить бесплатный API-ключ. Затем вы можете ввести свой API-ключ в соответствующее поле, показанное в исходном коде, и будете готовы к работе!
Этот проект позволяет вам получить больше практики с циклами и пользовательским вводом, но также расширяет это с помощью HTTP-запросов для получения данных из API в формате JSON.
Если вам незнаком формат JSON, он очень похож на словарь Python, что означает, что мы можем получить доступ к ключевым парам для получения нужных данных. В данном случае мы ищем результат конвертации валюты из вызова API.
Прочитайте документацию на сайте Fixer API для получения более подробной информации о различных данных, которые вы можете получить.
Исходный код:
'''Конвертер валюты-------------------------------------------------------------pip install requests'''import requestsdef convert_currency(): init_currency = input('Введите начальную валюту: ') target_currency = input('Введите целевую валюту: ') while True: try: amount = float(input('Введите сумму: ')) except: print('Сумма должна быть числом!') continue if not amount > 0: print('Сумма должна быть больше 0') continue else: break url = ('https://api.apilayer.com/fixer/convert?to=' + target_currency + '&from=' + init_currency + '&amount=' + str(amount)) payload = {} headers = {'apikey': 'ВАШ API-ключ'} response = requests.request('GET', url, headers=headers, data=payload) status_code = response.status_code if status_code != 200: print('Упс, возникла проблема. Пожалуйста, попробуйте позже') quit() result = response.json() print('Результат конвертации: ' + str(result['result']))if __name__ == '__main__': convert_currency()15. Автоматическая отправка поздравительных писем на день рождения
Этот проект на языке Python использует стандартные модули smtplib, EmailMessage и datetime, а также модули pandas и openpyxl (необходимо их установить при помощи pip, как показано ниже), для отправки автоматических поздравительных писем на день рождения.
Программа считывает данные из таблицы Excel, содержащей сведения о ваших друзьях (см. формат таблицы в исходном коде ниже). Затем она отправляет им электронное письмо, если сегодня их особенный день, и делает пометку в вашей таблице, чтобы указать, что они получили письмо.
Мы использовали модули smtplib и EmailMessage для создания защищенного подключения SSL к нашему почтовому аккаунту и сообщения. Затем мы использовали объект pandas dataframe для хранения данных в стиле таблицы внутри программы на Python (это необходимый навык для дата-саентистов). Наконец, мы использовали форматирование даты с помощью функции .strftime() модуля datetime.
Так что вам предстоит овладеть множеством новых навыков!
Важное примечание: с мая 2022 года Google ужесточил ограничения для “менее безопасных приложений”, которые получают доступ к Gmail. Вам потребуется выполнить дополнительные шаги, чтобы использовать этот код с вашей учетной записью Gmail. Но не беспокойтесь, они легко выполнимы, и мы перечислили их для вас.
- Перейдите на страницу “управление аккаунтом” вашей учетной записи Google
- Перейдите на вкладку “Безопасность”
- Включите двухфакторную аутентификацию (используйте любой метод, который вам нравится)
- Нажмите на “Пароли приложений”
- Нажмите на “Выбрать приложение” и выберите “Почта”
- Нажмите на “Выбрать устройство” и выберите “Другое (произвольное имя)”, введите “Python Birthday App”
- Нажмите на “Создать”, затем сохраните этот пароль
Теперь вы можете использовать этот пароль приложения в коде ниже для доступа к вашей учетной записи Gmail без проблем!
Исходный код:
'''Отправитель писем на день рождения-------------------------------------------------------------pip install pandas openpyxlexcel файл столбцы: Имя, E-mail, День рождения (мм/дд/гггг), Последнее отправлено (гггг)'''import pandas as pdfrom datetime import datetimeimport smtplibfrom email.message import EmailMessagedef send_email(recipient, subject, msg): GMAIL_ID = 'ваш_электронный_адрес_здесь' GMAIL_PWD = 'ваш_пароль_здесь' email = EmailMessage() email['Subject'] = subject email['From'] = GMAIL_ID email['To'] = recipient email.set_content(msg) with smtplib.SMTP_SSL('smtp.gmail.com', 465) as gmail_obj: gmail_obj.ehlo() gmail_obj.login(GMAIL_ID, GMAIL_PWD) gmail_obj.send_message(email) print('Письмо отправлено на ' + str(recipient) + ' с темой: \'' + str(subject) + '\' и сообщением: \'' + str(msg) + '\'')def send_bday_emails(bday_file): bdays_df = pd.read_excel(bday_file) today = datetime.now().strftime('%m-%d') year_now = datetime.now().strftime('%Y') sent_index = [] for idx, item in bdays_df.iterrows(): bday = item['День рождения'].to_pydatetime().strftime('%m-%d') if (today == bday) and year_now not in str(item['Последнее отправлено']): msg = 'С днем рождения, ' + str(item['Имя'] + '!!') send_email(item['E-mail'], 'С днем рождения', msg) sent_index.append(idx) for idx in sent_index: bdays_df.loc[bdays_df.index[idx], 'Последнее отправлено'] = str(year_now) bdays_df.to_excel(bday_file, index=False)if __name__ == '__main__': send_bday_emails(bday_file='ваш_список_дней_рождения.xlsx')16. Очередь
Этот проект на языке Python создает новый класс для реализации очереди. Очередь – это распространенная структура данных в компьютерной науке, которая используется при обработке сценариев “первым пришел – первым обслужен” (FIFO), таких как очереди сообщений, задач ЦПУ и т.д.
Код прост и предлагает дополнительную практику в объектно-ориентированном программировании. Попробуйте использовать очередь, чтобы разобраться, как она работает, и тогда вы будете готовы использовать эту структуру данных в других своих проектах.
Исходный код:
'''Структура данных Очередь-------------------------------------------------------------'''class Queue: def __init__(self): self.items = [] def __repr__(self): return f'Объект Очередь: данные={self.items}' def is_empty(self): return not self.items def enqueue(self, item): self.items.append(item) def dequeue(self): return self.items.pop(0) def size(self): return len(self.items) def peek(self): return self.items[0]if __name__ == '__main__': q = Queue() print(q.is_empty()) q.enqueue('Первый') q.enqueue('Второй') print(q) print(q.dequeue()) print(q) print(q.size()) print(q.peek())17. Треугольник Паскаля
Этот проект на Python выводит на экран треугольник Паскаля с использованием условных операторов и циклов. Он также использует функцию факториала из стандартной библиотеки math для вычисления уравнения «число сочетаний», которое используется для генерации значений в треугольнике.
Поэкспериментируйте с начальным числом для треугольника, чтобы исследовать, как уравнение «сочетаний» используется для генерации последовательных значений в треугольнике.
Исходный код:
'''Треугольник Паскаля-------------------------------------------------------------Число сочетаний через "n выбрать k" или nCk = n! / [k! * (n-k)!]'''from math import factorialdef pascal_triangle(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__': pascal_triangle(5)18. Блэкджек
Как один из самых интересных проектов на Python, эта игра будет интересна всем, кто любит карточные игры, так как мы эмулируем Блэкджек. Это очень популярная карточная игра с относительно простыми правилами: главное правило состоит в том, что чтобы выиграть, необходимо суммировать 21, или иметь более высокий счет, чем у дилера, не превышая 21 балл!
Это самый большой проект в этом списке. Он объединяет большую часть навыков, которые мы уже рассмотрели в предыдущих проектах, включая создание классов, циклы, условные операторы, импорт модулей, прием ввода пользователя и форматирование строк.
Сделайте перерыв, чтобы проработать разные разделы этого кода и сопоставить его с ранее рассмотренными проектами, чтобы увидеть, как разные техники объединяются вместе. Здесь нет ничего нового; все просто упаковано немного иначе и объединено для создания полностью функционального игрового эмулятора.
И мы должны сказать, попробуйте не проводить весь день, играя в это! Но мы полностью понимаем, если вы сделаете это!
Исходный код:
'''Блэкджек-------------------------------------------------------------'''import randomimport osclass Card: def __init__(self, card_face, value, symbol): self.card_face = card_face self.value = value self.symbol = symboldef show_cards(cards, hidden): s = '' for card in cards: s = s + '\t ________________' if hidden: s += '\t ________________' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| |' print(s) s = '' for card in cards: if card.card_face in ['J', 'Q', 'K', 'A']: s = s + '\t| {} |'.format(card.card_face) elif card.value == 10: s = s + '\t| {} |'.format(card.value) else: s = s + '\t| {} |'.format(card.value) if hidden: s += '\t| |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * * |' print(s) s = '' for card in cards: s = s + '\t| {} |'.format(card.symbol) if hidden: s += '\t| * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| * |' print(s) s = '' for card in cards: s = s + '\t| |' if hidden: s += '\t| |' print(s) s = '' for card in cards: if card.card_face in ['J', 'Q', 'K', 'A']: s = s + '\t|19. Реддит Бот
Этот проект на Python создает автоматического реддит бота с использованием новых модулей, а именно praw и enchant (см. команды pip install).
Концепция довольно проста: программа проверяет каждый комментарий в выбранном субреддите и отвечает на комментарии, содержащие заданную "условную фразу". Для этого мы используем модуль praw для взаимодействия с реддитом и enchant для генерации похожих слов на комментарий, что позволяет нам составить соответствующий ответ.
Эта идея действительно полезна, если вы ищете проекты на Python для изучения, как отвечать на вопросы в своем собственном субреддите. Вам просто нужно расширить этот код, чтобы включить автоматические ответы на заранее заданные вопросы (вы, наверное, уже заметили, что это используется другими на реддите!).
Важное замечание: Вам нужно ознакомиться с этими инструкциями, чтобы получить client_id, client_secret, username, password и user_agent. Вам понадобится эта информация для отправки комментариев на реддит через API интерфейс.
Исходный код:
'''Reddit Reply Bot-------------------------------------------------------------
pip install praw pyenchant'''import prawimport enchantdef reddit_bot(sub, trigger_phrase): reddit = praw.Reddit( client_id='your_client_id', client_secret='your_client_secret', username='your_username', password='your_pw', user_agent='your_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='useful bot')
20. Генератор Фибоначчи
Числа Фибоначчи могут быть одними из самых важных чисел в нашей жизни, так как они так часто встречаются в природе.
Ниже приведен код на Python, генерирующий числа Фибоначчи до определенной длины с использованием рекурсии (да, еще рекурсия!). Чтобы предотвратить рост времени вычислений, мы реализовали мемоизацию для кэширования значений по мере их вычисления.
Вы заметите, что для этого рекурсивного алгоритма базовый случай устанавливается для проверки, уже ли заданное значение последовательности Фибоначчи сохранено в кэше. Если да, то он возвращает это значение (что является операцией постоянного времени), что позволяет сэкономить огромное количество времени вычислений.
Исходный код:
'''Fibonacci Sequence-------------------------------------------------------------
'''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('======== Fibonacci Series ========') for i in range(1, 11): print(f'Fibonacci ({i}) : {fib_memo(i)}')
Идеи продвинутых проектов на Python
21. Чатбот
Этот проект на Python использует модуль chatterbot (см. инструкции по установке pip ниже), чтобы обучить автоматический чатбот отвечать на любые ваши вопросы! Знаете ли вы, мы теперь используем искусственный интеллект!
Вы заметите, что программа представляет собой один из относительно небольших проектов на Python в этом списке, но не стесняйтесь изучать документацию ChatterBot, а также широкую область чатботов на основе искусственного интеллекта, если вы хотите узнать больше или расширить возможности кода.
Если это разжигает ваш интерес к созданию чатботов на основе искусственного интеллекта, ознакомьтесь с нашим Курсом по созданию чатбота на Python за 24 часа, чтобы научиться создавать чатбот, работающий на искусственном интеллекте, с использованием тех же инструментов, которые использованы в ChatGPT от OpenAI.
И если вы хотите еще больше искусственного интеллекта, ознакомьтесь с последней новинкой от OpenAI, которая позволяет вам создать свой собственный GPT.
Важное замечание: ChatterBot больше не поддерживается активно. Это означает, что вам нужно внести небольшое изменение в файл tagging.py, расположенный в папке 'Lib/site-packages/chatterbot' вашей установки Python.
Не волнуйтесь, это легко сделать, и мы включили точный исходный код, который вам нужно использовать, как показано ниже.
Исходный код:
'''Чат-бот-------------------------------------------------------------1) pip install ChatterBot chatterbot-corpus spacy2) python3 -m spacy download en_core_web_sm Или... выберите предпочитаемый вами язык3) Перейдите в свой каталог Python34) Измените Lib/site-packages/chatterbot/tagging.py, чтобы корректно загрузить '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()
Измените tagging.py:
Найдите первый фрагмент кода, который является частью метода __init__ класса PosLemmaTagger. Замените его на выражение if/else.
Примечание: этот пример для английской библиотеки, которую мы использовали в нашем примере, но не стесняйтесь заменить ее на другой язык, если хотите.
# Заменить это:self.nlp = spacy.load(self.language.ISO_639_1.lower())# На это: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. Текст в речь
Этот проект на Python использует целый набор новых библиотек для преобразования существующей статьи в файл mp3, который можно воспроизводить. Вам потребуется установить nltk (инструменты естественного языка), newspaper3k и gtts (см. инструкции по установке pip).
Вы увидите, что программа проста, поскольку мы просто передаем URL-адрес статьи для преобразования, а затем позволяем функции, которую мы определили, обрабатывать преобразование текста в речь с нашими новыми установленными модулями.
Так что попробуйте это, если вам хочется превратить статью в воспроизводимый подкаст, это определенно одна из крутых Python-программ для копирования!
Исходный код:
'''Текст в речь-------------------------------------------------------------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. Система управления библиотекой
Как один из более сложных проектов на Python, этот программный продукт использует объектно-ориентированное программирование для моделирования системы управления библиотекой.
В этом примере мы создаем классы Library и Student, которые мы можем использовать для создания нашей системы библиотеки и ее пользователей. Затем мы реализовали простой пользовательский интерфейс, который запрашивает у пользователей выбор из ряда стандартных библиотечных действий, таких как взять или вернуть книги.
Это простой, но мощный пример того, как вы можете создавать реальные системы с помощью Python и объектно-ориентированного программирования. Не стесняйтесь расширять классы, добавляя другие полезные функции, такие как уникальные идентификаторы книг, несколько копий одной книги, даты возврата, штрафы за задержку возврата книг и любые другие функции, которые, по вашему мнению, должны быть в библиотеке!
Исходный код:
'''Библиотека-------------------------------------------------------------'''class Library: def __init__(self, books): self.books = books def show_avail_books(self): print('Наша библиотека может предложить вам следующие книги:') print('================================================') for book, borrower in self.books.items(): if borrower == 'Свободно': print(book) def lend_book(self, requested_book, name): if self.books[requested_book] == 'Свободно': print( f'{requested_book} была отмечена' f' как \'Взятая\' пользователем: {name}') self.books[requested_book] = name return True else: print( f'Извините, книга {requested_book}' f' в данный момент находится на руках у: {self.books[requested_book]}') return False def return_book(self, returned_book): self.books[returned_book] = 'Свободно' print(f'Спасибо за возврат {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('Вы не брали книги в библиотеке') else: for book in self.books: print(book) def request_book(self): book = input( 'Введите название книги, которую вы хотите взять >> ') if self.library.lend_book(book, self.name): self.books.append(book) def return_book(self): book = input( 'Введите название книги, которую вы хотите вернуть >> ') if book in self.books: self.library.return_book(book) else: print('Вы не брали эту книгу, попробуйте другую...')def create_lib(): books = { 'Последняя битва': 'Свободно', 'Голодные игры': 'Свободно', 'Взлом кодировочного собеседования': 'Свободно' } library = Library(books) student_example = Student('Ваше имя', library) while True: print(''' ==========МЕНЮ БИБЛИОТЕКИ=========== 1. Отобразить доступные книги 2. Взять книгу в аренду 3. Вернуть книгу 4. Просмотр взятых книг 5. Выход''' ) choice = int(input('Введите выбор: ')) 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('До свидания') exit()if __name__ == '__main__': create_lib()
24. Игра "Понг" в стиле аркады
Это действительно забавный и интересный проект, в котором мы использовали модуль Python turtle для эмуляции классической аркадной игры "Понг"!
Мы использовали различные методы из модуля turtle для создания компонентов игры и обнаружения столкновений мяча с платформами игроков. Мы также определили набор клавиш для управления платформами игроков влево и вправо. Не стесняйтесь экспериментировать с настройками игры, чтобы лучше понять, как каждая настройка работает и влияет на игру в целом.
Помимо новых графических функций turtle, мы использовали форматирование строк для вывода текущего счета и пользовательских функций для сохранения чистоты нашего кода. Это понятия, которым вы должны быть знакомы на данном этапе.
Исходный код:
'''Pong Arcade Game-------------------------------------------------------------'''
import turtle
def update_score(l_score, r_score, player, score_board):
if player == 'l':
l_score += 1
else:
r_score += 1
score_board.clear()
score_board.write('Левый Игрок: {} -- Правый Игрок: {}'.format(
l_score, r_score), align='center',
font=('Arial', 24, 'normal'))
return l_score, r_score, score_board
def setup_game():
screen = turtle.Screen()
screen.title('Аркадная игра "Понг"')
screen.bgcolor('white')
screen.setup(width=1000, height=600)
l_paddle = turtle.Turtle()
l_paddle.speed(0)
l_paddle.shape('square')
l_paddle.color('red')
l_paddle.shapesize(stretch_wid=6, stretch_len=2)
l_paddle.penup()
l_paddle.goto(-400, 0)
r_paddle = turtle.Turtle()
r_paddle.speed(0)
r_paddle.shape('square')
r_paddle.color('black')
r_paddle.shapesize(stretch_wid=6, stretch_len=2)
r_paddle.penup()
r_paddle.goto(400, 0)
ball = turtle.Turtle()
ball.speed(40)
ball.shape('circle')
ball.color('blue')
ball.penup()
ball.goto(0, 0)
ball.dx = 5
ball.dy = -5
score_board = turtle.Turtle()
score_board.speed(0)
score_board.color('blue')
score_board.penup()
score_board.hideturtle()
score_board.goto(0, 260)
score_board.write('Левый Игрок: 0 -- Правый Игрок: 0',
align='center', font=('Arial', 24, 'normal'))
return screen, ball, l_paddle, r_paddle, score_board
def pong_game():
game_components = setup_game()
screen = game_components[0]
ball = game_components[1]
l_paddle = game_components[2]
r_paddle = game_components[3]
score_board = game_components[4]
l_score = 0
r_score = 0
def l_paddle_up():
l_paddle.sety(l_paddle.ycor() + 20)
def l_paddle_down():
l_paddle.sety(l_paddle.ycor() - 20)
def r_paddle_up():
r_paddle.sety(r_paddle.ycor() + 20)
def r_paddle_down():
r_paddle.sety(r_paddle.ycor() - 20)
screen.listen()
screen.onkeypress(l_paddle_up, 'e')
screen.onkeypress(l_paddle_down, 'x')
screen.onkeypress(r_paddle_up, 'Up')
screen.onkeypress(r_paddle_down, 'Down')
while True:
screen.update()
ball.setx(ball.xcor()+ball.dx)
ball.sety(ball.ycor()+ball.dy)
if ball.ycor() > 280:
ball.sety(280)
ball.dy *= -1
if ball.ycor() 500:
ball.goto(0, 0)
ball.dy *= -1
l_score, r_score, score_board = update_score(
l_score, r_score, 'l', score_board)
continue
elif ball.xcor() 360) and
(ball.xcor() < 370) and
(ball.ycor() r_paddle.ycor()-40)):
ball.setx(360)
ball.dx *= -1
if ((ball.xcor() -370) and
(ball.ycor() l_paddle.ycor()-40)):
ball.setx(-360)
ball.dx *= -1
if __name__ == '__main__':
pong_game()
25. Тест скорости печати
Это интересный проект на языке Python, который проверяет, насколько быстро вы можете точно набрать предложение.
Эта программа требует создания графического пользовательского интерфейса (GUI) с помощью модуля tkinter. Если вы новичок в GUI, это пример хорошего введения, так как мы используем несколько простых ярлыков, кнопок и полей ввода для создания окна. Мы также использовали модуль времени Python timeit для обработки времени выполнения нашего теста набора, и модуль random для случайного выбора фразы для теста.
В этом примере мы добавили всего две фразы для теста, но не стесняйтесь экспериментировать с большим количеством или даже интегрировать сторонний словарь для более широкого спектра примеров.
Исходный код:
'''Тест скорости печати-------------------------------------------------------------'''import tkinterfrom timeit import default_timer as timerimport randomdef скоростной_тест(): скоростной_тест_предложения = [ 'Это случайное предложение для проверки скорости.', 'Скорость, я Молния МакКуин.' ] предложение = random.choice(скоростной_тест_предложения) старт = timer() главное_окно = tkinter.Tk() главное_окно.geometry('600x400') ярлык_1 = tkinter.Label(главное_окно, text=предложение, font='times 20') ярлык_1.place(x=150, y=10) ярлык_2 = tkinter.Label(главное_окно, text='Начните печатать', font='times 20') ярлык_2.place(x=10, y=50) поле_ввода = tkinter.Entry(главное_окно) поле_ввода.place(x=280, y=55) def проверить_результат(): if поле_ввода.get() == предложение: конец = timer() ярлык_3.configure(text=f'Время: {round((конец-старт), 4)}с') else: ярлык_3.configure(text='Неправильный ввод') кнопка_1 = tkinter.Button(главное_окно, text='Готово', command=проверить_результат, width=12, bg='grey') кнопка_1.place(x=150, y=100) кнопка_2 = tkinter.Button(главное_окно, text='Попробовать снова', command=скоростной_тест, width=12, bg='grey') кнопка_2.place(x=250, y=100) ярлык_3 = tkinter.Label(главное_окно, text='', font='times 20') ярлык_3.place(x=10, y=300) главное_окно.mainloop()if __name__ == '__main__': скоростной_тест()
26. Текстовый редактор
Продолжая наш предыдущий пример с tkinter, этот увлекательный проект на языке Python создает графический интерфейс пользователя для имитации собственного текстового редактора. В этом примере также используются стандартные компоненты GUI, включая ярлыки, кнопки и поля ввода.
Однако, мы также добавили возможность открытия и сохранения файлов, как в настоящем текстовом редакторе. Если вы незнакомы с обработкой файлов, этот проект на Python - отличный способ понять, как читать и сохранять файлы.
Экспериментируйте с приведенным ниже кодом, чтобы укрепить свои знания и посмотреть, сможете ли вы расширить этот код для создания других функций, которыми обычно пользуются в текстовом редакторе, например, функции "найти слово".
Исходный код:
'''Текстовый редактор-------------------------------------------------------------'''import tkinter as tkfrom tkinter.filedialog import askopenfilename, asksaveasfilenamedef текстовый_редактор(): def открыть_файл(): путь_к_файлу = askopenfilename( filetypes=[('Text Files', '*.txt'), ('All Files', '*.*')] ) if not путь_к_файлу: return txt_edit.delete(1.0, tk.END) with open(путь_к_файлу, 'r') as входной_файл: текст = входной_файл.read() txt_edit.insert(tk.END, текст) window.title(f'Текстовый редактор - {путь_к_файлу}') def сохранить_файл(): путь_к_файлу = asksaveasfilename( defaultextension='txt', filetypes=[('Text Files', '*.txt'), ('All Files', '*.*')], ) if not путь_к_файлу: return with open(путь_к_файлу, 'w') as выходной_файл: текст = txt_edit.get(1.0, tk.END) выходной_файл.write(текст) window.title(f'Текстовый редактор - {путь_к_файлу}') window = tk.Tk() window.title('Текстовый редактор') window.rowconfigure(0, minsize=800, weight=1) window.columnconfigure(1, minsize=800, weight=1) txt_edit = tk.Text(window) fr_buttons = tk.Frame(window, relief=tk.RAISED, bd=2) btn_open = tk.Button(fr_buttons, text='Открыть', command=открыть_файл) btn_save = tk.Button(fr_buttons, text='Сохранить как...', command=сохранить_файл) btn_open.grid(row=0, column=0, sticky='ew', padx=5, pady=5) btn_save.grid(row=1, column=0, sticky='ew', padx=5) fr_buttons.grid(row=0, column=0, sticky='ns') txt_edit.grid(row=0, column=1, sticky='nsew') window.mainloop()if __name__ == '__main__': текстовый_редактор()
27. Решатель Судоку
Этот проект на Python использует библиотеку pygame (см. инструкцию по установке pip) для реализации графического интерфейса автоматического решения судоку. Мы используем несколько пользовательских функций, чтобы создать GUI, как показано ниже.
Для решения судоку эт программа использует алгоритм возврата, который последовательно проверяет возможные решения, принимая или отказываясь от текущего решения, если оно не является жизнеспособным.
Отказ от решения является определяющей чертой подхода возврата, поскольку программа возвращается, чтобы попробовать новое решение, пока не найдет действительное. Этот процесс последовательно выполняется, пока всю сетку не заполнено правильно.
Не стесняйтесь экспериментировать с разными судоку, и даже подумайте о расширении размера сетки проблемы (вам понадобится новое базовое изображение, если вы это сделаете).
Исходный код:
'''Sudoku Solver-------------------------------------------------------------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('SUDOKU SOLVER USING BACKTRACKING')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# Default Sudoku Boardgrid = [ [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 get_coord(pos): x = pos[0] // dif y = pos[1] // difdef draw_box(): 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 draw(): 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 draw_val(val): text1 = font1.render(str(val), 1, (0, 0, 0)) screen.blit(text1, (x * dif + 15, y * dif + 15))def raise_error_1(): text1 = font1.render('WRONG !!!', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def raise_error_2(): text1 = font1.render('Wrong !!! Not a valid Key', 1, (0, 0, 0)) screen.blit(text1, (20, 570))def valid(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 solve(grid, i, j): while grid[i][j] != 0: if i < 8: i += 1 elif i == 8 and j < 8: i = 0 j +=28. Проверка подключения к сайту
Этот проект на Python использует модули urllib и tkinter для проверки подключения к веб-сайту.
Мы использовали модуль tkinter для создания графического интерфейса, позволяющего пользователям вводить веб-адрес. Подобно нашим предыдущим примерам, включены метки, кнопки и поля ввода.
После того, как мы получим веб-адрес пользователя, мы передаем его в нашу пользовательскую функцию, чтобы получить код состояния HTTP для текущего веб-сайта с помощью функции .getcode() модуля urllib.
В этом примере мы просто определяем, является ли код HTTP равным 200. Если да, то мы знаем, что сайт работает; в противном случае, мы информируем пользователя о его недоступности.
Можно расширить этот код для учета более детального подхода к обработке различных кодов ответа HTTP, так что не стесняйтесь добавить это!
Исходный код:
'''Проверка подключения к сайту-------------------------------------------------------------Введите веб-адреса в формате http(s)://www.yourwebsite.com'''import urllib.requestimport tkinter as tkdef test_connectivity(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='Проверка подключения к сайту', 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='Сайт доступен', font=('Calibri 15')).place(x=260, y=200) else: tk.Label(window, text='Сайт недоступен', 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='Проверить', command=check_url).place(x=285, y=150) window.mainloop()if __name__ == '__main__': test_connectivity()
29. Определитель языка
Этот проект на Python использует модуль langdetect (см. инструкции по установке через pip) для определения введенного языка. Это может быть действительно полезно, если вы не уверены, с каким языком вы имеете дело.
Это еще один пример, в котором мы использовали tkinter для создания простого графического интерфейса с метками, кнопками и полем ввода. Затем мы можем получить текст из поля ввода и обработать его с помощью langdetect для определения введенного языка. Наконец, мы выводим результат на графический интерфейс, чтобы пользователь узнал результат.
Обратите внимание, что результаты, возвращаемые langdetect, представлены в виде сокращенных кодов языков. Например, если мы вводим текст на английском, мы увидим 'en' как возвращаемое значение.
Исходный код:
'''Определитель языка-------------------------------------------------------------pip install langdetect'''from langdetect import detectimport tkinter as tkdef detect_lang(): window = tk.Tk() window.geometry('600x400') head = tk.Label(window, text='Определитель языка', 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='Определить язык', command=check_language).place(x=285, y=150) window.mainloop()if __name__ == '__main__': detect_lang()
30. Система рекомендаций Netflix
Наконец, мы сохранили особенно захватывающий проект на Python для последнего места! Это система рекомендаций Netflix, идеальная для начинающих дата-сайентистов. Фактически, если вы планируете пройти курс машинного обучения, это отличный проект для закрепления ваших новых навыков.
Для создания этого проекта вам потребуются импортировать ряд модулей, включая tkinter, re, nltk, pandas и numpy (см. инструкции по установке через pip для новых модулей). Вам также потребуется скачать набор данных Kaglge, содержащий фильмы и телешоу Netflix.
Мы будем использовать tkinter для создания графического интерфейса, который будет использовать метки, кнопки и поля ввода. Пользователь сможет ввести телешоу или фильм, который он полюбил на Netflix, и получить рекомендации на основе своих предпочтений.
Система рекомендаций использует актеров, режиссеров, рейтинги, страну и жанры как 'функции' машинного обучения. Затем код использует подход 'косинусного сходства' для нахождения похожих результатов на основе ввода пользователя. Для очистки данных и их подготовки к обработке в большой степени используются pandas и numpy.
В этом примере много всего, поскольку он использует множество понятий Python для науки о данных.
Лучший подход заключается в медленном прохождении кода и дальнейшем проведении исследований по машинному обучению (ML), "признакам" и "косинусной схожести".
После этого вы сможете понять, как использовать набор данных для получения рекомендаций на основе сходства. Если вы стремитесь стать учёным-исследователем данных, это отличный проект, чтобы попробовать свои силы!
Исходный код:
'''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', \s*', i) countries_2.append(country2)flat_list_6 = []for sublist in countries_2: for item in sublist: flat_list_6.append(item)countries_list_2 = sorted(set(flat_list_6))binary_countries_2 = [[0] * 0 for i in range(len(set(flat_list_6)))]for i in tv['Production Country']: k = 0 for j in countries_list_2: if
С чего начать с Python
Сегодня мы сталкиваемся с все более широким применением искусственного интеллекта (AI), машинного обучения (ML) и науки о данных в большинстве бизнес-секторов. Одной из основных вещей, объединяющих эти области, является использование языка программирования Python в одной форме или другой.
Когда дело доходит до изучения Python в 2023 году, у вас есть так много выборов, будь то создание проектов на Python, перечисленных нами, или поиск полезных Python-уроков.
Кроме того, если вы предпочитаете углубленный и интерактивный опыт обучения, мы также рекомендуем наш новый курс по Python.
В заключение
И вот вам. 30 интересных и захватывающих Python-проектов с исходным кодом, начиная от простых до продвинутых.
Независимо от того, что вам хотелось бы создать, наши Python-проекты должны иметь что-то для вас, так как мы включили игры, объектно-ориентированное программирование, графический интерфейс пользователя, искусственный интеллект (AI), машинное обучение (ML), API, ботов, модули стандартной библиотеки и несколько сторонних библиотек.
И одно, что есть у каждого из наших Python-проектов в общем, это то, что они требуют от вас применения теоретических навыков на практике. Это отличный способ проверить себя и улучшить свои навыки программирования на Python, на пути к становлению лучшим практикующим программистом.
Научились справляться с этими Python-проектами и готовы погрузиться еще глубже в Python? Ознакомьтесь с:
Часто задаваемые вопросы
1. Подходит ли Python для больших проектов?
Хотя можно спорить о том, что Python медленнее других популярных языков, таких как C и C++, Python все равно широко используется многими ведущими технологическими компаниями, потому что он очень гибкий, легко поддерживаемый и предлагает множество библиотек и поддержки со стороны сообщества.
2. С какого проекта на Python лучше начать?
Ознакомьтесь с любым из рассмотренных выше начальных проектов на Python, включая "Mad Libs", "Камень, ножницы, бумага", "Виселица" или "Крестики-нолики"!
Люди также читают:
- Вопросы на собеседовании по Python
- Руководство по веб-скрапингу на Python
- Фреймворки Python
- Цикл while в Python
- Операторы "is" и "==" в Python
- Условные операторы в Python
- Python RegEx Cheat Sheet
- Интерпретаторы Python
Leave a Reply