0
Более 30 лучших проектов на Python от новичка до профессионала с кодом [2024]
Если бы я мог вернуться в прошлое и помочь своим молодым коллегам выучить Python, я бы посоветовал им создавать больше проектов на Python!
Именно поэтому я написал эту статью: чтобы поделиться 30 проектами на Python, которые помогут таким программистам, как вы.
Независимо от того, хотите ли вы начать карьеру в области разработки на Python или расширить свое портфолио, эти проекты на Python идеально подойдут для повышения уровня ваших навыков работы с Python.
Я лично разработал каждый из этих проектов на Python, включая ряд пошаговых руководств, так что вы можете следовать за мной, чтобы освоить их на практике и написать несколько интересных текстов.
Вы можете рассматривать эти обучающие проекты как прохождение бесплатного курса Python и одновременно расширять свое портфолио по Python!
Я также регулярно добавляю новые проекты на Python с пошаговыми руководствами, поэтому обязательно добавьте эту страницу в закладки и следите за последними проектами на Python, чтобы развить свои навыки.
Без лишних слов, давайте погрузимся в работу и начнем создавать с помощью Python!
Кроме того, если вам нужна дополнительная помощь, я также выпустил свой собственный курс "Python с доктором Джонсом", в котором я применяю академический подход к преподаванию, а также создаю проекты на Python, достойные портфолио.
Лучшие проекты на Python для начинающих в 2024 году
Игра-палач на Python с графическим интерфейсом
Игра Python Hangman сочетает в себе удовольствие и практичность, что делает ее отличным проектом как для обучения, так и для демонстрации ваших навыков программирования. С помощью Tkinter для графического интерфейса и ООП для структуры вы можете создать игру, которая будет интерактивной и масштабируемой.
Хотите узнать, как Python может оживить игры и одновременно улучшить ваши навыки программирования? Присоединяйтесь и начинайте создавать этот проект Python hangman.
Как создать приложение для организации файлов на Python
Устали от загроможденной папки для загрузки? Файловый органайзер на Python - это идеальный проект, который упростит вашу жизнь и повысит ваши навыки программирования. Используя операционную систему Python и модули shutil, вы научитесь автоматизировать сортировку файлов по таким категориям, как изображения, видео и документы. Он удобен для начинающих, практичен и знакомит вас с обработкой файлов, управлением каталогами и автоматизацией.
Хотите упростить свой рабочий процесс и освоить автоматизацию на Python? Попробуйте свои силы в создании этого приложения для организации файлов на Python.
Как создать приложение для конвертации единиц измерения на Python с графическим интерфейсом
Приложение Python unit converter - это отличный проект для начинающих, который поможет освоить графическое программирование с помощью tkinter и практические навыки работы на Python. Это позволяет создать удобный инструмент для преобразования таких единиц измерения, как мили в километры или градусы Фаренгейта в градусы Цельсия, а также внедрить такие ключевые понятия, как повторно используемые функции, динамические обновления пользовательского интерфейса и базовые математические операции.
Хотите получить практический способ отточить свои навыки работы с Python и создать что-то, что вы сможете использовать ежедневно? Погрузитесь в работу и создайте свое собственное приложение для конвертации единиц измерения на Python.
Как создать приложение для создания QR-Кода на Python
Генератор QR-кодов на Python - это увлекательный и практичный проект, который повысит ваши навыки в разработке графического интерфейса пользователя и обработке изображений. Используя такие библиотеки, как qrcode, tkinter и Pillow, вы создадите удобное приложение для генерации QR-кодов для URL-адресов, контактной информации или секретных сообщений всего несколькими щелчками мыши.
Хотите совместить креативность с программированием и создать что-то полезное? Попробуйте создать это приложение с QR-кодом на Python.
Генератор безумных библиотек
Это один из самых увлекательных проектов на Python для начинающих, не говоря уже о том, что он позволяет вам попрактиковаться в использовании строк, переменных и конкатенации, которые являются необходимыми навыками для всех приложений на Python на всех уровнях квалификации.
Генератор Mad Libs собирает и обрабатывает введенные пользователем данные в виде прилагательных, местоимений и глаголов. Программа использует эти данные и упорядочивает их для создания истории.
исходный код:
'''
Mad Libs Generator
-------------------------------------------------------------
'''
# Questions for the user to answer
noun = input('Choose a noun: ')
p_noun = input('Choose a plural noun: ')
noun2 = input('Choose a noun: ')
place = input('Name a place: ')
adjective = input('Choose an adjective (Describing word): ')
noun3 = input('Choose a noun: ')
# Print a story from the user input
print('------------------------------------------')
print('Be kind to your', noun, '- footed', p_noun)
print('For a duck may be somebody\'s', noun2, ',')
print('Be kind to your', p_noun, 'in', place)
print('Where the weather is always', adjective, '. \n')
print('You may think that is this the', noun3, ',')
print('Well it is.')
print('------------------------------------------')
Угадывание чисел
Этот проект для начинающих на Python представляет собой забавную игру, в которой генерируется случайное число (в определенном диапазоне), которое пользователь должен угадать после получения подсказок. За каждое неверное предположение пользователь получает дополнительные подсказки, но ценой ухудшения его итогового результата.
Эта программа - отличный способ поэкспериментировать со стандартной библиотекой Python, поскольку она использует модуль Python random для генерации случайных чисел. Вы также можете попрактиковаться в работе с условными выражениями, форматированием печати, пользовательскими функциями и различными операторами Python.
исходный код:
'''
Number Guessing Game
-------------------------------------------------------------
'''
import random
def show_score(attempts_list):
if not attempts_list:
print('There is currently no best score,'
' it\'s yours for the taking!')
else:
print(f'The current best score is'
f' {min(attempts_list)} attempts')
def start_game():
attempts = 0
rand_num = random.randint(1, 10)
attempts_list = []
print('Hello traveler! Welcome to the game of guesses!')
player_name = input('What is your name? ')
wanna_play = input(
f'Hi, {player_name}, would you like to play '
f'the guessing game? (Enter Yes/No): ')
if wanna_play.lower() != 'yes':
print('That\'s cool, Thanks!')
exit()
else:
show_score(attempts_list)
while wanna_play.lower() == 'yes':
try:
guess = int(input('Pick a number between 1 and 10: '))
if guess < 1 or guess > 10:
raise ValueError(
'Please guess a number within the given range')
attempts += 1
if guess == rand_num:
attempts_list.append(attempts)
print('Nice! You got it!')
print(f'It took you {attempts} attempts')
wanna_play = input(
'Would you like to play again? (Enter Yes/No): ')
if wanna_play.lower() != 'yes':
print('That\'s cool, have a good one!')
break
else:
attempts = 0
rand_num = random.randint(1, 10)
show_score(attempts_list)
continue
else:
if guess > rand_num:
print('It\'s lower')
elif guess < rand_num:
print('It\'s higher')
except ValueError as err:
print('Oh no!, that is not a valid value. Try again...')
print(err)
if __name__ == '__main__':
start_game()Камень, ножницы, бумага
Эта программа "Камень, ножницы, бумага" имитирует популярную во всем мире игру с функциями и условными выражениями. Итак, что может быть лучше для того, чтобы освоить эти важнейшие понятия? Вы также будете использовать список Python для хранения коллекции допустимых ответов, которые затем можно использовать для создания элегантного условного выражения на языке Python.
Как один из многих проектов программирования на Python, который импортирует дополнительные библиотеки, эта программа использует модули random, os и re стандартной библиотеки.
Взгляните на приведенный ниже код, и вы увидите, что в этом Python project idea пользователю предлагается сделать первый ход, введя символ, обозначающий камень, ножницы или бумагу. После оценки входной строки условная логика определяет победителя.
Обновлено! Недавно я обновил этот проект на python "камень, ножницы, бумага", включив в него систему подсчета очков. Она отслеживает счет пользователя и счет компьютера. Она также отображает этот счет между раундами и в конце игры.
Здесь есть еще одно обновление. Я хотел добавить одну букву "Y" для тех, кто хочет продолжать играть. Раньше нужно было вводить "да". Я отказался от возможности использовать "N" вместо "нет". Это простая задача для тех, кто хочет улучшить мой проект на python "камень, ножницы, бумага".
исходный код:
'''
Rock Paper Scissors
-------------------------------------------------------------
'''
import random
import os
import re
def check_play_status():
valid_responses = ['yes', 'no', 'y']
while True:
try:
response = input('Do you wish to play again? (Yes or No): ')
if response.lower() not in valid_responses:
raise ValueError('Yes or No only')
if response.lower() == 'yes':
return True
elif response.lower() =='y':
return True
else:
os.system('cls' if os.name == 'nt' else 'clear')
print('Thanks for playing!')
print(f'Final Score - You: {user_score}, Computer: {computer_score}')
exit()
except ValueError as err:
print(err)
def play_rps():
user_score = 0
computer_score = 0
play = True
while play:
os.system('cls' if os.name == 'nt' else 'clear')
print('')
print('Rock, Paper, Scissors - Shoot!')
user_choice = input('Choose your weapon'
' [R]ock], [P]aper, or [S]cissors: ')
if not re.match("[SsRrPp]", user_choice):
print('Please choose a letter:')
print('[R]ock, [P]aper, or [S]cissors')
continue
print(f'You chose: {user_choice}')
choices = ['R', 'P', 'S']
opp_choice = random.choice(choices)
print(f'I chose: {opp_choice}')
if opp_choice == user_choice.upper():
print('Tie!')
print(f'Score - You: {user_score}, Computer: {computer_score}')
play = check_play_status()
elif opp_choice == 'R' and user_choice.upper() == 'S':
print('Rock beats scissors, I win!')
computer_score += 1
print(f'Score - You: {user_score}, Computer: {computer_score}')
play = check_play_status()
elif opp_choice == 'S' and user_choice.upper() == 'P':
print('Scissors beats paper! I win!')
computer_score += 1
print(f'Score - You: {user_score}, Computer: {computer_score}')
play = check_play_status()
elif opp_choice == 'P' and user_choice.upper() == 'R':
print('Paper beats rock, I win!')
computer_score +=1
print(f'Score - You: {user_score}, Computer: {computer_score}')
play = check_play_status()
else:
print('You win!\n')
user_score += 1
print(f'Score - You: {user_score}, Computer: {computer_score}')
play = check_play_status()
if __name__ == '__main__':
play_rps()
Генератор бросков кубиков
Являясь одним из наиболее удобных проектов на Python для начинающих программистов, эта программа имитирует бросание одного или двух кубиков. Это также отличный способ углубить ваше понимание пользовательских функций, циклов и условных операторов. Это фундаментальные навыки для начинающих Python, и, вероятно, они станут одними из первых, чему вы научитесь, будь то из онлайн-курса или книги по Python.
Как один из наших простых проектов на Python, это довольно простая программа, которая использует модуль Python random для воспроизведения случайного характера бросания кубиков. Вы также заметите, что мы используем модуль операционной системы для очистки экрана после того, как вы бросили кости.
Обратите внимание, что вы можете изменить максимальное значение кубика на любое число, что позволит вам имитировать многогранные кубики, часто используемые во многих настольных и ролевых играх.
исходный код:
'''
Dice Roll Generator
-------------------------------------------------------------
'''
import random
import os
def num_die():
while True:
try:
num_dice = input('Number of dice: ')
valid_responses = ['1', 'one', 'two', '2']
if num_dice not in valid_responses:
raise ValueError('1 or 2 only')
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 == 'two':
print('Rolling the dice...')
dice_1 = random.randint(min_val, max_val)
dice_2 = random.randint(min_val, max_val)
print('The values are:')
print('Dice One: ', dice_1)
print('Dice Two: ', dice_2)
print('Total: ', dice_1 + dice_2)
roll_again = input('Roll Again? ')
else:
print('Rolling the die...')
dice_1 = random.randint(min_val, max_val)
print(f'The value is: {dice_1}')
roll_again = input('Roll Again? ')
if __name__ == '__main__':
roll_dice()Средство проверки надежности пароля
Если вы хотите научиться создавать приложения, этот проект на Python может стать отличным дополнением, поскольку он позволяет вам проверить, достаточно ли надежен ваш пароль.
Для этого программа проверяет количество букв, цифр, специальных символов и пробелов в заданном пароле и выставляет оценку на основе полученных результатов. Итак, это еще один отличный способ узнать об условных выражениях, функциях и форматировании строк.
Мы также используем модули string и getpass из стандартной библиотеки Python. Это позволяет нам получить доступ ко всему набору строковых символов для сравнения с составом символов нашего пароля, в то время как функция .getpass() позволяет нам скрывать наш пароль при его вводе.
исходный код:
'''
Password Strength Checker
-------------------------------------------------------------
'''
import string
import getpass
def check_password_strength():
password = getpass.getpass('Enter the password: ')
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 = ('That\'s a very bad password.'
' Change it as soon as possible.')
elif strength == 2:
remarks = ('That\'s a weak password.'
' You should consider using a tougher password.')
elif strength == 3:
remarks = 'Your password is okay, but it can be improved.'
elif strength == 4:
remarks = ('Your password is hard to guess.'
' But you could make it even more secure.')
elif strength == 5:
remarks = ('Now that\'s one hell of a strong password!!!'
' Hackers don\'t have a chance guessing that password!')
print('Your password has:-')
print(f'{lower_count} lowercase letters')
print(f'{upper_count} uppercase letters')
print(f'{num_count} digits')
print(f'{wspace_count} whitespaces')
print(f'{special_count} special characters')
print(f'Password Score: {strength / 5}')
print(f'Remarks: {remarks}')
def check_pwd(another_pw=False):
valid = False
if another_pw:
choice = input(
'Do you want to check another password\'s strength (y/n) : ')
else:
choice = input(
'Do you want to check your password\'s strength (y/n) : ')
while not valid:
if choice.lower() == 'y':
return True
elif choice.lower() == 'n':
print('Exiting...')
return False
else:
print('Invalid input...please try again. \n')
if __name__ == '__main__':
print('===== Welcome to Password Strength Checker =====')
check_pw = check_pwd()
while check_pw:
check_password_strength()
check_pw = check_pwd(True)Количество в словах
Эта идея проекта Python преобразует целое число, введенное пользователем, в эквивалентные ему слова. Эта программа настроена на поддержку чисел, состоящих максимум из 12 цифр, но вы можете модифицировать программу для обработки больших чисел (подсказка: требуются условные операторы и циклы).
Являясь простым для понимания примером базовых проектов на Python, эта простая, но эффективная программа может расширить ваши навыки работы с циклами, пользовательским вводом и условными операторами, не говоря уже о кортежах и списках на Python.
Вы также сможете поэкспериментировать с некоторыми математическими операциями, которые могут быть для вас новыми, например, с оператором по модулю (%), возвращающим остаток от целочисленного деления.
Если какой-либо из этих методов для вас в новинку, вы можете рассмотреть возможность установки помощника по кодированию с помощью искусственного интеллекта в вашей среде разработки Python, чтобы он помогал с любыми блоками кода, которые кажутся вам сложными для понимания.
исходный код:
'''
Numbers To Words
-------------------------------------------------------------
'''
ones = (
'Zero', 'One', 'Two', 'Three', 'Four',
'Five', 'Six', 'Seven', 'Eight', 'Nine'
)
twos = (
'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen',
'Fifteen', 'Sixteen', 'Seventeen', 'Eighteen', 'Nineteen'
)
tens = (
'Twenty', 'Thirty', 'Forty', 'Fifty', 'Sixty',
'Seventy', 'Eighty', 'Ninety', 'Hundred'
)
suffixes = (
'', 'Thousand', 'Million', 'Billion'
)
def fetch_words(number, index):
if number == '0': return 'Zero'
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 += ' Hundred '
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('Zero')):
words = words[:-len('Zero')]
else:
words += ' '
if len(words) != 0:
words += suffixes[index]
return words
def convert_to_words(number):
length = len(str(number))
if length > 12:
return 'This program supports a maximum of 12 digit numbers.'
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_words
if __name__ == '__main__':
number = int(input('Enter any number: '))
print('%d in words is: %s' %(number, convert_to_words(number)))Игра в крестики-нолики
Крестики-нолики - это классическая игра для двух игроков, в которой используется сетка из девяти квадратов. Каждый игрок поочередно помечает свое поле буквой "О" или "Х", и выигрывает тот, кому удастся отметить три "О" или "Х" по диагонали, горизонтали или вертикали. Каждый игрок также должен блокировать своего противника, пытаясь выстроить свою цепочку.
Это очень весело питона проекта тхата¢ÂÂs уникальный для начинающих, так как он использует объектно-ориентированного программирования.Ã'Â
Это одна из самых важных концепций Python для изучения, и в этом проекте вы создадите новый класс под названием TicTacToe. Затем мы будем использовать его для представления возможностей игры с помощью атрибутов и методов класса.
Внимательно изучите эти методы, чтобы понять, как мы можем использовать объектно-ориентированное программирование для четкого описания различных моделей поведения, необходимых для моделирования этой игры.
Некоторые новые аспекты этой идеи проекта Python для начинающих включают вложенные циклы для проверки столбцов, строк и диагоналей таблицы на предмет выигрышного состояния, а также тип данных Python set, который используется для хранения уникальных значений. Эта программа также использует модуль Python random для выбора случайного игрока для начала игры, но теперь это вам более знакомо.
исходный код:
Â'Â
'''
Tic Tac Toe
-------------------------------------------------------------
'''
import random
class 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'\nPlayer {player} turn')
row, col = list(
map(int, input(
'Enter row & column numbers to fix spot: ').split()))
print()
if col is None:
raise ValueError(
'not enough values to unpack (expected 2, got 1)')
self.fix_spot(row - 1, col - 1, player)
game_over = self.has_player_won(player)
if game_over:
print(f'Player {player} wins the game!')
continue
game_over = self.is_board_filled()
if game_over:
print('Match Draw!')
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()Калькулятор
Еще один из наших простых проектов на Python, эта программа создает базовое приложение-калькулятор с функциями сложения, вычитания, умножения и деления.
Это один из практических проектов на Python, который отлично подходит для изучения использования циклов, функций, условных операторов, пользовательского ввода и форматирования строк. Мы также использовали модуль операционной системы Python для очистки экрана после того, как пользователь завершит свои вычисления.
Как только вы освоитесь с концепциями этого проекта, подумайте о том, как расширить возможности, включив в них возведение в степень или другие более сложные вычисления.
Если вы уже используете помощника по программированию с помощью искусственного интеллекта, такого как GitHub Copilot или Amazon CodeWhisperer, вы также можете поэкспериментировать с этим, чтобы добавить новые функции. Но сначала попробуйте сделать это самостоятельно!
Пример кода:
'''
Calculator
-------------------------------------------------------------
'''
import os
def addition():
os.system('cls' if os.name == 'nt' else 'clear')
print('Addition')
continue_calc = 'y'
num_1 = float(input('Enter a number: '))
num_2 = float(input('Enter another number: '))
ans = num_1 + num_2
values_entered = 2
print(f'Current result: {ans}')
while continue_calc.lower() == 'y':
continue_calc = (input('Enter more (y/n): '))
while continue_calc.lower() not in ['y', 'n']:
print('Please enter \'y\' or \'n\'')
continue_calc = (input('Enter more (y/n): '))
if continue_calc.lower() == 'n':
break
num = float(input('Enter another number: '))
ans += num
print(f'Current result: {ans}')
values_entered += 1
return [ans, values_entered]
def subtraction():
os.system('cls' if os.name == 'nt' else 'clear')
print('Subtraction')
continue_calc = 'y'
num_1 = float(input('Enter a number: '))
num_2 = float(input('Enter another number: '))
ans = num_1 - num_2
values_entered = 2
print(f'Current result: {ans}')
while continue_calc.lower() == 'y':
continue_calc = (input('Enter more (y/n): '))
while continue_calc.lower() not in ['y', 'n']:
print('Please enter \'y\' or \'n\'')
continue_calc = (input('Enter more (y/n): '))
if continue_calc.lower() == 'n':
break
num = float(input('Enter another number: '))
ans -= num
print(f'Current result: {ans}')
values_entered += 1
return [ans, values_entered]
def multiplication():
os.system('cls' if os.name == 'nt' else 'clear')
print('Multiplication')
continue_calc = 'y'
num_1 = float(input('Enter a number: '))
num_2 = float(input('Enter another number: '))
ans = num_1 * num_2
values_entered = 2
print(f'Current result: {ans}')
while continue_calc.lower() == 'y':
continue_calc = (input('Enter more (y/n): '))
while continue_calc.lower() not in ['y', 'n']:
print('Please enter \'y\' or \'n\'')
continue_calc = (input('Enter more (y/n): '))
if continue_calc.lower() == 'n':
break
num = float(input('Enter another number: '))
ans *= num
print(f'Current result: {ans}')
values_entered += 1
return [ans, values_entered]
def division():
os.system('cls' if os.name == 'nt' else 'clear')
print('Division')
continue_calc = 'y'
num_1 = float(input('Enter a number: '))
num_2 = float(input('Enter another number: '))
while num_2 == 0.0:
print('Please enter a second number > 0')
num_2 = float(input('Enter another number: '))
ans = num_1 / num_2
values_entered = 2
print(f'Current result: {ans}')
while continue_calc.lower() == 'y':
continue_calc = (input('Enter more (y/n): '))
while continue_calc.lower() not in ['y', 'n']:
print('Please enter \'y\' or \'n\'')
continue_calc = (input('Enter more (y/n): '))
if continue_calc.lower() == 'n':
break
num = float(input('Enter another number: '))
while num == 0.0:
print('Please enter a number > 0')
num = float(input('Enter another number: '))
ans /= num
print(f'Current result: {ans}')
values_entered += 1
return [ans, values_entered]
def calculator():
quit = False
while not quit:
results = []
print('Simple Calculator in Python!')
print('Enter \'a\' for addition')
print('Enter \'s\' for substraction')
print('Enter \'m\' for multiplication')
print('Enter \'d\' for division')
print('Enter \'q\' to quit')
choice = input('Selection: ')
if choice == 'q':
quit = True
continue
if choice == 'a':
results = addition()
print('Ans = ', results[0], ' total inputs: ', results[1])
elif choice == 's':
results = subtraction()
print('Ans = ', results[0], ' total inputs: ', results[1])
elif choice == 'm':
results = multiplication()
print('Ans = ', results[0], ' total inputs: ', results[1])
elif choice == 'd':
results = division()
print('Ans = ', results[0], ' total inputs: ', results[1])
else:
print('Sorry, invalid character')
if __name__ == '__main__':
calculator()Часы и таймер обратного отсчета
Идея этого проекта на Python - забавная! Здесь мы создали таймер обратного отсчета, который запрашивает у пользователя количество секунд с помощью пользовательского ввода, а затем ведет обратный отсчет, секунда за секундой, пока не отобразит сообщение.
Мы использовали функцию Python time module's .sleep() для приостановки на 1-секундные интервалы. Мы объединили это с некоторым изящным форматированием строк, чтобы отобразить обратный отсчет.
исходный код:
'''
Countdown Timer
-------------------------------------------------------------
'''
import time
def 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('Lift off!')
if __name__ == '__main__':
user_time = int(input("Enter a time in seconds: "))
countdown(user_time)Промежуточные проекты на Python с исходным Кодом
Алгоритм бинарного поиска
Для всех начинающих программистов в какой-то момент обязательно нужно заняться бинарным поиском в одном из своих проектов по программированию на Python! Я знаю, что когда я начинал, некоторые из моих самых распространенных ошибок в Python были связаны с классическими алгоритмами, подобными этому.
Этот проект на Python для бинарного поиска использует отсортированный список (массив), а затем постоянно сравнивает значение поиска с серединой массива.
В зависимости от того, является ли значение поиска меньше или больше среднего значения, список разделяется (стратегия "разделяй и властвуй"), чтобы сократить пространство поиска, которое зависит от заданного значения поиска. Такое непрерывное разделение приводит к логарифмической временной сложности.
Если вы посмотрите на приведенный ниже код, то увидите, что мы реализовали два решения: условные циклы и рекурсию. Оба подхода элегантны, поэтому не стесняйтесь экспериментировать с каждым из них.
Если вы новичок в рекурсии, то это отличное введение, поскольку оно демонстрирует, как мы уменьшаем размер проблемы при каждом рекурсивном вызове, а именно путем разделения списка по одну сторону от текущего среднего элемента.
Мы также определили базовый вариант рекурсии как точку, в которой средний элемент равен элементу поиска. В этом случае рекурсия остановится и вернет истинное значение вверх по стеку вызовов.
Если все это звучит для вас непривычно, подумайте об использовании чего-то вроде GitHub Copilot, чтобы лучше понять этот классический алгоритм.
Â'Â
исходный код:
'''
Binary Search
-------------------------------------------------------------
'''
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 False
def 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('Binary Search:', binary_search(a_list, 4))
print('Binary Search Recursive:',
binary_search_rec(a_list, 0, len(a_list) -1, 4))Алгоритм сортировки слиянием
Сортировка слиянием - еще одна популярная проблема, с которой сталкиваются начинающие программисты, когда ищут, что можно сделать в Python.
Эта стратегия "разделяй и властвуй" использует деление для разделения списка чисел на равные части, которые затем рекурсивно сортируются перед повторным объединением для создания отсортированного списка.
Если вы только что завершили пример бинарного поиска, вы можете заметить некоторое сходство с разделением и уменьшением размера задачи. Вы были бы правы, а это значит, что вы, вероятно, поняли, что нам нужно использовать рекурсию.
Эта реализация сортировки слиянием на языке Python использует рекурсию для управления процессом "разделяй и властвуй". Постоянное уменьшение размера задачи позволяет решить ее при достижении рекурсивного базового варианта, а именно, когда размер задачи составляет один элемент или меньше.
По сути, эта программа на Python продолжает рекурсивно разбивать список до тех пор, пока не достигнет базового варианта. На этом этапе она начинает сортировать меньшие части задачи, в результате чего получаются отсортированные массивы меньшего размера, которые затем повторно объединяются для получения полностью отсортированного массива. Если вы знакомы с обозначением типа "Большая буква О", вам будет интересно узнать, что сортировка слиянием имеет значение "Большая буква О" (n logn).
исходный код:
'''
Merge Sort
-------------------------------------------------------------
'''
def merge_sort(a_list):
print("Dividing ", 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("Merging ", a_list)
if __name__ == '__main__':
a_list = [45, 7, 85, 24, 60, 25, 38, 63, 1]
merge_sort(a_list)
print(a_list)Генератор паролей
Это интересный проект на Python, который использует модули secrets и string для создания надежного и защищенного пароля, подобно тому, как это можно сделать с помощью популярных менеджеров паролей.
Модуль string получает все возможные буквы, цифры и специальные символы, в то время как модуль secrets позволяет нам получать криптографически защищенные пароли.
Код для этого проекта относительно прост, поскольку он использует цикл для непрерывной генерации паролей до тех пор, пока в нем не появится хотя бы один специальный символ и две цифры. Вы, конечно, можете изменить его, чтобы он соответствовал вашим собственным правилам создания сверхстойких паролей!
исходный код:
'''
Password Generator
-------------------------------------------------------------
'''
import secrets
import string
def 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 pwd
if __name__ == '__main__':
print(create_pw())Конвертер валют
Это одна из нескольких идей проекта Python, которые требуют от нас установки одной из самых популярных библиотек Python, которой в данном случае является модуль requests. Он не входит в стандартную библиотеку Python, поэтому используйте команду pip, указанную в исходном коде, чтобы установить его в свою систему.
С помощью модуля requests мы можем отправлять HTTP-запросы к API Fixer, что позволяет нам конвертировать одну валюту в другую. Вы, вероятно, заметите, что мы используем сторонний API, поэтому вам нужно будет зарегистрироваться, чтобы получить бесплатный ключ API. Затем вы можете ввести свой API-ключ в поле, указанное в исходном коде, и вы будете готовы к работе!
Этот проект позволяет вам немного попрактиковаться в циклах и пользовательском вводе, но он расширяет это с помощью HTTP-запросов для получения данных API в формате JSON.
Если вы не знакомы с JSON, он очень похож на словарь Python, что означает, что мы можем получить доступ к парам ключ-значение для извлечения данных, которые нам нужны. В данном случае мы ищем результат конвертации валюты из вызова API.
Ознакомьтесь с документами на сайте Fixer API для получения более подробной информации о различных данных, которые вы можете получить.
исходный код:
'''
Currency Converter
-------------------------------------------------------------
pip install requests
'''
import requests
def convert_currency():
init_currency = input('Enter an initial currency: ')
target_currency = input('Enter a target currency: ')
while True:
try:
amount = float(input('Enter the amount: '))
except:
print('The amount must be a numeric value!')
continue
if not amount > 0:
print('The amount must be greater than 0')
continue
else:
break
url = ('https://api.apilayer.com/fixer/convert?to='
+ target_currency + '&from=' + init_currency +
'&amount=' + str(amount))
payload = {}
headers = {'apikey': 'YOUR API KEY'}
response = requests.request('GET', url, headers=headers, data=payload)
status_code = response.status_code
if status_code != 200:
print('Uh oh, there was a problem. Please try again later')
quit()
result = response.json()
print('Conversion result: ' + str(result['result']))
if __name__ == '__main__':
convert_currency()Автоматическая отправка писем на День рождения
Этот проект на Python использует стандартные модули smtplib, EmailMessage и datetime, в дополнение к pandas и openpyxl (на них должен быть установлен pip, как показано ниже) для автоматической отправки электронных писем на день рождения.
Эта программа считывает данные с листа Excel, который содержит информацию обо всех ваших друзьях (смотрите формат листа Excel в исходном коде ниже). Затем он отправляет им электронное письмо, если сегодня у них важный день, а затем делает пометку в вашей электронной таблице о том, что они получили свое электронное письмо.
Мы использовали модули smtplib и EmailMessage для создания SSL-соединения с нашей учетной записью электронной почты и сообщением. Затем мы использовали фрейм данных pandas для хранения данных в виде электронных таблиц в программе на Python (необходимый навык для специалистов по обработке данных). Наконец, мы использовали форматирование даты с помощью функции модуля datetime .strftime().
Итак, вам предстоит освоить множество новых навыков!
Важное примечание: с мая 2022 года Google ужесточила ограничения на доступ к Gmail через незащищенные приложения. Чтобы использовать этот код в своей учетной записи Gmail, вам потребуется выполнить несколько дополнительных действий. Но не волнуйтесь, это легко сделать, и мы перечислили их для вас.
- Перейдите на страницу "Управление учетной записью" вашего аккаунта Google
- Нажмите на Безопасность
- Включите 2FA (используйте любой метод, который вы предпочитаете)
- Нажмите на "Пароли приложений".
- Нажмите "Выбрать приложение" и выберите "Почта"
- Click on âÂÂSelect Deviceâ & select âÂÂOther (custom name)âÂÂ, enter âÂÂPython Birthday AppâÂÂ
- Нажмите "Создать" затем сохраните этот пароль
Теперь вы можете использовать пароль этого приложения в приведенном ниже коде, чтобы без проблем получить доступ к своей учетной записи Gmail!
исходный код:
'''
Birthday Email Sender
-------------------------------------------------------------
pip install pandas openpyxl
excel file cols:
Name, Email, Birthday (MM/DD/YYYY), Last Sent (YYYY)
'''
import pandas as pd
from datetime import datetime
import smtplib
from email.message import EmailMessage
def send_email(recipient, subject, msg):
GMAIL_ID = 'your_email_here'
GMAIL_PWD = 'your_password_here'
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('Email sent to ' + str(recipient) + ' with Subject: \''
+ str(subject) + '\' and Message: \'' + 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['Birthday'].to_pydatetime().strftime('%m-%d')
if (today == bday) and year_now not in str(item['Last Sent']):
msg = 'Happy Birthday ' + str(item['Name'] + '!!')
send_email(item['Email'], 'Happy Birthday', msg)
sent_index.append(idx)
for idx in sent_index:
bdays_df.loc[bdays_df.index[idx], 'Last Sent'] = str(year_now)
bdays_df.to_excel(bday_file, index=False)
if __name__ == '__main__':
send_bday_emails(bday_file='your_bdays_list.xlsx')Очередь
В этом проекте на Python создается новый класс для реализации очереди. Это распространенная структура данных в информатике, когда вам нужно обрабатывать сценарии "Первый пришел-первый вышел" (FIFO), такие как очереди сообщений, задачи процессора и т.д.
Код прост и позволяет попрактиковаться в объектно-ориентированном программировании. Протестируйте queue, чтобы понять, как это работает, и тогда вы будете готовы использовать эту структуру данных в других своих проектах.
исходный код:
'''
Queue Data Structure
-------------------------------------------------------------
'''
class Queue:
def __init__(self):
self.items = []
def __repr__(self):
return f'Queue object: data={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('First')
q.enqueue('Second')
print(q)
print(q.dequeue())
print(q)
print(q.size())
print(q.peek())Треугольник Паскаля
Этот проект на Python выводит треугольник Паскаля с использованием условных операторов и циклов. Он также использует математический модуль стандартной библиотеки и факториальную функцию для вычисления уравнения количества комбинаций, используемого для генерации значений в треугольнике.
Эксперимент с числом семян на треугольник, чтобы изучить, как âÂÂcombinationsâ уравнение используется для генерации последовательных значений в треугольнике.Ã'Â
исходный код:
'''
Pascal's Triangle
-------------------------------------------------------------
Number of combinations via "n choose k" or nCk = n! / [k! * (n-k)!]
'''
from math import factorial
def 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)Блэкджек
Это один из самых крутых проектов на Python, который понравится всем, кто любит карточные игры, поскольку мы будем имитировать блэкджек. Это очень популярная карточная игра с относительно простыми правилами: самое главное, чтобы выиграть, вам нужно 21 очко или набрать больше очков, чем у дилера, и при этом не проиграть!
На данный момент это самый крупный проект в списке. Он сочетает в себе большинство навыков, которые мы уже изучали в предыдущих проектах, включая создание классов, циклов, условных операторов, импорт модулей, прием пользовательского ввода и форматирование строк.
Потратьте время на изучение различных разделов этого кода и сравните его с предыдущими проектами, чтобы увидеть, как различные методы работают вместе. Здесь нет ничего такого, чего бы вы раньше не видели; просто это было немного по-другому упаковано и объединено для создания полнофункционального игрового эмулятора.
И мы должны сказать, что постарайтесь не играть с ним весь день! Но мы полностью поймем, если вы это сделаете!
исходный код:
'''
Blackjack
-------------------------------------------------------------
'''
import random
import os
class Card:
def __init__(self, card_face, value, symbol):
self.card_face = card_face
self.value = value
self.symbol = symbol
def 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:
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)
print()
def deal_card(deck):
card = random.choice(deck)
deck.remove(card)
return card, deck
def play_blackjack(deck):
player_cards = []
dealer_cards = []
player_score = 0
dealer_score = 0
os.system('clear')
while len(player_cards) < 2:
player_card, deck = deal_card(deck)
player_cards.append(player_card)
player_score += player_card.value
# If dealt a second Ace, adjust player score
if len(player_cards) == 2:
if player_cards[0].value == 11 and player_cards[1].value == 11:
player_cards[0].value = 1
player_score -= 10
print('PLAYER CARDS: ')
show_cards(player_cards, False)
print('PLAYER SCORE = ', player_score)
input('Continue...')
dealer_card, deck = deal_card(deck)
dealer_cards.append(dealer_card)
dealer_score += dealer_card.value
# If dealt a second Ace, adjust dealer score
# Note: adjusts 2nd card to hide that the dealer has an Ace
if len(dealer_cards) == 2:
if dealer_cards[0].value == 11 and dealer_cards[1].value == 11:
dealer_cards[1].value = 1
dealer_score -= 10
print('DEALER CARDS: ')
if len(dealer_cards) == 1:
show_cards(dealer_cards, False)
print('DEALER SCORE = ', dealer_score)
else:
show_cards(dealer_cards[:-1], True)
print('DEALER SCORE = ', dealer_score - dealer_cards[-1].value)
input('Continue...')
if player_score == 21:
print('PLAYER HAS A BLACKJACK!!!!')
print('PLAYER WINS!!!!')
quit()
os.system('clear')
print('DEALER CARDS: ')
show_cards(dealer_cards[:-1], True)
print('DEALER SCORE = ', dealer_score - dealer_cards[-1].value)
print()
print('PLAYER CARDS: ')
show_cards(player_cards, False)
print('PLAYER SCORE = ', player_score)
while player_score < 21:
choice = input('Enter H to Hit or S to Stand: ').upper()
if len(choice) != 1 or (choice not in ['H', 'S']):
os.system('clear')
print('Invalid choice!! Try Again...')
continue
if choice.upper() == 'S':
break
else:
player_card, deck = deal_card(deck)
player_cards.append(player_card)
player_score += player_card.value
card_pos = 0
# If dealt an Ace, adjust score for each existing Ace in hand
while player_score > 21 and card_pos < len(player_cards):
if player_cards[card_pos].value == 11:
player_cards[card_pos].value = 1
player_score -= 10
card_pos += 1
else:
card_pos += 1
if player_score > 21:
break
os.system('clear')
print('DEALER CARDS: ')
show_cards(dealer_cards[:-1], True)
print('DEALER SCORE = ', dealer_score - dealer_cards[-1].value)
print()
print('PLAYER CARDS: ')
show_cards(player_cards, False)
print('PLAYER SCORE = ', player_score)
os.system('clear')
print('PLAYER CARDS: ')
show_cards(player_cards, False)
print('PLAYER SCORE = ', player_score)
print()
print('DEALER IS REVEALING THEIR CARDS....')
print('DEALER CARDS: ')
show_cards(dealer_cards, False)
print('DEALER SCORE = ', dealer_score)
if player_score == 21:
print('PLAYER HAS A BLACKJACK, PLAYER WINS!!!')
quit()
if player_score > 21:
print('PLAYER BUSTED!!! GAME OVER!!!')
quit()
input('Continue...')
while dealer_score < 17:
os.system('clear')
print('DEALER DECIDES TO HIT.....')
dealer_card, deck = deal_card(deck)
dealer_cards.append(dealer_card)
dealer_score += dealer_card.value
# If dealt an Ace, adjust score for each existing Ace in hand
card_pos = 0
while dealer_score > 21 and card_pos < len(dealer_cards):
if dealer_cards[card_pos].value == 11:
dealer_cards[card_pos].value = 1
dealer_score -= 10
card_pos += 1
else:
card_pos += 1
print('PLAYER CARDS: ')
show_cards(player_cards, False)
print('PLAYER SCORE = ', player_score)
print()
print('DEALER CARDS: ')
show_cards(dealer_cards, False)
print('DEALER SCORE = ', dealer_score)
if dealer_score > 21:
break
input('Continue...')
if dealer_score > 21:
print('DEALER BUSTED!!! YOU WIN!!!')
quit()
elif dealer_score == 21:
print('DEALER HAS A BLACKJACK!!! PLAYER LOSES!!!')
quit()
elif dealer_score == player_score:
print('TIE GAME!!!!')
elif player_score > dealer_score:
print('PLAYER WINS!!!')
else:
print('DEALER WINS!!!')
def init_deck():
suits = ['Spades', 'Hearts', 'Clubs', 'Diamonds']
# UNICODE values for card symbol images
suit_symbols = {'Hearts': '\u2661', 'Diamonds': '\u2662',
'Spades': '\u2664', 'Clubs': '\u2667'}
cards = {'A': 11, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6,
'7': 7, '8': 8, '9': 9, '10': 10, 'J': 10, 'Q': 10, 'K': 10}
deck = []
for suit in suits:
for card, value in cards.items():
deck.append(Card(card, value, suit_symbols[suit]))
return deck
if __name__ == '__main__':
deck = init_deck()
play_blackjack(deck)Бот Reddit
Этот проект на Python создает автоматизированного бота Reddit с некоторыми новыми модулями, а именно praw и enchant (смотрите команды установки pip).
Это довольно простая концепция, поскольку программа проверяет каждый комментарий в выбранном субреддите, а затем отвечает на любые комментарии, содержащие предопределенную фразу-триггер. Для этого мы используем модуль praw для взаимодействия с Reddit, а enchant генерирует слова, похожие на комментарий, что позволяет нам ответить соответствующим образом.
Эта идея действительно полезна, если вы ищете проекты на Python, чтобы научиться отвечать на вопросы в своем собственном субреддите. Вам просто нужно расширить этот код, включив в него автоматические ответы на предопределенные вопросы (вы, вероятно, уже заметили, что это используется другими пользователями Reddit!).
Важное примечание: Вам нужно будет ознакомиться с этими инструкциями, чтобы получить данные client_id, client_secret, имя пользователя, пароль и user_agent. Вам понадобится эта информация, чтобы оставлять комментарии в Reddit через интерфейс API.
исходный код:
'''
Reddit Reply Bot
-------------------------------------------------------------
pip install praw pyenchant
'''
import praw
import enchant
def 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')Генератор Фибоначчи
Числа Фибоначчи, возможно, являются одними из самых важных чисел в нашей жизни, поскольку они так часто встречаются в природе.
Приведенный ниже код на 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 val
if __name__ == '__main__':
print('======== Fibonacci Series ========')
for i in range(1, 11):
print(f'Fibonacci ({i}) : {fib_memo(i)}')Продвинутые идеи проекта на Python
Чат-бот
В этом проекте на Python используется модуль chatterbot (см. инструкции по установке pip ниже) для обучения автоматического чат-бота отвечать на любой ваш вопрос! Я знаю, мы теперь используем искусственный интеллект!
Вы увидите, что эта программа является одним из относительно небольших проектов на Python в этом списке, но не стесняйтесь ознакомиться с документацией по чат-ботам, а также с более широкой областью чат-ботов с искусственным интеллектом, если хотите узнать больше или расширить код.особенности s.
Если это пробудило в вас желание создавать ИИ-ботов, ознакомьтесь с нашим 24-часовым курсом по созданию чат-ботов на Python, чтобы узнать, как создать чат-бота на базе ИИ с помощью тех же инструментов, что и в OpenAI ChatGPT.
А если вы жаждете еще большего совершенства искусственного интеллекта, ознакомьтесь с последней функцией OpenAI, которая позволяет вам создавать свой собственный GPT.
Важное примечание: Чат-бот больше не поддерживается в активном режиме. Это означает, что вам необходимо внести небольшое изменение в файл tagging.py, расположенный в каталоге LIB/site-packages/Chatterbot в вашей папке установки Python.
Не волнуйтесь, это просто сделать, и мы включили точный исходный код, который вам нужно использовать, как показано ниже.
исходный код:
'''
Chat Bot
-------------------------------------------------------------
1) pip install ChatterBot chatterbot-corpus spacy
2) python3 -m spacy download en_core_web_sm
Or... choose the language you prefer
3) Navigate to your Python3 directory
4) Modify Lib/site-packages/chatterbot/tagging.py
to properly load 'en_core_web_sm'
'''
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer
def 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):
break
if __name__ == '__main__':
create_chat_bot()Изменять tagging.py:
Найдите первый фрагмент кода, который является частью метода __init__ для класса PosLemmaTagger. Замените его оператором if/else.
Примечание: этот пример предназначен для английской библиотеки, которую мы использовали в нашем примере, но вы можете перевести его на другой язык, если хотите.
# Replace this:
self.nlp = spacy.load(self.language.ISO_639_1.lower())
# With this:
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())Преобразование текста в речь
В этом проекте на Python используется ряд новых библиотек для преобразования существующей статьи в воспроизводимый mp3-файл. Вам потребуется установить nltk (natural language toolkit), newspaper3k и gtts (см. инструкции по установке pip).
Вы увидите, что программа проста, поскольку мы просто вводим URL-адрес статьи для преобразования, а затем предоставляем функции, которую мы определили, обрабатывать преобразование текста в речь с помощью наших недавно установленных модулей.
Итак, попробуйте это в следующий раз вы захотите превратить статью в игровой подкаст как itâÂÂS и наверняка один из прохладных питон коды для копирования!Ã'Â
исходный код:
'''
Text To Speech
-------------------------------------------------------------
pip install nltk newspaper3k gtts
'''
import nltk
from newspaper import Article
from gtts import gTTS
def 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'
)Система управления библиотекой
Как один из наиболее продвинутых проектов на Python, эта программа использует объектно-ориентированное программирование для моделирования системы управления библиотекой.
В этом примере мы создаем библиотеку и класс для учащихся, которые мы можем использовать для создания нашей библиотечной системы и ее пользователей. Затем мы внедрили простой пользовательский интерфейс, который предлагает пользователям выбирать из ряда стандартных библиотечных действий, таких как заимствование или возврат книг.Да
Это простой, но наглядный пример того, как вы можете создавать реальные системы с помощью Python и объектно-ориентированного программирования. Не стесняйтесь расширять классы, добавляя в них другие полезные функции, такие как уникальные идентификаторы книг, несколько экземпляров одной и той же книги, даты возврата, плата за поздний возврат книг или любые другие функции, которые, по вашему мнению, должны быть в библиотеке!
исходный код:
'''
Library
-------------------------------------------------------------
'''
class Library:
def __init__(self, books):
self.books = books
def show_avail_books(self):
print('Our Library Can Offer You The Following Books:')
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} has been marked'
f' as \'Borrowed\' by: {name}')
self.books[requested_book] = name
return True
else:
print(
f'Sorry, the {requested_book} is currently'
f' on loan to: {self.books[requested_book]}')
return False
def return_book(self, returned_book):
self.books[returned_book] = 'Free'
print(f'Thanks for returning {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('You haven\'t borrowed any books')
else:
for book in self.books:
print(book)
def request_book(self):
book = input(
'Enter the name of the book you\'d like to borrow >> ')
if self.library.lend_book(book, self.name):
self.books.append(book)
def return_book(self):
book = input(
'Enter the name of the book you\'d like to return >> ')
if book in self.books:
self.library.return_book(book)
else:
print('You haven\'t borrowed that book, try another...')
def create_lib():
books = {
'The Last Battle': 'Free',
'The Hunger Games': 'Free',
'Cracking the Coding Interview': 'Free'
}
library = Library(books)
student_example = Student('Your Name', library)
while True:
print('''
==========LIBRARY MENU===========
1. Display Available Books
2. Borrow a Book
3. Return a Book
4. View Your Books
5. Exit'''
)
choice = int(input('Enter Choice: '))
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('Goodbye')
exit()
if __name__ == '__main__':
create_lib()Аркадная игра в теннис
Это действительно веселый и интересный проект, так как мы использовали модуль turtle на Python для имитации классической аркадной игры Pong!
Мы использовали различные методы из модуля 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('Left Player: {} -- Right Player: {}'.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('Pong Arcade Game')
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('Left Player: 0 -- Right Player: 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() < -280:
ball.sety(-280)
ball.dy *= -1
if ball.xcor() > 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() < -500:
ball.goto(0, 0)
ball.dy *= -1
l_score, r_score, score_board = update_score(
l_score, r_score, 'r', score_board)
continue
if ((ball.xcor() > 360) and
(ball.xcor() < 370) and
(ball.ycor() < r_paddle.ycor()+40) and
(ball.ycor() > r_paddle.ycor()-40)):
ball.setx(360)
ball.dx *= -1
if ((ball.xcor() < -360) and
(ball.xcor() > -370) and
(ball.ycor() < l_paddle.ycor()+40) and
(ball.ycor() > l_paddle.ycor()-40)):
ball.setx(-360)
ball.dx *= -1
if __name__ == '__main__':
pong_game()Тест на скорость набора текста
Это интересный проект на Python, который проверяет, насколько быстро вы можете точно напечатать предложение.
Эта программа требует от нас создания графического интерфейса пользователя (GUI) с помощью модуля tkinter. Если вы новичок в графических интерфейсах, этот пример будет хорошим введением, поскольку мы используем ряд простых надписей, кнопок и полей ввода для создания окна. Мы также использовали модуль Python timeit для обработки временного аспекта нашего теста набора текста и модуль random для случайного выбора тестовой фразы.
Мы добавили в этот пример только две тестовые фразы, но не стесняйтесь экспериментировать с большим количеством или даже использовать сторонний словарь для более широкого набора примеров.
исходный код:
'''
Speed Typing Test
-------------------------------------------------------------
'''
import tkinter
from timeit import default_timer as timer
import random
def speed_test():
speed_test_sentences = [
'This is a random sentence to check speed.',
'Speed, I am lightning mcqueen.'
]
sentence = random.choice(speed_test_sentences)
start = timer()
main_window = tkinter.Tk()
main_window.geometry('600x400')
label_1 = tkinter.Label(main_window, text=sentence, font='times 20')
label_1.place(x=150, y=10)
label_2 = tkinter.Label(main_window, text='Start Typing', font='times 20')
label_2.place(x=10, y=50)
entry = tkinter.Entry(main_window)
entry.place(x=280, y=55)
def check_result():
if entry.get() == sentence:
end = timer()
label_3.configure(text=f'Time: {round((end-start), 4)}s')
else:
label_3.configure(text='Wrong Input')
button_1 = tkinter.Button(main_window, text='Done',
command=check_result, width=12, bg='grey')
button_1.place(x=150, y=100)
button_2 = tkinter.Button(main_window, text='Try Again',
command=speed_test, width=12, bg='grey')
button_2.place(x=250, y=100)
label_3 = tkinter.Label(main_window, text='', font='times 20')
label_3.place(x=10, y=300)
main_window.mainloop()
if __name__ == '__main__':
speed_test()Текстовый редактор
Основываясь на нашем последнем примере с tkinter, этот интересный проект на Python создает графический интерфейс, имитирующий наш собственный текстовый редактор. В этом примере также используются стандартные компоненты графического интерфейса, включая надписи, кнопки и поля ввода.
Однако мы также добавили возможность открывать и сохранять файлы, как в обычном текстовом редакторе. Если вы новичок в работе с файлами, этот проект на Python - отличный способ понять, как считывать и сохранять файлы.
Поэкспериментируйте с приведенным ниже кодом, чтобы закрепить свое понимание, и посмотрите, сможете ли вы расширить этот код, чтобы создать другие функции, которые вы привыкли использовать в текстовом редакторе, например, функцию "Найти Word".
исходный код:
'''
Text Editor
-------------------------------------------------------------
'''
import tkinter as tk
from tkinter.filedialog import askopenfilename, asksaveasfilename
def text_editor():
def open_file():
filepath = askopenfilename(
filetypes=[('Text Files', '*.txt'), ('All Files', '*.*')]
)
if not filepath:
return
txt_edit.delete(1.0, tk.END)
with open(filepath, 'r') as input_file:
text = input_file.read()
txt_edit.insert(tk.END, text)
window.title(f'TextEditor - {filepath}')
def save_file():
filepath = asksaveasfilename(
defaultextension='txt',
filetypes=[('Text Files', '*.txt'), ('All Files', '*.*')],
)
if not filepath:
return
with open(filepath, 'w') as output_file:
text = txt_edit.get(1.0, tk.END)
output_file.write(text)
window.title(f'Text Editor - {filepath}')
window = tk.Tk()
window.title('Text Editor')
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='Open', command=open_file)
btn_save = tk.Button(fr_buttons, text='Save As...', command=save_file)
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__':
text_editor()Решатель судоку
В этом проекте на Python используется библиотека pygame (см. инструкции по установке pip) для реализации графического интерфейса для автоматического решения головоломок судоку. Мы используем несколько пользовательских функций для создания графического интерфейса, как показано ниже.
Чтобы решить головоломку судоку, эта программа использует алгоритм обратного отслеживания, который постепенно проверяет наличие решений, либо принимая текущее решение, либо отказываясь от него, если оно нежизнеспособно.
Этот этап отказа от решения является отличительной чертой подхода с обратным отслеживанием, поскольку программа возвращается к нему, чтобы попробовать новое решение, пока не найдет подходящее. Этот процесс выполняется постепенно, пока вся таблица не будет заполнена правильно.
Не стесняйтесь экспериментировать с различными задачами судоку и даже подумайте о том, чтобы увеличить размер сетки задач (для этого вам понадобится новое базовое изображение).
исходный код:
'''
Sudoku Solver
-------------------------------------------------------------
pip install pygame
image link:
https://www.pngitem.com/pimgs/m/210-2106648_empty-sudoku-grid-grid-6x6-png-transparent-png.png
'''
import pygame
pygame.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 = 0
y = 0
dif = 500 / 9
val = 0
# Default Sudoku Board
grid = [
[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] // dif
def 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 True
def solve(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 valid(grid, i, j, it) == True:
grid[i][j] = it
x = i
y = j
screen.fill((255, 255, 255))
draw()
draw_box()
pygame.display.update()
pygame.time.delay(20)
if solve(grid, i, j) == 1:
return True
else:
grid[i][j] = 0
screen.fill((255, 255, 255))
draw()
draw_box()
pygame.display.update()
pygame.time.delay(50)
return False
def instruction():
text1 = font2.render(
'PRESS D TO RESET TO DEFAULT / R TO EMPTY\n', 1, (0, 0, 0))
text2 = font2.render(
'ENTER VALUES AND PRESS ENTER TO VISUALIZE\n', 1, (0, 0, 0))
screen.blit(text1, (20, 520))
screen.blit(text2, (20, 540))
def result():
text1 = font1.render('FINISHED PRESS R or D\n', 1, (0, 0, 0))
screen.blit(text1, (20, 570))
run = True
flag_1 = 0
flag_2 = 0
rs = 0
error = 0
while run:
screen.fill((255, 255, 255))
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
flag_1 = 1
pos = pygame.mouse.get_pos()
get_coord(pos)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
x -= 1
flag_1 = 1
if event.key == pygame.K_RIGHT:
x += 1
flag_1 = 1
if event.key == pygame.K_UP:
y -= 1
flag_1 = 1
if event.key == pygame.K_DOWN:
y += 1
flag_1 = 1
if event.key == pygame.K_1:
val = 1
if event.key == pygame.K_2:
val = 2
if event.key == pygame.K_3:
val = 3
if event.key == pygame.K_4:
val = 4
if event.key == pygame.K_5:
val = 5
if event.key == pygame.K_6:
val = 6
if event.key == pygame.K_7:
val = 7
if event.key == pygame.K_8:
val = 8
if event.key == pygame.K_9:
val = 9
if event.key == pygame.K_RETURN:
flag_2 = 1
# If R pressed clear sudoku board
if event.key == pygame.K_r:
rs = 0
error = 0
flag_2 = 0
grid = [
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]
]
# If D pressed reset board to default
if event.key == pygame.K_d:
rs = 0
error = 0
flag_2 = 0
grid = [
[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]
]
if flag_2 == 1:
if solve(grid, 0, 0) == False:
error = 1
else:
rs = 1
flag_2 = 0
if val != 0:
draw_val(val)
if valid(grid, int(x), int(y), val) == True:
grid[int(x)][int(y)] = val
flag_1 = 0
else:
grid[int(x)][int(y)] = 0
raise_error_2()
val = 0
if error == 1:
raise_error_1()
if rs == 1:
result()
draw()
if flag_1 == 1:
draw_box()
instruction()
pygame.display.update()
Средство проверки подключения к сайту
Этот проект на Python использует модули urllib и tkinter для тестирования подключения к веб-сайту.
Мы использовали модуль tkinter для создания графического интерфейса, позволяющего пользователям вводить веб-адрес. Как и в наших предыдущих примерах, это включает в себя надписи, кнопки и поля ввода.
После того, как мы собрали веб-адрес пользователя, мы передаем его в нашу пользовательскую функцию, которая возвращает код состояния HTTP для текущего веб-сайта с помощью функции .getcode() модуля urllib.
В этом примере мы просто определяем, равен ли HTTP-код 200. Если это так, мы знаем, что сайт работает; в противном случае мы сообщаем пользователю, что он недоступен.
Вы могли бы расширить этот код, чтобы рассмотреть более детальный подход к обработке различных кодов HTTP-ответов, так что не стесняйтесь добавлять это!
исходный код:
'''
Site Connectivity Checker
-------------------------------------------------------------
Enter websites as http(s)://www.yourwebsite.com
'''
import urllib.request
import tkinter as tk
def test_connectivity():
window = tk.Tk()
window.geometry('600x400')
head = tk.Label(window, text='Website Connectivity Checker',
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='Website Available',
font=('Calibri 15')).place(x=260, y=200)
else:
tk.Label(window, text='Website Not Available',
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='Check', command=check_url).place(x=285, y=150)
window.mainloop()
if __name__ == '__main__':
test_connectivity()Детектор языка
Этот проект Python использует модуль langdetect (см. инструкции по установке ПГИ) для того чтобы помочь нам определить язык, который был введен. Это может быть очень полезно, если youâÂÂповторно уверены, какой язык youâÂÂповторно дело.Ã'Â
Это еще один пример, в котором мы использовали tkinter для создания простого графического интерфейса, включающего надписи, кнопки и поле ввода. Затем мы можем собрать текст из поля ввода и обработать его с помощью langdetect, чтобы определить, какой язык был введен. Наконец, мы выводим этот результат в графический интерфейс пользователя, чтобы пользователь знал о нем.
Обратите внимание, что результаты, возвращаемые langdetect, являются сокращенными языковыми кодами. Например, если мы введем текст на английском языке, в качестве возвращаемого значения мы увидим¢¢¢ÂÂÂ.
исходный код:
'''
Language Detector
-------------------------------------------------------------
pip install langdetect
'''
from langdetect import detect
import tkinter as tk
def detect_lang():
window = tk.Tk()
window.geometry('600x400')
head = tk.Label(window, text='Language Detector', 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='Check Language',
command=check_language).place(x=285, y=150)
window.mainloop()
if __name__ == '__main__':
detect_lang()Рекомендательная система Netflix
В довершение всего, мы оставили напоследок один особенно интересный проект на Python! Это рекомендательная система Netflix, идеально подходящая для начинающих специалистов по обработке данных. На самом деле, если вы рассматриваете курс машинного обучения, то это отличный проект для закрепления ваших новых навыков.
Чтобы создать этот проект, вам потребуется импортировать ряд модулей, включая tkinter, re, nltk, pandas и numpy (смотрите инструкции по установке pip для новых модулей). YouâÂÂЛл также нужно загрузить набор данных Kaggle, содержащих Netflix фильмы и сериалы.Ã'Â
WeâÂÂЛл использовать tkinter, чтобы создать графический интерфейс, который будет использовать метки, кнопки и поля ввода. Пользователь затем сможет войти ТВ-шоу или кино их заказать на Netflix, чтобы вернуть рекомендации, основанные на их вкус.Ã'Â
Механизм рекомендаций использует актеров, режиссеров, рейтинги, страну и жанры в качестве характеристик машинного обучения (ML). Затем в коде используется подход "сопоставимого сходства" для поиска похожих результатов на основе пользовательского ввода. При этом широко используются pandas и numpy для очистки данных и подготовки их к обработке.
В этом примере есть что распаковать, поскольку в нем используется множество концепций Python для анализа данных.
Лучший подход - медленно проработать код, а затем провести дальнейшие исследования в области машинного обучения (ML), "особенностей" и "сходства с кодом".
Тогда вы сможете понять, как использовать набор данных для выработки рекомендаций, основанных на сходствах. Если вы начинающий специалист по обработке данных, то это потрясающий проект, который заставит вас задуматься!
исходный код:
'''
Netflix Recommendation Engine
-------------------------------------------------------------
pip install pandas numpy nltk
'''
from nltk.tokenize import word_tokenize
import numpy as np
import pandas as pd
import re
import nltk
import tkinter as tk
from nltk.corpus import stopwords
nltk.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 += 1
binary_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 += 1
binary_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 += 1
binary_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 += 1
binary_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 += 1
binary_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 += 1
binary_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 j in i:
binary_countries_2[k].append(1.0)
else:
binary_countries_2[k].append(0.0)
k += 1
binary_countries_2 = pd.DataFrame(binary_countries_2).transpose()
genres_2 = []
for i in tv['Genres']:
genre2 = re.split(r', \s*', i)
genres_2.append(genre2)
flat_list_7 = []
for sublist in genres_2:
for item in sublist:
flat_list_7.append(item)
genres_list_2 = sorted(set(flat_list_7))
binary_genres_2 = [[0] * 0 for i in range(len(set(flat_list_7)))]
for i in tv['Genres']:
k = 0
for j in genres_list_2:
if j in i:
binary_genres_2[k].append(1.0)
else:
binary_genres_2[k].append(0.0)
k += 1
binary_genres_2 = pd.DataFrame(binary_genres_2).transpose()
ratings_2 = []
for i in tv['Rating']:
ratings_2.append(i)
ratings_list_2 = sorted(set(ratings_2))
binary_ratings_2 = [[0] * 0 for i in range(len(set(ratings_list_2)))]
for i in tv['Rating']:
k = 0
for j in ratings_list_2:
if j in i:
binary_ratings_2[k].append(1.0)
else:
binary_ratings_2[k].append(0.0)
k += 1
binary_ratings_2 = pd.DataFrame(binary_ratings_2).transpose()
binary_2 = pd.concat([binary_actors_2, binary_countries_2,
binary_genres_2], axis=1, ignore_index=True)
window = tk.Tk()
window.geometry('600x600')
head = tk.Label(window, text='Enter Movie / TV Show on Netflix For Recommendations', font=('Calibri 15'))
head.pack(pady=20)
def netflix_recommender(search):
cs_list = []
binary_list = []
if search in movies['Title'].values:
idx = movies[movies['Title'] == search].index.item()
for i in binary.iloc[idx]:
binary_list.append(i)
point_1 = np.array(binary_list).reshape(1, -1)
point_1 = [val for sublist in point_1 for val in sublist]
for j in range(len(movies)):
binary_list_2 = []
for k in binary.iloc[j]:
binary_list_2.append(k)
point_2 = np.array(binary_list_2).reshape(1, -1)
point_2 = [val for sublist in point_2 for val in sublist]
dot_product = np.dot(point_1, point_2)
norm_1 = np.linalg.norm(point_1)
norm_2 = np.linalg.norm(point_2)
cos_sim = dot_product / (norm_1 * norm_2)
cs_list.append(cos_sim)
movies_copy = movies.copy()
movies_copy['cos_sim'] = cs_list
results = movies_copy.sort_values('cos_sim', ascending=False)
results = results[results['title'] != search]
top_results = results.head(5)
return (top_results)
elif search in tv['Title'].values:
idx = tv[tv['Title'] == search].index.item()
for i in binary_2.iloc[idx]:
binary_list.append(i)
point_1 = np.array(binary_list).reshape(1, -1)
point_1 = [val for sublist in point_1 for val in sublist]
for j in range(len(tv)):
binary_list_2 = []
for k in binary_2.iloc[j]:
binary_list_2.append(k)
point_2 = np.array(binary_list_2).reshape(1, -1)
point_2 = [val for sublist in point_2 for val in sublist]
dot_product = np.dot(point_1, point_2)
norm_1 = np.linalg.norm(point_1)
norm_2 = np.linalg.norm(point_2)
cos_sim = dot_product / (norm_1 * norm_2)
cs_list.append(cos_sim)
tv_copy = tv.copy()
tv_copy['cos_sim'] = cs_list
results = tv_copy.sort_values('cos_sim', ascending=False)
results = results[results['Title'] != search]
top_results = results.head(5)
return (top_results)
else:
return ('Title not in dataset. Please check spelling.')
def call_recommender():
subject = text.get()
recommendation = netflix_recommender(subject)
txt = ''
for i in recommendation.iterrows():
txt += 'Title: ' + str(i[1][0]) + '\n'
tk.Label(window, text=txt, font=('Calibri 15')).place(x=195, y=150)
text = tk.StringVar()
tk.Entry(window, textvariable=text).place(x=200, y=80, height=30, width=280)
tk.Button(window, text='Find Recommendations',
command=call_recommender).place(x=285, y=150)
window.mainloop()Ã'Â Бонусный проект: Калькулятор возраста
Недавно я создал новый проект по запросу читателя. Начинающий программист хотел создать калькулятор возраста на Python, но у него возникли проблемы. Вот почему я написал эту статью.
Как и в моих проектах выше, в этом содержится исходный код и объяснение того, почему я использовал тот код, который я использовал.
Как создать калькулятор возраста на Python
С чего начать Работу С Python
Сегодня мы наблюдаем все более широкое внедрение искусственного интеллекта (ИИ), машинного обучения (ML) и науки о данных в подавляющем большинстве секторов бизнеса. Одной из главных общих черт этих областей является то, что они так или иначе используют язык программирования Python.
Когда дело доходит до Python обучения в 2024 году у вас так много вариантов. Плюс, если вы предпочитаете углубленное и интерактивный опыт обучения, weâÂÂD Также рекомендуем наш новый курс Python.Ã'Â
Что Я должен создать с помощью Python?
Это отличный вопрос, особенно если вы новичок в программировании на Python.
Ну, во-первых, вы должны знать, что существует очень много приложений на Python в различных дисциплинах, так что у вас есть множество вариантов.
Конечно, Python завоевал прочную репутацию в области науки о данных, анализа данных, машинного обучения и искусственного интеллекта, но на этом все не заканчивается.
Это также действительно хорошо, когда дело доходит до веб-разработки, благодаря популярным фреймворкам веб-приложений, таким как Django и Flask.
Кроме того, он также идеально подходит для автоматизации повторяющихся задач, отсюда его происхождение как скриптового языка.
Проще говоря, вы можете многое создать с помощью Python, но если вы ищете вдохновения, вы находитесь в правильном месте!
Вот почему я собрал для вас 30 проектов на Python, в которых вы можете поучаствовать, начиная от начинающих и заканчивая продвинутыми.
Сворачивание
И вот оно! Если вы потратили время на создание этих 30 проектов на Python, вы должны чувствовать себя гораздо более компетентным и уверенным в работе с Python.
У вас также будет растущее портфолио на Python, в котором будет множество интересных и практичных проектов на Python, каждый из которых продемонстрирует вашу преданность делу и способности.
Я также надеюсь, что вам понравилось следить за моим пошаговым руководством по первому проекту на Python!
Моя цель при создании этих руководств по Python - познакомить вас с нюансами разработки на Python, а также дать вам практический опыт, который вы обычно получаете только при прохождении курса Python.
Здесь, в hackr.io, мы большие поклонники проектного обучения, поэтому я надеюсь, что эти проекты на Python укрепили вашу уверенность и пробудили более глубокий интерес к веб-разработке или любой другой форме разработки на Python.
Помните, что путешествие на этом не заканчивается!
Поскольку на этой странице регулярно появляются новые проекты и пошаговые руководства, обязательно заходите почаще, чтобы узнать о новых возможностях усовершенствовать свои навыки работы с Python и расширить свое портфолио.
Счастливого кодирования!
Понравилось работать с этими проектами на Python, и вы готовы погрузиться в Python еще глубже? Проверять:
Наш мастер-класс по Python - Python с доктором Джонсом
Часто задаваемые вопросы
1. Подходит ли Python для крупных проектов?
Несмотря на то, что существует мнение, что Python медленнее других популярных языков, таких как C и C++, Python по-прежнему широко используется многими ведущими технологическими компаниями, поскольку он очень универсален, легко обслуживается и предлагает множество библиотек и поддержку со стороны сообщества.
2. Каким должен быть Мой Первый Проект на Python?
Ознакомьтесь с любым из проектов для начинающих на Python, которые мы рассмотрели выше, включая Mad Libs, Камень-ножницы-бумага, Палач или Крестики-нолики!
Люди тоже читают:
- Вопросы для интервью на Python
- Руководство по очистке веб-страниц на Python
- Фреймворки Python
- Цикл Python While
- Операторы Python Is и равенства
- Условные операторы Python
- Шпаргалка по регулярным выражениям Python
- Интерпретаторы Python
Рекомендации
1. Бюро трудовой статистики Министерства труда США. Справочник по профессиональным перспективам, разработчики программного обеспечения [Интернет]. [обновлено 8 сентября 2021 г.; опубликовано 15 января 2024 г.]. Доступно по адресу: https://www.bls.gov/ooh/computer-and-information-technology/software-developers.htm
2. apilayer. Обновление API - ценообразования [Интернет]. apilayer; [дата неизвестна; опубликовано 15 января 2024 года]. Доступно по адресу: https://apilayer.com/marketplace/fixer-api#pricing
3. [нет автора]. Пример быстрого запуска OAuth2 [Интернет]. GitHub; [обновлено 26 апреля 2016 г.; опубликовано 15 января 2024 г.]. Доступно по адресу: https://github.com/reddit-archive/reddit/wiki/OAuth2-Quick-Start-Example#first-steps
4. Махиджа, С. Фильмы и телешоу Netflix за 2021 год [набор данных]. Kaggle; 2021. Доступно по адресу: https://www.kaggle.com/datasets/satpreetmakhija/netflix-movies-and-tv-shows-2021?resource=download