9 个很酷、简单且有趣的 Python 项目及其源代码
发布日期 ： 2023-09-11 00:50:40 UTC
访问量： 1888 次浏览
本文收录了 9 个有趣的 Python 项目， 从适合初学者的简单 Python 项目到中级和高级 Python 项目， 您可以用它们来挑战自己或提高 Python 编程技能。
适合初学者的 Python 项目
让我们开始了解一系列适合初学者的 Python 项目。
1.Mad Libs Generator
这是最有趣的 Python 初学者项目之一， 更不用说它可以让您练习如何使用字符串、变量和连接， 这些是所有技能级别的所有Python 应用程序的基本技能。
Mad Libs Generator 收集并处理用户输入数据作为形容词、代词和动词。 该程序获取这些数据并安排它来构建一个故事。
源代码：
'''
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('------------------------------------------')
2.Number Guessing
这个 Python 初学者项目是一个有趣的游戏， 它会生成一个随机数（在一定范围内）， 用户在收到提示后必须猜测该随机数。 对于用户做出的每个错误猜测， 他们都会收到额外的提示， 但代价是降低最终分数。
该程序是试验 Python 标准库的好方法， 因为它使用 Python random模块来生成随机数。 您还可以进行一些有关条件语句、打印格式和用户定义函数的实践练习。
源代码：
'''
Number Guessing Game
-------------------------------------------------------------
'''
import random
attempts_list = []
def show_score():
if not attempts_list:
print('There is currently no high score,'
' it\'s yours for the taking!')
else:
print(f'The current high score is'
f' {min(attempts_list)} attempts')
def start_game():
attempts = 0
rand_num = random.randint(1, 10)
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()
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
attempts_list.append(attempts)
if guess == rand_num:
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()
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 项目
3.二分查找算法
对于所有有抱负的程序员来说， 在某个时候在他们的 Python 编程项目中处理二分搜索是一种必经之路！ 用于二分搜索的 Python 项目接受一个排序列表（数组）， 并不断将搜索值与数组的中间进行比较。
根据搜索值是小于还是大于中间值， 列表被分割（分而治之策略）以减少搜索空间， 从而专注于给定的搜索值。 这种连续除法导致对数时间复杂度。
如果查看下面的代码，会发现我们实现了两种解决方案：条件循环和递归。 这两种方法都很优雅， 因此请随意尝试每种方法。 如果您是递归新手， 这是一个很好的介绍， 因为它演示了如何“减少”每个递归调用的问题大小， 即通过将列表拆分到当前中间元素的一侧。 我们还将递归基本情况定义为中间元素等于搜索元素时的点。 在这种情况下，递归将停止并通过调用堆栈向上返回 True 值。
源代码：
'''
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))
4.归并排序算法
合并排序是有抱负的程序员在寻找 Python 中要做的事情时, 面临的另一个流行的编码挑战。 这种分而治之的策略使用除法将数字列表分成相等的部分， 并对这些部分进行递归排序， 然后重新组合以生成排序列表。
如果刚刚完成二分搜索示例， 可能会注意到除法和缩小问题大小的一些相似之处。 你是对的，这意味着可能已经意识到需要使用递归。
合并排序的 Python 实现使用递归来处理分而治之的过程。 问题规模的不断减小使得问题能够在达到递归基本情况时得到解决， 即当问题规模为一个元素或更小时。 本质上， 这个 Python 程序继续递归地划分列表， 直到到达基本情况。此时， 它开始对问题的较小部分进行排序， 从而产生较小的排序数组， 这些数组被重新组合以最终生成完全排序的数组。 如果您熟悉 Big O 表示法， 那么一定会好奇归并排序的 Big O 为 (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)
5.密码生成器
这是一个有趣的 Python 项目， 它使用 Secret 和字符串模块来生成强大且安全的密码， 就像使用流行的密码管理器一样。
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())
6.队列
此 Python 项目创建一个新类来实现 Queue。 当需要处理先进先出 (FIFO) 场景（例如消息队列、CPU 任务等）时， 这是计算机科学中常见的数据结构。
该代码很简单， 并提供了一些面向对象编程的更多练习。 测试队列以了解其工作原理， 然后就可以在其他项目中使用此数据结构。
源代码：
'''
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())
7.Reddit 机器人
这个 Python 项目创建了一个自动化的 reddit 机器人， 其中包含一些新模块，即 praw 和 enchant（请参阅 pip install 命令）。 这是一个相当简单的概念， 因为程序会检查选定子 Reddit 中的每条评论， 并回复任何包含预定义“触发短语”的评论。为此， 我们使用 praw 模块与 reddit 进行交互， 并生成与评论相似的单词， 以便做出适当的回复。
如果您正在寻找 Python 项目来学习如何回答自己 Reddit 子版块中的问题， 那么这个想法非常有用。 只需要扩展此代码以包含对预定义问题的自动响应（可能已经注意到 Reddit 上的其他人正在使用此代码！）。
重要提示：需要查看相关说明来获取 client_id、client_secret、用户名、密码和 user_agent， 需要此信息才能通过 API 接口向 reddit 发表评论。
源代码：
'''
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 项目想法
8.聊天机器人
此 Python 项目使用 chatterbot 模块（请参阅下面的 pip install 说明）来训练自动聊天机器人来回答您提出的任何问题！ 我们现在正在使用人工智能！
您将看到该程序是此列表中相对较小的 Python 项目之一， 但如果想了解更多信息或扩展代码的功能， 请随意探索 ChatterBot 文档以及更广泛的 AI 聊天机器人领域。
重要提示： ChatterBot 不再主动维护。 这意味着您需要对位于 Python 安装文件夹的 “Lib/site-packages/chatterbot” 目录中的 tagging.py 文件进行一些小更改。 不用担心; 操作起来很简单， 我们已经提供了您需要使用的确切源代码， 如下所示。
源代码：
'''
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()
修改 tag.py：
找到第一个代码片段， 它是 PosLemmaTagger 类的 __init__ 方法的一部分。将其替换为 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())
9.Netflix推荐系统
我们把一个特别令人兴奋的 Python 项目留到最后！ 这是一个 Netflix 推荐系统， 非常适合有抱负的数据科学家或机器学习爱好者。
要创建此项目，需要导入一系列模块， 包括tkinter、re、nltk、pandas 和 numpy（有关新模块，请参阅 pip 安装说明）。 还需要从此处下载包含 Netflix 电影和电视节目的数据集。
我们将使用tkinter创建 GUI， 它将使用标签、按钮和输入字段。 用户将能够输入他们在 Netflix 上喜欢的电视节目或电影， 并根据他们的口味返回推荐。
推荐引擎使用演员、导演、收视率、国家/地区和类型作为机器学习 (ML)“特征”。 代码使用“余弦相似度”方法根据用户输入查找相似结果。 这广泛使用 pandas 和 numpy 来清理数据并准备进行处理。 这个例子中有很多东西需要解开。 最好的方法是慢慢地研究代码， 并对机器学习（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()