如何用Python让你的电脑说话 你成为亿万花花公子的第一步  如果你是像《钢铁侠》这样的电影的粉丝，你可能已经幻想过得到你自己的贾维斯。那么，在这篇文章中，我将告诉你如何开始制作你自己的电脑助手。我们将通过一个小的编程和一些聪明的python包在引擎盖下进行数据科学。  现在，制作像超级智能人工智能这样复杂的东西是很难的，对于我来说，在一篇文章中甚至很可能在一般情况下都很难做到。然而，我们可以做的是把这个问题分解成更小的部分，使问题看起来更容易。这是你在每一个项目中都应该做的事情，这样就不会一下子被其所有的复杂性所困住了。  从我对这个问题的简单思考来看，我相信我们可以把一个超级智能的人工智能助手分成四个主要部分。  文本到语音（以获得回应） 语音转文字（用于询问事情） 一些计算，以了解我们的问题并创建一个响应 将回应变成现实世界中的行动 在今天的文章中，我将专注于计算机助手的文本到语音方面，让我们的计算机与我们交谈。如果一切顺利的话，我将在今后的文章中继续发展，使我们的助手变得更加复杂和有用。  找到一个文本到语音库 现在，用python做这样的事情有一个巨大的好处，那就是我们有大量的库可以使用，以快速完成事情。毕竟，如果我们从头开始开发其中的每一个部分，我们会在这里呆很久，以至于我们永远不会完成任何事情。让我们站在巨人的肩膀上，使用python软件包。  对于文本到语音来说，有几个Python包在人群中脱颖而出。  谷歌文本转语音（gTTs），以及 pyttsx3（我不知道那到底代表什么）。 谷歌文本转语音是一个Python库，用于连接谷歌翻译的文本转语音API。它具有谷歌自己的文本到语音应用程序的性能，但需要互联网连接才能使用。  另一方面，pyttsx3是一个文本到语音的转换库，它寻找预装在你的平台上的文本到语音引擎并使用它们。因此，它可以离线工作。  以下是它在主要操作系统上使用的文本转语音引擎。  Windows上的SAPI5 2. MacOSX上的NSSpeechSynthesizer  3.其他所有平台上的espeak  看看这两个，我不希望我的助手依赖谷歌或在线连接来工作。我更愿意使用pyttsx3，让一切都在我自己的机器上运行。  设置项目 现在，在我们开始运行一切之前，让我们设置我们的项目。  我们将通过文本编辑器和终端来完成一切。如果你不知道这意味着什么，那么我向人们推荐的文本编辑器是vscode，而终端通常内置在你的文本编辑器中（如vscode），或者是你电脑上的一个叫做 "终端 "或 "cmd "的程序。  现在，我想让你打开你的终端，改变目录到你保存项目的地方，例如，用  cd ~/projects 1 接下来，我们将需要创建一个目录来存储我们的项目。这完全取决于你，但我希望我的助手叫罗伯特。因此，我将创建一个名为 "robert "的新目录，然后用以下方式进入该目录  mkdir robert cd robert 1 你可以把这个名字改成你喜欢的样子，比如说Brandy或者Kumar之类的。  接下来，我们需要让python启动并运行。为此，我们将需要安装Python 3。如果你没有安装，请参阅https://www.python.org/，了解安装说明。我们还需要创建一个Python虚拟环境。如果你想了解更多这方面的信息，请看这里，我最近的一篇文章。  假设你已经安装了Python，你可以在终端用以下方法验证  python3 --version 1 现在你应该能够在你的robert目录下创建你的python虚拟环境了。  python3 -m venv venv 1 注意，如果你安装的python的版本是python，python3.7或者python3.9或者其他的，那么就使用这个版本。  然后你应该能够用以下方法激活你的虚拟环境。  (在MacOS和Linux上)  source venv/bin/activate 或 (Windows)  venv/Scripts/activate 1 现在我们需要安装我们需要的软件包。为了做到这一点，我们将创建一个requirements.txt文件。进入你最喜欢的文本编辑器，例如vscode，或者，如果你很冒险的话，vim，打开你的 "robert "文件夹，现在创建这个文件。  对于我们的项目，到目前为止，我们只需要pyttsx3。很简单。让我们现在把它添加到我们的requirements.txt文件中，如下所示  接下来，让我们用pip来安装我们的需求  pip install -r requirements.txt 1 使用pyttsx3  现在一切都安装好了，让我们开始使用pyttsx3。为了了解该怎么做，我查看了这里的文档。  然后，你可以通过创建一个名为speech.py的文件并添加以下代码来制作一个漂亮的例子。  import pyttsx3  engine = pyttsx3.init()  voice_num = 2 text_to_say = "Hello World! I am Robert!"  voices = engine.getProperty('voices') engine.setProperty('voice', voices[voice_num].id)  engine.say(text_to_say) engine.runAndWait() 1 我们首先导入pyttsx3以加载其所有的类和变量。然后我们初始化语音引擎，设置一个我们想要的声音，然后是我们想要说的文字。最后我们使用engine.runAndWait()来说话。  然后我们可以在终端用下面的命令运行这个文件。  python speech.py 1 玩一玩这个，改变text_to_say变量。你应该能说出任何你喜欢的东西。  酷！调整声音和速度  现在我们有了一些工作，让我们给我们的助手一些调整。Pyttsx3让我们调整声音和速度。  import pyttsx3  engine = pyttsx3.init()  # change voice  # getting details of current voice voices = engine.getProperty('voices')        for i in range(len(voices)):     engine.setProperty('voice', voices[i].id)     # say something     engine.say("Pick me, pick me! My voice is number " + str(i))     engine.runAndWait()  1 在上面的例子中，你可以改变声音_num到一个不同的数字来获得一个新的声音。从我的测试来看，这似乎取决于平台（可能取决于你的平台有SAPI5，NSSpeechSynthesizer或espeak）。  我创建了这个怪物般的文件（当很多机器人的声音用奇怪的口音和你说话时，你就会明白为什么），以帮助你决定什么声音最适合你。一旦你找到了你喜欢的声音号码，把这个号码换成在voice_num变量中找到的号码。  接下来的步骤  恭喜你达到了终点。如果你有任何问题或只是想打招呼，请在下面发表。  如果你想进一步阅读，我建议你查看下面的链接，并在即将到来的文章中获得先机。  https://www.geeksforgeeks.org/python-text-to-speech-by-using-pyttsx3/  https://realpython.com/python-speech-recognition/  对于我的下一篇文章，我将专注于语音转文字，这样我们的助手就可以对我们的命令作出回应🤖。给我一个关注，以确保你不会错过它。  本文由 mdnice 多平台发布 ———————————————— 版权声明：本文为CSDN博主「qq_40523298」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/qq_40523298/article/details/127766068 

 情况紧急 ⁉️ 不管你信不信，这就是俺刚瞧出的代码！！！ 现在离20：00还有38分钟！！！ 我现在在飞速的敲着文字，本来想着今晚简简单单买个东西就好，结果一看某宝，发现我想买的衣服有0元抢购的活动！！！  于是，刚吃完饭领完快递的我一到宿舍就开始劈里啪啦的敲起了代码，敲完代码后又进行一遍编的测试，终于将代码调试成功了。 具体实现如何，请往下看👇  抢❗️抢❗️抢❗️ 本次代码实现的功能是抢某宝的商品，需要先将商品加入购物车，然后根据用户输入的开抢时间进行任务等待，时间一到，立即开抢！！！ 注意：先设置好默认收货地址，然后将商品加入购物车！！！  开抢时间说明💨  开抢过程💥 Get_cookie.py Get_cookie.py – 老朋友又来了，《小玩意儿》专栏中已经说烂咯，那在这就简单说明一下吧： 在20秒内登录某宝，获取登录后的Cookie，保存为taobao_cookies.txt，这是实现自动登录前的必须一个步骤。  直接拿走💪  from selenium import webdriver from time import sleep import json  if __name__ == '__main__':   driver = webdriver.Chrome()   driver.maximize_window()   driver.get('https://login.taobao.com/member/login.jhtml?')   sleep(20)    dictCookies = driver.get_cookies() # 获取list的cookies   jsonCookies = json.dumps(dictCookies) # 转换成字符串保存   with open('taobao_cookies.txt', 'w') as f:     f.write(jsonCookies)   print('cookies保存成功！') 开抢 from selenium import webdriver from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.webdriver.common.by import By import datetime import time import json  class Taobao(object):     def __init__(self):         # 登入以下网址即可直接跳转到购物车         self.url = 'https://cart.taobao.com/cart.htm?'         self.driver = webdriver.Chrome()         self.driver.get(self.url)         self.driver.maximize_window()     # 自动登录     def login(self):         # 获取保存下的cookie值         with open('taobao_cookies.txt', 'r', encoding='utf8') as f:             listCookies = json.loads(f.read())          # 往browser里添加cookies         for cookie in listCookies:             cookie_dict = {                 'domain': '.taobao.com',                 'name': cookie.get('name'),                 'value': cookie.get('value'),                 "expires": '',                 'path': '/',                 'httpOnly': False,                 'HostOnly': False,                 'Secure': False             }             self.driver.add_cookie(cookie_dict)          self.driver.refresh()          # 等待快速登录按钮出现并点击         WebDriverWait(self.driver, 1000).until(             EC.presence_of_element_located((By.XPATH, '//div[@class="fm-btn"]/button'))         )         self.driver.find_element(By.XPATH, '//div[@class="fm-btn"]/button').click()      def shopping_cart(self):              # 设定时间等待，等到时间到了立即开抢         startTime = datetime.datetime(2022, 11, 10, 20, 0, 1)         print('正在等待开抢...')         while datetime.datetime.now() < startTime:             time.sleep(1)          # 点击全选         WebDriverWait(self.driver, 1000).until(             EC.presence_of_element_located((By.XPATH, '//div[@id="J_SelectAll1"]'))         )         self.driver.find_element(By.XPATH, '//div[@id="J_SelectAll1"]').click()          # 等待结算按钮出现后点击         WebDriverWait(self.driver, 1000).until(             EC.element_to_be_clickable((By.XPATH, '//a[@id="J_Go"]'))         )         self.driver.find_element(By.XPATH, '//a[@id="J_Go"]').click()         time.sleep(0.5)         try:             self.driver.find_element(By.XPATH, '//a[@id="J_Go"]').click()         except:             pass          WebDriverWait(self.driver, 1000).until(             EC.element_to_be_clickable((By.LINK_TEXT, '提交订单'))         )         # 等待“提交订单”元素加载完毕后点击         self.driver.find_element(By.LINK_TEXT, '提交订单').click()      def run(self):         self.login()         self.shopping_cart()  taobao = Taobao() taobao.run()   结束语😱 如果喜欢，点赞👍 收藏🌈 关注哦💖 话不多说，开抢啦啦啦！！！  ———————————————— 版权声明：本文为CSDN博主「街 三 仔」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/Oh_Python/article/details/127794789 

一、项目简介 本项目主要基于python实现的多人聊天室，主要的功能如下：  登录注册 添加好友 与好友进行私聊 创建群聊 邀请/申请加入群聊 聊天发送图片 聊天发送表情 聊天发送文件 聊天记录保存在本地中 聊天过程中发送的文件保存本地 二、环境介绍 python3.8 mysql8.0 tkinter：作为程序的gui库 flask ：主要用于登录/注册、表情下载、信息修改等http请求等 socket：主要用户聊天过程中消息发送、对方在线状态更新等 pygame：用于播放新消息提示音 三、运行展示 登录：  注册：  登录后主界面：  点击右上方“修改资料”：  添加好友或群：  ​双击好友或群打开聊天窗口：  点击表情按钮选择发送的表情：  发送图片可以预览，点击文件名称直接打开：  四、关键代码 配置文件：server.conf  配置服务器ip、http端口、socket端口、数据库的账号密码、是否启用新消息提示音  [server] SERVER_IP = 127.0.0.1 HTTP_PORT = 8000 SOCKET_PORT = 8001 SQLALCHEMY_DATABASE_URI = mysql://root:root@127.0.0.1:3306/chatdb ENABLE_MUSIC = 0 服务端主要代码：ChatServer.py  维持Socket通信、开启Flask进行http  # controller定义 @app.route('/login', methods=['POST']) def login():     try:         params = request.values         login_name = params['loginName']         pwd = params['pwd']         md5 = hashlib.md5()         md5.update(pwd.encode(encoding='utf-8'))         password = md5.hexdigest()          users = Users.query.filter(Users.loginName == login_name)\             .filter(Users.pwd == password).all()         if len(users) == 0:             return Result.fail('账号不存在或密码错误')         else:             # 服务返回uid，客户端打开好友界面后，凭借此uid与服务器进行socket连接             uid = users[0].id             # 已存在uid：已登录，重新登录，原登录退出连接，退出程序             if uid in online_users.keys():                 # logout                 connection = online_users[int(uid)]                 send_msg = {'type': UtilsAndConfig.SYSTEM_LOGOUT}                 connection.send(json.dumps(send_msg).encode())             online_users[uid] = None              return Result.success(uid)     except Exception as e:         return Result.fail('参数异常')  # 监听socket def socket_listen_thread():     while True:         connection, address = mySocket.accept()         # 用户连接携带的uid，判断是否和服务器相同         data_dic = json.loads(connection.recv(1024).decode())          uid = None         if data_dic['type'] == UtilsAndConfig.CONNECTION_REQUEST:             uid = int(data_dic['uid'])         else:             connection.send(UtilsAndConfig.CONNECTION_NOT_ALLOWED.encode())         if uid in online_users.keys():             # 可建立连接             online_users[uid] = connection             connection.send(UtilsAndConfig.CONNECTION_ALLOWED.encode())              # 通知好友们，我上线了             friends = get_friends_by_uid(uid)             for f in friends:                 if f.id in online_users.keys():                     friend_connection = online_users[f.id]                     send_msg = {'type': UtilsAndConfig.FRIENDS_ONLINE_CHANGED, 'uid': uid, 'online': 1}                     friend_connection.send(json.dumps(send_msg).encode())              # 创建子线程，保持通信             keep_link_thread = threading.Thread(target=socket_keep_link_thread, args=(connection, ))             keep_link_thread.setDaemon(True)             keep_link_thread.start()         else:             connection.send(UtilsAndConfig.CONNECTION_NOT_ALLOWED.encode())  def socket_keep_link_thread(connection):     while True:         try:             msg = connection.recv(1024).decode()             if not msg:                 if connection in online_users.values():                     uid = list(online_users.keys())[list(online_users.values()).index(connection)]                     online_users.pop(uid)                     friends = get_friends_by_uid(uid)                     for f in friends:                         if f.id in online_users.keys():                             friend_connection = online_users[f.id]                             send_msg = {'type': UtilsAndConfig.FRIENDS_ONLINE_CHANGED, 'uid': uid, 'online': 0}                             friend_connection.send(json.dumps(send_msg).encode())                     connection.close()                 return             else:                 msg_json = json.loads(str(msg))                 # 发消息                 if msg_json['type'] == UtilsAndConfig.CHAT_SEND_MSG:                     to_id = msg_json['toId']                     is_friend = msg_json['isFriend']                     from_uid = msg_json['fromId']                     send_time = msg_json['sendTime']                     msg_text = msg_json['msgText']                      data = {'from_uid': from_uid, 'to_id': to_id, 'send_time': send_time, 'msg_text': msg_text,                             'is_friend': is_friend, 'type': '', 'msg_type': 'train'}                     # 通知接收方，收到新消息                     if is_friend == 1:                         if to_id in online_users.keys():                             friend_connection = online_users[to_id]                             data['type'] = UtilsAndConfig.CHAT_HAS_NEW_MSG                             friend_connection.send(json.dumps(data).encode())                              # 通知发送方，发送成功                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_SUCCESS                             connection.send(json.dumps(data).encode())                         else:                             # 通知发送方，发送失败，对方不在线                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_ERR                             connection.send(json.dumps(data).encode())                     else:                         # 群                         members = get_group_members(to_id)                         members_online = False                         for m in members:                             if m.uId in online_users.keys() and m.uId != from_uid:                                 members_online = True                                 member_connection = online_users[m.uId]                                 data['type'] = UtilsAndConfig.CHAT_HAS_NEW_MSG                                 member_connection.send(json.dumps(data).encode())                         if members_online:                             # 通知发送方，发送成功                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_SUCCESS                             connection.send(json.dumps(data).encode())                         else:                             # 通知发送方，发送失败，对方不在线                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_ERR                             connection.send(json.dumps(data).encode())                 if msg_json['type'] == UtilsAndConfig.CHAT_SEND_FILE:                     from_id = msg_json['from_id']                     to_id = msg_json['to_id']                     is_friend = msg_json['is_friend']                     send_date = msg_json['send_date']                     file_length = msg_json['file_length']                     file_suffix = msg_json['file_suffix']                     file_name = msg_json['file_name']                      file_save_name = str(uuid.uuid1()) + '.' + file_suffix                     return_file_path = '/static/tmp/' + file_save_name                     file_path = os.path.abspath(os.path.dirname(__file__)) + return_file_path                     if not os.path.exists(os.path.dirname(file_path)):                         os.makedirs(os.path.dirname(file_path))                      data = {'from_uid': from_id, 'to_id': to_id, 'send_time': send_date, 'file_name': file_name,                             'is_friend': is_friend, 'type': UtilsAndConfig.CHAT_SEND_FILE_SUCCESS,                             'file_path': return_file_path}                      if is_friend == 1:                         if to_id not in online_users.keys():                             # 通知发送方，发送失败，对方不在线                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_ERR                             connection.send(json.dumps(data).encode())                             continue                     else:                         members = get_group_members(to_id)                         flag = True                         for m in members:                             if m.uId in online_users.keys() and m.uId != from_id:                                 flag = False                                 break                         if flag:                             # 通知发送方，发送失败，对方不在线                             data['type'] = UtilsAndConfig.CHAT_SEND_MSG_ERR                             connection.send(json.dumps(data).encode())                             continue                      # 接收文件                     total_data = b''                     file_data = connection.recv(1024)                     total_data += file_data                     num = len(file_data)                     while num < file_length:                         file_data = connection.recv(1024)                         num += len(file_data)                         total_data += file_data                      with open(file_path, "wb") as f:                         f.write(total_data)                      connection.send(json.dumps(data).encode())                      # 通知接收方，收到新文件消息                     if is_friend == 1:                         friend_connection = online_users[to_id]                         data['type'] = UtilsAndConfig.CHAT_HAS_NEW_FILE                         friend_connection.send(json.dumps(data).encode())                     else:                         members = get_group_members(to_id)                         for m in members:                             if m.uId in online_users.keys() and m.uId != from_id:                                 member_connection = online_users[m.uId]                                 data['type'] = UtilsAndConfig.CHAT_HAS_NEW_FILE                                 member_connection.send(json.dumps(data).encode())          except ConnectionAbortedError:             if connection in online_users.values():                 uid = list(online_users.keys())[list(online_users.values()).index(connection)]                 online_users.pop(uid)                 friends = get_friends_by_uid(uid)                 for f in friends:                     if f.id in online_users.keys():                         friend_connection = online_users[f.id]                         send_msg = {'type': UtilsAndConfig.FRIENDS_ONLINE_CHANGED, 'uid': uid, 'online': 0}                         friend_connection.send(json.dumps(send_msg).encode())                 connection.close()             return         except ConnectionResetError:             if connection in online_users.values():                 uid = list(online_users.keys())[list(online_users.values()).index(connection)]                 online_users.pop(uid)                 friends = get_friends_by_uid(uid)                 for f in friends:                     if f.id in online_users.keys():                         friend_connection = online_users[f.id]                         send_msg = {'type': UtilsAndConfig.FRIENDS_ONLINE_CHANGED, 'uid': uid, 'online': 0}                         friend_connection.send(json.dumps(send_msg).encode())                 connection.close()             return  # 主线程 if __name__ == '__main__':     # 启动socket线程     socketThread = threading.Thread(target=socket_listen_thread)     socketThread.setDaemon(True)     socketThread.start()      # 启动Flask服务器     app.run(host=serverConfig.SERVER_IP, port=serverConfig.HTTP_PORT, debug=False) 客户端主界面：ChatHome.py  与服务器保持Socket通信、与服务端进行http交互  class ChatHome:     def run(self):         pygame.mixer.init()          # Socket连接         self.socket.connect((self.server_config.SERVER_IP, self.server_config.SOCKET_PORT))         send_data = {'type': UtilsAndConfig.CONNECTION_REQUEST, 'uid': self.uid}         self.socket.send(json.dumps(send_data).encode())         socket_result = self.socket.recv(1024).decode()         if socket_result != UtilsAndConfig.CONNECTION_ALLOWED:             tkinter.messagebox.showwarning('提示', '参数出错，socket连接被拒绝!')             sys.exit()          # 创建子线程保持socket通信         keep_link_thread = threading.Thread(target=self.socket_keep_link_thread)         keep_link_thread.setDaemon(True)         keep_link_thread.start()          # 基本信息         self.root = tk.Tk()         self.root.title('ChatRoom')         self.root.geometry('320x510+100+0')          # 用户名         self.frame_user_info = Frame(self.root, relief=RAISED, width=320, borderwidth=0, height=70, bg='#4F7DA4')         self.frame_user_info.place(x=0, y=0)         self.init_user_info()          # 中间画布canvas         self.frame_mid = Frame(self.root, width=320, height=340)         self.frame_mid.place(x=0, y=70)         # # 画布中的frame         self.init_friends_and_group_view()         # 下方按钮         frame_bottom_button = Frame(self.root, relief=RAISED, borderwidth=0, width=320, height=50)         frame_bottom_button.place(x=0, y=420)         button_bottom_add_friends = Button(frame_bottom_button, width=11,                                            text='加好友/加群', command=self.open_add_friends)         button_bottom_add_friends.place(x=55, y=10)         button_bottom_create_groups = Button(frame_bottom_button, width=11,                                              text='创建群', command=self.open_create_groups)         button_bottom_create_groups.place(x=165, y=10)          # 新消息         frame_message = Frame(self.root, relief=RAISED, borderwidth=0, width=320, height=50)         frame_message.place(x=0, y=460)         self.label_message_tip = Label(frame_message)         self.label_message_tip.place(x=55, y=12)         self.refresh_message_count()         button_message_open = Button(frame_message, width=7,                                      text='查看', command=self.open_message_window)         button_message_open.place(x=193, y=10)         self.root.mainloop()      # 保持socket通信     def socket_keep_link_thread(self):         while True:             try:                 back_msg = self.socket.recv(1024).decode()                 msg = json.loads(back_msg)                 # 好友状态改变                 if msg['type'] == UtilsAndConfig.FRIENDS_ONLINE_CHANGED:                     self.frames_friend_view[msg['uid']].online_type_change(msg['online'])                 # 有新验证消息                 if msg['type'] == UtilsAndConfig.MESSAGE_NEW_MSG:                     self.refresh_message_count()                     self.play_new_msg_music()                 # 好友/群数量改变                 if msg['type'] == UtilsAndConfig.FRIENDS_GROUPS_COUNT_CHANGED:                     self.init_friends_and_group_view()                     self.refresh_message_count()                 # 有新文本消息， 写入缓存，更新显示                 if msg['type'] == UtilsAndConfig.CHAT_HAS_NEW_MSG:                     from_uid = msg['from_uid']                     to_id = msg['to_id']                     is_friend = msg['is_friend']                     txt = {'type': 'get', 'from_uid': from_uid, 'datetime': msg['send_time'],                            'msg': msg['msg_text'], 'msg_type': 'train'}                     UtilsAndConfig.add_one_chat_record(self.uid, is_friend, from_uid, to_id,                                                        json.dumps(txt, cls=UtilsAndConfig.MyJSONEncoder,                                                                   ensure_ascii=False), False)                     # 是否打开聊天界面，打开则更新，未打开则好友列表提示新消息                     if self.window_chat_context is not None and self.window_chat_context.to_id == from_uid\                             and self.window_chat_context.is_friend == 1 and is_friend == 1:                         self.window_chat_context.get_new_msg()                         pass                     elif self.window_chat_context is not None and self.window_chat_context.to_id == to_id\                             and self.window_chat_context.is_friend == 0 and is_friend == 0:                         self.window_chat_context.get_new_msg()                     else:                         if is_friend == 1:                             self.frames_friend_view[from_uid].new_msg_comming()                         else:                             self.frames_group_view[to_id].new_msg_comming()                     self.play_new_msg_music()                 # 发送文本消息成功， 写入本地缓存，更新显示                 if msg['type'] == UtilsAndConfig.CHAT_SEND_MSG_SUCCESS:                     from_uid = msg['from_uid']                     to_id = msg['to_id']                     send_time = msg['send_time']                     msg_text = msg['msg_text']                     is_friend = msg['is_friend']                     txt = {'type': 'send', 'datetime': send_time, 'msg': msg_text, 'msg_type': 'train'}                     UtilsAndConfig.add_one_chat_record(self.uid, is_friend, from_uid, to_id,                                                        json.dumps(txt, cls=UtilsAndConfig.MyJSONEncoder,                                                                   ensure_ascii=False), True)                     self.window_chat_context.get_new_msg()                 # 发送文件成功                 if msg['type'] == UtilsAndConfig.CHAT_SEND_FILE_SUCCESS:                     to_id = msg['to_id']                     send_time = msg['send_time']                     file_name = msg['file_name']                     is_friend = msg['is_friend']                     txt = {'type': 'send', 'datetime': send_time, 'msg': file_name, 'msg_type': 'file'}                     UtilsAndConfig.add_one_chat_record(self.uid, is_friend, self.uid, to_id,                                                        json.dumps(txt, cls=UtilsAndConfig.MyJSONEncoder,                                                                   ensure_ascii=False), True)                     self.window_chat_context.get_new_msg()                     self.window_chat_context.sending_file(False)                 # 收到文件                 if msg['type'] == UtilsAndConfig.CHAT_HAS_NEW_FILE:                     to_id = msg['to_id']                     from_uid = msg['from_uid']                     send_time = msg['send_time']                     file_name = msg['file_name']                     is_friend = msg['is_friend']                     file_path = msg['file_path']                     files_dir = os.path.abspath(os.path.dirname(__file__)) + '/static/LocalCache/' \                                 + str(self.uid) + '/files/'                     if not os.path.exists(os.path.dirname(files_dir)):                         os.makedirs(os.path.dirname(files_dir))                      all_file_name = file_name.split('/')[-1]                     file_suffix = all_file_name.split('.')[-1]                     end_index = len(all_file_name) - len(file_suffix) - 1                     file_name = all_file_name[0:end_index]                     file_save_path = files_dir + file_name + '.' + file_suffix                     i = 1                     while os.path.exists(file_save_path):                         file_save_path = files_dir + file_name + '（' + str(i) + '）' + '.' + file_suffix                         i += 1                     # http下载文件，保存到本地                     try:                         url = self.server_config.HTTP_SERVER_ADDRESS + file_path                         res = requests.get(url)                         file_content = res.content                         file = open(file_save_path, 'wb')                         file.write(file_content)                         file.close()                     except requests.exceptions.InvalidSchema:                         pass                         # 服务器中文件不存在                     txt = {'type': 'get', 'from_uid': from_uid, 'datetime': send_time,                            'msg': file_save_path, 'msg_type': 'file'}                     UtilsAndConfig.add_one_chat_record(self.uid, is_friend, from_uid, to_id,                                                        json.dumps(txt, cls=UtilsAndConfig.MyJSONEncoder,                                                                   ensure_ascii=False), False)                      if self.window_chat_context is not None and self.window_chat_context.to_id == from_uid\                             and self.window_chat_context.is_friend == 1 and is_friend == 1:                         self.window_chat_context.get_new_msg()                         pass                     elif self.window_chat_context is not None and self.window_chat_context.to_id == to_id\                             and self.window_chat_context.is_friend == 0 and is_friend == 0:                         self.window_chat_context.get_new_msg()                     else:                         if is_friend == 1:                             self.frames_friend_view[from_uid].new_msg_comming()                         else:                             self.frames_group_view[to_id].new_msg_comming()                     self.play_new_msg_music()                     # 告诉服务器 文件下载完成，可删除                     url = self.server_config.HTTP_SERVER_ADDRESS + '/downloadFileSuccess?path=' + file_path                     requests.get(url)                 # 发送聊天消息失败，不写入缓存，提示对方已下线                 if msg['type'] == UtilsAndConfig.CHAT_SEND_MSG_ERR:                     tkinter.messagebox.showwarning('提示', '对方已下线，不能发送消息')                 # 服务器强制下线                 if msg['type'] == UtilsAndConfig.SYSTEM_LOGOUT:                     self.socket.close()                     tkinter.messagebox.showwarning('提示', '此账号已在别处登录!')                     self.root.destroy()                     return             except ConnectionAbortedError:                 tkinter.messagebox.showwarning('提示', '与服务器断开连接!')                 self.root.destroy()                 return             except ConnectionResetError:                 tkinter.messagebox.showwarning('提示', '与服务器断开连接!')                 self.root.destroy()                 return ———————————————— 版权声明：本文为CSDN博主「抱着西瓜吹空调」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/be_your1/article/details/124462875 

 前言 嗨喽，大家好呀~这里是爱看美女的茜茜呐  又到了学Python时刻~   随着大数据和人工智能的发展，Python也与多种科技深深绑定。  比如自动化测试，运维，爬虫，数据分析，机器学习，金融领域，后端开发，云计算，游戏开发都有涉及。  万丈高楼平地起，Python这座大厦能够如此强大，就是拥有强大的成千上万的库的支持  无数牛x的轮子在支持这座大厦，今天我们来一起梳理一下，俯瞰整个Python宝库。   那么什么是库呢？  从代码角度讲：库就是一堆类(class)和函数(function)的集合。  从应用角度讲：库类似生活中的工具箱，箱子里有很多做其他事情必不可少的工具。  举一个例子，如果你想抓取某网站的数据或图片，那么你就需要能处理相关底层网络连接的代码，而这些代码都已经被写好了，你只需要调用库里的函数或类，能够提高开发效率。  面对不同的情况，自然需要不同的工具箱，那么，都有哪些Python库呢？   一、数据处理 Chardet  # 字符编码探测器，可以自动检测文本、网页、xml的编码；  colorama # 主要用来给文本添加各种颜色，并且非常简单易用；  Prettytable # 主要用于在终端或浏览器端构建格式化的输出  difflib  # Python标准库，计算文本差异；  Levenshtein # 快速计算字符串相似度  fuzzywuzzy  # 字符串模糊匹配  esmre  # 正则表达式的加速器  shortuuid   # 一组简洁URL/UUID函数库  ftfy  #  Unicode文本工具7  unidecode   #  ascii和Unicode文本转换函数  xpinyin   # 将汉字转换为拼音的函数库  pangu.py  #  调整对中日韩文字当中的字母、数字间距；  pyfiglet   #  Python写的figlet程序，使用字符组成ASCII艺术图片；  uniout    #  提取字符串中可读写的字符  awesome slugify    #一个Python slugify库，用于处理Unicode。  python-slugify   # 转换Unicode为ASCII内码的slugify函数库  unicode-slugify   # 生成unicode内码，Django的依赖包。  ply  #  Python版的lex和yacc的解析工具  phonenumbers   # 解析电话号码，格式，存储和验证的国际电话号码  python-user-agents    # 浏览器的用户代理（user-agents）的解析器  sqlparse   # SQL解析器  pygments    # 一个通用的语法高亮工具  python-nameparser    # 解析人名，分解为单独的成分；  pyparsing     # 通用解析器生成框架  tablib    # 表格数据格式，包括，XLS、CSV，JSON，YAML；  python-docx     # docx文档读取，查询和修改，微软Word 2007 / 2008的docx文件；  xlwt/xlrd     # 读写Excel格式的数据文件  xlsxwriter   # 创建Excel格式的xlsx文件  xlwings   #  利用Python调用Excel  csvkit    # CSV文件工具包  marmir   # 把Python[数据结构]，转化为电子表格；  pdfminer    # 从PDF文件中提取信息  pypdf2     # 合并和转换PDF页面的函数库  Python-Markdown     # 轻量级标记语言Markdown的Python实现  Mistune    # 快速、全功能的纯Python编写的Markdown解释器；  dateutil    # 标准的Python官方datetime模块的扩展包，字符串日期工具，其中parser是根据字符串解析成datetime，而rrule是则是根据定义的规则来生成datetime；  arrow    # 更好的日期和时间处理Python库  chronyk    # 一个Python 3版函数库，用于解析人写的时间和日期；  delorean   # 清理期时间的函数库  when.py   # 为见的日期和时间，提供人性化的功能；  moment     # 类似Moment.js的日期/时间Python库  pytz     # 世界时区，使用tz database时区信息[数据库] ；  BeautifulSoup    # 基于Python的HTML/XML解析器，简单易用, 功能很强大,即使是有bug，有问题的html代码，也可以解析；  lxml   # 快速，易用、灵活的HTML和XML处理库，功能超强，在遇到有缺陷、不规范的xml时，Python自带的xml处理器可能无法解析。报错时，程序会尝试再用lxml的修复模式解析；  htmlparser    #  官方版解析HTML DOM树，偶尔搞搞命令行自动表单提交用得上；  pyyaml    # Python版本的YAML解释器  html5lib   # 解析和序列化HTML文档和片段  pyquery    # 类似[jQuery]的的HTML解释器函数库  cssutils   # Python CSS库   MarkupSafe    #  XML或HTML / XHTML安全字符串标记工具   cssutils - ACSS library for Python., MarkupSafe - Implements a XML/HTML/XHTML bleach    # 漂白，基于HTML的白名单函数库；  xmltodict   # 类似JSON的XML工具包  xhtml2pdf   # HTML / CSS格式转换器，看生成pdf文档；  untangle     # 把XML文档，转换为Python对象，方便访问； 二、文件处理 Mimetypes  # Python标准库，映射文件名到MIME类型；  imghdr    # Python标准库，确定图像类型。python-magic，libmagic文件类型识别库，Python接口格式。path.py，os.path模块的二次封装；  watchdog    # 一组API和shell实用程序，用于监视文件系统事件；  Unipath   # 面向对象的文件/目录的操作工具包  pathlib   # （Python 3.4版已经作为Python标准库），一个跨平台，面向path的函数库；  pickle/cPickle    # python的pickle模块实现了基本的数据序列和反序列化。通过pickle模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储；通过pickle模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象；  cPickle  #  是[C语言]实现的版本，速度更快；  ConfigParser   # Python标准库，INI文件解析器；  configobj   # INI文件解析器。config，分层次配置，logging作者编写；  profig  #  多格式配置转换工具  logging    #  Python标准库，日志文件生成管理函数库；  logbook    #  logging的替换品  Sentry   # 实时log服务器。Raven，哨兵Sentry的Python客户端；  Sphinx   #  斯芬克斯（狮身人面像），Python文档生成器；  reStructuredText   #  标记语法和解析工具，Docutils组件。mkdocs，Markdown格式文档生成器；  pycco    #  简单快速、编程风格的文档生成器；  pdoc     # 自动生成的Python库API文档epydoc，从源码注释中生成各种格式文档的工具； 三、图像处理 更多精彩机密、教程，尽在下方，赶紧点击了解吧~  点击 蓝色字体 自取，我都放在这里了。  PIL（Python Image Library） # 基于Python的图像处理库，功能强大，对图形文件的格式支持广泛，内置许多图像处理函数，如图像增强、滤波[算法]等Pillow，图像处理库，PIL图像库的分支和升级替代产品。Matplotlib，著名的绘图库，提供了整套和matlab相似的命令API，用以绘制一些高质量的数学二维图形，十分适合交互式地进行制图。brewer2mpl，有一个专业的python配色工具包，提供了从美术角度来讲的精美配色；  PyGame  # 基于Python的多媒体开发和游戏软件开发模块，包含大量游戏和图像处理功能Box2d，开源的2d物理引擎，愤怒的小鸟就是使用了这款物理引擎进行开发的，Box2d物理引擎内部模拟了一个世界，你可以设置这个世界里的重力，然后往这个世界里添加各种物体，以及他们的一些物理特性，比如质量，摩擦，阻尼等等；  Pymunk  # 类似box2d的开源物理图形模拟库OpenCV, 目前最好的开源图像/视觉库，包括图像处理和计算机视觉方面、[机器学习]的很多通用算法。SimpleCV，计算机视觉开源框架，类似opencv。VTK，视觉化工具函式库（VTK， Visualization Toolkit）是一个开放源码，跨平台、支援平行处理（VTK曾用于处理大小近乎1个Petabyte的资料，其平台为美国Los Alamos国家实验室所有的具1024个处理器之大型系统）的图形应用函式库；  Aggdraw   # 开源图像库，几乎涵盖了2d image操作的所有功能，使用起来非常灵活Pycairo,开源矢量绘图库Cairo开罗的python接口，cairo提供在多个背景下做2-D的绘图，高级的更可以使用硬件加速功能。wand，Python绑定魔杖工具（MagickWand），C语言API接口；  thumbor   #  智能成像工具，可调整大小和翻转图像；  imgSeek    # 查询相似的图像  python-qrcode    # 纯Python的二维码（QR码）生成器  pyBarcode    # 创建条码，无需PIL模块；  pygram    # Instagram 像图像过滤器  Quads    # 基于四叉树的计算机艺术  nude.py   # 裸体检测函数  scikit-image    #  scikit工具箱的图像处理库  hmap    # 图像直方图工具  bokeh   #  交互的Web绘图  plotly   #  Web协同的Python和Matplotlib绘制  vincent    #  文森特，Python Vega的函数库  d3py    #Python绘图库，基于D3.JS, ggplot -API兼容R语言的ggplot2.Kartograph.py，在Python绘制漂亮的SVG地图。pygal， SVG图表的创造者；  pygraphviz   # Graphviz的Python接口  Fonttlools    # ttf字体工具函数包，用于fontforge、ttx等字体软件；  四、游戏和多媒体 audiolazy   #  数字信号处理（DSP）的Python工具包  audioread  #  跨平台（GStreamer + Core Audio + MAD + FFmpeg）音频解码库。 beets，音乐库管理；  dejavu   # 音频指纹识别算法  Dejavu   #  听一次音频后就会记录该音频的指纹信息，然后可通过麦克风对输入的音频进行识别是否同一首歌。django-elastic-transcoder,Django +亚马逊elastic转码。eyeD3,音频文件工具，特别是MP3文件包含的ID3元数据；  id3reader  # 用于读取MP3的元数据  mutagen   # 处理音频元数据  pydub   # 操纵音频和简单的高层次的接口  pyechonest  # Echo Nest API客户端。talkbox，语音和信号处理的Python库;  TimeSide   # 开放的网络音频处理框架  tinytag   #  读取音乐文件元数据，包括的MP3，OGG，FLAC和wave文件;  m3u8  # 用于解析m3u8文件  moviepy   # 多格式视频编辑脚本模块，包括GIF动画;  http://shorten.tv  # 视频摘要  scikit视频   # SciPy视频处理例程  GeoDjango   # 一个世界级的地理Web框架  geopy  # Geo地理编码的工具箱  pygeoip   # 纯Python写的GeoIP API  GeoIP  # Python API接口，使用高精度GeoIP Legacy Database数据库;  geojson   # GeoJSON函数库django-countries，一个Django程序，提供国家选择，国旗图标的静态文件，和一个国家的地域模型;  Pygame  # Python游戏设计模块  Cocos2d  # 2D游戏框架，演示，和其他的图形/交互应用，基于pyglet。Cocos2d- cocos2d is a framework for building 2D games, demos, and other graphical/interactive applications. It is based on pyglet.,PySDL2，SDL2的封装库;  Panda3D  #  3D游戏引擎，迪士尼开发;  PyOgre  # OGRE 3D渲染引擎，可用于游戏，模拟，任何3D;  PyOpenGL   # 绑定OpenGL和它相关的API  PySFML  # Python绑定SFMLRenPy，视觉小说引擎;  五、大数据与科学计算 pycuda/opencl  # GPU高性能并发计算Pandas，python实现的类似R语言的数据统计、分析平台。基于NumPy和Matplotlib开发的，主要用于数据分析和数据可视化，它的数据结构DataFrame和R语言里的data.frame很像，特别是对于时间序列数据有自己的一套分析机制，非常不错;  Open Mining   # 商业智能（BI），Pandas的Web界面。blaze，NumPy和Pandas大数据界面。 SciPy，开源的Python算法库和数学工具包，SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算；  ScientificPython  #  一组经过挑选的Python程序模块，用于科学计算，包括几何学（矢量、张量、变换、矢量和张量场），四元数，自动求导数，（线性）插值，多项式，基础统计学，非线性最小二乘拟合，单位计算，Fortran兼容的文本格式，通过VRML的3D显示，以及两个Tk小工具，分别用于绘制线图和3D网格模型。 此外还具有到netCDF，MPI和BSPlib库的接口；  NumPy  #  科学计算库，提供了矩阵，线性代数，傅立叶变换等等的解决方案, 最常用的是它的N维数组对象. NumPy提供了两种基本的对象： ndarray（N-dimensional array object）和 ufunc（universal function object；  ndarray  # 是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。 Cvxopt，最优化计算包，可进行线性规划、二次规划、半正定规划等的计算。 Numba，科学计算速度优化编译器。pymvpa2，是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架；  PyDy  #  Python动态建模函数库  SymPy   # 符号数学的Python库  statsmodels  # Python的统计建模和计量经济学  astropy  #  天文学界的Python库  orange   #  橙色，数据挖掘，数据可视化，通过可视化编程或Python脚本学习机分析；  RDKit  # 化学信息学和机器学习的软件  Open Babel  #  巴贝尔，开放的化学工具箱；  cclib   # 化学软件包的计算函数库  Biopython  # 免费的生物计算工具包  bccb  # 生物分析相关的代码集    bcbio-nextgen  #  提供完全自动化、高通量、测序分析的工具包；  visvis   #  可视化计算模块库，可进行一维到四维数据的可视化；  MapReduce  #  是Google提出的一个软件[架构]，用于大规模数据集（大于1TB）的并行运算。 概念“Map（映射）”和“Reduce（归纳）”，及他们的主要思想，都是从函数式编程语言借来的MapReduce函数库。Framworks and libraries for MapReduce.,PySpark，[Spark]的Python API。dpark，Spark的Python克隆，Python中的MapReduce框架。luigi，为批量工作，建立复杂的管道。mrjob，运行在[Hadoop]，或亚马逊网络服务的，MapReduce工作； 六、人工智能与机器学习 更多精彩机密、教程，尽在下方，赶紧点击了解吧~  点击 蓝色字体 自取，我都放在这里了。  NLTK（natural language toolkit)  # 是python的自然语言处理工具包。2001年推出，包括了大量的词料库，以及自然语言处理方面的算法实现： 分词， 词根计算， 分类， 语义分析等;  Pattern # 数据挖掘模块，包括自然语言处理，机器学习工具，等等;  textblob  # 提供API为自然语言处理、分解NLP任务。基于NLTK和Pattern模块;  jieba  # 结巴，中文分词工具。snownlp，用于处理中文文本库;  loso  # 中文分词函数库  genius  #  中文CRF基础库，条件随机场(conditional random field,简称 CRF),是一种鉴别式机率模型,是随机场的一种,常用于标注或分析序列资料,如自然语言文字或是生物序列Gensim，一个相当专业的主题模型Python工具包，无论是代码还是文档，可用于如何计算两个文档的相似度LIBSVM,是台湾大学林智仁(Lin Chih-Jen)教授等开发设计的一个简单、易于使用和快速有效的SVM模式识别与回归的软件包，他不但提供了编译好的可在Windows系列系统的执行文件，还提供了源代码，方便改进、修改以及在其它[操作系统]上应用；  scikits.learn   # 构建在SciPy之上用于机器学习的 Python 模块。它包括简单而高效的工具，可用于数据挖掘和数据分析;  PyMC  # 主要用来做Bayesian分析。Orange，基于组件的数据挖掘和机器学习软件套装，它的功能即友好，又很强大，快速而又多功能的可视化编程前端，以便浏览数据分析和可视化，包含了完整的一系列的组件以进行数据预处理，并提供了数据帐目，过渡，建模，模式评估和勘探的功能;  Milk    # 机器学习工具箱，其重点是提供监督分类法与几种有效的分类分析：SVMs(基于libsvm)，K-NN，随机森林经济和决策树。  PyMVPA(Multivariate Pattern Analysis in Python)  #  是为大数据集提供统计学习分析的Python工具包，它提供了一个灵活可扩展的框架。它提供的功能有分类、回归、特征选择、数据导入导出、可视化等NuPIC，开源人工智能平台;  hebel   # GPU加速，[深度学习]Python库;  gensim   # 机器学习库    pybrain   # 机器学习模块，它的目标是为机器学习任务提供灵活、易应、强大的机器学习算法;  pybrain # 包括神经网络、强化学习(及二者结合)、无监督学习、进化算法。以神经网络为核心，所有的训练方法都以神经网络为一个实例Mahout,是 Apache Software Foundation（ASF） 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助开发人员更加方便快捷地创建智能应用程序；  Mahout  # 包含许多实现，包括聚类、分类、推荐过滤、频繁子项挖掘。此外，通过使用 Apache Hadoop 库，Mahout 可以有效地扩展到云中；  Crab  # 灵活的，快速的推荐引擎。python-recsys，娱乐系统分析，推荐系统。vowpal_porpoise，Vowpal Wabbit轻量级Python封装；  Theano   # 用来定义、优化和模拟数学表达式计算，用于高效的解决多维数组的计算问题的python软件包。它使得写深度学习模型更加容易，同时也给出了一些关于在GPU上训练它们的选项； 七 、系统与命令行 threading   # Python标准线程库，更高级别的线程接口；  envoy   # 特使，Python子线程的函数库；  sh   #  成熟的子线程替换函数库  sarge  # 封装线程    subprocess  # 调用shell命令的神器  argparse   # 写命令行脚本必备，强大的命令行差数解析工具；  timeit  #  计算代码运行的时间等等  unp  # 命令行工具，解压文件；  eventlet  # 开销很少的多线程模块，使用的是 green threads 概念，例如，pool = eventlet.GreenPool(10000) 这样一条语句便创建了一个可以处理 10000 个客户端连接的线程池，类似Gevent线程库；  Gevent  #  多线程模块  pytools  # 著名的python通用函数、工具包  SendKeys  #  键盘鼠标操作模块, 模拟键盘鼠标模拟操作；  pyHook  # 基于Python的“钩子”库，主要用于监听当前电脑上鼠标和键盘的事件。 这个库依赖于另一个Python库PyWin32，如同名字所显示的，PyWin32只能运行在Windows平台，所以PyHook也只能运行在Windows平台；  pstuil  # 跨平台地很方便获取和控制系统的进程，以及读取系统的CPU占用内存占用等信息；  cement  # 一个轻量级的、功能齐全的命令行工具；  click  #  简单优雅的的命令行接口  clint  # Python命令行工具  cliff  # 创造多层次指令的命令行程序框架  Clime  # 可以转换任何模块为多的CLI命令程序，无任何配置；  docopt   # Python命令行参数分析器  pycli  # 命令行应用程序，支持的标准命令行解析，测井，单元[测试]和功能测试；  Gooey  #  打开命令行程序，作为为一个完整的GUI应用程序；  cookiecutter # 命令行工具，从cookiecutters（项目模板）创建项目；  percol #  为UNIX传统管道pipe命令，添加交互式选择风格；  rainbowstream  # 聪明和漂亮的推特客户终端  Django Models  #  Django的一部分  SQLAlchemy  # Python SQL工具包和对象关系映射  peewee # 小型的ORM解析器。  PonyORM  #  为ORM提供了一种面向SQL的接口    MongoEngine  #  Python对象文件映射，使用[MongoDB]  Django MongoDB引擎MongoDB  #  Django后台  django-mongodb-engine  # Django后台  redisco # 一个简单的模型和容器库，使用[Redis]flywheel，Amazon DynamoDB对象映射;  butterdb   #  谷歌电子表格的ORM，Python版;  celery  # 芹菜，异步任务队列/工作，基于分布式消息队列;  huey # 休伊，轻量级，多线程任务队列;  mrq  #  队列先生，分布式任务队列，使用redis & Gevent;  rq  #  简单的工作队列   Queue  # Queue模块可以用来实现多线程间通讯，让各个线程共享数据，生产者把货物放到Queue中，供消费者（线程）去使用;  simpleq # 简单的，可扩展的队列  Amazon SQS   # 基础队列  Psyco  # 超强的python性能优化工具，psyco 的神奇在于它只需要在代码的入口处调用短短两行代码，性能就能提升 40% 或更多，真可谓是立竿见影！如果你的客户觉得你的程序有点慢，敬请不要急着去优化代码，psyco 或许能让他立即改变看法；  psyco   #  堪称 Python 的 jit  fn.py  # Python函数编程：缺失的功能享受FP的实现;  funcy # 函数编程工具  Toolz # 函数编程工具：迭代器、函数，字典;  CyToolz  #  Toolz的Cython实现，高性能的函数编程工具;  Ansible # 安塞波，极为简单的自动化平台;  SaltStack #  基础设施的自动化管理系统  Fabric  #  织物，一个简单，远程执行和部署的语言工具;  Fabtools  # Fabric的工具函数  cuisine  # 热门的Fabric的工具函数  psutil  # 跨平台的过程和系统工具模块  pexpect  # 控制互动节目  provy  #  易于使用的配置系统的Python  honcho  # Foreman的Python接口，用于管理procfile应用工具;  gunnery  # 多任务执行工具，与网络接口的分布式系统;  fig  # 快速/独立的开发环境中使用泊坞窗  APScheduler  # 轻量级、但功能强大的在线任务调度程序；  django-schedule  #  Django日程应用程序。doit,任务流道/生成工具；  Joblib   #  Python提供的轻量级的流水线工具函数  Plan   #  简易生成crontab文件  Spiff    # 纯Python实现的，功能强大的工作流引擎;  schedule  # Python作业调度  TaskFlow  #  有助于使任务执行简单  ctypes  #  Python标准库，速度更快，Python调用C代码的外部函数接口;  cffi  # Python调用C代码外部函数接口，类似于ctypes直接在python程序中调用c程序,但是比ctypes更方便不要求编译成so再调用;  Cytoolz  # python 加速库SWIG，简化封装和接口生成器;  Cython  # Python优化静态编译器  PyPy   #  Python解释器的 Python实现  Stackless Python  # 一个增强版本的Python，它使程序员从基于线程的编程方式中获得好处，并避免传统线程所带来的性能与复杂度问题；  # Stackless为 Python带来的微线程扩展，是一种低开销、轻量级的便利工具Pyston,使用LLVM和现代JIT技术,对python进行性能优化；  pythonlibs  #非官方的Windows（32 / 64位）的Python扩展包scapy，优秀的数据包处理库；   ino   # Arduino命令行工具  Pyro  # Python的机器人工具包  pluginbase  #  一个简单而灵活的Python的插件系统  itsdangerous  #  数据安全传输工具  blinker   #   快速Python中的信号/事件调度系统  pychievements  #   用于创建和跟踪成果框架  python-patterns   #  Python中的设计模式  pefileWindows PE文件解析器SIP  # 自动为C和C++库生成Python扩展模块的工具 八、数据库 MySQLdb    # 成熟的[MySQL]数据库模块  Baresql   # SQL数据库包ZODB，Python本地对象数据库，一个K-V对象图数据库；  pickledb  # 简单和轻量级的K-V键值存储  TinyDB  # 轻量级，面向文档的数据库；  mysql-python   # MySQL的Python工具库  mysqlclient   # mysql-python分支，支持Python 3  PyMySQL  # 纯Python写的 MySQL驱动程序，兼容mysql-python；  mysql-connector-python  # MySQL连接器,来自[Oracle]，纯Python编写；  oursql # MySQL连接器，提供本地话指令语句和BLOBs支持；  psycopg2  # 最流行的Python PostgreSQL适配器  txpostgres   #  于Twisted的异步驱动，用于PostgreSQL；  queries   # psycopg2函数库，用于PostgreSQL；  dataset   # 存储Python字典数据,用于SQLite，MySQL和PostgreSQL；  cassandra-python-driver  # 开源分布式NoSQL数据库系统Apache Cassandra系统的Python驱动  pycassa  #  简化的cassandra数据库Python驱动  HappyBase  # 友好的Apache [Hbase]的函数库  PyMongo   # MongoDB官方客户端  Plyvel  #  LevelDB快速和功能丰富的Python接口  redis-py  # redis客户端  py2neo  # Python客户端(基于Neo4j的RESTful接口)  telephus  # 基于Twisted的cassandra客户端  txRedis  # 基于Twisted的Redis客户端 九、网络 更多精彩机密、教程，尽在下方，赶紧点击了解吧~  点击 蓝色字体 自取，我都放在这里了。  Curl  # Pycurl包是一个libcurl的Python接口，它是由C语言编写的，与urllib相比，它的速度要快很多；  Libcurl  # 一个支持FTP, FTPS, HTTP, HTTPS, GOPHER, TELNET, DICT, FILE 和 LDAP的客户端URL传输库.libcurl也支持HTTPS认证,HTTP POST,HTTP PUT,FTP上传,代理,Cookies,基本身份验证,FTP文件断点继传,HTTP代理通道等等。  Requests   # 用Python语言编写，基于 urllib的开源 HTTP 库，它比 urllib 更加方便；  httpie  # 命令行HTTP客户端，用户友好的cURL的替换工具；  s3cmd  # 命令行工具，用于管理Amazon S3和CloudFront；  youtube-dl  # 命令行程序，从YouTube下载视频；  you-get  #  Python3写的视频下载工具，可用于YouTube/Youku优酷/Niconico视频下载；  Coursera   # 从http://coursera.org下载视频，可重新命名文件wikiteam，wiki下载工具；  subliminal  # 命令行工具，搜索和下载字幕的函数库；  requests  #  HTTP函数库，更加人性化；  grequests  # 异步HTTP请求+ Gevent（高性能高并发函数库）；  urllib3  #  一个线程安全的HTTP连接池，支持文件post;  httplib2  # 综合HTTP的客户端函数库  treq  #  Python API接口，Twisted的HTTP客户;  Mininet  # 流行的网络仿真器,API采用python编写;  POX  #  基于Python的开源软件定义网络（SDN）控制开发平台的应用，如OpenFlow的SDN控制器;  Pyretic  # SDN的编程语言，提供了强大的抽象在网络交换机或仿真器;  SDX Platform  # 基于SDN的IXP实现，利用最小网络，痘和热;  inbox.py  # Python的SMTP服务器  imbox  # Python版本IMAP库   inbox   # 收件箱，开源邮件工具包;  lamson  # SMTP服务器  flanker  # 侧卫,电子邮件地址和MIME解析库;  marrow.mailer  # 高性能可扩展邮件交付框架  django-celery-ses #  Django电子邮件后台，使用AWS SES和Celery;  modoboa  #   邮件托管和管理平台，包括现代和简化Web UI;  envelopes  # 邮件工具  mailjet  # 批量邮寄mailjet API接口，带统计;  Talon  #  利爪，Mailgun库，提取消息和签名；  pyzmail # 编写，发送和解析电子邮件;  furl  # 燃料，小型的的URL解析库库;  purl  # 简单的，干净的API，操纵URL;  pyshorteners   #  纯Python库，URL短网址编辑;  short_url  # 短网址生成  Scrapy  # 快速屏幕截取和网页抓取的框架  portia  #  波西亚，Scrapy的可视化扩展  feedparser #  信息源解释器  RoboBrowser  # 简单的网页浏览Python函数库，没有使用Web浏览器；  MechanicalSoup  #网站自动化互动测试工具包  mechanize    #  网页浏览编程工具  Demiurge  # 造物主，-PyQuery的轻量级工具；  newspaper #  提取报纸新闻  html2text  #  转换HTML为 Markdown格式的文本  python-goose  #  HTML内容提取器  lassie #  莱西,人性化的网站内容检索;  micawber  # 通过UR抓提网页的函数库  sumy  # 概要，文本和HTML网页的自动文摘模块  Haul   #  距离，可扩展的图像爬虫;  python-readability  #可读性工具Arc90,快速的Python接口;  opengraph  # OpenGraphProtocol协议解析模块  textract   #  从任何文件，Word，PowerPoint，PDF文件中提取文本等;  sanitize  #  消毒，使混乱的数据变的理智;  AutobahnPython  #   WebSocket和WAMP的函数库，使用 Twisted和PythonWebSocket-for-Python ；  websocket # 客户端和服务器端函数库  SimpleXMLRPCServer  #  python标准库，简单的XML-RPC服务器，单线程；  SimpleJSONRPCServer  # JSON-RPC规范实施函数库  zeroRPC  # 基于ZeroMQ和MessagePack的RPC实现  apache-libcloud  # 所有云服务的Python接口库   WiFi   # 一套个Python库和命令行工具与WiFi，用于[Linux]；  streamparse  # 运行Python代码和数据的实时流。集成了Apache Storm；  boto  # 亚马逊网络服务接口  twython  # Twitter推特API  google-api-python-client    # 谷歌客户端API  gspread  # 谷歌电子表格的Python API  facebook-sdk  # facebook平台Python SDK  facepy  # 简易的facebook图形APIgmail，Gmail的Python接口;  django-wordpress    # Django的WordPress的模型和视图 十、Web框架 Django  # 最流行的Python-Web框架，鼓励快速开发,并遵循MVC设计，开发周期短;  ActiveGrid  # 企业级的Web2.0解决方案  Karrigell   # 简单的Web框架，自身包含了Web服务，py脚本引擎和纯python的数据库;  PyDBLitewebpy   # 一个小巧灵活的Web框架，虽然简单但是功能强大;  CherryPy   # 基于Python的Web应用程序开发框架Pylons基于Python的一个极其高效和可靠的Web开发框架Zope开源的Web应用服务器  TurboGears   # 基于Python的MVC风格的Web应用程序框架  Twisted   # 流行的网络编程库，大型Web框架;  QuixoteWeb   # 开发框架  Flask   # 轻量级web框架  Bottle  # 快速，简单和轻量级的WSGI模式Web框架;  Pyramid  # 轻量级，快速，稳定的开源Web框架;  web2py  # 简单易用的全堆栈Web框架和平台  web.py  # 强大、简单的Web框架。TurboGears，便于扩展的Web框架;  CherryPy  # 极简Python Web框架，支持，HTTP 1.1和WSGI线程池;  Grok  # 基于Zope3的Web框架  Bluebream  # 开源的Web应用服务器，原名Zope 3;  guava  # 轻量级，高性能的Python-Web框架，采用c语言编写;  django-cms  # 基于Django企业级开源CMS  djedi-cms   # 轻量级但功能强大的Django CMS的插件，内联编辑和性能优化;  FeinCMS  # 基于Django的先进内容管理系统  Kotte  # 高层次的Python的Web应用框架，基于Pyramid;  Mezzanine  # 强大，一致，灵活的内容管理平台;  Opps  # 基于Django的CMS，用于高流量的报纸、杂志和门户网站;  Plone  # 基于Zope的开源应用服务器Zope  Quokka  # 灵活，可扩展的，轻量级的CMS系统，使用Flask和MongoDB;  Wagtail  # Django内容管理系统  Widgy  # CMS框架，基于Django;  django-oscar  # Django奥斯卡，开源的电子商务框架;  django-shop  # 基于Django的网店系统  merchant  # 支持多种付款处理工具  money  # 可扩展的货币兑换解决方案  python-currencies  # 货币显示格式  cornice  #  Pyramid的REST框架  django-rest-framework  # Django框架，强大灵活的工具，可以很容易地构建Web API;  django-tastypie  # 创造精美的Django应用程序API接口  django-formapi  # 创建JSON API、HMAC认证和Django表单验证。flask-api，提供统一的浏览器体验，基于Django框架。  flask-restful  # 快速构建REST API支持扩展;  flask-api-utils  # flask的扩展  falcon  # 猎鹰，高性能的Python框架，构建云API和Web应用程序后端;  eve  # 夏娃，REST API框架，使用Flask，MongoDB和良好意愿。  sandman   # 睡魔，为现有的数据库驱动的系统，自动生成REST API;  restless  # 类似TastyPie的框架  savory-pie # REST API构建函数库（Django，及其他）  Jinja2 # 现代设计师友好的语言模板    Genshi # 网络感知输出模板工具包   Mako # 马可，Python平台的超高速、轻型模板;  Chameleon # 变色龙，一个HTML / XML模板引擎;  Spitfire # 快速的Python编译模板  django-haystack # 大海捞针,Django模块搜索;  elasticsearch-py # Elasticsearch官方低级的Python客户端  solrpy # solr客户端  Whoosh # 呼,快速，纯Python搜索引擎库;  Feedly # 建立新闻和通知系统的函数库，使用Cassandra和Redis;  django-activity-stream # Django活动流,从你网站上的行动,产生通用的活动流;  Beaker # 烧杯，一个缓存和会话使用的Web应用程序，独立的Python脚本和应用程序库;  dogpile.cache # 是Beaker作者的下一代替代作品  HermesCache # Python的缓存库，基于标签的失效及预防Dogpile效果;  django-cache-machine # Django缓存机，自动缓存失效，使用ORM;  django-cacheops # 自动颗粒事件驱动，ORM缓存失效;  johnny-cache # 约翰尼高速缓存框架,Django应用程序;  django-viewlet # 渲染模板部件扩展缓存控制  pylibmc # 在libmemcached接口  WTForms-JSON   # JSON表单数据处理扩展  Deform  # HTML表单生成的函数库。  django-bootstrap3 # bootstrap3 集成了Django  django-crispy-forms # Django程序，可以创建优雅的表单;  django-remote-forms # Django的远程表单，Django表格的序列化程序;  django-simple-spam-blocker # Django简单的垃圾邮件拦截器  django-simple-captcha # Django简单验证码，简单的和高度可定制的Django应用程序，用于添加验证码图像Ajenti，服务器管理面板;  Grappelli # 界面花哨的django皮肤  django-suit # Django替代o界面（仅用于非商业用途）  django-xadmin # Django管理面板替代工具  flask-admin # 简单的flask管理界面框架flower，实时监控和Web管理面板;  Pelican # 鹈鹕，Markdown或ReST，字王内容主题。支持 DVCS, Disqus. AGPL;   Cactus # 仙人掌,设计师的网站静态生成器;  Hyde # 海德， 基于Jinja2的静态网站生成器;  Nikola # 尼古拉-一个静态网站和博客生成器  Tags # 标签，最简单的静态网站生成器;  Tinkerer # 工匠，基于Sphinx的静态网站生成器;  asyncio # （在Python 3.4 +是Python标准库），异步I/O，事件循环，协同任务;  gevent # 基于Python的网络库  Twisted # 扭曲，事件驱动的网络引擎;  Tornado # 龙卷风，Web框架和异步网络的函数库;  pulsar # 脉冲星，事件驱动的并行框架的Python；  diesel # 柴油，绿色的，基于事件的I/O框架；  eventlet # WSGI支持异步框架  pyzmq # 0MQ消息库的Python封装  txZMQ # 基于Twisted的0MQ消息库封Crossbar,开源统一应用路由器（WebSocket和WAMP）  wsgiref # Python标准库，WSGI封装实现，单线程；  Werkzeug # 机床，WSGI工具函数库，很容易地嵌入到你自己的项目框架；  paste # 粘贴，多线程，稳定的，久经考验的WSGI工具；  rocket # 火箭，多线程服务，基于Pyramid；  netius # 快速的、异步WSGI服务器  gunicorn # forked前身，部分用C写的；  fapws3 # 异步网络，用C写的  meinheld # 异步WSGI服务器，是用C写的；  bjoern # 快速的、异步WSGI服务器，用C写的； 十一、安全 Permissions   # 函数库，允许或拒绝用户访问数据或函数；  django-guardian # Django守护者，管理每个对象的权限，用于Django 1.2 +Carteblanche，管理导航和权限；  Authomatic # 简单强大的认证/授权客户端  OAuthLib # 通用，规范，OAuth请求签约工具；  rauth # 用于OAuth 1.0，2.0，的Python库；  python-oauth2 # 利用全面测试，抽象接口来创建OAuth的客户端和服务器；  python-social-auth # 易于安装的社会认证机制  django-oauth-toolkit # Django OAuth工具包  django-oauth2-provider # Django OAuth2工具包  django-allauth # Django认证的应用程序  Flask-OAuthlib # Flask的OAuth工具包  sanction # 制裁，简单的oauth2客户端；  jose # [JavaScript]对象签名和加密(JOSE)草案实施，标记状态；  python-jwt # JSON的Web令牌生成和验证模块  pyjwt # JSON的Web令牌草案01  python-jws # JSON的Web令牌草案02  PyCrypto # Python的加密工具包。  Paramiko # sshv2协议的实现，提供了客户端和服务器端的功能；  cryptography # 密码开发工具包  PyNac # 网络和密码（NaCl）函数库  hashids # hashids的 Python函数库  Passlib # 安全的密码存储/哈希库，非常高的水平；  hashlib,md5 #  sha等hash算法，用来替换md5和sha模块，并使他们的API一致； # 它由OpenSSL支持，支持如下算法：md5,sha1, sha224, sha256, sha384, sha512. 十二、GUI PyGtk # 基于Python的GUI程序开发GTK+库  PyQt用于Python的QT开发库  WxPython   # Python下的GUI编程框架，其消息机制与MFC的架构相似,入门非常简单，需要快速开发相关的应用可以使用这个；  Tkinter  # Python下标准的界面编程包，因此不算是第三方库了；  PySide # 跨平台Qt的应用程序和用户界面框架，支撑Qt v4框架；  wxPython， # 混合wxWidgets的C++类库  kivy # 创建应用程序GUI函数库，看运行于Windows，Linux，MAC OS X，Android和iOS；  curse # 用于创建终端GUI应用程序  urwid # 创建终端GUI应用程序窗体的函数库，支持事件，色彩丰富；  pyglet # 跨平台的窗口和多媒体库的Python  Tkinter # 是Python事实上的标准GUI软件包  enaml # 创建漂亮的用户界面，语法类似QML；  Toga # 托加，OS原生GUI工具包； 十三、构建封装 更多精彩机密、教程，尽在下方，赶紧点击了解吧~  点击 蓝色字体 自取，我都放在这里了。  pyenv # 简单的Python版本管理  virtualenv # 创建独立的Python环境，用于同时安装不同版本的python环境；  virtualenvwrapper # 是virtualenv的一组扩展  pew # 一套管理多个虚拟环境的工具  vex # 使运行指定的virtualenv命令  PyRun # 一个单文件，无需安装的Python版本管理工具  PIP # Python包和依赖的管理工具  easy_install # 软件包管理系统,提供一个标准的分配Python软件和 函式库的格式。是一个附带设置工具的模块，和一个第三方函式库。旨在加快Python函式库的分配程式的速度。类似Ruby语言的RubyGems ；  conda # 跨平台，二进制软件包管理器；  Curdling # 一个管理Python包的命令行工具  wheel # Python发行的新标准，旨在替代eggs；  cx-Freeze # 跨平台的，用于打包成可执行文件的库；  py2exe #  Windows平台的Freeze脚本工具  Py2exe  # 将python脚本转换为windows上可以独立运行的可执行程序  py2app # MAC OS X平台的Freeze脚本工具  pyinstaller # 转换成独立的可执行文件的Python程序（跨平台）  pynsist # 构建Windows安装程序的工具，用Python编写；  dh-virtualenv # 建立和分发virtualenv(Debian软件包格式)  PyPI # 新一代的Python包库管理工具。  warehouse # 新一代的Python包库（PyPI）管理工具  devpi # PyPI服务器和包装/测试/发布工具  localshop # PyPI官方包镜像服务器，支持本地（私人）包上传；  buildout # 创建，组装和部署应用程序的多个部分，其中一些可能是非基于Python的；  SCons # 软件构造工具  platformio # 一个控制台的工具，构建的代码可用于不同的开发平台；  bitbake # 特殊设计的工具，用于创建和部署[嵌入式]Linux软件包；  fabricate # 自动为任何编程语言，生成依赖包；  django-compressor # Django压缩机，压缩和内联JavaScript或CSS，链接到一个单一的缓存文件；  jinja-assets-compressor # 金贾压缩机，一个Jinja扩展，通过编译，压缩你的资源；  webassets # 优化管理，静态资源，独特的缓存清除；  fanstatic # 球迷，包优化，提供静态文件；  fileconveyor # 监控资源变化，可保存到CDN（内容分发网络）和文件系统；  django-storages # 一组自定义存储Django后台  glue # 胶胶，一个简单的命令行工具，生成CSS Sprites；  libsass-python # Sass (层叠样式表)的Python接口  Flask-Assets # 整合应用程序资源  十四、代码调试 unittest # Python标准库，单元测试框架；  nose # 鼻子，unittest延伸产品；  pytest # 成熟的全功能的Python测试工具  mamba # 曼巴，Python的权威测试工具。出自BDD的旗下；  contexts # 背景，BDD测试框架，基于C#；  pyshould # should风格的测试框架，基于PyHamcrest；  pyvows # BDD风格测试框架  Selenium # web测试框架，Python绑定Selenium；  splinter # 分裂，测试Web应用程序的开源工具；  locust # 刺槐，可扩展的用户负载测试工具，用Python写的；  sixpack # 语言无关的A/B测试框架  mock # 模拟对象（英语：mock object，也译作模仿对象），模拟测试库；  responses # 工具函数，用于mock模拟测试；  doublex # 强大的测试框架  freezegun # 通过时间调整，测试模块；  httpretty #  HTTP请求的模拟工具  httmock # mock模拟测试  coverage # 代码覆盖度量测试  faker # 生成模拟测试数据的Python包  mixer # 混频器，产生模拟数据，用于Django ORM，SQLAlchemy，Peewee, MongoEngine, Pony ORM等；  model_mommy # 在Django创建测试随机工具  ForgeryPy # 易用的模拟数据发生器  radar # 雷达，生成随机日期/时间；  FuckIt.py # 测试Python代码运行  Code Analysispysonar2 # Python类型索引  pycallgraph # 可视化的流量（调用图）应用程序  code2flow # 转换Python和JavaScript代码到流程图  LinterFlake8 # 源代码模块检查器  pylama # Python和JavaScript代码审计工具  Pylint # 源代码分析器，它查找编程错误，帮助执行一个代码标准和嗅探一些代码味道。注意：相比于PyChecker，Pylint是一个高阶的Python代码分析工具，它分析Python代码中的错误；  Pyflakes # 一个用于检查Python源文件错误的简单程序。Pyflakes分析程序并且检查各种错误。它通过解析源文件实现，无需导入；  pdb # Python标准库,Python调试器；  ipdb # IPython使用的PDB  winpdb  # 独立于平台的GUI调试器  pudb # 全屏，基于python调试控制台；  pyringe # 可附着于及注入代码到Python程序的调试器  python-statsd # statsd服务器客户端  memory_profiler # 内存监视  profiling # 交互式Python分析器  django-debug-toolbar # Django调试工具栏,显示各种调试信息:当前请求/响应  django-devserver # Django调试工具  flask-debugtoolbar # flask调试工具 更多精彩机密、教程，尽在下方，赶紧点击了解吧~  点击 蓝色字体 自取，我都放在这里了。  尾语 💝 感谢你观看我的文章呐~本次航班到这里就结束啦 🛬  希望本篇文章有对你带来帮助 🎉，有学习到一点知识~  躲起来的星星🍥也在努力发光，你也要努力加油（让我们一起努力叭）。  最后，博主要一下你们的三连呀（点赞、评论、收藏），不要钱的还是可以搞一搞的嘛~  不知道评论啥的，即使扣个6666也是对博主的鼓舞吖 💞 感谢 💐 ———————————————— 版权声明：本文为CSDN博主「茜茜是帅哥」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/m0_72282564/article/details/127577146 

 在编写软件时，我们经常需要使用包含不同类型的数据，这种数据通常被称为“结构”。更具体地说，有些特定类型的结构又称为“可迭代对象”。  可迭代对象是一种类型，其中包含名叫“元素”的数据类型，而不是字段或属性。举个例子，Julia 中的可迭代对象包括 Dict 和 Vector，就相当于 Python 中的 list 和 dict。Dict 包含 Pair 类型的元素，而 Vector 包含其参数指定的任意类型。这些类型的结构被称为“可迭代对象”，因为它们是可以迭代。  迭代是编程中的一个非常关键的概念。事实上，迭代非常重要，就连低级汇编代码中都包含类似于循环的实现。迭代，更具体地说，for 循环，是我们在学习第一门编程语言时学习的第一个知识点。然而，迭代也有其自身的一些问题。  许多进程的执行速度减慢，究其原因最大的障碍往往就是循环。因此，我们应该最大限度地提高循环的性能，避免嵌套，并尽可能避免循环。那么，为什么我们要将循环作为默认的方式之一呢？为什么不试试看其他有助于提升性能的方式呢？  避免使用循环 有几种技巧可以避免使用循环。首先是递归，不过递归的应用范围更窄，而且性能远远比不上循环。不过，第二种方法就比较实用了。这种方法叫做“广播”（broadcasting），它将一个函数应用到给定结构中的每个元素上，因此可以很容易地一次性改变多个元素。还有一个类似的概念“映射”（mapping），从某种意义上来说，它和广播非常相似。第三种方法与它们相似，叫做“解析式”（comprehension）。这几个概念的基本思想都是将一个函数应用到所有元素上，从而在多个值上同时进行某种运算。  在编写 Python 时，最常用的方法就是 map。为了映射一个函数，我们只需用 lambda 或 def 定义它：  myfunc = lambda x: x + 1 1 2 然后将这个函数传递给 map 函数，后者将返回一个 map 对象。该对象可以转换成一个 list，从而获取其值。map 函数的第一个参数是上述函数，第二个参数是要映射的 list。  map(myfunc, [1, 2, 3, 4, 5]) <map object at 0x7f33562f8fa0> list(map(myfunc, [1, 2, 3, 4, 5])) [2, 3, 4, 5, 6] 虽然 Python 中的解析式也很强大，但与 Julia 等语言相比，其功能还是太受限了。因此，大部分情况下，解析式是快速操作多个元素的最佳选择。但是，由于解析式非常善于进行小型操作（如上例），我们应该在这里演示一下。  vals = [x + 1 for x in [1, 2, 3, 4, 5]] print(vals) [2, 3, 4, 5, 6] Julia 也有 map 函数，而且像 Python 一样，该函数非常易于使用。不过我必须承认，我在 Julia 中使用 map 的次数远远少于广播以及更强大的解析式。Julia 的 map 的语法也和 Python 非常相似，最主要的区别就是它会返回一个 Vector：  julia> map(x -> x + 1, [1, 2, 3, 4, 5, 6]) 6-element Vector{Int64}: 2 3 4 5 6 7 Julia 也支持广播。与 map 很相似，我们可以利用广播在数组内的每个元素上应用任意函数。Python 的 NumPy 也提供了此功能，但是本文主要想讨论 Julia。在 Julia 中，只需在给定函数前写一个点（.）， 即可将其应用到每个元素。Julia 的基本操作符中经常被引用的一个示例如下：  x = [5, 10, 15] y = [5, 10, 15] x .* y 3-element Vector{Int64}: 25 100 225 对于其他通用的应用，该操作也可以使用 @. 宏完成。如果你想了解有关 Julia 中广播的更多信息，可以阅读这篇文章：https://medium.com/chifi-media/broadcasting-power-in-julia-beginner-friendly-overview-11cdd099623a。  像 Python 一样，Julia 也有解析式。虽然 Python 的解析式很有局限性，特别是其可读性并非太好，但 Julia 则截然不同。当然，没有任何规定组禁止你在 Python 的解析式之外定义函数，但这样做会导致一些问题，比如当需要在函数中引某个变量的时候就会很麻烦。尽管如此，虽然有时候 Python 的解析式需要借助其他东西才能清晰易读，但 Julia 的解析式可以像函数一样书写，可以写在多行内，而且支持多种语句！下面是一个解析式，它很像 Python：  x = [x - 1 for x in 1:5] 1 2 替代循环 下面，我们来看看 Julia 的解析式究竟好在哪里。首先，我们可以利用 begin/end 语法，以函数的形式编写解析式。  x = [begin x - 1 end for x in 1:5] 在解析式中添加 begin/end 敞开了一扇大门，可以让解析式完成更多的工作。我喜欢将解析式写成这样：  x = [begin x - 1 end for x in 1:5] 在这个新函数中，我们可以做任何循环能做的事情，除了一些例外。例如，下面是个条件语句：  julia> x = [begin if x > 1 5 else 3 end end for x in 1:10] 10-element Vector{Int64}: 虽然 Python 也能实现这一点，但别忘了，我们还能添加更多的语句，甚至可以使用 try/catch 和闭包！  julia> x = [begin if x > 1 5 else try "hello" * 5 catch 3 end end end for x in 1:10] 10-element Vector{Int64}:  需要循环的情况 虽然用函数替换循环能节省不少时间，但循环在编程语言和软件中依然有着重要的作用。最值得一提的是，循环的关键字 break 和 continue 是其他方法都没有的。这可以节省很多不必要的循环。break 关键字能结束循环，而 continue 关键字可以直接跳转到下一次循环。下面是选择循环的一个例子，主要目的是在找到适当的值时，利用 break 跳出循环：  function display(d::OliveDisplay, m::MIME{<:Any}, o::Any) T::Type = typeof(o) mymimes = [MIME"text/html", MIME"text/svg", MIME"text/plain"] mmimes = [m.sig.parameters[3] for m in methods(show, [IO, Any, T])] correctm = nothing for m in mymimes if m in mmimes correctm = m break end end show(d.io, correctm(), o) end 在这个例子中，我们依次遍历 MIME，找到最有可能的值。在已有的 MIME（即 mmimes）中找到所需的 mime 后，设置 correctm，然后将其传递给 show 函数。这个例子中，相较于映射或解析式，选择迭代更合适，因为它拥有独到的优势。  总结 一直以来，迭代式循环都是编程中的一个重要的概念，在高级语言中得到了广泛的应用。循环是从硬件层面上实现的，其重要性不言而喻。但是，许多现代编程语言完全可以不使用循环，我们可以利用函数、映射和解析式来实现相同的功能。但是，在有一些情况下，选择循环依然比解析式或映射更好。一种情况就是可以利用 break 和 continue 关键字跳过元素、加快循环。 ———————————————— 版权声明：本文为CSDN博主「CSDN资讯」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/csdnnews/article/details/128340094 

 前言 最近那个电视剧很火，就是搞爱心代码的，本人兴趣使然，在网上搜集了一些代码，经过一定修改，做一个小总结。源文件直接免费下载点此处  一、python 运行  主要用的包都是那么几个，csdn搜pycharm怎么导包就可以。  1.python 第一个 成品效果      调整思路  HEART_COLOR = "#EEAEEE"  #引号内修改颜色！颜色代码放在文章末尾  双引号里面可以在csdn搜RGB颜色，比如这个兄弟的，直接看里面的对照表，把包括#的数字或字母替换就可以换颜色了  代码如下  import random from math import sin, cos, pi, log from tkinter import *   CANVAS_WIDTH = 840  # 画布的宽 CANVAS_HEIGHT = 680  # 画布的高 CANVAS_CENTER_X = CANVAS_WIDTH / 2  # 画布中心的X轴坐标 CANVAS_CENTER_Y = CANVAS_HEIGHT / 2  # 画布中心的Y轴坐标 IMAGE_ENLARGE = 11  # 放大比例   HEART_COLOR = "#EEAEEE"  #引号内修改颜色！颜色代码放在文章末尾   def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):     """     “爱心函数生成器”     :param shrink_ratio: 放大比例     :param t: 参数     :return: 坐标     """     # 基础函数     x = 17 * (sin(t) ** 3)     y = -(16 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(3 * t))       # 放大     #x *= shrink_ratio     #y *= shrink_ratio     x*=IMAGE_ENLARGE     y*=IMAGE_ENLARGE     # 移到画布中央     x += CANVAS_CENTER_X     y += CANVAS_CENTER_Y       return int(x), int(y)     def scatter_inside(x, y, beta=0.15):     """     随机内部扩散     :param x: 原x     :param y: 原y     :param beta: 强度     :return: 新坐标     """     ratio_x = - beta * log(random.random())     ratio_y = - beta * log(random.random())       dx = ratio_x * (x - CANVAS_CENTER_X)     dy = ratio_y * (y - CANVAS_CENTER_Y)       return x - dx, y - dy     def shrink(x, y, ratio):     """     抖动     :param x: 原x     :param y: 原y     :param ratio: 比例     :return: 新坐标     """     force = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6)  # 这个参数...     dx = ratio * force * (x - CANVAS_CENTER_X)     dy = ratio * force * (y - CANVAS_CENTER_Y)     return x - dx, y - dy     def curve(p):     """     自定义曲线函数，调整跳动周期     :param p: 参数     :return: 正弦     """     # 可以尝试换其他的动态函数，达到更有力量的效果（贝塞尔？）     return 2 * (2 * sin(4 * p)) / (2 * pi)     class Heart:     """     爱心类     """       def __init__(self, generate_frame=20):         self._points = set()  # 原始爱心坐标集合         self._edge_diffusion_points = set()  # 边缘扩散效果点坐标集合         self._center_diffusion_points = set()  # 中心扩散效果点坐标集合         self.all_points = {}  # 每帧动态点坐标         self.build(2000)           self.random_halo = 1000           self.generate_frame = generate_frame         for frame in range(generate_frame):             self.calc(frame)       def build(self, number):         # 爱心         for _ in range(number):             t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口             x, y = heart_function(t)             self._points.add((x, y))           # 爱心内扩散         for _x, _y in list(self._points):             for _ in range(3):                 x, y = scatter_inside(_x, _y, 0.05)                 self._edge_diffusion_points.add((x, y))           # 爱心内再次扩散         point_list = list(self._points)         for _ in range(10000):             x, y = random.choice(point_list)             x, y = scatter_inside(x, y, 0.27)             self._center_diffusion_points.add((x, y))       @staticmethod     def calc_position(x, y, ratio):         # 调整缩放比例         force = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.420)  # 魔法参数           dx = ratio * force * (x - CANVAS_CENTER_X) + random.randint(-1, 1)         dy = ratio * force * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)           return x - dx, y - dy       def calc(self, generate_frame):         ratio = 15 * curve(generate_frame / 10 * pi)  # 圆滑的周期的缩放比例           halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))         halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))           all_points = []           # 光环         heart_halo_point = set()  # 光环的点坐标集合         for _ in range(halo_number):             t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口             x, y = heart_function(t, shrink_ratio=-15)  # 魔法参数             x, y = shrink(x, y, halo_radius)             if (x, y) not in heart_halo_point:                 # 处理新的点                 heart_halo_point.add((x, y))                 x += random.randint(-60, 60)                 y += random.randint(-60, 60)                 size = random.choice((1, 1, 2))                 all_points.append((x, y, size))                 all_points.append((x+20, y+20, size))                 all_points.append((x-20, y -20, size))                 all_points.append((x+20, y - 20, size))                 all_points.append((x - 20, y +20, size))           # 轮廓         for x, y in self._points:             x, y = self.calc_position(x, y, ratio)             size = random.randint(1, 3)             all_points.append((x, y, size))           # 内容         for x, y in self._edge_diffusion_points:             x, y = self.calc_position(x, y, ratio)             size = random.randint(1, 2)             all_points.append((x, y, size))           for x, y in self._center_diffusion_points:             x, y = self.calc_position(x, y, ratio)             size = random.randint(1, 2)             all_points.append((x, y, size))           self.all_points[generate_frame] = all_points       def render(self, render_canvas, render_frame):         for x, y, size in self.all_points[render_frame % self.generate_frame]:             render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)     def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):     render_canvas.delete('all')     render_heart.render(render_canvas, render_frame)     main.after(1, draw, main, render_canvas, render_heart, render_frame + 1)     if __name__ == '__main__':     root = Tk()     canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)     canvas.pack()     heart = Heart()     draw(root, canvas, heart)     root.mainloop()  2.python第二个 成品效果      调整思路  HEART_COLOR = "#EEAEEE"  #心的颜色  调整颜色的思路同上  代码如下  import random from math import sin, cos, pi, log from tkinter import *   CANVAS_WIDTH = 640  # 画布的宽 CANVAS_HEIGHT = 480  # 画布的高 CANVAS_CENTER_X = CANVAS_WIDTH / 2  # 画布中心的X轴坐标 CANVAS_CENTER_Y = CANVAS_HEIGHT / 2  # 画布中心的Y轴坐标 IMAGE_ENLARGE = 11  # 放大比例 HEART_COLOR = "pink"  # 心的颜色     def heart_function(t, shrink_ratio: float = IMAGE_ENLARGE):     """     “爱心函数生成器”     :param shrink_ratio: 放大比例     :param t: 参数     :return: 坐标     """     # 基础函数     x = 16 * (sin(t) ** 3)     y = -(13 * cos(t) - 5 * cos(2 * t) - 2 * cos(3 * t) - cos(4 * t))       # 放大     x *= shrink_ratio     y *= shrink_ratio       # 移到画布中央     x += CANVAS_CENTER_X     y += CANVAS_CENTER_Y       return int(x), int(y)     def scatter_inside(x, y, beta=0.15):     """     随机内部扩散     :param x: 原x     :param y: 原y     :param beta: 强度     :return: 新坐标     """     ratio_x = - beta * log(random.random())     ratio_y = - beta * log(random.random())       dx = ratio_x * (x - CANVAS_CENTER_X)     dy = ratio_y * (y - CANVAS_CENTER_Y)       return x - dx, y - dy     def shrink(x, y, ratio):     """     抖动     :param x: 原x     :param y: 原y     :param ratio: 比例     :return: 新坐标     """     force = -1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.6)  # 这个参数...     dx = ratio * force * (x - CANVAS_CENTER_X)     dy = ratio * force * (y - CANVAS_CENTER_Y)     return x - dx, y - dy     def curve(p):     """     自定义曲线函数，调整跳动周期     :param p: 参数     :return: 正弦     """     return 4 * (2 * sin(4 * p)) / (2 * pi)     class Heart:     """     爱心类     """       def __init__(self, generate_frame=20):         self._points = set()  # 原始爱心坐标集合         self._edge_diffusion_points = set()  # 边缘扩散效果点坐标集合         self._center_diffusion_points = set()  # 中心扩散效果点坐标集合         self.all_points = {}  # 每帧动态点坐标         self.build(2000)           self.random_halo = 1000           self.generate_frame = generate_frame         for frame in range(generate_frame):             self.calc(frame)       def build(self, number):         # 爱心         for _ in range(number):             t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口             x, y = heart_function(t)             self._points.add((x, y))           # 爱心内扩散         for _x, _y in list(self._points):             for _ in range(3):                 x, y = scatter_inside(_x, _y, 0.05)                 self._edge_diffusion_points.add((x, y))           # 爱心内再次扩散         point_list = list(self._points)         for _ in range(4000):             x, y = random.choice(point_list)             x, y = scatter_inside(x, y, 0.17)             self._center_diffusion_points.add((x, y))       @staticmethod     def calc_position(x, y, ratio):         # 调整缩放比例         force = 1 / (((x - CANVAS_CENTER_X) ** 2 + (y - CANVAS_CENTER_Y) ** 2) ** 0.520)           dx = ratio * force * (x - CANVAS_CENTER_X) + random.randint(-1, 1)         dy = ratio * force * (y - CANVAS_CENTER_Y) + random.randint(-1, 1)           return x - dx, y - dy       def calc(self, generate_frame):         ratio = 10 * curve(generate_frame / 10 * pi)  # 圆滑的周期的缩放比例           halo_radius = int(4 + 6 * (1 + curve(generate_frame / 10 * pi)))         halo_number = int(3000 + 4000 * abs(curve(generate_frame / 10 * pi) ** 2))           all_points = []           # 光环         heart_halo_point = set()  # 光环的点坐标集合         for _ in range(halo_number):             t = random.uniform(0, 2 * pi)  # 随机不到的地方造成爱心有缺口             x, y = heart_function(t, shrink_ratio=11)             x, y = shrink(x, y, halo_radius)             if (x, y) not in heart_halo_point:                 # 处理新的点                 heart_halo_point.add((x, y))                 x += random.randint(-11, 11)                 y += random.randint(-11, 11)                 size = random.choice((1, 2, 2))#控制外围粒子的大小                 all_points.append((x, y, size))           # 轮廓         for x, y in self._points:             x, y = self.calc_position(x, y, ratio)             size = random.randint(1, 3)             all_points.append((x, y, size))           # 内容         for x, y in self._center_diffusion_points:             x, y = self.calc_position(x, y, ratio)             size = random.randint(1, 2)             all_points.append((x, y, size))           self.all_points[generate_frame] = all_points       def render(self, render_canvas, render_frame):         for x, y, size in self.all_points[render_frame % self.generate_frame]:             render_canvas.create_rectangle(x, y, x + size, y + size, width=0, fill=HEART_COLOR)     def draw(main: Tk, render_canvas: Canvas, render_heart: Heart, render_frame=0):     render_canvas.delete('all')     render_heart.render(render_canvas, render_frame)     main.after(160, draw, main, render_canvas, render_heart, render_frame + 1)     if __name__ == '__main__':     root = Tk()  # 一个Tk     canvas = Canvas(root, bg='black', height=CANVAS_HEIGHT, width=CANVAS_WIDTH)     canvas.pack()     heart = Heart()  # 心     draw(root, canvas, heart)  # 开始画画~     root.mainloop()  二、HTML html的个人感觉更好，因为有浏览器就支持运行，py的后期得导出成exe才可以在没有环境设备运行，html手机电脑都可以的。  1.第一个 输出样例   调整  <title>canvas爱心</title>   这个canvas爱心字样随便调整可以自己编辑TA的名字之类的  代码如下  <!doctype html> <html> <head> <meta charset="utf-8"> <title>canvas爱心</title>   <style> html, body {   height: 100%;   padding: 0;   margin: 0;   background: #000; } canvas {   position: absolute;   width: 100%;   height: 100%; }</style> </head> <body>   <canvas id="pinkboard"></canvas>   <script> /*  * Settings  */ var settings = {   particles: {     length:   500, // maximum amount of particles     duration:   2, // particle duration in sec     velocity: 100, // particle velocity in pixels/sec     effect: -0.75, // play with this for a nice effect     size:      30, // particle size in pixels   }, };   /*  * RequestAnimationFrame polyfill by Erik M?ller  */ (function(){var b=0;var c=["ms","moz","webkit","o"];for(var a=0;a<c.length&&!window.requestAnimationFrame;++a){window.requestAnimationFrame=window[c[a]+"RequestAnimationFrame"];window.cancelAnimationFrame=window[c[a]+"CancelAnimationFrame"]||window[c[a]+"CancelRequestAnimationFrame"]}if(!window.requestAnimationFrame){window.requestAnimationFrame=function(h,e){var d=new Date().getTime();var f=Math.max(0,16-(d-b));var g=window.setTimeout(function(){h(d+f)},f);b=d+f;return g}}if(!window.cancelAnimationFrame){window.cancelAnimationFrame=function(d){clearTimeout(d)}}}());   /*  * Point class  */ var Point = (function() {   function Point(x, y) {     this.x = (typeof x !== 'undefined') ? x : 0;     this.y = (typeof y !== 'undefined') ? y : 0;   }   Point.prototype.clone = function() {     return new Point(this.x, this.y);   };   Point.prototype.length = function(length) {     if (typeof length == 'undefined')       return Math.sqrt(this.x * this.x + this.y * this.y);     this.normalize();     this.x *= length;     this.y *= length;     return this;   };   Point.prototype.normalize = function() {     var length = this.length();     this.x /= length;     this.y /= length;     return this;   };   return Point; })();   /*  * Particle class  */   var Particle = (function() {   function Particle() {     this.position = new Point();     this.velocity = new Point();     this.acceleration = new Point();     this.age = 0;   }   Particle.prototype.initialize = function(x, y, dx, dy) {     this.position.x = x;     this.position.y = y;     this.velocity.x = dx;     this.velocity.y = dy;     this.acceleration.x = dx * settings.particles.effect;     this.acceleration.y = dy * settings.particles.effect;     this.age = 0;   };   Particle.prototype.update = function(deltaTime) {     this.position.x += this.velocity.x * deltaTime;     this.position.y += this.velocity.y * deltaTime;     this.velocity.x += this.acceleration.x * deltaTime;     this.velocity.y += this.acceleration.y * deltaTime;     this.age += deltaTime;   };   Particle.prototype.draw = function(context, image) {     function ease(t) {       return (--t) * t * t + 1;     }     var size = image.width * ease(this.age / settings.particles.duration);     context.globalAlpha = 1 - this.age / settings.particles.duration;     context.drawImage(image, this.position.x - size / 2, this.position.y - size / 2, size, size);   };   return Particle; })();   /*  * ParticlePool class  */ var ParticlePool = (function() {   var particles,       firstActive = 0,       firstFree   = 0,       duration    = settings.particles.duration;      function ParticlePool(length) {     // create and populate particle pool     particles = new Array(length);     for (var i = 0; i < particles.length; i++)       particles[i] = new Particle();   }   ParticlePool.prototype.add = function(x, y, dx, dy) {     particles[firstFree].initialize(x, y, dx, dy);          // handle circular queue     firstFree++;     if (firstFree   == particles.length) firstFree   = 0;     if (firstActive == firstFree       ) firstActive++;     if (firstActive == particles.length) firstActive = 0;   };   ParticlePool.prototype.update = function(deltaTime) {     var i;          // update active particles     if (firstActive < firstFree) {       for (i = firstActive; i < firstFree; i++)         particles[i].update(deltaTime);     }     if (firstFree < firstActive) {       for (i = firstActive; i < particles.length; i++)         particles[i].update(deltaTime);       for (i = 0; i < firstFree; i++)         particles[i].update(deltaTime);     }          // remove inactive particles     while (particles[firstActive].age >= duration && firstActive != firstFree) {       firstActive++;       if (firstActive == particles.length) firstActive = 0;     }             };   ParticlePool.prototype.draw = function(context, image) {     // draw active particles     if (firstActive < firstFree) {       for (i = firstActive; i < firstFree; i++)         particles[i].draw(context, image);     }     if (firstFree < firstActive) {       for (i = firstActive; i < particles.length; i++)         particles[i].draw(context, image);       for (i = 0; i < firstFree; i++)         particles[i].draw(context, image);     }   };   return ParticlePool; })();   /*  * Putting it all together  */ (function(canvas) {   var context = canvas.getContext('2d'),       particles = new ParticlePool(settings.particles.length),       particleRate = settings.particles.length / settings.particles.duration, // particles/sec       time;      // get point on heart with -PI <= t <= PI   function pointOnHeart(t) {     return new Point(       160 * Math.pow(Math.sin(t), 3),       130 * Math.cos(t) - 50 * Math.cos(2 * t) - 20 * Math.cos(3 * t) - 10 * Math.cos(4 * t) + 25     );   }      // creating the particle image using a dummy canvas   var image = (function() {     var canvas  = document.createElement('canvas'),         context = canvas.getContext('2d');     canvas.width  = settings.particles.size;     canvas.height = settings.particles.size;     // helper function to create the path     function to(t) {       var point = pointOnHeart(t);       point.x = settings.particles.size / 2 + point.x * settings.particles.size / 350;       point.y = settings.particles.size / 2 - point.y * settings.particles.size / 350;       return point;     }     // create the path     context.beginPath();     var t = -Math.PI;     var point = to(t);     context.moveTo(point.x, point.y);     while (t < Math.PI) {       t += 0.01; // baby steps!       point = to(t);       context.lineTo(point.x, point.y);     }     context.closePath();     // create the fill     context.fillStyle = '#ea80b0';     context.fill();     // create the image     var image = new Image();     image.src = canvas.toDataURL();     return image;   })();      // render that thing!   function render() {     // next animation frame     requestAnimationFrame(render);          // update time     var newTime   = new Date().getTime() / 1000,         deltaTime = newTime - (time || newTime);     time = newTime;          // clear canvas     context.clearRect(0, 0, canvas.width, canvas.height);          // create new particles     var amount = particleRate * deltaTime;     for (var i = 0; i < amount; i++) {       var pos = pointOnHeart(Math.PI - 2 * Math.PI * Math.random());       var dir = pos.clone().length(settings.particles.velocity);       particles.add(canvas.width / 2 + pos.x, canvas.height / 2 - pos.y, dir.x, -dir.y);     }          // update and draw particles     particles.update(deltaTime);     particles.draw(context, image);   }      // handle (re-)sizing of the canvas   function onResize() {     canvas.width  = canvas.clientWidth;     canvas.height = canvas.clientHeight;   }   window.onresize = onResize;      // delay rendering bootstrap   setTimeout(function() {     onResize();     render();   }, 10); })(document.getElementById('pinkboard'));</script>   </body> </html> 

 前言：前几天上课闲着没事写了一个python敲击木鱼积累功德的小项目，当时纯粹就是写着玩，回顾一下鼠标事件的东西还记不记得，发现这个博客的点赞和收藏量还挺高的，我当时也没有把它当回事，后面也有很多人问怎么实现的，想让我再添加一些其他功能！  随着点赞量和关注量不断增高，我又重新看了一下博客，感觉过于简单了，实在不配当当时python热榜的第一，所以我又把代码给稍微大改了一下，在原来总体实现的基础上添加了如下功能！  我们先看原来的效果：  1：实现了点击鼠标会弹出切换功德+1的surface界面，鼠标松开回复原先界面！  2：随着鼠标按键的按下同时也会伴随木鱼敲击的空灵的声音！  本次更新之后的功能有：  1：点击鼠标按键会出现功德+1和累计敲击多少次，积累了多少功德的新画面  2：优化了声音的play，降噪处理！  3：增加较强的互动性能，在不断的积累功德的过程中，会不定时随机出现意想不到的的互动效果，极大程度增加了该程序的趣味性！  ps：下次更新可能会在半个月后了，届时会使用tk的模块添加登录注册，以及网络编程的使用用户功德的统计排行榜！最近期末，还请谅解！  好了，话不多说，直接上代码：  import pygame from locale import * pygame.init() pygame.mixer.init() screen=pygame.display.set_mode((700,500)) pygame.display.set_caption("木鱼功德")  img1=pygame.image.load("images/muyuluck1.jpg") # img2=pygame.image.load("images/muyulucky2.png") img2=pygame.image.load("images/zan.jpg") img3=pygame.image.load("images/qw.png") rect1=img1.get_rect()  muyulucky = pygame.mixer.Sound('sound/muyu.WAV') muyulucky.set_volume(0.4) if pygame.mouse.get_focused():             # 获取光标位置,2个值     ball_x, ball_y = pygame.mouse.get_pos() screen.blit(img1, (-180, -100)) count=0 f = pygame.font.SysFont('华文楷体',50) f1 = pygame.font.SysFont('华文楷体',30) # 生成文本信息，第一个参数文本内容；第二个参数，字体是否平滑； # 第三个参数，RGB模式的字体颜色；第四个参数，RGB模式字体背景颜色； # text = f.render("功德+1",True,(255,0,0),(0,0,0)) # text1=f1.render("今日积累功德"+str(count)+"次",True,(255,0,0),(0,0,0)) #获得显示对象的rect区域坐标 # textRect =text.get_rect() # text1Rect =text1.get_rect() # 设置显示对象居中 # textRect.topleft = (30,30) # text1Rect.topleft = (450,30) flag = False while True:     for event in pygame.event.get():         if pygame.Rect.collidepoint(rect1, (ball_x, ball_y)) and event.type==pygame.MOUSEBUTTONDOWN:             muyulucky.play()             flag=True             count = count + 1             text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))             textRect = text.get_rect()             textRect.topleft = (30, 30)             text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0), (0, 0, 0))             text1Rect = text1.get_rect()             text1Rect.topleft = (450, 30)             screen.blit(text1, text1Rect)             screen.blit(text,textRect)             if count==8:                 f2 = pygame.font.SysFont("华文楷体", 25)                 text2 = f2.render("今日积累功德8次，去表白应该不会被拒绝太难堪哦", True, (255, 0, 20))                 text2Rect = text.get_rect()                 text2Rect.topleft = (60, 150)                 screen.blit(text2, text2Rect)             if count==10:                 text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))                 textRect = text.get_rect()                 textRect.topleft = (30, 30)                 text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0))                 text1Rect = text1.get_rect()                 text1Rect.topleft = (450, 30)                 screen.blit(img1, (-180, -100))                 screen.blit(text1, text1Rect)                 screen.blit(text, textRect)             if count==20:                 f2 = pygame.font.SysFont("华文楷体", 25)                 text3 = f2.render("手速这么快干嘛，这是敲木鱼积功德，不是你dfj", True, (230, 90, 80))                 text3Rect = text.get_rect()                 text3Rect.topleft = (60, 150)                 screen.blit(text3, text3Rect)             if count==22:                 text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))                 textRect = text.get_rect()                 textRect.topleft = (30, 30)                 text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0), (0, 0, 0))                 text1Rect = text1.get_rect()                 text1Rect.topleft = (450, 30)                 screen.blit(img1, (-180, -100))                 screen.blit(text1, text1Rect)                 screen.blit(text, textRect)             if count==28:                 f2 = pygame.font.SysFont("华文楷体", 25)                 text3 = f2.render("tmd，我看你不是敲木鱼，是泄火吧", True, (255, 200, 20))                 text3Rect = text.get_rect()                 text3Rect.topleft = (60, 150)                 screen.blit(text3, text3Rect)             if count==30:                 text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))                 textRect = text.get_rect()                 textRect.topleft = (30, 30)                 text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0), (0, 0, 0))                 text1Rect = text1.get_rect()                 text1Rect.topleft = (450, 30)                 screen.blit(img1, (-180, -100))                 screen.blit(text1, text1Rect)                 screen.blit(text, textRect)             if count==40:                 screen.blit(img2, (-210,10))             if count==41:                 text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))                 textRect = text.get_rect()                 textRect.topleft = (30, 30)                 text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0), (0, 0, 0))                 text1Rect = text1.get_rect()                 text1Rect.topleft = (450, 30)                 screen.blit(img1, (-180, -100))                 screen.blit(text1, text1Rect)                 screen.blit(text, textRect)             if count==50:                 f2 = pygame.font.SysFont("华文楷体", 25)                 text3 = f2.render("今日功德累计50次了，小熊后台奖励你一只女朋友！", True, (255, 0, 0))                 text3Rect = text.get_rect()                 text3Rect.topleft = (60, 150)                 screen.blit(text3, text3Rect)                 screen.blit(img3, (-300, 0))             if count==51:                 text = f.render("功德+1", True, (255, 0, 0), (0, 0, 0))                 textRect = text.get_rect()                 textRect.topleft = (30, 30)                 text1 = f1.render("今日积累功德" + str(count) + "次", True, (255, 0, 0), (0, 0, 0))                 text1Rect = text1.get_rect()                 text1Rect.topleft = (450, 30)                 screen.blit(img1, (-180, -100))                 screen.blit(text1, text1Rect)                 screen.blit(text, textRect)               pygame.display.flip()         if pygame.Rect.collidepoint(rect1, (ball_x, ball_y)) and event.type==pygame.MOUSEBUTTONUP:             flag = False              text = f.render("功德+1", True, (0, 0, 0), (0, 0, 0))             textRect = text.get_rect()             textRect.topleft = (30, 30)             screen.blit(text, textRect)             if count==40:                 screen.blit(img2, (-210, 10))             if count==50:                 f2 = pygame.font.SysFont("华文楷体", 25)                 text3 = f2.render("功德积累是好事，凡事有个度！", True, (255, 0, 0))                 text4 = f2.render("小熊后台检测到你今日功德累计50次，看张照片放松一下吧！！", True, (255, 0, 0))                 text3Rect = text.get_rect()                 text4Rect = text.get_rect()                 text3Rect.topleft = (60, 150)                 text4Rect.topleft = (0, 180)                 screen.blit(img3, (-300, 0))                 screen.blit(text3, text3Rect)                 screen.blit(text4, text4Rect)               pygame.display.flip()         if event.type==pygame.QUIT:             import mouse             pygame.quit()     pygame.display.flip()  截图：    ———————————————— 版权声明：本文为CSDN博主「DY.memory」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/Abtxr/article/details/127827970 

 序言 话说在前面，我不是小黑子~  我是超级大黑子😏  表弟大周末的跑来我家，没事干天天骚扰我，搞得我都不能跟小姐姐好好聊天了，于是为了打发表弟，我决定用Python做一个小游戏来消耗一下他的精力，我思来想去，决定把他变成小黑子，于是做了一个坤坤打篮球的游戏，没想到他还挺爱玩的~  终于解放了，于是我把游戏写下来，也给大家分享一下吧~  好吧，其实并不是这样的游戏，往下慢慢看吧。  准备工作 开发环境 Python版本：3.7.8  相关模块： requests模块； tqdm模块； pyfreeproxy模块； pyecharts模块； 以及一些python自带的模块。  效果预览 开始界面  游戏规则 wasd 控制人物的移动，空格启动律师函炸毁全部篮球。    结束游戏  兄弟们学习python，有时候不知道怎么学，从哪里开始学。掌握了基本的一些语法或者做了两个案例后，不知道下一步怎么走，不知道如何去学习更加高深的知识。 那么对于这些大兄弟们，我准备了大量的免费视频教程，PDF电子书籍，以及源代码！直接在文末名片自取即可！  代码实现 导入模块  import pygame import sys import traceback import os import CXK import enemy import bullet import supply from pygame.locals import * from random import * 游戏主界面  #游戏主界面 def ui():     #循环播放背景音乐     pygame.mixer.music.play(-1)      #初始化界面按键图片并获取图片的矩形位置     start_game_image = pygame.image.load("images/start_game.png").convert_alpha()     start_game_image_rect = start_game_image.get_rect()     game_rules_image = pygame.image.load("images/game_rules.png").convert_alpha()     game_rules_image_rect = game_rules_image.get_rect()     game_quit_image = pygame.image.load("images/game_quit.png").convert_alpha()     game_quit_image_rect = game_quit_image.get_rect()      #初始化游戏规则图片并获取图片的矩形位置     rules_image = pygame.image.load("images/游戏玩法.png").convert_alpha()     back_image = pygame.image.load("images/back.png").convert_alpha()     back_image_rect =  back_image.get_rect()      #标志是否在主界面     is_ui = True      #帧率     clock = pygame.time.Clock()      #主界面循环     while True:         #获取事件信息         for event in pygame.event.get():             #如果点击右上角退出             if event.type == QUIT:                 #退出程序                 pygame.quit()                 sys.exit()          #如果是主界面         if is_ui:             #绘制背景             screen.blit(background,(0,0))              #更改主界面按键图片的矩形位置并绘制主界面按键             start_game_image_rect.left,start_game_image_rect.top = (width - start_game_image_rect.width)//2,height - 500             screen.blit(start_game_image,start_game_image_rect)              game_rules_image_rect = game_rules_image.get_rect()             game_rules_image_rect.left,game_rules_image_rect.top = (width - game_rules_image_rect.width)//2,start_game_image_rect.bottom+50             screen.blit(game_rules_image,game_rules_image_rect)              game_quit_image_rect.left,game_quit_image_rect.top = (width - game_quit_image_rect.width)//2, game_rules_image_rect.bottom+50             screen.blit(game_quit_image,game_quit_image_rect)              #检测用户的鼠标操作             #如果用户按下鼠标左键             if pygame.mouse.get_pressed()[0]:                 #获取鼠标坐标                 pos = pygame.mouse.get_pos()                 #如果用户点击”开始游戏“                 if start_game_image_rect.left < pos[0] < start_game_image_rect.right and start_game_image_rect.top < pos[1] < start_game_image_rect.bottom:                     #调用主函数                     main()                 #如果用户点击”退出游戏“                 if game_quit_image_rect.left < pos[0] < game_quit_image_rect.right and game_quit_image_rect.top < pos[1] < game_quit_image_rect.bottom:                     pygame.quit()                     sys.exit()                 #如果用户点击”游戏规则“                 if game_rules_image_rect.left < pos[0] < game_rules_image_rect.right and game_rules_image_rect.top < pos[1] < game_rules_image_rect.bottom:                     #离开主界面                     is_ui = False  代码有点多，就没有全部粘贴出来，可以在文末名片自取哈~  ———————————————— 版权声明：本文为CSDN博主「轻松学Python」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/ooowwq/article/details/128083180 

遍历list的元素后，输入网页文本框内的内容有[ " "]这四个符号这是我用messageBox查看遍历的元素，弹出的消息框我该怎么删掉这四个符号呢？这是它写入网页文本框内的样子list的元素是我获取的excel的一列数据，因为他太长了超过15个字符，数值形式会导致15个字符之后的数字都变成0，所以把它的单元格格式设置为文本的形式，然后读取这一列的数据，然后遍历输入到网页文本框内。但是出现了以上这个问题，不知道该如何解决。

@app.route('/uploader',methods=['GET','POST'])def uploader(): if request.method == 'POST': f = request.files['file'] print(request.files) f.save(os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(f.filename))) return 'file uploaded successfully' else: return render_template('upload.html')像这样的Flask代码，它返回一个字符串或者返回一个html（都会打开一个新页面）那我如何返回html的同时，也带一个字符串参数呢？然后在新的html页面里，如何在新的请求中加上这个字符串参数呢？感谢！

 项目场景：使用Anaconda Prompt创建虚拟环境问题描述 保存虚拟环境的默认地址是C盘，而我想将下载的虚拟环境保存到我自定义的位置。  解决方案： 1、使用  conda config --show 1 查看envs_dirs的信息，一般第一个路径是默认路径。把它修改成想要自定义的路径 方法1: windows+r输入%HOMEPATH% 找到.condarc文件，用记事本打开，将自定义文件夹的路径append到文件中。 比如:  envs_dirs:   - D:\SDE\Anaconda\Anaconda3\envs 1 2 first step:  second step:  third step:  注意: 我看了很多材料说是把Anaconda3文件夹的只读属性去掉(右键属性即可找到)。但是我尝试后，新创建的虚拟环境还是在C盘。 ⭐故大家在改完Anaconda3的文件夹属性后没成功的话可以试试，将envs文件夹(这是我的文件夹，因人而异)的只读属性去掉，并且在属性–>安全–>User中将权限全都勾上。此时再Anaconda Prompt中创建虚拟环境应该就没问题了。⭐  2、在Anaconda Prompt中使用命令，添加新的虚拟环境作为默认环境  conda config --add envs_dirs 虚拟环境的绝对路径 1 我的方法的亮点在于对envs文件夹的权限的操作，针对我的情况确实通过修改envs文件夹的只读和赋予全部权限操作实现了虚拟环境下载到自定义路径。  Tips： 1、在用  conda create -n 虚拟环境名 python=指定python版本   （不指定默认最新版本） 1 创建虚拟环境时，在命令行询问我们是否创建虚拟环境时(y/n),在命令的上方会显示此时虚拟环境的路径创建在什么位置，故不用去选择y下载，等下载完后再去用下方命令查看。  conda env list some common commands  conda activate 退出虚拟环境 conda remove --name env_name --all 删除虚拟环境及其中所安装的包 conda remove --name env_name package_name conda config --show 查看conda信息 修改虚拟环境的默认目录   -%HOMEPATH%大家.condarc文件加入       envs_dirs:       D:\SDE\Anaconda\Anaconda3\envs 这是我在使用Anaconda Prompt创建虚拟环境时遇到的问题，供大家参考，欢迎大家一起交流探讨。如有帮助，还请点个赞哦，谢谢大家的支持！ ———————————————— 版权声明：本文为CSDN博主「慢车早行」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/weixin_44768070/article/details/126682896 

isdigit() isalpha()用于判断字符串的类型要求1统计某个字符串中的数字数量并输出，例如字符串为“adsfsd1adf23sdfa12”思路：遍历字符串，用isdigit()方法判断是否为数字，如果为数字，统计+1代码如下：str=input("请输入任意字符串") num=0   #统计基数 for i in str:  #遍历字符串     if i.isdigit():     #判断是否为数字         num+=1 print(num)要求2在要求1的基础中统计出现数字的次数，比如12dsd23dsddf1,其中出现数字12，23,1共3次。思路：此时如果利用上述思路，无法实现要求，故转换思路。1.遍历字符串，用 isalpha()判断字符串类型是否Wie字符串2.将字符串中的字符都换成空格，此时字符串中只有数字和空格3.将原有字符串用split()转换为列表4.统计列表元素长度代码如下：s=input("") num=0   #统计基数 for i in s: #遍历字符串     if i.isalpha(): #判断是否为字符串         s=s.replace(i," ")  #如果是字符串，替换为空格 b=s.split()     #拆分字符串 print(len(b))   #统计字符串长度isdigit()、isalpha()、isalnum() 三个函数的区别和注意点一、isdigit()python关于 isdigit() 内置函数的官方定义：S.isdigit() -> bool                 Return True if all characters in S are digits         and there is at least one character in S, False otherwise.翻译：S.isdigit()返回的是布尔值：True FalseS中至少有一个字符且如果S中的所有字符都是数字，那么返回结果就是True；否则，就返回False S1 = '12345'       #纯数字 S2 = '①②'        #带圈的数字 S3 = '汉字'        #汉字 S4 = '%#￥'        #特殊符号  print(S1.isdigit()) print(S2.isdigit()) print(S3.isdigit()) print(S4.isdigit())  # 执行结果： True      True False False 二、isalpha()python关于 isalpha() 内置函数的官方定义：S.isalpha() -> bool                 Return True if all characters in S are alphabetic         and there is at least one character in S, False otherwise.翻译：S.isalpha()返回的是布尔值：True FalseS中至少有一个字符且如果S中的所有字符都是字母，那么返回结果就是True；否则，就返回False S1 = 'abc汉字'     #汉字+字母 S2 = 'ab字134'     #包含数字 S3 = '*&&'         #特殊符号  print(S1.isalpha()) print(S2.isalpha()) print(S3.isalpha())  #执行结果 True False False 三、isalnum()python关于 isalnum() 内置函数的官方定义：S.isalnum() -> bool          Return True if all characters in S are alphanumeric         and there is at least one character in S, False otherwise.翻译：S.isalnum()返回的是布尔值：True FalseS中至少有一个字符且如果S中的所有字符都是字母数字，那么返回结果就是True；否则，就返回False S1 = 'abc汉字1'    #字母+汉字+数字 S2 = '①②③'      #带圈的数字 S3 = '%……&'       #特殊符号  print(S1.isalnum()) print(S2.isalnum()) print(S3.isalnum())  #执行结果 True True False 注意点：1.python官方定义中的字母：大家默认为英文字母+汉字即可2.python官方定义中的数字：大家默认为阿拉伯数字+带圈的数字即可

今天分享一个我自己写的实用脚本，主要是将.xml文件进行批量的修改首先，声明我并不是很了解.xml的相关知识，所以今天主要是以我遇到的问题来做个记录。想要更多的了解xml，请看最后的资料分享。效果展示：因为这些是属于我们项目小组的，我也不清楚是不是有什么不能公开的，我就截取了一小部分，原本是用lambelme来修改的，但由于xml文件似乎读不进去，所以只有手动修改，将water改为blue（重要的是一个一个用记事本打开，手动修改），这时候我的第一生产力产生了，because I am lazy。这是下面的pyxml.py文件import os import os.path import xml.dom.minidom as md   path = 'E:\\Deeplearning\\Road_Detect_Project\\road_surface_mark\\Annot\\' files = os.listdir(path)  # 得到文件夹下所有文件名称 def main():     for xmlFile in files:  # 遍历文件夹         if not os.path.isdir(xmlFile):  # 判断是否是文件夹，不是文件夹才打开               dom = md.parse(os.path.join(path,xmlFile))             root = dom.documentElement             names = root.getElementsByTagName('name')  #对某个标签进行修改             # print(name[0].firstChild.data)             for i in range(len(names)):                 print(names[i].firstChild.data)                 a=names[i].firstChild.data                 print(type(a))                 names[i].firstChild.data = "red"                 print(names[i].firstChild.data)             with open(os.path.join(path,xmlFile), 'w') as fh:                 dom.writexml(fh)                 print('夏天是冰红茶的文件成功写入')  #使用时，请不要删除这段   if __name__ == '__main__':     main() 我说一下问题，因为小组的其他师兄有用中文路径，就会发生下面的情况：但是记事本打开是正常的，也已经修改成功了。这种我是成功了。（别建议我打马赛克）下次组会，我一定要提这个问题，以前因为路径中有中文吃了很多亏，所以我现在建工程都是尽量去用英文。补充除了上文的方法，小编还为大家整理了Python修改xml文件的其他方法，需要的可以参考一下批量修改xml文件中指定位置内容我要修改图片的绝对路径 #!/usr/bin/python ''' 此文件用于整理网络上搜集的数据集的xml文件，整理后方便用于训练。  ''' import os       #文件操作相关 import xml.etree.ElementTree as ET  #xml文件操作相关  """  "******************************************************************************************* *函数功能 ：  *输入参数 ：输入裁剪后图像， *返 回 值 ：无 *编写时间 ： 2021.7.12 *作    者 ： diyun ********************************************************************************************""" # 批量修改整个文件夹所有的xml文件 def change_all_xml(xmlfilepath,string1):     total_xml = os.listdir(xmlfilepath)  # 用于返回指定的文件夹包含的文件或文件夹的名字的列表。      num = len(total_xml)  # xml文件个数     print(num)     print(total_xml[0])     for xmlfile in total_xml:         #print(xml_id)         in_file = open('%s/%s' % (xmlfilepath, xmlfile),encoding = 'UTF-8')         #print(in_file)          tree = ET.parse(in_file)         #print(tree)         root = tree.getroot()         #print(root)         obj = root.find('path')  # 找到filename标签，         #print(obj)         path_text = obj.text         #print(path_text)         end = "\\"         string2 = path_text[path_text.rfind(end):]  # 在strint1中查找最后一个正斜杠/后面的字符,图片名称         #print(string2)         path_text_1=string1+string2         #print("path_text_1:",path_text_1)         obj.text = path_text_1  # 修改标签内容         tree.write('%s/%s' % (xmlfilepath, xmlfile))  # 保存修改  xmlfilepath = 'helmet_xml'  # xml文件保存地址 # 要修改的内容 string1='E:\\1_Training_picture\\6_helmet\\helmet_train'  change_all_xml(xmlfilepath,string1) print("ok") 修改path和filename #!/usr/bin/python ''' 此文件用于整理网络上搜集的数据集的xml文件，整理后方便用于训练。  ''' import os       #文件操作相关 import xml.etree.ElementTree as ET  #xml文件操作相关  """  "******************************************************************************************* *函数功能 ：  *输入参数 ：输入裁剪后图像， *返 回 值 ：无 *编写时间 ： 2021.7.12 *作    者 ： diyun ********************************************************************************************""" # 批量修改整个文件夹所有的xml文件 def change_all_xml(xmlfilepath,string1):     total_xml = os.listdir(xmlfilepath)  # 用于返回指定的文件夹包含的文件或文件夹的名字的列表。      num = len(total_xml)  # xml文件个数     print(num)     print(total_xml[0])     for xmlfile in total_xml:         #print("**********************************************************************************************************")         #print(xmlfile)         in_file = open('%s/%s' % (xmlfilepath, xmlfile),encoding = 'UTF-8')         #print(in_file)          tree = ET.parse(in_file)         #print(tree)         root = tree.getroot()         #print(root)         obj = root.find('path')  # 找到filename标签，         #print(obj)         path_text = obj.text         #print(path_text)         #end = "."         end = "."         string3 = path_text[path_text.rfind(end):]  # 在strint1中查找最后一个反斜杠\后面的字符,图片名称         #print("string3:", string3)         end = "."         #string4 = string3[string3.rfind(end):]  # 在strint1中查找最后一个正斜杠/后面的字符,图片名称         #print("string4:", string4)          #print("xmlfile:", xmlfile)         #print("string1:", string1)         end = "."         string2 = xmlfile[:xmlfile.rfind(end)]  # 在strint1中查找最后一个正斜杠/后面的字符,图片名称         #print("string2:", string2)         path_text_1 = string1 + string2+string3         #print("path_text_1:",path_text_1)         obj.text = path_text_1  # 修改标签内容         #tree.write('%s/%s' % (xmlfilepath, xmlfile))  # 保存修改         obj_2 = root.find('filename')  # 找到filename标签         #print("obj_2:", obj_2)         path_text_2= string2+string3         #print("path_text_2:", path_text_2)         obj_2.text = path_text_2  # 修改标签内容         tree.write('%s/%s' % (xmlfilepath, xmlfile))  # 保存修改  #xmlfilepath = 'temp'  # xml文件保存地址 xmlfilepath = 'helmet_xml'  # xml文件保存地址 # 要修改的内容 string1='E:\\1_Training_picture\\6_helmet\\helmet_train\\'  change_all_xml(xmlfilepath,string1) print("ok") 

一、面向对象三大特征之继承python三大特征：封装、继承、多态三者中继承最为核心，实际应用多，感受较为直观封装和多态略微抽象1、继承的概念继承的含义:在现实生活中，继承表示人与人之间资源的从属关系例如：儿子继承父亲在编程的世界中，继承表示类与类之间的资源从属关系例如：类a继承类b继承的目的:在现实生活中，儿子继承了附件就拥有了父亲所有资源的支配权限在编程世界中，类A继承了类B就拥有了类B中所有的数据和方法使用权限2、继承的本质继承本质应该分为两部分：当多个类中含有相同部分时，我们就把相同的部分抽离出去，将相同的部分新成一个新的类，在用刚才被抽离出去相同部分的类，去继承新的那部分，这样的好处就是，当多个类需要一个相同用的功能时，可以节省代码，不用反复编写抽象：将多个类相同的东西抽出去，形成一个新的类继承：将多个类继承刚刚抽取出来的新的类对象>>>：数据与功能的结合体类(子类)>>>:多个对象相同功能和数据的结合体父类>>>：多个子类相同功能和数据的结合体本质：类、父类的本质都是为了节省代码，减少重复编写相同代码的时间，使用时更为方便3、继承的实操在定义类的时候，类名后方可加括号，早括号内填入其他它类的名字，就意味着继承了其它类python支持多类继承，括号内可填写多个类名，只需用逗号隔开即可# 1、定义两个类，其中一个假设为父类，另一个假设为子类 class Father:      money = 99999999     house = '老北京四合院'  # 父类中数据强大 class Son:     pass  # 子类中空空如也 # 2、父类中的数据，子类无权直接使用，当我们在子类中继承父类后，子类和子类产生的对象都可以通过'点'的方式使用父类中的数据 class Father:     money = 99999999     house = '老北京四合院' class Son(Father):     pass # 子类直接使用父类中的数据 print(Son.money) # 子类产生的对象使用父类中的数据 obj1 = Son() print(obj1.money) ------------------------------------------------------------------------------------ 99999999 99999999 4、继承后名字查找的顺序未继承：对象（object）自身名称空间>>>类的名称空间单线继承:对象（object）自身名称空间>>>子类的名称空间>>>父类的名称空间多线继承:1、菱形继承： （广度优先，最后才会找闭环的定点）对象自身名称空间>>>子类名称空间>>>父类名称空间（形参内由左至右）>>>闭环2、非菱形继承： （深度优先）对象自身名称空间>>>子类名称空间>>>父类名称空间（形参内由左至右）在一个子类绑定多个父类时，名字的查找顺序可能比较难理解，针对这个问题，可以使用python中内置方法：mor()   通过对象名点mor() 的方式，可以帮助我们查看名字的查找顺序5、经典类与新式类经典类：不继承object的类或者其子类的类新式类:继承object或者其之类的类在python3中，只有新式类，所有类都默认继承object在python2中，区分经典类和新式类在以后我们定义类的时候，如果没有明确的父类，可以在类的括号内填入object，这样话能够提高我们代码的兼容性二、派生1、派生的概念派生是指，子类继承父类，派生出自己的属性与方法，并且重用父类的属性与方法2、派生的方法1.直接引用父类的__ init __为其传参，并添加子类属性缺点：代码重复率太高，浪费资源，时间class People:     school = '清华大学'     def __init__(self, name, sex, age):         self.name = name         self.sex = sex         self.age = age class Teacher(People):     def __init__(self, name, sex, age, title): #派生         self.name = name         self.sex = sex         self.age = age         self.title = title     def teach(self):         print(f'{self.name}是老师') obj = Teacher('lili','female', 28, '高级教师')  #只会找自己类中的__init__ print(obj.name, obj.sex, obj.age, obj.title)   #lili female 28 高级教师 123456789101112131415161718class People:    school = '清华大学'    def __init__(self, name, sex, age):        self.name = name        self.sex = sex        self.age = ageclass Teacher(People):    def __init__(self, name, sex, age, title): #派生        self.name = name        self.sex = sex        self.age = age        self.title = title    def teach(self):        print(f'{self.name}是老师')obj = Teacher('lili','female', 28, '高级教师') #只会找自己类中的__init__print(obj.name, obj.sex, obj.age, obj.title)  #lili female 28 高级教师2.通过super()来只想父类的属性super()是一个特殊的类，在子类__ init __内调用super得到一个对象，该对象指向父类的名称空间class Teacher(People):     def __init__(self, name, sex, age, title):         super().__init__(name, age, sex)         #调用的是绑定方法，自动传入self         self.title = title      def teach(self):          print(f'{self.name}是老师') obj = Teacher('lili','female', 28, '高级教师')  注意：在python2中super 的使用需要完整地写成super（自己的类名,self）,而在python3中可以简写为super（）。

一、hashlib模块什么是哈希模块：hashlib模块是一种加密模块，内部存有多种加密类型加密的作用：可将明文数据进行加密，转换成一串密文，密文越长说明文件加密的越复杂加密算法的种类：md5base64hmacsha系列（sha1、sha224、sha256等等）补充说明：1.算法不变，如果内容相同，那么加密的结果肯定相同2.待加密的明文，可以一次传入，也可分多次传入，不会影响密文的结果3.加密的结果是无法反解密的4.加盐处理：4.1.加盐处理的意思是指：在明文内加入干扰项，可改变密文的结果，来提高被加密的安全性4.2.动态加盐：指干扰项是动态的，在加盐的基础上更大程度上提高被加密文件的安全性应用方向:用户密码加密可应用于用户登录时，对密码的加密文件安全性校验可对文件进行加密，通过比对文件的密文来判断文件是否被修改基本操作与用法导入模块：import hashlib 具体用法：1、选择加密算法：    md5 = hashlib.md5()2、传入明文：    md5.update(b'hello')     # 传入的明文需提前转换成二进制的方式3、获取加密密文：    res = md5.hexdigets()    print(res)      # 5d41402abc4b2a76b9719d911017c592二、subprocess模块简介什么是subprocess模块：subprocess是python内置的模块，这个模块中的Popen可以查看用户输入的命令行是否存在如果存在，把内容写入到stdout管道中如果不存在，把信息写入到stderr管道要注意的是，这个模块的返回结果只能让开发者看一次，如果想多次查看，需要在第一次输出的时候，把所有信息写入到变量中。基本操作与用法模块导入：import subprocess 基本格式:subprocess.Popen('命令'，              shell = True，              stdout = subprocess.PIPE,              stderr = subprocess.PIPE) shell=True 表示要在终端中运行的命令stdout=sbuprocess.PIPE 表示当命令存在的时候，把结果写入到stdout管道stderr=sbuprocess.PIPE 表示当命令不存在的时候，把结果吸入到stderr管道具体用法：import subprocess r = subprocess.Popen('xxxx', shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) print(r.stdout.read().decode('utf8')) print(r.stderr.read().decode('utf8')) 三、logging模块简介什么是logging模块：loggin模块是用来写日志的，以前我们写日志需要自己往文件里写记录信息，使用了logging之后我们只需要一次配置好，以后写日志的事情都不需要我们操心了，非常方便日志的组成：产生日志过滤日志输出日志日志格式日志的等级：DEBUG最详细的日志信息，典型应用场景是 问题诊断INFO信息详细程度仅次于DEBUG，通常只记录关键节点信息，用于确认一切都是按照我们预期的那样进行工作WARNING当某些不期望的事情发生时记录的信息（如，磁盘可用空间较低），但是此时应用程序还是正常运行的ERROR由于一个更严重的问题导致某些功能不能正常运行时记录的信息CRITICAL当发生严重错误，导致应用程序不能继续运行时记录的信息掌握层度：longging日志模块，内置方法与代码相对固定，在使用时，只需根据个人要求，对内部变量稍作修改即可使用基本操作与用法导入模块:import logging 打印日志级别：logging.debug('Python debug') logging.info('Python info') logging.warning('Python warning') logging.error('Python Error') logging.critical('Python critical') ------------------------------------------------------------------- WARNING:root:Python warning ERROR:root:Python Error CRITICAL:root:Python critical 当指定一个日志级别之后，会记录大于或等于这个日志级别的日志信息，小于的将会被丢弃， 默认情况下日志打印只显示大于等于 WARNING 级别的日志。代码用法：import logging logger = logging.getLogger("simple_example") logger.setLevel(logging.DEBUG) # 建立一个filehandler来把日志记录在文件里，级别为debug以上 fh = logging.FileHandler("spam.log") fh.setLevel(logging.DEBUG) # 建立一个streamhandler来把日志打在CMD窗口上，级别为error以上 ch = logging.StreamHandler() ch.setLevel(logging.ERROR) # 设置日志格式 formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") ch.setFormatter(formatter) fh.setFormatter(formatter) #将相应的handler添加在logger对象中 logger.addHandler(ch) logger.addHandler(fh) # 开始打日志 logger.debug("debug message") logger.info("info message") logger.warn("warn message") logger.error("error message") logger.critical("critical message") 日志模板：import logging import logging.config # 定义日志输出格式 开始 standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \                   '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字 simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s' # 自定义文件路径 logfile_path = 'a3.log' LOGGING_DIC = {     'version': 1,     'disable_existing_loggers': False,     'formatters': {         'standard': {             'format': standard_format         },         'simple': {             'format': simple_format         },     },     'filters': {},  # 过滤日志     'handlers': {         # 打印到终端的日志         'console': {             'level': 'DEBUG',             'class': 'logging.StreamHandler',  # 打印到屏幕             'formatter': 'simple'         },         # 打印到文件的日志,收集info及以上的日志         'default': {             'level': 'DEBUG',             'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件             'formatter': 'standard',             'filename': logfile_path,  # 日志文件             'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M             'backupCount': 5,                 # 这里两个参数的意思是一个日志文件最多写5M，最多可以存在五个不同的日志文件，但是当数量达到五个之后就会出现最早的那个会被删除，                 # 然后再产生一个新的文件（类似于覆盖了最早的那个文件）             'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了         },     },     'loggers': {         # logging.getLogger(__name__)拿到的logger配置         '': {             'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕             'level': 'DEBUG',             'propagate': True,  # 向上（更高level的logger）传递         },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置         # '购物车记录': {         #     'handlers': ['default','console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕         #     'level': 'WARNING',         #     'propagate': True,  # 向上（更高level的logger）传递         # },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置     }, } logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置 # logger1 = logging.getLogger('购物车记录') # logger1.warning('尊敬的VIP客户 晚上好 您又来啦') # logger1 = logging.getLogger('注册记录') # logger1.debug('jason注册成功') logger1 = logging.getLogger('红浪漫顾客消费记录') # 当这里的getLogger内部的参数如果字典中没有，就会自动使用字典中名称为空的那个模版来执行 logger1.debug('慢男 猛男 骚男')