本文收录了 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()
以上就是“9 个很酷、简单且有趣味的 Python 项目及其源代码教程”的详细内容，想要了解更多Python教程欢迎持续关注编程学习网。
扫码二维码 获取免费视频学习资料
- 本文固定链接: http://www.phpxs.com/post/11688/
- 转载请注明：转载必须在正文中标注并保留原文链接
- 扫码： 扫上方二维码获取免费视频资料
查 看2022高级编程视频教程免费获取