Python

介绍Redis（Remote Dictionary Server）是一种高性能的开源内存数据库，它反对多种数据结构，如字符串、哈希、列表、汇合、有序汇合等，并提供了丰盛的操作命令。Redis具备疾速、牢靠和灵便的特点，广泛应用于缓存、音讯队列、会话存储、计数器等场景。本文将从入门到精通地介绍Python中操作Redis数据库的办法，带你把握应用Redis进行数据存储和读取的技巧。 目录装置和导入连贯Redis数据库字符串操作哈希操作列表操作汇合操作有序汇合操作公布订阅模式事务操作过期工夫和长久化性能优化分布式锁Redis主从复制Redis哨兵Redis集群总结1. 装置和导入首先，咱们须要装置Redis数据库。能够从Redis官网下载安装包进行装置，或者应用包管理工具进行装置。装置实现后，咱们须要在Python中导入redis模块来操作Redis数据库： import redis2. 连贯Redis数据库在应用Redis之前，咱们须要先建设与Redis服务器的连贯。能够应用redis.Redis()办法创立一个Redis客户端对象，而后通过该对象进行数据的存储和读取。 import redis# 建设与本地Redis服务器的连贯client = redis.Redis(host='localhost', port=6379, db=0)# 存储数据client.set('name', 'Alice')# 读取数据value = client.get('name')print(value.decode())在上述代码中，咱们应用redis.Redis()办法创立了一个与本地Redis服务器的连贯，并应用client.set()办法存储了一个键值对，而后应用client.get()办法读取了数据，并通过decode()办法将二进制数据转换为字符串输入。 3. 字符串操作Redis的字符串数据结构是最根本的数据类型，能够用来存储字符串、整数、浮点数等。 存储和读取字符串import redisclient = redis.Redis(host='localhost', port=6379, db=0)# 存储字符串client.set('name', 'Alice')# 读取字符串value = client.get('name')print(value.decode())减少和缩小整数import redisclient = redis.Redis(host='localhost', port=6379, db=0)# 存储整数client.set('counter', 10)# 减少整数client.incr('counter', 5)# 读取整数value = client.get('counter')print(int(value))设置过期工夫import redisclient = redis.Redis(host='localhost', port=6379, db=0)# 存储字符串，并设置过期工夫为10秒client.setex('name', 10, 'Alice')# 读取字符串value = client.get('name')print(value.decode())# 期待11秒后，再次读取数据import timetime.sleep(11)value = client.get('name')print(value) # 过期后返回None在上述代码中，咱们应用client.setex()办法存储了一个带有过期工夫的键值对，过期工夫为10秒。期待11秒后，再次读取数据，发现键曾经过期，返回了None。 4. 哈希操作哈希是一种键值对的汇合，适宜存储对象。 存储和读取哈希import redisclient = redis.Redis(host='localhost', port=6379, db=0)# 存储哈希client.hset('user', 'name', 'Alice')client.hset('user', 'age', 30)# 读取哈希name = client.hget('user', 'name')age = client.hget('user', 'age')print(name.decode(), age.decode())获取所有键值对import redisclient = redis.Redis(host='localhost', port=6379, db=0)# 存储哈希client.hset('user', 'name', 'Alice')client.hset('user', 'age', 30)# 获取所有键值对data = client.hgetall('user')for key, value in data.items(): print(key.decode(), value.decode())5. 列表操作列表是一种有序的字符串列表，能够存储反复的值。 ...

在Python网络申请中级篇中，咱们理解了如何通过Requests库发送带参数的申请，解决Cookies，应用Session对象，以及设置申请头。在本文中，咱们将进一步深刻学习Requests库的高级性能，包含解决重定向，设置超时，解决大文件以及谬误和异样解决。 一、解决重定向默认状况下，Requests会主动解决重定向。咱们能够通过响应对象的history属性查看重定向历史。如果咱们不想让Requests主动解决重定向，能够通过allow_redirects选项来禁止重定向。 import requestsresponse = requests.get('http://github.com', allow_redirects=False)print(response.status_code)print(response.history)二、设置超时咱们能够通过timeout选项为申请设置超时工夫。超时工夫能够设置为一个浮点数，示意申请的最长工夫，单位为秒。 import requeststry: response = requests.get('http://github.com', timeout=0.001)except requests.exceptions.Timeout: print('The request timed out')三、解决大文件当咱们须要下载大文件时，咱们应该防止一次性读取整个文件到内存。咱们能够通过流(stream)来解决大文件。 import requestsresponse = requests.get('http://example.com/big_file', stream=True)with open('big_file', 'wb') as fd: for chunk in response.iter_content(chunk_size=128): fd.write(chunk)这段代码将会分块读取大文件，每块的大小为128字节，并将每块写入到本地的big_file文件中。 四、谬误和异样解决Requests库提供了一套残缺的异样体系，能够解决各种谬误。例如，咱们能够捕捉RequestException异样，这是所有Requests异样的基类。 import requestsfrom requests.exceptions import RequestExceptiontry: response = requests.get('http://example.com')except RequestException as e: print('There was an ambiguous exception that occurred while handling your request.', e)深度了解Requests库，能够让咱们在解决网络申请时更加得心应手。不管你是要进行爬虫开发，还是API测试，Requests库都是你的得力工具。

在Python网络申请高级篇中，咱们理解了Requests库根底的应用形式，包含如何发动GET和POST申请，如何解析JSON响应以及如何解决异样。在本文中，咱们将深刻了解Requests库，包含如何发送带参数的申请，如何解决Cookies，如何应用Session对象以及如何设置申请头。 一、发送带参数的申请咱们能够通过两种形式向URL增加参数，一种是间接在URL中增加，另一种是应用params选项。 import requests# 间接在URL中增加参数response = requests.get('http://httpbin.org/get?name=John&age=23')# 应用params选项增加参数payload = {'name': 'John', 'age': 23}response = requests.get('http://httpbin.org/get', params=payload)二、解决Cookies有时，咱们须要在申请中发送或接管cookies。咱们能够通过Requests库的cookies属性来实现。 import requests# 发送cookiescookies = dict(cookies_are='working')response = requests.get('http://httpbin.org/cookies', cookies=cookies)# 接管cookiesresponse = requests.get('http://www.github.com')print(response.cookies['some_cookie'])三、应用Session对象在进行多个申请时，咱们可能须要应用到同一个Session。Session对象容许咱们跨申请放弃某些参数。 import requestss = requests.Session()s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')r = s.get('http://httpbin.org/cookies')print(r.text)在这个例子中，咱们首先创立了一个Session对象s，而后应用s进行了两次申请。因为这两次申请应用了同一个Session，所以第二次申请能够获取到第一次申请设置的cookies。 四、设置申请头咱们能够通过headers选项设置申请头。 import requestsheaders = {'user-agent': 'my-app/0.0.1'}response = requests.get('http://httpbin.org/get', headers=headers)这段代码设置了User-Agent申请头，而后发动了一个GET申请。 应用Requests库，咱们能够轻松实现各种简单的网络申请工作。在后续的文章中，咱们将进一步学习Requests库的高级应用形式。

在Python中，列表（list）是一种有序、可变的数据结构，用于存储多个元素。列表能够蕴含不同类型的元素，包含整数、浮点数、字符串等。实际上列表有点相似C++语言中的数组，但仅仅只是相似，和数组还是有点不一样的。列表非常适合利用程序和地位定位某一元素，尤其是当元素的程序或内容常常产生扭转时。 在Python列表应用方括号[]来示意，其中的元素用逗号,分隔。上面是一个简略的列表示例： fruits = ['apple', 'banana', 'orange']这个列表fruits蕴含了三个字符串元素：'apple'、'banana'和'orange'。 列表是可变的，这意味着您能够批改列表的内容。你能够通过索引来拜访和批改列表中的特定元素。索引从0开始，即第一个元素的索引为0。最初一个元素的索引为-1。 fruits = ['apple', 'banana', 'orange']print(fruits[0]) # 输入第一个元素 'apple'print(fruits[-1]) # 输入最初一个元素 'orange'fruits[1] = 'cherry' # 批改第二个元素为 'cherry'fruits.append('strawberry') # 在列表开端增加 'strawberry'del fruits[2] # 删除第三个元素 'orange'print(fruits) # 输入批改后的列表 ['apple', 'cherry', 'strawberry']列表反对许多其余有用的办法，如插入元素、移除元素、排序等。应用列表可能不便地存储和操作多个元素，因而在Python编程中常常被应用到。 创立列表要想应用列表，必定要先创立它，Python中创立列表的形式有以下几种： 应用方括号 [] 创立蕴含元素的列表：my_list = [1, 2, 3, 4, 5]应用 list() 函数将其余数据类型转换为列表：my_string = "hello"my_list = list(my_string) #输入['h', 'e', 'l', 'l', 'o']应用列表推导式创立列表：my_list = [x for x in range(10)] #输入[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]应用 range() 函数创立列表：my_list = list(range(10)) #输入[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]应用 * 运算符创立反复元素的列表：my_list = [0] * 5 #输入[0, 0, 0, 0, 0]以上就是创立列表的几种形式，能够看到，Python中创立列表的形式非常灵活，能够依据具体的需要抉择不同的形式。然而初学者的话，只有把握第1、2种创立形式就能够了，前面在实际的过程种缓缓把握其余的。 ...

在Python中，列表（list）是一种有序、可变的数据结构，用于存储多个元素。列表能够蕴含不同类型的元素，包含整数、浮点数、字符串等。实际上列表有点相似C++语言中的数组，但仅仅只是相似，和数组还是有点不一样的。列表非常适合利用程序和地位定位某一元素，尤其是当元素的程序或内容常常产生扭转时。 在Python列表应用方括号[]来示意，其中的元素用逗号,分隔。上面是一个简略的列表示例： fruits = ['apple', 'banana', 'orange']这个列表fruits蕴含了三个字符串元素：'apple'、'banana'和'orange'。 列表是可变的，这意味着您能够批改列表的内容。你能够通过索引来拜访和批改列表中的特定元素。索引从0开始，即第一个元素的索引为0。最初一个元素的索引为-1。 fruits = ['apple', 'banana', 'orange']print(fruits[0]) # 输入第一个元素 'apple'print(fruits[-1]) # 输入最初一个元素 'orange'fruits[1] = 'cherry' # 批改第二个元素为 'cherry'fruits.append('strawberry') # 在列表开端增加 'strawberry'del fruits[2] # 删除第三个元素 'orange'print(fruits) # 输入批改后的列表 ['apple', 'cherry', 'strawberry']列表反对许多其余有用的办法，如插入元素、移除元素、排序等。应用列表可能不便地存储和操作多个元素，因而在Python编程中常常被应用到。 创立列表要想应用列表，必定要先创立它，Python中创立列表的形式有以下几种： 应用方括号 [] 创立蕴含元素的列表：my_list = [1, 2, 3, 4, 5]应用 list() 函数将其余数据类型转换为列表：my_string = "hello"my_list = list(my_string) #输入['h', 'e', 'l', 'l', 'o']应用列表推导式创立列表：my_list = [x for x in range(10)] #输入[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]应用 range() 函数创立列表：my_list = list(range(10)) #输入[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]应用 * 运算符创立反复元素的列表：my_list = [0] * 5 #输入[0, 0, 0, 0, 0]以上就是创立列表的几种形式，能够看到，Python中创立列表的形式非常灵活，能够依据具体的需要抉择不同的形式。然而初学者的话，只有把握第1、2种创立形式就能够了，前面在实际的过程种缓缓把握其余的。 ...

插入排序是一种简略但无效的排序算法。它的根本思维是将待排序的元素一一插入已排序序列中的正确地位，直到所有元素都被插入实现。插入排序的算法复杂度为O(n^2)，实用于小规模的数据排序。本文将介绍插入排序的原理、具体实现和优化，并提供相干的Python代码示例。 一、插入排序的基本原理插入排序的基本原理能够用以下步骤形容： 将待排序序列的第一个元素看作已排序序列。从第二个元素开始，一一将元素插入已排序序列的正确地位。每次插入时，从后往前比拟已排序序列中的元素，将比以后元素大的元素顺次向后挪动，直到找到适合的插入地位。反复步骤3，直到所有元素都被插入实现，失去有序序列。插入排序的关键在于找到插入地位并进行元素的后移操作。这种排序算法相似于咱们打扑克牌时整顿手中的牌，每次将一张新牌插入到已排序的牌中的正确地位。 二、插入排序的具体实现上面是插入排序的具体实现代码： def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] # 以后待插入元素 j = i - 1 # 已排序序列的最初一个元素的索引 while j >= 0 and arr[j] > key: arr[j + 1] = arr[j] # 比以后元素大的元素向后挪动 j -= 1 arr[j + 1] = key # 将以后元素插入到正确地位 return arr三、插入排序的优化插入排序是一种简略然而效率较低的排序算法，特地是对于大规模数据的排序。然而，咱们能够通过一些优化策略来进步插入排序的性能。 优化1：缩小元素的比拟次数在内层循环中，咱们能够通过应用“哨兵”来防止每次比拟都须要查看边界条件。咱们能够将待插入的元素复制到一个长期变量中，并将其作为哨兵，而后在内层循环中只比拟哨兵与已排序元素，而不是每次都拜访原始数组。 def insertion_sort(arr): for i in range(1, len(arr)): key = arr[i] # 以后待插入元素 j = i - 1 # 已排序序列的最初一个元素的索引 while arr[j] > key: arr[j + 1] = arr[j] # 比以后元素大的元素向后挪动 j -= 1 arr[j + 1] = key # 将以后元素插入到正确地位 return arr优化2：应用二分查找确定插入地位传统的插入排序是通过一一比拟已排序元素找到正确的插入地位。然而，咱们能够应用二分查找来确定插入地位，从而缩小比拟的次数。 ...

Matplotlib 是一款极其弱小的 Python 数据可视化库。只管其应用起来可能稍显简单，但无疑，Matplotlib 是创立高质量图形的要害工具之一。在上一篇文章中，咱们介绍了 Matplotlib 的基础知识，包含创立和自定义根底图形等。而在这篇文章中，咱们将深刻探讨 Matplotlib 的一些高级个性，包含对象导向接口、自定义色彩映射和款式、动静图形等。 一、对象导向接口尽管 Matplotlib 的 pyplot 接口用于疾速绘制和批改图形，然而其有一个次要毛病，那就是在解决简单的图形和布局时可能会比拟艰难。这时，Matplotlib 的对象导向（Object-Oriented，简称 OO）接口就派上用场了。OO 接口通过明确创立图形和轴对象来提供更好的管制。 上面是一个应用 OO 接口创立图形的例子： import numpy as npimport matplotlib.pyplot as pltx = np.linspace(0, 10, 100)y = np.sin(x)fig, ax = plt.subplots() # 创立一个图形和一个轴对象ax.plot(x, y) # 在轴上绘制数据ax.set_xlabel('x')ax.set_ylabel('sin(x)')ax.set_title('A Simple Plot')plt.show()二、自定义色彩映射和款式在 Matplotlib 中，你能够自定义图形的简直所有元素，包含色彩映射和款式。例如，你能够应用 Colormap 对象来自定义色彩映射，应用 Style 对象来自定义款式。 以下是一个应用自定义色彩映射和款式的例子： import numpy as npimport matplotlib.pyplot as pltimport matplotlib.colors as mcolorsx = np.random.rand(100)y = np.random.rand(100)sizes = 1000 * np.random.rand(100)colors = np.random.rand(100)cmap = mcolors.LinearSegmentedColormap.from_list("", ["red", "yellow", "green"]) # 自定义色彩映射plt.style.use('ggplot') # 应用自定义款式plt.scatter(x, y, s=sizes, c=colors, cmap=cmap) # 应用自定义色彩映射plt.colorbar() # 显示色彩条plt.show()三、动静图形Matplotlib 还反对创立动静图形。你能够应用 FuncAnimation 对象来创立动静图形。动静图形能够使你的数据更加活泼，并能更好地展现数据的变动过程。 ...

Matplotlib是Python中最罕用的数据可视化库之一。它提供了丰盛的图表类型和灵便的自定义选项，能帮忙咱们以更直观的形式了解数据。本文将对Matplotlib的基本功能进行介绍，包含如何创立和自定义图表等。 一、Matplotlib简介Matplotlib是一个专门用于创立2D图表（包含3D图表）的Python库。它的名称来源于“MATLAB-style plotting”，示意它的设计指标是为Python提供和MATLAB类似的绘图性能。 Matplotlib的次要模块是pyplot，它提供了一套和MATLAB相似的命令格调的函数集，用于创立和显示图表。 上面是一个简略的例子，展现了如何应用Matplotlib创立一个线图： import matplotlib.pyplot as pltimport numpy as npx = np.linspace(0, 10, 100)y = np.sin(x)plt.plot(x, y)plt.show()在这个例子中，咱们首先生成了一组x和y的值，而后应用plt.plot(x, y)创立了一个线图，最初应用plt.show()显示图表。 二、创立不同类型的图表Matplotlib反对创立多种类型的图表，包含线图、散点图、柱状图、直方图、饼图等。 1. 线图线图是最根本的图表类型，它通过把数据点按程序连接起来，展现数据的变化趋势。咱们曾经在后面的例子中看到了如何创立线图。 2. 散点图散点图是用于展现两个变量之间关系的图表类型。咱们能够应用plt.scatter()函数创立散点图： x = np.random.rand(100)y = np.random.rand(100)plt.scatter(x, y)plt.show()3. 柱状图柱状图是用于比拟类别间差别的图表类型。咱们能够应用plt.bar()函数创立柱状图： categories = ['A', 'B', 'C', 'D']values = [23, 45, 56, 78]plt.bar(categories, values)plt.show()三、自定义图表Matplotlib提供了许多选项用于自定义图表，例如咱们能够增加题目、标签，更改色彩、线型、线宽等。 x = np.linspace(0, 10, 100)y = np.sin(x)plt.plot(x, y, color='red', linestyle='--', linewidth=2)plt.title('Sin Wave')plt.xlabel('X')plt.ylabel('Y')plt.grid(True)plt.show()在这个例子中，咱们更改了线的色彩、线型和线宽，增加了题目和坐标轴标签，还开启了网格。 除了上述的根底自定义选项，Matplotlib还提供了更多的高级性能，例如： 1. 创立子图咱们能够在一个图表中创立多个子图，每个子图能够有不同的类型和设置。咱们能够应用plt.subplot()函数创立子图： x = np.linspace(0, 10, 100)y1 = np.sin(x)y2 = np.cos(x)plt.subplot(2, 1, 1) # 创立一个2行1列的子图，并抉择第1个子图plt.plot(x, y1, color='red')plt.title('Sin Wave')plt.subplot(2, 1, 2) # 创立一个2行1列的子图，并抉择第2个子图plt.plot(x, y2, color='blue')plt.title('Cos Wave')plt.tight_layout() # 主动调整子图间距plt.show()2. 保留图表咱们能够应用plt.savefig()函数将图表保留为图片文件： ...

在Python中，文件操作是一项常见且重要的工作。通过文件操作，咱们能够读取文件内容、写入新的数据以及对文件进行其余的操作。本文将介绍Python中的文件操作，包含关上文件、读取文件、写入文件和敞开文件等基本操作，以及一些罕用的文件解决技巧和最佳实际。 一、关上文件在进行文件操作之前，咱们首先须要关上一个文件。Python提供了内置的open()函数来关上文件，并返回一个文件对象，咱们能够通过该对象来进行后续的操作。 1.1 示例代码上面是一个示例代码，展现了如何关上一个文件： # 关上文件file = open("example.txt", "r")在这个示例中，咱们应用open()函数关上了一个名为example.txt的文件，并将返回的文件对象赋值给变量file。参数"r"示意以只读模式关上文件，即咱们能够读取文件的内容但不能批改它。 二、读取文件一旦咱们关上了一个文件，就能够开始读取文件的内容了。Python提供了多种办法来读取文件，例如逐行读取、读取整个文件或按需读取等。 2.1 逐行读取文件逐行读取文件是一种常见的文件读取形式，特地实用于大型文件。咱们能够应用文件对象的readline()办法来逐行读取文件内容。 2.2 示例代码上面是一个示例代码，展现了如何逐行读取文件内容： # 逐行读取文件file = open("example.txt", "r")for line in file: print(line)file.close()在这个示例中，咱们应用for循环遍历文件对象file，每次迭代读取一行内容，并通过print()函数将其打印进去。最初，咱们通过close()办法敞开文件。 2.3 读取整个文件如果咱们心愿一次性读取整个文件的内容，能够应用文件对象的read()办法。该办法将返回一个蕴含文件所有内容的字符串。 2.4 示例代码上面是一个示例代码，展现了如何读取整个文件的内容： # 读取整个文件file = open("example.txt", "r")content = file.read()print(content)file.close()在这个示例中，咱们应用read()办法将文件的所有内容读取到变量content中，并通过print()函数将其打印进去。最初，咱们通过close()办法敞开文件。 2.5 按需读取文件如果咱们只须要读取文件中的一部分内容，而不是整个文件，能够应用文件对象的readlines()办法来按需读取文件内容，并返回一个蕴含所有行的列表。 2.6 示例代码上面是一个示例代码，展现了如何按需读取文件的内容： # 按需读取文件file = open("example.txt", "r")lines = file.readlines()for line in lines: print(line)file.close()在这个示例中，咱们应用readlines()办法将文件的所有行读取到列表lines中，并通过for循环逐行打印进去。最初，咱们通过close()办法敞开文件。 三、写入文件除了读取文件，咱们还能够应用Python进行文件的写入操作。通过关上文件时指定写入模式，咱们能够向文件中写入新的数据。 3.1 示例代码上面是一个示例代码，展现了如何向文件中写入数据： # 写入文件file = open("example.txt", "w")file.write("Hello, World!")file.close()在这个示例中，咱们应用open()函数关上文件并指定写入模式"w"，而后应用文件对象的write()办法向文件中写入字符串"Hello, World!"。最初，咱们通过close()办法敞开文件。须要留神的是，应用写入模式关上文件时，如果文件曾经存在，将会清空文件中的内容。如果心愿在已有内容的根底上追加新的数据，能够应用追加模式"a"。 3.2 追加文件内容如果咱们心愿在已有文件内容的开端追加新的数据，能够应用追加模式"a"关上文件。 3.3 示例代码上面是一个示例代码，展现了如何追加文件内容： # 追加文件内容file = open("example.txt", "a")file.write("\nWelcome to Python!")file.close()在这个示例中，咱们应用open()函数以追加模式"a"关上文件，并应用write()办法向文件中写入字符串"\nWelcome to Python!"。这里的\n示意换行符，用于在追加的内容前增加一个空行。最初，咱们通过close()办法敞开文件。 ...

引言在软件开发中，缓存是一种罕用的技术，用于进步零碎性能和响应速度。Python提供了多种缓存技术和库，使咱们可能轻松地实现缓存性能。本文将带您从入门到精通，逐渐介绍Python中的缓存应用办法，并提供实例演示。 目录缓存基础知识 什么是缓存缓存的工作原理缓存的劣势和实用场景Python中的缓存技术 应用字典作为缓存应用functools.lru_cache实现LRU缓存应用cachetools库实现各种缓存策略缓存的最佳实际 缓存过期工夫的设置缓存生效策略缓存与数据库的一致性实例演示 应用缓存优化函数调用缓存HTTP响应数据缓存数据库查问后果1. 缓存基础知识1.1 什么是缓存缓存是一种将计算结果长期存储起来的技术，以便在后续雷同或相似的申请中间接应用该后果，而不用从新计算。缓存能够存储在内存、磁盘或其余介质上，以进步零碎的性能和响应速度。 1.2 缓存的工作原理缓存的工作原理是将计算结果与对应的输出参数关联起来，并存储在缓存中。当下次应用雷同的参数进行计算时，首先查看缓存中是否存在对应的后果，如果存在，则间接返回缓存中的后果，而不用从新计算。 1.3 缓存的劣势和实用场景应用缓存能够进步零碎性能和响应速度，缩小计算资源的耗费。缓存实用于以下场景： 计算结果具备重复性，即雷同的输出参数会产生雷同的后果。计算结果的获取代价较高，例如波及网络申请、数据库查问等耗时操作。计算结果的有效期较长，即后果在一段时间内放弃不变。2. Python中的缓存技术2.1 应用字典作为缓存在Python中，最简略的缓存实现形式是应用字典。将计算结果与输出参数作为键值对存储在字典中，以便后续应用。 cache = {}def calculate_value(key): # 查看缓存中是否存在对应的后果 if key in cache: return cache[key] # 如果缓存中不存在后果，则进行计算 value = expensive_calculation(key) # 将计算结果存储到缓存中 cache[key] = value return value2.2 应用functools.lru_cache实现LRU缓存Python规范库functools中的lru_cache装璜器提供了LRU（Least Recently Used）缓存的实现。它应用字典作为缓存存储，并依据最近应用的规定进行缓存淘汰。 from functools import lru_cache@lru_cache(maxsize=100)def calculate_value(key): return expensive_calculation(key)2.3 应用cachetools库实现各种缓存策略cachetools是一个功能强大的缓存库，提供了多种缓存策略的实现，包含LRU、LFU（Least Frequently Used）、FIFO（First In, First Out）等。 from cachetools import LRUCache, TTLCache# 创立LRU缓存cache = LRUCache(maxsize=100)# 存储后果到缓存cache[key] = value# 从缓存中获取后果value = cache[key]# 创立具备过期工夫的缓存cache = TTLCache(maxsize=100, ttl=60) # 过期工夫为60秒3. 缓存的最佳实际3.1 缓存过期工夫的设置缓存的过期工夫是指缓存后果在多长时间后生效。依据理论需要，能够依据以下几种形式设置缓存的过期工夫： ...

深度探讨Django ORM的概念、根底应用、进阶操作以及具体解析在理论应用中如何解决数据库操作。同时，咱们还探讨了模型深刻了解，如何进行CRUD操作，并且深入了解到数据库迁徙等高级主题。为了全面解读Django ORM，咱们也探讨了其存在的有余，并对其将来倒退进行了瞻望。这篇文章旨在帮忙读者全面把握Django ORM，了解其如何简化数据库操作，并透过表象了解其外部工作原理。 Django ORM简介在深刻探讨Django的ORM（Object-Relational Mapping，对象-关系映射）之前，让咱们先了解一下什么是ORM。 ORM是一种编程技术，用于在面向对象的软件和关系数据库之间建设一种可兼容的零碎。简略来说，ORM可能让你应用Python（或其余编程语言）来操作数据库，就像你在操作Python对象一样。 Django的ORM是一个十分弱小的工具，它帮忙你治理和查询数据库。基于Django ORM的次要劣势，你能够： 利用Python的对象模型进行数据库查问，无需编写简单的SQL语句。实现数据库的平台独立性，因为Django ORM能够在多种数据库系统上运行。上面咱们用一个简略的例子来阐明这个概念。假如咱们有一个名为"Blog"的模型，其中有一个名为"title"的字段。应用Django ORM，咱们能够轻松地查问所有题目蕴含"Django"的博客。 # 导入模型from myapp.models import Blog# 应用ORM进行查问blogs = Blog.objects.filter(title__contains='Django')# 输入查问后果for blog in blogs: print(blog.title)如果你在数据库中有名为"Learning Django"和"Django ORM basics"的博客，下面的代码将会输入： Learning DjangoDjango ORM basics看到这里，你可能会发现Django ORM的弱小之处：它把简单的数据库操作转化为Python对象操作，这极大地提高了咱们的编程效率。 Django ORM运行机理与模型介绍Django ORM运行机理Django ORM将类（class）映射到数据库表（table），将类的实例（instance）映射到表的记录（record），将类的字段（field）映射到数据库的字段（column）。通过这种形式，你能够应用Python代码对数据库进行操作，而无需写任何SQL语句。 在Django ORM中，每个模型（model）对应一个数据库表，模型的字段对应表的列，模型的实例对应表的行。 Django模型介绍在Django中，模型是对数据库表的一种高级形象。通过定义一个模型，你能够明确地指定数据库的构造，包含数据表的名称、字段的名称和类型，以及可能的索引等。 让咱们看一个简略的例子，定义一个名为“Blog”的模型： from django.db import modelsclass Blog(models.Model): title = models.CharField(max_length=200) content = models.TextField() pub_date = models.DateTimeField(auto_now_add=True)在这个例子中，咱们定义了一个名为Blog的模型，它有三个字段：title、content和pub_date。每个字段都对应一种数据库的列类型：CharField对应字符类型，TextField对应文本类型，DateTimeField对应日期工夫类型。 Django模型Model深刻了解定义模型在Django中，模型是数据拜访层的外围组成部分，它为你的数据定义了最重要的行为。模型是一个Python类，子类于django.db.models.Model。每个模型都对应一个数据库表。 from django.db import modelsclass Blog(models.Model): title = models.CharField(max_length=200) content = models.TextField() pub_date = models.DateTimeField(auto_now_add=True)下面的例子中，咱们定义了一个名为Blog的模型，它有三个字段：title、content和pub_date。 ...

在本篇文章中，咱们将深入探讨Pandas库中两个重要的数据处理性能：解决缺失数据和数据聚合。 一、解决缺失数据在数据处理过程中，常常会遇到数据缺失的问题。Pandas为此提供了一些办法来解决缺失数据。 1. 查看缺失数据应用isnull()和notnull()函数，能够查看DataFrame对象中的每个元素是否为空。 import pandas as pdimport numpy as npdf = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f', 'h'], columns=['one', 'two', 'three'])df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])print(df['one'].isnull())2. 填充缺失数据Pandas提供了一个fillna()函数，能够应用常数值或前一个或后一个数据点来填充空值。 print(df.fillna(0)) # 应用0来填充空值print(df.fillna(method='pad')) # 应用前一个数据点来填充空值3. 删除缺失数据如果你想删除蕴含缺失值的行，能够应用dropna()函数。 print(df.dropna())二、数据聚合数据聚合是数据处理的重要步骤，Pandas提供了一个弱小的groupby性能，能够依照一个或多个列对数据进行分组，而后对每个分组利用一个函数。 import pandas as pddf = pd.DataFrame({ 'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'], 'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'], 'C': np.random.randn(8), 'D': np.random.randn(8)})# 分组并对每个分组进行求和print(df.groupby('A').sum())# 按多个列进行分组造成档次索引，而后执行函数print(df.groupby(['A', 'B']).mean())Pandas的数据聚合性能十分弱小，能够应用各种函数（如mean、sum、size、count、std、var等）进行聚合操作。 ...

本文深入探讨了 Django 中的申请与响应解决，从 Django 申请和响应的基础知识、生命周期，到 HttpRequest 和 HttpResponse 对象的具体介绍。同时，探讨了 Django 的视图和申请、响应解决，以及安全性和异步解决的思考。最初，比照了 Django 与 Flask、FastAPI 等框架在申请响应解决上的异同。无论您是 Django 老手还是有教训的开发者，这篇文章都能帮忙您更好地了解 Django 的申请和响应解决。 1. Django 申请HttpRequest和响应HttpResponse的基础知识在Web应用程序中，申请和响应模式是十分重要的概念。当用户在浏览器地址栏输出一个URL或者点击某个链接时，会向服务器发送一个申请。服务器解决完这个申请后，会返回一个响应给浏览器。这就是典型的HTTP申请-响应模式。 1.1 Django 的申请对象HttpRequest在 Django 中，当一个 HTTP 申请达到 Django 利用时，它首先会被某个URLconf文件转化为一个 HttpRequest 对象。这个对象蕴含了这次HTTP申请的所有相干的信息。 def view(request): # request 是一个 HttpRequest 对象 print(request.method) # 输入申请办法，比方 "GET" 或 "POST"1.2 Django 的响应对象HttpResponseDjango的视图必须返回一个 HttpResponse 对象。这个对象示意服务器给客户端（通常是浏览器）的响应。这个 HttpResponse 对象会被转化为一个 HTTP 响应，而后被发送到客户端。 from django.http import HttpResponsedef view(request): # 创立一个 HttpResponse 对象 response = HttpResponse("Hello, World!") return response # 这个响应将会被发送给客户端1.3 HTTP 办法Get/PostHTTP 办法是客户端能够对服务器收回的一种 "指令"。最常见的办法包含 GET 和 POST。 ...

你好，我是猫哥。这里每周分享优质的 Python 及通用技术内容，大部分为英文，已在小标题注明。（题目取自其中一则分享，不代表全部内容都是该主题，特此申明。） 首发于我的博客：https://pythoncat.top/posts/2023-07-08-weekly 周刊已开明 Telegram 频道，欢送关注：https://t.me/pythontrendingweekly 文章&教程1、聊一聊 Python 和 Golang 的垃圾回收 常见的垃圾回收算法有哪些，它们的优缺点是什么？Python 的垃圾回收机制由什么组成，如何解决内存透露问题？Golang 的垃圾回收机制又是怎么的，如何解决内存透露问题？ 2、像比赛程序员一样调试 (英) 编程比赛须要在限定工夫内解决一系列难题，这篇文章介绍了在编程比赛中作主动调试的办法。它的办法除了能够晋升问题，对于事实的软件开发也有所启发。 3、Python 3.12 预览版：反对 Linux 性能分析器 (英) Python 3.12 最终版将在往年 10 月公布，其中最大的变动之一是反对 Linux perf 分析器。这篇文章介绍了什么是 Linux perf 分析器、perf 能给 Python 带来什么益处、如何在 Python 3.12 中应用 perf、如何剖析性能数据、性能数据可视化…… 4、CPython 招聘一名全职工程师 (英) Łukasz Langa 是 PSF 的首个全职开发者（由 Meta 资助），近日发文示意要新招聘一名“正手”工程师（由彭博社资助）！两周前，PSF 官网刚颁布了首个全职的平安开发工程师 （由 OpenSSF 资助），当初又有了新的资助，真的要感激慷慨的赞助者们！ 5、PEP 563 和 PEP 649 (英) PEP-563 注解的提早求值，PEP-649 应用描述符作注解的提早求值。这篇 2021 年的文章出自 PEP-563 的作者 Łukasz Langa，介绍和比照了这两个 PEP。它们都是 Accepted 状态，然而原打算在 3.10 公布的 PEP-563 已被宣告无限期搁置 ，所以它仿佛须要更多的关注？（@Plutonium 投稿） ...

本文首先介绍了Django模板零碎的基础知识，接着探讨了如何装置和配置Django模板零碎，而后深刻解析了Django模板的根本构造、标签和过滤器的用法，论述了如何在模板中展现模型数据，最初应用一个理论我的项目的例子来演示如何在理论开发中应用Django模板零碎。 Django模板零碎的简介Django模板零碎是一个弱小的组件，它容许咱们依据所提供的数据动静生成HTML、XML等结构化文本。模板零碎不仅易于应用，且功能丰富。它包含一个内置的语言：Django模板语言 (DTL)，这是一种简略、非侵入式的语言，用于定义模板的构造和逻辑。 例如，在一个Django模板中，咱们能够应用变量和标签来动静地生成内容： # Django模板示例{{ book.title }} <!-- 输入: Python编程根底 -->{% if user.is_authenticated %} <!-- 如果用户已登录 --> Hello, {{ user.username }}! <!-- 输入: Hello, John! -->{% endif %}以上代码中，花括号{{ }}用于输入变量的值，标签{% %}用于执行逻辑操作。 模板的根本构造Django模板是由一系列非凡的语法形成的文本文件，用于动静生成HTML、XML或其余标记语言。上面咱们来具体理解一下Django模板的根本构造。 模板语法Django模板次要应用两种语法： 变量：用双大括号（{{ }}）包裹。比方{{ variable }}，Django将会将其替换为变量的值。标签：用大括号和百分号（{% %}）包裹。标签提供了模板的控制结构，比方循环、条件语句等。比方{% for item in list %}...{% endfor %}。模板继承Django模板零碎反对模板继承。这是一种DRY（Don't Repeat Yourself）的设计准则。你能够定义一个根底模板（base template），而后让其余模板继承这个根底模板并笼罩其中的某些局部。 例如，定义一个根底模板base.html： <!-- base.html --><html><body>{% block content %}{% endblock %}</body></html>而后，定义一个子模板child.html，继承base.html并笼罩content块： <!-- child.html -->{% extends "base.html" %}{% block content %}<p>Hello, Django!</p>{% endblock %}其余模板除了继承，Django模板还反对蕴含（include）其余模板，这能够帮忙你将模板合成为小的、可重用的局部。 ...

装璜器是Python中一种弱小而灵便的编程技巧，它能够用于批改或扩大函数的行为，同时又不须要批改函数的源代码。本文将介绍Python中的装璜器的基本概念、应用办法以及高级技巧，帮忙你从入门到精通装璜器的应用。 一、基本概念在深刻学习装璜器之前，咱们首先须要理解一些基本概念。 1.1 函数即对象在Python中，函数也是一种对象。咱们能够将函数赋值给变量，将函数作为参数传递给其余函数，以及在函数中定义函数等。 1.2 闭包闭包是一种非凡的函数，它能够援用并拜访定义在其内部作用域中的变量。在Python中，当一个函数返回了一个外部函数时，该外部函数能够应用内部函数中的变量，并保留对外部函数作用域的拜访权限。 1.3 装璜器装璜器是一种非凡的函数，它承受一个函数作为输出，并返回一个新的函数作为输入。装璜器的作用是在不批改被装璜函数源代码的状况下，批改或扩大被装璜函数的行为。 二、应用装璜器应用装璜器能够给函数增加额定的性能，例如日志记录、性能计时、输出验证等。上面是一个简略的装璜器示例： def logger(func): def wrapper(*args, **kwargs): print("日志记录：函数", func.__name__, "被调用") return func(*args, **kwargs) return wrapper@loggerdef add(x, y): return x + yresult = add(2, 3)print("后果:", result)在这个示例中，咱们定义了一个名为logger的装璜器函数。装璜器承受一个函数作为参数，并返回一个新的函数wrapper。在wrapper函数外部，咱们能够增加额定的代码，例如打印日志信息。最初，咱们应用@logger语法将装璜器利用到函数add上。当调用被装璜的函数add时，实际上是调用了装璜器返回的函数wrapper。在wrapper函数中，咱们首先打印日志信息，而后再调用原始函数add。最终，咱们能够失去函数执行的后果并输入。通过应用装璜器，咱们能够轻松地为函数增加通用的性能，而无需批改函数自身的源代码。 三、高级技巧除了根本的装璜器用法外，还有一些高级技巧能够进一步扩大装璜器的性能。 3.1 带参数的装璜器装璜器函数也能够承受参数，这样能够依据不同的参数为被装璜函数提供不同的性能。上面是一个带参数的装璜器示例： def repeat(n): def decorator(func): def wrapper(*args, **kwargs): for _ in range(n): result = func(*args, **kwargs) return result return wrapper return decorator@repeat(3)def greet(name): print("Hello,", name)greet("Alice")在这个示例中，咱们定义了一个带参数的装璜器repeat。装璜器承受一个参数n，示意反复调用被装璜函数的次数。在装璜器外部，咱们定义了一个新的函数decorator，它承受被装璜的函数func作为参数，并返回一个新的函数wrapper。在wrapper函数外部，咱们应用for循环屡次调用原始函数func。通过应用带参数的装璜器，咱们能够依据须要为不同的函数提供不同的反复调用次数。 3.2 类装璜器除了函数装璜器外，Python还反对应用类作为装璜器。类装璜器能够提供更多的灵活性和性能扩展性。上面是一个简略的类装璜器示例： class Logger: def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): print("日志记录：函数", self.func.__name__, "被调用") return self.func(*args, **kwargs)@Loggerdef multiply(x, y): return x * yresult = multiply(2, 3)print("后果:", result)在这个示例中，咱们定义了一个名为Logger的类装璜器。类装璜器必须实现__init__和__call__两个非凡办法。在__init__办法中，咱们承受被装璜的函数func作为参数并保留到实例变量中。在__call__办法中，咱们实现了装璜器的性能，打印日志信息并调用原始函数。通过应用类装璜器，咱们能够更灵便地管制装璜器的行为，并且能够在装璜器中保留状态和状态信息。 ...

在本篇文章中，咱们将探讨Python中的NumPy库的一些高级个性和技巧，包含播送机制、矢量化操作、高级索引、结构化数组以及NumPy中的随机抽样等内容。这些性能将有助于咱们进行更加简单和高效的科学计算。 一、播送机制播送是NumPy中对不同形态数组进行算术运算的形式。依据某些规定，NumPy能够主动地在没有对等形态的数组之间进行计算。 例如，如果咱们想要将一个数字增加到数组的每个元素中，咱们能够应用播送机制： import numpy as nparr = np.array([1, 2, 3])result = arr + 5print(result) # 输入：[6 7 8]同样的，如果两个数组在某个维度上长度统一，或其中一个数组在该维度长度为1，那么它们也能够进行播送： import numpy as nparr1 = np.array([[1, 2, 3], [4, 5, 6]])arr2 = np.array([1, 2, 3])result = arr1 + arr2print(result) # 输入：[[2 4 6] [5 7 9]]二、矢量化操作在NumPy中，能够应用矢量化操作对数组进行操作，而不须要应用循环。这样能够使代码更加简洁，运行效率也更高。 import numpy as nparr = np.array([1, 2, 3, 4, 5])result = arr * arrprint(result) # 输入：[ 1 4 9 16 25]这里，咱们间接对数组进行乘法运算，实际上进行的是每个元素的平方，这就是矢量化操作。 三、高级索引在NumPy中，除了能够应用惯例的切片操作来索引数组，还能够应用布尔索引和整数数组索引。 例如，咱们能够通过布尔索引来抉择数组中满足条件的元素： import numpy as nparr = np.array([1, 2, 3, 4, 5])mask = arr > 3result = arr[mask]print(result) # 输入：[4 5]咱们也能够应用整数数组来索引： ...

应用 nameko 的时候，设置 max_workers 能够实现不同并发的生产 我本人用 eventlet+kombu 写了一个消费者，却不能实现并发生产，只能一个一个排队生产 代码如下： import randomimport eventleteventlet.monkey_patch() # noqa (code before rest of imports)from kombu.mixins import ConsumerMixinfrom kombu.messaging import Consumerfrom kombu import Connection, Exchange, Queuefrom loguru import loggerimport timeclass MyConsumer(ConsumerMixin): def __init__(self, connection): self.connection = connection def get_consumers(self, Consumer, channel): print('创立消费者 start') queue_name = 'evt-ye.events-take--dna_create_service.auth' exchange_name = 'ye.events' routing_key = 'take' exchange = Exchange(exchange_name, type='topic') queue = Queue( queue_name, exchange=exchange, routing_key=routing_key, queue_arguments={'x-max-priority': 10} ) # 创立一个消费者，并设置预取音讯数量为10 consumer = Consumer( queues=[queue], callbacks=[self.on_message], prefetch_count=10 ) print('创立消费者 down') return [consumer] def on_message(self, body, message): logger.debug(f"Received message: {body}") logger.debug(f'开始生产') time.sleep(3) logger.debug(f'完结生产') message.ack() # 发送ACK确认音讯接管with Connection('amqp://pon:pon@192.168.38.191:5672//') as conn: consumer = MyConsumer(conn) consumer.run()就很烦，怎么办，我就去翻了半天 nameko 的源码代码，发现问题在这里： ...

本文首发自集体博客，获取更多对于LLM利用开发实际记录OpenAI 在gpt-3.5-turbo-0613 和 gpt-4-0613两个模型的chat completion api中减少了一个叫 Function Calling 的新性能，本篇文章对其性能进行探索，并剖析其作用。 Function Calling应用我认为这是一种比Plugin更优雅的形式，给开发者提供了更多的自由度，一方面辨认出何时须要调用函数来对输入格式化，一方面设定具体的格式化数据有助于接入后续业务逻辑。达到尽可能保障（留神这里，是依据你的函数形容最大可能保障，不能100%）LLM输入可控的根底上，来加强本人业务的目标。 show me code上面以记账利用为例，通知AI：“明天喝奶茶花了6元”，失常思路来说，交互流程应该是这样的： 用户输出promptAI进行语义剖析返回结构化的数据（每个子项是什么，破费是多少）拿到数据进行下一步操作借助Function Calling，微调后的模型能够检测何时应该调用函数并应用合乎函数签名的 JSON 进行响应，上面看代码例子 import openaiimport jsonfrom enum import Enumclass BaseTool(Enum): Bookkeeping = "record_price" RecordingTask = "record_task" def record_price(category, price): print(category, price) # 记账利用 API print("记账胜利!")def funtion_call_conversation(): response = openai.ChatCompletion.create( model="gpt-3.5-turbo-0613", messages=[ {"role": "user", "content": "明天喝奶茶花了6元"}, ], temperature=0, functions=[ { "name": BaseTool.Bookkeeping.value, "description": "bookkeeping assistant", "parameters": { "type": "object", "properties": { "category": { "type": "string", "description": "类目", }, "price": {"type": "string", "description": "金额"}, }, "required": ["category", "price"], }, } ], function_call="auto", ) message = response["choices"][0]["message"] if(message.get("function_call")): function_name = message["function_call"]["name"] if function_name == BaseTool.Bookkeeping.value: arguments = json.loads(message["function_call"]["arguments"]) record_price(arguments.get('category'), arguments.get('price'))接口调用阐明name字段示意要调用的函数名，description示意函数形容，paramters是一个合乎JSON Schema格局的对象，用来形容这个函数的入参信息（让 LLM 读得懂的工具函数阐明）record_price是用来给Function Calling调用的函数，这个函数接管两个必填的参数，category类目（string类型），price金额（string类型） ...

在Python Web开发畛域，Django框架的位置犹如璀璨的明星，其全面、高效和平安的个性使其在寰球范畴内广受欢迎。本文将全面解析Django框架的默认文件，并深入探讨每个文件及其组成的意义和用处，透彻展现这个弱小框架的文件构造和设计原理。 首先，让咱们看一下创立一个新的Django我的项目后的目录构造： myproject/ manage.py myproject/ __init__.py settings.py urls.py asgi.py wsgi.pymanage.py：这是Django我的项目的命令行工具，能够用于执行许多与项目管理和开发相干的工作，如运行服务器、运行测试、创立数据库模式等。myproject/__init__.py：这是一个空文件，用于通知Python解释器该目录是一个Python包。myproject/settings.py：这个文件蕴含所有的我的项目配置。每个Django我的项目都有其本人的设置，你能够在这里配置数据库、利用、中间件、模板、缓存等。myproject/urls.py：这个文件定义了我的项目的URL路由。通过编写URL模式和对应的视图函数，Django能够将HTTP申请路由到适当的视图。myproject/asgi.py和myproject/wsgi.py：这两个文件是用于配置服务器的，WSGI是Python的Web服务器网关接口，ASGI是异步服务器网关接口，用于解决异步申请。manage.py在Django的我的项目构造中，manage.py扮演着十分重要的角色。它是一个命令行工具，能够让你以各种形式与Django我的项目进行交互。让咱们深刻地摸索一下这个文件以及其次要的用法。 首先，当咱们创立一个新的Django我的项目时，Django会主动创立一个manage.py文件。它位于我的项目的根目录下，其次要目标是作为一个命令行实用工具，它封装了django-admin.py的性能，还蕴含了针对该项目标一些额定的命令。 让咱们看一下一个典型的manage.py文件内容： #!/usr/bin/env python"""Django's command-line utility for administrative tasks."""import osimport sysdef main(): """Run administrative tasks.""" os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings') try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?" ) from exc execute_from_command_line(sys.argv)if __name__ == '__main__': main()咱们能够看到，在manage.py文件中，Django的设置模块被定义为环境变量DJANGO_SETTINGS_MODULE，默认值为'myproject.settings'。接着，它尝试从django.core.management中导入execute_from_command_line，这个函数是用来执行命令行治理工作的。 ...

在Python世界里，NumPy库是科学计算的外围库。NumPy（Numeric Python）提供了Python对多维数组对象的反对，并提供了大量的库，如线性代数函数、傅立叶变换以及随机数生成等科学计算性能。在这篇文章中，咱们将深刻摸索NumPy的一些中级常识。 一、NumPy数组操作1. 更改数组形态有时咱们须要更改数组的形态以便进行某些运算。NumPy提供了reshape函数来实现这个工作。 import numpy as nparr = np.array([1, 2, 3, 4, 5, 6])print(arr.reshape(2, 3))2. 数组的重叠在某些状况下，咱们须要将两个数组重叠在一起。NumPy提供了vstack和hstack函数，用于垂直和程度方向上的重叠。 import numpy as nparr1 = np.array([1, 2, 3])arr2 = np.array([4, 5, 6])print(np.vstack((arr1, arr2))) # 垂直重叠print(np.hstack((arr1, arr2))) # 程度重叠二、NumPy的播送机制播送是NumPy中弱小的性能之一。当操作两个数组时，NumPy能够就地将较小的数组播送到较大数组的大小以进行兼容的操作。 import numpy as npa = np.array([1, 2, 3])b = np.array([1, 2])a + b # 这会报错，因为形态不匹配b_new = np.broadcast_to(b, a.shape) # 将b播送到a的形态a + b_new三、NumPy的条件索引NumPy提供了条件索引的性能，即能够基于条件抉择数组中的元素。这是通过在索引操作符[]中提供条件表达式实现的。 import numpy as nparr = np.array([1, 2, 3, 4, 5, 6])print(arr[arr > 3]) # 抉择数组中大于3的元素四、NumPy随机数生成NumPy提供了各种随机数生成的性能，包含均匀分布、正态分布等。 ...

NumPy（Numeric Python）是Python的一种开源的数值计算扩大。这种工具可用于存储和解决大型矩阵，使得在Python中进行数学运算变得更为便捷高效。 一、NumPy数组和Python列表的比拟Python的列表是一种通用的数据结构，但对于大规模数值运算，列表的效率并不高。NumPy提供的是一种称为ndarray的多维数组对象，它比Python的原生列表在存储和操作数据时，更加的高效和便捷。 import numpy as np# 创立一个NumPy数组arr = np.array([1, 2, 3, 4, 5])print(arr)以上代码将打印出一个NumPy数组[1 2 3 4 5]。咱们能够看到，NumPy数组和Python列表在表现形式上并无太大区别，然而在进行大规模数据运算时，二者的差别就显现出来。 二、NumPy的矢量化运算NumPy最重要的个性之一就是其矢量化运算的能力。所谓矢量化，就是指对数组的每个元素利用函数，而无需编写显式的循环。这使得程序在进行数值计算时，更加简洁且运行更快。 import numpy as np# 创立一个NumPy数组arr = np.array([1, 2, 3, 4, 5])# 将数组中每个元素加1arr = arr + 1print(arr) # 输入: [2 3 4 5 6]在这个例子中，咱们间接将一个标量值1加到了数组arr的每一个元素上，这在Python原生列表中是无奈做到的。如果你尝试将一个数字和一个列表相加，Python会抛出一个类型谬误。然而在NumPy中，这种矢量化的运算能够让咱们更不便地进行数学运算。 三、NumPy的播送机制NumPy的另一个弱小个性是播送（Broadcasting）。播送是NumPy解决不同大小数组间二元运算的能力。 例如，咱们有一个值和一个数组，咱们想将这个值加到数组的每一个元素上。NumPy的播送机制能够让咱们做到这一点，而无需显式地复制这个值。 import numpy as np# 创立一个NumPy数组arr = np.array([1, 2, 3, 4, 5])# 创立一个标量值value = 1# 应用播送将标量值加到数组的每一个元素上result = arr + valueprint(result) # 输入: [2 3 4 5 6]这个例子和上个例子类似，咱们也是将一个值加到数组的每个元素上。然而这里咱们更明确地展现了NumPy的播送机制。这种机制也能够利用于更简单的状况，比方两个数组之间的运算。 ...

# 输入语句# print("hello word")counter = 100 # 整型变量miles = 1000.0 # 浮点型变量name = "runoob" # 字符串# print (counter)# print (miles)# print (name)'''python最具特色的就是应用缩进来示意代码块，不须要应用大括号 {}'''# if True:# print ("True")# else:# print ("False")# 数组total = ['item_one', 'item_two', 'item_three', 'item_four', 'item_five']# print(total)# 字符串word = '字符串'sentence = "这是一个句子。"paragraph = """这是一个段落，能够由多行组成"""'''字符串拼接print(word+sentence+paragraph)字符串换行拼接print(word+'\n'+sentence+'\n'+paragraph)输入 \n 并且不换行print(word+'\n'+sentence+r'\n'+paragraph)'''# input("\n\n按下 enter 键后退出。")# 同一行显示多条语句import sys; x = 'runoob'; sys.stdout.write(x + '\n')

爬虫，这个常常被人提到的词，是对数据收集过程的一种形象化形容。特地是在Python语言中，因为其丰盛的库资源和良好的易用性，使得其成为编写爬虫的绝佳抉择。本文将从基础知识开始，深入浅出地解说Python爬虫的相干常识，并分享一些独特的用法和实用技巧。本文将以理论的网站为例，深刻论述各个解决局部，并展现输入，助力大家疾速把握Python爬虫技巧。 开始之前：必要的库Python有很多库能够用来编写爬虫，但咱们这里重点介绍两个：requests和BeautifulSoup。 import requestsfrom bs4 import BeautifulSouprequests库用于发送HTTP申请，而BeautifulSoup库则用于解析HTTP响应中的HTML。 根本爬虫：爬取全副网页内容以Python官方网站（https://www.python.org/）为例，一个根本的Python爬虫可能会这样编写： url = "https://www.python.org/"response = requests.get(url)soup = BeautifulSoup(response.text, 'html.parser')print(soup.prettify()[:500])这段代码的目标是获取网页的内容，并应用BeautifulSoup库进行解析。咱们能够看到，requests.get(url)是用来发送GET申请的，而BeautifulSoup(response.text, 'html.parser')则是用来解析HTTP响应中的HTML内容的。 这段代码的输入前500个字符如下： <!DOCTYPE html><!--[if lt IE 7]> <html class="no-js ie6 lt-ie7 lt-ie8 lt-ie9"> <![endif]--><!--[if IE 7]> <html class="no-js ie7 lt-ie8 lt-ie9"> <![endif]--><!--[if IE 8]> <html class="no-js ie8 lt-ie9"> <![endif]--><!--[if gt IE 8]><!--><html class="no-js" dir="ltr" lang="en"> <!--<![endif]--><head><meta charset="utf-8"/><meta content="IE=edge" http-equiv="X-UA-Compatible"/><meta content="Python.org" name="application-name"/><meta content="The official home of the Python Programming Language" 应用CSS选择器爬取特定元素当咱们心愿获取特定元素时，咱们能够应用CSS选择器。比方咱们心愿获取Python官方网站中所有的头部链接： elements = soup.select('div.top-bar > ul > li > a')for element in elements: print(element.get('href'), element.text)在这里，div.top-bar > ul > li > a是一个CSS选择器，用来抉择 ...

fastapi 如何在中间件中抛出异样？ chatGPT 给我的计划是：raise HTTPException(status_code=401, detail="Invalid token") 然而理论没用，客户端收到的还是 500 理论应该 return 一个 response 参考代码： @app.middleware("http")async def get_user_id(request: Request, call_next): from core.mysql.models import SessionTable from core.mysql.models import SessionTable from core.mysql.models import UserTable from apps.user.schemas import User from playhouse.shortcuts import model_to_dict session_key = request.cookies.get("session_key") if session_key: try: session: SessionTable | None = SessionTable.get_or_none( session_key=session_key) if session: user_id = session.user_id if user_id: request.state.user_id = user_id user: UserTable | None = UserTable.get_or_none(id=user_id) request.state.user = User(**model_to_dict(user)) except Exception as error: logger.warning(error) if not session_key or not request.state.get('user_id', None): return Response(status_code=401, content='Invalid token') response = call_next(request) return response

一、介绍文本情感剖析零碎，应用Python作为开发语言，基于文本数据集，应用Word2vec对文本进行解决。通过反对向量机SVM算法训练情绪分类模型。实现对文本消极情感和文本踊跃情感的辨认。并基于Django框架开发网页平台实现对用户的可视化操作和数据存储。 二、成果展现 三、演示视频视频+代码：https://www.yuque.com/ziwu/yygu3z/yn2icplnbkwafd10 四、Word2vec介绍当今社会，文本处理在自然语言解决畛域中占据着重要位置。Word2Vec是一种罕用的文本处理办法，它可能将文本数据转化为向量示意，从而实现文本的语义剖析和比拟。本文将介绍如何应用Python中的gensim库来实现Word2Vec算法，并附有相应的代码示例。首先，咱们须要确保曾经装置了所需的Python库。Word2Vec库通常是通过gensim库来实现的，因而咱们须要应用以下命令来装置它们： pip install gensimpip install numpypip install nltk接下来，咱们须要导入所需的库和模块： import nltkfrom gensim.models import Word2Vecfrom nltk.corpus import stopwordsfrom nltk.tokenize import sent_tokenize, word_tokenize咱们将应用一个示例文本进行演示，能够是任何英文文本。在这里，咱们应用《白鲸记》作为示例。首先，咱们须要加载文本数据： # 加载文本数据nltk.download('gutenberg')from nltk.corpus import gutenbergraw_data = gutenberg.raw('melville-moby_dick.txt')接下来，咱们须要将文本数据进行预处理。预处理的次要目标是去除文本中的噪声和冗余信息，使得Word2Vec可能更好地进行向量化解决。在这里，咱们将应用NLTK库来实现预处理的工作。NLTK库是Python中罕用的自然语言解决库，其中蕴含了许多有用的函数和工具。咱们首先将文本进行分句和分词解决。分句将文本拆分成句子，而分词则将句子拆分成单词。咱们能够应用NLTK库中的sent_tokenize和word_tokenize函数来实现这些操作。示例代码如下： # 分句sentences = sent_tokenize(raw_data)# 分词tokenized_sentences = [word_tokenize(sentence.lower()) for sentence in sentences]在分词之后，咱们还能够进行一些其余的预处理步骤，比方去除停用词、标点符号和数字。停用词是那些在文本中频繁呈现但通常没有实际意义的词语，比方"the"、"and"等。咱们能够应用NLTK库中提供的停用词列表进行去除。示例代码如下： # 去除停用词、标点符号和数字stop_words = set(stopwords.words('english'))filtered_sentences = []for sentence in tokenized_sentences: filtered_sentence = [word for word in sentence if word.isalpha() and word not in stop_words] filtered_sentences.append(filtered_sentence)在预处理实现之后，咱们能够应用Word2Vec库来训练咱们的词向量模型了。Word2Vec库提供了两种训练模式：间断词训练（CBOW）和跳字模型（Skip-gram）。在这里，咱们将应用Skip-gram模型进行训练。示例代码如下： # 训练Word2Vec模型model = Word2Vec(filtered_sentences, size=100, window=5, min_count=1, sg=1)# 查找与给定词最类似的词similar_words = model.wv.most_similar('whale')print(similar_words)在下面的代码中，咱们首先创立了一个Word2Vec模型对象，传入通过预处理的句子列表filtered_sentences作为训练数据。参数size示意生成的词向量的维度，window示意窗口大小，min_count示意最小词频阈值，sg示意训练模式抉择了Skip-gram模型。接着，咱们能够应用训练好的Word2Vec模型来查找与给定词最类似的词。在示例代码中，咱们查找与词'whale'最类似的词，并打印出后果。除了查找类似词之外，Word2Vec还能够用于计算词语之间的类似度。咱们能够应用similarity办法来计算两个词之间的余弦类似度。示例代码如下： ...

一、介绍电商购物零碎Python，基于Flask框架实现。实现用户查看商品、购买商品、增加购物车、商城订单、编辑个人信息、点击喜爱不喜爱等、商品评论、登录注册、查看物流信息等性能。实现商家公布商品、查看销售列表、治理商品、物流信息更新、个人信息批改等性能。 二、成果展现 三、演示视频视频+代码：https://www.yuque.com/ziwu/yygu3z/snkqwdm1wwbyfrfs 四、Flask介绍Flask是一个轻量级的Python Web框架，具备以下特点： 简洁而灵便：Flask的设计理念是放弃简略和可扩展性。它提供了根本的性能和组件，但没有过多的限度和束缚，让开发者可能依据本人的需要进行灵便的定制和扩大。易于学习和应用：Flask的API简略易懂，文档清晰明了，使得初学者可能疾速上手。它没有繁琐的配置，开发者能够依据须要抉择应用的插件和工具，缩小了学习和应用的难度。路由和视图解决：Flask应用装璜器机制来定义路由和视图函数，使得编写和治理路由变得简单明了。开发者能够通过装璜器将URL门路与对应的函数关联起来，从而解决不同的申请并返回相应的响应。模板引擎反对：Flask集成了Jinja2模板引擎，它能够将动态数据与动态模板文件进行联合，生成最终的HTML页面。模板引擎反对模板继承、条件判断、循环迭代等性能，使得开发者可能更好地组织和治理页面的展现逻辑。轻量级而高效：因为Flask的设计简略，它的运行开销绝对较小，能够在资源无限的环境下高效运行。它不依赖于大型的内部库或框架，因而能够更好地管制和优化应用程序的性能。RESTful反对：Flask对于构建RESTful格调的API提供了良好的反对。通过联合Flask的路由和视图解决机制，开发者能够轻松地创立和治理API端点，实现资源的增删改查操作。扩展性和生态系统：Flask提供了丰盛的扩大库和插件，能够不便地集成第三方性能和服务。例如，Flask-SQLAlchemy用于数据库操作，Flask-WTF用于表单验证，Flask-Login用于用户认证等。这些扩大库遵循Flask的设计理念，提供简洁的API和良好的文档。社区反对和活跃度：Flask领有宏大而沉闷的开发者社区，提供了大量的文档、教程和示例代码。开发者能够从社区中获取反对和解决问题，也能够奉献本人的扩大和插件，促成了Flask框架的倒退和演进。上面是一个应用Flask框架实现商城零碎的简略例子： from flask import Flask, render_template, request, redirectapp = Flask(__name__)# 商品列表products = [ {"id": 1, "name": "商品1", "price": 10}, {"id": 2, "name": "商品2", "price": 20}, {"id": 3, "name": "商品3", "price": 30}]# 购物车cart = []@app.route("/")def index(): return render_template("index.html", products=products, cart=cart)@app.route("/add_to_cart", methods=["POST"])def add_to_cart(): product_id = int(request.form.get("product_id")) product = next((p for p in products if p["id"] == product_id), None) if product: cart.append(product) return redirect("/")@app.route("/checkout")def checkout(): total_price = sum(product["price"] for product in cart) return render_template("checkout.html", cart=cart, total_price=total_price)@app.route("/clear_cart")def clear_cart(): cart.clear() return redirect("/")if __name__ == "__main__": app.run()在上述代码中，咱们首先导入了Flask类和其余必要的模块。而后，咱们创立了一个Flask应用程序实例，并定义了两个全局变量products和cart，别离代表商品列表和购物车。接下来，咱们定义了四个路由处理函数。index()函数解决首页的申请，应用render_template()函数渲染了一个名为index.html的模板，并将商品列表和购物车传递给模板进行展现。add_to_cart()函数解决增加商品到购物车的申请，从申请中获取商品的ID，并应用列表推导式在商品列表中查找对应的商品。如果找到了对应的商品，就将其增加到购物车，并重定向到首页。checkout()函数解决结算页面的申请，计算购物车中商品的总价格，并将购物车和总价格传递给checkout.html模板进行展现。clear_cart()函数解决清空购物车的申请，通过调用clear()办法清空购物车，并重定向到首页。最初，通过查看__name__是否为__main__，咱们确保脚本作为主程序运行时才启动Flask应用程序。须要留神的是，上述代码中的路由处理函数应用了@app.route装璜器，这样能够不便地将URL门路与对应的函数关联起来。render_template()函数用于渲染模板文件，request对象用于拜访申请数据，redirect()函数用于重定向到其余URL。 ...

疾速排序（Quick Sort）是一种高效的排序算法，它的根本思维是通过分治的策略将一个大问题分解成小问题并解决。疾速排序的外围操作是选取一个基准元素，将待排序序列划分成左右两局部，其中左局部的元素都小于基准元素，右局部的元素都大于基准元素。而后递归地对左右两局部进行排序，最终实现整个序列的排序。本文将具体介绍疾速排序算法的原理和实现，并提供相干的Python代码示例。 一、算法原理疾速排序算法的步骤如下： 抉择一个基准元素（通常抉择第一个或最初一个元素）。将序列划分成两局部，使得左局部的元素都小于基准元素，右局部的元素都大于基准元素。这个过程称为分区（Partition）。对左右两局部递归地利用步骤1和步骤2，直到每个局部只剩下一个元素或为空。疾速排序的核心思想是通过一直地划分和排序子序列，最终实现整个序列的排序。 二、疾速排序的实现上面是应用Python实现疾速排序算法的代码： def quick_sort(arr): if len(arr) <= 1: return arr else: pivot = arr[0] # 抉择第一个元素作为基准元素 less = [x for x in arr[1:] if x <= pivot] # 小于等于基准元素的子序列 greater = [x for x in arr[1:] if x > pivot] # 大于基准元素的子序列 return quick_sort(less) + [pivot] + quick_sort(greater)# 测试代码numbers = [4, 2, 6, 1, 3]sorted_numbers = quick_sort(numbers)print(sorted_numbers) # 输入：[1, 2, 3, 4, 6]在上述代码中，quick_sort()函数承受一个待排序的列表作为输出，并对列表进行疾速排序。算法应用递归形式实现。首先抉择列表的第一个元素作为基准元素（也能够抉择最初一个元素），而后通过列表解析的形式将列表划分成两局部：小于等于基准元素的子序列和大于基准元素的子序列。最初，将子序列和基准元素合并起来，失去最终的排序后果。 三、算法剖析疾速排序是一种旧址排序算法，即在排序过程中间接批改原始列表，不须要额定的存储空间。疾速排序的均匀工夫复杂度为O(nlogn)，其中n是待排序序列的长度。在大多数状况下，疾速排序是一种高效的排序算法。然而，在最坏状况下，即待排序序列曾经有序或根本有序时，疾速排序的工夫复杂度为O(n^2)，性能降落。为了防止最坏状况的产生，能够采纳一些优化办法，如随机抉择基准元素、三数取中法抉择基准元素、应用插入排序优化小规模数据等。 四、优化思路优化1：随机抉择基准元素为了防止最坏状况的产生，能够随机抉择基准元素。在每次分区时，随机抉择一个元素作为基准元素，而不是固定抉择第一个或最初一个元素。这样能够升高最坏状况产生的概率，进步算法的性能。 import randomdef quick_sort(arr): if len(arr) <= 1: return arr else: pivot_index = random.randint(0, len(arr) - 1) # 随机抉择一个索引作为基准元素的索引 pivot = arr[pivot_index] arr[0], arr[pivot_index] = arr[pivot_index], arr[0] # 将基准元素替换到第一个地位 less = [x for x in arr[1:] if x <= pivot] greater = [x for x in arr[1:] if x > pivot] return quick_sort(less) + [pivot] + quick_sort(greater)优化2：三数取中法抉择基准元素另一种优化办法是应用三数取中法抉择基准元素。这种办法通过从待排序序列的首、尾和两头抉择三个元素，并将它们排序后的两头元素作为基准元素，来升高最坏状况的概率。 ...

HDC期间可参加华为云新人注册抽奖流动，流动链接在文末，无线鼠标，定制帆布包等 源代码是企业最贵重的资产之一，一旦保留源代码的零碎呈现安全性或稳定性问题，将给企业商业及信用带来不可估量的损失。随着软件规模的不断扩大，生成软件的源代码规模也在急剧回升，单个软件系统规模已达数亿行、开发人员达数千人——如何治理好宏大的源代码，并让企业员工继续稳固的发展软件开发流动将成为一个重大的挑战。 华为云代码托管服务CodeArts Repo是一款全栈自研、基于Git的云端代码托管服务，旨在爱护企业外围代码资产平安，晋升企业研发品质和效率。 点击>>进入产品官网 代码管理工具是软件开发的根底 一直晋升研发品质和效率，缩短TTM（Time to Market）是软件企业商业胜利的要害。现在，一款软件通常由多人合作开发而成，代码管理工具不仅是研发资产的重要载体，同时也撑持了版本化配置管理、代码开发的工作流等流动，通过与CI/CD工具服务集成，可能无效晋升团队合作效率和自动化交付效率。 编辑 代码管理工具在开发流动中施展着关键作用 为了让代码资产更加平安和稳固，一款现代化代码管理工具该当具备如下次要能力： 版本控制： 蕴含代码存储性能，反对代码上传和下载，并可能简略、精确地记录和重现代码的任何一个历史版本。 协同开发：反对多人协同开发，如不同开发人员可同时在同一个软件模块上工作，同时对同一代码局部做不同的批改，即便是跨地区散布的开发团队也能互不烦扰。 品质管控： 提供在线浏览代码和代码检视性能，反对自动化继续集成与继续交付工具（CI/CD），对代码进行质量检查，确保合乎品质的代码能力入库。 稳固牢靠： 反对多人并发在线作业，并发上传和下载代码，放弃长期稳固，以保障企业研发流动不中断。 平安防护： 可能爱护企业的代码外围资产平安，抵挡黑客盗取代码、对源代码投毒、恶意代码注入等攻打。 CodeArts Repo6 大特色保障代码外围资产平安 为了撑持业务的高速倒退，华为公司外部代码管理工具也在一直演进。从最开始满足根本配置管理需要，到撑持公司内源协同开发，再到撑持公司可信改革、达成CleanCode指标，华为的代码管理工具经验了“商用+开源”，到“边买边造”，再到“自力更生”的三个阶段。 现在，华为云CodeArts Repo治理并爱护着华为1100亿行代码，撑持15万人开发作业，日均1亿次下载量、1PB传输流量、3亿次API调用，一套零碎撑持了华为嵌入式、云、终端、车等各类型产品代码治理和协同开发。 CodeArts Repo具备以下 6大个性。 个性一：自研内核，确保代码平安，稳固高效开发。 针对开源代码管理工具破绽多、单体架构、存在连续性危险，和无奈满足华为大规模、多场景开发作业流等问题，华为云CodeArts Repo通过自研内核，基于零信赖思维进行设计和平安加固，从黑客视角建设攻打门路模型，落地6大类100+小类安全措施，从接入层、业务层，存储层到基础设施层全面构筑平安防护能力，确保代码不丢，零碎不破，代码资产可复原。 此外，华为成立了“蓝军”部门，每年例行专门针对代码托管工具进行模仿攻打测试，以攻促防，一直晋升CodeArts Repo的平安能力。 为应答公司巨量业务增长，CodeArts Repo在架构上充分利用云原生技术劣势，基于云化基础设施，实现容灾、备份、流控、服务降等，保障了业务不中断和数据不失落，多维度晋升可靠性。 编辑 个性二：笼罩基于Git的次要工作流，满足多种开发场景 华为云CodeArts Repo反对Git Flow、Gitlab Flow、Github Flow等所有工作流。华为将以前应用Gitlab、Github、Gerrit部署的100多套零碎归一到CodeArts Repo一套零碎，期间经验了超过10000条来自华为各产品线的需要锻炼，不断完善和优化，既能满足强流程标准的大规模产品协同开发，也实用于采纳DevOps模式、疾速上线的产品开发。 编辑 个性三：多模式代码检视流动，晋升代码品质，传递开发教训 华为云CodeArts Repo提供分散式和集中式的代码检视能力，反对团队随时发展代码检视流动。 以合并申请为例，开发人员发动代码合并申请后，零碎可主动调配给不同检视人员，检视人员利用碎片化工夫检视代码，配合门禁系统保障检视意见敞开能力合入该合并申请。团队成员也能够集中到一起，间接在浏览器中关上代码仓文件，进行在线检视，提出检视意见后使跟踪流程闭环检视意见。 另外，CodeArts Repo提供灵便的检视意见分类性能，既集成华为优良的实际，应用此性能能够无效标准团队检视流动，同时积淀团队教训和常识，将常识在公司、产品、我的项目等不同范畴内传递。 编辑 个性四：品质门禁，确保每一行入库代码Clean 在软件生命周期中，缺点发现越早、修复越早，缺点的影响和修复代价就越小，数据显示，产品公布后每个缺点的均匀修复老本是验证阶段的6倍以上。因而为了防止有缺点的代码合入主干，灵便无效的门禁管制必不可少。 华为云CodeArts Repo提供“人工审核+CICD自动化查看”双重看护代码品质机制。通过爱护分支性能，针对不同的角色控制代码的推送和合并权限，确保代码在推送入库的时候就合乎品质要求。 配合CI/CD自动化查看工具链，提供代码动态查看、安全检查、测试后果验证、代码检视人员角色和数量查看、检视意见闭环率等几十种细粒度门禁控制策略，用户可灵便配置以满足不同的企业标准。 编辑 个性五：记录代码前因后果，双向可追溯 软件的可追溯性是软件工程的根底属性，具备可追溯性是良好的软件工程能力的主观出现。可追溯性要求软件生产过程中从需要剖析到编码、构建、验证、公布过程中产生的需要、设计、代码、用例、缺点、公布等业务对象以及其关系的精确记录。 华为云CodeArts Repo反对建设工作项和合并申请或者代码提交commit的双向关联关系，实现软件开发过程可追溯，通过可信的开发过程，保障后果可信。 以华为外部为例，团队通过在代码托管工具设置规定，确保了每次的代码入库都有对应的工作项，通过对关联关系数据进行辨认、监控和预警，及时发现不合规的代码，进步产品质量。企业也能够在解决现网问题时依据关联关系找到对应的代码版本，疾速修复。 编辑 个性六：内置多种模板，确保开发标准有序 软件开发是一项创造性的流动，也是一项简单的多人协同流动。在软件开发过程中，企业须要抉择适宜的开发工作流，并建设标准的开发合作流程来保障产品可能继续高质量交付。 华为云CodeArts Repo凝聚了华为公司外部各类研发场景的标准，能够帮忙企业进行组织级开发规定制订和落地，促成产品质量和开发效率晋升。 ...

本文将具体探讨如何在Python中连贯全品种数据库以及实现相应的CRUD（创立，读取，更新，删除）操作。咱们将逐个解析连贯MySQL，SQL Server，Oracle，PostgreSQL，MongoDB，SQLite，DB2，Redis，Cassandra，Microsoft Access，ElasticSearch，Neo4j，InfluxDB，Snowflake，Amazon DynamoDB，Microsoft Azure CosMos DB数据库的办法，并演示相应的CRUD操作。 MySQL连贯数据库Python能够应用mysql-connector-python库连贯MySQL数据库： import mysql.connectorconn = mysql.connector.connect(user='username', password='password', host='127.0.0.1', database='my_database')print("Opened MySQL database successfully")conn.close()CRUD操作接下来，咱们将展现在MySQL中如何进行根本的CRUD操作。 创立（Create）conn = mysql.connector.connect(user='username', password='password', host='127.0.0.1', database='my_database')cursor = conn.cursor()cursor.execute("CREATE TABLE Employees (ID INT PRIMARY KEY NOT NULL, NAME TEXT NOT NULL, AGE INT, ADDRESS CHAR(50), SALARY REAL)")print("Table created successfully")conn.close()读取（Retrieve）conn = mysql.connector.connect(user='username', password='password', host='127.0.0.1', database='my_database')cursor = conn.cursor()cursor.execute("SELECT id, name, address, salary from Employees")rows = cursor.fetchall()for row in rows: print("ID = ", row[0]) print("NAME = ", row[1]) print("ADDRESS = ", row[2]) print("SALARY = ", row[3])conn.close()更新（Update）conn = mysql.connector.connect(user='username', password='password', host='127.0.0.1', database='my_database')cursor = conn.cursor()cursor.execute("UPDATE Employees set SALARY = 25000.00 where ID = 1")conn.commit()print("Total number of rows updated :", cursor.rowcount)conn.close()删除（Delete）conn = mysql.connector.connect(user='username', password='password', host='127.0.0.1', database='my_database')cursor = conn.cursor()cursor.execute("DELETE from Employees where ID = 1")conn.commit()print("Total number of rows deleted :", cursor.rowcount)conn.close()SQL Server连贯数据库Python能够应用pyodbc库连贯SQL Server数据库： ...

软件开发是把人类智慧以代码形式表达出来的过程，面对不可预知且疾速变动的世界，开发者面临着前所未有的微小挑战。例如，软件交付周期和迭代速度要求更高、开发者须要疾速学习各种新技术、开发工夫碎片化重大、扩散的交付团队协同艰难、开发与运行环境计算架构不统一将带来穿插编译危险等等。 软件的生产力往往由开发者和开发工具独特决定，开发工具对效率的影响不可漠视。“工欲善其事，必先利其器”，面对新时代的重重挑战，开发者在一直晋升本身技能的同时，也对手中的开发工具产生了新的思考和诉求。 华为云CodeArts IDE Online服务，提供了可随时随地编码的云上开发环境，同时具备凋谢的生态和独立插件市场，旨在为开发者提供环境疾速获取、性能开箱即用、逾越计算架构、随时随地拜访、横向可扩大和反对第三方集成等能力，打造数字时代的开发利器。 体验通道：https://auth.huaweicloud.com/authui/login.html?locale=zh-cn&service=https%3A%2F%2Fwww.huaweicloud.com%2Fproduct%2Fcloudide.html%3Futm_medium%3DHDC#/login 一图带你理解华为云CodeArts IDE Online的独特能力

在Python编程中，有一种弱小的技术容许咱们在运行时批改或生成代码，这就是元编程。Python的元编程工具包含装璜器，元类，以及函数和类的各种动静批改技术。这篇文章将向你介绍元编程的基本概念，并通过实例解说如何应用元编程。 一、什么是元编程元编程是对于编写能够批改或生成其余代码的代码的概念。它容许程序员创立灵便的代码，这些代码能够扭转其本身的行为，或者在运行时扭转其余代码的行为。Python提供了一套弱小的工具来实现元编程，包含装璜器、元类和动静批改代码。 二、装璜器装璜器是一种非凡类型的函数，它能够包装其余函数或类，以批改其行为。上面是一个简略的装璜器示例： def simple_decorator(function): def wrapper(): print("Before function execution") function() print("After function execution") return wrapper@simple_decoratordef hello(): print("Hello, world!")hello()当咱们运行这段代码时，咱们会看到输入的不仅仅是"Hello, world!"，还有装璜器增加的额定行为："Before function execution"和"After function execution"。 三、元类元类是创立类的类，你能够通过元类来管制类的创立。这容许你在类创立时增加或批改类的属性或办法。以下是一个简略的元类示例： class Meta(type): def __init__(cls, name, bases, attrs): attrs['say_hello'] = lambda self: f"Hello, I'm {name}" super().__init__(name, bases, attrs)class MyClass(metaclass=Meta): passobj = MyClass()print(obj.say_hello()) # 输入: Hello, I'm MyClass在这个例子中，元类 Meta 在类 MyClass 被创立时增加了一个新办法 say_hello。 四、动静批改代码Python容许在运行时动静批改函数和类。例如，你能够向现有的类中增加新的办法，或者替换类的某个办法。上面是一个例子： class MyClass: def hello(self): return "Hello, world!"def new_hello(self): return "Hello, Python!"MyClass.hello = new_helloobj = MyClass()print(obj.hello()) # 输入: Hello, Python!在这个例子中，咱们在运行时替换了 MyClass 类的 hello 办法。 ...

多线程是一种并发编程的技术，通过同时执行多个线程来进步程序的性能和效率。在Python中，咱们能够应用内置的threading模块来实现多线程编程。本文将介绍Python中的多线程应用，包含创立线程、线程同步、线程间通信以及线程池等基本概念和技巧。 一、创立线程在应用多线程之前，咱们首先须要理解如何创立线程。Python提供了threading模块，咱们能够通过继承Thread类或应用函数来创立线程。 1.1 示例代码上面是一个示例代码，展现了如何创立线程： import threading# 继承Thread类创立线程class MyThread(threading.Thread): def run(self): # 线程执行的代码 print("Hello, World!") # 应用函数创立线程def my_function(): # 线程执行的代码 print("Hello, World!") # 创立线程对象并启动线程thread1 = MyThread()thread2 = threading.Thread(target=my_function)thread1.start()thread2.start()在这个示例中，咱们应用继承Thread类和应用函数的两种形式创立了线程。对于继承Thread类的形式，咱们须要重写run()办法，将线程要执行的代码放在该办法中。对于应用函数的形式，咱们须要将线程要执行的函数作为target参数传递给Thread对象。最初，通过调用start()办法来启动线程。须要留神的是，多线程的执行程序是不确定的，线程的启动程序不肯定等于线程的执行程序。 二、线程同步在多线程编程中，线程之间可能会共享资源，因而须要进行线程同步来保障资源的正确拜访。Python提供了多种线程同步机制，例如互斥锁、信号量和事件等。 2.1 互斥锁互斥锁是一种最根本的线程同步机制，它能够确保同一时刻只有一个线程能够访问共享资源。Python中的threading模块提供了Lock类来实现互斥锁。 2.2 示例代码上面是一个示例代码，展现了如何应用互斥锁进行线程同步： import threading# 共享资源count = 0# 创立互斥锁lock = threading.Lock()def increment(): global count # 获取锁 lock.acquire() try: # 批改共享资源 count += 1 finally: # 开释锁 lock.release() # 创立多个线程并启动threads = []for _ in range(10): thread = threading.Thread(target=increment) threads.append(thread) thread.start() # 期待所有线程完结for thread in threads: thread.join() # 打印后果print("Count:", count)在这个示例中，咱们应用互斥锁来保障对共享资源count的拜访是线程平安的。在线程的increment()函数中，咱们首先应用lock.acquire()办法获取锁，而后在try-finally语句块中批改共享资源，并最初应用lock.release()办法开释锁。须要留神的是，在应用互斥锁时，肯定要确保在获取锁后，无论产生何种状况，都可能开释锁，以防止产生死锁的状况。 ...

一、介绍图书举荐零碎 / 图书管理系统，以Python作为开发语言，基于Django实现，应用协同过滤算法实现对登录用户的图书举荐。 二、成果展现 三、演示视频视频+代码：https://www.yuque.com/ziwu/yygu3z/gq555ph49m9fvrze 四、Django介绍Django是一个弱小而灵便的Python Web框架，它为开发人员提供了一种高效构建Web应用程序的形式。Django的设计理念是简单明了的，它重视代码的可读性和可维护性，同时提供了丰盛的性能和插件，帮忙开发人员疾速构建高质量的Web应用程序。本文将介绍Django的次要特点，并通过一个实例展现如何应用Django构建一个图书管理系统。Django的次要特点： 弱小的ORM（对象关系映射）：Django提供了弱小的ORM，使得与数据库的交互变得简略而高效。通过定义模型类和字段，Django会主动解决数据库的创立、查问、更新和删除操作，大大简化了与数据库的交互过程。自带的治理界面：Django自带了一个功能强大的治理界面，开发人员无需手动编写治理界面代码，就能够对数据库中的数据进行增删改查操作。这使得开发人员能够疾速创立一个性能齐备的治理后盾，节俭了大量的开发工夫和精力。灵便的URL路由：Django的URL路由零碎非常灵活，能够轻松地定义URL模式，并将它们与对应的视图函数进行绑定。这样，当用户申请某个URL时，Django会主动调用相应的视图函数来解决申请，使得开发人员能够更加不便地组织和治理URL构造。丰盛的内置性能和插件：Django提供了许多内置性能和插件，如表单解决、用户认证、缓存、国际化等，能够帮忙开发人员疾速实现常见的Web应用程序性能。此外，Django还有一个宏大的第三方插件生态系统，能够满足各种不同的需要。示例：图书管理系统上面是一个应用Django构建图书管理系统的简略示例代码，其中蕴含了图书、作者和出版社三个模型，并实现了根本的增删改查性能。代码中有具体的中文正文，帮忙了解代码的性能和实现形式。 # 导入Django的相干模块from django.db import modelsfrom django.contrib.auth.models import User# 定义图书模型class Book(models.Model): title = models.CharField('书名', max_length=100) author = models.ForeignKey('Author', on_delete=models.CASCADE, verbose_name='作者') publisher = models.ForeignKey('Publisher', on_delete=models.CASCADE, verbose_name='出版社') def __str__(self): return self.title # 定义作者模型class Author(models.Model): name = models.CharField('姓名', max_length=50) birth_date = models.DateField('出生日期') def __str__(self): return self.name # 定义出版社模型class Publisher(models.Model): name = models.CharField('名称', max_length=100) address = models.CharField('地址', max_length=200) def __str__(self): return self.name# 定义图书管理系统的视图函数from django.shortcuts import render, get_object_or_404, redirectdef book_list(request): # 获取所有图书列表 books = Book.objects.all() return render(request, 'book_list.html', {'books': books})def book_detail(request, book_id): # 获取图书详情 book = get_object_or_404(Book, pk=book_id) return render(request, 'book_detail.html', {'book': book})def book_create(request): # 创立图书 if request.method == 'POST': book_form = BookForm(request.POST) if book_form.is_valid(): book_form.save() return redirect('book_list') else: book_form = BookForm() return render(request, 'book_create.html', {'book_form': book_form})def book_update(request, book_id): # 更新图书 book = get_object_or_404(Book, pk=book_id) if request.method == 'POST': book_form = BookForm(request.POST, instance=book) if book_form.is_valid(): book_form.save() return redirect('book_list') else: book_form = BookForm(instance=book) return render(request, 'book_update.html', {'book_form': book_form})def book_delete(request, book_id): # 删除图书 book = get_object_or_404(Book, pk=book_id) if request.method == 'POST': book.delete() return redirect('book_list') return render(request, 'book_delete.html', {'book': book})上述代码展现了如何应用Django构建一个简略的图书管理系统。通过定义模型类和视图函数，咱们能够实现图书列表展现、图书详情、图书创立、图书更新和图书删除等性能。在模板文件中，咱们能够应用Django提供的模板语言来动静生成HTML内容，从而展现图书管理系统的各种页面。 ...

在这篇文章中，我将手把手地教你如何从零开始部署一个应用Django框架的Python服务。无论你是一个刚开始接触开发的老手，还是一个有教训的开发者想要疾速理解Django，这篇教程都会为你提供一条清晰的门路。咱们将从环境搭建开始，一步一步地创立一个能够解决GET和POST申请的服务，让你能在实践中了解Django的工作原理。 环境搭建（按需）首先，咱们须要创立一个适宜开发的环境。在Python开发中，咱们通常会应用虚拟环境来放弃工作空间的整洁。以下是创立和激活虚拟环境的步骤： # 创立虚拟环境python3 -m venv myenv# 激活虚拟环境（Linux/macOS）source myenv/bin/activate# 激活虚拟环境（Windows）.\myenv\Scripts\activate在虚拟环境中，咱们能够装置Django： pip install Django这将会装置Django并且保障它不会影响到零碎中的其余Python我的项目。 创立我的项目装置实现后，咱们能够应用Django的命令行工具来创立一个新的我的项目： django-admin startproject myproject这将会在当前目录下创立一个名为myproject的文件夹，其中蕴含了治理Django我的项目所需的一些文件。 创立利用在Django中，一个我的项目能够蕴含多个利用，每个利用都是一个Python模块，蕴含了视图、模型、模板、路由等一系列性能。咱们首先创立一个名为myapp的利用： cd myprojectpython manage.py startapp myapp这会在myproject目录下创立一个myapp的目录，蕴含了治理利用所需的一些文件。 定义视图接下来，咱们须要定义视图来解决HTTP申请。在myapp/views.py文件中，咱们能够定义一个视图来解决GET和POST申请： from django.http import JsonResponsefrom django.views.decorators.csrf import csrf_exempt@csrf_exemptdef hello(request): if request.method == 'GET': return JsonResponse({'message': 'Hello, Django!'}) elif request.method == 'POST': return JsonResponse({'message': 'POST request received.'})这里，咱们应用了JsonResponse来返回JSON响应，用@csrf_exempt来豁免CSRF爱护，以便于咱们在测试时能不便地发送POST申请。 配置路由视图定义实现后，咱们还须要配置路由来将URL映射到视图。在myapp/urls.py 文件中，咱们能够定义路由： from django.urls import pathfrom . import viewsurlpatterns = [ path('hello/', views.hello),]而后，在myproject/urls.py文件中，咱们须要蕴含myapp的路由： from django.urls import include, pathurlpatterns = [ path('myapp/', include('myapp.urls')),]这样，拜访/myapp/hello/URL时，就会调用咱们定义的hello视图。 ...

递归是一种常见且重要的算法设计和解决问题的办法。它通过将问题合成为规模更小的子问题，并通过解决子问题来解决原始问题。递归算法的关键在于找到递归终止条件和递归调用的形式。本文将介绍递归的基本原理、利用场景，并通过相干的Python代码示例具体解说递归算法的应用。 一、递归的基本原理递归算法的基本原理能够用以下步骤形容： 确定递归函数的终止条件：递归终止条件是指当问题规模达到肯定水平时，无需再进行递归，间接返回后果。将原始问题合成为更小的子问题：将原始问题划分为一个或多个规模更小的子问题，这些子问题与原问题具备雷同的构造，但规模更小。通过递归调用解决子问题：应用递归调用的形式解决子问题，直到子问题的规模足够小，能够间接失去后果。合并子问题的后果：将子问题的后果合并，失去原始问题的解。递归算法通常采纳自顶向下的思考形式，将一个大问题一直合成为小问题，直到问题的规模足够小，能够间接求解。在实现递归算法时，须要特地留神递归终止条件的正确性，否则可能导致有限递归的问题。 二、递归的利用场景递归算法在许多畛域都有宽泛的利用。以下是一些常见的利用场景： 2.1 数据结构的遍历递归能够用于遍历树、图等数据结构。通过递归调用，在每个节点处拜访节点的值，并递归地拜访其子节点，实现对整个数据结构的遍历。 2.2 分治算法分治算法是一种常见的递归算法，它将一个大问题合成为多个独立的子问题，而后将子问题的解合并失去原始问题的解。经典的例子包含归并排序和疾速排序。 2.3 深度优先搜寻深度优先搜寻是一种罕用的图遍历算法，也能够应用递归来实现。在深度优先搜寻中，通过递归地拜访相邻节点，直到找到指标节点或遍历残缺个图。 2.4 回溯算法回溯算法通常用于解决组合、排列、子集等问题。它通过递归地尝试所有可能的抉择，并依据问题的要求进行剪枝，最终找到满足条件的解。 三、递归算法的代码示例上面通过几个具体的例子来演示递归算法的应用。 例子1：计算阶乘阶乘是一个经典的递归问题，能够用以下形式实现： def factorial(n): if n == 0: return 1 # 终止条件：0的阶乘为1 else: return n * factorial(n-1) # 递归调用，计算n的阶乘例子2：斐波那契数列斐波那契数列是另一个常见的递归问题，能够用以下形式实现： def fibonacci(n): if n <= 1: return n # 终止条件：前两个斐波那契数为0和1 else: return fibonacci(n-1) + fibonacci(n-2) # 递归调用，计算第n个斐波那契数例子3：二叉树遍历递归能够用于遍历二叉树。以下是二叉树节点的定义和前序遍历的实现： class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = rightdef preorderTraversal(root): if root is None: return [] # 终止条件：空节点 else: return [root.val] + preorderTraversal(root.left) + preorderTraversal(root.right)四、总结本文介绍了递归算法的基本原理、利用场景，并通过具体的Python代码示例具体解说了递归算法的应用。递归是一种弱小的算法设计技巧，可能解决许多简单的问题。在利用递归算法时，须要留神递归终止条件的正确性，以防止有限递归的问题。通过把握递归的原理和利用技巧，咱们能够更好地了解和利用递归算法，晋升问题解决的能力。关注我，更多精彩内容立刻出现！ ...

在Python中，生成器和迭代器是实现惰性计算的两种重要工具，它们能够帮忙咱们更无效地解决数据，特地是在解决大数据集时，能够显著缩小内存的应用。接下来，咱们将具体介绍这两种工具。一、迭代器迭代器是一种非凡的对象，它能够遍历一个汇合中的所有元素。任何实现了__iter__()和__next__()办法的对象都能够被称为迭代器。 1.1 创立迭代器首先，让咱们通过一个简略的例子来看看如何创立一个迭代器： class MyIterator: def __init__(self, data): self.data = data self.index = 0 def __iter__(self): return self def __next__(self): if self.index < len(self.data): result = self.data[self.index] self.index += 1 return result else: raise StopIteration # 应用自定义的迭代器my_iter = MyIterator("Hello")for char in my_iter: print(char)在这个例子中，咱们创立了一个迭代器，它能够一一返回给定字符串中的所有字符。当咱们试图获取下一个元素时，如果还有元素可供返回，就返回该元素，否则就抛出StopIteration异样。 1.2 应用内置的迭代器Python中有许多内置的迭代器，如列表迭代器、字典迭代器、文件迭代器等。上面是一些例子： # 列表迭代器list_iter = iter([1, 2, 3])print(next(list_iter))print(next(list_iter))print(next(list_iter))# 字典迭代器dict_iter = iter({"a": 1, "b": 2, "c": 3})print(next(dict_iter))print(next(dict_iter))print(next(dict_iter))# 文件迭代器with open("test.txt") as file: for line in file: print(line, end="")二、生成器生成器是一种非凡的迭代器，它更加简洁和灵便。生成器能够通过两种形式创立：生成器函数和生成器表达式。 2.1 生成器函数生成器函数是蕴含yield关键字的函数。当调用生成器函数时，它会返回一个生成器对象，咱们能够通过next函数或for循环来获取生成器中的元素。以下是一个生成器函数的例子： ...

在 Python 中，对于函数的参数传递，有两种次要的形式：传值和传援用。事实上，Python 的参数传递是一种“传对象援用”的形式。接下来的文章咱们将具体介绍 Python 的函数参数传递机制，这对了解 Python 编程语言的底层实现以及优化你的代码都十分有帮忙。 一、Python 中的变量和对象在深刻了解参数传递之前，咱们首先须要了解 Python 中的变量和对象的概念。 在 Python 中，所有的数据都是对象，无论是数字、字符串还是自定义类型。而变量则是指向对象的援用。 x = 3y = x在这个例子中，x 和 y 都是指向整数 3 这个对象的援用。咱们能够通过 id() 函数查看它们指向的对象的内存地址，验证这一点。 print(id(x)) # 输入：94832830448320print(id(y)) # 输入：94832830448320二、可变对象和不可变对象在 Python 中，对象能够分为可变对象和不可变对象。例如，列表、字典和汇合是可变对象，而数字、字符串和元组是不可变对象。 对于不可变对象，咱们无奈扭转对象本身，然而能够扭转变量所指向的对象。 x = 3print(id(x)) # 输入：94832830448320x = 4print(id(x)) # 输入：94832830448352在这个例子中，咱们先是让变量 x 指向了整数 3，而后又让 x 指向了整数 4。咱们无奈扭转整数 3 本身，然而能够扭转 x 所指向的对象。 对于可变对象，咱们既能够扭转对象本身，也能够扭转变量所指向的对象。 x = [1, 2, 3]print(id(x)) # 输入：139644486420232x.append(4)print(id(x)) # 输入：139644486420232x = [1, 2, 3, 4, 5]print(id(x)) # 输入：139644486437576在这个例子中，咱们先是让变量 x 指向了一个列表 [1, 2, 3]，而后咱们通过 append() 办法扭转了这个列表，使其变为了 [1, 2, 3, 4]。此时，x 所指向的对象并没有扭转，然而对象本身产生了变动。而后，咱们让 x 指向了一个新的列表 [1, 2, 3, 4, 5]。此时，x 所指向的对象扭转了。 ...

这是一个明天产生的热点话题，说是热点，其实对我来说不算是生疏的话题了，因为早在几年前，我就曾经关注到一些技术论坛有相似的探讨，过后就曾经上过某些博客网站的热搜，当然，因为技术社区具备垂直化的个性，因而很难引起技术圈以外的公众的留神。 首先，得申明一下，本篇博客的写作纯正对于技术的探索，我已经是一名网络安全爱好者，同时近期正好在看一些法律常识，因而更加关注用户隐衷，因而这篇博客不会提供任何的人脸图片，无论是任何地区的陌生人，还是某个明星。这是出于一种尊重。 技术概念在介绍代码之前，我打算先科普一下几个相干的技术概念： 百度AI的人脸检测与属性剖析接口：百度AI平台提供了丰盛的人脸技术接口，其中包含人脸检测与属性剖析接口。通过该接口，咱们能够将一个图片的人脸区域进行定位，并获取诸如年龄、性别、颜值等属性信息。这对于目前国内的颜值打分测评网站，软件而言，非常的要害。 为什么非常要害？几年前我读大三的时候，因为学校理科专业课程不多的缘故，我在图书馆里对这类程序的代码过后趣味的看了看，发现目前国内的颜值测评次要分为两类： 1.伪评测应用随机数，也就是说，给一个数值范畴，在该范畴中进行打分，给出评估，我用c语言代码举一个示例： #include <stdio.h>#include <stdlib.h>#include <time.h>int evaluate_beauty() { // 生成种子，用于产生随机数 srand(time(NULL)); // 随机生成颜值评分（0-100） int beauty_score = rand() % 101; return beauty_score;}const char* evaluate_comment(int beauty_score) { // 依据评分给出中文评估 if (beauty_score >= 90) { return "哇，超级美！"; } else if (beauty_score >= 80) { return "很美哦！"; } else if (beauty_score >= 70) { return "挺难看的！"; } else if (beauty_score >= 60) { return "还能够！"; } else { return "不是很美，加油！"; }}int main() { // 调用评分函数进行颜值测评 int score = evaluate_beauty(); // 输入评分 printf("颜值评分：%d\n", score); // 获取中文评估 const char* comment = evaluate_comment(score); // 输入中文评估 printf("中文评估：%s\n", comment); return 0;}其实你能够发现，这类程序其实基本没有所谓的ai人工智能进行思考判断，相似于风行的算命求姻缘一样，并无实际意义。 ...

在 Python 中，有许多内置的装璜器能够用来加强函数或者类的性能。其中之一就是 functools.lru_cache 装璜器。这是一个十分有用的装璜器，它能够帮忙咱们优化递归函数，防止反复计算曾经计算过的值。在这篇文章中，咱们将探讨 functools.lru_cache 的工作原理以及如何应用它。 一、什么是 functools.lru_cache？functools.lru_cache 是 Python 规范库中 functools 模块的一部分。lru_cache 装璜器能够用来为一个函数增加一个缓存零碎。这个缓存零碎会存储函数的输出和对应的输入。如果函数被调用，并且给出了曾经缓存过的输出，那么函数就不会从新计算，而是间接从缓存中获取对应的输入。 LRU 是 “Least Recently Used” 的缩写，意思是 “最近起码应用”。LRU 缓存就是一种缓存淘汰算法，当缓存达到预设的容量下限时，会优先淘汰最近起码应用的数据。 from functools import lru_cache@lru_cache(maxsize=None)def fib(n): if n < 2: return n return fib(n - 1) + fib(n - 2)print(fib(10)) # 输入：55在下面的例子中，咱们定义了一个求斐波那契数列的函数，并且应用 @lru_cache(maxsize=None) 装璜器对其进行了装璜。而后咱们调用 fib(10)，失去后果 55。实际上，因为应用了缓存，fib 函数在求解过程中，对于同样的参数只进行了一次计算。 二、如何应用 functools.lru_cache？要应用 functools.lru_cache 装璜器，你只须要在你的函数定义之前增加 @functools.lru_cache 行。这会让 lru_cache 装璜器晓得你心愿为这个函数增加一个缓存零碎。 lru_cache 装璜器有两个可选参数： maxsize：这个参数用来设置缓存的大小。如果你设置了这个参数，缓存的大小就会被限度在这个值之内。如果你不设置这个参数，或者将其设置为 None，那么缓存的大小就没有下限。typed：如果你将这个参数设置为 True，那么 lru_cache 就会依据输出参数的类型别离进行缓存。也就是说，1 和 1.0 只管在 Python 中是相等的，但它们会被当成两个不同的输出进行缓存。默认状况下，typed 参数是 False。from functools import lru_cache@lru_cache(maxsize=128, typed=False)def add(x, y): print(f"Calculating: {x} + {y}") return x + yprint(add(1, 2)) # 输入：Calculating: 1 + 2 \n 3print(add(1, 2)) # 输入：3print(add(1.0, 2.0)) # 输入：Calculating: 1.0 + 2.0 \n 3.0print(add(1.0, 2.0)) # 输入：3.0在下面的代码中，咱们定义了一个加法函数 add，并应用 lru_cache 装璜器对其进行装璜。咱们能够看到，当咱们第二次调用 add(1, 2) 和 add(1.0, 2.0) 时，add 函数并没有从新进行计算，而是间接从缓存中获取了后果。 ...

在Python中，filter函数是一种内置的高阶函数，它可能承受一个函数和一个迭代器，而后返回一个新的迭代器，这个新的迭代器仅蕴含使给定函数返回True的原始元素。这个性能在许多状况下都十分有用，比方当你须要从一个大的数据集中筛选出满足某些条件的数据时。 一、filter函数的根本用法在最根本的模式中，filter函数承受一个函数和一个迭代器，并返回一个新的迭代器，其中蕴含原始迭代器中使给定函数返回True的元素。这个函数通常被称为"谓词"，因为它应该返回一个布尔值。 这是一个简略的例子： def is_even(n): return n % 2 == 0numbers = [1, 2, 3, 4, 5, 6]even_numbers = filter(is_even, numbers)print(list(even_numbers)) # 输入：[2, 4, 6]在这个例子中，咱们首先定义了一个函数is_even，这个函数承受一个数字并查看它是否是偶数。而后，咱们创立了一个列表numbers。接着，咱们应用filter函数和is_even函数来从numbers列表中筛选出偶数。最初，咱们将filter对象转换为列表并打印后果。 二、应用匿名函数与filter函数你能够应用匿名函数（也称为lambda函数）作为filter函数的第一个参数。这在你只须要在一个中央应用函数，并且函数的逻辑非常简单时十分有用。 上面是一个应用匿名函数的例子： numbers = [1, 2, 3, 4, 5, 6]even_numbers = filter(lambda x: x % 2 == 0, numbers)print(list(even_numbers)) # 输入：[2, 4, 6]在这个例子中，咱们间接在filter函数调用中定义了一个匿名函数。这个匿名函数承受一个数字并查看它是否是偶数。这与后面的例子完全相同，然而更加简洁。 三、应用filter函数解决简单数据结构filter函数也能够解决更简单的数据结构。例如，如果你有一个蕴含字典的列表，你能够应用filter函数来筛选出满足某些条件的字典。 上面是一个例子，咱们应用filter函数筛选出年龄大于30的人： data = [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 35}]old_people = filter(lambda x: x['age'] > 30, data)print(list(old_people)) # 输入：[{'name': 'Charlie', 'age': 35}]在这个例子中，咱们首先定义了一个蕴含字典的列表data，每个字典代表一个人，并含有他们的名字和年龄。而后咱们应用filter函数和一个匿名函数来筛选出年龄大于30的人。 ...

你好，我是猫哥。这里每周分享优质的 Python 及通用技术内容，局部为英文，已在小标题注明。（题目取自其中一则分享，不代表全部内容都是该主题，特此申明。） 首发于我的博客：https://pythoncat.top/posts/2023-07-01-weekly 周刊的投稿通道已凋谢，请在 Github 我的项目中提交 issue：https://github.com/chinesehuazhou/python-weekly 文章&教程本地部署开源大模型的残缺教程：LangChain + Streamlit+ Llama (英)一篇步骤清晰的教程，它应用 LangChain 及 Facebook 开源的 LLaMA 大语言模型搭建了一个基于文档的问答助手，另外应用 Streamlit 构建出一个好看的用户界面。（附一篇中文的翻译文 ） Python Asyncio 协程对象开销老本一个 Python Asyncio 协程会占用有多少内存呢？文章的测试论断是约 2Kb。另外，文中还测试了以下的问题：每秒可创立多少个裸协程？每秒可解决多少个协程？应用uvloop 后，创立及解决协程工作，能有多少晋升？ 如何应用 asyncio.Runner 执行多个协程 (英)asyncio.Runner 是 Python 3.11 中新增的性能，反对在同一事件循环中执行多个协程。文章次要内容：如何应用 asyncio.run() 运行多个协程，如何应用包装办法运行多个协程，以及如何应用 asyncio.Runner 类在同一个事件循环中以自适应甚至有条件的形式执行协程。 不应用锁的并发实现 (英)在并发编程中，通常须要应用锁，然而不应该滥用锁。这篇文章探讨了如何尽量不依赖锁来实现并发，演示的例子是生成短链接，次要的思维是“申请饶恕”而不是“提前查看”、应用 PostgreSQL 数据库提供的性能。 奉献 CPython 日记 (3) CPython 是如何运行的文章介绍了 CPython 是如何把 Python 代码跑起来的，次要过程：词法剖析、语法分析、编译到字节码、执行字节码。 Python JIT 编译器 - 即时编译 (英)文章探讨了 JIT 编译的概念及其长处，并深入分析了支流的 Python JIT 编译器的优缺点（如 PyPy、Numba 和 Cython），介绍了在 Python 中应用 JIT 编译器的最佳实际和准则。 ...

面向对象编程（Object-Oriented Programming，简称OOP）是一种罕用的编程范式，它将数据和操作数据的函数封装在一起，以创建对象。Python是一种反对面向对象编程的高级编程语言，它提供了类（class）、对象（object）和继承（inheritance）等概念，使得代码更加模块化、可维护性更高。本文将介绍Python中的面向对象编程概念，包含类的定义、对象的创立以及继承的应用，并通过相干代码进行解说。 一、类的定义和对象的创立在Python中，类是创建对象的蓝图，它定义了对象的属性和行为。类由关键字class后跟类名和一个冒号开始，紧接着是类的属性和办法。 1.1 示例代码上面是一个简略的示例代码，展现了如何定义一个类和创建对象： class Car: def __init__(self, brand, color): self.brand = brand self.color = color def drive(self): print(f"{self.color}的{self.brand}汽车正在行驶") # 创立Car类的对象car1 = Car("宝马", "彩色")car2 = Car("飞驰", "红色")# 调用对象的办法car1.drive()car2.drive()在这个示例中，咱们定义了一个名为Car的类，它有两个属性brand和color，以及一个办法drive。__init__是一个非凡的办法，用于在创建对象时进行初始化。通过self关键字，咱们能够在类的办法中拜访对象的属性。通过Car类，咱们创立了两个对象car1和car2，并调用了它们的drive办法。 二、继承继承是面向对象编程中的重要概念之一，它容许咱们创立新的类（称为子类），并从现有的类（称为父类或基类）继承属性和办法。子类能够扩大或批改父类的性能，从而实现代码的重用和扩大。 2.1 示例代码上面是一个示例代码，展现了如何应用继承创立子类： class Animal: def __init__(self, name): self.name = name def speak(self): raise NotImplementedError("子类必须实现speak办法")class Dog(Animal): def speak(self): print(f"{self.name}在汪汪叫")class Cat(Animal): def speak(self): print(f"{self.name}在喵喵叫") # 创立Animal类的对象animal = Animal("动物")animal.speak()# 创立Dog类和Cat类的对象dog = Dog("旺财")dog.speak()cat = Cat("小咪")cat.speak()在这个示例中，咱们定义了一个名为Animal的基类，它有一个属性name和一个办法speak。因为speak办法在基类中没有具体实现，咱们通过raise语句引发了一个NotImplementedError异样，要求子类必须实现该办法。而后，咱们创立了两个子类Dog和Cat，它们继承了Animal类。子类中重写了父类的speak办法，并提供了具体的实现。通过创立Animal类的对象和子类的对象，咱们能够调用它们的speak办法，实现了不同动物的叫声输入。 三、封装、继承和多态封装、继承和多态是面向对象编程的三个次要概念。 封装（Encapsulation）：将数据和操作数据的函数封装在一起，造成一个对象。对象暗藏外部的细节，只裸露必要的接口，进步了代码的可维护性和重用性。继承（Inheritance）：通过继承现有类的属性和办法，创立新的类。子类能够重用父类的代码，并在此基础上增加、批改或扩大性能。多态（Polymorphism）：容许应用不同的对象调用雷同的办法，实现了不同对象对同一音讯的响应形式。这三个概念互相关联，独特形成了面向对象编程的核心思想。 四、总结通过本文的介绍，咱们理解了Python中面向对象编程的基本概念，包含类的定义、对象的创立以及继承的应用。面向对象编程使得代码更加模块化、可维护性更高，可能进步代码的重用性和扩展性。同时，封装、继承和多态是面向对象编程的重要个性，它们独特形成了面向对象编程的根底。心愿本文对你了解Python面向对象编程有所帮忙！ 五、最初关注我，更多精彩内容立刻出现！

1. 函数根底1. 函数的定义"""函数就是封装格局def 函数名(): 函数体(封装内容)函数名()"""# 申明(函数封装)def know_error(): # 打印 # 控制台查看 print("我错了") print("我错了") print("我错了") print("我错了") print("我错了")# 调用know_error()# 申明(函数封装)def func(): # 返回值 return "hello world"# 拼接num = func() + " " + "python"# 打印# hello world pythonprint(num)2. 函数参数及其类型# 必备参数# 申明def func(name_1): # 形参 # 循环 for i in range(10): # 打印 # 控制台查看 print("我是{}，我晓得错了".format(name_1))# 调用func("qi") # qi 实参# return# 申明def func_1(name_2): # 定义一个列表 li = [] # 循环 for i in range(10): # 赋值 test = "我是{}，我晓得错了".format(name_2) # 增加到列表 li.append(test) # 返回值 return li# 其他人也能够调用print(func_1("老王"))# 默认参数# 有就用实参，没有就用形参def func_2(a, b=5): # 打印 print(a, "---", b)# 调用# 9 --- 5func_2(9)# 调用# 9 --- 9func_2(9, 9)# 不定长参数(地位参数)def func_3(num, *args, **kwargs): # 打印 # 1 print(num) print(args) print(kwargs)# 调用# qi# (1, 2, 3, 4, 5)# {'num_1': 12, 'num_2': 13, 'num_3': 15}func_3("qi", 1, 2, 3, 4, 5, num_1=12, num_2=13, num_3=15)3. 内置函数# 查看函数# ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']# print(dir(__builtins__))# filter 过滤def func_4(x): # 返回值 return x > 10# 赋值li_1 = [2, 3, 5, 8, 22, 35, 68, 79]# 筛选# [22, 35, 68, 79]print(list(filter(func_4, li_1)))# zip 配对# 赋值li_2 = [22, 33, 55, 88]# 配对# {2: 22, 3: 33, 5: 55, 8: 88}print(dict(zip(li_1, li_2)))# map 对立对格局进行批改def func_5(y): # 返回值 return y * 10# 打印后果# [220, 330, 550, 880]print(list(map(func_5, li_2)))2. 函数进阶1. 匿名函数匿名函数 ...

Python Django全面介绍Django是一个十分弱小的Python Web开发框架，它以"疾速开发"和"洁净、实用的设计"为设计主旨。本文将从Django的基本概念开始，逐步疏导大家了解如何应用Django构建简单的web应用程序。 Django基本概念与原理首先，让咱们从Django的外围组件开始解说。Django遵循MVC模型-视图-控制器设计模式，并在Python中有一个非凡的表现形式，称为MTV模型-模板-视图。这是因为Django的控制器局部由框架本身外部解决，而开发者次要与模型、模板和视图交互。 # 示例代码：创立一个Django模型from django.db import modelsclass Blog(models.Model): title = models.CharField(max_length=200) content = models.TextField() def __str__(self): return self.title在下面的代码中，咱们定义了一个简略的博客模型，蕴含题目和内容两个字段。其中，CharField和TextField都是Django提供的数据库字段类型。 Django的视图与URL配置在Django中，视图是Python函数，用于接管Web申请并返回Web响应。每个视图函数都将一个HttpRequest对象作为参数，并返回一个HttpResponse对象。视图与Web应用程序的URLs关联，这是通过URL配置实现的。 # 示例代码：创立一个视图from django.http import HttpResponsefrom .models import Blogdef blog_index(request): blogs = Blog.objects.all() output = ', '.join([blog.title for blog in blogs]) return HttpResponse(output)# 示例代码：URL配置from django.urls import pathfrom . import viewsurlpatterns = [ path('blogs/', views.blog_index, name='blog_index'),]上述代码中，咱们首先定义了一个视图blog_index，该视图从数据库获取所有的博客条目并显示其题目。而后咱们在URL配置中创立了一个新的URL门路'blogs/'，将其关联到blog_index视图。 Django模板Django的模板零碎容许咱们创立动静HTML页面。Django模板应用本人的语言，是Python的一个小子集。 <!-- 示例代码：创立一个模板 -->{% for blog in blogs %} <h2>{{ blog.title }}</h2> <p>{{ blog.content }}</p>{% endfor %}在上述代码中，咱们创立了一个模板，该模板接管一个博客对象列表，并为每个对象生成一个HTML段落。 ...

在Python中，map是一个十分实用的内置函数，它容许你对一个序列的所有元素执行特定的操作。map函数的后果能够被转换为一个列表，或者其余的可迭代对象。在本文中，咱们将深入探讨map函数的用法及其在理论编程中的利用。 一、map函数的根底用法map函数的根底用法很简略。这个函数须要两个参数，第一个参数是一个函数，第二个参数是一个可迭代对象。map函数将会对可迭代对象的每一个元素执行函数，并返回一个新的map对象。 上面是一个简略的例子，咱们将一个列表中的每个元素都乘以2： def double(n): return n * 2numbers = [1, 2, 3, 4, 5]result = map(double, numbers)print(list(result)) # 输入：[2, 4, 6, 8, 10]在这个例子中，咱们首先定义了一个函数double，这个函数承受一个参数并将其乘以2。而后，咱们创立了一个列表numbers。接着，咱们应用map函数对numbers列表中的每个元素调用double函数。最初，咱们将map对象转换为列表并打印后果。 二、map函数与匿名函数的联合map函数常常与匿名函数（lambda函数）一起应用。匿名函数是一个没有名字的简略函数，它在咱们只须要一个简略函数并且只应用一次时十分有用。 上面是一个例子，咱们应用map和匿名函数将一个列表中的所有元素转换为它们的平方： numbers = [1, 2, 3, 4, 5]result = map(lambda x: x ** 2, numbers)print(list(result)) # 输入：[1, 4, 9, 16, 25]在这个例子中，咱们应用了一个匿名函数lambda x: x ** 2作为map函数的第一个参数。这个匿名函数承受一个参数x并返回x的平方。咱们没有必要为这个简略的操作创立一个残缺的函数，所以应用匿名函数更加不便。 三、map函数与多个可迭代对象的联合如果你的函数须要承受多个参数，你能够将多个可迭代对象传递给map函数。map函数将会并行地对这些可迭代对象的元素进行解决。 上面是一个例子，咱们应用map函数并行地解决两个列表，将它们的元素相加： def add(x, y): return x + ynumbers1 = [1, 2, 3]numbers2 = [4, 5, 6]result = map(add, numbers1, numbers2)print(list(result)) # 输入：[5, 7, 9]在这个例子中，咱们定义了一个函数add，这个函数承受两个参数并返回它们的和。而后，咱们创立了两个列表numbers1和numbers2。接着，咱们应用map函数对这两个列表中的元素并行地调用add函数。最初，咱们将map对象转换为列表并打印后果。 ...

在Python编程中，咱们常常会遇到单下划线（_）和双下划线（__）的应用。它们在命名标识符、变量、办法和属性中扮演着不同的角色。本文将具体解释Python中单下划线和双下划线的含意和用法，并通过代码示例进行解说，帮忙你了解它们的作用和实用场景。一、单下划线（_）的应用命名约定。在Python中，单下划线作为命名约定，用于示意某个变量、办法或属性是外部应用的或具备特定含意，但不心愿在内部间接拜访。代码示例： # 单下划线作为命名约定class MyClass: def __init__(self): self._internal_var = 42 def _internal_method(self): return "Internal method" def public_method(self): return self._internal_method()在下面的例子中，变量_internal_var和办法_internal_method都以单下划线结尾。这是一种约定，通知其余开发人员这些成员是类外部应用的，不倡议在类内部间接拜访。公共办法public_method能够拜访外部办法_internal_method。 防止命名抵触。单下划线还能够用于防止命名抵触。当咱们在导入模块时，能够应用单下划线作为前缀，以防止与以后命名空间中的其余标识符抵触。代码示例： # 防止命名抵触from mymodule import my_function, _internal_function在下面的例子中，通过应用单下划线前缀导入_internal_function函数，咱们能够明确指定该函数是模块的外部应用，而不是公共接口。 长期变量。在一些状况下，咱们可能只须要长期应用某个变量，而不关怀它的具体值。此时，能够应用单下划线作为变量名，示意它是一个无关紧要的长期变量。代码示例： # 应用单下划线作为长期变量for _ in range(5): print("Hello!")在下面的例子中，循环变量被命名为单下划线，这通知其余开发人员循环变量的具体值并不重要，只须要执行循环体内的代码5次即可。 引入未应用的变量。有时候，在编码过程中咱们可能会定义一些变量，但在后续的代码中并没有应用它们。为了避免出现未应用变量的正告，能够应用单下划线作为变量名。代码示例： # 引入未应用的变量_, y, _ = (1, 2, 3)在下面的例子中，咱们应用单下划线占位符引入了一个未应用的变量。这样做能够通知读者，咱们在意识到该变量存在但并不关怀它的具体值。 二、双下划线（__）的应用名称润饰。双下划线用于名称润饰，行将属性或办法后面的双下划线作为前缀，使其成为公有成员。公有成员只能在类外部拜访，无奈在类内部间接拜访。代码示例： # 双下划线作为名称润饰class MyClass: def __init__(self): self.__private_var = 42 def __private_method(self): return "Private method" def public_method(self): return self.__private_method()obj = MyClass()print(obj.public_method()) # 输入：Private methodprint(obj.__private_var) # 报错：AttributeError: 'MyClass' object has no attribute '__private_var'在下面的例子中，属性__private_var和办法__private_method都以双下划线结尾，它们被视为公有成员。在类内部无奈间接拜访公有成员，但能够通过公共办法public_method间接拜访。 ...

本文将具体探讨Python Flask Web服务。我将首先简略介绍Flask，而后将逐渐进入Flask中的路由、模板、表单解决以及数据库集成等高级概念，指标是可能让大家理解并把握应用Flask来创立动静Web利用的技巧。 1. Flask简介Flask是一个轻量级的Web服务器网关接口（WSGI）web利用框架。它被设计为易于应用，同时也提供了扩展性，用户能够自在地抉择将其与哪些第三方库集成。Flask是"微"框架，这意味着其外围性能十分无限，但能够通过一系列的扩大来加强性能。 让咱们来看一下如何创立一个简略的Flask利用。 from flask import Flaskapp = Flask(__name__)@app.route('/')def hello_world(): return 'Hello, World!'if __name__ == '__main__': app.run()在这段代码中，咱们首先导入Flask模块，并创立一个Flask web服务器实例。而后，咱们定义了一个路由（route），即/。这个路由映射到一个函数hello_world，当用户拜访这个URL时，它会返回'Hello, World!'字符串。 2. Flask路由Flask通过提供装璜器app.route，使得定义路由变得简单易行。但你晓得咱们也能够通过app.add_url_rule办法间接增加路由吗？这种形式提供了更多的灵活性，例如，能够为路由增加不同的HTTP办法。 def hello(): return "Hello, World!"app.add_url_rule('/', 'hello', hello)在上述代码中，app.add_url_rule的第一个参数是URL规定，第二个参数是函数的别名，第三个参数是要映射的函数。 3. Flask模板Flask应用jinja2模板库。这个库十分弱小，能够让你在HTML中嵌入Python代码。上面的例子展现了如何在Flask利用中应用模板： from flask import render_template@app.route('/hello/<name>')def hello(name): return render_template('hello.html', name=name)render_template函数用于渲染一个模板。它接管模板的名称和一些模板变量作为参数，返回生成的HTML内容。在模板中，你能够应用{{ name }}来显示变量的值。 4. Flask表单解决Flask-WTF是Flask中用于解决Web表单的扩大库。它基于WTF Python，一个解决表单数据的Python库。Flask-WTF还具备CSRF（跨站申请伪造）爱护的性能。 让咱们 看一个简略的例子： from flask import requestfrom flask_wtf import FlaskFormfrom wtforms import StringFieldclass MyForm(FlaskForm): name = StringField('name')@app.route('/submit', methods=('GET', 'POST'))def submit(): form = MyForm() if form.validate_on_submit(): return 'Hello, %s' % form.name.data return render_template('submit.html', form=form)在这个例子中，咱们定义了一个表单类MyForm，蕴含一个name字段。而后，咱们在submit路由中创立了一个该类的实例，并查看表单是否通过验证。如果表单无效，咱们就返回一条欢送信息；否则，咱们就渲染一个表单模板。 ...

石头剪刀布是一种简略而又经典的游戏，经常用于决定输赢或者娱乐消遣。本文将应用Python实现一个简略的石头剪刀布游戏，让你能够与计算机进行对战。 一、游戏规则石头、剪刀和布别离代表不同的手势，其输赢规定如下： 石头战败剪刀：石头获胜。剪刀战败布：剪刀获胜。布战败石头：布获胜。 二、实现步骤步骤1：导入随机模块首先，咱们须要导入Python的随机模块random，以便生成计算机的随机手势。 import random步骤2：定义手势列表咱们能够定义一个手势列表，其中蕴含石头、剪刀和布三种手势。 gestures = ['石头', '剪刀', '布']步骤3：获取玩家输出通过应用input函数，咱们能够获取玩家抉择的手势。 player_gesture = input("请输出你的抉择（石头、剪刀或布）：")步骤4：生成计算机手势应用random.choice函数从手势列表中随机抉择一个手势作为计算机的抉择。 computer_gesture = random.choice(gestures)步骤5：判断输赢依据石头剪刀布的输赢规定，咱们能够通过一系列的判断语句来确定输赢。 if player_gesture == computer_gesture: result = "平局"elif (player_gesture == '石头' and computer_gesture == '剪刀') or \(player_gesture == '剪刀' and computer_gesture == '布') or \(player_gesture == '布' and computer_gesture == '石头'): result = "你赢了"else: result = "计算机赢了"步骤6：输入后果最初，咱们将输入玩家和计算机的手势，以及游戏的后果。 print(f"你的抉择是：{player_gesture}")print(f"计算机的抉择是：{computer_gesture}")print(f"后果：{result}")三、残缺代码上面是残缺的Python代码： import randomgestures = ['石头', '剪刀', '布']player_gesture = input("请输出你的抉择（石头、剪刀或布）：")computer_gesture = random.choice(gestures)if player_gesture == computer_gesture: result = "平局"elif (player_gesture == '石头' and computer_gesture == '剪刀') or \(player_gesture == '剪刀' and computer_gesture == '布') or \(player_gesture == '布' and computer_gesture == '石头'): result = "你赢了"else: result = "计算机赢了"print(f"你的抉择是：{player_gesture}")print(f"计算机的抉择是：{computer_gesture}")print(f"后果：{result}")四、运行游戏将上述代码保留为rock_paper_scissors.py文件，而后在命令行中运行该文件： ...

一、概述在Python中，eval函数是一个内置函数，用于将字符串解析并执行为Python表达式。本文将具体介绍eval函数的应用办法和注意事项，以及一些实用的例子。 二、根本用法eval函数的根本用法如下： x = 1print(eval('x+1')) # 输入：2在这个例子中，eval函数接管一个字符串'x+1'作为输出，解析并执行这个字符串作为Python表达式，而后返回后果。因为在这个表达式中，变量x的值为1，所以表达式x+1的后果为2。 三、eval函数和字典eval函数还能够承受一个可选的字典参数，该字典用于定义在表达式中应用的变量。例如： print(eval('x+y', {'x': 1, 'y': 2})) # 输入：3在这个例子中，eval函数接管两个参数：一个是表达式字符串'x+y'，另一个是定义变量的字典{'x': 1, 'y': 2}。因为在这个字典中，x的值为1，y的值为2，所以表达式x+y的后果为3。 四、应用eval函数执行简单表达式eval函数能够解析并执行非常复杂的Python表达式。例如： print(eval('[x**2 for x in range(5)]')) # 输入：[0, 1, 4, 9, 16]在这个例子中，eval函数解析并执行了一个列表推导式，这个列表推导式计算了前5个自然数的平方，并返回了一个列表。 五、eval函数的安全性问题尽管eval函数十分弱小，然而也须要审慎应用。因为eval函数能够解析并执行任何Python表达式，所以如果你在eval函数中执行了不可信的或歹意的代码，可能会带来重大的平安问题。 # 危险的应用示例user_input = "os.system('rm -rf /')" # 一段恶意代码eval(user_input) # 这将执行恶意代码为了防止这种平安问题，你应该总是确保传递给eval函数的代码是可信的。如果你不能保障代码的安全性，那么最好不要应用eval函数。 总结起来，eval函数是Python的一个弱小工具，它能够解析并执行Python表达式。然而，eval函数也须要审慎应用，因为它可能带来重大的平安问题。 六、eval函数与exec函数的区别eval函数和exec函数在肯定水平上是类似的，都能够执行字符串模式的Python代码。然而，eval函数返回表达式的后果，而exec函数不返回任何后果。此外，exec能够执行更简单的Python代码构造，比方类定义、函数定义和多行语句，而eval只能解析单个表达式。 eval('x = 5') # 这会导致语法错误，因为'x = 5'不是一个表达式exec('x = 5') # 这能够失常执行，因为'x = 5'是一个语句print(x) # 输入：5在下面的代码中，尝试应用eval函数执行赋值语句x = 5会导致语法错误，因为赋值语句不是一个表达式。然而，应用exec函数就能够失常执行。 七、总结eval函数是Python的一个弱小的内置函数，它可能解析并执行字符串模式的Python表达式。尽管如此，你应该审慎应用eval函数，特地是当你不能保障输出的安全性时。为了防止潜在的平安问题，你应该尽量避免在eval函数中执行不可信的或歹意的代码。 心愿本篇文章能帮忙你更深刻地了解Python的eval函数，并正确地应用它。记住，编程时平安总是第一位的！

1. 管制流程"""程序执行 从上到下顺次执行抉择执行 依据条件选择性执行循环执行 规定循环次数反复执行"""2. 程序执行# 输入# 1print(1)# 2print(2)# 3print(3)# 4print(4)3. 抉择执行"""留神！！！1. 必须要英文冒号2. if后下一段必须要缩进，惯例四格""""""第一种格局if 判断条件: print(后果)"""# 例如:# 赋值num = 7# 判断if num < 10: # 打印出小于10的数字 # num是小于10的 print("num是小于10的")"""第二种格局if 判断条件: print(后果)else: print(另一种后果) """# 例如:# 赋值num_1 = 13# 判断if num_1 <= 10: # 打印出小于10的数字 print("num_1是小于10的")# 否则else: # 打印出大于10的数字 # num_1是大于10的(抉择执行上面这段代码) print("num_1是大于10的")"""第三种格局if 判断条件: print(第一种后果) elif 判断条件: print(第二种后果) ...(elif判断能够有多个)else: print(另一个后果)"""# 例如:# 赋值num_2 = 97# 判断if num_2 >= 100: # 打印问题等级 print("超过")# 持续判断elif 90 <= num_2 <= 100: # 打印问题等级 # 问题为97，断定为优良(抉择执行此段代码) # 优良 print("优良") # 嵌套判断 if 95 <= num_2 <= 100: # 打印问题等级 # 优良 极优 print("极优")# 持续判断elif 80 <= num_2 < 90: # 打印问题等级 print("良好")# 持续判断elif 70 <= num_2 < 80: # 打印问题等级 print("个别")# 持续判断elif 70 <= num_2 < 80: # 打印问题等级 print("及格")# 否则else: # 打印残余的问题等级 print("不及格")# 案例# 判断是否是平年(四年一闰，百年不闰，四百年再闰)# 初始值year = 2000# 判断if year % 4 == 0 and year % 100 != 0 or year % 400 == 0: # 打印后果 print("闰")# 否则else: # 打印后果 print("不闰")4. 循环执行1. while循环"""# 条件循环while 条件: print("代码块")continue 终止当次循坏，间接开始下一次循坏break 间接终止循环pass 间接跳过，但不会报错"""# 定义初始值num = 1# 判断while num < 10: # 打印 # 控制台查看 print(num) # 自增量 num += 1# continue 和 break# 求1--100的奇数和# 定义初始值sum = 0count = 1# 循环while count <= 100: # 偶数 if count % 2 == 0: # 每循环一次就加一 count += 1 # 终止当次循坏，间接开始下一次循坏 # 2500 # continue # 间接终止循环 # 1 break # 计算 sum = sum + count # 每循环一次就加一 count += 1# 打印后果print(sum)# pass 不晓得该怎么写了，占位而不报错# 判断if num < 9: # 跳过 pass2. for循环"""# 遍历for 变量 in 可迭代对象: # 打印 print(变量)"""# 遍历（取全副）for i in range(10): # 打印 # 控制台查看 print(i)# 遍历（取局部）for i in range(3, 10): # 打印 # 控制台查看 print(i)# 遍历（依据步长取）for i in range(3, 10, 2): # 打印 # 控制台查看 print(i)# 案例# 用一个循环写一个等边三角形# 遍历for i in range(1, 10): # 打印 print(' ' * (10 - i), "*" * i * 2)三目运算# 原版# 赋值num = 5# 判断if num < 3: # 输入 print(False)# 否则else: # 输入 # True print(True)# 三目运算(只能用于简略格局)# 后果1 if 判断条件 else 后果2# 形式一# Trueprint(True) if num < 3 else print(True)# 形式二num_1 = (True if num < 3 else True)# 打印# Trueprint(num_1)

抉择排序（Selection Sort）是一种简略但无效的排序算法。它的根本思维是每次从待排序的元素中抉择最小（或最大）的元素，并将其搁置在已排序序列的开端。通过屡次抉择和替换操作，逐渐将序列排序。本文将具体介绍抉择排序算法的原理和实现，并提供相干的Python代码示例。 一、算法原理抉择排序算法的步骤如下： 遍历待排序序列，将第一个元素视为以后最小（或最大）元素。在残余的待排序序列中，找到最小（或最大）的元素，将其与以后地位替换。排除已排序的元素，反复步骤2，直到所有元素都被排序。抉择排序的核心思想是通过屡次抉择最小（或最大）元素，逐渐将序列排序。 二、抉择排序的实现上面是应用Python实现抉择排序算法的代码： def selection_sort(arr): n = len(arr) for i in range(n - 1): # 假如以后地位的元素为最小值 min_index = i for j in range(i + 1, n): # 在残余局部中寻找最小值的索引 if arr[j] < arr[min_index]: min_index = j # 将以后地位的元素与最小值进行替换 arr[i], arr[min_index] = arr[min_index], arr[i] # 测试代码numbers = [4, 2, 6, 1, 3]selection_sort(numbers)print(numbers) # 输入：[1, 2, 3, 4, 6]在上述代码中，selection_sort()函数承受一个待排序的列表作为输出，并对列表进行抉择排序。算法应用两个嵌套的循环。内部循环从第一个元素遍历到倒数第二个元素，外部循环从内部循环的下一个地位遍历到列表开端，寻找最小元素的索引。而后通过替换操作，将最小元素搁置在以后地位上。 三、算法剖析抉择排序是一种旧址排序算法，即在排序过程中间接批改原始列表，不须要额定的存储空间。抉择排序的工夫复杂度为O(n^2)，其中n是待排序序列的长度。尽管抉择排序的工夫复杂度较高，但在小规模数据或局部有序的数据集上，其性能依然能够承受。抉择排序是一种不稳固的排序算法，即相等元素的绝对程序可能会产生扭转。例如，对于序列[2, 2, 1]，通过抉择排序后，第一个2会被移到第二个2的前面。 四、优化思路只管抉择排序的工夫复杂度较高，但能够通过一些优化思路晋升算法性能。 优化1：缩小替换次数在外部循环中，咱们每次找到最小元素后都会进行一次替换操作。实际上，咱们能够在外部循环完结后再进行一次替换操作，将最小元素搁置在正确的地位上。 def selection_sort(arr): n = len(arr) for i in range(n - 1): # 假如以后地位的元素为最小值 min_index = i for j in range(i + 1, n): # 在残余局部中寻找最小值的索引 if arr[j] < arr[min_index]: min_index = j # 将以后地位的元素与最小值进行替换 if min_index != i: arr[i], arr[min_index] = arr[min_index], arr[i]这样能够缩小替换的次数，但并不会扭转算法的工夫复杂度。 ...

Python提供了一些内建的库以反对各种常见的编程工作。Contextlib库是其中之一，它提供了一些用于反对上下文治理协定（即with语句）的函数。 这篇文章将具体介绍如何应用Contextlib库中的性能，包含contextmanager装璜器，closing函数，以及其余有用的类和函数。 一、contextmanager装璜器contextmanager装璜器能让咱们更简略的实现上下文管理器。上下文管理器通常用于封装起始和完结须要做的操作，例如关上和敞开文件，获取和开释锁等等。 以下是一个应用contextmanager装璜器实现的上下文管理器例子： import contextlib@contextlib.contextmanagerdef managed_resource(*args, **kwds): # Code to acquire resource, e.g.: resource = acquire_resource(*args, **kwds) try: yield resource finally: # Code to release resource, e.g.: release_resource(resource)在上述代码中，yield语句将产生一个上下文，用户能够应用这个上下文在with语句中。 二、closing函数closing函数是一个帮忙函数，用来确保对象的close办法在实现后被正确的调用。这对于一些提供了close办法然而没有实现上下文治理协定的对象十分有用。 import contextlibwith contextlib.closing(open('my_file.txt', 'w')) as f: f.write('Hello, World!')在上述代码中，文件my_file.txt被关上，数据被写入，而后文件被正确的敞开，无论写入数据是否胜利。 三、其余有用的类和函数Contextlib库还提供了其余一些有用的类和函数，如ExitStack，nullcontext，和supress等。 咱们将在后续文章中具体介绍这些类和函数的用法和实例。目前，咱们能够简略的理解一下他们的性能： ExitStack类容许咱们更灵便地治理上下文资源。咱们能够在一个ExitStack实例中增加任意多个上下文管理器，并保障所有的上下文管理器都会在退出时正确的执行清理操作。nullcontext是一个简略的上下文管理器，它不执行任何操作。这在某些须要动静决定是否应用上下文管理器的状况下十分有用。suppress函数能够用来疏忽指定的异样。Contextlib库提供了一些弱小的工具来帮忙咱们更好地治理和操作上下文。尽管在开始时可能须要一些工夫来了解这些工具的工作原理，然而一旦把握了，你会发现它们在理论编程中十分有用。 四、ExitStack类的应用如前所述，ExitStack类是一个灵便的上下文管理器，它能够治理多个上下文管理器和个别的清理工作。上面是一些应用ExitStack的例子： from contextlib import ExitStackdef archive_files(files, archive_name): with ExitStack() as stack: archive = stack.enter_context(open(archive_name, 'w')) for file_name in files: file = stack.enter_context(open(file_name)) archive.write(file.read())在这个例子中，咱们首先创立了一个ExitStack实例，而后在这个实例中关上了一个用于存档的文件。而后，咱们关上了一系列的文件，每关上一个文件，就将其增加到ExitStack实例中。无论过程中产生何种异样，ExitStack都会保障所有关上的文件在退出时都被正确敞开。 五、nullcontext的应用nullcontext是一个非常简单的上下文管理器，它不执行任何操作。它的主要用途是在须要动静决定是否须要应用上下文管理器时作为一个占位符应用。以下是一个应用nullcontext的例子： import contextlibdef optional_open(file_name, mode, use_context): if use_context: return open(file_name, mode) else: return contextlib.nullcontext()with optional_open('my_file.txt', 'w', False) as f: if f is not None: f.write('Hello, World!')在这个例子中，咱们定义了一个函数optional_open，它依据传入的参数use_context决定是否应用open函数的上下文管理器。如果use_context为True，则应用open函数的上下文管理器；否则，应用nullcontext作为占位符。 ...

在Python开发中，咱们常常须要解决日期和工夫。Python提供了一些内置模块，如datetime、time和calendar，这些模块让咱们可能轻松地获取、操作和格式化日期和工夫。本文将介绍如何在Python中应用这些模块进行日期和工夫的解决。 一、获取以后日期和工夫在Python中，咱们能够应用datetime模块的datetime类来获取以后的日期和工夫。 import datetime# 获取以后日期和工夫now = datetime.datetime.now()print(now) # 输入：2023-06-25 09:00:00.000000这将返回以后日期和工夫的一个datetime对象。这个对象蕴含了年、月、日、时、分、秒和微秒。 二、日期和工夫的操作datetime对象反对很多操作，例如咱们能够加减timedelta对象来扭转日期和工夫。 import datetimenow = datetime.datetime.now()# 创立一个timedelta对象delta = datetime.timedelta(days=1, hours=2)# 加减timedeltafuture = now + deltapast = now - deltaprint(future) # 输入：2023-06-26 11:00:00.000000print(past) # 输入：2023-06-24 07:00:00.000000timedelta对象示意一个工夫距离，能够是几天、几小时、几分钟或几秒等。 三、日期和工夫的格式化咱们常常须要把日期和工夫转换为字符串，或者从字符串中解析出日期和工夫。datetime对象的strftime办法能够将日期和工夫格式化为字符串，strptime办法能够将字符串解析为日期和工夫。 import datetimenow = datetime.datetime.now()# 格式化为字符串s = now.strftime('%Y-%m-%d %H:%M:%S')print(s) # 输入：2023-06-25 09:00:00# 从字符串解析d = datetime.datetime.strptime(s, '%Y-%m-%d %H:%M:%S')print(d) # 输入：2023-06-25 09:00:00这里的%Y、%m、%d、%H、%M和%S是格式化代码，别离代表年、月、日、时、分和秒。 四、工夫戳和日期工夫的转换在Python中，咱们常常须要将日期工夫转换为工夫戳，或者将工夫戳转换为日期工夫。datetime对象的timestamp办法能够将日期工夫转换为工夫戳，datetime类的fromtimestamp办法能够将工夫戳转换为日期工夫。 import datetimenow = datetime.datetime.now()# 转换为工夫戳t = now.timestamp()print(t) # 输入：1693086000.0# 从工夫戳转换d = datetime.datetime.fromtimestamp(t)print(d) # 输入：2023-6-25 17:00:00然而在解决工夫戳时，咱们须要留神时区问题。以上述代码为例，timestamp办法返回的工夫戳是将以后工夫转为UTC工夫，而后再转换为工夫戳。而fromtimestamp办法默认将工夫戳转换为本地工夫。如果咱们心愿将工夫戳转换为UTC工夫，咱们能够应用utcfromtimestamp办法。import datetime ...

在 Python 编程中，args 和 kwargs 是罕用的两个非凡参数，用于解决不确定数量的函数参数。它们提供了一种灵便的形式来传递和接管参数，使函数的定义更加通用。本文将具体介绍 args 和 kwargs 的应用办法，并提供相干代码示例。 一、*args 参数args 是一个非凡的参数，在函数定义时以星号 () 结尾，用于传递不确定数量的地位参数。在函数体内，args 将接管传递给函数的地位参数，将它们作为一个元组(tuple)来解决。以下是应用 args 参数的示例代码： def sum_numbers(*args): total = 0 for num in args: total += num return totalprint(sum_numbers(1, 2, 3, 4, 5)) # 输入：15print(sum_numbers(10, 20, 30)) # 输入：60在上述示例中，sum_numbers 函数应用了 *args 参数来接管任意数量的地位参数，并将它们相加并返回总和。能够看到，咱们能够向函数传递任意数量的参数，不限度参数的个数。 二、**kwargs 参数kwargs 是另一个非凡的参数，在函数定义时以两个星号 () 结尾，用于传递不确定数量的关键字参数。在函数体内，kwargs 将接管传递给函数的关键字参数，并将它们作为一个字典(dict)来解决。以下是应用 kwargs 参数的示例代码： def print_person_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}")print_person_info(name="Alice", age=25, country="USA")# 输入：# name: Alice# age: 25# country: USAprint_person_info(name="Bob", occupation="Engineer")# 输入：# name: Bob# occupation: Engineer在上述示例中，print_person_info 函数应用了 **kwargs 参数来接管任意数量的关键字参数，并将它们打印进去。通过传递键值对给函数，咱们能够传递任意多个关键字参数，并在函数外部以字典的模式进行解决。 ...

可能的两个相干起因主机的某个文件系统短少磁盘空间， 或者内存信号量相干的短少查看文件系统是否短少磁盘空间df -k 查看磁盘空间，察看是否有100%使用率的文件系统，留神/tmp 文件系统咱们过后是在docker 容器中，发现/dev/shm 100%的使用率查看信号量相干的短少通过ipcs -u -s 来查看以后应用的信号量状况ipcs -l 查看默认配置参数状况通过定位，咱们发现是k8s 的docker 容器中/dev/shm 文件系统使用率100%通过挂在/dev/shm 文件夹即可解决办法

在 Python 中，魔法办法是指那些以双下划线结尾和结尾的非凡办法。它们是 Python 的内置办法，对应于 Python 对象的各种运算符。通过实现这些魔法办法，咱们能够扭转 Python 对象的行为。这篇文章将深入探讨 Python 的一些魔法办法，并通过示例展现如何应用它们。 一、结构和初始化__new__ 和 __init__ 是 Python 对象生命周期的开始。__new__ 办法是在一个对象实例化的时候所调用的第一个办法，在调用 __init__ 初始化前，先调用 __new__。 class MyClass: def __new__(cls, *args, **kwargs): print('Instance is created') instance = super().__new__(cls) return instance def __init__(self, name): print('Instance is initialized') self.name = nameobj = MyClass('MyClass') # 输入：Instance is created Instance is initialized二、字符串示意__str__ 和 __repr__ 都是用于显示的魔法办法。__str__ 是敌对易读的形式出现，而 __repr__ 是精确、无歧义地表达出来，次要供开发和调试时应用。 class MyClass: def __init__(self, name): self.name = name def __str__(self): return f'Instance of MyClass with name {self.name}' def __repr__(self): return f'MyClass(name={self.name})'obj = MyClass('MyClass')print(str(obj)) # 输入：Instance of MyClass with name MyClassprint(repr(obj)) # 输入：MyClass(name=MyClass)三、算术运算符魔法办法还能够用来定义对象的算术运算行为，例如 __add__、__sub__、__mul__ 等。 ...

冒泡排序（Bubble Sort）是一种简略且经典的排序算法，在初学者学习算法时通常是首选的算法之一。它的原理简略易懂，通过屡次比拟和替换相邻元素的地位来实现排序。本文将从入门到精通，具体介绍冒泡排序的算法原理，并提供相干的代码示例。 一、冒泡排序算法原理冒泡排序算法的核心思想是从待排序的元素中一一比拟相邻的两个元素，如果它们的程序不符合要求（比方升序排序时，前一个元素大于后一个元素），就将它们替换地位，直到所有元素都排好序。冒泡排序的过程能够类比水中的冒泡景象，大的元素会逐步"浮"到数组的开端，而小的元素则会"沉"到数组的后面。冒泡排序的具体步骤如下： 从第一个元素开始，比拟相邻的两个元素。如果程序不符合要求，则替换它们的地位。持续比拟下一对相邻元素，反复上述步骤，直到最初一对相邻元素。反复执行上述步骤，直到没有须要替换的元素，即数组曾经排序实现。冒泡排序的工夫复杂度为O(n^2)，其中n是待排序数组的长度。它是一种稳固的排序算法，实用于小规模的数组。 二、冒泡排序的示例代码上面是应用Python实现冒泡排序的示例代码： def bubble_sort(arr): n = len(arr) for i in range(n - 1): for j in range(n - i - 1): # 比拟相邻的两个元素 if arr[j] > arr[j + 1]: # 如果程序不符合要求，替换它们的地位 arr[j], arr[j + 1] = arr[j + 1], arr[j] # 测试冒泡排序arr = [64, 34, 25, 12, 22, 11, 90]bubble_sort(arr)print("排序后的数组：", arr)在上述代码中，咱们定义了一个名为bubble_sort的函数，它承受一个待排序的数组作为参数。通过嵌套的循环，应用了两个索引i和j来遍历数组，并比拟相邻的两个元素。如果它们的程序不符合要求，则替换它们的地位。在示例代码中，咱们给定了一个待排序的数组arr，而后调用bubble_sort(arr)来对数组进行排序。最初，咱们打印排序后的数组。 三、优化冒泡排序只管冒泡排序是一个简略的算法，但在解决大规模数据时，它的效率并不高。因而，咱们能够对冒泡排序进行一些优化，以缩小比拟和替换的次数。 优化1：提前结束循环在每一趟的冒泡过程中，如果没有产生任何元素的替换，阐明数组曾经有序，能够提前结束排序过程。 def bubble_sort(arr): n = len(arr) for i in range(n - 1): swapped = False for j in range(n - i - 1): if arr[j] > arr[j + 1]: arr[j], arr[j + 1] = arr[j + 1], arr[j] swapped = True # 如果没有产生替换，阐明数组曾经有序，提前结束排序 if not swapped: break优化2：记录最初一次替换的地位在每一趟的冒泡过程中，最初一次替换的地位之后的元素曾经有序，下一趟排序时无需再比拟这些元素。 ...

collections模块是Python的内建模块之一，它实现了非凡的容器数据类型，提供了Python内建的数据类型dict、list、set、和tuple的高效替代选择。 一、namedtuplenamedtuple() 函数是一个工厂函数，它返回一个子类，这个子类继承自 tuple 类，并且领有名字，这个名字就是你传给 namedtuple() 的第一个参数。这个子类的实例就像一个一般的元组，然而还提供了不便的属性拜访。namedtuple是一种定义小型和不可变的数据类的简略办法。 from collections import namedtuple# 创立一个namedtuple类型User，并蕴含name和age两个属性。User = namedtuple('User', ['name', 'age'])# 创立一个User对象user = User(name='user1', age=23)print(user.name) # 输入：user1print(user.age) # 输入：23二、dequedeque（双向队列）是一种来自 collections 模块的容器，它提供了从左端和右端高效、疾速地增加和删除元素的性能。 from collections import deque# 创立一个dequed = deque(['a', 'b', 'c'])# 从右端增加元素d.append('d') # d当初是deque(['a', 'b', 'c', 'd'])# 从左端增加元素d.appendleft('e') # d当初是deque(['e', 'a', 'b', 'c', 'd'])# 从右端删除元素d.pop() # 返回 'd', d当初是deque(['e', 'a', 'b', 'c'])# 从左端删除元素d.popleft() # 返回 'e', d当初是deque(['a', 'b', 'c'])三、Countercollections模块的Counter类是一个简略的计数器，例如，它能够用来统计字符的个数： from collections import Counterc = Counter('hello world') # 从一个可迭代对象创立print(c) # 输入 Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})Counter对象有一个有用的办法most_common(n)，该办法返回计数最多的n个元素的列表，每个元素是一个元组，元组的第一个元素是元素自身，第二个元素是元素的计数。 ...

一、简介Moviepy是一个用于解决视频的Python第三方库。它提供了简略易用的接口，能够进行视频剪辑、合并、转码以及增加各种成果等操作。本文将介绍如何应用Moviepy库来进行视频剪辑的基本操作。 二、装置Moviepy在开始之前，咱们须要先装置Moviepy库。能够应用pip命令进行装置： pip install moviepy三、导入Moviepy在应用Moviepy之前，咱们须要先导入该库。应用以下代码导入Moviepy： from moviepy.editor import *四、加载视频文件在进行视频剪辑之前，首先须要加载视频文件。Moviepy反对多种视频格式，包含常见的MP4、AVI等格局。应用以下代码能够加载视频文件： video = VideoFileClip("input.mp4")这里的input.mp4是待处理的视频文件名。确保该视频文件与代码文件在同一目录下，或者指定正确的文件门路。 五、剪辑视频接下来，咱们能够对视频进行剪辑操作。比方，能够截取视频的某个时间段作为新的视频片段。应用以下代码能够实现剪辑操作： # 定义剪辑的起始和完结工夫（以秒为单位）start_time = 10end_time = 30# 对视频进行剪辑clipped_video = video.subclip(start_time, end_time)这段代码中，咱们通过设置start_time和end_time变量来定义剪辑的起始和完结工夫。而后，应用subclip()办法对视频进行剪辑，生成一个新的视频片段clipped_video。 六、增加文字和音乐除了剪辑视频，Moviepy还反对在视频中增加文字和音乐。以下代码演示了如何在视频中增加文字和音乐： # 增加文字text = TextClip("Hello, World!", fontsize=30, color='white')text = text.set_position('center').set_duration(5)# 增加音乐audio = AudioFileClip("music.mp3").subclip(0, 5)# 将文字和音乐增加到视频中final_video = CompositeVideoClip([clipped_video, text])final_video = final_video.set_audio(audio)在这段代码中，咱们首先创立一个文字剪辑text，并设置其内容、字体大小和色彩。而后，通过set_position()办法将文字设置在视频核心，并设置其显示时长为5秒。接着，咱们加载音乐文件music.mp3，并应用subclip()办法截取音乐的前5秒。最初，应用CompositeVideoClip()将剪辑后的视频和文字剪辑合成为一个新的视频final_video，并应用set_audio()办法将音乐增加到该视频中。 七、导出视频实现视频剪辑后，咱们能够将最终的视频导出为文件。应用以下代码能够将视频导出为指定格局的文件： # 导出视频final_video.write_videofile("output.mp4")这段代码将最终的视频保留为output.mp4文件。你能够依据须要批改文件名和输入格局。 八、残缺代码示例from moviepy.editor import *# 加载视频文件video = VideoFileClip("input.mp4")# 定义剪辑的起始和完结工夫（以秒为单位）start_time = 10end_time = 30# 对视频进行剪辑clipped_video = video.subclip(start_time, end_time)# 增加文字text = TextClip("Hello, World!", fontsize=30, color='white')text = text.set_position('center').set_duration(5)# 增加音乐audio = AudioFileClip("music.mp3").subclip(0, 5)# 将文字和音乐增加到视频中final_video = CompositeVideoClip([clipped_video, text])final_video = final_video.set_audio(audio)# 导出视频final_video.write_videofile("output.mp4")九、结语通过Moviepy库，咱们能够不便地进行视频剪辑、增加文字和音乐等操作。本文介绍了Moviepy库的根本应用办法，心愿对你在Python中解决视频有所帮忙。你能够依据理论需要，进一步摸索Moviepy库的其余性能和个性。 ...

你好，我是猫哥。这里每周分享优质的 Python 及通用技术内容，局部为英文，已在小标题注明。（题目取自其中一则分享，不代表全部内容都是该主题，特此申明。） 首发于我的博客：https://pythoncat.top/posts/2023-06-24-weekly 文章&教程Python 3.13 版本的打算 (英)Faster CPython 我的项目（即香农打算）有了对于 3.13 版本的最新打算，这次的性能指标是缩小解释器 50% 的耗时。涵盖三项次要工作：第 2 层的优化器、启用子解释器（PEP-554）、内存治理。 为什么 Numpy 并行性很重要？ (英)Numpy 是作科学计算和数据分析的最重要的库之一，并行性是晋升其性能的重要伎俩。文章介绍了 5 种能够实现 Numpy 并行性的场景和办法：加载/保留 Numpy 数组数据、高效地计算数学函数、高效地初始化数组、并行执行数组的元素级数学运算、在过程间高效共享 Numpy 数组数据。 用少于 100 行的 Rust 使 Python 变快 100 倍 (英)文章针对一个有性能问题的 Python 库，应用 Rust 重写并作了三轮优化后，晋升了性能 100 倍。文中应用了 py-spy 库绘制火焰图，剖析出了代码的瓶颈点，并以此作为优化的根据，能够看到前后火焰图的差异很大。 将 Python 我的项目移植到 Rust (英)文章指出“一步到位的移植”形式存在一些问题，从而提出“迭代式移植”的办法，并给出了一个代码示例。 设计 Pythonic 的库 API (英)如何设计出一个 Pythonic 的 API？在设计上有什么办法和根本准则呢？文章从代码构造、变量命名、错误处理、版本控制、类型注解等方面，给出了十分具体的介绍。文章较长，最初总结出 18 条 takeaways。 编译类型化的 Python (英)Python 已反对类型提醒，那是否编译 Python 代码为本地代码以晋升性能呢？尽管类型提醒能够提供一些性能优化，但因为 Python 的动静个性和灵活性，使得动态剖析和编译十分艰难。因而目前还没有一种办法能够将 Python 代码编译成本地代码以进步性能。 ...

一、引言Python 装璜器在很多状况下是一个十分有用的工具，它们能够用于批改或加强函数或类的行为。咱们曾经相熟了应用函数作为装璜器，然而你晓得咱们也能够应用类作为装璜器吗？本篇文章将深入探讨如何在 Python 中应用类装璜器。 二、什么是类装璜器？类装璜器就是应用类来实现的装璜器。它们通常通过在类中定义 __call__ 办法来实现。当咱们应用 @ 语法利用装璜器时，Python 会调用装璜器类的 __init__ 办法创立一个实例，而后将被装璜的函数或类作为参数传递给 __init__ 办法。当被装璜的函数或办法被调用时，Python 会调用装璜器实例的 __call__ 办法。 上面是一个根本的类装璜器的例子： class MyDecorator: def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): print("Before call") result = self.func(*args, **kwargs) print("After call") return result@MyDecoratordef hello(): print("Hello, world!")hello()在这个例子中，MyDecorator 类的实例被创立并传入 hello 函数作为参数。当咱们调用 hello 时，实际上是在调用 MyDecorator 实例的 __call__ 办法。 三、类装璜器的劣势相比函数装璜器，类装璜器有几个次要劣势。 更好的组织：类装璜器能够利用 Python 的面向对象个性，将相干的办法和数据封装在一起，这使得代码更易于了解和保护。更大的灵活性：类装璜器能够利用继承来复用和扩大代码。例如，你能够创立一个根底的装璜器类，而后通过继承这个类来创立特定的装璜器。更好的管制：类装璜器能够应用实例变量来保留状态。这在一些须要保留状态的装璜器（例如计数器或缓存）中十分有用。四、应用类装璜器接下来咱们来看一个更简单的例子，这个例子中的类装璜器用于计算函数的执行工夫： import timeclass TimerDecorator: def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): start_time = time.time() result = self.func(*args, **kwargs end_time = time.time() print(f"Function {self.func.__name__} took {end_time - start_time} seconds to run.") return result@TimerDecoratordef slow_function(): time.sleep(2)slow_function()在这个例子中，TimerDecorator 类的 __call__ 办法计算了 slow_function 函数执行的工夫。这是通过记录函数开始执行和完结执行的工夫，而后计算差值来实现的。这种计算函数执行工夫的装璜器在性能调优时十分有用。 ...

1. 逻辑运算符# 逻辑运算符多用于判断# == 等于# 判断是否成立# Falseprint(1 == 2)# < 小于# 判断是否成立# Trueprint(1 < 2)# > 大于# 判断是否成立# Falseprint(1 > 2)# <= 小于等于# 判断是否成立# Trueprint(1 <= 2)# >= 大于等于# 判断是否成立# Falseprint(1 >= 2)# 与或非 逻辑运算符# and 与# and两边的条件必须都成立为True,否则为False# input_user == user and input_password == password# or 或# or两边的条件只须要其中一个成立就能够了# input_user == user or input_phone == phone# not 取反# 运算符优先级# 优先级从上到下顺次递加# ** 幂运算# 打印# 8print(2**3)# + - 一元运算符(正负号)# 正号（+） 不会对数字产生任何影响# 1print(+1)# 减号（-） 能够对数字进行负号的取反# -1print(-1)# % / * 算术运算符# % 取余# 1print(10 % 3)# / 除# 3.1print(9.3 / 3)# * 乘# 9print(3 * 3)# + - 算术运算符# + 加# 2print(1 + 1)# - 减# 3print(5 - 2)# < > <= >= == !=# < 小于# Trueprint(1 < 2)# > 大于# Falseprint(1 > 2)# <= 小于等于# Trueprint(2 <= 3)# >= 大于等于# Falseprint(2 >= 3)# == 恒等于# Trueprint(2 == 2)# != 不等于# Falseprint(2 != 2)# = /= -= += *= %= **= //= 赋值运算符# a = b 赋值# a /= b 等价于a = a / b# a -= b 等价于a = a - b# a += b 等价于a = a + b# a *= b 等价于a = a * b# a %= b 等价于a = a % b# a **= b 等价于a = a ** b# a //= b 等价于a = a // b 整数除法# is is not 身份运算符# 用于比拟两个对象的内存地址是否统一# 赋值num_1 = "hello world"num_2 = "hello world"# 打印内存地址# 1592544406832print(id(num_1))# 1592544406832print(id(num_2))# Trueprint(num_1 is num_2)# Falseprint(num_1 is not num_2)# in not in 成员运算符# 赋值num_3 = ["hello", "world", "i", "love", "python"]# 判断# Trueprint("world" in num_3)# 判断# Falseprint("world" not in num_3)# not > and > or 逻辑运算符2. 格式化拼接"""格式化拼接(4)+joinformat% %s 代表 字符串 (罕用) %d 代表 整数 (理解) %f 代表 浮点数 (理解)"""# 格式化拼接# 赋值num_1 = "hello"num_2 = "world"# +# 打印# hello worldprint(num_1 + " " + num_2)# join# 打印# hello world pythonprint(" ".join([num_1, num_2, "python"]))# format# 打印# hello world# print("{} {}".format(num_1, num_2))# 也能够这样用# hello worldprint(f"{num_1} {num_2}")# %# 打印# name:qi age:18 height:1.730000print("name:%s age:%d height:%f" % ("qi", 18, 1.73))# 字符串的格式化# 打印# 2.300000print("%f" % 2.3)# %.2f 保留两位小数 五舍六入# 2.30print("%.2f" % 2.3)# %6.2f 总共位数变成6# 2.30print("%6.2f" % 2.3)# num=%6.2f 后面能够加值# 2.30print("num_3=%6.2f" % 2.3)# 保留两位小数# 12.33print('{:.2f}'.format(12.333))# 赋值# 12.33print('{num_4:.2f}'.format(num_4=12.333))# 用即显示，不必则不显示# 12.33print('{num_5:.2f}'.format(num_5=12.333, num=13.444))# 十进制(20)转换为八进制# 24print('{:o}'.format(20))# 十进制(20)转换为十六进制# 14print('{:x}'.format(20))3. 字节类型"""罕用于传输"""# 赋值num = b"hello"# 查看类型# <class 'bytes'>print(type(num))4. 数组# 赋值num = "人生苦短 我用python"# 把中文转换成字节类型# bytearray 数组li = bytearray(num.encode())# 打印# bytearray(b'\xe4\xba\xba\xe7\x94\x9f\xe8\x8b\xa6\xe7\x9f\xad \xe6\x88\x91\xe7\x94\xa8python')print(li)5. 解码和编码"""encode() 编码decode() 解码编码格局 utf-8 (罕用) unicode 万国码 每三个字节对应一个字符 中国人用的 GPK 每两个字节对应一个字符"""# 编码# 括号里不带编码格局，默认 utf-8# 括号里带编码格局，就必须以编码格局解码 不区别大小写# 赋值num_1 = "星越科技".encode()# 打印# b'\xe6\x98\x9f\xe8\xb6\x8a\xe7\xa7\x91\xe6\x8a\x80'print(num_1)# 解码num_2 = num_1.decode()# 打印# 星越科技print(num_2)# 用gbk编码，utf-8解码会报错# 用utf-8编码，gbk解码会乱码# 赋值num_3 = "星越科技".encode('UTF-8')print(num_3)# 解码# 鏄熻秺绉戞妧print(num_3.decode('gbk'))6. 进制转换# 赋值num = 99# 10进制转2进制# 0b1100011print(bin(num))# 优化# 1100011print(bin(num)[2:])# 10进制转8进制# 0o143print(oct(num))# 优化# 143print(oct(num)[2:])# 10进制转16进制# 0x63print(hex(num))# 优化# 63print(hex(num)[2:])

Python 是一门功能强大的编程语言，但在解决大规模数据或简单计算工作时，性能可能成为一个瓶颈。侥幸的是，Python 提供了多种办法来晋升性能，其中之一是利用并行处理来减速循环操作。本文将介绍如何应用并行处理技术来优化 for 循环，从而进步 Python 程序的执行速度。咱们将探讨并行处理的概念、罕用的并行处理库以及示例代码来演示如何利用并行处理来减速 for 循环。一、什么是并行处理在计算机科学中，"并行处理" 是指同时执行多个工作或操作的技术。它利用多个处理单元或线程来并发执行工作，从而进步程序的执行速度。在 Python 中，咱们能够利用多线程、多过程或异步编程等技术来实现并行处理。 二、罕用的并行处理库Python 提供了多个并行处理库，其中一些罕用的库包含： multiprocessing：这个内置库提供了跨平台的多过程反对，能够应用多个过程并行执行工作。threading：这个内置库提供了多线程反对，能够在同一过程内应用多个线程并行执行工作。concurrent.futures：这个规范库提供了高级的并行处理接口，能够应用线程池或过程池来治理并发工作的执行。joblib：这是一个风行的第三方库，提供了简略的接口来并行执行 for 循环，尤其实用于科学计算和机器学习工作。dask：这是一个灵便的第三方库，提供了并行处理和分布式计算的性能，实用于解决大规模数据集。在本文中，咱们将重点关注 multiprocessing 和 joblib 这两个库来进行示范。 三、并行处理 for 循环的示例代码为了演示如何应用并行处理技术来减速 for 循环，咱们将采纳一个简略的示例场景：计算一个列表中每个元素的平方值，并将后果存储在新的列表中。 应用 multiprocessing 进行并行处理import timeimport multiprocessingdef square(num): time.sleep(1) # 模仿耗时的计算操作 return num ** 2if __name__ == '__main__': numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 一般的 for 循环 start_time = time.time() results = [] for num in numbers: results.append(square(num)) end_time = time.time() print("一般的 for 循环工夫：", end_time - start_time) # 并行处理 start_time = time.time() pool = multiprocessing.Pool() results = pool.map(square, numbers) pool.close() pool.join() end_time = time.time() print("并行处理工夫：", end_time - start_time)在上述代码中，咱们定义了一个 square 函数，用于计算给定数字的平方。而后，咱们创立了一个 multiprocessing.Pool 对象，它治理了一个过程池。通过调用 pool.map 办法，咱们将 square 函数利用到 numbers 列表的每个元素上，并应用多个过程并行执行。最初，咱们取得了计算结果并打印输出。输入成果： ...

散列类型"""汇合 set 符号: {} (为空则是字典) 转换形式: set() 可变类型字典 dict 符号: {} (键值对) 表现形式: {"key": "value"} 转换形式: set() 可变类型"""汇合1. 汇合的定义"""汇合的三大个性无序性 汇合里的各个元素是不须要辨别程序的，不能以索引取值互同性 一个给定的汇合里的元素是互不雷同的，汇合中不会有反复的元素，可用于去重确定性 给定的汇合，它的元素必须是确定的，元素不能是可变类型"""# 赋值num = [1, 1, 2, 3, 3, 9, 4, 5, 66, 7, 7, 9]# 去重 先转换为汇合，利用汇合个性去重，再转换为列表num_1 = list(set(num))# 打印# {1, 2, 3, 4, 5, 66, 7, 9}print(num_1)2. 汇合的三种运算"""交加 s1 & s2并集 s1 | s2差集 s1 - s2"""# 赋值s_1 = {1, 2, 3, 4, 5, 6}s_2 = {4, 5, 6, 7, 8, 9}# 交加# 打印相交的局部# {4, 5, 6}print(s_1 & s_2)# 并集# 打印相交的局部# {1, 2, 3, 4, 5, 6, 7, 8, 9}print(s_1 | s_2)# 赋值s_3 = {1, 2, 3, 4, 5, 6}s_4 = {4, 5, 6}# 差集# 打印相交的局部# {1, 2, 3}print(s_1 - s_2)汇合的办法增# add 将元素增加到汇合中# 汇合内只能增加不可变类型# 赋值s_1 = {1, 2, 3, 4, 5}# 增加数据s_1.add("hello")# 打印# {1, 2, 3, 4, 5, 'hello'}print(s_1)删# pop 删除并返回任意set元素# 赋值s_1 = {1, 2, 3, 4, 5}# 打印# 1print(s_1.pop())# {2, 3, 4, 5}print(s_1)# 赋值s_2 = {1, 2, 3, "hello", 4, 5, 6}# remove 删除指定的元素s_2.remove("hello")# 打印# {1, 2, 3, 4, 5, 6}print(s_2)改# update 用自身和其它元素的并集更新汇合# 相当于是增加，只能增加可迭代对象# 赋值s_1 = {1, 2, 3, 4, 5}# 更新汇合s_1.update({7, 8, 9, 0})# 打印# {0, 1, 2, 3, 4, 5, 7, 8, 9}print(s_1)查# isdisjoint 判断两个汇合的交点是否为空# 赋值s_1 = {1, 2, 3, 4, 5}s_2 = {7, 8, 9, 0}# 打印判断后果# Trueprint(s_1.isdisjoint(s_2))# 赋值s_3 = {1, 2, 3, 4, 5}s_4 = {1, 2, 3}# issubset 子类汇合 判断另一个汇合是否蕴含该汇合# 判断s_3是s_4的子集汇合# Falseprint(s_3.issubset(s_4))# issuperset 父类汇合 判断另一个汇合是否蕴含该汇合# 判断s_3是s_4的父集汇合# Trueprint(s_3.issuperset(s_4))字典"""字典key值有唯一性 key值不能为可变类型字典也是无序性"""# 赋值num = {"name": "qi", "age": "20", "sex": "man"}# 取值# qiprint(num["name"])# 查看类型# <class 'dict'>print(type(num))字典的办法增# 赋值 {"key": "value"}num = {"name": "qi"}# 打印原字典# {'name': 'qi'}print(num)# setdefault 有则查key值所对应的value值，无则增# 有则查# 增加数据num_1 = num.setdefault("name")# 打印# qiprint(num_1)# 无则增# 办法一# 只增加key值 value值为None# 增加数据num_2 = num.setdefault("age")# 打印# Noneprint(num_2)# 打印# {'name': 'qi', 'age': None}print(num)# 办法二# 增加字典 增加key值及key值所对应的value值# 增加数据num_3 = num.setdefault("sex", "man")# 打印# manprint(num_3)# 打印# {'name': 'qi', 'age': None, 'sex': 'man'}print(num)删# 赋值num = {'name': 'qi', 'age': 18, 'sex': 'man'}# pop 查出指定key的键值对# 删除key值及key值所对应的value值 用完再删# 18print(num.pop("age"))# 打印# {'name': 'qi', 'sex': 'man'}print(num)# 赋值num_2 = {'name': 'qi', 'age': 18, 'sex': 'man', "job": "python工程师"}# popitem 返回并删除字典中的最初一对键值对# 删除key值及key值所对应的value值 用完再删# ('job', 'python工程师')print(num_2.popitem())# 打印# {'name': 'qi', 'age': 18, 'sex': 'man'}print(num_2)# clear 清空# 赋值num_3 = {'name': 'qi', 'age': 18, 'sex': 'man'}# 清空数据num_3.clear()# 打印# {}print(num_3)改# 赋值num = {'name': 'qi', 'age': None}# update 有则改，无则增# 有则改# 改变数据num.update({"age": 18})# 打印# {'name': 'qi', 'age': 18}print(num)# 无则增# 减少数据num.update({"sex": "man"})# 打印# {'name': 'qi', 'age': 18, 'sex': 'man'}print(num)查# 赋值num = {"name": "qi", "age": "20", "sex": "man"}# get 获取指定key对应的value值，key不存在则返回None# 打印# qiprint(num.get("name"))# keys 取出所有的key# 打印# dict_keys(['name', 'age', 'sex'])print(num.keys())# 转换为列表# ['name', 'age', 'sex']print(list(num.keys()))# values 取出所有的value# 打印# dict_values(['qi', '20', 'man'])print(num.values())# 转换为列表# ['name', 'age', 'sex']print(list(num.keys()))# items 取出所有的键对值# 打印# dict_items([('name', 'qi'), ('age', '20'), ('sex', 'man')])print(num.items())# 转换为列表# [('name', 'qi'), ('age', '20'), ('sex', 'man')]print(list(num.items()))字典索引key与字典get办法的区别 ...

Python中的偏函数是来自函数式编程的一个弱小工具，它的次要指标是缩小函数调用的复杂性。这个概念可能起初看起来有点艰难了解，但一旦你明确了它的工作形式，它可能会成为你的编程工具箱中的重要组成部分。 一、什么是偏函数？在计算机科学中，偏函数是固定一个函数的一些参数，而后生成一个新的函数的行为。偏函数的概念能够用来简化函数的复杂性，让咱们可能复用已有的函数然而不须要扭转它们的实现。 举一个简略的例子，咱们有一个函数 multiply(x, y)，这个函数承受两个参数 x 和 y，返回他们的乘积。 def multiply(x, y): return x * y咱们能够应用偏函数来创立一个新的函数，比方 double(x)，这个函数将 y 参数固定为 2： from functools import partialdouble = partial(multiply, y=2)print(double(3)) # Output: 6在这个例子中，咱们创立了一个新的函数 double(x)，这个函数实际上是函数 multiply(x, y) 的一个偏函数版本，其中 y 被固定为 2。 二、如何创立偏函数？在Python中，咱们能够应用 functools 模块中的 partial 函数来创立偏函数。partial 函数承受一个函数作为第一个参数，而后承受任意数量的地位参数或关键字参数。这些参数将被用来事后填充到新的偏函数中。 以下是如何应用 partial 函数来创立偏函数的一个例子： from functools import partialdef power(base, exponent): return base ** exponentsquare = partial(power, exponent=2)print(square(3)) # Output: 9在这个例子中，咱们首先定义了一个名为 power(base, exponent) 的函数，而后咱们应用 partial 函数来创立一个新的偏函数 square，在这个偏函数中，exponent 参数被固定为 2。 ...

一、介绍蔬菜识别系统，应用Python作为次要开发语言，基于深度学习TensorFlow框架，搭建卷积神经网络算法。并通过对数据集进行训练，最初失去一个辨认精度较高的模型。并基于Django框架，开发网页端操作平台，实现用户上传一张图片辨认其名称。 二、成果图片 三、演示视频+代码视频+残缺代码：https://www.yuque.com/ziwu/yygu3z/uc1z9asdufhe1co7 四、TensorFlow图像分类示例TensorFlow是由Google开发的开源机器学习框架，广泛应用于深度学习工作。它提供了一套丰盛的工具和库，使得构建、训练和部署深度学习模型变得更加简略和高效。TensorFlow基于数据流图的概念，应用图来示意计算过程中的数据流动。它的外围是张量（Tensor），是多维数组的形象，能够在计算图中流动。在进行图像识别分类之前，咱们须要筹备训练数据。通常状况下，咱们须要一个蕴含训练图像和对应标签的数据集。TensorFlow提供了一些便捷的工具来加载和解决图像数据。以下是一个加载图像数据集的示例代码： import tensorflow as tffrom tensorflow.keras.preprocessing.image import ImageDataGenerator# 定义数据集门路train_dir = 'train/'val_dir = 'validation/'# 设置图像预处理参数train_datagen = ImageDataGenerator(rescale=1./255, rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)val_datagen = ImageDataGenerator(rescale=1./255)# 加载训练数据集train_generator = train_datagen.flow_from_directory(train_dir, target_size=(224, 224), batch_size=32, class_mode='categorical')# 加载验证数据集val_generator = val_datagen.flow_from_directory(val_dir, target_size=(224, 224), batch_size=32, class_mode='categorical')在上述代码中，咱们应用ImageDataGenerator来定义图像的预处理参数，并通过flow_from_directory办法从目录中加载数据集。在TensorFlow中，咱们能够应用Keras API来构建图像识别分类模型。Keras提供了一系列不便易用的层和模型，能够帮忙咱们疾速构建深度学习模型。以下是一个应用Keras构建图像分类模型的示例代码： from tensorflow.keras.applications import VGG16from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Dense, Flatten# 加载预训练的VGG16模型base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))# 解冻预训练模型的权重for layer in base_model.layers: layer.trainable = False# 构建分类模型model = Sequential()model.add(base_model)model.add(Flatten())model.add(Dense(256, activation='relu'))model.add(Dense(10, activation='softmax'))# 编译模型model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])在上述代码中，咱们应用了VGG16作为预训练的模型，并在其根底上构建了一个全连贯层分类模型。 ...

Python中的列表（list）是一种罕用的数据结构，用于存储多个元素。列表是可变的、有序的，并且能够包容任意类型的数据。本文将具体介绍Python列表的应用办法，并提供相干的代码示例。 一、创立列表能够应用方括号[]或者应用list()函数来创立一个空列表，或者在创立时间接指定列表中的元素。 # 创立一个空列表empty_list = []empty_list = list()# 创立一个蕴含元素的列表fruits = ['apple', 'banana', 'orange']numbers = [1, 2, 3, 4, 5]列表中的元素能够是任意类型，包含数字、字符串、布尔值、甚至其余列表等。 二、拜访和批改列表元素能够应用索引来拜访和批改列表中的元素，列表的索引从0开始。 fruits = ['apple', 'banana', 'orange']# 拜访列表元素print(fruits[0]) # 输入：'apple'print(fruits[1]) # 输入：'banana'# 批改列表元素fruits[2] = 'grape'print(fruits) # 输入：['apple', 'banana', 'grape']列表也反对负索引，示意从列表开端开始倒数的地位。 fruits = ['apple', 'banana', 'orange']print(fruits[-1]) # 输入：'orange'print(fruits[-2]) # 输入：'banana'三、列表的切片操作能够应用切片操作来获取列表中的一部分元素，切片操作应用[start:stop:step]的语法。 numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]# 获取前三个元素print(numbers[:3]) # 输入：[1, 2, 3]# 获取索引1到索引4之间的元素print(numbers[1:5]) # 输入：[2, 3, 4, 5]# 获取从索引2开始的所有偶数print(numbers[2::2]) # 输入：[3, 5, 7, 9]切片操作返回一个新的列表，不会批改原始列表。 ...

字符串1. 增# 赋值num_1 = "hello"num_2 = "world"# join 连贯任意数量的字符串num = '+'.join([num_1, num_2])# 打印后果# hello+worldprint(num)2. 删# 赋值num = " hello world "# 删除空格 ' ' != ''# helloworldprint(num.replace(' ', ''))# 把空格替换为0# 00hello0world00print(num.replace(' ', '0'))# 删除字符o# hell wrldprint(num.replace('o', ''))# 间断删除# hellwrldprint(num.replace('o', '').replace(' ', ''))3. 改# 赋值num = "hello world"# upper 把所有的字母转换为大写# HELLO WORLDprint(num.upper())# 赋值num_1 = "HELLO WORLD"# lower 把所有的字母转换为小写# hello worldprint(num_1.lower())# 赋值num_2 = " hello world "# strip 除去结尾和结尾的空格# hello worldprint(num_2.strip())# 赋值num_3 = " hello world"# lstrip 除去结尾的空格# hello worldprint(num_3.lstrip())# 赋值num_4 = "hello world "# rstrip 除去结尾的空格# hello worldprint(num_4.rstrip())# 赋值num_5 = "hello world"# capitalize 首字母大写# Hello worldprint(num_5.capitalize())# 赋值num_6 = "hello world"# title 每个单词的首字母大写# Hello Worldprint(num_6.title())# 赋值num_7 = "hello world"# split 切割# 括号里为空时，按空格切割# ['hello', 'world']print(num_7.split())# 括号里为字符时，按字符切割# ['hell', ' w', 'rld']print(num_7.split('o'))# 赋值num_8 = " hello world "# 括号里为空时，按空格切割# ['hello', 'world']print(num_8.split())4. 查# 赋值num = "hello world"# find 如果查找的字符在字符串中，就返回找到的第一个元素的索引值，没有找到返回-1# 2print(num.find('l'))# index 返回字符所对应的索引值，没有找到该字符就报错# 4print(num.index('o'))# isdigit 判断一个字符串里的数据是不是全部都是数字# Falseprint(num.isdigit())# 赋值num_1 = "helloworld"# isalpha 判断一个字符串里的数据是不是全部都是字母# Trueprint(num_1.isalpha())# islower 判断字符串中的值是否全副是小写# Trueprint(num_1.islower())# isupper 判断字符串中的值是否全副是大写# Falseprint(num_1.isupper())# endswith 比拟结尾的元素是否雷同# Trueprint(num.endswith('ld'))# startswith 比拟结尾的元素是否雷同# Falseprint(num.startswith('ne'))其它办法num = "hello world"# dir() 查看字符串类型的办法名# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']print(dir(num))2. 列表1. 增# 赋值li = ['h', 'e', 'l']# append 将一个元素追加到开端# 不能增加多个# 增加数据li.append("qi")# 打印# ['h', 'e', 'l', 'qi']print(li)# 增加数据li.append("九")# 打印# ['h', 'e', 'l', 'qi', '九']print(li)# 赋值li_1 = ['h', 'e', 'l', 'l']# insert 增加到指定地位# 通过索引增加 不能增加多个# 增加数据li_1.insert(0, "hello")# 打印# ['hello', 'h', 'e', 'l', 'l']print(li_1)# 赋值li_2 = ['h', 'e', 'l', 'l', 'o']# extend 将序列中的每个元素追加到开端# 不能增加多个# 增加数据li_2.extend([1, 2, 3])# 打印# ['h', 'e', 'l', 'l', 'o', 1, 2, 3]print(li_2)# 赋值num_1 = [1, 2, 3]num_2 = [4, 5, 6]# 拼接列表# [1, 2, 3, 4, 5, 6]print(num_1 + num_2)2. 删# 赋值li = ['h', 'e', 'l', 'l', 'o']# pop用法一# 删除数据 括号里为空，默认删除最初一个元素li.pop()# 打印# ['h', 'e', 'l', 'l']print(li)# pop用法二# 赋值li_1 = ['p', 'y', 't', 'h', 'o', 'n']# 删除数据 括号里有索引参数，删除索引值所对应的元素li_1.pop(1)# 打印# ['p', 't', 'h', 'o', 'n']print(li_1)# pop用法三# 赋值li_2 = ['w', 'o', 'r', 'l', 'd']# 删除数据 间接用print,用完再删# dprint(li_2.pop())# 打印# ['w', 'o', 'r', 'l']print(li_2)# 赋值li_3 = ['a', 'b', 'c', 'e', 'f']# remove 间接删除元素 有雷同的元素时，优先删除索引值靠前的元素li_3.remove("c")# 打印# ['a', 'b', 'e', 'f']print(li_3)# 赋值li_4 = ['a', 'b', 'c', 'e', 'f', 'g', 'h']# clear 清空列表中所有的元素li_4.clear()# 打印# []print(li_4)# 赋值li_5 = ['a', 'b', 'c', 'e', 'f', 'g']# del 通过索引值删除所对应的元素del li_5[2]# 打印# ['a', 'b', 'e', 'f', 'g']print(li_5)3. 改# 赋值li = ['a', 'b', 'c', 'e', 'd', 'f']# 办法一# 批改数据 批改索引值所对应的元素li[1] = "hello"# 打印# ['a', 'hello', 'c', 'e', 'c', 'f']print(li)# 办法二# 赋值li_1 = ['a', 'b', 'c', 'e', 'd']# 批改数据 先查找到元素对应的索引值，再批改索引值所对应的元素li_1[li_1.index('e')] = "hello"# 打印# ['a', 'b', 'c', 'hello', 'd']print(li_1)4. 查# 赋值li = ['a', 'b', 'c', 'e', 'c', 'f']# index 通过元素查找所对应的索引值 没有元素会报错# 有雷同的元素时，优先查找元素靠前的索引值# 2print(li.index('c'))# 赋值li_1 = ['a', 'b', 'c', 'e', 'c', 'f', 'c']# count 计算列表中指定元素呈现的次数 没有元素为0# 3print(li_1.count('c'))其它办法# 赋值li = ['a', 'b', 'c', 'e', 'c', 'f']# dir() 查看列表类型的办法名# ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']print(dir(li))# reverse 对列表中的元素进行反向排列li.reverse()# 打印# ['f', 'c', 'e', 'c', 'b', 'a']print(li)# 赋值li_1 = [1, 52, 3, 5, 4, 9, 23]# sort 对列表中的元素进行从小到大的排列# 个别针对于数值应用 字母是依据ASCII表排列li_1.sort() # 或 li_1.sort(reverse=False)# 打印# [1, 3, 4, 5, 9, 23, 52]print(li_1)# 赋值li_2 = [1, 52, 35, 5, 47, 9, 23]# sort 对列表中的元素进行从大到小的排列li_2.sort(reverse=True)# 打印# [52, 47, 35, 23, 9, 5, 1]print(li_2)3. 元组查# 赋值li = ('a', 'b', 'd', 'c', 'e', 'c', 'f')# dir() 查看元组类型的办法名# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']print(dir(li))# count 查找元素的数量# 2print(li.count('c'))# index 有雷同的元素时，查找第一个元素的索引值# 3print(li.index("c"))

变量# 打印print(123)# 变量就是专门用来保留数据的，关键词不能用于变量# 赋值给变量numnum = 123# 打印# 123print(num)# 还可用于计算new_num = num + 2# 打印后果# 123print(new_num)# 导入关键词模块import keyword# 关键词不可用于变量# 查看关键词# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']print(keyword.kwlist)数值类型"""数值类型整数 int浮点数 float复数 complex布尔 bool"""1. 整数# 运算符号 + - * / % **# 赋值计算num = 1 + 1# 打印后果# 2print(num)# 打印类型# <class 'int'>print(type(num))2. 浮点数(小数)# 导入模块import decimal# 赋值计算num = 0.1 + 0.2# 打印后果# 0.30000000000000004print(num)# 打印类型# <class 'float'>print(type(num))# 准确计算new_num = decimal.Decimal("0.1") + decimal.Decimal("0.2")# 打印后果# 0.3print(new_num)3. 布尔# 布尔(True,False)# 打印# Trueprint(bool(True))# 打印# Falseprint(bool(False))# 打印# Trueprint(bool(1))# 打印# Falseprint(bool(0))4. 复数(理解)# 复数e = 1 + 2j# 查看类型# <class 'complex'>print(type(e))# 取实部# 1.0print(e.real)# 取虚部# 2.0print(e.imag)5. 转换# 小数转整数# 赋值num = 1.223# 转换为整数# 1print(int(num))# 类型# <class 'int'>print(type(int(num)))# 整数转小数# 赋值num_1 = 12323# 转换为浮点数# 12323.0print(float(num_1))# 类型# <class 'float'>print(type(float(num_1)))序列类型"""序列类型字符串 str 符号: '' "" """""" 转换形式: str()列表 list 符号: [] 转换形式: list() 可变类型元组 tuple 符号: () 转换形式: tuple() 不可变类型"""1. 字符串# 单引号'hello world'# 双引号"hello world"# 三引号 能够多行'''hello worldhello world'''"""hello worldhello world"""# 引号嵌套"'hello world'"# 赋值num = """abcdefghijk"""# 打印# abc# def# ghi# jkprint(num)2. 列表# 列表 用逗号隔开# 列表里能够放 变量.整数.浮点数.字符串.列表 也能够为空# 赋值qi = "hello world"# 嵌套num = [qi, 1, 2, 3, 4, 5, 6, "hello", [1, 2, [1, 2], 3]]# 查看类型# <class 'list'>print(type(num))3. 元组# 元组 用逗号隔开 必须要有一个逗号能力算作元组# 元组里能够放 变量.整数.浮点数.字符串.列表 也能够为空# 赋值 能够嵌套num = (1, 2, 3, 4, 5)# 查看类型# <class 'tuple'>print(type(num))# 不加逗号不能算作元组num_1 = (1)# 查看类型# <class 'int'>print(type(num_1))# 只有用逗号隔开，不加括号也算是元组num_2 = 1, 2, 3, 4, 5# 查看类型# <class 'tuple'>print(type(num_2))4. 转换# 字符串# 引号内只有有一个不是数字，不能转换为整数和浮点数# 引号内是整数能够间接转整数或浮点数# 浮点数要先转换为浮点数，再转为整数# 任何类型都能够转换为字符串# 赋值num_1 = "123"# 转换为整数# 123print(int(num_1))# 转换为浮点数# 123.0print(float(num_1))# 赋值num_2 = "123.12"# 转换为浮点数# 123.12print(float(num_2))# 转换为整数# 123print(int(float(num_2)))# 列表# 赋值num_3 = "hello world"# 转换为列表# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']print(list(num_3))# 赋值num_4 = ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']# 转换为字符串# ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']print(str(num_4))# 类型# <class 'str'>print(type(str(num_4)))# 元组# 把列表转换为元组# ('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')print(tuple(num_4))其它操作1.索引 ...

Python是一种动静类型语言，这意味着咱们能够在运行时更改对象的构造，例如增加或删除属性。然而，这种灵活性有时可能会导致问题，例如咱们可能无心中扭转了一个属性的值，或者误用了一个应该是只读的属性。为了解决这些问题，Python提供了一个弱小的个性：描述符。 一、什么是描述符？在Python中，描述符是一个实现了特定协定的对象。这个协定包含__get__()、__set__()和__delete__()办法。描述符使咱们能够在拜访、设置或删除属性时定义额定的行为。 描述符次要用于治理对特定属性的拜访。当你在类中定义了一个描述符，Python会在你拜访该属性时应用描述符中定义的行为，而不是间接拜访对象的字典。 让咱们看一个简略的例子，一个只读的描述符： class ReadOnly: def __init__(self, initval=None, name='var'): self.val = initval self.name = name def __get__(self, obj, objtype): return self.val def __set__(self, obj, val): raise AttributeError(f"{self.name} is read-only")class MyClass: attr = ReadOnly(10, 'attr')在这个例子中，ReadOnly是一个描述符。当咱们尝试设置MyClass的attr属性时，它会抛出一个AttributeError，因为attr是只读的。 二、描述符的类型在Python中，有两种类型的描述符：数据描述符和非数据描述符。 数据描述符是定义了__set__()或__delete__()办法的描述符。当一个数据描述符和一个实例字典中的项有雷同的名字时，数据描述符将具备更高的优先级。 非数据描述符只定义了__get__()办法。如果实例字典中有雷同名字的项，那么这个项将具备更高的优先级。 三、应用描述符描述符通常用于实现高级性能，例如数据验证、属性拜访日志记录、类型查看等。上面咱们将实现一个简略的类型查看描述符： class Typed: def __init__(self, name, required_type): self.name = name self.required_type = required_type def __get__(self, instance, owner): return instance.__dict__[self.name] def __set__(self, instance, value): if not isinstance(value, self.required_type): raise TypeError(f"Expected {self.required_type}") instance.__dict__[self.name] = valueclass MyClass: attr = Typed('attr', int)在这个例子中，Typed描述符确保attr属性总是一个整数。如果咱们尝试设置一个非整数值，就会抛出一个TypeError。 ...

eKuiper 团队于年前公布了 1.8.0 版本，并在 2 月对该版本的文档进行了欠缺，同时通过 EMQ Demo Day 直播帮忙用户更进一步理解新性能的应用场景。 咱们也开始了下一个版本 1.9.0 的开发，该版本将是一个较小的迭代版本，次要指标是实现与工业协定网关软件 Neuron 的多实例连贯。目前次要实现了性能调研和布局工作，以及新性能 Python 插件虚拟环境反对的开发。 此外，2 月还公布了 1.8.1 版本，蕴含导入 Portable 插件以及 Flow Editor 等 bug 修复。 残缺内容请点击下方链接查看： https://developer.aliyun.com/article/1174802?utm_content=g_10... 版权申明：本文内容由阿里云实名注册用户自发奉献，版权归原作者所有，阿里云开发者社区不领有其著作权，亦不承当相应法律责任。具体规定请查看《阿里云开发者社区用户服务协定》和《阿里云开发者社区知识产权爱护指引》。如果您发现本社区中有涉嫌剽窃的内容，填写侵权投诉表单进行举报，一经查实，本社区将立即删除涉嫌侵权内容。

一、介绍手写数字识别系统，应用Python语言，基于TensorFlow搭建CNN卷积神经网络算法对数据集进行训练，最初失去模型，并基于FLask搭建网页端界面，基于Pyqt5搭建桌面端可视化界面。 二、成果展现 三、演示视频+残缺代码视频+代码：https://www.yuque.com/ziwu/yygu3z/tb1mzqi847daqkru 四、手写数字辨认当波及手写数字识别系统时，TensorFlow是一个弱小的工具，它提供了许多用于构建深度学习模型的性能。以下是一个根本的代码示例，展现了如何应用TensorFlow来构建、训练和测试手写数字识别系统。 首先，咱们须要导入所需的库和模块： pythonCopy codeimport tensorflow as tffrom tensorflow import kerasfrom tensorflow.keras import layers接下来，咱们能够加载并预处理手写数字数据集（例如MNIST数据集）： pythonCopy code# 加载MNIST数据集(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()# 将像素值缩放到0到1之间x_train = x_train.astype("float32") / 255.0x_test = x_test.astype("float32") / 255.0# 将标签转换为独热编码（one-hot encoding）y_train = keras.utils.to_categorical(y_train)y_test = keras.utils.to_categorical(y_test)接下来，咱们能够定义一个根本的卷积神经网络（CNN）模型来进行手写数字辨认： pythonCopy codemodel = keras.Sequential([ layers.Reshape(target_shape=(28, 28, 1), input_shape=(28, 28)), layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu'), layers.MaxPooling2D(pool_size=(2, 2)), layers.Flatten(), layers.Dense(units=128, activation='relu'), layers.Dense(units=10, activation='softmax')])当初，咱们能够编译模型并开始训练： pythonCopy codemodel.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])model.fit(x_train, y_train, batch_size=128, epochs=5, validation_data=(x_test, y_test))在训练过程中，咱们应用Adam优化器和穿插熵损失函数。咱们还指定了每个批次的大小（128）和训练周期的数量（5）。通过应用验证集（x_test和y_test）进行验证，咱们能够评估模型的性能。 训练实现后，咱们能够应用测试集来评估模型的准确性： pythonCopy codetest_loss, test_acc = model.evaluate(x_test, y_test)print("Test accuracy:", test_acc)以上代码提供了一个根本的手写数字识别系统的构建、训练和测试流程。你能够依据须要对模型进行调整和优化，例如减少网络的深度、调整超参数等，以进步准确性。 ...

Python的多线程和多过程一、简介并发是明天计算机编程中的一项重要能力，尤其是在面对须要大量计算或I/O操作的工作时。Python 提供了多种并发的解决形式，本篇文章将深入探讨其中的两种：多线程与多过程，解析其应用场景、长处、毛病，并联合代码例子深刻解读。 二、多线程Python中的线程是利用threading模块实现的。线程是在同一个过程中运行的不同工作。 2.1 线程的根本应用在Python中创立和启动线程很简略。上面是一个简略的例子： import threadingimport timedef print_numbers(): for i in range(10): time.sleep(1) print(i)def print_letters(): for letter in 'abcdefghij': time.sleep(1.5) print(letter)thread1 = threading.Thread(target=print_numbers)thread2 = threading.Thread(target=print_letters)thread1.start()thread2.start()在这个例子中，print_numbers和print_letters函数都在各自的线程中执行，彼此互不烦扰。 2.2 线程同步因为线程共享内存，因而线程间的数据是能够相互拜访的。然而，当多个线程同时批改数据时就会呈现问题。为了解决这个问题，咱们须要应用线程同步工具，如锁（Lock）和条件（Condition）等。 import threadingclass BankAccount: def __init__(self): self.balance = 100 # 共享数据 self.lock = threading.Lock() def deposit(self, amount): with self.lock: # 应用锁进行线程同步 balance = self.balance balance += amount self.balance = balance def withdraw(self, amount): with self.lock: # 应用锁进行线程同步 balance = self.balance balance -= amount self.balance = balanceaccount = BankAccount()特地阐明：Python的线程尽管受到全局解释器锁（GIL）的限度，然而对于IO密集型工作（如网络IO或者磁盘IO），应用多线程能够显著进步程序的执行效率。 ...

Python的asyncio模块是一个用于编写单线程并发代码的库，应用协程，多路复用IO以及其余技术。在本文中，咱们将介绍asyncio的基本概念和应用办法。一、异步编程和协程异步编程是一种编程范式，它容许程序在期待某个操作实现时继续执行其余工作。这对于IO密集型工作十分有用，例如网络申请或文件操作，这些操作通常须要期待一段时间。在Python中，咱们能够应用协程（coroutines）来编写异步代码。协程是能够在任何时候暂停和复原的函数。Python的协程通过async/await语法来定义和应用。以下是一个简略的协程的例子： import asyncioasync def main(): print('Hello') await asyncio.sleep(1) print('World')asyncio.run(main())在这个例子中，main是一个协程，咱们用async关键字来定义它。main协程首先打印'Hello'，而后期待1秒，而后打印'World'。咱们用await关键字来期待一个异步操作（在这个例子中是asyncio.sleep(1)）的实现。asyncio.run函数用于运行一个协程。 二、工作和事件循环在asyncio中，协程不会立刻执行。相同，咱们须要将协程注册到事件循环（event loop），而后由事件循环来调度协程的执行。事件循环是asyncio的外围，它负责调度和执行工作。工作（Task）是对协程的封装。当咱们将一个协程注册到事件循环时，它会被包装成一个工作。以下是一个创立和运行工作的例子： import asyncioasync def hello(): await asyncio.sleep(1) print('Hello, World!')async def main(): task = asyncio.create_task(hello()) await taskasyncio.run(main())在这个例子中，咱们应用asyncio.create_task函数将hello协程包装成一个工作，并将其注册到事件循环。而后咱们期待工作的实现。 三、异步IOasyncio反对异步的IO操作，包含网络申请和文件操作。以下是一个应用asyncio进行异步网络申请的例子： import asyncioimport aiohttpasync def fetch(session, url): async with session.get(url) as response: return await response.text()async def main(): async with aiohttp.ClientSession() as session: html = await fetch(session, 'http://python.org') print(html)asyncio.run(main())在这个例子中，咱们应用aiohttp库进行异步的HTTP申请。aiohttp是一个基于asyncio的异步HTTP申请 四、异步上下文管理器和异步迭代器asyncio还反对异步上下文管理器和异步迭代器。这容许咱们在异步代码中应用with语句和for语句。异步上下文管理器是实现了异步__aenter__和__aexit__办法的对象。咱们能够在async with语句中应用异步上下文管理器。异步迭代器是实现了__aiter__和__anext__办法的对象。咱们能够在async for语句中应用异步迭代器。以下是一个应用异步上下文管理器和异步迭代器的例子： import asyncioclass AsyncIterable: def __init__(self, iterable): self.iterable = iterable def __aiter__(self): return self async def __anext__(self): if not self.iterable: raise StopAsyncIteration return self.iterable.pop(0)async def main(): async for i in AsyncIterable([1, 2, 3, 4, 5]): await asyncio.sleep(1) print(i)asyncio.run(main())在这个例子中，AsyncIterable是一个异步迭代器，它每次产生一个元素，并在产生每个元素后期待1秒。 ...

一、引言在Python多线程编程中，咱们经常须要解决多个线程同时访问共享数据的状况。为了避免数据在多线程之间呈现抵触，咱们须要对线程进行同步。本文将具体介绍Python中的线程同步的几种罕用办法：锁（Lock），递归锁（RLock），条件变量（Condition），信号量（Semaphore），事件（Event），以及屏障（Barrier）。 二、锁（Lock）Python的threading模块提供了锁（Lock）作为最根本的线程同步机制。锁有两种状态，"locked"和"unlocked"。当多个线程要访问共享数据时，它们必须先获取锁，拜访数据后再开释锁。只有一个线程能够获取锁，其余线程必须期待，直到锁被开释。 以下是一个应用锁的例子： import threading# 创立一个锁lock = threading.Lock()def worker(): # 获取锁 lock.acquire() try: # 访问共享数据 print("Thread is working...") finally: # 开释锁 lock.release()# 创立两个线程thread1 = threading.Thread(target=worker)thread2 = threading.Thread(target=worker)# 启动线程thread1.start()thread2.start()# 期待所有线程完结thread1.join()thread2.join()在这个例子中，两个线程必须在访问共享数据之前获取锁。因而，它们不能同时访问共享数据，防止了数据抵触。 三、递归锁（RLock）递归锁（RLock）是一种能够被同一个线程屡次获取的锁。它与一般锁的区别在于，如果一个线程曾经获取了一个递归锁，它能够再次获取这个锁，而不会导致线程阻塞。这在某些须要在同一个线程中屡次获取锁的状况下十分有用。 以下是一个应用递归锁的例子： import threading# 创立一个递归锁rlock = threading.RLock()def worker(): # 获取锁 rlock.acquire() try: # 再次获取锁 rlock.acquire() try: # 访问共享数据 print("Thread is working...") finally: # 第一次开释锁 rlock.release() finally: # 第二次开释锁 rlock.release()# 创立两个线程thread1 = threading.Thread(target=worker)thread2 = threading.Thread(target=worker)# 启动线程thread1.start()thread2.start()# 期待所有线程完结thread1.join()thread2.join()在这个例子中，同一个线程能够屡次获取同一个递归锁。这是通过在每次获取锁时减少一个计数器，每次开释锁时缩小一个计数器来实现的。只有当计数器的值为零时，锁才会真正的被开释，这样其余线程才有可能获取到这个锁。 递归锁能够解决一些简单的锁需要，例如一个函数在递归调用时须要获取锁，或者一个线程须要在不同的函数中获取同一个锁。但请留神，尽管递归锁能够使得代码更加灵便，然而它也使得代码更难了解，更难保障线程同步的正确性，因而应尽量避免应用递归锁，除非的确有须要。 四、条件变量（Condition）条件变量（Condition）是另一种罕用的线程同步机制，它容许一个或多个线程期待某个条件成立，而后才继续执行。条件变量通常与一个关联的锁一起应用，这个锁能够被多个线程共享。 以下是一个应用条件变量的例子： import threading# 创立一个条件变量condition = threading.Condition()def worker1(): with condition: # 期待条件成立 condition.wait() # 访问共享数据 print("Worker 1 is working...")def worker2(): with condition: # 访问共享数据 print("Worker 2 is working...") # 告诉其余线程条件曾经成立 condition.notify()# 创立两个线程thread1 = threading.Thread(target=worker1)thread2 = threading.Thread(target=worker2)# 启动线程thread1.start()thread2.start()# 期待所有线程完结thread1.join()thread2.join()在这个例子中，线程1必须期待线程2告诉条件成立后，能力继续执行。 ...

日期和工夫在计算机编程中是十分重要的概念，特地是在解决数据、日志记录、打算工作等方面。Python作为一门功能强大的编程语言，提供了丰盛的库和内置函数，使得对日期和工夫的操作变得简略而高效。本文将介绍一些常见的Python日期工夫操作，以帮忙你更好地解决和治理工夫数据。一、获取以后日期和工夫在Python中，你能够应用datetime模块来获取以后的日期和工夫。上面的代码演示了如何获取以后日期和工夫： import datetime# 获取以后日期和工夫now = datetime.datetime.now()# 输入以后日期和工夫print("以后日期和工夫：", now)运行以上代码，你将取得以后的日期和工夫的输入后果，如下所示： 以后日期和工夫： 2023-06-16 10:30:00二、格式化日期和工夫在理论利用中，咱们通常须要以特定的格局显示日期和工夫。Python中的strftime()办法能够用于将日期和工夫格式化为字符串。上面的代码演示了如何将日期和工夫格式化为指定的格局： import datetime# 获取以后日期和工夫now = datetime.datetime.now()# 格式化日期和工夫formatted_date = now.strftime("%Y-%m-%d")formatted_time = now.strftime("%H:%M:%S")# 输入格式化后的日期和工夫print("格式化后的日期：", formatted_date)print("格式化后的工夫：", formatted_time)运行以上代码，你将取得格式化后的日期和工夫的输入后果，如下所示： 格式化后的日期： 2023-06-16格式化后的工夫： 10:30:00在strftime()办法中，你能够应用不同的格局代码来定义日期和工夫的格局。例如，%Y示意4位数的年份，%m示意两位数的月份，%d示意两位数的日期，%H示意24小时制的小时，%M示意分钟，%S示意秒。 三、将字符串转换为日期工夫对象有时候，你可能须要将字符串转换为日期和工夫对象进行进一步的操作。Python中的strptime()函数能够帮忙你实现这个指标。上面的代码演示了如何将字符串转换为日期工夫对象： import datetime# 将字符串转换为日期工夫对象date_str = "2023-06-16"date_obj = datetime.datetime.strptime(date_str, "%Y-%m-%d")# 输入日期工夫对象print("日期工夫对象：", date_obj)运行以上代码，你将取得转换后的日期工夫对象的输入后果，如下所示： 日期工夫对象： 2023-06-16 00:00:00在strptime()函数中，你须要指定要转换的字符串和对应的日期工夫格局。在上述代码中，%Y-%m-%d示意年、月、日的格局。 四、日期工夫运算Python提供了不便的办法来执行日期和工夫的运算，比方计算两个日期之间的差别，或者在特定日期上减少或缩小肯定的工夫量。上面的代码演示了一些常见的日期工夫运算： import datetime# 获取以后日期和工夫now = datetime.datetime.now()# 计算两个日期之差date1 = datetime.datetime(2023, 6, 16)date2 = datetime.datetime(2022, 5, 15)date_diff = date1 - date2# 在特定日期上减少或缩小工夫量one_week_ago = now - datetime.timedelta(weeks=1)one_day_later = now + datetime.timedelta(days=1)# 输入后果print("两个日期的差别：", date_diff)print("一周前的日期：", one_week_ago)print("一天后的日期：", one_day_later)运行以上代码，你将取得日期工夫运算的输入后果，如下所示： ...

Python有一些内置库用于解决数据压缩和解压缩，其中一个就是zlib模块。这个模块为DEFLATE压缩算法和相干的gzip（文件格式）提供了反对。在这篇文章中，咱们将深入探讨如何应用zlib模块进行数据压缩和解压缩。 一、zlib模块的根底 在Python中，zlib模块为解决大量数据提供了便当。这个模块次要有两个函数：compress()和decompress()。compress()函数接管一个字符串作为参数，并返回一个蕴含压缩数据的字符串。decompress()函数则执行相同的操作，接管一个蕴含压缩数据的字符串，并返回解压缩后的数据。 以下是一个应用这两个函数的简略示例： import zlib# 要压缩的数据data = b"This is some data that we're going to compress"# 应用 zlib.compress() 压缩数据compressed_data = zlib.compress(data)print(f"Compressed data: {compressed_data}")# 应用 zlib.decompress() 解压数据decompressed_data = zlib.decompress(compressed_data)print(f"Decompressed data: {decompressed_data}")二、压缩级别 zlib.compress()函数接管一个可选的第二参数，即压缩级别。压缩级别是一个介于1（最小压缩）和9（最大压缩）之间的数字。如果省略了这个参数，zlib会应用默认的压缩级别6。 以下是一个示例，展现了如何应用不同的压缩级别： import zlib# 要压缩的数据data = b"This is some data that we're going to compress"for i in range(1, 10): compressed_data = zlib.compress(data, i) print(f"Compression level: {i}, size of compressed data: {len(compressed_data)}")三、错误处理 在应用zlib进行解压缩时，如果传入的数据不是无效的压缩数据，zlib.decompress()函数会抛出一个zlib.error异样。咱们须要对这个异样进行解决，以避免程序解体。以下是一个示例，展现了如何解决这个异样： import zlib# 有效的压缩数据invalid_compressed_data = b"This is not valid compressed data"try: decompressed_data = zlib.decompress(invalid_compressed_data)except zlib.error: print("Invalid compressed data")在这个示例中，咱们尝试对一段有效的压缩数据进行解压缩，后果引发了一个zlib.error异样。咱们应用try/except语句捕捉了这个异样，并打印出一条谬误音讯。 ...

在Python中，文件操作是一个重要的概念。咱们通常须要读取文件中的数据进行解决，或者将解决后的数据保留到文件中。在本文中，咱们将介绍Python如何关上文件，以及如何读写文件内容。一、关上文件在Python中，咱们应用内置的open函数来关上文件。open函数的根本语法如下： file = open("filename", "mode")"filename"是要关上的文件的名称。"mode"是关上文件的模式。罕用的模式有："r"示意读取模式，"w"示意写入模式，"a"示意追加模式，"b"示意二进制模式。以下是一个关上文件的例子： file = open("test.txt", "r")在这个例子中，咱们关上了名为"test.txt"的文件，关上模式为"r"，即读取模式。留神，当咱们应用open函数关上文件后，肯定要记得在操作实现后敞开文件。咱们能够应用file.close()办法来敞开文件。 二、读取文件在Python中，咱们能够应用以下几种办法来读取文件中的数据： file.read()：读取文件中的所有内容，并返回一个字符串。file.readline()：读取文件中的一行内容，并返回一个字符串。file.readlines()：读取文件中的所有行，每行作为一个字符串，返回一个蕴含所有字符串的列表。以下是一个读取文件内容的例子： file = open("test.txt", "r")content = file.read()print(content)file.close()在这个例子中，咱们关上了名为"test.txt"的文件，读取了文件中的所有内容，而后打印了这些内容。 三、写入文件在Python中，咱们能够应用file.write()办法来写入文件。file.write()办法承受一个字符串作为参数，并将这个字符串写入文件。以下是一个写入文件的例子： file = open("test.txt", "w")file.write("Hello, World!")file.close()在这个例子中，咱们关上了名为"test.txt"的文件，写入模式为"w"，即写入模式。而后，咱们将字符串"Hello, World!"写入了这个文件。留神，当咱们应用写入模式("w")关上文件时，如果文件曾经存在，那么原来的文件内容将被齐全笼罩。如果咱们只想在文件的开端增加内容，而不是笼罩原来的内容，咱们能够应用追加模式("a")来关上文件。 四、应用with语句关上文件在Python中，咱们还能够应用with语句来关上文件。with语句能够确保文件在操作实现后被正确敞开，即便在解决文件的过程中产生了异样。以下是一个应用with语句关上文件的例子： with open("test.txt", "r") as file: content = file.read()print(content)在这个例子中，咱们应用with语句关上了名为"test.txt"的文件，并读取了文件中的所有内容。当with语句完结时，文件会被主动敞开，咱们不须要手动调用file.close()办法。 五、读写二进制文件在Python中，咱们也能够读写二进制文件。咱们只须要在关上文件的模式中增加"b"字符，就能够将文件关上为二进制模式。以下是一个读取二进制文件的例子： with open("test.bin", "rb") as file: content = file.read()在这个例子中，咱们关上了名为"test.bin"的二进制文件，并读取了文件中的所有内容。 六、论断Python提供了弱小的文件操作性能，咱们能够轻松地关上文件，读取文件内容，写入文件，以及解决二进制文件。通过把握Python的文件操作，咱们能够解决各种各样的数据，无论是文本数据还是二进制数据。以上就是对Python文件关上、读写的根本介绍，心愿对你有所帮忙。 七、最初如果感觉本文对你有帮忙记得 点个关注，给个赞，加个珍藏，更多精彩内容欢送查看。

一、Bokeh 简介Bokeh 是一个风行的 Python 数据可视化库，能够生成高质量的交互式图表，无论是简略的线图、散点图，还是简单的多维面图、网络图，Bokeh 都能轻松解决。同时，它反对网页输入，使得图表能够轻易的分享和展现。Bokeh 的次要指标是为大数据和实时数据流提供优良的交互式可视化解决方案。 二、装置与根本应用应用pip装置Bokeh非常简单，只需在终端中运行以下命令： pip install bokeh装置实现后，咱们就能够应用 Bokeh 了。以下是一个简略的示例，演示了如何应用 Bokeh 创立一个简略的线图： from bokeh.plotting import figure, show# 筹备数据x = [1, 2, 3, 4, 5]y = [6, 7, 2, 3, 6]# 创立一个新的图p = figure(title="简略线图", x_axis_label='x', y_axis_label='y')# 增加一条线到图中p.line(x, y, legend_label="Temp.", line_width=2)# 显示图show(p)在这个示例中，咱们首先从 bokeh.plotting 模块中导入了 figure 和 show 函数。而后，咱们筹备了一些数据，创立了一个新的图，向图中增加了一条线，最初应用 show 函数来显示这个图。 三、增加交互性Bokeh 的弱小之处在于它反对丰盛的交互性性能。例如，咱们能够增加工具栏、滑动条等交互组件，以便用户能够管制图表的显示方式。以下是一个简略的例子，展现了如何增加一个滑动条和一个回调函数来扭转图表的数据： from bokeh.io import curdocfrom bokeh.layouts import columnfrom bokeh.models import ColumnDataSource, Sliderfrom bokeh.plotting import figure# 创立一个新的 ColumnDataSource，这将容许咱们扭转数据source = ColumnDataSource(data=dict(x=[1, 2, 3, 4, 5], y=[6, 7, 2, 3, 6]))# 创立一个新的图p = figure(title="交互性线图", x_axis_label='x', y_axis_label='y')p.line('x', 'y', source=source, legend_label="Temp.", line_width=2)# 创立一个滑动条slider = Slider(start=0, end=10, value=1, step=.1, title="幂")# 创立一个回调函数，这将会在滑动条的值扭转时被调用def update_data(attrname, old, new): c = slider.value source.data = dict(x=[1, 2, 3, 4, 5], y=[6*c, 7*c, 2*c, 3*c, 6*c])# 把回调函数增加到滑动条上slider.on_change('value', update_data)# 将图和滑动条放到一个布局中layout = column(slider, p)# 增加布局到以后文档curdoc().add_root(layout)在这个示例中，咱们首先创立了一个新的 ColumnDataSource，这个对象会存储咱们的数据，并容许咱们扭转这些数据。而后，咱们创立了一个新的图，并向这个图中增加了一条线。留神，咱们在增加线时，指定了数据源为咱们之前创立的 ColumnDataSource。 ...

Python除了反对多线程，还反对多过程。相比于多线程，多过程能够充分利用多核CPU的计算能力，实现真正的并行计算。在本文中，咱们将介绍Python中的多过程，以及如何应用Python的multiprocessing模块创立和治理过程。一、什么是过程？过程是操作系统分配资源的根本单位。每个过程都有本人的内存空间，这意味着过程之间的变量是隔离的，一个过程无法访问另一个过程的变量。 二、Python中的过程在Python中，咱们能够应用multiprocessing模块创立和治理过程。以下是一个创立过程的例子： from multiprocessing import Processdef print_numbers(): for i in range(10): print(i)def print_letters(): for letter in 'abcdefghij': print(letter)process1 = Process(target=print_numbers)process2 = Process(target=print_letters)process1.start()process2.start()process1.join()process2.join()在这个例子中，咱们创立了两个过程：process1和process2。process1的工作是打印数字0到9，process2的工作是打印字母'a'到'j'。咱们应用multiprocessing.Process类创立了两个过程对象，并指定了每个过程的指标函数。而后，咱们调用了start办法来启动过程。join办法用于期待过程完结。这是阻塞调用，也就是说，调用join办法的过程（在这个例子中是主过程）会被阻塞，直到被调用join办法的过程（在这个例子中是process1和process2）完结。 三、过程间通信因为过程之间的内存是隔离的，所以过程之间不能间接通信。Python的multiprocessing模块提供了多种过程间通信的工具，包含管道（Pipe）、队列（Queue）等。以下是一个应用队列进行过程间通信的例子： from multiprocessing import Process, Queuedef worker(q): q.put('Hello, world!')def main(): q = Queue() p = Process(target=worker, args=(q,)) p.start() print(q.get()) p.join()if __name__ == '__main__': main()在这个例子中，咱们创立了一个子过程，该子过程向队列中增加了一个音讯。主过程从队列中获取了这个音讯，并打印了它。通过队列，咱们实现了过程间的通信。 四、进程同步和线程一样，过程也可能须要同步。Python的multiprocessing模块提供了多种进程同步的工具，包含锁（Lock）、信号量（Semaphore）等。 五、Python中的过程池在Python中，咱们能够应用multiprocessing.Pool类创立一个过程池。过程池中的过程数量是固定的，当有新的工作提交到过程池时，如果过程池中有闲暇的过程，那么这个过程就会被调配到这个工作。如果所有的过程都在忙，那么这个工作就会期待，直到有过程变成闲暇状态。以下是一个应用过程池的例子： pythonCopy codefrom multiprocessing import Pooldef square(x): return x * xif __name__ == '__main__': with Pool(5) as p: print(p.map(square, [1, 2, 3, 4, 5]))在这个例子中，咱们创立了一个蕴含5个过程的过程池。而后，咱们应用map办法提交了一组工作到过程池。这组工作是计算一组数字的平方。map办法会主动调配这些工作到过程池中的过程。 ...

你好，我是猫哥。这里记录每周值得分享的 Python 及通用技术内容，局部为英文，已在小标题注明。（题目取自其中一则分享，不代表全部内容都是该主题，特此申明。） 首发于我的博客：https://pythoncat.top/posts/2023-06-17-weekly7 文章&教程1、AsyncIO (英) 文章的作者厌恶 asyncio 库，认为应用 async 和 await 的设计非常蹩脚，它与大多数库不兼容，也不满足“Python之禅”的一些规范。作者的举荐计划是 gevent，提及了它的几点益处。另外，作者还举荐了两篇相干的文章：Flask 作者 Armin Ronacher 的《I don't understand Python's Asyncio》，SQLAlchemy 作者 Mike Bayer 的《Asynchronous Python and Databases》 2、gevent 到底是什么？ (英) gevent 是一个基于协程的合作式多任务 Python 框架，应用猴子补丁来协调所有代码。这篇文章是一个系列的第一篇，介绍了 gevent 的根本实现原理，第二篇是《Gevent Correctness》，第三篇是《Gevent Performance》 3、ReactPy 的入门教程 (英) 上期周刊举荐过的 ReactPy 最近很火，它反对用 Python 写 React 格调的前端利用。这里是一篇简略的入门教程。另外，倡议感兴趣的同学去看官网文档。 4、Python 业务框架循环依赖和全局上下文的一些思考 如何简略而优雅地解决 Python 的循环依赖问题呢？作者考查了支流 API 框架（Django、Flask、FastAPI）的上下文治理计划，而后介绍了本人框架采纳的计划：借鉴了 Ray 社区中对象所有权的概念，在一个协程上实现一个繁难的所有权字典。 5、Python 函数调用的理论依赖关系跟踪 (英) 跟踪 Python 函数调用时拜访的代码和数据是一种很有用的操作，比方绘制依赖图、调试和剖析性能、缓存生效。这篇文章考查了一种可能的实现形式，蕴含了一个少于 100 行代码的最小可行实现。作者是 MIT 的计算机科学博士。 ...

单刀直入钻研的问题：如果我插入一个 datetime 的 tzinfo 北京时区的，peewee insert 的时候，会帮我转成 utc 再插入吗？ 答案：不会 钻研过程咱们通过 peewee 返回对的 sqlpeewee 外部的 sql以及 wireshark 抓包获取的 sql三者验证判断 from loguru import loggerimport settingsfrom peewee import *from datetime import datetime, timedelta, timezoneimport timeimport contextlibdef get_min_utc_timestamp() -> datetime: return (datetime(year=1970, month=1, day=1) + timedelta(seconds=1)).replace(tzinfo=timezone.utc)def get_utc_now_timestamp() -> datetime: """ https://blog.csdn.net/ball4022/article/details/101670024 """ return datetime.utcnow().replace(tzinfo=timezone.utc)def get_cst_now_timestamp() -> datetime: """ https://segmentfault.com/q/1010000043912065 """ try: from zoneinfo import ZoneInfo tz = ZoneInfo('Asia/Shanghai') return datetime.now(tz) except ImportError: beijing_offset = timedelta(hours=8) current_time = datetime.now(timezone(beijing_offset)) return current_timehost = settings.MYSQL_CONFIG.hostport = settings.MYSQL_CONFIG.portusername = settings.MYSQL_CONFIG.usernamepassword = settings.MYSQL_CONFIG.passworddatabase_name = settings.MYSQL_CONFIG.database_namedb = MySQLDatabase( database=database_name, host=host, port=port, user=username, password=password, charset='utf8mb4')class User(Model): name = CharField(unique=True) age = IntegerField(null=True) address = CharField(null=True) city = CharField(null=True) birth = DateTimeField(null=True) created_at = DateTimeField( null=False, constraints=[SQL('DEFAULT CURRENT_TIMESTAMP')], help_text='应用数据库工夫' ) updated_at = DateTimeField( null=False, constraints=[ SQL('DEFAULT CURRENT_TIMESTAMP'), SQL('ON UPDATE CURRENT_TIMESTAMP'), ] ) class Meta: database = db table_name = 'user'model_set = [User]db.drop_tables(model_set)db.create_tables(model_set)d = get_cst_now_timestamp()print(d)q = User.select().where( User.age == 1, User.birth == d)print('> sql', str(q))list(q)q = User.insert({'created_at': d})logger.debug(str(q))q.execute()而后批改 peewee 的源码： ...

在 datetime 对象中，能够应用 datetime 对象的 utcoffset() 办法来查看时区偏移量。 以下是一个示例代码： from datetime import datetime, timedeltacurrent_time = datetime.now()timezone_offset = current_time.utcoffset()print(timezone_offset)这将打印出以后工夫的时区偏移量。请留神，时区偏移量是以 timedelta 对象的模式返回的，示意绝对于协调世界时（UTC）的时间差。正值示意东半球的时区，负值示意西半球的时区。 如果想以小时为单位获取时区偏移量的整数值，能够应用 total_seconds() 办法： timezone_offset_hours = timezone_offset.total_seconds() / 3600print(timezone_offset_hours)这将打印出以小时为单位的时区偏移量整数值。

pytz 是什么，是一个 python 中解决时区问题的库 这个库有什么问题： 解决北京工夫（严格来讲是上海工夫）的时候，会多 6 分钟，这很要命github 星星太少 （https://github.com/stub42/pytz） 具体起因请参考：为什么 pytz 不反对 北京工夫（为什么很多货色不反对北京工夫）？ 换成 zoneinfo 就不会多出 6 分钟了吗？ 是的！ zoneinfo 是什么，是 python 从 3.9 开始退出规范库，不须要你额定装置 from zoneinfo import ZoneInfofrom datetime import datetimeimport pytz# 应用第三方库 pytz 给 datetime 增加时区信息print(datetime.now().replace(tzinfo=pytz.timezone('Asia/Shanghai')))# 应用规范库 ZoneInfo 给 datetime 增加时区信息tz = ZoneInfo('Asia/Shanghai')print(datetime.now(tz))输入如下： 2023-06-17 13:36:54.594807+08:062023-06-17 13:36:54.605920+08:00如果你不想要这些乌七八糟的文字信息，只想增加 8 小时的时区偏移量怎么办？ from datetime import datetime, timedelta, timezonefrom zoneinfo import ZoneInfobeijing_offset = timedelta(hours=8)current_time = datetime.now(timezone(beijing_offset))print(current_time)输入如下： 2023-06-17 13:58:57.897151+08:00

将 datetime 对象的时区设为 None 是可行的，这将使 datetime 对象成为一个无时区的对象，也称为“naive datetime”。 以下是一个示例代码： from datetime import datetimecurrent_time = datetime.now()current_time_naive = current_time.replace(tzinfo=None)print(current_time_naive)在这个示例中，current_time 是一个带有时区的 datetime 对象。通过应用 replace() 办法，将其时区设为 None，创立了一个无时区的 datetime 对象 current_time_naive。 须要留神的是，将 datetime 对象的时区设为 None 后，该对象将失去时区信息，无奈进行时区转换或精确的时区操作。因而，在进行工夫计算或与其余带有时区的对象进行比拟时，倡议始终应用带有正确时区的 datetime 对象。

一、迭代器（Iterators）在Python中，迭代器是一个能够记住遍历的地位的对象。迭代器对象从汇合的第一项元素开始拜访，直到所有的元素被拜访完完结。迭代器只能往前不会后退。字符串，元组或列表等可迭代对象都能够用于创立迭代器。 迭代器实现了两个根本的办法，别离是 __iter__() 和 next()。 my_tuple = ("apple", "banana", "cherry")my_iter = iter(my_tuple)print(next(my_iter))print(next(my_iter))print(next(my_iter))这段代码中，首先咱们定义了一个元组 my_tuple，而后通过 iter() 函数失去了这个元组的迭代器 my_iter。之后，咱们通过 next() 函数来顺次拜访这个迭代器中的元素。 二、自定义迭代器咱们也能够创立本人的迭代器对象。要创立一个迭代器对象，你须要定义一个类，而后在这个类中实现 __iter__() 和 __next__() 办法。 上面是一个简略的自定义迭代器的例子： class MyNumbers: def __iter__(self): self.a = 1 return self def __next__(self): x = self.a self.a += 1 return xmy_class = MyNumbers()my_iter = iter(my_class)print(next(my_iter))print(next(my_iter))print(next(my_iter))print(next(my_iter))print(next(my_iter))在这段代码中，咱们定义了一个 MyNumbers 类，这个类实现了 __iter__() 和 __next__() 办法，因而它能够被视为一个迭代器类。咱们能够创立这个类的对象，并通过 iter() 函数失去它的迭代器。 三、生成器（Generators）生成器是一种非凡的迭代器，然而你不须要去实现类的 __iter__() 和 __next__() 办法。一个函数只有蕴含了 yield 语句，那么这个函数就是一个生成器。 生成器是一种使用方便的创立迭代器的办法。上面是一个简略的生成器的例子： def my_gen(): n = 1 print('This is printed first') yield n n += 1 print('This is printed second') yield n n += 1 print('This is printed last') yield na = my_gen()next(a)next(a)next(a)在这段代码中，my_gen 是一个生成器函数，它应用了 yield 语句。咱们能够间接调用 next() 函数来获取生成器中的下一个值。 ...

Python中什么是配置文件，配置文件如何应用，有哪些反对的配置文件等内容，话不多说，让咱们一起看看吧~ 1 什么是配置文件？配置文件是用于配置计算机程序的参数和初始化设置的文件，如果没有这些配置程序可能无奈运行或是影响运行（运行速度、便捷性等），应用配置文件的益处在于，局部内容以及环境运行时只须要批改配置文件的参数内容，而无需去代码里查找并批改，进步便捷性、进步可维护性。 2 配置文件有哪几种？配置次要有四种模式： 第一种是YAML、JSON、XML、TOML、INI、Linux零碎中的.bashrc一类，次要利用于软件测试畛域，在软件测试的畛域行业中，大多数公司采纳最新的YAML模式来作为配置文件，例如数据库地址、用例数据等内容的寄存，而少部分公司依然采纳旧的INI配置模式第二种是excel表格的模式，在excel表格中会有固定的title代表每个字段列的含意，有多列，以此来进行配置，多用于游戏畛域中，在游戏行业大量应用excel表格的模式，曾经是一个常态了。第三种是py文件，py文件对于一个纯Python我的项目而言是十分不便的，它不须要做数据的读取操作，只须要进行导入即可，不好的点在于，没有YAML这一类灵便，YAML配置文件无论是Python、Java等语言，都是反对的，且数据类型反对很多，而py的配置文件，就只能用作于python，有肯定的局限性。第四种是txt文本格式，通过读取的形式来辨认到txt文本内容，通常而言是测开或者测试工程师制作的简便工具，供应业务层面的测试人员进行应用，升高了YAML这种配置的了解难度，也防止了关上excel的迟缓，用轻量级txt来代替是一个不错的抉择。2.1 inipython3自带的ini .ini 文件是Initialization File的缩写，即初始化文件，是windows的零碎配置文件所采纳的存储格局，统管windows的各项配置 2.1.1 ini文件的定义.ini 文件通常由节（Section）、键（key）和值（value）组成。具体模式如下： db.ini[mysql]host = 127.0.0.1port = 3306user = rootpassword = 123456database = test2.1.2 python读取ini文件应用python内置的 configparser 规范库进行解析ini文件。 read() 读取文件内容 items() 获取指定节的所有键值对 # -*- coding: utf-8 -*-''' * @Author : wxy * @Date : 2022-08-24 11:11:06 * @Description : 读取ini文件 * @LastEditTime : 2022-08-24 11:11:06'''from configparser import ConfigParserfrom pprint import pprintimport pymysql# ini文件门路ini_file = './db.ini'# 读取ini的节（Section）db_name = 'mysql'# configparser实例化text = ConfigParser()# 读取ini文件内容text.read(ini_file)# text.items()返回list，元素为tuple,元组格局为 key,valuedb_tuple = text.items(db_name)print(db_tuple)# 将元组转换成dictdb_dict = dict(text.items(db_name))print(db_dict)2.2 jsonJSON(JavaScript Object Notation,) 是一种轻量级的数据交换格局。 ...

在Python中，文件操作是一个重要的概念。咱们通常须要读取文件中的数据进行解决，或者将解决后的数据保留到文件中。在本文中，咱们将介绍Python如何关上文件，以及如何读写文件内容。一、关上文件在Python中，咱们应用内置的open函数来关上文件。open函数的根本语法如下： file = open("filename", "mode")"filename"是要关上的文件的名称。"mode"是关上文件的模式。罕用的模式有："r"示意读取模式，"w"示意写入模式，"a"示意追加模式，"b"示意二进制模式。以下是一个关上文件的例子： file = open("test.txt", "r")在这个例子中，咱们关上了名为"test.txt"的文件，关上模式为"r"，即读取模式。留神，当咱们应用open函数关上文件后，肯定要记得在操作实现后敞开文件。咱们能够应用file.close()办法来敞开文件。 二、读取文件在Python中，咱们能够应用以下几种办法来读取文件中的数据： file.read()：读取文件中的所有内容，并返回一个字符串。file.readline()：读取文件中的一行内容，并返回一个字符串。file.readlines()：读取文件中的所有行，每行作为一个字符串，返回一个蕴含所有字符串的列表。以下是一个读取文件内容的例子： file = open("test.txt", "r")content = file.read()print(content)file.close()在这个例子中，咱们关上了名为"test.txt"的文件，读取了文件中的所有内容，而后打印了这些内容。 三、写入文件在Python中，咱们能够应用file.write()办法来写入文件。file.write()办法承受一个字符串作为参数，并将这个字符串写入文件。以下是一个写入文件的例子： file = open("test.txt", "w")file.write("Hello, World!")file.close()在这个例子中，咱们关上了名为"test.txt"的文件，写入模式为"w"，即写入模式。而后，咱们将字符串"Hello, World!"写入了这个文件。留神，当咱们应用写入模式("w")关上文件时，如果文件曾经存在，那么原来的文件内容将被齐全笼罩。如果咱们只想在文件的开端增加内容，而不是笼罩原来的内容，咱们能够应用追加模式("a")来关上文件。 四、应用with语句关上文件在Python中，咱们还能够应用with语句来关上文件。with语句能够确保文件在操作实现后被正确敞开，即便在解决文件的过程中产生了异样。以下是一个应用with语句关上文件的例子： with open("test.txt", "r") as file: content = file.read()print(content)在这个例子中，咱们应用with语句关上了名为"test.txt"的文件，并读取了文件中的所有内容。当with语句完结时，文件会被主动敞开，咱们不须要手动调用file.close()办法。 五、读写二进制文件在Python中，咱们也能够读写二进制文件。咱们只须要在关上文件的模式中增加"b"字符，就能够将文件关上为二进制模式。以下是一个读取二进制文件的例子： with open("test.bin", "rb") as file: content = file.read()在这个例子中，咱们关上了名为"test.bin"的二进制文件，并读取了文件中的所有内容。 六、论断Python提供了弱小的文件操作性能，咱们能够轻松地关上文件，读取文件内容，写入文件，以及解决二进制文件。通过把握Python的文件操作，咱们能够解决各种各样的数据，无论是文本数据还是二进制数据。以上就是对Python文件关上、读写的根本介绍，心愿对你有所帮忙。 七、最初如果感觉本文对你有帮忙记得 点个关注，给个赞，加个珍藏，更多精彩内容欢送查看。

一、介绍鸟类识别系统，应用Python作为次要开发语言，基于深度学习TensorFlow框架，搭建卷积神经网络算法。并通过对数据集进行训练，最初失去一个辨认精度较高的模型。并基于Django框架，开发网页端操作平台，实现用户上传一张图片辨认其名称。 数据集选自加州理工学院200种鸟类数据集 二、成果展现 三、演示视频+代码视频+残缺代码：https://www.yuque.com/ziwu/yygu3z/txsu6elpcf0o5az1 四、TensorFlow应用TensorFlow是由Google开发的一个开源机器学习框架。它的设计指标是让开发者可能更轻松地构建、训练和部署机器学习模型。TensorFlow的核心理念是应用计算图来示意简单的数值计算过程，这使得它可能高效地执行分布式计算和主动微分操作。 TensorFlow的特点之一是其灵活性。它提供了丰盛的工具和库，实用于各种机器学习工作和算法。无论是传统的机器学习算法还是深度学习模型，TensorFlow都能够提供弱小的反对。此外，TensorFlow还反对多种硬件和平台，包含CPU、GPU和TPU等，使得开发者能够依据理论需要抉择最合适的计算资源。 TensorFlow应用计算图来示意机器学习模型。计算图是一种数据流图，其中节点示意操作，边示意数据流。通过将模型表示为计算图，TensorFlow能够对模型进行高效的优化和并行化解决。此外，计算图的构造还使得TensorFlow可能轻松地将模型部署到分布式系统中，实现高性能的分布式训练和推理。 TensorFlow还提供了主动微分的性能，使得开发者能够轻松地计算模型的梯度。这对于训练深度学习模型来说尤为重要，因为梯度计算是反向流传算法的关键步骤。TensorFlow的主动微分性能大大简化了梯度计算的过程，缩小了开发者的工作量。 除了这些外围特点之外，TensorFlow还具备丰盛的生态系统和社区反对。它提供了许多高级API和预训练模型，使得开发者可能更快地构建模型。此外，TensorFlow还反对可视化工具，如TensorBoard，用于可视化模型的训练过程和性能剖析。 总的来说，TensorFlow是一个功能强大、灵便而又易用的机器学习框架。它的设计理念和特点使得开发者可能更加高效地构建、训练和部署机器学习模型，为机器学习和深度学习的钻研和利用提供了弱小的工具和反对。 上面介绍的是TensorFlow的应用的一个demo例子 import tensorflow as tffrom tensorflow.keras.applications.resnet50 import ResNet50from tensorflow.keras.preprocessing.image import ImageDataGenerator# 下载并解压数据集!wget http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz!tar -xf CUB_200_2011.tgz# 设置数据集门路和其余参数train_data_dir = 'CUB_200_2011/train' # 训练集门路validation_data_dir = 'CUB_200_2011/val' # 验证集门路test_data_dir = 'CUB_200_2011/test' # 测试集门路img_width, img_height = 224, 224 # 图像宽度和高度batch_size = 32 # 批次大小num_epochs = 10 # 训练轮数# 创立图像数据生成器train_datagen = ImageDataGenerator( rescale=1. / 255, # 像素值缩放为0-1之间 shear_range=0.2, # 随机剪切变换 zoom_range=0.2, # 随机缩放变换 horizontal_flip=True) # 随机程度翻转validation_datagen = ImageDataGenerator(rescale=1. / 255) # 验证集不进行数据加强train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical') # 生成训练集图像和标签的批次数据validation_generator = validation_datagen.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical') # 生成验证集图像和标签的批次数据# 创立并编译ResNet50模型base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(img_width, img_height, 3))model = tf.keras.Sequential([ base_model, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dense(200, activation='softmax')])model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])# 训练模型model.fit( train_generator, steps_per_epoch=train_generator.samples // batch_size, validation_data=validation_generator, validation_steps=validation_generator.samples // batch_size, epochs=num_epochs)# 保留模型model.save('bird_classification_model.h5')import tensorflow as tffrom tensorflow.keras.applications.resnet50 import ResNet50from tensorflow.keras.preprocessing.image import ImageDataGenerator# 下载并解压数据集!wget http://www.vision.caltech.edu/visipedia-data/CUB-200-2011/CUB_200_2011.tgz!tar -xf CUB_200_2011.tgz# 设置数据集门路和其余参数train_data_dir = 'CUB_200_2011/train' # 训练集门路validation_data_dir = 'CUB_200_2011/val' # 验证集门路test_data_dir = 'CUB_200_2011/test' # 测试集门路img_width, img_height = 224, 224 # 图像宽度和高度batch_size = 32 # 批次大小num_epochs = 10 # 训练轮数# 创立图像数据生成器train_datagen = ImageDataGenerator( rescale=1. / 255, # 像素值缩放为0-1之间 shear_range=0.2, # 随机剪切变换 zoom_range=0.2, # 随机缩放变换 horizontal_flip=True) # 随机程度翻转validation_datagen = ImageDataGenerator(rescale=1. / 255) # 验证集不进行数据加强train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical') # 生成训练集图像和标签的批次数据validation_generator = validation_datagen.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='categorical') # 生成验证集图像和标签的批次数据# 创立并编译ResNet50模型base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(img_width, img_height, 3))model = tf.keras.Sequential([ base_model, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dense(200, activation='softmax')])model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])# 训练模型model.fit( train_generator, steps_per_epoch=train_generator.samples // batch_size, validation_data=validation_generator, validation_steps=validation_generator.samples // batch_size, epochs=num_epochs)# 保留模型model.save('bird_classification_model.h5')

一、引言在开发大型软件或解决简单问题时，咱们常常须要一种办法来记录和跟踪程序的运行状态。这就是日志记录的主要用途。Python 提供了一个名为 logging 的规范库，能够帮忙咱们更好地实现这项工作。 在这篇文章中，咱们将介绍如何应用 Python 的 logging 库进行日志记录。咱们将涵盖根本的日志记录操作，如何配置和管制日志记录，以及如何利用日志记录进行调试。 二、根本的日志操作要在 Python 中记录日志，首先须要导入 logging 库。而后，你能够应用 logging 库中的五个函数来记录不同级别的日志：debug()、info()、warning()、error() 和 critical()。以下是一个简略的例子： import logginglogging.debug("这是一个 debug 级别的日志音讯")logging.info("这是一个 info 级别的日志音讯")logging.warning("这是一个 warning 级别的日志音讯")logging.error("这是一个 error 级别的日志音讯")logging.critical("这是一个 critical 级别的日志音讯")每一种级别的日志音讯都有其对应的重要性。默认状况下，只有 warning、error 和 critical 级别的日志会被记录。 三、配置日志记录logging 库提供了丰盛的配置选项，能够帮忙你管制日志的输入格局、输入地位以及输入级别等。 例如，你能够应用 logging.basicConfig() 函数来配置日志记录的级别和日志音讯的格局： import logginglogging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')在这个示例中，咱们设置了日志记录的级别为 DEBUG，这意味着所有级别的日志音讯都将被记录。咱们还设置了日志音讯的格局，包含了工夫戳、记录器的名称、日志级别和日志音讯自身。 四、应用日志记录器在 logging 库中，日志记录器（Logger）是进行日志记录的次要对象。每个日志记录器都有一个名字，和一些与其相干的行为。你能够应用 logging.getLogger(name) 函数来获取一个日志记录器，如果这个记录器不存在，这个函数将会创立一个。 以下是一个应用日志记录器的例子： import logginglogger = logging.getLogger('mylogger')logger.setLevel(logging.DEBUG)logger.debug("这是一个 debug 级别的日志音讯")在这个示例中，咱们首先获取了一个名为 'mylogger' 的日志记录器，而后设置了它的日志级别为 DEBUG。之后，咱们就能够通过这个日志记录器来记录日志了。 五、配置日志处理器在 logging 库中，处理器（Handler）决定如何解决每个日志音讯。例如，一个处理器可能会将日志音讯输入到控制台，而另一个处理器可能会将日志音讯写入到文件中。 要应用处理器，你须要创立一个处理器对象，而后增加到日志记录器中。以下是一个将日志音讯写入到文件中的例子： import logginglogger = logging.getLogger('mylogger')logger.setLevel(logging.DEBUG)# 创立一个处理器，用于写入日志文件fh = logging.FileHandler('mylog.log')fh.setLevel(logging.DEBUG)# 增加到 logger 中logger.addHandler(fh)logger.debug("这是一个 debug 级别的日志音讯")在这个示例中，咱们创立了一个 FileHandler 对象，并将其增加到了 logger 中。这样，logger 中的日志音讯就会被写入到 mylog.log 文件中。 ...

一、介绍迭代器（Iterators）和生成器（Generators）是 Python 中最弱小的性能之一，但也是老手最容易混同的局部。本文将深入探讨这两种概念，以及它们在 Python 编程中的理论利用。 二、了解迭代器首先，咱们来了解什么是迭代器。在 Python 中，迭代器是任何实现了迭代器协定（定义了 __iter__() 和 __next__() 办法）的对象。咱们能够通过调用 next() 办法获取迭代器的下一个值。当迭代器耗尽时，将引发 StopIteration 异样。 上面是一个简略的迭代器例子： class Counter: def __init__(self, low, high): self.current = low self.high = high def __iter__(self): return self def __next__(self): if self.current < self.high: num = self.current self.current += 1 return num raise StopIterationfor num in Counter(3, 9): print(num)这个 Counter 类定义了一个简略的迭代器，它从 low 开始，每次迭代减少 1，直到达到 high。留神咱们是如何在 __next__ 办法中抛出 StopIteration 的。这是因为 for 循环通过捕捉 StopIteration 异样来晓得何时进行迭代的。 三、了解生成器生成器是构建迭代器的一种更加优雅的形式。生成器是一种非凡类型的迭代器，但它的定义更为简略，能够间接应用函数语法。在函数中，咱们应用 yield 语句来返回值，而不是 return。当 yield 被调用时，函数的状态（包含局部变量）都会被保留，以供下次调用。 ...

一、介绍验证码识别系统，应用Python作为次要开发语言，基于深度学习TensorFlow框架，搭建卷积神经网络算法。并通过对数据集进行训练，最初失去一个辨认精度较高的模型。并基于Django框架，开发网页端操作平台，基于Pyqt5搭建桌面端操作界面，实现用户上传一张图片辨认其名称。 二、成果展现 三、演示视频视频+代码：https://www.yuque.com/ziwu/yygu3z/awhoxie8moiwvqi8 四、CNN卷积神经网络卷积神经网络（Convolutional Neural Network，CNN）的典型构造由多个档次组成，包含卷积层、池化层和全连贯层。上面是一个常见的CNN网络结构示例： 输出层（Input Layer）：承受输出数据，通常是图像数据。图像数据由像素组成，能够是二维图像（灰度图像）或三维图像（彩色图像）。卷积层（Convolutional Layers）：卷积层是CNN的外围局部。每个卷积层由多个卷积核（滤波器）组成，每个卷积核负责提取输出数据的某种特色。卷积核在输出数据上进行卷积操作，产生一系列特色图（feature maps）。卷积层通过部分感触野和参数共享的形式，捕获输出数据的部分特色并放弃空间结构。激活函数层（Activation Layers）：卷积层之后通常会增加激活函数，如ReLU（Rectified Linear Unit）函数。激活函数引入非线性个性，使得网络可能学习更简单的特色和模式。池化层（Pooling Layers）：池化层用于对特色图进行下采样，缩小特色图的空间尺寸，同时保留重要的特色信息。常见的池化操作有最大池化（Max Pooling）和均匀池化（Average Pooling）。全连贯层（Fully Connected Layers）：全连贯层将池化层输入的特色图展平为一维向量，并与输入层连贯。全连贯层的神经元与上一层的所有神经元相连接，负责学习高级特色和进行分类决策。输入层（Output Layer）：输入层通常是一个蕴含预测后果的向量，每个元素示意一个类别的概率分布。依据具体问题的要求，输入层可能采纳不同的激活函数，如softmax函数用于多类别分类问题。以上是一个简略的CNN网络结构示例，理论的CNN网络能够依据问题的复杂性和数据集的特点进行设计和调整。常见的改良包含增加额定的卷积层、应用批归一化（Batch Normalization）层来减速训练、引入残差连贯（Residual Connections）来解决梯度隐没问题等。依据具体任务的要求，还能够应用其余的层次结构和技术来改良网络性能。 以下是一个简略的示例，演示了如何应用CNN卷积神经网络对验证码图像进行训练和预测。 import osimport numpy as npimport tensorflow as tffrom tensorflow.keras import layers, modelsfrom PIL import Image# 定义数据集门路和其余参数dataset_path = '/path/to/dataset' # 数据集门路image_width = 100 # 图像宽度image_height = 100 # 图像高度num_classes = 10 # 类别数量batch_size = 32 # 批次大小epochs = 10 # 训练轮数# 加载数据集def load_dataset(): images = [] labels = [] for filename in os.listdir(dataset_path): if filename.endswith('.png'): image_path = os.path.join(dataset_path, filename) label = int(filename.split('_')[0]) # 文件名中的标签 image = Image.open(image_path).convert('L') # 关上并转换为灰度图像 image = image.resize((image_width, image_height)) # 调整图像大小 image = np.array(image) / 255.0 # 归一化像素值到 [0, 1] images.append(image) labels.append(label) images = np.array(images) labels = tf.keras.utils.to_categorical(labels, num_classes) return images, labels# 构建卷积神经网络模型def build_model(): model = models.Sequential() model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(image_width, image_height, 1))) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.MaxPooling2D((2, 2))) model.add(layers.Conv2D(64, (3, 3), activation='relu')) model.add(layers.Flatten()) model.add(layers.Dense(64, activation='relu')) model.add(layers.Dense(num_classes, activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) return model# 加载数据集images, labels = load_dataset()# 将数据集分为训练集和验证集split = int(0.8 * len(images))train_images, val_images = images[:split], images[split:]train_labels, val_labels = labels[:split], labels[split:]# 构建模型model = build_model()# 训练模型model.fit(train_images, train_labels, batch_size=batch_size, epochs=epochs, validation_data=(val_images, val_labels))# 保留模型model.save('captcha_model.h5')上述代码中，咱们首先定义了数据集门路和一些超参数。而后，通过load_dataset函数加载数据集。该函数遍历数据集文件夹中的图像文件，将图像转换为灰度图像、调整大小并进行归一化解决。同时，将图像数据存储在images数组中，将标签转换为独热编码（one-hot encoding）模式，并存储在labels数组中。 ...

一、介绍手势识别系统，应用Python作为次要开发语言，基于深度学习TensorFlow框架，搭建卷积神经网络算法。并通过对数据集进行训练，最初失去一个辨认精度较高的模型。并基于Django框架，开发网页端操作平台，实现用户上传一张图片辨认其名称。 二、成果展现 三、演示视频+代码视频+代码：https://www.yuque.com/ziwu/yygu3z/gp3gifl678hhz64c 四、关键技术TensorFlowTensorFlow是一种广泛应用于机器学习和深度学习畛域的开源软件库。它具备弱小的计算能力和灵活性，为手势识别系统的开发提供了重要反对。本章将介绍在基于TensorFlow的手势识别系统中所应用的关键技术，包含数据预处理、模型构建与训练以及模型优化等方面。 模型构建与训练： 在TensorFlow中，能够应用各种深度学习模型构建手势识别系统。其中，卷积神经网络（CNN）是一种罕用的模型架构，因其在图像处理工作中表现出色而备受青眼。模型的构建过程包含定义网络结构、抉择适合的激活函数和损失函数等。在模型构建实现后，通过反向流传算法进行训练，应用标注好的数据进行迭代优化，使模型逐步收敛并进步精确 模型评估与部署： 在实现模型训练后，须要对模型进行评估和测试。罕用的评估指标包含准确率、准确率、召回率和F1值等。通过在测试集上进行评估，能够理解模型的性能和泛化能力。在模型部署阶段，能够将训练好的模型导出为可部署的格局。 import tensorflow as tffrom tensorflow.keras.applications.resnet50 import ResNet50from tensorflow.keras.preprocessing.image import ImageDataGenerator# 设置数据集门路train_data_dir = 'path/to/training/data'validation_data_dir = 'path/to/validation/data'# 设置模型参数num_classes = 10input_shape = (224, 224, 3)batch_size = 32epochs = 10# 数据预处理与加强train_datagen = ImageDataGenerator(rescale=1./255, # 归一化 rotation_range=20, # 随机旋转 width_shift_range=0.2, # 随机程度平移 height_shift_range=0.2, # 随机垂直平移 horizontal_flip=True) # 随机程度翻转validation_datagen = ImageDataGenerator(rescale=1./255) # 只进行归一化# 从文件夹加载训练和验证数据train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=input_shape[:2], batch_size=batch_size, class_mode='categorical')validation_generator = validation_datagen.flow_from_directory( validation_data_dir, target_size=input_shape[:2], batch_size=batch_size, class_mode='categorical')# 加载预训练的ResNet50模型，不包含顶层（全连贯层）base_model = ResNet50(weights='imagenet', include_top=False, input_shape=input_shape)# 解冻预训练模型的权重for layer in base_model.layers: layer.trainable = False# 构建顶层分类器model = tf.keras.models.Sequential([ base_model, tf.keras.layers.GlobalAveragePooling2D(), tf.keras.layers.Dense(num_classes, activation='softmax')])# 编译模型model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])# 训练模型model.fit(train_generator, steps_per_epoch=train_generator.samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=validation_generator.samples // batch_size)# 保留模型model.save('gesture_recognition_model.h5')上述示例代码中，应用了ImageDataGenerator来进行数据预处理和加强操作，通过调整其参数能够依据理论需要进行配置。加载了预训练的ResNet50模型，并在其根底上构建了顶层分类器。最初，应用fit函数对模型进行训练，并保留训练好的模型。 ...

一、介绍在软件开发中，单元测试是一种测试方法，它用于查看单个软件组件（例如函数或办法）的正确性。Python 提供了一个内置的单元测试库，名为 unittest，能够用来编写测试代码，而后运行测试，并报告测试后果。 本文将向你介绍如何应用 unittest 来编写和运行单元测试。通过浏览本文，你将理解 unittest 的根本应用办法，以及如何应用 unittest 中的断言办法和测试用例组织构造。 二、根底概念和办法在 unittest 中，每个测试用例都是 unittest.TestCase 的一个实例，而测试用例的汇合就是一个测试套件。你能够通过实现 unittest.TestCase 的子类来定义你的测试用例，而后通过实例化这个子类的对象来创立具体的测试用例。 这是一个简略的示例，演示了如何定义和应用测试用例： import unittestclass TestStringMethods(unittest.TestCase): def test_upper(self): self.assertEqual('foo'.upper(), 'FOO') def test_isupper(self): self.assertTrue('FOO'.isupper()) self.assertFalse('Foo'.isupper()) def test_split(self): s = 'hello world' self.assertEqual(s.split(), ['hello', 'world']) # check that s.split fails when the separator is not a string with self.assertRaises(TypeError): s.split(2)if __name__ == '__main__': unittest.main()在上述代码中，咱们定义了一个 TestStringMethods 类，这个类继承自 unittest.TestCase。在这个类中，咱们定义了三个办法：test_upper、test_isupper 和 test_split。这三个办法就是咱们的三个测试用例。 unittest.TestCase 类提供了许多断言办法，例如 assertEqual(a, b)、assertTrue(x) 和 assertFalse(x)。这些断言办法用来查看咱们的代码是否满足预期的行为。 三、运行测试和查看测试后果当咱们定义好测试用例后，就能够运行这些测试用例，并查看测试后果了。你能够通过执行 unittest.main() 来运行所有的测试用例。 ...

Python面试必知100例。收集整理了目前Python岗位常见的面试题，心愿大家通过学习了解相干知识点。上面介绍的是6~10道题。六、什么是lambda函数？在Python中，lambda函数也被称为匿名函数，这是因为它们没有正式的函数名。lambda函数是一种简洁的创立小型函数的形式。lambda函数的根本语法如下： lambda arguments: expression这里，arguments是函数的输出，而expression是函数的输入。lambda函数能够承受任意数量的参数，但只能有一个表达式。例如，咱们能够创立一个lambda函数来计算两个数字的和： add = lambda x, y: x + yprint(add(5, 3)) # Output: 8在这个例子中，lambda函数承受两个参数x和y，并返回它们的和。而后咱们将这个lambda函数赋值给add，这样咱们就能够像应用其余函数一样应用这个lambda函数了。只管lambda函数在代码中看起来更简洁，然而它们通常只在须要简略性能的中央应用，例如作为排序函数的关键字参数。对于更简单的性能，通常举荐应用残缺的def语句来定义函数。 七、什么是装璜器？在Python中，装璜器（Decorator）是一种非凡类型的函数，它容许咱们向曾经存在的对象增加额定的性能。装璜器的常见用处包含插入日志、性能测试、事务处理、缓存、权限校验等场景。装璜器是批改已有对象的一种轻便、弱小且可保护的形式。装璜器的根本语法如下： @decoratordef function(): pass这里，@decorator是装璜器，function()是要被装璜的函数。Python会先执行装璜器来装璜函数，而后再执行这个函数。以下是一个简略的装璜器示例： def my_decorator(func): def wrapper(): print("在函数被调用之前，产生了一些事件。") func() print("在函数被调用之后，产生了一些事件。") return wrapper@my_decoratordef say_hello(): print("你好！")say_hello()在这个例子中，my_decorator是一个装璜器，它承受一个函数作为参数，并返回一个新的函数wrapper。这个新的函数在调用原函数之前和之后都会执行一些额定的代码。而后，咱们应用@my_decorator来装璜say_hello函数。最初，当咱们调用say_hello函数时，它会先执行装璜器增加的代码，而后再执行本来的say_hello函数代码。 八、什么是多过程？多过程是一种并发执行技术，其中程序的不同局部在不同的过程中运行。每个过程都有本人的内存空间和系统资源。过程是操作系统进行资源分配和调度的根本单位，是利用程序运行的载体。多过程技术的次要长处是它能够充分利用多核CPU的计算能力。因为每个过程都有本人的内存空间，所以在一个过程中产生的谬误不会影响其余过程。这使得多过程应用程序更加稳固。在Python中，能够应用multiprocessing模块来创立和治理多过程。例如，你能够创立一个Process对象，而后调用它的start()办法来启动一个新的过程。能够应用Queue或Pipe等工具进行过程间的通信。须要留神的是，因为Python的全局解释器锁（GIL）的存在，多线程在Python中通常无奈无效利用多核CPU。因而，对于计算密集型工作，应用多过程通常比应用多线程更无效。 九、什么是多线程多线程是一种并发执行的技术，它容许单个程序中的不同局部同时执行。这些不同局部被称为线程，所有线程都在同一过程中运行，共享雷同的内存空间和系统资源。与多过程相比，多线程有几个长处： 线程的启动和完结的开销相比过程要小得多，因为所有线程都在同一过程中，无需进行过程上下文的切换。线程之间的通信更加简略，因为它们共享内存空间，能够间接拜访雷同的数据。然而，这也须要一些同步机制（如互斥锁、信号量等）来避免多个线程同时批改同一份数据，导致数据不统一。在Python中，能够应用threading模块来创立和治理线程。例如，你能够创立一个Thread对象，而后调用它的start()办法来启动一个新的线程。 十、请介绍下深拷贝与浅拷贝的区别在Python中，深拷贝和浅拷贝是两种不同的复制形式，次要区别在于它们解决对象外部的子对象的形式不同。 浅拷贝（Shallow Copy）：创立一个新的对象，但只复制原对象的援用，不复制外部的子对象。这意味着新对象和原对象会共享外部的子对象。在Python中，能够应用copy.copy()函数或者应用某些类型的构造函数（如list(), dict()等）来创立浅拷贝。深拷贝（Deep Copy）：创立一个新的对象，并递归复制原对象的所有元素，包含外部的子对象。这意味着新对象和原对象不会共享任何元素。在Python中，能够应用copy.deepcopy()函数来创立深拷贝。 import copy# 浅拷贝示例a = [[1, 2, 3], [4, 5, 6]]b = copy.copy(a)b[0][0] = 100print(a) # Output: [[100, 2, 3], [4, 5, 6]]# 深拷贝示例a = [[1, 2, 3], [4, 5, 6]]b = copy.deepcopy(a)b[0][0] = 100print(a) # Output: [[1, 2, 3], [4, 5, 6]]在浅拷贝示例中，批改了b的元素，但a的相应元素也产生了变动，这是因为a和b共享外部的子对象。而在深拷贝示例中，批改了b的元素，a的元素没有发生变化，这是因为a和b不共享任何元素。 ...

原文链接 Ubuntu装置Python的形式与其余Linux零碎有所不同，在这里介绍一下。 配置环境切换的国内源： sudo gedit /etc/apt/sources.list将原有的源正文掉，增加如下内容： #清华源deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-updates main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-backports main restricted universe multiversedeb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ focal-security main restricted universe multiverse更新apt-get： sudo apt-get update装置build-essential： sudo apt-get install build-essential装置Python装置Python3.8： sudo apt-get install python3.8sudo apt install python3-pip查看是否胜利： 查看Python是否装置胜利： python3 --version输入版本号Python 3.8.5即示意装置胜利。 Ubuntu更换源长期更换应用阿里源： pip install *** -i https://mirrors.aliyun.com/pypi/simple/ 永恒更换新建.pip暗藏文件夹： cd ~ mkdir .pip新建pip.conf文件： cd .piptouch pip.conf 用vim编辑pip.conf文件 vim pip.conf 内容如下： [global]index-url = https://mirrors.aliyun.com/pypi/simple[install]trusted-host=mirrors.aliyun.com   ...

原文链接 Python和Anaconda的版本对应关系如下： Packages included in Anaconda 2022.10 for 64-bit Linux on x86_64 CPUs with Python 3.10Packages included in Anaconda 2022.10 for 64-bit Linux on ARMv8 CPUs with Python 3.10Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Power CPUs with Python 3.10Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Z CPUs with Python 3.10Packages included in Anaconda 2022.10 for macOS on x86_64 with Python 3.10Packages included in Anaconda 2022.10 for macOS on Apple M1 with Python 3.10Packages included in Anaconda 2022.10 for 64-bit Windows with Python 3.10Packages included in Anaconda 2022.10 for 64-bit Linux on x86_64 CPUs with Python 3.7Packages included in Anaconda 2022.10 for 64-bit Linux on ARMv8 CPUs with Python 3.7Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Z CPUs with Python 3.7Packages included in Anaconda 2022.10 for macOS on x86_64 with Python 3.7Packages included in Anaconda 2022.10 for 32-bit Windows with Python 3.7Packages included in Anaconda 2022.10 for 64-bit Windows with Python 3.7Packages included in Anaconda 2022.10 for 64-bit Linux on x86_64 CPUs with Python 3.8Packages included in Anaconda 2022.10 for 64-bit Linux on ARMv8 CPUs with Python 3.8Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Z CPUs with Python 3.8Packages included in Anaconda 2022.10 for macOS on x86_64 with Python 3.8Packages included in Anaconda 2022.10 for macOS on Apple M1 with Python 3.8Packages included in Anaconda 2022.10 for 32-bit Windows with Python 3.8Packages included in Anaconda 2022.10 for 64-bit Windows with Python 3.8Packages included in Anaconda 2022.10 for 64-bit Linux on x86_64 CPUs with Python 3.9Packages included in Anaconda 2022.10 for 64-bit Linux on ARMv8 CPUs with Python 3.9Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Power CPUs with Python 3.9Packages included in Anaconda 2022.10 for 64-bit Linux on IBM Z CPUs with Python 3.9Packages included in Anaconda 2022.10 for macOS on x86_64 with Python 3.9Packages included in Anaconda 2022.10 for macOS on Apple M1 with Python 3.9Packages included in Anaconda 2022.10 for 32-bit Windows with Python 3.9Packages included in Anaconda 2022.10 for 64-bit Windows with Python 3.9Packages for 64-bit Linux on x86_64 CPUs with Python 3.7Packages for 64-bit Linux on ARMv8 CPUs with Python 3.7Packages for 64-bit Linux on IBM Power CPUs with Python 3.7Packages for 64-bit Linux on IBM Z CPUs with Python 3.7Packages for macOS on x86_64 with Python 3.7Packages for 32-bit Windows with Python 3.7Packages for 64-bit Windows with Python 3.7Packages for 64-bit Linux on x86_64 CPUs with Python 3.8Packages for 64-bit Linux on ARMv8 CPUs with Python 3.8Packages for 64-bit Linux on IBM Power CPUs with Python 3.8Packages for 64-bit Linux on IBM Z CPUs with Python 3.8Packages for macOS on x86_64 with Python 3.8Packages for macOS on Apple M1 with Python 3.8Packages for 32-bit Windows with Python 3.8Packages for 64-bit Windows with Python 3.8Packages for 64-bit Linux on x86_64 CPUs with Python 3.9Packages for 64-bit Linux on ARMv8 CPUs with Python 3.9Packages for 64-bit Linux on IBM Power CPUs with Python 3.9Packages for 64-bit Linux on IBM Z CPUs with Python 3.9Packages for macOS on x86_64 with Python 3.9Packages for macOS on Apple M1 with Python 3.9Packages for 32-bit Windows with Python 3.9Packages for 64-bit Windows with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Linux on x86_64 CPUs with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Linux on ARMv8 Graviton2 CPUs with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Power CPUs with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Z CPUs with Python 3.9Packages included in Anaconda 2021.11 for macOS on x86_64 with Python 3.9Packages included in Anaconda 2021.11 for 32-bit Windows with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Windows with Python 3.9Packages included in Anaconda 2021.11 for 64-bit Linux on x86_64 CPUs with Python 3.8Packages included in Anaconda 2021.11 for 64-bit Linux on ARMv8 Graviton2 CPUs with Python 3.8Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Z CPUs with Python 3.8Packages included in Anaconda 2021.11 for macOS on x86_64 with Python 3.8Packages included in Anaconda 2021.11 for 32-bit Windows with Python 3.8Packages included in Anaconda 2021.11 for 64-bit Windows with Python 3.8Packages included in Anaconda 2021.11 for 64-bit Linux on x86_64 CPUs with Python 3.7Packages included in Anaconda 2021.11 for 64-bit Linux on ARMv8 Graviton2 CPUs with Python 3.7Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2021.11 for 64-bit Linux on IBM Z CPUs with Python 3.7Packages included in Anaconda 2021.11 for macOS on x86_64 with Python 3.7Packages included in Anaconda 2021.11 for 32-bit Windows with Python 3.7Packages included in Anaconda 2021.11 for 64-bit Windows with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Linux on x86_64 CPUs with Python 3.9Packages included in Anaconda 2021.05 for 64-bit Linux on ARMv8 CPUs with Python 3.9Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Power CPUs with Python 3.9Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Z CPUs with Python 3.9Packages included in Anaconda 2021.05 for macOS on x86_64 with Python 3.9Packages included in Anaconda 2021.05 for 32-bit Windows with Python 3.9Packages included in Anaconda 2021.05 for 64-bit Windows with Python 3.9Packages included in Anaconda 2021.05 for 64-bit Linux on x86_64 CPUs with Python 3.8Packages included in Anaconda 2021.05 for 64-bit Linux on ARMv8 CPUs with Python 3.8Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Z CPUs with Python 3.8Packages included in Anaconda 2021.05 for macOS on x86_64 with Python 3.8Packages included in Anaconda 2021.05 for 32-bit Windows with Python 3.8Packages included in Anaconda 2021.05 for 64-bit Windows with Python 3.8Packages included in Anaconda 2021.05 for 64-bit Linux on x86_64 CPUs with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Linux on ARMv8 CPUs with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Z CPUs with Python 3.7Packages included in Anaconda 2021.05 for macOS on x86_64 with Python 3.7Packages included in Anaconda 2021.05 for 32-bit Windows with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Windows with Python 3.7Packages included in Anaconda 2021.05 for 64-bit Linux with Python 3.6Packages included in Anaconda 2021.05 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2021.05 for macOS with Python 3.6Packages included in Anaconda 2021.05 for 32-bit Windows with Python 3.6Packages included in Anaconda 2021.05 for 64-bit Windows with Python 3.6Packages included in Anaconda 2021.04 for 64-bit Linux on x86_64 CPUs with Python 3.9Packages included in Anaconda 2021.04 for 64-bit Linux on ARMv8 CPUs with Python 3.9Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Power CPUs with Python 3.9Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Z CPUs with Python 3.9Packages included in Anaconda 2021.04 for macOS on x86_64 with Python 3.9Packages included in Anaconda 2021.04 for 32-bit Windows with Python 3.9Packages included in Anaconda 2021.04 for 64-bit Windows with Python 3.9Packages included in Anaconda 2021.04 for 64-bit Linux on x86_64 CPUs with Python 3.8Packages included in Anaconda 2021.04 for 64-bit Linux on ARMv8 CPUs with Python 3.8Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Z CPUs with Python 3.8Packages included in Anaconda 2021.04 for macOS on x86_64 with Python 3.8Packages included in Anaconda 2021.04 for 32-bit Windows with Python 3.8Packages included in Anaconda 2021.04 for 64-bit Windows with Python 3.8Packages included in Anaconda 2021.04 for 64-bit Linux on x86_64 CPUs with Python 3.7Packages included in Anaconda 2021.04 for 64-bit Linux on ARMv8 CPUs with Python 3.7Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2021.04 for 64-bit Linux on IBM Z CPUs with Python 3.7Packages included in Anaconda 2021.04 for macOS on x86_64 with Python 3.7Packages included in Anaconda 2021.04 for 32-bit Windows with Python 3.7Packages included in Anaconda 2021.04 for 64-bit Windows with Python 3.7Packages included in Anaconda 2020.11 for 64-bit Linux with Python 3.8Packages included in Anaconda 2020.11 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2020.11 for macOS with Python 3.8Packages included in Anaconda 2020.11 for 32-bit Windows with Python 3.8Packages included in Anaconda 2020.11 for 64-bit Windows with Python 3.8Packages included in Anaconda 2020.11 for 64-bit Linux with Python 3.7Packages included in Anaconda 2020.11 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2020.11 for macOS with Python 3.7Packages included in Anaconda 2020.11 for 32-bit Windows with Python 3.7Packages included in Anaconda 2020.11 for 64-bit Windows with Python 3.7Packages included in Anaconda 2020.07 for 64-bit Linux with Python 3.8Packages included in Anaconda 2020.07 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2020.07 for macOS with Python 3.8Packages included in Anaconda 2020.07 for 32-bit Windows with Python 3.8Packages included in Anaconda 2020.07 for 64-bit Windows with Python 3.8Packages included in Anaconda 2020.07 for 64-bit Linux with Python 3.7Packages included in Anaconda 2020.07 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2020.07 for macOS with Python 3.7Packages included in Anaconda 2020.07 for 32-bit Windows with Python 3.7Packages included in Anaconda 2020.07 for 64-bit Windows with Python 3.7Packages included in Anaconda 2020.07 for 64-bit Linux with Python 3.6Packages included in Anaconda 2020.07 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2020.07 for macOS with Python 3.6Packages included in Anaconda 2020.07 for 32-bit Windows with Python 3.6Packages included in Anaconda 2020.07 for 64-bit Windows with Python 3.6Packages included in Anaconda 2020.02 for 64-bit Linux with Python 3.8Packages included in Anaconda 2020.02 for 64-bit Linux on IBM Power CPUs with Python 3.8Packages included in Anaconda 2020.02 for macOS with Python 3.8Packages included in Anaconda 2020.02 for 32-bit Windows with Python 3.8Packages included in Anaconda 2020.02 for 64-bit Windows with Python 3.8Packages included in Anaconda 2020.02 for 64-bit Linux with Python 3.7Packages included in Anaconda 2020.02 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2020.02 for macOS with Python 3.7Packages included in Anaconda 2020.02 for 32-bit Windows with Python 3.7Packages included in Anaconda 2020.02 for 64-bit Windows with Python 3.7Packages included in Anaconda 2020.02 for 64-bit Linux with Python 3.6Packages included in Anaconda 2020.02 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2020.02 for macOS with Python 3.6Packages included in Anaconda 2020.02 for 32-bit Windows with Python 3.6Packages included in Anaconda 2020.02 for 64-bit Windows with Python 3.6Packages included in Anaconda 2019.10 for 64-bit Linux with Python 3.7Packages included in Anaconda 2019.10 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2019.10 for macOS with Python 3.7Packages included in Anaconda 2019.10 for 32-bit Windows with Python 3.7Packages included in Anaconda 2019.10 for 64-bit Windows with Python 3.7Packages included in Anaconda 2019.10 for 64-bit Linux with Python 3.6Packages included in Anaconda 2019.10 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2019.10 for macOS with Python 3.6Packages included in Anaconda 2019.10 for 32-bit Windows with Python 3.6Packages included in Anaconda 2019.10 for 64-bit Windows with Python 3.6Packages included in Anaconda 2019.10 for 64-bit Linux with Python 2.7Packages included in Anaconda 2019.10 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 2019.10 for macOS with Python 2.7Packages included in Anaconda 2019.10 for 32-bit Windows with Python 2.7Packages included in Anaconda 2019.10 for 64-bit Windows with Python 2.7Packages included in Anaconda 2019.07 for 64-bit Linux with Python 3.7Packages included in Anaconda 2019.07 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2019.07 for macOS with Python 3.7Packages included in Anaconda 2019.07 for 32-bit Windows with Python 3.7Packages included in Anaconda 2019.07 for 64-bit Windows with Python 3.7Packages included in Anaconda 2019.07 for 64-bit Linux with Python 3.6Packages included in Anaconda 2019.07 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2019.07 for macOS with Python 3.6Packages included in Anaconda 2019.07 for 32-bit Windows with Python 3.6Packages included in Anaconda 2019.07 for 64-bit Windows with Python 3.6Packages included in Anaconda 2019.07 for 64-bit Linux with Python 2.7Packages included in Anaconda 2019.07 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 2019.07 for macOS with Python 2.7Packages included in Anaconda 2019.07 for 32-bit Windows with Python 2.7Packages included in Anaconda 2019.07 for 64-bit Windows with Python 2.7Packages included in Anaconda 2019.03 for 64-bit Linux with Python 3.7Packages included in Anaconda 2019.03 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2019.03 for macOS with Python 3.7Packages included in Anaconda 2019.03 for 32-bit Windows with Python 3.7Packages included in Anaconda 2019.03 for 64-bit Windows with Python 3.7Packages included in Anaconda 2019.03 for 64-bit Linux with Python 3.6Packages included in Anaconda 2019.03 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2019.03 for macOS with Python 3.6Packages included in Anaconda 2019.03 for 32-bit Windows with Python 3.6Packages included in Anaconda 2019.03 for 64-bit Windows with Python 3.6Packages included in Anaconda 2019.03 for 64-bit Linux with Python 2.7Packages included in Anaconda 2019.03 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 2019.03 for macOS with Python 2.7Packages included in Anaconda 2019.03 for 32-bit Windows with Python 2.7Packages included in Anaconda 2019.03 for 64-bit Windows with Python 2.7Packages included in Anaconda 2018.12 for 32-bit Linux with Python 3.7Packages included in Anaconda 2018.12 for 64-bit Linux with Python 3.7Packages included in Anaconda 2018.12 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 2018.12 for macOS with Python 3.7Packages included in Anaconda 2018.12 for 32-bit Windows with Python 3.7Packages included in Anaconda 2018.12 for 64-bit Windows with Python 3.7Packages included in Anaconda 2018.12 for 32-bit Linux with Python 3.6Packages included in Anaconda 2018.12 for 64-bit Linux with Python 3.6Packages included in Anaconda 2018.12 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 2018.12 for macOS with Python 3.6Packages included in Anaconda 2018.12 for 32-bit Windows with Python 3.6Packages included in Anaconda 2018.12 for 64-bit Windows with Python 3.6Packages included in Anaconda 2018.12 for 32-bit Linux with Python 2.7Packages included in Anaconda 2018.12 for 64-bit Linux with Python 2.7Packages included in Anaconda 2018.12 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 2018.12 for macOS with Python 2.7Packages included in Anaconda 2018.12 for 32-bit Windows with Python 2.7Packages included in Anaconda 2018.12 for 64-bit Windows with Python 2.7Packages included in Anaconda 5.3.0 for 32-bit Linux with Python 3.7Packages included in Anaconda 5.3.0 for 64-bit Linux with Python 3.7Packages included in Anaconda 5.3.0 for 64-bit Linux on IBM Power CPUs with Python 3.7Packages included in Anaconda 5.3.0 for 64-bit macOS with Python 3.7Packages included in Anaconda 5.3.0 for 32-bit Windows with Python 3.7Packages included in Anaconda 5.3.0 for 64-bit Windows with Python 3.7Packages included in Anaconda 5.3.0 for 32-bit Linux with Python 3.6Packages included in Anaconda 5.3.0 for 64-bit Linux with Python 3.6Packages included in Anaconda 5.3.0 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 5.3.0 for macOS with Python 3.6Packages included in Anaconda 5.3.0 for 32-bit Windows with Python 3.6Packages included in Anaconda 5.3.0 for 64-bit Windows with Python 3.6Packages included in Anaconda 5.3.0 for 32-bit Linux with Python 2.7Packages included in Anaconda 5.3.0 for 64-bit Linux with Python 2.7Packages included in Anaconda 5.3.0 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 5.3.0 for macOS with Python 2.7Packages included in Anaconda 5.3.0 for 32-bit Windows with Python 2.7Packages included in Anaconda 5.3.0 for 64-bit Windows with Python 2.7Packages included in Anaconda 5.2.0 for 32-bit Linux with Python 3.6Packages included in Anaconda 5.2.0 for 64-bit Linux with Python 3.6Packages included in Anaconda 5.2.0 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 5.2.0 for macOS with Python 3.6Packages included in Anaconda 5.2.0 for 32-bit Windows with Python 3.6Packages included in Anaconda 5.2.0 for 64-bit Windows with Python 3.6Packages included in Anaconda 5.2.0 for 32-bit Linux with Python 3.5Packages included in Anaconda 5.2.0 for 64-bit Linux with Python 3.5Packages included in Anaconda 5.2.0 for 64-bit Linux on IBM Power CPUs with Python 3.5Packages included in Anaconda 5.2.0 for macOS with Python 3.5Packages included in Anaconda 5.2.0 for 32-bit Windows with Python 3.5Packages included in Anaconda 5.2.0 for 64-bit Windows with Python 3.5Packages included in Anaconda 5.2.0 for 32-bit Linux with Python 2.7Packages included in Anaconda 5.2.0 for 64-bit Linux with Python 2.7Packages included in Anaconda 5.2.0 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 5.2.0 for macOS with Python 2.7Packages included in Anaconda 5.2.0 for 32-bit Windows with Python 2.7Packages included in Anaconda 5.2.0 for 64-bit Windows with Python 2.7Packages included in Anaconda 5.1.0 for 32-bit Linux with Python 3.6Packages included in Anaconda 5.1.0 for 64-bit Linux with Python 3.6Packages included in Anaconda 5.1.0 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 5.1.0 for macOS with Python 3.6Packages included in Anaconda 5.1.0 for 32-bit Windows with Python 3.6Packages included in Anaconda 5.1.0 for 64-bit Windows with Python 3.6Packages included in Anaconda 5.1.0 for 32-bit Linux with Python 3.5Packages included in Anaconda 5.1.0 for 64-bit Linux with Python 3.5Packages included in Anaconda 5.1.0 for 64-bit Linux on IBM Power CPUs with Python 3.5Packages included in Anaconda 5.1.0 for macOS with Python 3.5Packages included in Anaconda 5.1.0 for 32-bit Windows with Python 3.5Packages included in Anaconda 5.1.0 for 64-bit Windows with Python 3.5Packages included in Anaconda 5.1.0 for 32-bit Linux with Python 2.7Packages included in Anaconda 5.1.0 for 64-bit Linux with Python 2.7Packages included in Anaconda 5.1.0 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 5.1.0 for macOS with Python 2.7Packages included in Anaconda 5.1.0 for 32-bit Windows with Python 2.7Packages included in Anaconda 5.1.0 for 64-bit Windows with Python 2.7Packages included in Anaconda 5.0.1 for 32-bit Linux with Python 3.6Packages included in Anaconda 5.0.1 for 64-bit Linux with Python 3.6Packages included in Anaconda 5.0.1 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 5.0.1 for macOS with Python 3.6Packages included in Anaconda 5.0.1 for 32-bit Windows with Python 3.6Packages included in Anaconda 5.0.1 for 64-bit Windows with Python 3.6Packages included in Anaconda 5.0.1 for 32-bit Linux with Python 3.5Packages included in Anaconda 5.0.1 for 64-bit Linux with Python 3.5Packages included in Anaconda 5.0.1 for 64-bit Linux on IBM Power CPUs with Python 3.5Packages included in Anaconda 5.0.1 for macOS with Python 3.5Packages included in Anaconda 5.0.1 for 32-bit Windows with Python 3.5Packages included in Anaconda 5.0.1 for 64-bit Windows with Python 3.5Packages included in Anaconda 5.0.1 for 32-bit Linux with Python 2.7Packages included in Anaconda 5.0.1 for 64-bit Linux with Python 2.7Packages included in Anaconda 5.0.1 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 5.0.1 for macOS with Python 2.7Packages included in Anaconda 5.0.1 for 32-bit Windows with Python 2.7Packages included in Anaconda 5.0.1 for 64-bit Windows with Python 2.7Packages included in Anaconda 5.0.0 for 32-bit Linux with Python 3.6Packages included in Anaconda 5.0.0 for 64-bit Linux with Python 3.6Packages included in Anaconda 5.0.0 for 64-bit Linux on IBM Power CPUs with Python 3.6Packages included in Anaconda 5.0.0 for macOS with Python 3.6Packages included in Anaconda 5.0.0 for 32-bit Windows with Python 3.6Packages included in Anaconda 5.0.0 for 64-bit Windows with Python 3.6Packages included in Anaconda 5.0.0 for 32-bit Linux with Python 3.5Packages included in Anaconda 5.0.0 for 64-bit Linux with Python 3.5Packages included in Anaconda 5.0.0 for 64-bit Linux on IBM Power CPUs with Python 3.5Packages included in Anaconda 5.0.0 for macOS with Python 3.5Packages included in Anaconda 5.0.0 for 32-bit Windows with Python 3.5Packages included in Anaconda 5.0.0 for 64-bit Windows with Python 3.5Packages included in Anaconda 5.0.0 for 32-bit Linux with Python 2.7Packages included in Anaconda 5.0.0 for 64-bit Linux with Python 2.7Packages included in Anaconda 5.0.0 for 64-bit Linux on IBM Power CPUs with Python 2.7Packages included in Anaconda 5.0.0 for macOS with Python 2.7Packages included in Anaconda 5.0.0 for 32-bit Windows with Python 2.7Packages included in Anaconda 5.0.0 for 64-bit Windows with Python 2.7Packages included in Anaconda 4.4.0 for Python version 3.6Packages included in Anaconda 4.4.0 for Python version 3.5Packages included in Anaconda 4.4.0 for Python version 2.7Packages included in Anaconda 4.3.1 for Python version 3.6Packages included in Anaconda 4.3.1 for Python version 3.5Packages included in Anaconda 4.3.1 for Python version 3.4Packages included in Anaconda 4.3.1 for Python version 2.7Packages included in Anaconda 4.3.0 for Python version 3.6Packages included in Anaconda 4.3.0 for Python version 3.5Packages included in Anaconda 4.3.0 for Python version 3.4Packages included in Anaconda 4.3.0 for Python version 2.7Packages included in Anaconda 4.2.0 for Python version 3.5Packages included in Anaconda 4.2.0 for Python version 3.4Packages included in Anaconda 4.2.0 for Python version 2.7Packages included in Anaconda 4.1.1 for Python version 3.5Packages included in Anaconda 4.1.1 for Python version 3.4Packages included in Anaconda 4.1.1 for Python version 2.7Packages included in Anaconda 4.1.0 for Python version 3.5Packages included in Anaconda 4.1.0 for Python version 3.4Packages included in Anaconda 4.1.0 for Python version 2.7Packages included in Anaconda 4.0.0 for Python version 3.5Packages included in Anaconda 4.0.0 for Python version 3.4Packages included in Anaconda 4.0.0 for Python version 2.7Packages included in Anaconda 2.5.0 for Python version 3.5Packages included in Anaconda 2.5.0 for Python version 3.4Packages included in Anaconda 2.5.0 for Python version 2.7Packages included in Anaconda 2.4.1 for Python version 3.5Packages included in Anaconda 2.4.1 for Python version 3.4Packages included in Anaconda 2.4.1 for Python version 2.7Packages included in Anaconda 2.4.0 for Python version 3.5Packages included in Anaconda 2.4.0 for Python version 3.4Packages included in Anaconda 2.4.0 for Python version 2.7Packages included in Anaconda 2.3.0 for Python version 3.4Packages included in Anaconda 2.3.0 for Python version 3.3Packages included in Anaconda 2.3.0 for Python version 2.7Packages included in Anaconda 2.3.0 for Python version 2.6Packages included in Anaconda 2.2.0 for Python version 3.4Packages included in Anaconda 2.2.0 for Python version 3.3Packages included in Anaconda 2.2.0 for Python version 2.7Packages included in Anaconda 2.2.0 for Python version 2.6Packages included in Anaconda 2.1.0 for Python version 3.4Packages included in Anaconda 2.1.0 for Python version 3.3Packages included in Anaconda 2.1.0 for Python version 2.7Packages included in Anaconda 2.1.0 for Python version 2.6Packages included in Anaconda 2.0.1 for Python version 3.4Packages included in Anaconda 2.0.1 for Python version 3.3Packages included in Anaconda 2.0.1 for Python version 2.7Packages included in Anaconda 2.0.1 for Python version 2.6Packages included in Anaconda 1.9.2Packages included in Anaconda 1.9.1Packages included in Anaconda 1.9.0Packages included in Anaconda 1.8.0Packages included in Anaconda 1.7.0Packages included in Anaconda 1.6.1Packages included in Anaconda 1.5.0Packages included in Anaconda 1.4.0Packages included in Anaconda 1.3.1Packages included in Anaconda 1.2.1Packages included in Anaconda v.1.1Packages included in Anaconda v.1.0数据来自Anaconda官网：Old package lists — Anaconda documentation ...

原文链接 在没有外网的状况下，装置Python环境只能采纳离线形式。 Windows离线装置PythonPython离线安装包的下载地址：https://www.python.org/ftp/python/ 我抉择的是：python-3.8.5-amd64.exe 双击运行安装包即可实现装置。 装置实现后增加环境变量： D:\Python3.8.5\D:\Python3.8.5\Scripts\查看是否胜利： python --version输入版本号Python 3.8.5即示意装置胜利。 如果输入的版本号不对，将命令改为python3 --version试一下。 Linux离线装置PythonPython离线安装包的下载地址：https://www.python.org/ftp/python/ 我抉择的是：Python-3.8.5.tgz 进入解压门路： cd /home/root/Download/Python-3.8.5设置装置门路： ./configure --prefix=/usr/local/python3 --enable-sharedmake && make install建设python和pip的软连贯： ln -s /usr/local/python3/bin/python3.8 /usr/bin/python3ln -s /usr/local/python3/bin/pip3.8 /usr/bin/pip3配置python3的lib到ldconfig： echo "/usr/local/python3/lib" > /etc/ld.so.conf.d/python3.8.confldconfig查看Python是否装置胜利： python3 --version输入版本号Python 3.8.5即示意装置胜利。 查看pip是否配置胜利： pip3 --version有如下输入即示意胜利： pip 20.2.4 from /usr/local/python3/lib/python3.8/site-packages/pip (python 3.8)Ubuntu装置PythonUbuntu装置Python的形式与其余Linux零碎有所不同。 有网络的状况下，能够间接应用命令行装置： sudo apt-get install python3.8sudo apt install python3-pip没有网络的话，须要先下载离线包。 Python离线安装包的下载地址：https://www.python.org/ftp/python/ 我抉择的是：Python-3.8.5.tgz 解压并进入装置目录： sudo tar -zxvf Python-3.8.5.tgz -C ~cd Python-3.8.5装置编译环境： sudo apt-get install zlib1g-dev libbz2-dev libssl-dev libncurses5-dev libsqlite3-dev libreadline-dev tk-dev libgdbm-dev libdb-dev libpcap-dev xz-utils libexpat1-dev liblzma-dev libffi-dev libc6-dev在有网络的状况下，间接应用sudo apt-get即可。离线状况下，须要将上述安装包下载下来拷入，再进行装置。 ...

原文链接 在搞深度学习的时候，咱们在本地开发，然而须要在服务器去运行工程，所以须要应用Pycharm进行近程配置，能够实现本地代码主动同步到服务器，并在本地应用服务器的解释器。 条件：须要应用专业版Pycharm。 近程部署点击菜单栏Tools——Deployment——Configuration 点“+”，新建一个SFTP类型的Deployment配置： 我给新的配置命名为“remote”： 抉择Connection栏，填入服务器的IP、帐号、明码，并点击“Test Connection”测试是否能够链接。将编码类型改为“utf-8”： 抉择Connection栏，填入本地代码的门路： 抉择Excluded Paths栏，增加本地不须要同步的文件夹： 最初点击OK确定，实现近程部署的配置。 近程解释器近程部署能够实现代码的主动同步，接下来还要配置近程解释器。 首先拷贝本地Pycharm装置目录下的helpers目录中的所有文件，上传到近程服务器的登录用户目录下。例如，我应用的是root用户，则拷贝至/root/.pycharm_helpers目录下。 在Pycharm中抉择File -> Settings -> Project:learn -> Project Interpreter -> Add 抉择SSH解释器，输出服务器的IP、帐号，点击Next，而后输出明码： 抉择服务器上的Python解释器： 抉择代码寄存地址，我本地的地址是E:/project/learn，服务器上的地址是/app/learn； 而后点击确定即可。此时Pycharm底部会呈现File Transfer栏，显示代码文件的同步信息： 此时运行代码，应用的就是服务器的Python解释器。后续对代码的每一次批改，都会在保留后主动上传服务器。 常见问题在文件同步过程中，若呈现报错： Failed to change timestamp of the file抉择菜单栏Tool——Deployment——Options，勾销选中Preferve files timestamps： 画红线处的√即可。    学习更多编程常识，请关注我的公众号： 代码的路