AskPython-博客中文翻译-十一-
AskPython 博客中文翻译（十一）
如何在 Python 中对数组排序
Python 数组可以使用不同的排序算法进行排序，根据所选的算法，它们的运行时间和效率会有所不同。我们研究了对数组元素进行排序的一些方法。
对 Python 可迭代对象使用 sorted()
Python 使用一些非常有效的算法来执行排序。例如，sorted()方法使用一种叫做 Timsort (它是插入排序和合并排序的组合)的算法来执行高度优化的排序。
任何 Python 可迭代对象，比如列表或数组，都可以使用这个方法进行排序。
import array
# Declare a list type object
list_object = [3, 4, 1, 5, 2]
# Declare an integer array object
array_object = array.array('i', [3, 4, 1, 5, 2])
print('Sorted list ->', sorted(list_object))
print('Sorted array ->', sorted(array_object))
输出:
Sorted list -> [1, 2, 3, 4, 5]
Sorted array -> [1, 2, 3, 4, 5]
实现合并排序和快速排序
在这里，我们研究两种在实际应用中常用的排序技术，即合并排序和快速排序算法。
1.合并排序算法
该算法使用自下而上的分治方法，首先将原始数组划分为子数组，然后合并单独排序的子数组以产生最终排序的数组。
在下面的代码片段中，mergesort_helper()方法实际上将数组拆分成子数组，而 perform_merge()方法将两个先前排序的数组合并成一个新的排序数组。
import array
def mergesort(a, arr_type):
def perform_merge(a, arr_type, start, mid, end):
# Merges two previously sorted arrays
# a[start:mid] and a[mid:end]
tmp = array.array(arr_type, [i for i in a])
def compare(tmp, i, j):
if tmp[i] <= tmp[j]:
i += 1
return tmp[i-1]
else:
j += 1
return tmp[j-1]
i = start
j = mid + 1
curr = start
while i<=mid or j<=end:
if i<=mid and j<=end:
if tmp[i] <= tmp[j]:
a[curr] = tmp[i]
i += 1
else:
a[curr] = tmp[j]
j += 1
elif i==mid+1 and j<=end:
a[curr] = tmp[j]
j += 1
elif j == end+1 and i<=mid:
a[curr] = tmp[i]
i += 1
elif i > mid and j > end:
break
curr += 1
def mergesort_helper(a, arr_type, start, end):
# Divides the array into two parts
# recursively and merges the subarrays
# in a bottom up fashion, sorting them
# via Divide and Conquer
if start < end:
mergesort_helper(a, arr_type, start, (end + start)//2)
mergesort_helper(a, arr_type, (end + start)//2 + 1, end)
perform_merge(a, arr_type, start, (start + end)//2, end)
# Sorts the array using mergesort_helper
mergesort_helper(a, arr_type, 0, len(a)-1)
测试用例:
a = array.array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print('Before MergeSort ->', a)
mergesort(a, 'i')
print('After MergeSort ->', a)
输出:
Before MergeSort -> array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
After MergeSort -> array('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])
2.快速排序算法
该算法也使用分治策略，但是使用自顶向下的方法，首先围绕一个 pivot 元素划分数组(这里，我们总是选择数组的最后一个元素作为 pivot)。
从而确保在每一步之后，枢轴都位于最终排序数组中的指定位置。
在确保数组围绕轴心被划分后(小于轴心的元素在左边，大于轴心的元素在右边)，我们继续对数组的其余部分应用partition函数，直到所有元素都在它们各自的位置，这时数组被完全排序。
注意:该算法还有其他选择枢纽元素的方法。一些变体选择中间元素作为中枢，而另一些变体使用随机选择策略作为中枢。
def quicksort(a, arr_type):
def do_partition(a, arr_type, start, end):
# Performs the partitioning of the subarray a[start:end]
# We choose the last element as the pivot
pivot_idx = end
pivot = a[pivot_idx]
# Keep an index for the first partition
# subarray (elements lesser than the pivot element)
idx = start - 1
def increment_and_swap(j):
nonlocal idx
idx += 1
a[idx], a[j] = a[j], a[idx]
[increment_and_swap(j) for j in range(start, end) if a[j] < pivot]
# Finally, we need to swap the pivot (a[end] with a[idx+1])
# since we have reached the position of the pivot in the actual
# sorted array
a[idx+1], a[end] = a[end], a[idx+1]
# Return the final updated position of the pivot
# after partitioning
return idx+1
def quicksort_helper(a, arr_type, start, end):
if start < end:
# Do the partitioning first and then go via
# a top down divide and conquer, as opposed
# to the bottom up mergesort
pivot_idx = do_partition(a, arr_type, start, end)
quicksort_helper(a, arr_type, start, pivot_idx-1)
quicksort_helper(a, arr_type, pivot_idx+1, end)
quicksort_helper(a, arr_type, 0, len(a)-1)
在这里，quicksort_helper方法执行分治法的步骤，而do_partition方法围绕轴心分割数组并返回轴心的位置，围绕轴心我们继续递归分割轴心前后的子数组，直到整个数组排序完毕。
测试用例:
b = array.array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
print('Before QuickSort ->', b)
quicksort(b, 'i')
print('After QuickSort ->', b)
输出:
Before QuickSort -> array('i', [3, 1, 2, 4, 5, 1, 3, 12, 7, 6])
After QuickSort -> array('i', [1, 1, 2, 3, 3, 4, 5, 6, 7, 12])
结论
在本文中，我们研究了在 Python 数组上执行排序的 MergeSort 和 QuickSort 算法，了解了如何以自顶向下和自底向上的方式使用分治法。我们还简要地看了一下该语言提供的对 iterables 进行排序的本机sorted()方法。
参考资料:
在 Python 中对数据帧进行排序—循序渐进
原文：https://www.askpython.com/python-modules/pandas/sorting-a-dataframe
嘿，读者们！在本文中，我们将详细关注 Python 中对数据帧的排序。所以，让我们开始吧！
使用 sort_values()函数对数据帧进行排序
Python Pandas 模块为我们提供了各种处理大数据记录的函数。在根据数据帧处理数据记录时，我们经常会遇到需要对数据进行排序并表示输出的情况。
就在这时，Pythonpandas . data frame . sort _ values()函数出现了。
sort_values() function以定制的方式按升序或降序对数据进行排序。
现在，让我们在下一节集中讨论函数的结构。
Python 中 sort_values()函数的语法
看看下面的语法！
pandas.DataFrame.sort_values(by, axis=0, ascending=True, kind=’mergesort’)
- by :表示要排序的列的列表。
- 轴 : 0 表示按行排序，1 表示按列排序。
- 升序:如果为真，则按升序对数据帧进行排序。
- 种类:可以有三个值:
Quicksort、mergesort或heapsort。
现在，让我们在下一节中关注 sort_values()函数的实现。
Python 中对数据帧进行排序的示例代码
在这个例子中，我们已经用pandas.dataframe()函数初步创建了一个数据帧。此外，我们已经使用 sort_values()函数按降序对“RATE”列进行了排序。
举例:
import pandas as pd
data = pd.DataFrame([[3,0,1], [4,4,4], [1,7,7], [10,10,10]],
index=['Python', 'Java', 'C','Kotlin'],
columns=['RATE','EE','AA'])
sort = data.sort_values("RATE", axis = 0, ascending = False)
print("Data before sorting:\n")
print(data)
print("Data after sorting:\n")
print(sort)
输出:
Data before sorting:
RATE EE AA
Python 3 0 1
Java 4 4 4
C 1 7 7
Kotlin 10 10 10
Data after sorting:
RATE EE AA
Kotlin 10 10 10
Java 4 4 4
Python 3 0 1
C 1 7 7
在下面的例子中，我们按两列对上述数据帧进行了排序，即“EE”和“AA ”,如下所示。
举例:
import pandas as pd
data = pd.DataFrame([[3,0,1], [4,4,4], [1,7,7], [10,10,10]],
index=['Python', 'Java', 'C','Kotlin'],
columns=['RATE','EE','AA'])
sort = data.sort_values(["EE","AA"], axis = 0, ascending = True)
print("Data before sorting:\n")
print(data)
print("Data after sorting:\n")
print(sort)
输出:
如下图所示，数据框分别按照列“EE”和“AA”以升序排序。
Data before sorting:
RATE EE AA
Python 3 0 1
Java 4 4 4
C 1 7 7
Kotlin 10 10 10
Data after sorting:
RATE EE AA
Python 3 0 1
Java 4 4 4
C 1 7 7
Kotlin 10 10 10
结论
到此，我们就结束了这个话题。我们已经了解了 sort_values()函数对数据帧进行排序的功能。
如果你遇到任何问题，欢迎在下面评论。更多与 Python 相关的此类帖子，敬请关注，继续学习！
参考
NumPy 中的 3 种简单排序技术
原文：https://www.askpython.com/python/sorting-techniques-in-numpy
读者朋友们，你们好！在本文中，我们将详细关注 NumPy 中的 3 排序技术。
所以，让我们开始吧！🙂
Python NumPy 库 为我们提供了各种函数来创建数组和操作数组结构中相似类型的元素。除此之外，NumPy 还为我们提供了各种函数，使我们能够对数组结构中的元素进行排序。
NumPy 中的排序技术
我们将在 NumPy 中学习下面的排序技术。
- NumPy sort()函数
- NumPy argsort()函数
- NumPy lexsort()函数
所以，让我们开始吧！
1。NumPy sort()函数
为了对数组结构中出现的各种元素进行排序，NumPy 为我们提供了 sort() 函数。使用 sort()函数，我们可以对元素进行排序，并分别按照升序到降序对它们进行分离。
看看下面的语法！
语法:
numpy.sort(array, axis)
参数“轴”指定了需要执行排序的方式。因此，当我们设置 axis = NONE 时，排序以传统方式进行，得到的数组是单行元素。另一方面，如果我们设置 axis = 1，排序是以行的方式进行的，也就是说，每一行都是单独排序的。
例 1:
在这个例子中，我们已经创建了一个数组，我们还使用 sort()函数和 axis = NONE 对数组进行了排序，也就是说，它按升序对元素进行排序。
import numpy as np
data = np.array([[22, 55], [0, 10]])
res = np.sort(data, axis = None)
print ("Data before sorting:", data)
print("Data after sorting:", res)
输出:
Data before sorting: [[22 55]
[ 0 10]]
Data after sorting: [ 0 10 22 55]
例 2:
在这个例子中，我们已经创建了一个数组，并使用 sort()函数对其进行了排序，这里我们设置 axis = 1，即已经执行了按行排序。
import numpy as np
data = np.array([[66, 55, 22], [0, 10, -1]])
res = np.sort(data, axis = 1)
print ("Data before sorting:", data)
print("Row wise sorting:", res)
输出:
Data before sorting: [[66 55 22]
[ 0 10 -1]]
Row wise sorting: [[22 55 66]
[-1 0 10]]
2。NumPy argsort()
除了 sort()方法之外，我们还有用作 NumPy 中排序技术的 argsort() 函数，它返回排序元素的索引的数组。从这些排序的索引值中，我们可以得到按升序排序的数组元素。
因此，用 argsort()函数，我们可以对数组值进行排序，并得到与单独数组相同的索引值。
举例:
import numpy as np
data = np.array([66, 55, 22,11,-1,0,10])
res_index = np.argsort(data)
print ("Data before sorting:", data)
print("Sorted index values of the array:", res_index)
x = np.zeros(len(res_index), dtype = int)
for i in range(0, len(x)):
x[i]= data[res_index[i]]
print('Sorted array from indexes:', x)
输出:
在上面的例子中，我们对数据值执行了 argsort()函数，并获得了元素的排序索引值。此外，我们利用相同的数组索引值来获得排序后的数组元素。
Data before sorting: [66 55 22 11 -1 0 10]
Sorted index values of the array: [4 5 6 3 2 1 0]
Sorted array from indexes: [-1 0 10 11 22 55 66]
3。NumPy lexsort()函数
lexsort()函数使我们能够使用键序列(即按列)对数据值进行排序。使用 lexsort() 函数，我们一次一个地对两个数组进行排序。结果，我们得到排序元素的索引值。
import numpy as np
data = np.array([66, 55, 22,11,-1,0,10])
data1 = np.array([1,2,3,4,5,0,-1])
res_index = np.lexsort((data1, data))
print("Sorted index values of the array:", res_index)
输出:
Sorted index values of the array: [4 5 6 3 2 1 0]
结论
如果你遇到任何问题，欢迎在下面评论。更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！
Python 中的稀疏矩阵–简化
在本文中，我们将了解一种用于在 Python 中实现稀疏矩阵的数据结构。让我们开始吧。
什么是稀疏矩阵？
稀疏矩阵是一种有许多零元素的矩阵。也就是说，稀疏矩阵中的大多数项都是零，因此得名，所以稀疏矩阵占用的大部分内存都是零。例如，以下矩阵是一个稀疏矩阵:
A = [
[0, 4, 0, 0],
[2, 0, 0, 5],
[0, 0, 0, 0],
[0, 0, 0, 1]
]
可以看到，除了四项，其余都是零，这些多余的零占用了内存的大量空间。
稀疏矩阵是存储这种矩阵的最佳方式。它本质上是一个非零项的有序列表。稀疏矩阵中的每一行都存储非零元素的行和列，以及非零元素本身。
因此，对于上面的矩阵 A，它的稀疏对应物将如下所示:
A = [
[0, 1, 4],
[1, 0, 2],
[1, 3, 5],
[3, 3, 1]
]
在第一行中，元素是 0、1 和 4，因此第 4 项位于索引 0、1 处。同样，2 在索引 1，0 处；等等。
很明显，这个版本比普通版本占用更少的空间，在矩阵很大的情况下，稀疏矩阵占用的空间明显更少。
为了使用这个矩阵作为稀疏矩阵，我们需要在一个类中实现它，并为输入、打印、加法、减法、乘法等定义方法。
Python 中的稀疏矩阵
让我们看看 Python 中稀疏矩阵的类定义。
class Sparse:
def __init__(self, rows, columns):
self._matrix = []
self._num = 0
self._rows = rows
self._columns = columns
def __repr__(self):
prnt = f"Shape: {self._rows} x {self._columns}\n"
for lst in self._matrix:
prnt += lst.__repr__() + '\n'
prnt += f"Total: {self._num}"
return prnt
def insert(self, row, column, value):
if row < 0 | column < 0 | row >= self._rows | column >= self._columns:
raise ValueError("Invalid row or column")
if(value == 0):
raise ValueError("Zeroes are not included in a sparse matrix")
filled = False
for i in range(self._num):
if(self._matrix[i][0] < row):
continue
elif(self._matrix[i][0] > row):
self._matrix.insert(i, [row, column, value])
self._num += 1
filled = True
break
elif(self._matrix[i][1] < column):
continue
elif(self._matrix[i][1] > column):
self._matrix.insert(i, [row, column, value])
self._num += 1
filled = True
break
else:
raise ValueError("The position is already filled")
if(filled == False):
self._matrix.append([row, column, value])
self._num += 1
return
def remove(self, row, column):
if row < 0 | column < 0 | row >= self._rows | column >= self._columns:
raise ValueError("Invalid row or column")
for i in range(num):
if(self._matrix[i][0] == row | self._matrix[i][1] == column):
return pop(i)
return None
def size(self):
return self._num
def shape(self):
return tuple((self._rows, self._columns))
def display(self):
print(self)
def add(self, obj):
if(isinstance(obj, Sparse) != True):
raise TypeError("add() method needs an object of type Sparse")
if(self.shape() == obj.shape()):
result = Sparse(self._rows, self._columns)
else:
raise ValueError("Invalid row or columns")
i = 0
j = 0
k = 0
while((i < self._num) & (j < obj._num)):
if(self._matrix[i][0] < obj._matrix[j][0]):
result._matrix.insert(k, self._matrix[i])
k += 1
i += 1
elif(self._matrix[i][0] > obj._matrix[j][0]):
result._matrix.insert(k, obj._matrix[j])
k += 1
j += 1
elif(self._matrix[i][1] < obj._matrix[j][1]):
result._matrix.insert(k, self._matrix[i])
k += 1
i += 1
elif(self._matrix[i][1] > obj._matrix[j][1]):
result._matrix.insert(k, obj._matrix[j])
k += 1
j += 1
else:
result._matrix.insert(k, list([self._matrix[i][0], self._matrix[i][1], self._matrix[i][2] + obj._matrix[j][2]]))
k += 1
i += 1
j += 1
while(i < self._num):
result._matrix.insert(k, self._matrix[i])
k += 1
i += 1
while(j < obj._num):
result._matrix.insert(k, obj._matrix[j])
k += 1
j += 1
result._num = k
return result
def fast_transpose(self):
occurrence = []
index = []
for i in range(self._columns):
occurrence.append(0)
for i in range(self._num):
occurrence[self._matrix[i][1]] += 1
index.append(0)
for i in range(1, self._columns):
index.append(index[i-1] + occurrence[i-1])
result = Sparse(self._columns, self._rows)
result._num = self._num
for i in range(self._num): result._matrix.append(list())
for i in range(self._num):
result._matrix[index[self._matrix[i][1]]] = list([self._matrix[i][1], self._matrix[i][0], self._matrix[i][2]])
index[self._matrix[i][1]] += 1
return result
上面的定义相当大，所以我们将逐个查看每个函数:
1。__init__法
对于每个稀疏矩阵，我们首先需要行数和列数，然后将其传递给构造函数，后者创建一个空的稀疏矩阵。
2。__repr__法
这将返回一个字符串，当在对象上调用print()时，该字符串将被打印出来。在我们的例子中，我们打印矩阵的形状和大小，以及实际的稀疏矩阵。
3。稀疏矩阵中的插入和删除
要在某个位置插入一个非零项，我们只需遍历矩阵找到新项的正确位置并将其插入。我们首先比较行，然后如果发现行匹配，就比较列。其中一个必须是不同的，否则，我们抛出一个异常。
在做所有这些之前，我们需要验证输入，给定的项目不能为零，并且位置必须位于矩阵内部。
要删除给定位置的一个项目，过程非常简单，只需在矩阵中找到该位置并弹出整行。
4。两个稀疏矩阵的相加
添加两个稀疏矩阵非常类似于合并两个排序列表。
这两个矩阵是基本上是包含其他表示行的列表的列表。并且这些内部列表在每个列表的第一和第二项(每个值的行和列索引)以升序排列的意义上被排序。
我们创建了三个指标:i、j和k。
i是第一个矩阵中下一个项目的索引。j是第二个矩阵中下一个项目的索引。k是结果矩阵中下一个项目的索引。
然后我们比较第一个矩阵中的第i项和第二个矩阵中的第j项。基于其行和列索引，无论哪一项应该首先出现，都被插入到结果矩阵中，并且我们递增各自的索引。
如果这两项有相同的行和列索引，那么它们肯定需要相加，一旦我们这样做了，它们的和就被插入到结果矩阵中。
最后，一个输入矩阵将被完成，此时，我们只需将另一个矩阵的所有项插入到结果矩阵中，我们将得到两个矩阵的和。
5。稀疏矩阵的快速转置
转置稀疏矩阵非常简单，我们只需交换行和列的值，然后对稀疏矩阵中的行进行排序。但是这样的操作是非常无效的，而稀疏矩阵的构造方式，我们有一个快得多的方法来转置这个矩阵。
我们将首先创建两个有助于算法的列表。
第一个列表叫做occurrence，它将存储每个列索引在稀疏矩阵中出现的次数。因此，它的大小将是稀疏矩阵的列大小，每个索引将代表该列。最初，它将被填充零，稍后，我们将遍历稀疏矩阵并查找每一项的列值，我们将在occurrence列表中递增该索引。
第二个列表称为index列表。在这个列表中，当原始稀疏矩阵转换为稀疏矩阵时，我们将存储原始稀疏矩阵中每个项目的结果索引。因此，index[i]将拥有原始矩阵中列索引为i的第一项的新索引。为此，我们首先在索引[0]处存储 0，这意味着原始矩阵中列索引为 0 的第一项将放入转置矩阵的第 0 个索引中。然后为了计算index[i]，我们加上index[i-1]和occurrence[i-1]。
在这之后，我们查看稀疏矩阵中的每一项，我们找到该项的列索引，我们在该索引处查找index列表中的值，并且我们使用该值作为转置矩阵中的新索引。
在这之后，我们增加我们使用的索引值，以便具有相同列索引的下一个项目将转置到下一个索引。
这样做，我们可以非常有效地转置一个稀疏矩阵。
输出
首先，我们创建两个稀疏矩阵:
现在我们做加法和快速转置运算:
结论
在矩阵大部分被零填充的情况下，稀疏矩阵使用更少的存储并且更有效。我们讨论了这些是什么，如何创建它们，然后实现它们，最后，我们通过运行代码得到的输出来确认。
Python 语音识别模块——完整介绍
原文：https://www.askpython.com/python-modules/speech-recognition
你好。今天，让我们学习如何使用 Python 编程语言中的speech recognition库将语音转换成文本。所以让我们开始吧！
语音识别简介
语音识别被定义为自动识别人类语音，并被认为是制作 Alexa 或 Siri 等应用程序时最重要的任务之一。
Python 附带了几个支持语音识别特性的库。我们将使用speech recognition库，因为它是最简单、最容易学习的。
导入语音识别模块
和往常一样，第一步是导入所需的库。在这种情况下，我们只需要导入speech_recognition库。
import speech_recognition as SR
如果语句出错，您可能需要使用pip命令安装库。
用 Python 实现语音识别
为了将语音从音频转换成文本，我们需要来自speech_recognition模块的Recognizer类来创建一个对象，该对象包含进一步处理所需的所有函数。
1.正在加载音频
继续之前，我们需要下载一个音频文件。我用来开始的是艾玛·沃森的演讲，可以在这里找到。
我们下载了音频文件，并将其转换为wav格式，因为它最适合识别语音。但是要确保将它保存到 Python 文件所在的文件夹中。
为了加载音频，我们将使用AudioFile功能。该函数打开文件，读取其内容，并将所有信息存储在名为source.的音频文件实例中
我们将遍历源代码并做以下事情:
- 每个音频都包含一些
noise，可以使用adjust_for_ambient_noise功能移除。 - 利用
record方法读取音频文件，并将某些信息存储到一个变量中，供以后读取。
下面是加载音频的完整代码。
import speech_recognition as SR
SR_obj = SR.Recognizer()
info = SR.AudioFile('speech.wav')
with info as source:
SR_obj.adjust_for_ambient_noise(source)
audio_data = SR_obj.record(source,duration=100)
这里我们还提到了一个称为duration的参数，因为对于较长的音频，识别语音需要更多的时间。所以威尔只会录下前 100 秒的音频。
2.从音频中读取数据
既然我们已经成功加载了音频，我们现在可以调用recognize_google()方法并识别音频中的任何语音。
该方法可能需要几秒钟，具体取决于您的互联网连接速度。在处理之后，该方法返回程序能够从第一个 100 秒中识别的最佳语音。
相同的代码如下所示。
import speech_recognition as SR
SR_obj = SR.Recognizer()
info = SR.AudioFile('speech.wav')
with info as source:
SR_obj.adjust_for_ambient_noise(source)
audio_data = SR_obj.record(source,duration=100)
SR_obj.recognize_google(audio_data)
输出结果是音频中的一串句子，结果非常好。精确度可以通过使用更多的功能来提高，但是现在它只提供基本的功能。
"I was appointed 6 months and I have realised for women's rights to often become synonymous with man heating if there is one thing I know it is that this has to stop someone is by definition is the belief that men and women should have equal rights and opportunities is the salary of the economic and social policy of the success of a long time ago when I was 8 I was confused sinkhole but I wanted to write the play Aise the width on preparing for the 14 isostasy sacralized elements of the media 15 my girlfriend Statue of Liberty sports team because they don't want to pay monthly 18 18 Mai Mela friends were unable to express their feelings I decided that I am business analyst at the seams and complicated to me some recent research has shown me feminism has become"
结论
恭喜你！今天，在本教程中，您学习了如何从音频中识别语音，并将其显示在屏幕上。
我还想提一下，语音识别是一个非常深奥和庞大的概念，我们在这里学到的知识仅仅触及了整个主题的表面。
感谢您的阅读！
Python 中的拼写检查器
原文：https://www.askpython.com/python/examples/spell-checker-in-python
Python 中的拼写检查器是一种检查文本中拼写错误的软件功能。拼写检查功能通常嵌入在软件或服务中，如文字处理器、电子邮件客户端、电子词典或搜索引擎。
用 Python 构建拼写检查器
让我们开始构建我们的拼写检查工具吧！
1.导入模块
我们将用两个不同的模块来构建我们的拼写检查工具:
- 拼写检查模块
- textblob 模块
让我们从一个一个地安装和导入开始。
为了在 python 中构建拼写检查器，我们需要导入拼写检查器模块。如果您没有该模块，您可以使用 pip 软件包管理器安装该模块。
C:\Users\Admin>pip install spellchecker
你也可以用同样的方法安装 textblob 模块
C:\Users\Admin>pip install textblob
2.使用 textblob 模块进行拼写检查
TextBlob 在 python 编程语言中是一个用于处理文本数据的 python 库。它提供了一个简单的 API，用于处理常见的自然语言处理任务，如词性标注、名词短语提取、情感分析、分类、翻译等。
correct()函数:纠正输入文本最直接的方法是使用correct()方法。
from textblob import TextBlob
#Type in the incorrect spelling
a = "eies"
print("original text: "+str(a))
b = TextBlob(a)
#Obtain corrected spelling as an output
print("corrected text: "+str(b.correct()))
输出:
original text: eies
corrected text: eyes
3.使用拼写检查器模块进行拼写检查
让我们看看拼写检查模块如何纠正句子错误！
#import spellchecker library
from spellchecker import SpellChecker
#create a variable spell and instance as spellchecker()
spell=SpellChecker()
'''Create a while loop under this loop you need to create a variable called a word and make this variable that takes the real-time inputs from the user.'''
while True:
w=input('Enter any word of your choice:')
w=w.lower()
'''if the word that presents in the spellchecker dictionary, It
will print “you spelled correctly" Else you need to find the best spelling for that word'''
if w in spell:
print("'{}' is spelled correctly!".format(w))
else:
correctwords=spell.correction(w)
print("The best suggestion for '{}' is '{}'".format(w,correctwords))
Enter any word of your choice:gogle
The best suggestion for 'gogle' is 'google'
拼写检查器实例将在该程序中被多次调用。它能容纳大量的单词。如果你输入任何拼写错误的单词，如果它不在拼写检查词典中，它会纠正下来。这就是你对这个图书馆的了解。
结论
简单来说，这是关于如何使用 Python 编程语言来构建你自己的拼写检查器，它易于编码，易于学习和理解，只需要很少的几行代码。
如何使用 sklearn 在 Python 中将数据拆分成训练集和测试集？
原文：https://www.askpython.com/python/examples/split-data-training-and-testing-set
在机器学习中，将数据分成两个不同的集合是一种常见的做法。这两套是训练套和测试套。顾名思义，训练集用于训练模型，测试集用于测试模型的准确性。
在本教程中，我们将:
- 首先，了解分割数据集的重要性
- 然后看看如何在 Python 中将数据分成两组
为什么我们需要将数据分成训练集和测试集？
在训练机器学习模型时，我们试图找到一种模式，以最小的误差最好地代表所有的数据点。这样做时，会出现两个常见的错误。这些是过拟合和欠拟合。
欠拟合
欠拟合是指模型甚至不能表示训练数据集中的数据点。在欠拟合的情况下，即使在训练数据集上进行测试，您也会得到较低的精度。
拟合不足通常意味着您的模型过于简单，无法捕捉数据集的复杂性。
过度拟合
当您的模型表示训练数据集有点太精确时，就会出现过度拟合的情况。这意味着你的模型太接近了。在过度拟合的情况下，您的模型将无法在新的看不见的数据上表现良好。过度拟合通常是模型过于复杂的标志。
过度装配和装配不足都是不可取的。
我们应该在训练数据上测试吗？
理想情况下，您不应该在训练数据上进行测试。您的模型可能会过度适应训练集，因此在处理新数据时会失败。
训练数据集中的良好准确性不能保证您的模型在看不见的数据上成功。
这就是为什么建议将训练数据与测试数据分开。
基本思想是将测试集用作看不见的数据。
在训练集上训练数据之后，应该在测试集上测试模型。
如果您的模型在测试集上表现良好，您可以对您的模型更有信心。
Python 中如何拆分训练和测试数据集？
最常见的分割比例是 80:20。
也就是说，80%的数据集进入训练集，20%的数据集进入测试集。
拆分数据之前，请确保数据集足够大。训练/测试分割适用于大型数据集。
让我们用一些代码来弄脏我们的手。
1.导入整个数据集
我们在整个教程中使用加州住房数据集。
你可以使用 pip 命令安装 pandas:
pip install pandas
使用以下方法将数据集导入 pandas 数据框架:
import pandas as pd
housing = pd.read_csv("/sample_data/california_housing.csv")
housing.head()
Housing Dataframe
让我们把 median_income 列当作输出(Y)。
y= housing.median_income
同时，我们必须从数据集中删除该列，以形成输入向量。
x=housing.drop('median_income',axis=1)
你可以使用。head()方法来看看输入和输出是什么样子的。
x.head()
Input X
y.head()
Output Y
现在我们已经准备好了输入和输出向量，我们可以将数据分成训练集和测试集。
2.使用 sklearn 拆分数据
为了分割数据，我们将使用来自 sklearn 的 train_test_split 。
train_test_split 根据提供的比率将您的数据随机分布到训练集和测试集中。
让我们看看它是如何在 python 中实现的。
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2)
这里我们使用 80:20 的分割比例。20%的测试数据集用末尾的 0.2 表示。
若要比较不同测试集和定型集的形状，请使用以下代码:
print("shape of original dataset :", housing.shape)
print("shape of input - training set", x_train.shape)
print("shape of output - training set", y_train.shape)
print("shape of input - testing set", x_test.shape)
print("shape of output - testing set", y_test.shape)
这给出了以下输出。
完整的代码
这种分割训练和测试数据的完整代码如下:
import pandas as pd
housing = pd.read_csv("/sample_data/california_housing.csv")
print(housing.head())
#output
y= housing.median_income
#input
x=housing.drop('median_income',axis=1)
#splitting
x_train,x_teinst,y_train,y_test=train_test_split(x,y,test_size=0.2)
#printing shapes of testing and training sets :
print("shape of original dataset :", housing.shape)
print("shape of input - training set", x_train.shape)
print("shape of output - training set", y_train.shape)
print("shape of input - testing set", x_test.shape)
print("shape of output - testing set", y_test.shape)
结论
在本教程中，我们了解了将数据分成训练集和测试集的重要性。此外，我们将数据集导入到 pandas 数据框架中，然后使用 sklearn 将数据分成训练集和测试集。
Python:间谍号还是不是？
你好，程序员朋友！今天我们要了解什么是间谍号以及如何使用 python 编程语言来判断一个数字是否是间谍号。
什么是间谍号？
如果某个数字的数字之和正好等于其数字之积，则该数字被称为间谍号。让我们看一些例子:
例 1: 1421
位数之和== > 1+4+2+1 = 8
位数之积== > 142*1 = 8
由于数字的乘积和总和完全相同，所以该数字是一个间谍号
例二: 1342
位数之和== > 1+3+4+2 = 10
位数之积== > 134*2 =24
显然，乘积和总和不相等，因此，这个数不是间谍数。
用 Python 识别一个间谍号
要知道一个号码是否是间谍号码，需要遵循下面描述的一些步骤:
步骤 1: 输入数字
步骤 2: 创建两个变量，一个存储总和，另一个存储乘积
步骤 3: 从右到左一个接一个地迭代数字位数
步骤 4: 在每次迭代中，将数字加到总和上，并将相同的数字乘以乘积
步骤 5: 在遇到所有数字之后，比较总和与乘积值:如果它们相等=【T11
现在，让我们按照上面提到的步骤来看看代码。
num=int(input("Enter your number "))
sum=0
product=1
num1 = num
while(num>0):
d=num%10
sum=sum+d
product=product*d
num=num//10
if(sum==product):
print("{} is a Spy number!".format(num1))
else:
print("{} is not a Spy number!".format(num1))
希望你能按照上面提到的代码中提到的步骤去做。让我们看一些示例输出。
Enter your number 123
123 is a Spy number!
Enter your number 234
234 is not a Spy number!
您可以看到代码非常准确，并且给出了正确的结果。
结论
到本教程结束时，您已经了解了什么是 spy number 以及如何用 python 编程语言实现它。
感谢您的阅读！
Python 中如何使用 SQL？
大多数现代应用程序都非常频繁地与数据库进行交互。SQL 或结构化查询语言使得访问和操作存储在这些数据库中的数据变得更加容易。
Python 作为流行语言之一，支持内置和第三方 SQL 库。
在下一节中，我们将讨论如何使用最流行的库之一 SQLite 在 Python 中使用 SQL。
SQLite 简介
我们之所以选择 SQLite 作为我们的教程，是因为它的无服务器架构。SQLite 速度快，重量轻，将整个数据库存储在一个文件中，甚至存储在 PC 的内存(RAM)中。它在测试环境中被开发人员大量使用。
模块 SQLite 是 Python 自带的。因此，您不必使用 pip 从外部安装它。
但是不应该轻视 SQLite 的简单性，因为它也可以为生产就绪环境处理大型数据库。
所有这些特性使 SQLite 成为初学者和中级开发人员的完美模块。
在 Python 中使用 SQL 的步骤
按照下面的说明在 python 脚本中使用 SQL。
1.导入 SQLite
在 python 中使用任何模块的第一步都是在文件的最顶端导入它。在 Python3 中，该模块被称为“sqlite3”
import sqlite3 #Importing the module
2.创建与数据库的连接
导入模块后，我们需要使用“connect()”方法创建一个数据库对象，并将数据库文件路径作为参数传递。
如果我们目前没有任何数据库，相同的命令将使用我们指定的文件路径/名称创建一个新的数据库。
import sqlite3 #Importing the module
conn = sqlite3.connect("databasename.db")
""" Here, conn is the database object and 'databasename.db' is the actual database we're trying to connect with.
If there is no database available then the same command will trigger to create a new database of the same name in our current directory."""
3.创建光标对象
一旦我们的数据库对象被创建，我们需要设置另一个对象，它能够使用 Python 对数据库对象执行本地 SQL 命令。
为了实现这一点，我们需要做的就是在数据库对象上调用“cursor()”方法。所有 SQL 命令都必须使用游标对象来执行。
curr = conn.cursor() #Here 'curr' is our new cursor object.
4.使用 SQL 命令创建表
在这一节中，我们在当前的数据库上设置一个基本表，并学习如何提交它们，以便该表实际存储在文件中。
# SQL command that creates a table in the database
createTableCommand = """ CREATE TABLE NSA_DATA (
username VARCHAR(50),
phonenumber VARCHAR(15),
password VARCHAR(50),
baddeedcount INT,
secrets VARCHAR(250)
);"""
# Executing the SQL command
curr.execute(createTableCommand)
# Commit the changes
conn.commit()
正如我们所看到的，首先，我们需要将 SQL 命令放入字符串形式。然后，我们对游标对象调用“execute()”方法，并将字符串作为参数传递。
最后，我们需要在数据库对象上调用“commit()”方法。否则，这些变化不会反映在我们实际的数据库中。因此，我们不能忘记提交更改。
5.向数据库添加数据
创建数据库模式后，我们要做的下一件事是添加数据。按照下面的命令学习如何操作:
# First, we write our SQL command within a string and assign it to a variable addData
addData = """INSERT INTO NSA_DATA VALUES('abcd', '0123456789', 'Password1o1', 23, 'None Yet');"""
print("The data has been added!")
# Then we execute the command
curr.execute(addData)
# And finally commit
conn.commit()
输出:
INSERT INTO NSA_DATA VALUES('abcd', '0123456789', 'Password1o1', 23, 'None Yet')
The data has been added!
但是，如果您有一个数据列表，并且希望导入到数据库中，而不需要逐一查看，这里有一种方法，可以将数据从 2D 阵列导入到数据库中。
# The 2D array containing required data
data = [['abcd', '0123456789', 'Password1o1', 23, 'None Yet'],
['oswald', '0123456888', 'SunnyDay', 0, 'None Yet'],
['nobitanobi', '3216548876', 'ilovedoracake', 357, 'many of them']]
# A for loop to iterate through the data and add them one by one.
for i in data:
addData = f"""INSERT INTO NSA_DATA VALUES('{i[0]}', '{i[1]}', '{i[2]}', '{i[3]}', '{i[4]}')"""
print(addData) # To see all the commands iterating
curr.execute(addData)
print("Data added successfully!")
conn.commit()
输出:
INSERT INTO NSA_DATA VALUES('abcd', '0123456789', 'Password1o1', '23', 'None Yet')
INSERT INTO NSA_DATA VALUES('oswald', '0123456888', 'SunnyDay', '0', 'None Yet')
INSERT INTO NSA_DATA VALUES('nobitanobi', '3216548876', 'ilovedoracake', '357', 'many of them')
Data added successfully!
6.获取数据
最后，我们还需要从数据库中提取数据，以满足我们日常的技术需求。这个过程与我们在上一节中所做的非常相似，只是有一点小小的变化。
一旦我们使用 cursor 对象执行搜索查询，它不会立即返回结果。相反，我们需要在游标上使用方法“fetchall()”来获取数据。
# Our search query that extracts all data from the NSA_DATA table.
fetchData = "SELECT * from NSA_DATA"
# Notice that the next line of code doesn't output anything upon execution.
curr.execute(fetchData)
# We use fetchall() method to store all our data in the 'answer' variable
answer = curr.fetchall()
# We print the data
for data in answer:
print(data)
输出:
('abcd', '0123456789', 'Password1o1', 23, 'None Yet')
('abcd', '0123456789', 'Password1o1', 23, 'None Yet')
('oswald', '0123456888', 'SunnyDay', 0, 'None Yet')
('nobitanobi', '3216548876', 'ilovedoracake', 357, 'many of them')
('abcd', '0123456789', 'Password1o1', 23, 'None Yet')
('oswald', '0123456888', 'SunnyDay', 0, 'None Yet')
('nobitanobi', '3216548876', 'ilovedoracake', 357, 'many of them')
结论
希望您已经学会了如何使用 Python 执行基本的 SQL 操作。您还应该注意到，SQLite 不是唯一可用的库。对于生产级别的工作，更高级别的数据库如 PostgreSQL 和 MySQL 是非常推荐的。虽然 python 中的用法基本相同。
完整的代码:
以下部分包含本教程中使用的完整代码。
在 Python 中使用 SQL 创建表
import sqlite3
conn = sqlite3.connect("database.db")
curr = conn.cursor()
createTableCommand = """CREATE TABLE NSA_DATA (
username VARCHAR(50),
phonenumber VARCHAR(15),
password VARCHAR(50),
baddeedcount INT,
secrets VARCHAR(250)
);"""
try:
curr.execute(createTableCommand)
print("Table Successfully Created!")
except:
print("There was an error with Table creation")
finally:
conn.commit()
输出:
Table Successfully Created!
在 Python 中通过 SQL 添加数据
import sqlite3
conn = sqlite3.connect("database.db")
curr = conn.cursor()
# The 2D array containing required data
data = [['abcd', '0123456789', 'Password1o1', 23, 'None Yet'],
['oswald', '0123456888', 'SunnyDay', 0, 'None Yet'],
['nobitanobi', '3216548876', 'ilovedoracake', 357, 'many of them']]
# A for loop to iterate through the data and add them one by one.
for i in data:
addData = f"""INSERT INTO NSA_DATA VALUES('{i[0]}', '{i[1]}', '{i[2]}', '{i[3]}', '{i[4]}')"""
print(addData) # To see all the commands iterating
curr.execute(addData)
print("Data added successfully!")
conn.commit()
输出:
INSERT INTO NSA_DATA VALUES('abcd', '0123456789', 'Password1o1', '23', 'None Yet')
INSERT INTO NSA_DATA VALUES('oswald', '0123456888', 'SunnyDay', '0', 'None Yet')
INSERT INTO NSA_DATA VALUES('nobitanobi', '3216548876', 'ilovedoracake', '357', 'many of them')
Data added successfully!
在 Python 中使用 SQL 提取数据
import sqlite3
conn = sqlite3.connect("database.db")
curr = conn.cursor()
fetchData = "SELECT * from NSA_DATA"
curr.execute(fetchData)
# We use fetchall() method to store all our data in the 'answer' variable
answer = curr.fetchall()
# We print the data
for data in answer:
print(data)
输出:
('abcd', '0123456789', 'Password1o1', 23, 'None Yet')
('oswald', '0123456888', 'SunnyDay', 0, 'None Yet')
('nobitanobi', '3216548876', 'ilovedoracake', 357, 'many of them')
参考
Python 中标准偏差的 3 种变体
原文：https://www.askpython.com/python/examples/standard-deviation
嘿，读者们！在本文中，我们将关注 Python 中标准差的 3 种变体。
所以在开始之前，让我们先了解一下什么是标准差？
标准偏差表示数据值或实体相对于平均值或中心值的偏差。它主要用于数据分析领域，探索和分析数据分布。
现在，让我们在下一节中进一步看看 Python 中计算标准差的各种方法。
变体 1:使用 stdev()函数的 Python 中的标准偏差
Python statistics module为我们提供了statistics.stdev() function来计算一组值的标准差。
语法:
statistics.stdev(data)
在下面的示例中，我们创建了一个列表，并对数据值执行了标准差操作，如下所示
举例:
import statistics as std
lst = [1,2,3,4,5]
stat = std.stdev(lst)
print(stat)
输出:
1.5811388300841898
变体 2:使用 NumPy 模块的标准偏差
NumPy 模块为我们提供了各种函数来处理和操作数字数据值。
我们可以使用如下所示的numpy.std() function计算数值范围的标准偏差
语法:
numpy.std(data)
举例:
import numpy as np
num = np.arange(1,6)
stat = np.std(num)
print(stat)
这里，我们已经利用numpy.arange() function生成了一组 1-6 之间的连续值。此外，已经使用 std()函数计算了标准偏差。
输出:
1.4142135623730951
变量 3:熊猫模块的标准偏差
Pandas 模块使我们能够处理大量的数据集，并为我们提供了在这些数据集上执行的各种功能。
使用 Pandas 模块，我们可以对数据值执行各种统计操作，其中一项是标准差，如下所示
语法:
dataframe.std()
举例:
import pandas as pd
lst = [1,2,3,4,5,6,7]
data = pd.DataFrame(lst)
stat = data.std()
print(stat)
在本例中，我们创建了一个列表，然后使用 pandas.dataframe()函数将该列表转换为数据框。此外，我们已经使用std()函数计算了数据框中出现的那些值的标准偏差。
输出:
0 2.160247
dtype: float64
结论
到此，我们就结束了这个话题。如果你遇到任何问题，请随时在下面评论。
更多此类与 Python 相关的帖子，敬请关注@ AskPython 继续学习！
用 Python 标准化机器学习数据的两种简单方法
原文：https://www.askpython.com/python/examples/standardize-data-in-python
嘿，读者们。在本文中，我们将重点关注在 Python 中标准化数据的 2 项重要技术。所以，让我们开始吧！！
为什么我们需要在 Python 中标准化数据？
在深入研究标准化的概念之前，了解标准化的必要性是非常重要的。
所以，你看，我们用来为一个特定的问题陈述建立模型的数据集通常是从各种来源建立的。因此，可以假设数据集包含不同尺度的变量/特征。
为了让我们的机器学习或深度学习模型能够很好地工作，数据在特征方面具有相同的规模是非常必要的，以避免结果中的偏差。
因此，特征缩放被认为是建模前的重要步骤。
特征缩放可大致分为以下几类:
- 归一化
- 标准化
标准化用于normally distributed的数据值。此外，通过应用标准化，我们倾向于使数据集的平均值为 0，标准差等于 1。
也就是说，通过标准化这些值，我们得到了数据分布的以下统计数据
- 平均值= 0
- 标准差= 1
Standardization
因此，通过这种方式，数据集变得不言自明并且易于分析，因为平均值下降到 0 ，并且它碰巧具有单位方差。
在 Python 中标准化数据的方法
现在，让我们在下一节重点关注实现标准化的各种方法。
1.使用预处理. scale()函数
preprocessing.scale(data) function可用于将数据值标准化为平均值等于零且标准差为 1 的值。
这里，我们已经使用下面的代码行将 虹膜数据集 加载到环境中:
from sklearn.datasets import load_iris
此外，我们已经将 iris 数据集保存到如下创建的数据对象中。
from sklearn import preprocessing
data = load_iris()
# separate the independent and dependent variables
X_data = data.data
target = data.target
# standardization of dependent variables
standard = preprocessing.scale(X_data)
print(standard)
在分离因变量和响应/目标变量后，我们将preprocessing.scale() function应用于因变量以标准化数据。
输出:
Standardization-Output
2.使用 StandardScaler()函数
Python sklearn library为我们提供了StandardScaler() function来对数据集执行标准化。
在这里，我们再次利用虹膜数据集。
此外，我们创建了一个 StandardScaler()对象，然后应用fit_transform() function对数据集应用标准化。
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
data = load_iris()
scale= StandardScaler()
# separate the independent and dependent variables
X_data = data.data
target = data.target
# standardization of dependent variables
scaled_data = scale.fit_transform(X_data)
print(scaled_data)
输出:
Standardization-Output
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
在那之前，请继续关注并快乐学习！！🙂
使用 Python 设计状态机[快速指南]
原文：https://www.askpython.com/python-modules/state-machines-python
你好。在这篇文章中，我们将学习一些计算机科学的基础知识。当然，不是整个课程！只是计算理论的一部分。本课题是关于有限自动机的设计。我们将在下一部分讨论所有的术语。所以，让我们开始吧。
Python 中的状态机是什么？
状态机是一种行为模型，它定义了对象如何响应事件。在 Python 中，状态机通常被实现为有限状态机(FSM) 。FSM 是一种数学计算模型，可用于设计数字逻辑电路和计算机程序。它由一组状态、这些状态之间的转换以及转换发生时执行的操作组成。
有限状态机(FSM)是一种数学计算模型，可用于设计数字逻辑电路和计算机程序。它由一组状态、这些状态之间的转换以及转换发生时执行的操作组成。FSM 可以表示为有向图，状态表示为节点，转换表示为边。边用触发转换的事件标记，动作与边相关联。
什么是 TOC 和自动机？
自动机理论和 TOC 都用于研究机器的行为，但它们采用不同的方法。自动机理论关注的是抽象机器本身，而 TOC 关注的是使用那台机器可以解决的问题。
自动机理论是对抽象机器和自动机以及可以使用它们解决的计算问题的研究。自动机理论也与形式语言理论密切相关，因为自动机经常被用作形式语言的计算模型。计算理论(TOC)是数学的一个分支，研究算法及其效率。它涉及算法、数据结构和复杂性理论的设计和分析。
计算理论是我们设计一些基于基本输入和输出的虚拟机的主题。从最底层开始，工作从接受固定长度的字符串开始。这些机器的基本术语是自动机。
自动机有两种类型:
- 确定性有限自动机。
- 【非确定性有限自动机】(NDFA)。
对确定性有限自动机(DFA)的理解
确定性有限自动机(DFA)是一种特殊类型的有限状态机，它根据确定性算法接受或拒绝一个称为输入字符串的符号字符串。DFA 可以表示为有向图，状态表示为节点，转换表示为边。边用触发转换的事件标记，动作与边相关联。
理解非确定性有限自动机(NDFA)
非确定性有限自动机(NDFA)是一种特殊类型的有限状态机，它可以基于非确定性算法接受或拒绝输入字符串。NDFA 可以表示为有向图，状态表示为节点，转换表示为边。边用触发转换的事件标记，动作与边相关联。
一个基本的自动机是由五个单元组成的元组:
Automata = (Q, F, δ, q0, Σ)
- Q =所有状态的集合。
- F =所有最终状态的集合。
- δ =将状态的移动与每个输入进行映射的转换函数或映射函数。
- q0 =初始状态。
- σ=输入符号的有限集合。
基本 DFA 的示意图
Automata diagram
本机接受字符串“aa”。这里的图表是 DFA 最简单的表示。让我们理解它的参数:
- 这里 Q = {q0，q1，q2}。一组最终状态。
- q0 是初始状态。
- q2 是最终状态
- σ= { a }是所有输入符号的集合。
该机器由三种状态组成–Q0、q1 和 q2。最初，当我们给一个状态输入时，它转换/移动到另一个状态。转移函数( δ )跟踪所有这些活动。当期望的字符串达到特定状态时，我们将其定义为该机器的最终状态。
自动机的应用
自动机理论是对抽象机器和可以用它们解决的计算问题的研究。自动机用于各种应用，包括验证、模型检查、调度和数据库更新。这里有三个自动机的应用
- 游戏开发
- 人工智能 e
- 编译器设计
现在让我们跳到使用 Python 的状态机库构建状态机。
使用 Python 构建状态机
我们将使用 Python 编写我们自己的状态机。这将与在纸上画它是一样的。此外，我们将使用一些特殊的操作来检查转换。
1.安装状态机库
打开您的命令提示符并键入 pip 命令:
pip install python-statemachine
Installing Python Statemachine
工具和技术
- Python 版本: 3.8.x 以上。
- 支持库:python-state machine。
- 好的 IDE : VSCode，Spyder 等。
代码:
from statemachine import StateMachine, State
class LightBulb(StateMachine):
# creating states
offState = State("off", initial = True)
onState = State("on")
# transitions of the state
switchOn = offState.to(onState)
switchOff = onState.to(offState)
bulb = LightBulb()
print(bulb.current_state)
输出:
State('off', identifier='offState', value='offState', initial=True)
说明:
- 我们先将
state machine模块和State class一起导入。 - 我们首先创建一个类别为的灯泡。然后，为了继承这些属性，将状态机放在括号内。
- 我们创造了两种状态。
- offState :表示最初灯泡是关闭的。将初始参数设置为真。
- onState :打开灯泡。
- 然后，创建两个转场:
- 开关 On :从 off 状态转换到 On 状态。
- 关闭:从 on 状态转换到 Off 状态。
- 创建我们类的一个实例，即灯泡。
- 然后，为了检查当前状态，我们简单地调用灯泡对象的 current_state 属性。
- 我们看到灯泡的当前状态是“关”。
状态机的动态属性
当我们创建一个状态机时，该模块为该状态机中的每个状态创建一组特殊的属性。我们可以使用实例和属性来检查该属性是否适用于该状态。在上面的代码中，我们有两个这样的状态。所以，创建的属性也是真。
检查属性的代码:
bulb.is_offState # returns True
bulb.is_onState # returns False
检查状态和转换的数量
让我们看看如何从 State 类中提取转换和所有状态。当我们的类只有两种状态时，这可能看起来没有用。但是考虑具有多种可能状态的类，这时候这些技术就很方便了。
代码检查状态数:
在自动机中，我们需要保存所有当前状态的记录。为此，我们使用下面的列表理解。
a = [s.identifier for s in bulb.states]
print(a)
输出:
['offState', 'onState']
说明:
- 我们使用列表理解将所有状态存储在一个列表中。
- 然后使用“标识符”属性，运行一个 for 循环。
- 使用 states 属性获取每个状态。我们需要使用灯泡类的实例灯泡对象来调用它。
- 将该列表分配给一个变量“a”。
- 然后打印出来。我们得到了所有的州。
检查转换的代码:
自动机总是从一种状态转移到另一种状态。简单来说，我们称之为过渡。因此，为了记录它们，我们的状态机有了转换属性。
b = [s.identifier for s in bulb.transitions]
print(b)
输出:
['switchOff', 'switchOn']
说明:
所有代码都与州代码相同。我们只是对灯泡对象使用“过渡”关键字。
结论
这样，我们就可以用 Python 构建一个简单的状态机。当我们设计人工智能算法或游戏时，这些机器是要研究的重要概念之一。对于逻辑构建，状态机也是很好的页面主题。所以，我们在这里结束这个话题。
参考
您可以通过访问此链接查看更多信息:https://pypi.org/project/python-statemachine/
Python 中的@staticmethod
@staticmethod 装饰器
python@ static methoddecorator 用于将类方法标记为静态方法，这意味着无需先实例化类即可调用。它只是定义了一个普通的函数，出于可读性的目的，这个函数逻辑上包含在类中。这里，我们不需要通过[self](https://www.askpython.com/python/python-self-variable)将类实例作为第一个参数传递，这与其他类函数不同。
class Student():
def __init__(self, mark):
self.mark = mark
@staticmethod
def find_min(mark):
return min(mark, 100)
print(Student.find_min(20))
输出
20
通过类实例访问
静态方法也可以通过类实例或对象来访问。例如:
class Bank():
def __init__(self, balance):
self.balance = balance
@staticmethod
def find_interest(loan_money, interest_rate):
return loan_money * (1 + interest_rate)
bank = Bank(1000)
print(bank.find_interest(bank.balance, 0.3))
输出:
1300
重写静态方法
静态方法定义即使在任何继承之后也不会改变，这意味着它可以被重写，类似于其他类方法。
class ATM(Bank):
def __init__(self, balance):
super().__init__(balance)
@staticmethod
def find_interest(loan_money):
return loan_money * 1.4
atm = ATM(1000)
print(atm.find_interest(atm.balance))
输出
1400
@staticmethod vs @classmethod
类方法是通过包含它的类调用的，而不是从实例调用的。这就是为什么 classmethod 被定义为class_method(cls, param1, param2)，它不包含self，这意味着它不能使用类实例来调用。静态方法既可以从类实例调用，也可以从类调用。
@staticmethod 与实例方法
实例方法只能从类实例中调用，这就是为什么任何实例方法都是形式为instance_method(self, param1, param2)的原因，其中self关键字表示调用方法的类实例。@staticmethod既可以从类实例中调用，也可以从类中调用。
Comparison between @classmethod, @staticmethod and instance methods
这里有一个例子来把这一切放在一起。
class Bank():
def __init__(self, balance):
self.balance = balance
@staticmethod
def find_interest(loan_money, interest_rate):
return loan_money * (1 + interest_rate)
@classmethod
def find_interest_classmethod(cls, loan_money):
return loan_money * 1.4
def find_interest_instancemethod(self, loan_money):
if self.balance <= 100:
return loan_money * 1.2
else:
return loan_money * 1.5
class ATM(Bank):
def __init__(self, balance):
super().__init__(balance)
@staticmethod
def find_interest(loan_money):
return loan_money * 1.3
atm = ATM(1000)
print('Using staticmethod ->', atm.find_interest(atm.balance))
print('Using classmethod from the parent class ->', Bank.find_interest_classmethod(atm.balance))
print('Using classmethod from the inherited subclass ->', ATM.find_interest_classmethod(atm.balance))
print('Using a regular instance method ->', atm.find_interest_instancemethod(atm.balance))
输出:
Using staticmethod -> 1300.0
Using classmethod from the parent class -> 1400.0
Using classmethod from the inherited subclass -> 1400.0
Using a regular instance method -> 1500.0
结论
Python 静态方法属于该类。它们在创建不需要实例变量的函数时很有用。本文向我们展示了@staticmethod 的用例，以及它们与其他装饰器(即@classmethod 装饰器)的比较。我们还比较了静态方法、类方法和常规实例方法，并展示了如何使用它们来使类代码更易于维护。
参考
Python 官方文档:https://docs . python . org/3/library/functions . html # static method
Python 统计模块–需要了解的 7 个函数！
原文：https://www.askpython.com/python-modules/statistics-module
Python 统计模块提供了对给定的一组数字计算数学统计数据的函数。它是在 Python 3.4 版本中引入的。这是一个非常简单的模块，可以处理整数、浮点数、小数和分数。在本文中，我们将关注 Python 统计模块的 7 个重要函数。
Python 统计模块函数
我们将关注 Python 中统计模块提供的一些最突出的功能。
- 均值()函数
- 中值()函数
- median_high()函数
- median_low()函数
- stdev()函数
- _sum()函数
- _counts()函数
让我们一个一个来看看。
1.mean()函数
均值是最常用的统计量之一，可以一目了然地了解数据。平均值代表一次全部数据的总体平均估计值。它的计算方法是将数据集中的所有值相加，然后除以值的个数。
例如，如果数据集是[1，2，3，4，5]，则平均值将是(1+2+3+4+5)/5 = 3。
statistics.mean()函数返回一组数字数据值的平均值。
语法:
statistics.mean(data)
2.median()函数
除了平均值之外，我们经常会遇到这样的情况:我们需要一个值来表示整个数据的中间部分。使用statistics.median()函数，我们可以计算数据值的中间值。中值是在从最小值到最大值对数据集进行排序后得出的。如果数据集有偶数个值，则中位数是中间两个数的平均值。
例如，如果数据集是[1，3，10，2]，那么首先我们将按升序排列它，即[1，2，3，10]。因为有偶数个值，所以中值将是中间两个数字(即 2 和 3)的平均值。所以中位数是 2.5。对于数据集[1，10，3]，中值将为 3。
语法:
statistics.median(data)
3.median_high()函数
统计模块的median_high()函数返回数据集中较高的中值。当数据值本质上是离散的时，高中值特别有用。如果数据集有偶数个值，则返回中间两个值中较高的一个。对于奇数个值，median_high 与中值相同。
例如，如果数据集是[1，2，3，10]，则 median_high 将是 3。如果数据集为[1，3，5]，则 median_high 与中值 3 相同。
语法:
statistics.median_high(data)
4.statistics.median_low()函数
median_low()函数返回一组值中的最低中值。当数据本质上是离散的，并且我们需要精确的数据点而不是插值点时，这是很有用的。如果数据集有偶数个值，则返回中间两个值中较小的一个。对于奇数个值，median_low 与中值相同。
例如，如果数据集是[1，2，3，10]，则 median_low 将是 2。如果数据集是[1，3，5]，则 median_low 与中值 3 相同。
语法:
statistics.median_low(data)
5.statistics.stdev 函数
stdev()函数返回数据的标准偏差。首先，计算数据的平均值。然后计算变化量。方差的平方根就是数据集的标准差。
语法:
statistics.stdev(data)
6.统计的 _sum()函数
当涉及到作为参数传递的数据点的累积时，就需要使用 _sum()函数了。使用_sum()函数，我们可以得到所有数据值的总和以及传递给它的所有数据点的计数。
语法:
statistics._sum(data)
7.counts()函数
使用_counts()函数，我们可以从该组值中获得每个数据点的频率。它计算每个数据点的出现次数，并返回大小为 2 的元组列表。元组的第一个值是数据集值，第二个值是出现次数。
Python 统计模块函数示例
让我们看一些使用统计模块函数的例子。
import statistics
data = [10, 203, 20, 30, 40, 50, 60, 70, 80, 100]
res = statistics.mean(data)
print("Mean: ", res)
res = statistics.median(data)
print("Median: ", res)
res = statistics.median_high(data)
print("Median High value: ", res)
res = statistics.median_low(data)
print("Median Low value: ", res)
res = statistics.stdev(data)
print("Standard Deviation: ", res)
res = statistics._sum(data)
print("Sum: ", res)
res = statistics._counts(data)
print("Count: ", res)
输出:
Mean: 66.3
Median: 55.0
Median High value: 60
Median Low value: 50
Standard Deviation: 55.429735301150004
Sum: (<class 'int'>, Fraction(663, 1), 10)
Count: [(10, 1), (203, 1), (20, 1), (30, 1), (40, 1), (50, 1), (60, 1), (70, 1), (80, 1), (100, 1)]
摘要
Python 统计模块对于获取数值数据集的平均值、中值、众数和标准差非常有用。他们处理数字，并提供简单的函数来计算这些值。但是，如果您已经在使用 NumPy 或 Pandas 模块，您可以使用它们的函数来计算这些值。
下一步是什么？
资源
Python 中的词干化和词汇化
原文：https://www.askpython.com/python/examples/stemming-and-lemmatization
在自然语言处理领域，词干化和词汇化是用于准备文本、文档以供进一步分析的文本规范化技术。
理解词干化和词汇化
在处理语言数据时，我们需要承认这样一个事实，即像“care”和“care”这样的词具有相同的意思，但以不同的时态形式使用。在这里，我们利用词干化和词汇化将单词简化为基本形式。
在本文中，我们将使用 NLTK 库和 SpaCy 库来执行词干化和词汇化。
什么是词干？
对单词进行词干分析的计算机程序或子程序可以称为词干分析程序、词干分析算法或词干分析器。 ( 维基)
词干分析用于预处理文本数据。英语中一个单词有很多变体，所以为了减少机器学习算法学习的歧义，过滤这些单词并将其简化为基本形式是非常重要的。
NLTK 提供了对单词进行词干分析的类。使用最广泛的词干算法有 PorterStemmer 、 SnowballStemmer 等。
与波特斯特默一起创作斯特梅尔
让我们试试这个词干法。
#Importing required modules
from nltk.stem.porter import PorterStemmer
#Creating the class object
stemmer = PorterStemmer()
#words to stem
words = ['rain','raining','faith','faithful','are','is','care','caring']
#Stemming the words
for word in words:
print(word+' -> '+ stemmer.stem(word))
输出:
rain --> rain
raining --> rain
faith --> faith
faithful --> faith
are --> are
is --> is
care --> care
caring --> care
PorterStemmer 类有.stem方法，该方法将一个单词作为输入参数，并返回简化为其根形式的单词。
用雪球斯特梅尔创造一个斯特梅尔
它也被称为 Porter2 词干算法，因为它倾向于修复波特斯特梅尔的一些缺点。让我们看看如何使用它。
#Importing the class
from nltk.stem.snowball import SnowballStemmer
#words to stem
words = ['rain','raining','faith','faithful','are','is','care','caring']
#Creating the Class object
snow_stemmer = SnowballStemmer(language='english')
#Stemming the words
for word in words:
print(word+' -> '+snow_stemmer.stem(word))
输出:
rain --> rain
raining --> rain
faith --> faith
faithful --> faith
are --> are
is --> is
care --> care
caring --> care
两个词干分析器的输出看起来很相似，因为我们在演示中使用了有限的文本语料库。随意试验不同的单词，比较两者的输出。
什么是词汇化？
词条化是查找单词词条的算法过程——这意味着不同于词干化，词干化可能导致不正确的单词归约，词条化总是根据单词的含义来归约单词。
它有助于返回单词的基本形式或字典形式，这就是所谓的词条。
起初，词干化和词汇化看起来可能是一样的，但实际上它们是非常不同的。在下一节中，我们将看到它们之间的区别。
现在让我们来看看如何对文本数据执行词汇化。
使用 Python Spacy 创建 Lemmatizer
注: python -m spacy 下载 en_core_web_sm
为了下载所需的文件来执行词汇化，必须运行上面的代码行
#Importing required modules
import spacy
#Loading the Lemmatization dictionary
nlp = spacy.load('en_core_web_sm')
#Applying lemmatization
doc = nlp("Apples and oranges are similar. Boots and hippos aren't.")
#Getting the output
for token in doc:
print(str(token) + ' --> '+ str(token.lemma_))
输出:
Apples --> apple
and --> and
oranges --> orange
are --> be
similar --> similar
. --> .
Boots --> boot
and --> and
hippos --> hippos
are --> be
n't --> not
. --> .
上面的代码返回一个spacy.doc对象类型的迭代器，它是输入单词的符号化形式。我们可以使用.lemma_属性访问词汇化的单词。
看看它是如何为我们自动标记句子的。
用 Python NLTK 创建一个 Lemmatizer
NLTK 使用 wordnet。NLTK 词汇化方法基于 WorldNet 内置的 morph 函数。
让我们看看如何使用它。
import nltk
nltk.download('wordnet') #First download the required data
#Importing the module
from nltk.stem import WordNetLemmatizer
#Create the class object
lemmatizer = WordNetLemmatizer()
# Define the sentence to be lemmatized
sentence = "Apples and oranges are similar. Boots and hippos aren't."
# Tokenize the sentence
word_list = nltk.word_tokenize(sentence)
print(word_list)
# Lemmatize list of words and join
lemmatized_output = ' '.join([lemmatizer.lemmatize(w) for w in word_list])
print(lemmatized_output)
输出:
['Apples', 'and', 'oranges', 'are', 'similar', '.', 'Boots', 'and', 'hippos', 'are', "n't", '.']
Apples and orange are similar . Boots and hippo are n't .
词汇化与词干化
我明白了。一开始，在词干化和词元化之间做出选择可能会令人困惑，但词元化肯定比词干化更有效。
我们看到这两种技术都将每个单词简化为它的词根。在词干分析中，这可能只是目标词的简化形式，而词汇化则简化为真正的英语词根，因为词汇化需要在 WordNet 语料库中交叉引用目标词。
词干化 vs .词汇化？这是一个速度和细节之间权衡的问题。词干化通常比词汇化更快，但可能不准确。然而，如果我们需要我们的模型尽可能的详细和精确，那么就应该优先选择引理化。
结论
在本文中，我们看到了词干化和词汇化的含义。我们看到了实现词干化和词汇化的各种方法。
我们还比较了词干化和词干化，以展示这两个过程之间的差异。快乐学习！🙂
用 Python 以 HTML 格式获取股票价格——完整指南
原文：https://www.askpython.com/python/examples/stock-price-as-html
有多少次，我们投资了一只股票，然后在一个晴朗的日子里，我们听到了关于这只股票的猜测性消息，我们把手机、电脑、经纪人都扭打在一起，想得到一个提醒。我们倾向于通过在手机上反复输入股票名称或点击长长的列表来查看不同的价格。最终，你的大部分时间得到的会更少。
但是有很多简单的方法可以让我们从你最喜欢的股票筛选网站上删除股票价格，这也需要一些 python 代码。在本文中，我们将介绍使用 Beautifulsoup 作为 python 库从 page 的 HTML 代码中抓取数据的开发。
什么是 Beautifulsoup，我们为什么要使用它？
美汤是 2004 年发布的 screen screening python 库，用于使用 HTML 或 XML 源代码从网站中提取数据。
尽管有更好的 web 报废库，如 scrappy 和 selenium ，但我们在本文中使用 Beautifulsoup，因为它非常用户友好且易于学习。Beautifulsoup 很难从 java 脚本等网站中提取复杂的数据，但通过它可以轻松完成较小规模的简单数据提取。
在 Python 中使用 BeautifulSoup
有许多方法可以做到这一点，这取决于什么样的机器或操作系统，你正在运行。我们将在 windows 操作系统和 PyCharm IDE 中为广大读者介绍安装部分。此外，在 PyCharm IDE 中，安装包和创建环境是非常简单的
在我们开始之前，Python 和 Python pip 必须安装在您的机器上。
打开 cmd 并输入:
pip install beautifulsoup4
python 库将自动安装在您的机器上。一旦完成，我们需要安装解析器。解析器支持 beautifulsoup 的 python 库，这是解析 HTML 和 XML 代码所必需的。
pip install lxml
pip install requests
在 PyCharm 中安装 Beautifulsoup
与其他 IDE 相比，在 PyCharm 中安装 python 包相对容易，没有任何麻烦，所以我们将继续使用它。
- 创建一个新项目，并向其附加一个 python 文件(使用。py 扩展名)添加到它。
- 然后进入“文件”>“设置”,在左窗格中点击你刚刚创建的项目的标题。
- “Python 解释器”选项会打开一个新窗口，其中包含该项目所需的所有解释器。
- 找到“Package”列正上方的加号，然后单击它。
Plus sign above the package column
- 当你点击它时，一个新的窗口会弹出一个很长的 Python 解释器列表。
- 您必须搜索“Beautifulsoup4 ”,然后在页面底部单击“安装包”。
Install the beautifulsoup4 Package
Beautifulsoup4 现在将安装在您的 PyCharm 系统中。
为了从 HTML 中获取股票价格，我们首先需要两样东西:
- 网站的 URL
- 股票价格属性的检验要素
在这篇文章中，我们将从两个不同的网站中选取例子，来了解如何识别要检查的正确属性。
提取雅虎财务数据
在第一个例子中，我们将通过雅虎财经网站获取纳斯达克的实时价格。为了做到这一点，谷歌‘纳斯达克雅虎金融’。搜索引擎会直接把你带到纳斯达克的报价页面。在那里我们需要复制页面的 URL。
Websites URL
其次，我们将要求报价的属性。要获取它，选择报价，右键单击并点击 inspect。
Inspect Element
当 inspect 菜单弹出时，必需的属性将会突出显示。在下面的例子中，我们突出显示了所需的 HTML 代码片段，我们只需要选择并复制其中的基本数据。我们只需要双引号内的代码。
注意:当我们将光标移动到嵌入式代码上时，它会显示与之链接的元素。在下图中，当光标在嵌入报价的 HTML 代码上时，虚线在报价的旁边。
Copying Attributes
使用 Python BeautifulSoup 提取雅虎财务数据
让我们进入提取股票数据的代码。
from bs4 import BeautifulSoup
import requests
url_of_page = 'https://finance.yahoo.com/quote/%5EIXIC/'
def computequoteprice():
url_requests = requests.get(url_of_page)
soup_ocreate = BeautifulSoup(url_requests.text, 'lxml')
quote_price = soup_ocreate.find('span', class_='Trsdu(0.3s) Fw(b) Fz(36px) Mb(-4px) D(ib)').text
return quote_price
print ("Quote price= " +str(computequoteprice()))
正如您在上面的代码中看到的，网站的 url 存储在变量“URL”中。同样，属性也用于变量“价格”。该代码转到网站的 URL，并从该页面请求所有 HTML 数据。然后使用“soup.find”代码在 HTML 代码中专门搜索 span id，class 包含我们要从页面中获取的报价的属性。
货币控制
让我们再举一个不同网站的例子。这里，信实工业的股票价格将取自 moneycontrol.com。步骤是相同的，除了 HTML 属性的不同。Yahoo finance 使用“span”作为 id，而 money control 使用“div”作为 id。
注意:识别属性的正确 id 是很重要的，不同的网站使用不同的 id，但是整个过程是相似的。
Moneycontrol.com inspect element
使用 Python BeautifulSoup 从 Moneycontrol 中提取股票价格的代码
from bs4 import BeautifulSoup
import requests
url_of_page = 'https://www.moneycontrol.com/india/stockpricequote/refineries/relianceindustries/RI'
def computequoteprice():
url_requests = requests.get(url_of_page)
soup_ocreate = BeautifulSoup(url_requests.text, 'lxml')
quote_price = soup_ocreate.find('div', class_='inprice1 nsecp').text
return quote_price
print ("Quote price= " +str(computequoteprice()))
结论
在这篇文章中，我们已经了解了如何从股票筛选网站上轻松获取股票价格。我们还了解了 beautifulsoup 库，如何安装以及如何工作。要了解更多关于股价报废的信息，你可以谷歌一下“AskPython stocks scrappy”。
使用 Python 进行股票价格预测
原文：https://www.askpython.com/python/examples/stock-price-prediction-python
你好。今天我们将学习如何使用 Python 编程语言预测不同类别的股票价格。
股票市场预测是试图确定在交易所交易的公司股票或其他金融工具的未来价值的行为。
成功预测一只股票的未来价格可以产生可观的利润。在这个应用程序中，我们使用 LSTM 网络通过过去 60 天的股价来预测收盘股价。
对于应用程序，我们使用了称为长短期记忆(LSTM)的机器学习技术。LSTM 是一种用于深度学习领域的人工递归神经网络(RNN)架构。
与标准的前向神经网络不同，LSTM 有反馈连接。它不仅可以处理单个数据点(如图像)，还可以处理整个数据序列(如语音或视频)。
LSTM 被广泛应用于序列预测问题，并且非常有效
股票价格预测在 Python 中的实现
1.导入模块
第一步是导入项目中所有必需的模块。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, LSTM
import math
from sklearn.preprocessing import MinMaxScaler
对于这个项目，我们将使用像 numpy 、 pandas 和 matplotlib 这样的基本模块。除此之外，我们将使用keras的一些子模块来正确地创建和构建我们的模型。
我们还需要 sklearn 的基本计算和预处理模块的数学模块，以更好、更简单的方式处理数据。
2.数据的加载和准备
对于该项目，我们将使用all_stocks_5yrs csv 文件，该文件包含 5 年的股票数据，有 7 列，如下所示。
- 日期–日期格式为:“年-月-日”
- 开盘–股票在公开市场的价格
- 高位-当日最高价
- 低-当日最低价格
- 收盘–收盘时股票的价格
- 成交量–交易的股票数量
- 名称-股票代码的名称
data=pd.read_csv("all_stocks_5yr..csv")
data.head()
head函数显示数据集的前五行。
First_five_rows_stock_data
3.理解数据
3.1 获得唯一的股票名称
从整个数据集中，我们将首先借助于unique函数提取所有唯一的股票分笔成交点名称。在数据集中，我们有 444 个不同的股票名称。
all_stock_tick_names = data['Name'].unique()
print(all_stock_tick_names)
All Stock Names Stock Data
3.2 提取特定股票名称的数据
我们将通过从用户处获取股票名称的输入并收集该特定股票名称的所有数据来尝试理解股票数据是如何工作的。
# 1\. Getting a stock name
stock_name = input("Enter a Stock Price Name: ")
# 2\. Extrating all the data having the name same as the stock name entered
all_data = data['Name'] == stock_name
# 3\. Putting all the rows of specific stock in a variable
final_data = data[all_data]
# 4\. Printing first 5 rows of the stock data of a specific stock name
final_data.head()
Stock Data FITB Stock Name
3.3 可视化股票数据
为了可视化数据，我们将首先绘制所有数据点的 FITB 股票的日期与收盘价格。
为了使可视化更简单，我们将绘制相同的图，但只针对前 60 个数据点。
# Plotting date vs the close market stock price
final_data.plot('date','close',color="red")
# Extract only top 60 rows to make the plot a little clearer
new_data = final_data.head(60)
# Plotting date vs the close market stock price
new_data.plot('date','close',color="green")
plt.show()
Date Vs Close Price FITB
Date Vs Close Price FITB First 60
4.创建新的数据框架和训练数据
为了使我们的研究更容易，我们将只考虑closing market price并使用 Python 预测收盘价。整个列车数据准备如以下步骤所示。添加评论供您参考。
# 1\. Filter out the closing market price data
close_data = final_data.filter(['close'])
# 2\. Convert the data into array for easy evaluation
dataset = close_data.values
# 3\. Scale/Normalize the data to make all values between 0 and 1
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(dataset)
# 4\. Creating training data size : 70% of the data
training_data_len = math.ceil(len(dataset) *.7)
train_data = scaled_data[0:training_data_len , : ]
# 5\. Separating the data into x and y data
x_train_data=[]
y_train_data =[]
for i in range(60,len(train_data)):
x_train_data=list(x_train_data)
y_train_data=list(y_train_data)
x_train_data.append(train_data[i-60:i,0])
y_train_data.append(train_data[i,0])
# 6\. Converting the training x and y values to numpy arrays
x_train_data1, y_train_data1 = np.array(x_train_data), np.array(y_train_data)
# 7\. Reshaping training s and y data to make the calculations easier
x_train_data2 = np.reshape(x_train_data1, (x_train_data1.shape[0],x_train_data1.shape[1],1))
这里，我们创建一个数据集来训练包含 60 天收盘价(60 个数据点)的数据，以便我们可以预测第 61 天的收盘价。
现在 x_train 数据集将包含总共 60 个值，第一列将包含从索引 0 到 59 的值，第二列将包含从索引 1 到 60 的值，依此类推
y_train 数据集将包含位于索引 60 的第一列的第 61 个值，对于第二列，它将包含位于索引 61 的第 62 个值，依此类推。
将独立和非独立训练数据集分别转换为 x_train_data 和 y_train_data，转换为 NumPy 数组，以便它们可以用于训练 LSTM 模型。
此外，由于 LSTM 模型需要三维数据集中的数据，使用 shape()函数，我们将以三维形式对数据进行整形。
5.建立 LSTM 模型
LSTM 模型将具有两个具有 50 个神经元的 LSTM 层和两个密集层，一个具有 25 个神经元，另一个具有一个神经元。
model = Sequential()
model.add(LSTM(units=50, return_sequences=True,input_shape=(x_train_data2.shape[1],1)))
model.add(LSTM(units=50, return_sequences=False))
model.add(Dense(units=25))
model.add(Dense(units=1))
6.编译模型
LSTM 模型是使用均方误差(MSE)损失函数和 adam 优化器编译的。
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(x_train_data2, y_train_data1, batch_size=1, epochs=1)
使用 fit()函数(train 的另一个名称),我们正在训练数据集。这里，batch_size 是单个批次中存在的训练样本的总数，而 epochs 是整个数据集通过神经网络向前和向后传递时的迭代次数。
Compiled LSTM Stock Price Predict
7.根据测试数据测试模型
下面的代码将从收盘价列中获取 training_data_len 以上的所有行。然后将 x_test 数据集转换为 NumPy 数组，以便它们可以用于训练 LSTM 模型。
由于 LSTM 模型期望的是三维数据集中的数据，使用 shape()函数，我们将以三维的形式对数据集进行整形。
使用 predict()函数，使用测试数据从模型中获取预测值。scaler.inverse_transform()函数正在取消缩放。
# 1\. Creating a dataset for testing
test_data = scaled_data[training_data_len - 60: , : ]
x_test = []
y_test = dataset[training_data_len : , : ]
for i in range(60,len(test_data)):
x_test.append(test_data[i-60:i,0])
# 2\. Convert the values into arrays for easier computation
x_test = np.array(x_test)
x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1))
# 3\. Making predictions on the testing data
predictions = model.predict(x_test)
predictions = scaler.inverse_transform(predictions)
8.误差计算
RMSE 是均方根误差，它有助于衡量模型的准确性。
rmse=np.sqrt(np.mean(((predictions- y_test)**2)))
print(rmse)
该值越低，模型的性能越好。0 值表示模型的预测值与测试数据集中的实际值完全匹配。
我们得到的 rmse 值是 0.6505512245089267，这已经足够好了。
9.做预测
最后一步是绘制和可视化数据。为了可视化数据，我们使用这些基本功能，如标题、标签、绘图，根据我们想要的图形外观。
train = data[:training_data_len]
valid = data[training_data_len:]
valid['Predictions'] = predictions
plt.title('Model')
plt.xlabel('Date')
plt.ylabel('Close')
plt.plot(train['close'])
plt.plot(valid[['close', 'Predictions']])
plt.legend(['Train', 'Val', 'Predictions'], loc='lower right')
plt.show()
Predictions Made Plot LSTM Stocks
10.实际值与预测值的对比
Final Predictions Vs Actual Values LSTM Stocks
结论
恭喜你！今天我们学习了如何使用 LSTM 模型预测股票价格！实际(接近)价格和预测(预测)价格的值非常匹配。
感谢您的阅读！
Python 中的 Stooge 排序——Python 中的分步实现
嘿伙计们！在本教程中，我们将讨论Stooge sort algorithm，并学习如何用 Python 编程语言实现。
让我们先来介绍一下活宝的分类。
活宝排序简介
Stooge sort是一种递归排序，以时间复杂度差著称。该算法的运行时间比冒泡排序要慢。但是，它比慢速排序更高效。
该算法简要定义如下:
- 如果起始位置的值大于结束位置的值，则交换它们。
- 如果列表中有 3 个或更多元素，那么，
- 首先，Stooge 排序列表的前 2/3
- 其次，Stooge 排序列表的最后 2/3
- 最后，Stooge 再次对列表的前 2/3 进行排序。
Stooge 排序算法中包含的步骤
当涉及到 Stooge 排序算法时，涉及到许多步骤。
首先，将数组传递给函数，比较第一个元素和最后一个元素，如果第一个元素较小，则交换它们。
接下来，我们考虑数组的大小，如果size>2那么数组的各个部分被递归调用来排序数组的第一个、最后一个以及第一个2/3 部分。
最后，只需在屏幕上显示排序后的数组。现在我们来看看这个排序算法的代码实现。
Stooge Sort Demonstration
在 Python 中实现活宝排序
理论说完了，让我们学习如何用 Python 实现 stooge sort。这个例子是为了帮助你更好地理解这个算法的每一步。
def stoogesort(arr, start, end):
# Check if there are elements in the array
if start >= end:
return
# Check first element with the last element
if arr[start]>arr[end]:
temp = arr[start]
arr[start] = arr[end]
arr[end] = temp
# Check if the number of elements are more than 2
if end-start+1 > 2:
temp = (int)((end-start+1)/3)
# Recursively call the parts of array to be sorted
stoogesort(arr, start, (end-temp))
stoogesort(arr, start+temp, (end))
stoogesort(arr, start, (end-temp))
# Take Input of the Unorted Array
arr = list(map(int,input("Enter all the numbers of array separated by a space: ").split()))
n = len(arr)
# Print the Unsorted Array
print("The original unsorted array is: ")
for i in range(0, n):
print(arr[i], end = ' ')
stoogesort(arr, 0, n-1)
# Print the Sorted Array
print("\nThe sorted array is: ")
for i in range(0, n):
print(arr[i], end = ' ')
示例输出
Enter all the numbers of array separated by a space: 23 2 9 -3 0 34 1
The original unsorted array is:
23 2 9 -3 0 34 1
The sorted array is:
-3 0 1 2 9 23 34
Enter all the numbers of array separated by a space: 9 4 -2 -2 4 67 100
The original unsorted array is:
9 4 -2 -2 4 67 100
The sorted array is:
-2 -2 4 4 9 67 100
结论
我希望您喜欢并理解排序算法及其实现。自己试试吧！
您还可以阅读:
快乐学习！😇
Streamlit 中的主题化–定制 Streamlit 应用外观的两种方法
原文：https://www.askpython.com/python-modules/streamlit-theming
在我们之前的文章中，我们学习了如何安装 Streamlit，创建一个“Hello World”应用程序 ，以及一些文本元素和小部件。接下来，在本文中，我们将学习 Streamlit 中的主题化。
Streamlit 提供亮暗两种模式。Streamlit 首先检查用户在其操作系统和浏览器中设置的亮或暗模式的偏好。如果是，则使用该首选项。否则，默认情况下将应用灯光主题。
亦读:细流简介
如何更改 Streamlit 应用程序的主题？
现在让我们看看可以用来改变 Streamlit 默认主题的不同方法。
更改 Streamlit 应用程序主题的方法 1[GUI 方法]
我们可以从设置中改变主题。
点击应用程序中的“≣”符号，然后点击“设置”选项。这些步骤如下图所示。
Theme Step 1
Theme Step 2
你会看到下面的屏幕。
Theme Step 3
现在，在主题部分，点击下拉菜单。正如我们在上面的图片中看到的，默认的主题是用户在他们的系统设置中设置的。这是这种情况下的黑暗主题。
Theme Step 4
有三个选项:Use system setting(默认)、Light、Dark。或者，如果我们想制作自己的主题，我们可以使用'编辑活动主题按钮。点击它将引导我们到下面的屏幕。
Theme Step 5
在这里，我们有所有的选项来改变文本的不同颜色和字体。一旦你自己创建了一个主题，它将被保存为主题选择器中的一个'自定义主题'，并且将被默认应用。
更改 Streamlit 应用程序主题的方法 2[编码方法]
我们也可以在使用streamlit run命令启动应用程序时通过命令行设置主题。同样，我们可以在.streamlit/config.toml文件的[theme]部分定义主题。它可以在以下位置找到
C:\Users\userName\.streamlit\config.toml
在 Windows 机器上，以及在
~/.streamlit/config.toml
在 Mac OS/Linux 机器上。
.streamlit/config.toml文件中的默认灯光主题将如下所示:
[theme]
primaryColor="#F63366"
backgroundColor="#FFFFFF"
secondaryBackgroundColor="#F0F2F6"
textColor="#262730"
font="sans serif"
而黑暗主题会是这样的:
[theme]
primaryColor="#FF4B4B"
backgroundColor="#0E1117"
secondaryBackgroundColor="#262730"
textColor="#FAFAFA"
font="sans serif"
让我们逐一探讨所有这些选项。但在此之前，让我们用我们在之前关于 Streamlit 的入门教程中学到的东西快速开发一个应用程序。
import streamlit as st
# button
st.button('Streamlit Button', help="Click here")
# check box
st.checkbox('Check Box')
# radio button
lang = st.radio(
"What's your favorite programming language?",
('C++', 'Python'))
if lang == 'C++':
st.write('You selected C++.')
else:
st.write('You selected Python')
# slider
score = st.slider('Please specify your test score', 0, 100, 10)
st.write("My test score is ", score)
# Using object notation
add_selectbox = st.sidebar.radio(
"Please choose an option",
("Option 1", "Option 2", "Option 3")
)
输出:
Theme Demo App
上面是一个简单的 Streamlit 应用程序，由不同的小部件组成，如复选框、按钮、侧边栏、滑块和单选按钮。我们将使用这个应用程序，并在下面的例子中尝试不同的主题选项。
注意:所有颜色选项支持 HEX、RGB、HSL 格式，以及网络浏览器支持的 颜色名称，如【绿色】【蓝色】。在下面的例子中，我们将使用浏览器支持的颜色名称。
原色–更改细流应用程序的原色
primaryColor 是指 Streamlit 应用中的强调色。滑块、按钮和复选框(聚焦时)等小部件使用 primaryColor。
config.toml:
[theme]
primaryColor="green"
backgroundColor="#0E1117"
secondaryBackgroundColor="#262730"
textColor="#FAFAFA"
font="sans serif"
输出:
Streamlit PrimaryColor
在上图中，所有处于焦点的小部件都以绿色作为主色，而不是配置文件中指定的默认红色。
background color–更改细流应用程序的背景颜色
指的是 app 主要内容区域的背景色。
config.toml:
[theme]
primaryColor="#FF4B4B"
backgroundColor="pink"
secondaryBackgroundColor="#262730"
textColor="#FAFAFA"
font="sans serif"
输出:
Streamlit BackgroundColor
主要内容区域的背景现在是粉红色的。
secondaryBackgroundColor–添加辅助背景色
当需要第二种背景色时，使用此选项。Streamlit 中的 Plotly 图表和侧边栏大多使用此选项。
配置文件:
[theme]
primaryColor="#FF4B4B"
backgroundColor="#0E1117"
secondaryBackgroundColor="blue"
textColor="#FAFAFA"
font="sans serif"
输出:
Streamlit SecondaryBackgroundColor
使用secondaryBackgroundColor的小部件，比如侧边栏，在这里变成了蓝色。请注意，主要内容区域的背景颜色没有改变。
text color–设置细流应用程序的文本颜色
它用于更改我们的 Streamlit 应用程序中文本的颜色。
config.toml:
[theme]
primaryColor="#FF4B4B"
backgroundColor="#0E1117"
secondaryBackgroundColor="#262730"
textColor="red"
font="sans serif"
输出:
Streamlit TextColor
这里的文本颜色是配置文件中指定的红色。
字体–更改细流应用的字体
Streamlit 支持三种字体类型，分别是sans serif、serif和monospace。默认字体为sans serif。
在代码块中，字体类型始终为monospace，与此处选择的字体类型无关。
配置文件:
【主题】T0【主色调= # ff 4b】
【背景色= # 0e 1117】
【次背景色= # 262730】
【文本颜色= # fafa】
字体=【单幅空间】
输出:
Streamlit Font
在这种情况下，字体系列已更改为monospace。
结论
这是 Streamlit 教程系列的第二篇，我们在这里学习了 Streamlit 中的主题化。希望对你有帮助。也请查看本系列中的其他教程。
参考
Python 中的字符串比较
原文：https://www.askpython.com/python/string/string-comparison-in-python
以下是在 Python 中比较两个字符串的方法:
- 通过使用
== (equal to)运算符 - 通过使用
!= (not equal to)运算符 - 通过使用
sorted()方法 - 通过使用
is运算符 - 通过使用
Comparison运算符
1.使用==(等于)运算符比较两个字符串
str1 = input("Enter the first String: ")
str2 = input("Enter the second String: ")
if str1 == str2:
print ("First and second strings are equal and same")
else:
print ("First and second strings are not same")
输出:
输入第一串:AA
输入第二串:AA
第一串和第二串相等且相同
2.使用！比较两个字符串！=(不等于)运算符
str1 = input("Enter the first String: ")
str2 = input("Enter the second String: ")
if str1 != str2:
print ("First and second strings are not equal.")
else:
print ("First and second strings are the same.")
输出:
输入第一串:ab
输入第二串:ba
第一串和第二串不相等。
3.使用 sorted()方法比较两个字符串
如果我们希望比较两个字符串并检查它们是否相等，即使字符/单词的顺序不同，那么我们首先需要使用 sorted()方法，然后比较两个字符串。
str1 = input("Enter the first String: ")
str2 = input("Enter the second String: ")
if sorted(str1) == sorted(str2):
print ("First and second strings are equal.")
else:
print ("First and second strings are not the same.")
输出:
输入第一串:工程学科
输入第二串:学科工程
第一串和第二串相等。
4.使用“is”运算符比较两个字符串
如果两个变量引用同一个对象实例，Python is 运算符将返回 True。
str1 = "DEED"
str2 = "DEED"
str3 = ''.join(['D', 'E', 'E', 'D'])
print(str1 is str2)
print("Comparision result = ", str1 is str3)
输出:
真
比较结果=假
在上面的示例中，str1 is str3 返回 False，因为对象 str3 是以不同方式创建的。
5.使用比较运算符比较两个字符串
input = 'Engineering'
print(input < 'Engineering')
print(input > 'Engineering')
print(input <= 'Engineering')
print(input >= 'Engineering')
输出:
假
假
真
真
字符串按字典顺序进行比较。如果左操作数字符串在右字符串之前，则返回 True。
参考
- Python 字符串比较
Python 中的字符串连接
原文：https://www.askpython.com/python/string/string-concatenation-in-python
串联是一种将字符串连接在一起形成一个新字符串的方法。
以下是在 Python 中执行字符串串联的方法:
- 通过使用
+运算符 - 通过使用
join()方法 - 通过使用
%运算符 - 通过使用
format()功能 - 由
Literal String Interpolation - 通过使用
IO Module中的StringIO - 通过使用
+=连接运算符
1.使用+运算符的字符串串联
语法 : string1 + string2
str1 = 'Safa'
str2 = 'Mulani'
result = str1 + str2
print(result)
输出 : SafaMulani
2.使用 join()方法连接 Python 字符串
语法 : join(string1，string2)
str1 = 'Safa'
str2 = 'Mulani'
print(" ".join([str1, str2]))
输出:萨法·穆拉尼
3.使用%运算符的字符串串联
语法 : %(string1，string2)
str1 = 'Safa'
str2 = 'Mulani'
result = "%s %s" % (str1, str2)
print('Concatenated String =', result)
输出:串接字符串= Safa Mulani
4.使用 format()函数连接字符串
语法:格式(string1，string2)
str1 = 'Safa'
str2 = 'Mulani'
res = "{} {}".format(str1, str2)
print('Concatenated String=', res)
输出:串接字符串= Safa Mulani
5.使用文字字符串插值的字符串连接
Python 3.6+版本允许我们将 f-string 用于文字字符串插值中引入的字符串连接。
语法:f“{ string 1 } { string 2 }”
str1 = 'Safa'
str2 = 'Mulani'
res = f'{str1} {str2}'
print('Concatenated String =', res)
输出:串接字符串= Safa Mulani
6.使用 IO 模块中的 StringIO 连接字符串
from io import StringIO
result = StringIO()
result.write('Safa ')
result.write('Mulani ')
result.write('Engineering ')
print(result.getvalue())
输出 : Safa Mulani 工程
7.使用+=连接运算符
语法 : string1 += string2
str1 = 'Safa '
str2 = 'Mulani'
str1 += str2
print(str1)
输出:萨法·穆拉尼
参考
- Python 字符串串联
- Python 运算符
Python 中的字符串等于检查——4 种简单方法
原文：https://www.askpython.com/python/string/string-equals-check-in-python
在本文中，我们将看看在 Python 中执行字符串等于检查的不同方法。
字符串比较基本上是两个字符串的比较，即我们通过逐字符比较来检查字符串是否相等的过程。
技巧 1: Python '== '操作符检查两个字符串是否相等
Python 比较运算符可用于比较两个字符串，并检查它们在case-sensitive manner中的相等性，即大写字母和小写字母将被区别对待。
Python '==' operator以逐字符的方式比较字符串，如果两个字符串相等则返回真，否则返回假。
语法:
string1 == string2
举例:
str1 = "Python"
str2 = "Python"
str3 = "Java"
print(str1 == str2)
print(str1 == str3)
输出:
True
False
技巧二:Python '！用于字符串比较的“=”运算符
Python！= '运算符也可用于在 python 中执行字符串等于检查。
'!=' operator比较两个字符串，如果不相等则返回真，否则返回假。
语法:
string1 != string2
举例:
str1 = "Python"
str2 = "Python"
str3 = "Java"
if(str1 != str3):
print("str1 is not equal to str3")
if(str1 != str2):
print("str1 is not equal to str2")
else:
print("str1 is equal to str2")
输出:
str1 is not equal to str3
str1 is equal to str2
技巧 3: Python 中执行字符串等于检查的 Python“is”操作符
****Python“is”操作符可用于有效检查两个字符串对象的相等性。如果两个变量指向同一个数据对象，则is operator返回真，否则返回假。
语法:
variable1 is variable2
举例:
str1 = "Python"
str2 = "Python"
str3 = "Java"
if(str1 is str3):
print("str1 is equal to str3")
else:
print("str1 is not equal to str3")
if(str1 is str2):
print("str1 is equal to str2")
else:
print("str1 is not equal to str2")
输出:
str1 is not equal to str3
str1 is equal to str2
技巧 4:在 python 中执行字符串等于检查的 eq()函数
Python 内置 eq()方法可以用来比较两个 string 对象。 __eq__()方法基本上是比较两个对象，如果相等则返回真，否则返回假。
语法:
string1.__eq__(string2)
举例:
str1 = "Python"
str2 = "Python"
str3 = "Java"
if(str1.__eq__(str3)):
print("str1 is equal to str3")
else:
print("str1 is not equal to str3")
if(str1.__eq__(str2)):
print("str1 is equal to str2")
else:
print("str1 is not equal to str2")
输出:
str1 is not equal to str3
str1 is equal to str2
Python 中的字符串等于检查:无案例比较
str1 = "Python"
str2 = "PYTHON"
if(str1.__eq__(str2)):
print("str1 is equal to str2")
else:
print("str1 is not equal to str2")
输出:
str1 is not equal to str2
如上面的例子所示，结果是假，因为比较是Case-sensitive。
为了有一个无案例的字符串比较，即以case-insensitive的方式，那么我们可以使用 Python string.casefold()函数来达到目的。
方法将字符串立即转换成小写字母。
在字符串比较的场景中，我们可以将两个输入字符串都传递给 casefold()函数。因此，两个字符串都将被转换成小写，这样，我们就可以进行无案例比较。
语法:
string.casefold()
例 2:
str1 = "Python"
str2 = "PYTHON"
str3 = "PYthoN"
if((str1.casefold()).__eq__(str2.casefold())):
print("str1 is equal to str2")
else:
print("str1 is not equal to str2")
if((str1.casefold()) == (str3.casefold())):
print("str1 is equal to str3")
else:
print("str1 is not equal to str3")
输出:
str1 is equal to str2
str1 is equal to str3
结论
因此，在本文中，我们已经了解了 Python 中大小写字符串比较的方法和技巧。
参考
- Python 字符串比较–journal dev
- Python 是操作符——stack overflow
- Python 字符串等于 JournalDev
Python 中的字符串格式——快速概述
原文：https://www.askpython.com/python/string/string-formatting
字符串格式化，顾名思义，指的是 Python 中格式化字符串的多种方式。在本教程中，我们将讨论不同的方法以及如何使用它们。
什么是字符串格式？
假设你正在编写一个程序，打印一个数字的平方。在你的输入中，你从用户那里得到一个整数，在输出中，你告诉用户这个整数的平方是某某。
例如，如果输入是 12，那么您需要打印“12 的平方是 144”。我们不能像这样写一个完整的字符串，因为我们有两个整数要插入到字符串中，所以我们需要一种方法来生成这个字符串。字符串格式化允许我们这样做。
注意:如果我们做print("The square of", input, "is", result)，这将打印四种不同的东西，它不会生成格式化的字符串，所以这不算字符串格式化。
字符串格式化技术的类型
今天我们将讨论三种格式化字符串的方法:
- 使用%运算符
- 使用 f 弦
- 使用 format()方法
让我们逐一讨论每种方法。
1。使用%操作符的字符串格式
这是字符串格式化的老方法，对于简单的操作仍然有用。这与 c 语言中的printf语句非常相似。
让我们举一个例子:
num = 12
result = num * num
str = "The square of %d is %d" % (num, result)
print(str)
输出:
The square of 12 is 144
我们有两个整数，num和result。在双引号中，我们写的是要打印的整个字符串，但是我们写的不是整数，而是%d。这将告诉 Python 这里要替换一个整数。
在字符串之后，我们使用%操作符并写入第二个操作数，它是一个元组，包含要以正确顺序替换的整数列表。在上面的例子中，我们有两个整数需要替换，所以我们将这两个整数写入一个元组，并将其作为第二个操作数。
请注意，在我们编写的字符串%d中，%之后的内容被称为格式说明符。在示例中，d是为整数指定的格式，s是为字符串指定的格式，f是为浮点或小数指定的格式，等等。要查看说明符的完整列表，我们可以查看 Python 文档。
使用%格式化字符串的技巧
- 我们可以在
%和格式说明符(例如%5d)之间指定一个数字，Python 会给整数左填充，这样整数的字符总数就等于指定的数字。如果是%5d,则将“123”替换为“123 ”,将 12 替换为“12 ”,以此类推。 - 上面的数字可以在左边指定一个零(例如
%05d)，Python 会给这个整数类似的左填充，但不是空格，而是零。例如，在%05d 的情况下，“123”将被替换为“00123”，“12”将被替换为“00012”，等等。 - 上面的数字也可以在左边用“-”号(
%-5d)来指定，Python 不会提供左边的填充，而是在右边提供填充。因此，对于%-5d，将“123”替换为“123”，“12”将替换为“12”，以此类推。
当要构造一个表时，这些点可以派上用场。
2。使用 f 字符串格式化
这是最容易理解的，也是最广泛使用的格式化技术。为了理解它，让我们举个例子。
num = 12
result = num * num
str = f"The square of {num} is {result}"
print(str)
输出:
The square of 12 is 144
正如你所看到的，我们直接将表达式嵌入到字符串中。该字符串还以字母“f”为前缀，这将告诉 python 它是一个 f 字符串，无论在{和}中写入什么表达式，都将被计算并嵌入到字符串的那个位置。
花括号内的表达式不必是单个变量，而是可以是任何返回值的语句。它可以是算术计算、函数调用或条件运算。让我们看一个例子:
a = 1
b = 2
str = f"Expression: {a + b}"
print(str)
输出:
Expression: 3
在上面的例子中，我们在 f 字符串内部执行了一个数学运算。所以我们可以看到 f 弦是强大的选项。
让我们看另一个例子:
a = 1
b = 2
str = f"a is '{a:5}' and b is '{b:05}'"
print(str)
输出:
a is ' 1' and b is '00002'
类似于%操作符，我们也可以如上例所示指定填充。
3。使用.format()方法进行字符串格式化
这种方法非常类似于 f 字符串，让我们用一个例子来看看:
num = 12
result = num * num
str = "The square of {} is {}".format(num, result)
print(str)
输出:
The square of 12 is 144
正如我们所看到的，在字符串内部，我们使用{}指定了两个占位符，然后我们对字符串使用format方法，并传递适当的整数以正确的顺序替换。
我们可以将标识符放在花括号内，但是我们稍后必须发送标识符的值。我们也可以像前面一样指定左填充。举个例子:
a = 1
b = 2
str = "a is '{first}' and b is '{second:03}'".format(first=a, second=b)
print(str)
输出:
a is '1' and b is '002'
在上面的例子中，我们将名字放入占位符中，在 format方法的参数列表中，我们使用名字为每个占位符指定值。与其他技术一样，第二个占位符甚至被指定为左边零填充。
结论
在本教程中，我们学习了字符串格式，并讨论了三种常见的方法。我们首先学习了%操作符，然后我们继续学习 f 字符串和format方法。我们还讨论了如何向格式化字符串添加填充，并通过查看其输出来研究代码。
希望你学得愉快，下次教程再见。
Python 中的字符串–完整参考
原文：https://www.askpython.com/python/string/strings-in-python
Python 中的字符串是广泛使用的数据类型之一，它是通过用引号将字符括起来而创建的。例如:
string1 = "Hello"
string2 = "welcome"
字符串用单引号或双引号括起来。这两者都被解释器认为是字符串。
Python 不支持“字符”数据类型，但支持长度为 1 的字符串。例如:
var char1 = "H"
如何用 Python 创建字符串？
在 Python 中有 3 种不同的方法可以用来创建字符串对象。
1.使用单引号
字符串可以通过用单引号将字符括起来来创建。
例如:
var example = 'Welcome to the tutorial!'
2.使用双引号
字符串通常是通过用双引号括住字符来创建的。
例如:
var example = "Welcome to the tutorial!"
3.使用三重引号
可以使用三重引号创建字符串。通过三重引号，字符串可以由三个单引号或三个双引号组成。它允许用户声明多行字符串。
此外，三重引号习惯于注释掉在执行代码时被解释器忽略的代码段。
var example = '''Welcome to the tutorial!'''
var example2 = """Welcome to the tutorial"""
# multi-line comment
''' This is the comment section.
The interpreter will ignore this section'''
在 Python 中访问和操作字符串
Indexes In String
虽然我们现在知道了制作字符串的方法，但是我们还必须了解如何访问和使用字符串来满足我们的编程需求。让我们了解一下如何访问字符串索引的基本原理。
在 Python 中，字符串的字符可以通过索引来访问。所需字符的位置在方括号中指定，其中索引 0 标记字符串的第一个字符(如上图所示):
var1 = 'Hello World!'
print("var1[0]: ", var1[0])
上述代码的输出是:
var1[0]: H
索引允许负地址引用访问字符串末尾的字符，例如-1 表示最后一个字符，-5 表示倒数第五个字符，依此类推。
例如:
var1 = 'Hello World'
print("var1[-1]: ", var1[-1])
print("var1[-5]: ", var1[-5])
上面代码的输出是:
var1[-1]: d
var1[-1]: W
而访问超出范围的索引将导致 IndexError 。下面的例子可以说明这一点:
var1 = 'Hello'
print(var1[5]) # gives error
注意:只允许整数作为索引传递。
任何其他数据类型都会导致类型错误。
1.Python 字符串切片
要访问字符串中的某个范围的字符，可以使用切片操作符(冒号)对字符串进行切片。
Str1 = "AskPython Strings Tutorial"
print(Str1[10:20])
print("\nSlicing characters from 3rd to 5th character: ")
print(String1[3:5])
代码的输出如下所示:
Strings Tu
Slicing characters from 3rd to 5th character:
Py
如果你有兴趣进一步了解细节，我们有一篇关于 Python 字符串切片的综合文章。
2.串并置
使用“+”运算符将字符串连接起来。下图显示了相同的情况:
var1 = "Hi,"
var2 = "Good Morning!"
var3 = var1 + var2
print(var3)
上述代码片段的输出如下所示:
Hi,Good Morning!
3.在 Python 中更新字符串
字符串是不可变的，因此更新或删除字符是不可能的。这可能会导致错误，因为不支持项分配(更新的情况)或从字符串中删除项。
String1 = "Hello"
# Updating character
String1[2] = 'p'
print("\nUpdating character at 2nd Index: ")
print(String1)
上述代码片段的输出如下:
Traceback (most recent call last):
File “/Desktop/trial.py”, line 4, in
String1[2] = ‘p’
TypeError: ‘str’ object does not support item assignment
但是，使用内置的 del 关键字删除整个字符串是可行的。
String1 = "hello"
del(String1)
字符串也可以更新，如下所示:
# Updating entire string
String1 = "Hello"
print(String1) # prints Hello
String1 = "Welcome"
print(String1) # prints Welcome
# concatenation and slicing to update string
var1 = 'Hello World!'
print ("Updated String :- ", var1[:6] + 'Python')
# prints Hello Python!
4.重复字符串
可以使用星号(*)运算符重复字符串，如下所示:
var1 = "hello"
print(var1*2)
上面代码的输出是它打印字符串两次。
hello hello
5.用 Python 格式化字符串
方法 1:使用格式化操作符
字符串格式操作符 %是字符串特有的，其行为类似于 C 的 printf()系列格式选项。
print("%s has Rs %d with her" % ('Aisha', 100))
上述代码的输出是:
Aisha has Rs 100 with her
方法 2:使用 format()方法
字符串的 format()方法包含花括号{}作为占位符，它可以根据位置或关键字保存参数以指定顺序。
Str1 = "{} {}".format('Hi, It is', '2020')
print(Str1)
上述代码片段的输出如下所示:
Hi, It is 2020
Python 中的 format()方法可用于格式化整数，允许从十进制格式转换为二进制、八进制和十六进制格式。
num = int(input())
ar1 = "{0:b}".format(num)
print("\nBinary representation of ",num," is ", ar1)
结论
这就把我们带到了教程的结尾。我希望您对字符串及其功能有非常扎实的理解。我们涵盖了许多关于 Python 的文章，并在这里展示了一些真正有趣的 Python 编程示例。
参考
https://docs.python.org/2/library/string.html
带示例的 Tkinter string var–Tkinter 教程
原文：https://www.askpython.com/python-modules/tkinter/stringvar-with-examples
大家好！在本教程中，我们将了解如何在 Tkinter 中使用 StringVar 函数来存储文本变量和编辑小部件中的文本。我们还将看到一个例子，当文本变量发生变化时，编写回调函数进行通知。所以让我们开始吧。
什么是 StringVar()？
Tkinter 包含内置的编程类型，其工作方式类似于普通的 python 变量，具有额外的特性，用于更有效地操纵像Label和Entry这样的小部件的值，这使它们不同于 python 数据类型。这些变量还包含 getter 和 setter 方法来访问和更改它们的值。StringVar就是其中的一个例子。
使用StringVar()定义的变量保存一个字符串数据，我们可以在其中设置文本值并检索它。此外，我们可以将这个变量传递给类似条目的小部件的 textvariable 参数。每当StringVar()变量的值改变时，小部件将自动用新值更新。
定义 StringVar()变量
下面是使用 Tkinter StringVar()定义字符串变量的步骤:
- 主:是
StringVar对象关联的一个小部件。如果未指定任何内容，则默认为根窗口。 - value :字符串变量的初始值。默认为“”。
- 名称:已定义变量的名称。默认值为 PY_VARnum(如 PY_VAR1、PY_VAR2 等)。
例如，在下面的代码中，我们使用StringVar()创建一个字符串变量，并将其赋给Label小部件的 textvariable 参数。
import tkinter as tk
master_window = tk.Tk()
master_window.geometry("150x150")
master_window.title("StringVar Example")
string_variable = tk.StringVar(master_window, "Hello Everyone!!")
label = tk.Label(master_window, textvariable=string_variable, height=150)
label.pack()
master_window.mainloop()
Defining StringVar
设置 StringVar()变量的值
可以通过两种方式将值分配给使用StringVar()定义的字符串变量:
- 在构造函数中传递值:定义 Tkinter 变量时，可以在构造函数的
value参数中传递字符串变量的值。
string_variable = tk.StringVar(master=master_window, value="Initial value of string variable")
- 使用
set()方法:你可以使用set()方法来改变字符串的值。例如:
string_variable = tk.StringVar(master_window)
string_variable.set("Some Text")
检索 StringVar()变量的值
我们可以对StringVar()变量使用get()方法来检索变量中的文本值。
import tkinter as tk
master_window = tk.Tk()
string_variable = tk.StringVar(master_window)
string_variable.set("Welcome to AskPython!!")
print(string_variable.get())
使用这种方法，当 StringVar 变量被传递给小部件时，我们还可以检索出现在Entry小部件中的数据。例如:
import tkinter as tk
master_window = tk.Tk()
master_window.geometry("300x300")
master_window.title("StringVar get() example")
def print_data():
print(string_variable.get())
string_variable = tk.StringVar(master_window)
label = tk.Label(master_window, text="Enter Data: ")
label.grid(row=0, column=0)
entry = tk.Entry(master_window, textvariable=string_variable)
entry.grid(row=0, column=1)
button = tk.Button(master_window, text="Print data", command=print_data)
button.grid(row=1, column=0, columnspan=2)
master_window.mainloop()
编写回调来跟踪 StringVar()变量
Tkinter-defined 对象的一个有趣的特性是，每当对象的值被更改、读取或删除时，对象都会得到通知。如果您想在对内部定义的对象进行某些操作时自动更新其他小部件，这个特性会很有帮助。
要在StringVar()对象上定义回调，我们可以在StringVar()对象上使用trace()方法，该方法有两个参数:
- 模式:对
StringVar()对象的操作类型。'w'(write):当值改变时调用回调'r'(read):读取值时调用回调'u'(未设置):删除值时调用回调
- 回调:当对象上有操作时调用的方法。
让我们考虑一个例子，其中将为在Entry小部件中输入的名字生成一条问候消息。当我们通过Entry小部件改变StringVar()对象中的数据时，将会调用一个方法来同时改变问候消息。
import tkinter as tk
class GreetingApp(tk.Tk):
def __init__(self):
super().__init__()
self.title('Greeting Application')
self.geometry("300x300")
self.name_var = tk.StringVar()
self.name_var.trace('w', self.create_greeting_message)
self.create_widgets()
def create_widgets(self):
self.description_label = tk.Label(self, text="Enter your name:")
self.description_label.grid(column=0, row=0)
self.entry = tk.Entry(self, textvariable=self.name_var)
self.entry.grid(column=1, row=0)
self.entry.focus()
self.greeting_label = tk.Label(self)
self.greeting_label.grid(column=0, row=1, columnspan=2)
def create_greeting_message(self, *args):
name_entered = self.name_var.get()
greeting_message = ""
if name_entered != "":
greeting_message = "Hello " + name_entered
self.greeting_label['text'] = greeting_message
if __name__ == "__main__":
app = GreetingApp()
app.mainloop()
结果如下:
https://www.askpython.com/wp-content/uploads/2021/09/Stringvar-Greeting-Example.webm
结论
在本教程中，我们学习了 Tkinter 中的StringVar(),以及如何使用它来设置字符串值、检索它以及编写自动更改数据的回调函数。
感谢阅读！！
用 Python 从字符串中剥离
原文：https://www.askpython.com/python/string/strip-from-a-string-in-python
让我们看看如何在 Python 中从字符串中剥离。
Python 为我们提供了不同的方法来从一个 Python 字符串中删除尾部字符，比如换行符、空格和制表符。这叫做从管柱上剥离。
如何在 Python 中从字符串中剥离
我们可以使用以下任何一种方法从字符串中剥离:
- strip()–这将删除前导的和结尾的空格(" ")、制表符(" \t ")和换行符(" \n ")，并返回经过修剪的字符串。
- rst rip()–这将删除任何尾随的空格、制表符和换行符，并返回经过修剪的字符串。由于我们只在右边修剪，这被恰当地称为
rstrip()。 - lstrip()–我们只修剪前导字符并返回修剪后的字符串。因为这只会修剪最左边的字符，所以称为
lstrip()。
有字符串方法，所以我们在字符串对象上调用它们。它们不带任何参数，因此调用它们的语法是:
# Strip from both left and right
my_string.strip()
# Strip only from the right
my_string.rstrip()
# Strip only from the left
my_string.lstrip()
让我们举一个例子来形象化地说明这一点:(我们放置一个名为“ _ENDOFSTRING ”的字符串结束标记，以查看是否删除了尾随空格和制表符。
my_string = "\t Hello from JournalDev\t \n"
print("Original String (with tabs, spaces, and newline)", my_string + "_ENDOFSTRING")
print("After stripping leading characters using lstrip(), string:", my_string.lstrip() + "_ENDOFSTRING")
print("After stripping trailing characters using rstrip(), string:", my_string.rstrip() + "_ENDOFSTRING")
print("After stripping both leading and trailing characters using strip(), string:", my_string.strip() + "_ENDOFSTRING")
输出
Original String (with tabs, spaces, and newline) Hello from JournalDev
_ENDOFSTRING
After stripping leading characters using lstrip(), string: Hello from JournalDev
_ENDOFSTRING
After stripping trailing characters using rstrip(), string: Hello from JournalDev_ENDOFSTRING
After stripping both leading and trailing characters using strip(), string: Hello from JournalDev_ENDOFSTRING
注意，在lstrip()的情况下，尾随字符(连同换行符)仍然存在，而在rstrip()和strip()中它们被删除了。
结论
在本文中，我们学习了如何使用各种方法从 Python 中的字符串中剥离。
参考
- JournalDev 关于修剪字符串的文章
如何在 Python 中对数据帧进行子集化？
原文：https://www.askpython.com/python/examples/subset-a-dataframe
在本教程中，我们将介绍几种可以用来划分数据帧子集的方法。如果要将数据导入 Python，则必须了解数据框。DataFrame 是一个二维数据结构，即数据以表格形式排列成行和列。
数据框子集化是从数据框中选择一组所需行和列的过程。
您可以选择:
- 所有行和有限的列
- 所有列和有限的行
- 有限的行和有限的列。
设置数据框的子集非常重要，因为它允许您仅访问数据框的特定部分。当您想要减少数据框中的参数数量时，这很方便。
让我们从导入数据集开始。
导入数据以构建数据框架
在本教程中，我们使用的是加州住房数据集。
让我们从使用 pandas 将数据导入数据框开始。
import pandas as pd
housing = pd.read_csv("/sample_data/california_housing.csv")
housing.head()
Housing Dataframe
我们的 csv 文件现在作为熊猫数据帧存储在 housing 变量中。
使用索引运算符选择数据帧的子集
索引操作符只是方括号的一个花哨名字。您可以仅使用方括号选择列、行以及行和列的组合。让我们来看看实际情况。
1.仅选择列
要使用索引运算符选择列，请使用下面的代码行。
housing['population']
Population
这行代码选择标签为“population”的列，并显示与之对应的所有行值。
您也可以使用索引运算符选择多个列。
housing[['population', 'households' ]]
Population And Household
要对数据帧进行子集化并存储，请使用以下代码行:
housing_subset = housing[['population', 'households' ]]
housing_subset.head()
这将创建一个单独的数据框作为原始数据框的子集。
2.选择行
您可以使用索引运算符根据特定条件选择特定的行。
例如，要选择人口数大于 500 的行，可以使用下面的代码行。
population_500 = housing[housing['population']>500]
population_500
population Greater Than 500
您还可以进一步划分数据框的子集。例如，让我们尝试从上面创建的 housing_subset 数据框中过滤行。
population_500 = housing_subset[housing['population']>500]
population_500
Subset
请注意，上面的两个输出具有相同的行数(应该是这样)。
使用 Python 子集化数据帧。loc()
。 loc 索引器是从数据帧中选择行和列的有效方法。它还可以用来同时选择行和列。
需要记住的重要一点是。loc()作用于行和列的标签。这之后，我们再来看看。基于行和列索引的 iloc()。
1.使用 loc()选择行
使用选择单行。loc()使用下面一行代码。
housing.loc[1]
Loc
要选择多行，请使用:
housing.loc[[1,5,7]]
Loc
您还可以对起始索引和结束索引之间的行进行切片。
housing.loc[1:7]
Slicing
2.选择行和列
要从数据框中选择特定的行和列，请使用以下代码行:
housing.loc[1:7,['population', 'households']]
这一行代码选择从 1 到 7 的行以及对应于标签“人口”和“住房”的列。
使用 Python iloc()子集 a 数据帧
iloc()函数 是整数位置的简称。它完全适用于行和列的整数索引。
要使用 iloc()选择行和列的子集，请使用以下代码行:
housing.iloc[[2,3,6], [3, 5]]
Iloc
这行代码选择行号 2、3 和 6 以及列号 3 和 5。
使用 iloc 可以省去您编写完整的行和列标签的麻烦。
在用整数替换标签后，您还可以使用 iloc()单独选择行或列，就像 loc()一样。
结论
本教程是关于使用方括号、loc 和 iloc 在 python 中设置数据框的子集。我们学习了如何将数据集导入数据框，以及如何从数据框中过滤行和列。
Python 中的数独求解器
原文：https://www.askpython.com/python/examples/sudoku-solver-in-python
今天就让我们用 Python 来构建一个数独求解器吧！数独谜题是一个非常受欢迎的谜题，出现在日报上，吸引了很多人的注意。关于数独谜题和它们的推广有许多困难的、未解决的问题，这使得这个谜题很有趣，特别是对许多数学爱好者来说。
什么是数独谜题？
在数独游戏中，我们需要用 1 到 9 之间的整数填充每个空盒子，这样从 1 到 9 的每个数字在每行、每列和每个用粗边框突出显示的 3 乘 3 的小盒子中都出现一次。
这个难题的难度可能会有所不同。数独谜题的难度级别越多，对计算科学家来说，研究问题就变得越有挑战性。难的谜题大多规定符号较少。
为娱乐而出版的数独游戏有独特的解决方案。如果一个数独谜题有唯一的解，它就被认为是良构的。另一个具有挑战性的研究问题是确定一个数独谜题需要填充多少个盒子才是良构的。有 17 个符号的格式良好的数独存在。未知是否存在一个只有 16 条线索的格式良好的谜题。线索越少，多解的几率越高。
用 Python 解决数独难题的步骤
- 在这个解决数独难题的方法中，首先，我们将 2D 矩阵的大小赋给一个变量 M (M*M)。
- 然后我们分配效用函数(puzzle)来打印网格。
- 稍后，它会将 num 分配给行和列。
- 如果我们在同一行或同一列或特定的 3*3 矩阵中找到相同的 num，将返回“false”。
- 然后，我们将检查是否已经到达第 8 行和第 9 列，并返回 true 以停止进一步的回溯。
- 接下来，我们将检查列值是否变为 9，然后我们移动到下一行和下一列。
- 现在我们进一步查看网格的当前位置是否有大于 0 的值，然后我们迭代下一列。
- 在检查它是否是一个安全的地方之后，我们移动到下一列，然后在网格的当前(行，列)位置分配 num。稍后，我们用下一列检查下一个可能性。
- 由于我们的假设是错误的，我们丢弃了指定的 num，然后我们用不同的 num 值进行下一个假设
用 Python 实现数独求解器
我们将使用回溯方法在 Python 中创建数独求解器。回溯意味着一旦我们确定我们当前的解决方案不能延续到一个完整的解决方案，就切换回上一步。我们使用这种回溯原理来实现数独算法。它也被称为解决数独难题的暴力算法。
M = 9
def puzzle(a):
for i in range(M):
for j in range(M):
print(a[i][j],end = " ")
print()
def solve(grid, row, col, num):
for x in range(9):
if grid[row][x] == num:
return False
for x in range(9):
if grid[x][col] == num:
return False
startRow = row - row % 3
startCol = col - col % 3
for i in range(3):
for j in range(3):
if grid[i + startRow][j + startCol] == num:
return False
return True
def Suduko(grid, row, col):
if (row == M - 1 and col == M):
return True
if col == M:
row += 1
col = 0
if grid[row][col] > 0:
return Suduko(grid, row, col + 1)
for num in range(1, M + 1, 1):
if solve(grid, row, col, num):
grid[row][col] = num
if Suduko(grid, row, col + 1):
return True
grid[row][col] = 0
return False
'''0 means the cells where no value is assigned'''
grid = [[2, 5, 0, 0, 3, 0, 9, 0, 1],
[0, 1, 0, 0, 0, 4, 0, 0, 0],
[4, 0, 7, 0, 0, 0, 2, 0, 8],
[0, 0, 5, 2, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 9, 8, 1, 0, 0],
[0, 4, 0, 0, 0, 3, 0, 0, 0],
[0, 0, 0, 3, 6, 0, 0, 7, 2],
[0, 7, 0, 0, 0, 0, 0, 0, 3],
[9, 0, 3, 0, 0, 0, 6, 0, 4]]
if (Suduko(grid, 0, 0)):
puzzle(grid)
else:
print("Solution does not exist:(")
输出:
====================== RESTART: C:/Users/SIDDHI/sudoku.py ===========
2 5 8 7 3 6 9 4 1
6 1 9 8 2 4 3 5 7
4 3 7 9 1 5 2 6 8
3 9 5 2 7 1 4 8 6
7 6 2 4 9 8 1 3 5
8 4 1 6 5 3 7 2 9
1 8 4 3 6 9 5 7 2
5 7 6 1 4 2 8 9 3
9 2 3 5 8 7 6 1 4
结论
这就是用 Python 构建数独求解器的全部内容！我希望您在通读这篇文章并了解我们如何实现代码时感到愉快。
嘘…用 Python 还有一种更简单的方法来构建数独求解器！
你可以导入数独游戏。来自 https://pypi.org/project/py-sudoku/的 PyPI 模块。这是一个简单的 Python 程序，可以生成并解决 m x n 数独难题。
很酷，不是吗？现在是你玩数独游戏的时候了！
下一步是什么？
资源
求二叉树中所有节点的和
原文：https://www.askpython.com/python/examples/sum-of-all-nodes-binary-tree
在本文中，我们将使用该算法来查找二叉树中所有节点的总和。我们已经讨论过 Python 中的级顺序二叉树遍历。
如何求二叉树中所有节点的和？
为了找到二叉树中所有节点的总和，我们将遍历二叉树的每个节点并找到它们的总和。在本文中，我们将使用一种改进的层次顺序树遍历算法来查找所有节点的总和。对于这个任务，我们将维护一个变量来保存总和，在处理每个节点之后，我们将把它的值加到总和中。
例如，下面的二叉树的元素之和是 150。
Binary tree
一种算法，用于计算二叉树中所有节点的和
如前所述，我们将使用层次顺序树遍历算法来制定算法，以找到二叉树的所有元素的总和。该算法可以用公式表示如下。该算法将二叉树的根作为输入，并将所有元素的和作为输出。
- 如果根为空，则返回。
- 设 Q 为队列。
- 将总和初始化为 0。
- 在 q 中插入 root。
- 从 q 中取出一个节点。
- 如果节点为空，请转到 10。否则，转到 7。
- 将节点中的元素添加到 sum 中。
- 将节点的左子节点插入 q。
- 将节点的右子节点插入 q。
- 检查 Q 是否为空。如果 Q 不为空，则转到 5。
算法在 Python 中的实现
正如我们已经讨论过的算法，我们将用 Python 实现该算法，并在上图给出的二叉树上执行它。
from queue import Queue
class BinaryTreeNode:
def __init__(self, data):
self.data = data
self.leftChild = None
self.rightChild = None
def insert(root, newValue):
# if binary search tree is empty, make a new node and declare it as root
if root is None:
root = BinaryTreeNode(newValue)
return root
# binary search tree is not empty, so we will insert it into the tree
# if newValue is less than value of data in root, add it to left subtree and proceed recursively
if newValue < root.data:
root.leftChild = insert(root.leftChild, newValue)
else:
# if newValue is greater than value of data in root, add it to right subtree and proceed recursively
root.rightChild = insert(root.rightChild, newValue)
return root
def sumOfNodes(root):
if root is None:
return 0
Q = Queue()
Q.put(root)
current_sum = 0
while not Q.empty():
node = Q.get()
if node is None:
continue
current_sum = current_sum + node.data
Q.put(node.leftChild)
Q.put(node.rightChild)
return current_sum
root = insert(None, 15)
insert(root, 10)
insert(root, 25)
insert(root, 6)
insert(root, 14)
insert(root, 20)
insert(root, 60)
print("Printing the sum of all the elements of the binary tree.")
print(sumOfNodes(root))
输出:
Printing the sum of all the elements of the binary tree.
150
结论
在本文中，我们已经讨论了寻找二叉树所有元素之和的算法。请继续关注更多关于 Python 中不同算法实现的文章。
了解 Python 中的 super()方法
原文：https://www.askpython.com/python/built-in-methods/super-method-in-python
介绍
今天在本教程中，我们将讨论 Python 中的 super()方法。
在进入主题之前，我们强烈建议浏览一下关于 Python 继承的教程。
一旦你了解了 Python 中的继承，我们就可以开始了。
Python 中的 super()方法
super方法返回一个代理对象，该对象将方法调用委托给类型的父类或兄弟类。这对于访问在类中被重写的继承方法很有用。
或者简单来说，就是用来调用构造函数，即超类的 __init__()方法。
下面给出了在 Python 中使用 super 的语法。
super([type[, object-or-type]])
在 Python 3.x 版本中，我们可以不用传递上述两个参数就可以使用 super。请看下面的代码片段。
class C(B):
def method(self, arg):
super().method(arg)
这里，C是派生类，B是基类，方法是带有参数arg的用户定义函数。
可以看到，行super().method(arg)实际上相当于 Python 3.x 中的super( C, self).method(arg)。这在 Python 2.x 中是不允许的。因此，在那里使用 super 有点棘手。
使用超级()
考虑下面给出的例子。
class Demo:
a = 0
b = 0
c = 0
def __init__(self,A,B,C):
self.a = A
self.b = B
self.c = C
def display(self):
print(self.a, self.b, self.c)
class Newdemo(Demo):
d = 0
def __init__(self,A,B,C,D):
self.a = A
self.b = B
self.c = C
self.d = D
def display(self):
print(self.a, self.b, self.c,self.d)
B1 = Demo(100,200,300)
print("Contents of Base Class:")
B1.display()
D1 = Newdemo(10,20,30,40)
print("Contents of Derived Class:")
D1.display()
输出:
Output
在上面的例子中，从基类Demo派生的类没有被有效或健壮地实现。
派生类Newdemo显式初始化基类的 A、B 和 C 字段的值。在初始化基类Demo中的相同字段时，也发现了相同的重复代码。
这个过程效率很低。这意味着一个子类必须被授权访问一个超类的成员。
因此，每当子类需要引用它的直接超类时，super就会出现。
Super()来调用超类构造函数
现在让我们对上面的例子应用super()方法。
class Demo:
a = 0
b = 0
c = 0
def __init__(self,A,B,C):
self.a = A
self.b = B
self.c = C
def display(self):
print(self.a, self.b, self.c)
class Newdemo(Demo):
d = 0
def __init__(self,A,B,C,D):
self.d = D
super().__init__(A,B,C) #super to call super Class
#The __init__() Method
def display(self):
print(self.a, self.b, self.c,self.d)
B1 = Demo(12,34,56)
print("Contents of Base Class:")
B1.display()
D1 = Newdemo(11,22,33,44)
print("Contents of Derived Class:")
D1.display()
输出:
Output
这里，派生类Newdemo用参数 a 、 b 和 c 调用super()。这导致基类的构造函数__init__，即Demo被调用。这将初始化 a 、 b 和 c 的值。因此，Newdemo类不再自己初始化值。
在 Python 2.x 中使用 super
下面给出了在 Python 2.x 中调用super类构造函数的语法，
super(Derived_Class_Name, self).__init__(Parameters_of_Super_Class_Constructor)
因此，如果我们想在 Python 2 中使用它，我们需要对上面的例子做一些小的修改。
首先，我们需要将object放在基类中，如下所示。
class Demo(object):
...#other statements
其次，在超类调用的站点传递Newdemo和self。像这样。
super(Newdemo,self).__init__(A,B,C) #super to call super Class
... #The __init__() Method
我们为什么需要 super()
在单继承有父类和子类的情况下，super函数用于隐式引用父类，而不用显式命名。这使得代码在本质上更加高效、可维护和健壮。
接下来，对于一个多级继承,super方法可以用来隐式引用直接超类。这也使得代码更容易理解和维护。
结论
所以在本教程中，我们理解了 Python 中 super()方法的概念，它的用途和需要。
任何进一步的问题，请在下面随意评论。
参考
- python Super-Journal Dev Post，
- Python 中的‘super’是做什么的？–stack overflow 问题，
- Python super——官方文档。
监督学习与非监督学习——需要了解的差异！
原文：https://www.askpython.com/python/supervised-vs-unsupervised-learning
读者朋友们，你们好！在本文中，我们将详细关注监督学习和非监督学习之间的差异。
在对数据值进行建模以了解趋势时，机器学习已经成为一个重要的概念。从类似的角度来看，它为我们提供了两种最常用的算法——监督和非监督的最大似然算法。
让我们在下一节中首先对这一点有一个简要的了解。
所以，让我们开始吧！！🙂
什么是监督学习？
监督机器学习是机器学习的一个分支，其中模型从历史数据值中学习。也就是说，我们向模型提供历史数据值(训练数据集)，然后模型/算法从提供的数据中学习，以对其执行预测。
当它从历史数据中学习时，它确定模式并使用它们对未知数据值执行预测。提供给模型的数据是完全标记的。
常见的监督 ML 算法——
现在让我们来理解一些有监督的机器学习算法，以了解相同的概念
线性回归
通过线性回归，我们试图根据对自变量数据的印象找到最佳拟合线来确定因变量。
也就是说，我们将这组值提供给算法(训练数据集)。基于这些值，算法试图找到并预测因变量的值。这里的所有变量本质上都是线性的，甚至最终结果值本质上都是线性的。
决策树
决策树是一种有监督的机器学习算法，具有流程图结构。也就是说，数据值的预测取决于决策规则。树结构的内部节点代表属性。该树根据这些属性的值进行划分和分区。分割继续进行，直到所有节点/属性都用尽。
什么是无监督学习？
与有监督的机器学习不同，无监督的 ML 算法不从历史数据值中学习。也就是说，它不接受任何带有模式的学习数据。相反，它从数据中检测相似的特征，并为预测形成相同的类别。
它利用未标记的数据，然后检测相同范围内的模式，并将其收集到一个分组的形式中，以便在输入时检测未知数据。
常见的无监督学习算法–
使用无监督学习算法，不会提供任何训练数据。假设 K 表示聚类，该算法对特定值(n)的数据进行聚类，并根据独立变量收集具有相似性的属性。
从而证明了检测模式的概念。基本上，就单词而言，我们的意思是说算法根据周围的其他属性考虑一些模式和相似性，将 n 个属性分组(聚类)。
监督学习和非监督学习的基本区别
让我们来了解一下监督学习和非监督学习的 3 个区别。
1.真实数据集上的结果
预测后，当我们考虑模型的评估时，与非监督学习模型相比，监督机器学习模型在更高的准确性方面给我们提供了更好的结果。
原因是受监督的 ML 模型从历史数据中学习，然后执行预测，这使得它更加准确。当我们想到无监督模型时，算法检测模式和执行预测有点挑战性，因为没有历史数据集，这可能导致开始时的准确性较低。
然而，如果无监督模型在真实世界的数据集上进行足够的“练习”，随着模型学习你以前可能没有见过的模式，准确性可以飙升。同样，这取决于模型和数据类型。
2.输入数据的性质
当涉及到监督学习算法时，馈入模型的输入数据被标记。这就是它如何使算法能够从数据中检测模式。
另一方面，未标记的数据被提供给无监督的模型，在其中检测相似的特征并将它们分组。
3.定型数据模型的行为
当涉及到监督机器学习时，模型需要输入学习数据和输出模型。它非常清楚输入和输出值。
使用无监督机器学习，只有输入/训练数据被馈送到模型。该模型不将预测的输出(对于历史数据)作为输入，这是它完全不知道的。
结论
到此，我们就结束了这个话题。如果你有任何问题，欢迎在下面评论。更多关于 Python 编程和机器学习的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的支持向量机
原文：https://www.askpython.com/python/examples/support-vector-machines-in-python
说到机器学习算法的实现，列表从线性回归到决策树开始。他们有各种各样的类型。主要当涉及沿着线性轴分离数据点时，专家的建议是:
- K-均值聚类。
- 支持向量机。
众所周知，ML 模型有两种类型:
一般理论
这篇文章的主要目的是让读者了解 SVM 的技巧是如何运作的。在互联网上，数据是原始的。因此，当我们构建数据并将其可视化时，结果要么是离散分布，要么是连续分布。据此，支持向量机用于两个目的:
- 分类:为离散数据参数。
- 回归:为连续数据参数。
这是支持向量机被高度用于分类和回归目的的主要原因之一。定义中说:支持向量机是一组学习算法，帮助我们对数据的性质进行分类和分析。
SVM 的组成部分
- 支持向量:这些是主要成分。它们是位于最大边距两侧的简单数据点。
- 最大余量:直到数据分类发生的最大限度。
- 最大边缘超平面:位于正负超平面之间的最大中限边缘。
- 正超平面:边缘平面的右侧。
- 负超平面:边缘平面左侧。
图表
SVM Diagram Simplified
在这张图中，我们可以清楚地看到，主要空白是根据颜色分隔所有不同的数据点。我们用颜色来表现它们的不同性质。SVM 的主要目的是显示区别，并用尽可能好的边缘线对每个点进行分类。
示例和应用
假设我们有一个类:车辆。我们的任务是从那个班拿运动型多功能车(SUV)。现在还有各种其他类型。现在，当我们试图按顺序手动排列它们时，可能会花费很多时间。这也产生了一些错误。因此，为了使分类更加稳定，我们可以创建一个支持向量机，它将对来自父车辆类别的所有汽车模型进行分类。它应按照以下步骤工作:
- 该模型将拍摄样本图像。
- 然后将其与已提供的车型试验数据进行比较。
- 之后，它会告诉我们输入图像中的汽车型号。
- 没有其他算法能比 SVM 更简单。
实现支持向量机
在本节中，我们将实现支持向量机的所有必要实现。所以，让我们开始吧！
环境详细信息:
- Python 3.9.7
- IDE: Jupyter 笔记本
- 环境:蟒蛇 3
- 数据集:癌症数据集(cell_samples.csv)
导入数据读取和预处理所需的库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from warnings import filterwarnings
filterwarnings("ignore")
读取数据集
cancer_data = pd.read_csv("Datasets/cell_samples.csv", sep = ",")
cancer_data.head()
输出:
Viewing The Dataset
检查空值
cancer_Data.isna().sum()
No Null Values
获取数据集的一般信息
print("The shape of the dataset is: ", cancer_data.shape)
print("The size of the dataset is: ", cancer_data.size, " bytes\n")
print("The count of each attribute of the dataset is: \n")
print(cancer_data.count())
print("\nThe datatype of each attribute is: \n")
print(cancer_data.dtypes)
输出:
The shape of the dataset is: (699, 11)
The size of the dataset is: 7689 bytes
The count of each attribute of the dataset is:
ID 699
Clump 699
UnifSize 699
UnifShape 699
MargAdh 699
SingEpiSize 699
BareNuc 699
BlandChrom 699
NormNucl 699
Mit 699
Class 699
dtype: int64
The datatype of each attribute is:
ID int64
Clump int64
UnifSize int64
UnifShape int64
MargAdh int64
SingEpiSize int64
BareNuc object
BlandChrom int64
NormNucl int64
Mit int64
Class int64
dtype: object
将 BareNuc 列转换为整数类型
cancer_data = cancer_data[pd.to_numeric(cancer_data["BareNuc"], errors = "coerce").notnull()]
cancer_data["BareNuc"] = cancer_data["BareNuc"].astype("int")
cancer_data.dtypes
ID int64
Clump int64
UnifSize int64
UnifShape int64
MargAdh int64
SingEpiSize int64
BareNuc int32
BlandChrom int64
NormNucl int64
Mit int64
Class int64
dtype: object
从数据框中分离出两个类
对于癌细胞类型分类，我们有两种类型的细胞用于分类:
- 恶性:在我们的数据集中值= 4
- 良性:在我们的数据集中值= 2
我们创建了两个同名的独立数据框。然后，尝试使用数据可视化技术对它们进行分类。仅从核心数据集中取前 50 个值。这使得绘图更容易。
malignant = cancer_data[cancer_data["Class"] == 4][0:50]
benign = cancer_data[cancer_data["Class"] == 2][0:50]
plt.figure(figsize = (10, 5))
ax = plt.axes()
ax.set_facecolor("white")
plt.title("Separating the data points - Clump and UniformShape")
plt.scatter(malignant["Clump"], malignant["UnifShape"] , color = "red", marker = "*")
plt.scatter(benign["Clump"], benign["UnifShape"], color = "green", marker = "+")
plt.legend(["Malignant cell class", "Benign cell class"])
plt.show()
Scatter Plots
使用 numpy 数组创建独立和从属数据列列表:
dependent_data = cancer_data[["ID", "Class"]]
independent_data = cancer_data[['Clump', 'UnifSize', 'UnifShape', 'MargAdh', 'SingEpiSize',
'BareNuc', 'BlandChrom', 'NormNucl', 'Mit']]
X_data = np.array(independent_data)
X_data[0:5]
Y_data = np.array(dependent_data["Class"])
Y_data[0:5]
输出:
array([[ 5, 1, 1, 1, 2, 1, 3, 1, 1],
[ 5, 4, 4, 5, 7, 10, 3, 2, 1],
[ 3, 1, 1, 1, 2, 2, 3, 1, 1],
[ 6, 8, 8, 1, 3, 4, 3, 7, 1],
[ 4, 1, 1, 3, 2, 1, 3, 1, 1]], dtype=int64)
array([2, 2, 2, 2, 2], dtype=int64)
将数据分为训练和测试变量
从 sklearn.model_selection 导入 train_test_split 函数。这将数据分成四个数组:
- x _ 火车
- x _ 测试
- y _ 火车
- y _ 测试
其中，训练阵列是二维的，测试阵列是一维的。只需记住取 test_size = 0.2，因为我们只需要总数据集的 20%来测试我们的模型准确性。
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X_data, Y_data, test_size = 0.2, random_state = 4)
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)
输出:
(546, 9)
(546,)
(137, 9)
(137,)
从 sklearn 导入 SVM 并创建分类器实例
首先我们导入模型，然后导入 SVC。它是用于分离支持向量的分类器类。创建一个实例“分类”。给定内核值为“线性”,它将线性分离支持向量。然后，我们使用 fit()函数拟合模型中的 X_train 数据和 Y_train 数据。之后，创建一个实例“y_predict ”,它将所有预测保存在一个一维数组中。
from sklearn import svm
classify = svm.SVC(kernel = "linear")
Classify.fit(X_train, y_train)
y_predict = Classify.predict(X_test)
print(y_predict)
输出:
array([2, 4, 2, 4, 2, 2, 2, 2, 4, 2, 2, 4, 4, 4, 4, 2, 2, 2, 2, 2, 4, 2,
4, 4, 4, 4, 2, 2, 4, 4, 4, 2, 4, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 4,
4, 2, 2, 2, 2, 4, 2, 2, 2, 2, 2, 2, 4, 2, 2, 2, 2, 4, 4, 2, 4, 4,
4, 2, 2, 2, 4, 4, 2, 2, 2, 4, 2, 2, 4, 4, 2, 2, 2, 2, 4, 4, 2, 4,
2, 2, 4, 4, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4, 2, 2, 4, 2, 4, 2, 2, 4,
2, 2, 4, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 2, 2, 4, 2, 2, 4, 2, 4, 2,
2, 2, 2, 2, 4], dtype=int64)
因此，我们成功地将所有的癌症患者与非癌症患者分开。值为 4 的细胞是癌性的，值为 2 的细胞是非癌性的。现在，我们已经得到了预测，我们可以对 Y_test 数组运行它们来检查模型的准确性。为此，我们可以准备一份分类报告。
准备分类报告
为此，我们需要从 sklearn.metrics 模块导入 classification_report 函数。然后在 print()函数内部调用它。我们用我们的 Y_test 数组测试它，结果如下:
from sklearn.metrics import classification_report
print(classification_report(y_test, y_predict))
输出:
precision recall f1-score support
2 1.00 0.94 0.97 90
4 0.90 1.00 0.95 47
accuracy 0.96 137
macro avg 0.95 0.97 0.96 137
weighted avg 0.97 0.96 0.96 137
结果表明模型的精度很高。对于恶性等级(值= 4) :精度分值为:100%。对于良性类(值= 2) ，精度分数为:90%
结论
因此，通过这种方式，我们成功地使用 Python 实现了支持向量机，并根据给定的输入数据构建了一个预测模型。
如何在 matplotlib 中绘制曲面图
原文：https://www.askpython.com/python-modules/matplotlib/surface-plot-in-matplotlib
我们之前已经介绍过如何在 matplotlib 中绘制等高线图。现在是时候学习 matplotlib 中的曲面图了。表面图是以视觉上令人愉悦的格式可视化三维数据的一种很好的方式。不同的颜色编码允许人们理解不同点的数据的可变性。在数学中，我们非常广泛地使用这个。
使用虚拟数据在 matplotlib 中绘制表面图
首先，让我们绘制一些虚拟数据的表面图。我们首先导入所有必需的库:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
现在让我们创建一些虚拟数据:
x = [1,2,3,4]
y = [5,7,10,12]
表面图需要网格数据，因此我们需要将数据转换成正确的格式，为此我们将使用 np.meshgrid 函数:
X, Y = np.meshgrid(x,y)
这给了我们以下结果:
[array([[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4]]),
array([[ 5, 5, 5, 5],
[ 7, 7, 7, 7],
[10, 10, 10, 10],
[12, 12, 12, 12]])]
我们现在需要创建第三个变量 Z，因为表面图是为三维数据集绘制的。我们将使用 X 和 Y 变量把它们转换成 Z 变量。有几个函数可以使用，但我们将使用一个常用的 z 函数，代码如下:
def z_function(x, y):
return np.sin(np.sqrt(x**2+y**2))
Z = z_function(X, Y)
现在我们有了所有三个变量，我们可以画出我们的表面图。为此，我们执行以下代码:
plt.figure(figsize=(10, 10))
ax = plt.axes(projection='3d')
ax.plot_surface(X, Y, Z)
如果我们执行上述代码，将生成下图:
Surface plot using Dummy Data
如果您使用 Jupyter 笔记本，那么您可以在最后一个程序块的开头添加以下命令，然后您甚至可以与图形进行交互:
matplotlib notebook
使用您自己的数据集(csv 文件)绘制表面图
现在，我们不会总是知道我们需要绘制的函数。事实上，大多数情况下，我们会有一些样本数据，并被要求使用这些数据创建一个曲面图。要做到这一点，让我们看看说明。
首先，我们需要将 csv 文件导入到 python 实例中。为此，我们将使用 pd.read_csv 函数:
df = pd.read_csv("name_of_csv.csv")
我们可以通过执行以下代码来查看数据集中的所有列:
df.columns
我们现在可以设置 x 和 y 变量，并再次创建网格:
x = df['column_name_of_x']
y = df['column_name_of_y']
X, Y = np.meshgrid(x,y)
我们需要再次定义我们的 z 函数:
Z = z_function(X, Y)
现在剩下的和以前一样，我们初始化坐标轴并绘制数据:
plt.figure(figsize=(10, 10))
ax = plt.axes(projection='3d')
ax.plot_surface(X, Y, Z)
最后，让我们添加一些标签，这一天就结束了！
ax.set_xlabel("x-label")
ax.set_ylabel("y-label")
结论
读者们，就这样吧！现在，您已经对如何使用 matplotlib 绘制曲面图有了基本的了解！如果你期待更多这样的精彩内容，请继续关注 AskPython，一如既往地感谢你的阅读！
Python 中的同步–Python 中的同步线程
原文：https://www.askpython.com/python/examples/synchronization-in-python
我们来谈谈 Python 中的同步。多线程允许您的计算机利用系统上的多核/多 CPU 并行执行操作。但是，当同时读取和更新共享变量时，可能会导致错误的结果。我们将学习如何同步线程以给出正确的结果。
理解多线程中的竞争条件
当两个或更多线程试图同时访问共享资源并更改数据时，这些变量的最终值是不可预测的。这是因为线程调度算法可以随时在线程之间交换，并且您不知道哪个线程将首先执行。这种情况称为竞争条件。
让我们举一个例子，我们使用线程将一些金额从一个银行帐户转移到另一个帐户。我们将创建 100 个线程来将 1 个单元从 account1 转移到 account2。
import threading
import time
class BankAccount():
def __init__(self, name, balance):
self.name = name
self.balance = balance
def __str__(self):
return self.name
# These accounts are our shared resources
account1 = BankAccount("account1", 100)
account2 = BankAccount("account2", 0)
class BankTransferThread(threading.Thread):
def __init__(self, sender, receiver, amount):
threading.Thread.__init__(self)
self.sender = sender
self.receiver = receiver
self.amount = amount
def run(self):
sender_initial_balance = self.sender.balance
sender_initial_balance -= self.amount
# Inserting delay to allow switch between threads
time.sleep(0.001)
self.sender.balance = sender_initial_balance
receiver_initial_balance = self.receiver.balance
receiver_initial_balance += self.amount
# Inserting delay to allow switch between threads
time.sleep(0.001)
self.receiver.balance = receiver_initial_balance
if __name__ == "__main__":
threads = []
for i in range(100):
threads.append(BankTransferThread(account1, account2, 1))
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print(account1.balance)
print(account2.balance)
account1 98
account2 3
最初，帐户 1 有 100 个单位，帐户 2 有 0 个单位。
在 100 次转移 1 个单位后，账户 1 应该有 0 个单位，账户 2 应该有 100 个单位。然而，我们得到了不同的结果。如果我们运行多次，我们会得到不同的结果。
Python 中的同步——同步线程的不同方法
让我们看看如何同步线程以避免竞争情况。
1.锁定对象
锁对象是最基本的同步原语，它在被锁定时不属于特定的线程。锁对象不保存关于哪个线程拥有锁的许可以及任何线程都可以释放锁的信息。
锁定对象处于两种状态之一:“锁定”和“解锁”。当创建锁对象时，它处于“解锁”状态。锁定对象中只有 3 种方法:
- acquire(): 该方法将锁对象从“解锁”状态改为“锁定”状态，并允许调用线程继续执行。如果锁对象已经处于“锁定”状态，调用线程将被阻塞，直到锁进入“解锁”状态。
- release(): 该方法将锁定对象的状态从“锁定”变为“解锁”状态。如果锁定对象已经处于“解锁”状态，则引发
RuntimeError。该方法可以从任何线程调用，而不仅仅是获得锁的线程。 - locked(): 如果获取了锁对象，则该方法返回 true。
让我们看看如何使用 Lock 对象将 Python 中的同步添加到银行转帐示例中。
import threading
import time
class BankAccount():
def __init__(self, name, balance):
self.name = name
self.balance = balance
def __str__(self):
return self.name
# These accounts are our shared resources
account1 = BankAccount("account1", 100)
account2 = BankAccount("account2", 0)
# Creating lock for threads
lock = threading.Lock()
class BankTransferThread(threading.Thread):
def __init__(self, sender, receiver, amount):
threading.Thread.__init__(self)
self.sender = sender
self.receiver = receiver
self.amount = amount
def run(self):
lock.acquire()
sender_initial_balance = self.sender.balance
sender_initial_balance -= self.amount
# Inserting delay to allow switch between threads
time.sleep(0.001)
self.sender.balance = sender_initial_balance
receiver_initial_balance = self.receiver.balance
receiver_initial_balance += self.amount
# Inserting delay to allow switch between threads
time.sleep(0.001)
self.receiver.balance = receiver_initial_balance
lock.release()
if __name__ == "__main__":
threads = []
for i in range(100):
threads.append(BankTransferThread(account1, account2, 1))
for thread in threads:
thread.start()
for thread in threads:
thread.join()
print(account1.name, account1.balance)
print(account2.name, account2.balance)
account1 0
account2 100
锁对象不知道哪个线程调用了acquire()方法，任何线程都可以对锁调用release()，锁可以从调用acquire()的线程那里获取许可。
同样，如果同一个线程在没有release()的情况下再次调用acquire()方法，该线程将处于死锁状态。
import threading
lock = threading.Lock()
def funcA():
print("In A, acquiring lock")
lock.acquire()
print("In A, lock acquired")
print("In A, lock acquiring again and entering into deadlock")
lock.acquire()
print("In A, releasing lock")
lock.release()
print("In A, lock released")
def funcB():
print("In B, releasing lock acquired by A")
lock.release()
print("In B, lock released")
if __name__ == "__main__":
thread1 = threading.Thread(target=funcA)
thread2 = threading.Thread(target=funcB)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
In A, acquiring lock
In A, lock acquired
In A, lock acquiring again and entering into deadlock
In B, releasing lock acquired by A
In B, lock released
In A, releasing lock
In A, lock released
2.锁定对象
可重入锁(RLock)是另一种同步原语，可以被同一个线程多次获取，而不会进入死锁状态。RLock 对象知道哪个线程拥有锁的权限，并且同一个线程可以解锁它。
RLock 对象处于两种状态之一:“锁定”和“解锁”。创建 RLock 对象时，它处于“解锁”状态。RLock 对象中只有两种方法:
- acquire(): 该方法将锁对象从“解锁”状态改为“锁定”状态，并允许调用线程继续执行。如果同一个线程再次调用此方法，它会将递归级别增加一级。为了完全释放锁，同一个线程需要调用
release()相同的次数。如果另一个线程在“锁定”状态下调用此方法，该线程将被阻塞。 - release(): 这个方法释放锁，递归层次减一。如果递减后递归级别变为 0，则锁定状态变为“未锁定”状态。如果递减后递归级别仍然是非零的，锁保持“锁定”状态，并由调用线程拥有。如果 RLock 对象已经处于“解锁”状态，则引发
RuntimeError。
import threading
lock = threading.RLock()
def funcA():
print("In A, acquiring lock")
lock.acquire()
print("In A, lock acquired, recursion level = 1")
print("In A, acquiring lock again")
lock.acquire()
print("In A, lock acquired again, recursion level = 2")
print("In A, releasing lock")
lock.release()
print("In A, lock released, recursion level = 1")
def funcB():
print("In B, trying to acquire lock, but A released only once, so entering in deadlock state")
lock.acquire()
print("This statement won't be executed")
if __name__ == "__main__":
thread1 = threading.Thread(target=funcA)
thread2 = threading.Thread(target=funcB)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
In A, acquiring l
In A, lock acquired, recursion level = 1
In A, acquiring lock again
In A, lock acquired again, recursion level = 2
In A, releasing lock
In A, lock released, recursion level = 1
In B, trying to acquire lock, but A released only once, so entering in deadlock state
3.信号灯
信号量只是一个非负的变量，在线程间共享。虽然Lock和RLock对象只允许一个线程执行，但 Semaphore 允许一次执行多个线程。信号量用于通过指定创建信号量对象时允许执行的线程数量来保护容量有限的资源。如果这个初始计数是 1，信号量可以帮助线程同步。
- 创建信号量: 创建信号量对象，在线程模块中调用
Semaphore(count)，其中count是允许同时访问的线程数。计数的默认值是 1。 - acquire(): 当线程调用此方法时
- 如果信号量的计数值为 0，线程将被阻塞，直到被调用
release()唤醒。 - 如果信号量的计数值大于 0，则它递减 1，线程继续执行。
- 如果信号量的计数值为 0，线程将被阻塞，直到被调用
- release(): 该方法将计数值递增 1。如果任何线程在
acquire()上被阻塞，它会解除其中一个线程的阻塞。
让我们举一个例子，10 个线程试图读取一个共享资源，但是我们使用信号量将对共享资源的并发读取限制为 3 个。
import threading
import time
read_mutex = threading.Semaphore(3)
# Our shared resource
data = "A Data Stream"
class ReaderThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
def run(self):
read_mutex.acquire()
output = self.getName() + " starts reading"
print(output)
# threads take time to read a data
time.sleep(0.5)
some_data = data
output = self.getName() + " ends reading"
print(output)
read_mutex.release()
if __name__ == "__main__":
threads = []
for i in range(10):
threads.append(ReaderThread())
for thread in threads:
thread.start()
for thread in threads:
thread.join()
Thread-6 starts reading
Thread-7 starts reading
Thread-8 starts reading
Thread-8 ends readingThread-7 ends readingThread-6 ends reading
Thread-10 starts reading
Thread-11 starts reading
Thread-9 starts reading
Thread-11 ends readingThread-10 ends reading
Thread-12 starts reading
Thread-13 starts reading
Thread-9 ends reading
Thread-14 starts reading
Thread-13 ends readingThread-12 ends reading
Thread-15 starts reading
Thread-14 ends reading
Thread-15 ends reading
结论
在本教程中，我们学习了 Python 中的同步，通过使用 Python 中的线程模块来避免竞争情况。我们使用 Lock、RLock 和信号量来实现 Python 中的同步。感谢阅读！！
语法错误:扫描字符串文字时出现 EOL
原文：https://www.askpython.com/python/syntax-error-eol-while-scanning-string-literal
Python 是一种解释型语言，本质上意味着每一行代码都是一个一个执行的，而不是一次把整个程序转换成更低级别的代码。
当 Python 解释器扫描每一行代码并发现异常时，它会引发一个错误，称为语法错误。这些错误可能是由“缺少括号”、“缺少结束引号”和语法中的其他基本异常引起的。
本文中我们将要讨论的语法错误是“扫描字符串文字时的 EOL”。
这个错误是什么意思？
我们不能解决一个问题，除非我们有效地理解它。 EOL 代表“生产线末端”。该错误意味着 Python 解释器在尝试扫描字符串文字时到达了行尾。
字符串文字(常量)必须用单引号和双引号括起来。扫描时到达“行尾”是指到达字符串的最后一个字符，没有遇到结束引号。
# String value
s = "This is a string literal...
# Printing the string
print(s)
运行上述代码会产生以下输出:
File "EOL.py", line 2
s = "This is a string literal...
^
SyntaxError: EOL while scanning string literal
小箭头指向字符串的最后一个字符，表示在解析语句的该部分时发生了错误。
既然我们已经理解了这个问题，那么让我们来看一些在运行 python 代码时会出现这个问题的例子。
如何修复“扫描字符串文字时出现语法错误:EOL”
可能会在四种主要情况下遇到此错误:
缺少结束引号
正如上面的代码片段所解释的，当 Python 解释器到达字符串文字的末尾并发现引号丢失时，它会引发一个语法错误。
# Situation #1
# Missing the ending quotation mark
s = "This is a string literal...
# Printing the string
print(s)
这个语法错误的原因很明显。每种语言都有一些基本的语法规则，违反这些规则会导致错误。
解决方案:
简单的解决方法是遵守语法规则并加上引号。
# Solution #1
# Place the ending quotation mark
s = "This is a string literal..."
# Printing the string
print(s)
使用不正确的结束引号
Python 允许使用' '和" "来封装字符串常量。有时程序员使用不正确的引用来结束字符串值。
# Situation #2
# Incorrect ending quotation mark
s = "This is a string literal...'
# Printing the string
print(s)
尽管字符串看起来是封闭的，但事实并非如此。Python 解释器在字符串末尾搜索匹配的引号。
解决方案:
基本的解决方案是匹配开始和结束引号。
# Solution #2
# Match the quotation marks
s = "This is a string literal..."
# Printing the string
print(s)
字符串常量拉伸到多行
许多初学 Python 的程序员会犯将语句拉长到多行的错误。Python 认为新的一行是语句的结尾，不像 C++和 Java 认为';'是语句的结尾。
# Situation #3
# String extending to multiple lines
s = "This is a string literal...
Going to the next line"
# Printing the string
print(s)
起初，代码可能看起来很普通，但是一旦新行开始，Python 解释器就结束该语句，并因没有包含字符串常量而引发错误。
解决方案 1:
转义序列'\n'可用于向字符串常量提供新行的效果。访问这里了解其他逃脱序列。
# Solution #3.1
# Using the escape sequences \n -> Newline
s = "This is a string literal... \n Going to the next line"
# Printing the string
print(s)
解决方案 2:
另一个解决方案是使用三重引号、'''或"""来存储多行字符串。
# Solution #3.2
# Using triple quotation marks
s = """This is a string literal...
Going to the next line"""
# Printing the string
print(s)
在结束引号前使用反斜杠
反斜杠'\'负责转义字符串并导致语法错误。
# Situation #4
# Storing a directory path
s = "\home\User\Desktop\"
# Printing the string
print(s)
引号前的最后一个反斜杠对字符串常量进行转义，Python 解释器将\"视为单个字符。这个转义序列被翻译成引号(")。
解决方案:
解决方案是用转义序列替换反斜杠(\\)。
# Solution #4
# Storing a directory path
s = "\\home\\User\\Desktop\\"
# Printing the string
print(s)
结论
长达一千行的代码中的一个错误可能会花费数小时来调试。因此，建议编写这样的代码时要非常专注，并使用正确的语法。
我们希望这篇文章在解决读者的错误方面有所收获。感谢您的阅读。
Python 中的 t 检验假设
原文：https://www.askpython.com/python/examples/t-test-hypothesis
无论是生物学研究还是人群研究，每种研究都有不同类型的统计检验。学生的 T 检验，或简称 T 检验，是另一种这样的检验，用于评估两个不同组之间的平均值。它被称为双样本 T 检验，或者具有特定值的 T 检验，它被称为单样本 T 检验。
在本文中，我们将详细讨论 T 检验。我们开始吧！
什么是 T 检验，它为什么有用？
T 检验是一种参数检验，用于在比较不同组的平均值或特定组的特定平均值后得出推论。t 检验遵循 t 分布，t 分布是一种连续概率分布。
t 检验特别适用于小样本数据(n<=30)，而 Z 检验只适用于大样本数据。即使对于非常小的数据量(n<=5)，t 检验也非常有用。
什么是 p 值和 Alpha？
P-value 实际上给出了你将得到一个比你通过做一个实验得到的值更大的值的概率的度量。α给出了当无效假设实际上为真时拒绝该假设的概率。α的值为 5 %或 0.05。因此，如果 p 值大于α，我们将接受零假设，如果小于α，我们将接受替代假设。
T 检验的类型
您可以使用三种类型的 T 检验。让我们详细地看一下它们，并学习如何用 Python 实现它们。
1.单样本 T 检验
单样本 t 检验或单样本 t 检验用于比较总体中随机样本的平均值和已知总体的平均值。例如，我们知道印度婴儿的平均出生体重是 2499 克，现在我们想将婴儿样本的平均出生体重与这个已知的平均值进行比较。
现在让我们看看这个测试的假设。
- 零假设:在这种情况下，样本均值等于总体的已知均值。
- 替代假设:在这种情况下，样本均值可以大于或小于已知总体均值。
- 另一个替代假设可以是样本均值，它不等于已知的总体均值。
让我们看看如何用 Python 实现这一点。
- 零假设:面积平均值为 5000。
- 替代假设:面积平均值不是 5000。
import scipy.stats as stats
import pandas as pd
data = pd.read_csv('C://Users//Intel//Documents//areas.csv')
t_statistic, p_value = stats.ttest_1samp(a=data, popmean=5000)
print(t_statistic , p_value)
输出:
[-0.79248301] [0.44346471]
这里我们可以看到 p 值大于 0.05，因此我们将接受零假设并拒绝替代假设。
2.双样本 t 检验
两个样本 t 检验或不成对独立检验用于通过比较它们的平均值来确定两个个体组之间的差异。在这种类型的 t 检验中，首先导出样本均值，然后从样本均值导出总体均值或未知均值。
例如:有两组，我们想通过比较它们的平均值来比较这两组的显著差异。
注:两组应从同一人群中独立取样。
让我们看看这种 t 检验的假设。
- 零假设:当两个组均值相等时为真。两个
- 备择假设:当两组均值不同时。
让我们看看如何用 python 来解释这一点。
import numpy as np
group1 = np.array([14, 15, 15, 16, 13, 8, 14, 17, 16, 14, 19, 20, 21, 15, 15, 16, 16, 13, 14, 12])
group2 = np.array([15, 17, 14, 17, 14, 8, 12, 19, 19, 14, 17, 22, 24, 16, 13, 16, 13, 18, 15, 13])
import scipy.stats as stats
stats.ttest_ind(a=group1, b=group2, equal_var=True)
输出:
Ttest_indResult(statistic=-0.6337397070250238, pvalue=0.5300471010405257)
由于 p 值大于 0.05，我们将接受零假设。
3.配对 T 检验
配对 t 检验用于比较同一受试者或人群的一对因变量之间的差异。当您有成对的测量值时，可以特别使用这种类型的 t 检验。您可以在测量前后应用该测试。
例如，您可以检查药物对人群的影响。用药前后可以看到药的效果。
让我们来看看假设。
- 零假设:两个因变量相等，两者之差等于零。
- 备择假设:两个因变量有差异。
- 另一个替代假设可以是两个独立变量可以大于或小于零。
注:此类试验的观察值应相互独立地取样。
让我们看看如何用 Python 实现这一点。在这种情况下，我们将生成人群用药前和用药后的数据。
pre = [88, 82, 84, 93, 75, 79, 84, 87, 95, 91, 83, 89, 77, 90, 91]
post = [91, 84, 88, 90, 79, 80, 88, 90, 90, 96, 88, 85, 81, 74, 92]
import scipy.stats as stats
stats.ttest_rel(pre, post)
输出:
Ttest_relResult(statistic=-0.36856465236305264, pvalue=0.7179658269802107)
双侧 p 值大于 0.05，因此我们接受零假设。
结论
在本文中，我们学习了 Python 中不同的 t 测试。t 检验的优点是它可以应用于非常小的样本量。在配对 t 检验的情况下，如果样本量很小，最好是两组具有很高的配对内相关性或 r 大于 0.8。
Python 制表模块:如何在 Python 中轻松创建表格？
原文：https://www.askpython.com/python-modules/tabulate-tables-in-python
各位程序员好！在今天的教程中，您将学习如何在 Python 中借助tabulate函数创建表格，并了解与所创建的表格相关的各种属性。
使用制表模块在 Python 中创建表格的步骤
事不宜迟，让我们直接进入使用制表模块在 Python 中创建表格的步骤。
1.导入tabulate
第一步是从制表库中导入制表函数。如果这导致一个错误，通过在命令提示符下执行pip install命令，确保您已经安装了制表库。
from tabulate import tabulate
现在让我们在制表函数的帮助下创建我们的第一个表格。
2.创建简单表格
表格的数据以嵌套的列表的形式存储，如下面提到的代码所示。
all_data = [["Roll Number","Student name","Marks"],
[1,"Sasha",34],
[2,"Richard",36],
[3,"Judy",20],
[4,"Lori",39],
[5,"Maggie",40]]
为了将数据制成表格，我们只需将数据传递给tabulate函数。我们还可以使用一个名为headers的属性将第一个嵌套列表作为表的头部。
table1 = tabulate(all_data)
table2 = tabulate(all_data,headers='firstrow')
两个表的结果如下所示。
----------- ------------ -----
Roll Number Student name Marks
1 Sasha 34
2 Richard 36
3 Judy 20
4 Lori 39
5 Maggie 40
----------- ------------ -----
Roll Number Student name Marks
------------- -------------- -------
1 Sasha 34
2 Richard 36
3 Judy 20
4 Lori 39
5 Maggie 40
3.格式化 Python 表以使其看起来更好
为了让 Python 中的表格看起来更好，我们可以为表格添加边框，使其看起来更像表格而不是文本数据。可以在tablefmt属性的帮助下添加边框，并将其值设置为grid。
print(tabulate(all_data,headers='firstrow',tablefmt='grid'))
+---------------+----------------+---------+
| Roll Number | Student name | Marks |
+===============+================+=========+
| 1 | Sasha | 34 |
+---------------+----------------+---------+
| 2 | Richard | 36 |
+---------------+----------------+---------+
| 3 | Judy | 20 |
+---------------+----------------+---------+
| 4 | Lori | 39 |
+---------------+----------------+---------+
| 5 | Maggie | 40 |
+---------------+----------------+---------+
为了让它看起来更好，我们可以使用fancy_grid来代替简单的网格。
print(tabulate(all_data,headers='firstrow',tablefmt='fancy_grid'))
╒═══════════════╤════════════════╤═════════╕
│ Roll Number │ Student name │ Marks │
╞═══════════════╪════════════════╪═════════╡
│ 1 │ Sasha │ 34 │
├───────────────┼────────────────┼─────────┤
│ 2 │ Richard │ 36 │
├───────────────┼────────────────┼─────────┤
│ 3 │ Judy │ 20 │
├───────────────┼────────────────┼─────────┤
│ 4 │ Lori │ 39 │
├───────────────┼────────────────┼─────────┤
│ 5 │ Maggie │ 40 │
╘═══════════════╧════════════════╧═════════╛
4.从制表中提取表格的 HTML 代码
为了提取表格的 HTML 代码，我们需要将tablefmt属性设置为html。同样显示在下面。
print(tabulate(all_data,headers='firstrow',tablefmt='html'))
<table>
<thead>
<tr><th style="text-align: right;"> Roll Number</th><th>Student name </th><th style="text-align: right;"> Marks</th></tr>
</thead>
<tbody>
<tr><td style="text-align: right;"> 1</td><td>Sasha </td><td style="text-align: right;"> 34</td></tr>
<tr><td style="text-align: right;"> 2</td><td>Richard </td><td style="text-align: right;"> 36</td></tr>
<tr><td style="text-align: right;"> 3</td><td>Judy </td><td style="text-align: right;"> 20</td></tr>
<tr><td style="text-align: right;"> 4</td><td>Lori </td><td style="text-align: right;"> 39</td></tr>
<tr><td style="text-align: right;"> 5</td><td>Maggie </td><td style="text-align: right;"> 40</td></tr>
</tbody>
</table>
结论
在本教程中，我们使用tabulate函数创建了自己的表格数据，并了解了表格的一些属性。希望你喜欢它！
感谢您的阅读！
双曲正切激活函数
原文：https://www.askpython.com/python/examples/tanh-activation-function
在深度学习中，神经网络由神经元组成，这些神经元根据它们的权重、偏差和各自的激活功能进行工作。基于输出中的误差来调整权重和偏差。这被称为反向传播。激活函数使这一过程成为可能，因为它们提供梯度以及误差来更新权重和偏差。
激活函数在神经网络中引入了非线性。它们将线性输入信号转换成非线性输出信号。一些激活功能有Sigmoid、ReLu、Softmax、tanh等。
在本教程中，我们将学习 tanh 激活函数。所以让我们开始吧。
tanh 是什么？
激活函数可以是线性的也可以是非线性的。tanh是正切双曲线的缩写。tanh是一个非线性激活函数。它是一个指数函数，主要用于多层神经网络，专门用于隐藏层。
让我们看看双曲正切函数的方程。
tanh Equation 1
这里，' e '是欧拉数，也是自然对数的底数。它的值大约为 2.718 。
通过简化，我们得到这个等式，
tanh Equation 2
据说双曲正切激活函数的性能比 s 形激活函数好得多。事实上，tanh和sigmoid激活函数是相互关联的，并且可以从彼此导出。
tanh 与 sigmoid 激活函数的关系
sigmoid激活函数的方程式为
Sigmoid Equation 1
同样，我们可以写，
Sigmoid Equation 2
因此，从等式 tanh 等式 1 和 sigmoid 等式 2 我们可以看到这两个等式之间的关系为
tanh Sigmoid Relation Equation
现在，让我们尝试使用 Python 绘制tanh函数的图形。
使用 Matplotlib 创建双曲正切图
我们将使用 matplotlib 库来绘制图表。这是一个巨大的图书馆，我们已经在网站上详细介绍过了。以下是 AskPython 上所有 matplotlib 教程的列表。
#importing the required libraries
from math import exp
import matplotlib.pyplot as plt
#defining the tanh function using equation 1
def tanh(x):
return (exp(x)-exp(-x))/(exp(x)+exp(-x))
#input to the tanh function
input = []
for x in range(-5, 5):
input.append(x)
#output of the tanh function
output = []
for ip in input:
output.append(tanh(ip))
#plotting the graph for tanh function
plt.plot(input, output)
plt.grid()
#adding labels to the axes
plt.title("tanh activation function")
plt.xlabel('x')
plt.ylabel('tanh(x)')
plt.show()
输出:
tanh Plot using first equation
从上面可以看出，图形tanh是 S 形。它可以取值范围从 -1 到+1 。此外，注意这里的输出是以零为中心的，这在执行反向传播时很有用。
如果我们不使用直接方程，而是使用tanh和sigmoid的关系，那么代码将是:
#importing the required libraries
from math import exp
import matplotlib.pyplot as plt
#defining the sigmoid function
def sigmoid(x):
return 1/(1+exp(-x))
#defining the tanh function using the relation
def tanh(x):
return 2*sigmoid(2*x)-1
#input to the tanh function
input = []
for x in range(-5, 5):
input.append(x)
#output of the tanh function
output = []
for ip in input:
output.append(tanh(ip))
#plotting the graph for tanh function
plt.plot(input, output)
plt.grid()
#adding labels to the axes
plt.title("tanh activation function")
plt.xlabel('x')
plt.ylabel('tanh(x)')
plt.show()
输出:
tanh Plot using second equation
上面两幅图完全相同，证明它们之间的关系是正确的。
tanh 函数已经在许多 NLP 应用中使用，包括自然语言处理和语音识别。
摘要
仅此而已！因此，我们在本教程中学习了tanh激活功能。如果你有兴趣，你还可以了解一下乙状结肠激活功能。
tarfile 模块——如何在 Python 中处理 tar 文件？
在本教程中，我们将了解什么是 tar 文件，并尝试使用 python 编程语言的tarfile模块创建和操作 tar 文件。
在本文中，我们将了解如何:
- 使用 tar file 模块创建一个 tar 文件
- 向 tar 文件添加和追加文件
- 获取 tar 文件中的文件列表
- 从 tar 文件中提取文件
什么是 tar 文件？
tar 文件中的名称 tar 代表磁带归档文件。Tar 文件是归档文件，将许多文件保存在一个文件中。
Tar 文件用于开源软件的分发。一般来说，tar 文件的扩展名是.tar，但是当它们被 gzip 之类的其他工具压缩时，它们的扩展名是tar.gz。
在 Python 中使用 tarfile 模块
现在让我们开始使用 tarfile 模块。如果你对学习 Python 中的 zip 文件更感兴趣，这里的 zipfile 模块教程将会是完美的。
1.如何使用 tar file 模块创建一个 tar 文件？
在 Python 中，我们可以使用tarfile模块创建 tar 文件。以写模式打开一个文件，然后将其他文件添加到 tar 文件中。下面的屏幕截图显示了创建压缩文件之前文件夹中的文件。
Folder Before Tar Creation
以下代码是用 Python 创建 tar 文件的实现。这里我们使用open()方法创建 tar 文件，使用add()方法将其他文件添加到 tar 文件中。
#import module
import tarfile
#declare filename
filename= "tutorial.tar"
#open file in write mode
file_obj= tarfile.open(filename,"w")
#Add other files to tar file
file_obj.add("plane.xml")
file_obj.add("sample.txt")
file_obj.add("person.ini")
#close file
file_obj.close()
这里的open()方法把要创建的 tar 文件的文件名作为第一个参数，把“w”作为以写模式打开文件的参数。add()方法把要添加到 tar 文件中的文件的文件名作为参数。
下图显示了运行上述代码时创建的 tar 文件。
Folder After Creating Tar
2.如何检查一个文件是否是 tarfile？
我们可以检查一个文件是否以。tar 扩展只是通过使用tarfile模块中的is_tarfile() 方法。下面的代码显示了代码的实现。
#import module
import tarfile
#declare filename
filename= "tutorial.tar"
#Check for the file being tarfile
#this will give true
flag=tarfile.is_tarfile(filename)
print("tutorial.tar is a tar file?")
print(flag)
#this will give false
flag=tarfile.is_tarfile("plane.xml")
print("plane.xml is a tar file?")
print(flag)
上面代码的输出是:
tutorial.tar is a tar file?
True
plane.xml is a tar file?
False
3.如何使用 tarfile 模块检查 tar 文件的内容？
要检查 tar 文件的内容而不提取它们，我们可以使用tarfile模块的getnames()方法。getnames()方法返回 tar 文件中的文件名列表。
这里我们以“读取”模式打开了文件，因此“r”作为第二个参数被赋予open()。方法
#import module
import tarfile
#declare filename
filename= "tutorial.tar"
#open file in write mode
file_obj= tarfile.open(filename,"r")
# get the names of files in tar file
namelist=file_obj.getnames()
#print the filenames
print("files in the tar file are:")
for name in namelist:
print(name)
#close file
file_obj.close()
上述代码的输出为:
files in the tar file are:
plane.xml
sample.txt
person.ini
4.如何将新文件直接追加到 tar 文件中？
我们可以像创建 tar 文件一样，使用tarfile 模块中的add()方法直接将额外的文件添加到 tar 文件中。
唯一的区别是我们必须在追加模式下打开文件，因此“a”作为第二个参数传递给open()方法。
#import module
import tarfile
#declare filename
filename= "tutorial.tar"
#open file in append mode
file_obj= tarfile.open(filename,"a")
# print initial content of tarfile
namelist=file_obj.getnames()
print("Initial files in the tar file are:")
for name in namelist:
print(name)
file_obj.add("sampleoutput.txt")
# print final content of tarfile
namelist=file_obj.getnames()
print("Final files in the tar file are:")
for name in namelist:
print(name)
#close file
file_obj.close()
上述代码的输出是:
Initial files in the tar file are:
plane.xml
sample.txt
person.ini
Final files in the tar file are:
plane.xml
sample.txt
person.ini
sampleoutput.txt
5.如何在 Python 中从 tar 文件中提取单个文件？
要从压缩文件夹中只提取一个文件，我们可以使用tarfile模块的extractfile()方法。
这个方法以一个文件名作为参数，并在我们的工作目录中提取文件。
#import module
import tarfile
#declare filename
filename= "tutorial.tar"
#open file in write mode
file_obj= tarfile.open(filename,"r")
#extract a file
file=file_obj.extractfile("sample.txt")
print("Content of the extracted file are")
#print content of extracted file
print(file.read())
#close file
file_obj.close()
上述代码的输出是:
Content of the extracted file are
b'This is a sample file for tarfile tutorial in python on askpython.com'
6.如何使用 tarfile 模块提取 tarball 中的所有文件？
要提取整个 tar 文件而不是单个文件，我们可以使用tarfile模块的extractall()方法。
下图显示了在提取 tar 文件的内容之前，文件夹的快照。
Folder Before Extracting From Tar\
extractall()方法将输出文件夹的名称作为它的参数，并将 tar 文件的全部内容提取到我们工作目录的文件夹中。
#import module
import tarfile
#declare filename
filename = "tutorial.tar"
#open file in write mode
file_obj = tarfile.open(filename,"r")
#extract all files
file = file_obj.extractall("extracted_tar_folder")
#close file
file_obj.close()
下图显示了从 tar 文件中提取文件夹后工作目录的快照。
Folder After Extracting From Tar
结论
在本教程中，我们已经了解了什么是 tar 文件，以及如何使用 python 中的tarfile模块创建、访问和操作 tar 文件。快乐学习！
Python how to–在 Python 中使用 tempfile 模块
原文：https://www.askpython.com/python/tempfile-module-in-python
大家好！在今天的文章中，我们将看看如何在 Python 中使用 tempfile 模块。
当你想存储临时文件时，这个模块非常有用。从应用程序的角度来看，可能需要存储临时数据，因此这些文件可能非常有用！
Python 为我们提供了tempfile模块，这给了我们一个易于使用的接口。让我们开始吧。
Python 中的 tempfile 模块
这个模块是标准库(Python 3.x)的一部分，所以你不需要用 pip 安装任何东西。可以简单导入！
import tempfile
我们现在将看看如何创建临时文件和目录。
创建临时文件和目录
tempfile模块给了我们TemporaryFile()方法，它将创建一个临时文件。
由于该文件是临时的，其他程序 不能 直接访问该文件。
作为一般的安全措施，Python 会在关闭后自动删除任何创建的临时文件。即使它保持打开，在我们的程序完成后，这个临时数据将被删除。
现在让我们看一个简单的例子。
import tempfile
# We create a temporary file using tempfile.TemporaryFile()
temp = tempfile.TemporaryFile()
# Temporary files are stored here
temp_dir = tempfile.gettempdir()
print(f"Temporary files are stored at: {temp_dir}")
print(f"Created a tempfile object: {temp}")
print(f"The name of the temp file is: {temp.name}")
# This will clean up the file and delete it automatically
temp.close()
输出
Temporary files are stored at: /tmp
Created a tempfile object: <_io.BufferedRandom name=3>
The name of the temp file is: 3
现在让我们试着找到这个文件，使用tempfile.gettempdir()获取存储所有临时文件的目录。
运行完程序后，如果您转到temp_dir(在我的例子中是/tmp——Linux ),您可以看到新创建的文件3不在那里。
ls: cannot access '3': No such file or directory
这证明 Python 在这些临时文件关闭后会自动删除它们。
现在，类似于创建临时文件，我们也可以使用tempfile.TemporaryDirectory()函数创建临时目录。
tempfile.TemporaryDirectory(suffix=None, prefix=None, dir=None)
目录名是随机的，所以您可以指定一个可选的suffix和/或prefix来标识它们，作为您程序的一部分。
同样，为了确保在相关代码完成后安全删除目录，我们可以使用一个上下文管理器来安全地包装它！
import tempfile
with tempfile.TemporaryDirectory() as tmpdir:
# The context manager will automatically delete this directory after this section
print(f"Created a temporary directory: {tmpdir}")
print("The temporary directory is deleted")
输出
Created a temporary directory: /tmp/tmpa3udfwu6
The temporary directory is deleted
还是那句话，要验证这一点，你可以试着去相关的目录路径，不会存在的！
1.从临时文件中读写
类似于从文件中读取或写入，我们也可以从临时文件中使用相同类型的函数调用来做到这一点！
import tempfile
with tempfile.TemporaryFile() as fp:
name = fp.name
fp.write(b'Hello from AskPython!') # Write a byte string using fp.write()
fp.seek(0) # Go to the start of the file
content = fp.read() # Read the contents using fp.read()
print(f"Content of file {name}: {content}")
print("File is now deleted")
现在让我们看看输出。
输出
Content of file 3: b'Hello from AskPython!'
File is now deleted
事实上，我们也能够轻松地读写临时文件。
2.创建命名的临时文件
在某些情况下，命名的临时文件可能有助于使文件对其他脚本/进程可见，以便它们可以在它尚未关闭时访问它。
tempfile.NamedTemporaryFile()对此很有用。这与创建普通临时文件的语法相同。
import tempfile
# We create a named temporary file using tempfile.NamedTemporaryFile()
temp = tempfile.NamedTemporaryFile(suffix='_temp', prefix='askpython_')
print(f"Created a Named Temporary File {temp.name}")
temp.close()
print("File is deleted")
输出
Created a Named Temporary File /tmp/askpython_r2m23q4x_temp
File is deleted
这里，创建了一个带有前缀askpython_和后缀_temp的命名临时文件。同样，关闭后会自动删除。
结论
在本文中，我们学习了如何使用 Python 中的 tempfile 模块来处理临时文件和目录。
参考
- Python 临时文件模块文档
- tempfile 模块上的 JournalDev 文章
tensor flow vs py torch vs Jax–比较
原文：https://www.askpython.com/python-modules/tensorflow-vs-pytorch-vs-jax
在本文中，我们尝试探索 python 中的 3 个主要深度学习框架——tensor flow vs py torch vs Jax。这些框架尽管不同，但有两个共同点——
- 它们是开源的。这意味着如果你觉得程序库中有一个 bug，你可以在 GitHub 中发布一个问题(并修复它)。您也可以在库中添加自己的功能。
- 由于全局解释器锁，Python 在内部很慢。所以这些框架使用 C/C++作为后端来处理所有的计算和并行处理。
我们将强调这些框架中最重要的几点，并尝试回答哪一个最适合您。
tensor flow vs py torch vs Jax–快速概述
| | Tensorflow | PyTorch | 贾克斯 |
| 开发人 | 谷歌 | 脸谱网 | 谷歌 |
| 灵活的 | 不 | 是 | 是 |
| 图形创建 | 静态/动态 | 动态的 | 静态 |
| 目标受众 |
研发人员 |
研发人员 | 研究人员
|
| 低级/高级 API | 高水平（位） | 两者 | 两者 |
| 发展阶段 | 成熟(2.4.1 版) | 成熟(1.8.0 版) | 开发中(v0.1.55) |
TensorFlow vs PyTorch vs Jax – Comparison table
TensorFlow
Google 开发的 TensorFlow 是目前最流行的机器学习库。以下是张量流的一些重要特征:
- 首先，它是一个非常用户友好的框架。高级 API -Keras 的可用性使得模型层定义、损失函数和模型创建变得非常容易。
- TensorFlow2.0 附带了使用动态类型图的急切执行。这使得该库更加用户友好，是对以前版本的重大升级。
- Keras 的这种高层接口有一定的弊端。由于 TensorFlow 抽象出了大量的底层机制(仅仅是为了方便最终用户)，这使得研究人员在使用他们的模型时自由度更小。
- Tensorflow 提供的最有吸引力的东西之一是 TensorBoard，它实际上是 TensorFlow 可视化工具包。它允许你可视化损失函数，模型图，剖析等。
因此，如果你正从深度学习开始，或者希望轻松部署你的模型，TensorFlow 可以是一个很好的开始框架。TensorFlow Lite 可以更轻松地将 ML 模型部署到移动和边缘设备。你可以查看官方的 GitHub Repo 来深入了解这个框架。
PyTorch
PyTorch(Python-Torch) 是一个来自脸书的机器学习库。它的受欢迎程度正在慢慢赶上 TensorFlow。PyTorch 的一些最重要的特性是:
- 与 TensorFlow 不同，PyTorch 使用动态类型图，这意味着执行图是随时创建的。它允许我们随时修改和检查图形的内部。
- 除了用户友好的高级 API 之外，PyTorch 确实有一个构建良好的低级 API，它允许对您的机器学习模型进行越来越多的控制。在训练期间，我们可以在模型向前和向后传递的过程中检查和修改输出。这被证明是非常有效的梯度裁剪和神经风格转移。
- PyTorch 允许扩展他们的代码，添加新的损失函数和用户定义的层很容易。PyTorch autograd 功能强大，足以通过这些用户定义的层进行区分。用户也可以选择定义如何计算梯度。
- PyTorch 对数据并行和 GPU 使用有广泛的支持。
- PyTorch 比 TensorFlow 更 pythonic 化。PyTorch 非常适合 python 生态系统，它允许使用 Python 调试器工具来调试 PyTorch 代码。
PyTorch 由于其高度的灵活性吸引了许多学术研究者和工业界的注意。学习起来既简单又直观。PyTorch 还有强大的社区支持，以防你遇到问题。请务必从托管在 GitHub 中的库中查看更多 PyTorch。
贾克斯
Jax 是 Google 推出的一个相对较新的机器学习库。它更像是一个亲笔签名的库，可以区分每一个原生 python 和 NumPy 代码。让我们看看 JAX 的一些特点:
- 正如官方网站所描述的，JAX 能够对 Python+NumPy 程序进行可组合转换:微分、矢量化、JIT 到 GPU/TPU，以及更多。
- 与 PyTorch 相比，JAX 最重要的方面是梯度是如何计算的。在 torch 中，图形是在向前传递过程中创建的，梯度是在向后传递过程中计算的。另一方面，在 JAX，计算被表示为一个函数。在函数上使用
grad()返回一个梯度函数，它直接计算给定输入的函数梯度。 - JAX 是一个亲笔签名的工具，单独使用它几乎不是一个好主意。有各种基于 JAX 的 ML 库，其中著名的有 ObJax、Flax 和 Elegy。因为它们都使用相同的核心，而且接口只是 JAX 库的包装，所以我们把它们放在同一个括号里。
- 亚麻最初是在 PyTorch 生态系统下发展起来的。它更注重使用的灵活性。另一方面，的挽歌更多的是受到了喀拉斯的启发。 ObJAX 主要是为面向研究的目的而设计的，更注重简单性和可理解性。事实上，它符合 研究者为研究者提出的口号。
JAX 正变得日益受欢迎。许多研究人员正在使用 JAX 进行他们的实验，吸引了 PyTorch 的一些流量。JAX 仍处于起步阶段，不建议刚开始探索深度学习的人使用(目前)。玩这种艺术需要一些数学专业知识。访问官方知识库以了解关于这个有前途的新图书馆的更多信息。
你选择哪一个？
选择 TensorFlow vs PyTorch vs Jax 的答案完全取决于您的使用目的。然而，如果你作为初学者从事机器学习项目，这两个库都不会出错。一旦你进入了高级 ML 建模，你的需求将变得足够具体，以至于你可以确定最适合你的库。
在那之前，敬请关注，继续学习！
Python 中基于终端的高低游戏
原文：https://www.askpython.com/python/examples/terminal-hi-lo-game-in-python
本文围绕创建我们自己的高低牌游戏，可以在命令行上玩。
Hi-Lo 非常简单，但却是赌场中著名的游戏，玩家的目标是猜测一副牌中的下一张牌是高还是低。卡片等级从王牌开始，从最低等级到国王，最高等级。
高低游戏演示
看起来很简单，对吧？让我们快速进入游戏的设计部分。
游戏设计
游戏开发中最有创意的部分是游戏设计。作为一款基于终端的卡牌游戏，对于一个程序员来说自由度并不多。
在游戏的特定时刻，会显示三张牌，前一张、当前一张和一副牌中面朝下的下一张。我们的游戏设计看起来像:
Cards Display
在屏幕上，我们可以看到红心 a，方块 7 和一张未知的下一张牌。这通过以下方式实现:
def print_cards(prev_card, current_card):
print()
print("\t ________________ ________________ ________________")
print("\t| | | | | |")
if prev_card.value == '10' and current_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
elif prev_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
elif current_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
else:
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| {} | | {} | | * |".format(prev_card.suit, current_card.suit))
print("\t| | | | | * |")
print("\t| | | | | * |")
print("\t| | | | | |")
print("\t| | | | | |")
if prev_card.value == '10' and current_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
elif prev_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
elif current_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
else:
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
print("\t|________________| |________________| |________________|")
print()
印刷卡片的技巧部分是卡片边界的对齐，这成为 10 值卡片的一个问题，因为它有两个字符而不是一个。使用简单的条件语句，问题就解决了。
print_cards()函数接受两个参数，即Card对象。
创建卡片
表示“扑克牌”的最佳方式是使用对象。我们创建一个Card类。
class Card:
def __init__(self, suit, value):
self.suit = suit
self.value = value
任何卡片都有两个特征:
- 花色–牌的花色类型，例如黑桃
- 数值–牌的面值，例如 ace 或九。
要了解更多 Python 中的类和对象，请访问这里。
西装和价值观
我们需要特定的数据结构来存储花色和牌的类型。
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The suit value
suits_values = {"Spades":"\u2664", "Hearts":"\u2661", "Clubs": "\u2667", "Diamonds": "\u2662"}
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":11, "Q":12, "K":13}
这些数据结构中的每一个都在游戏的流畅运行中扮演了一些角色。
制作一副纸牌
一副牌包含 52 张牌，每张牌都有不同的花色和值组合。使用对象列表，我们存储所有的卡片。
# The deck of cards
deck = []
# Loop for every type of suit
for suit in suits:
# Loop for every type of card in a suit
for card in cards:
# Adding card to the deck
deck.append(Card(suits_values[suit], card))
一切准备工作就绪后，就该开始游戏了。
hi_lo_game(deck)
函数hi_lo_game()负责一个游戏的运行。它需要一副牌才能工作。
设置游戏变量
在我们进入游戏逻辑之前，我们需要设置一些游戏变量:
- 前一张卡–我们需要用一张空卡初始化前一张卡。
- 当前卡–初始化当前卡
- 高低游戏的标准规则要求起始牌不是最低牌或最高牌。
- 从一副牌中取出当前的牌
- 得分–正确猜测的次数。
- 机会–一次不正确猜测的机会数量。
def hi_lo_game(deck):
global cards_values
# Initialize the previous card
prev_card = Card(" ", " ")
# Initialize the current card
current_card = random.choice(deck)
# The starting card cannot be lowest or highest
while current_card.value == "A" or current_card.value == "K":
current_card = random.choice(deck)
# Remove the card from the deck
deck.remove(current_card)
# Number of chances left
chances = 3
# The current
score = 0
第一行函数中card_values前的global关键字，负责获取当前函数hi_lo_game()范围外定义的全局变量card_values。
游戏循环
游戏逻辑的关键组成部分之一是游戏循环。在我们的高低游戏版本中，游戏循环取决于留给玩家的机会数量。因此:
# The GAME LOOP
while chances:
while 循环一直运行，直到留给玩家的机会不为零。
显示记分板
有两件事需要显示在我们的记分牌上:得分和机会。
# Function to print the scorebaord
def print_scoreboard(score, chances):
print("\t\t\t ____________________")
print("\t\t\t | |")
if score >= 10:
print("\t\t\t | Score = {} |".format(score))
else:
print("\t\t\t | Score = {} |".format(score))
print("\t\t\t | Chances Left = {} |".format(chances))
print("\t\t\t |____________________|")
游戏菜单
我们的游戏菜单是接受玩家输入所需的界面。在游戏过程中，菜单看起来像这样:
Game Menu
该游戏菜单由以下人员创建:
print_scoreboard(score, chances)
print_cards(prev_card, current_card)
print("\t\t ------------------------------------")
print("\t\t\t\tGAME MENU")
print("\t\t ------------------------------------")
print()
print("\t\t Enter 1 to bet for a high card")
print("\t\t Enter 0 to bet for a low card")
print()
接受玩家输入
在这个游戏中，玩家唯一要做的就是猜“高”或“低”。在游戏菜单中，我们已经给“高”分配了 1，而给“低”分配了 0。
# Try block for player input error
try:
choice = int(input("\t\t\t Enter your choice = "))
except ValueError:
clear()
print("\t\t\tWrong Input!! Try Again.")
continue
# Some wrong choice
if choice > 1 or choice < 0:
clear()
print("\t\t\tWrong Input!! Try Again.")
continue
有try块用于抑制误差，并通过except部分引导误差。
交换卡片
我们 Hi-Lo 游戏的游戏逻辑非常简单。我们需要将当前卡切换到之前的卡，并将未知卡作为当前卡。
# Switch the current card to the previous card
prev_card = current_card
# Choose the new current card
current_card = random.choice(deck)
# Remove the new card from the deck
deck.remove(current_card)
检查回合结果
新卡选定后，我们可以检查结果，即高或低。
# A high card
if cards_values[current_card.value] > cards_values[prev_card.value]:
result = 1
# A low card
elif cards_values[current_card.value] < cards_values[prev_card.value]:
result = 0
# Same value card
else:
result = -1
管理游戏变量
像分数和机会这样的游戏变量需要根据结果进行更新。
# A Tie Round
if result == -1:
clear()
print("\t\t\t TIE GAME!! Play Again")
# Round won
elif choice == result:
clear()
print("\t\t\t YOU WIN!!! Play Again")
score = score + 1
# Round Lost
else:
if chances == 1:
clear()
print("\t\t\t\tGAME OVER")
print_cards(prev_card, current_card)
print("\t\t Your Final Score =", score)
print("\t\t Thank you for playing!!!")
break
clear()
print("\t\t\t YOU LOSE!! Play Again")
chances = chances - 1
在玩家赢之前没有问题。当玩家输了，我们也需要管理游戏的结局。
一旦玩家消耗了最后一次机会，游戏就显示涉及打印最终分数的最终状态。
这总结了用 Python 语言创建我们自己的高低游戏的教程。
完整的代码
import random
import os
# Function to clear the terminal
def clear():
os.system("clear")
# Function to print the scorebaord
def print_scoreboard(score, chances):
print("\t\t\t ____________________")
print("\t\t\t | |")
if score >= 10:
print("\t\t\t | Score = {} |".format(score))
else:
print("\t\t\t | Score = {} |".format(score))
print("\t\t\t | Chances Left = {} |".format(chances))
print("\t\t\t |____________________|")
# Function to print the cards
def print_cards(prev_card, current_card):
print()
print("\t ________________ ________________ ________________")
print("\t| | | | | |")
if prev_card.value == '10' and current_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
elif prev_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
elif current_card.value == '10':
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
else:
print("\t| {} | | {} | | |".format(prev_card.value,current_card.value))
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| | | | | * * |")
print("\t| {} | | {} | | * |".format(prev_card.suit, current_card.suit))
print("\t| | | | | * |")
print("\t| | | | | * |")
print("\t| | | | | |")
print("\t| | | | | |")
if prev_card.value == '10' and current_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
elif prev_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
elif current_card.value == '10':
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
else:
print("\t| {} | | {} | | * |".format(prev_card.value,current_card.value))
print("\t|________________| |________________| |________________|")
print()
# The Card class definition
class Card:
def __init__(self, suit, value):
self.suit = suit
self.value = value
def hi_lo_game(deck):
global cards_values
# Initialize the previous card
prev_card = Card(" ", " ")
# Initialize the current card
current_card = random.choice(deck)
# The starting card cannot be lowest or highest
while current_card.value == "A" or current_card.value == "K":
current_card = random.choice(deck)
# Remove the card from the deck
deck.remove(current_card)
# Number of chances left
chances = 3
# The current
score = 0
# The GAME LOOP
while chances:
print_scoreboard(score, chances)
print_cards(prev_card, current_card)
print("\t\t ------------------------------------")
print("\t\t\t\tGAME MENU")
print("\t\t ------------------------------------")
print()
print("\t\t Enter 1 to bet for a high card")
print("\t\t Enter 0 to bet for a low card")
print()
# Check if we reached the end of the deck
if len(deck) == 0:
clear()
print_cards(prev_card, current_card)
print("\t\t YOU HAVE REACHED THE END OF THE DECK!")
print("\t\t Congratulations!!!")
print()
print("\t\t Your Final Score =", score)
print("\t\t Thank you for playing!!!")
break
# Try block for player input error
try:
choice = int(input("\t\t\t Enter your choice = "))
except ValueError:
clear()
print("\t\t\tWrong Input!! Try Again.")
continue
# Some wrong choice
if choice > 1 or choice < 0:
clear()
print("\t\t\tWrong Input!! Try Again.")
continue
# Switch the current card to the previous card
prev_card = current_card
# Choose the new current card
current_card = random.choice(deck)
# Remove the new card from the deck
deck.remove(current_card)
# A high card
if cards_values[current_card.value] > cards_values[prev_card.value]:
result = 1
# A low card
elif cards_values[current_card.value] < cards_values[prev_card.value]:
result = 0
# Same value card
else:
result = -1
# A Tie Round
if result == -1:
clear()
print("\t\t\t TIE GAME!! Play Again")
# Round won
elif choice == result:
clear()
print("\t\t\t YOU WIN!!! Play Again")
score = score + 1
# Round Lost
else:
if chances == 1:
clear()
print("\t\t\t\tGAME OVER")
print_cards(prev_card, current_card)
print("\t\t Your Final Score =", score)
print("\t\t Thank you for playing!!!")
break
clear()
print("\t\t\t YOU LOSE!! Play Again")
chances = chances - 1
if __name__ == '__main__':
# The type of suit
suits = ["Spades", "Hearts", "Clubs", "Diamonds"]
# The suit value
suits_values = {"Spades":"\u2664", "Hearts":"\u2661", "Clubs": "\u2667", "Diamonds": "\u2662"}
# The type of card
cards = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
# The card value
cards_values = {"A": 1, "2":2, "3":3, "4":4, "5":5, "6":6, "7":7, "8":8, "9":9, "10":10, "J":11, "Q":12, "K":13}
# The deck of cards
deck = []
# Loop for every type of suit
for suit in suits:
# Loop for every type of card in a suit
for card in cards:
# Adding card to the deck
deck.append(Card(suits_values[suit], card))
hi_lo_game(deck)
结论
Python 中的 Hi-Lo 游戏是一个非常容易创建的游戏。我们希望读者清楚创建一个简单的基于终端的游戏的基本概念。
如果您有任何疑问或建议，可以在下面的评论区给我们留言。
如何用 Python 创建基于文本的冒险游戏？
原文：https://www.askpython.com/python/text-based-adventure-game
你好，学习伙伴！今天我们将从头开始制作一个有趣的基于文本的冒险游戏。首先，让我们了解什么是基于文本的游戏，然后我们将在 python 编程语言中实现相同的内容。
什么是基于文本的游戏？
基于文本的游戏是完全基于文本的输入输出简单游戏。在这种类型的游戏中，当用户以输入的形式做出选择时，用户可以选择处理各种情况。
我们游戏的故事情节
下图显示了我们将在本教程中用 python 构建的小故事。你可以根据自己的喜好展开或者改变故事。
Text Based Story Game
基于文本的冒险游戏的 Python 实现
让我们首先通过打印最初的场景和故事如何发展来开始这个故事。这可以通过简单地使用打印功能来完成。为了更有趣，我们还可以添加表情符号和表情符号！
print("""WELCOME TO THE ADVENTURE GAME!
Let's start the action! ☆-🎬-☆
Lily wakes up in her bedroom in the middle of the night. She heard a loud BAN outside the house.
Now she has two choices she can either stay in the room or check what the sound might be about.
Type your choice: Stay or Evaluate?
""")
```py
干得好！现在我们有了场景设置，结果也很有趣，看，你的第一选择来了！现在让我们接受用户的输入，并为每个选择输入条件语句。
我们需要确保我们的游戏对用户输入的所有类型都有答案，并且不会导致任何选择的错误。
def scene1():
import time
print("""WELCOME TO THE ADVENTURE GAME!
Let's start the action! ☆-🎬-☆
Lily wakes up in her bedroom in the middle of the night. She heard a loud BAN outside the house.
Now she has two choices she can either stay in the room or check what the sound might be about.
Type your choice: Stay or Evaluate?
""")
c1 = input()
time.sleep(2)
ans = 'incorrect'
while(ans=='incorrect'):
if(c1.upper()=="STAY"):
print("\nLily decides to stay in the room and ends up staying inside forever as noone seems to come to help her.")
ans = 'correct'
elif(c1.upper()=="EVALUATE"):
print("Lily exits the room silently and reaches the main hall.")
ans='correct'
scene2()
else:
print("ENTER THE CORRECT CHOICE! Stay or Evaluate?")
c1 = input()
我们选择第一个选项`input`，然后我们将创建一个变量来确认我们的答案是正确还是不正确。然后我们创建条件循环和 if-else 语句。游戏一次又一次地要求选择，直到给出的答案有效。
现在第一个场景完成了，我们可以继续下一个场景，用同样的方式构建整个游戏。下面是第二个场景的代码。
def scene2():
import time
print("""
In the main hall, she finds a strange but cute teddy bear on the floor.
She wanted to pick the teddy up.
But should she? It doesn't belong to her. (•˳̂•̆)
Type your choice: Pick or Ignore?
""")
time.sleep(2)
c1 = input()
ans = 'incorrect'
while(ans=='incorrect'):
if(c1.upper()=="PICK"):
print("""\nThe moment Lily picked up the the teddy bear. The Teddy bear starts TALKING!The bear tells Lily that she is in grave danger as there is a monster in the house.And the monster has captured her PARENTS as well!But he hugged her and told her not to get scared as he knows how to beat the moster!""")
time.sleep(2)
print("""\nThe bear handed lily a magical potion which can weaken the moster and make him run away!He handed her the potion and then DISAPPEARED!Lily moved forward.""")
ans = 'correct'
pick="True"
elif(c1.upper()=='IGNORE'):
print("""\nLily decided not to pick up the bear and walked forward.""")
ans='correct'
pick="False"
else:
print("Wrong Input! Enter pick or ignore?")
c1=input()
time.sleep(2)
scene3(pick)
第三个场景的代码如下。现在，第三个场景的结果取决于场景 2 中的选择，即泰迪熊是被选中还是被忽略，以及主角是否收到了药剂。
def scene3(pick_value):
import time
print("""\n\nAfter walking for a while, Lily saw the MONSTOR in front of her!
It had red eyes and evil looks. She got very scared! """)
time.sleep(2)
if(pick_value"True"):
time.sleep(2)
print("""But then she remembered! She had the magic portion and she threw it on the moster!
Well she had nothing to lose!""")
time.sleep(2)
print("\n The monster SCREAMED in pain but he managed to make a portal and pushed Lily to a new world!")
elif(pick_value"False"):
print("The monster attacked Lily and hurt her! She was then thrown to the new world by the monster!")
我们将在三个场景后结束故事的第一章。你可以根据自己的喜好展开甚至改变整个故事。
要开始故事，只需开始故事的场景 1。
scene1()
print("\n\n")
print("=END OF CHAPTER 1=")
上面故事的结果如下图。这真是太棒了！
Text Based Adventure Game Output
## 结论
现在你知道如何建立简单和容易的基于文本的冒险游戏！你也可以尝试自己独特的故事！编码快乐！感谢您的阅读！
# Python 中的文本挖掘——完全指南
> 原文：<https://www.askpython.com/python/examples/text-mining-in-python>
今天，我们将学习一个非常令人兴奋的话题，那就是 Python 中的文本挖掘。我们将学习一些重要的模块，以及一些重要的方法。在深入讨论之前，让我们快速浏览一下目录。
## Python 中的文本挖掘是什么？
在开始之前，让我们了解什么是文本挖掘。
文本挖掘是从文本数据中提取信息的过程。它涉及多种任务，例如文本分类、文本聚类、概念/实体提取、情感分析、文档摘要和上下文相关建模。它使用信息检索、词汇分析、词频研究和模式识别技术来寻找链接和关联。它还使用可视化和自然语言处理算法和分析方法。
**文本挖掘的优势**
* 它构建非结构化数据以供进一步分析。
* 它降低了错误见解的风险。
* 它创建信息决策、自动化流程和研究分析。
## 文本挖掘的应用
* **信息提取**:从非结构化数据中识别和提取相关事实。
* **文档分类和聚类**:按照分类和聚类的方法对术语进行分组和归类。
* **信息检索**:将文本文档中检索到的文本进行字符串化。
* **[自然语言处理](https://www.askpython.com/python/examples/introduction-to-nlp) :** 它是文本挖掘的主要部分。这里，我们使用不同的计算任务来理解和分析来自文本文件的非结构化数据。
## 用 Python 实现文本挖掘
今天我们将进行文本挖掘，我们将在计算机上尝试一个简单的文本挖掘问题。让我们输入代码片段，不要迟到。我们将使用我们的 google collab。我们将一步一步来，完成我们的要求。
### 步骤 1:导入模块
为了完成我们的工作，我们需要导入一些模块。
* **Codecs 模块**:用于实现文件编码和解码的类，提供查找过程中管理错误的访问。
* **集合模块**:作为字典、列表、元组和集合等容器的替代。
* [**【NLTK(自然语言工具包)**](https://www.askpython.com/python-modules/tokenization-in-python-using-nltk) :是用于自然语言处理的库。
* [**Matplotlib 库**](https://www.askpython.com/python-modules/matplotlib/python-matplotlib) :用于我们数据的可视化(可能是图形或者图表)。
* [**NumPy 库**](https://www.askpython.com/python-modules/numpy/python-numpy-module) :用于处理数组。它提供了一些受 NumPy 库支持的内置方法。
* [**熊猫库**](https://www.askpython.com/python-modules/pandas/python-pandas-module-tutorial) :用于 python 编程语言中的数据操作和分析。
* **nltk.stem** :它是 nltk 模块的一个子包，为一个字符串或内容去除形态词缀(额外的乘积)。我们从这个子包中导入 porter stemmer 算法来完成词干提取。
* nltk.tokenize :它帮助我们将文本分割成记号。
最后两个包用于计算文本文件中的令牌数。我们将创建一个函数 `total_tokens()` ，我们将在同一个函数中使用这些函数。
```py
import codecs
import collections
import numpy as np
import pandas as pd
import nltk
from nltk.stem import PorterStemmer
from nltk.tokenize import WordPunctTokenizer
import matplotlib
如果在导入我们的模块时出现任何错误，您可以使用如下的 pip 安装程序在您的命令提示符下安装它们。
!pip install nltk
!pip install pandas
!pip install numpy
!pip install matplotlib
步骤 2:读取文本文件
编解码器模块提供 codecs.open()方法来读取和写入 Unicode 编码的文件。这对于读取包含多种不同语言字符的文件非常有用。
with codecs.open("/content/text1.txt", "r", encoding="utf-8") as f:
text1=f.read()
with codecs.open("/content/text2.txt", "r", encoding="utf-8") as f:
text2=f.read()
步骤 3:创建函数
我们使用的是 WordPunctTokenizer()。tokenize()方法来计算文本文件中的标记总数。这将帮助我们更容易地处理我们的数据文件。
我们使用 collection.counter()方法将每个单独的令牌作为键存储在字典中，并将它们的计数作为相应的值。这样，在实现之后，下面的函数将返回一个字典列表，以及令牌总数。
def total_tokens(text):
n = WordPunctTokenizer().tokenize(text)
return collections.Counter(n), len(n)
我们可以创建一个函数来计算文本文件中最常见单词的相对和绝对频率。通过这样做，我们可以创建一个返回结果的 dataframe。
#function to create relative frequency and absolute frequency for most common words
def make_df(counter, size):
#getting absolute and relative frequencies for each tokens in the counter list
absolute_frequency = np.array([el[1] for el in counter])
relative_frequency = absolute_frequency / size
#creating a data frame using obtained data above(absolute_frequency & relative_frequency)
df = pd.DataFrame(data=np.array([absolute_frequency, relative_frequency]).T, index = [el[0] for el in counter], columns=["Absolute frequency", "Relative frequency"])
df.index.name = "Most common words"
return df
步骤 4:处理文本
现在我们也将使用上述两个函数来分析单个文本。我们将把这两个文本文件传递给total_token()函数。在获得各个令牌及其计数的列表后，我们将把它们都传递给 make_df() 函数，以获得结果数据帧。
#for text1
text1_counter, text1_size = get_text_counter(text1)
make_df(text1_counter.most_common(10), text1.size)
上面的代码片段使用前面的函数 为每个令牌及其频率创建一个数据帧 。让我们对 text2 做同样的事情。
#for text2
text2_counter, text2_size = get_text_counter(text2)
make_df(text2_counter.most_common(10), text2_size)
上面的代码片段将给出如下结果。
让我们找出两个文档中最常见的单词，并打印出所有这些最常见单词的词频差异。
all_counter = text1_counter + text2_counter
all_df = make_df(all_counter.most_common(1000), 1)
x = all_df.index.values
#creating our new list for dataframe as df_data[] comprising of
#text1 relative frequency as text1_c,
#text2 relative frequency as text2_c, and
#Relative frequency difference as difference for both text files
df_data = []
for word in x:
#getting relative frequency for each word in text1 and text2 and loading the same into text1_C and text2_c respectively
text1_c = text1_counter.get(word, 0) / text1_size
text2_c = text2_counter.get(word, 0) / text2_size
#calculating difference between text1_c and text2_c & getting mod for all(in case of negative difference value)
difference = abs(text1_c - text2_c)
#appending above three columns into the list
df_data.append([text1_c, text2_c, difference])
#creating dataframe dist_df and loading above list into the same
dist_df = pd.DataFrame(data=df_data, index=x, columns=["text1 relative frequency", "text2 relative frequency","Relative frequency difference" ])
dist_df.index.name = "Most common words"
dist_df.sort_values("Relative frequency difference", ascending=False, inplace=True)
#printing our required result
dist_df.head(10)
上面的代码片段将给出如下输出。
步骤 5:将文件保存为 CSV 格式
dist_df.to_csv("output.csv")
上面的语法将创建一个名为 output.csv 的文件，并将我们的输出加载到这个文件中。就这样，我们保存了我们需要的结果。
结论
在本文中，我们讨论了文本挖掘的一小部分。我们学习了一些新的模块及其方法，然后将它们投入使用。我们希望您喜欢我们今天的教程，并期待在未来学习更多令人兴奋的话题。
Python gtts 模块:如何在 Python 中将文本转换成语音？
你好，学习伙伴！今天，我们将建立我们自己的文本到语音转换器！
我们开始吧！
项目介绍
文本到语音意味着将文本翻译成人类可以理解的语音。该应用程序对于那些在正确阅读句子和单词方面有困难的人来说非常有用。
在应用程序中，用户在输入框中输入一些文本，然后只需单击一下按钮，应用程序就会将文本转换成音频。
1.导入库
让我们从导入应用程序所需的库开始，如下所示:
- tkinter
- gTTS，
- 播放声音
from tkinter import *
from gtts import gTTS
from playsound import playsound
2.创建初始 Tkinter 窗口
首先，我们初始化了窗口，并为窗口添加了几何图形和其他配置，包括背景颜色和标题。
window = Tk()
window.geometry("350x300")
window.configure(bg='#FAD7A0')
window.title("TEXT TO SPEECH")
3.向窗口添加小部件
下一步包括在屏幕上添加标签、输入框和按钮。相同的代码如下所示。为了方便起见，突出显示了小部件声明。
对于这个应用程序，我们将使用三个按钮。一个是播放文本，第二个是重置应用程序，最后一个是退出应用程序。
Label(window, text = " TEXT TO SPEECH ", font = "arial 20 bold", bg='black',fg="white").pack()
Msg = StringVar()
Label(window,text ="Enter Your Text Here: ", font = 'arial 20 bold', fg ='darkgreen').place(x=5,y=60)
entry_field = Entry(window, textvariable = Msg ,width ='30',font = 'arial 15 bold',bg="lightgreen")
entry_field.place(x=5,y=100)
Button(window, text = "PLAY TEXT", font = 'arial 15 bold' , width = '20',bg = 'orchid',fg="white").place(x=35,y=140)
Button(window, font = 'arial 15 bold',text = 'RESET APPLICATION', width = '20',bg = 'darkgreen',fg="white").place(x=35 , y = 190)
Button(window, font = 'arial 15 bold',text = 'EXIT APPLICATION', width = '20' , bg = 'red',fg="white").place(x=35 , y = 240)
4.为按钮创建将文本转换为语音的功能
我们将为这三个按钮定义三个功能，退出应用程序按钮非常简单，我们只需要销毁窗口。
下一个功能，即重置按钮，通过将其设置为空字符串来删除输入框的内容。需要最后一个函数来将文本转换成语音，这需要下面描述的几个函数。
get:获取输入框中输入的文本，并存储在变量中gTTS:将传递给函数的消息转换成语音save:以 mp3 格式保存演讲playsound:播放上一步保存的语音
def Text_to_speech():
Message = entry_field.get()
speech = gTTS(text = Message)
speech.save('data.mp3')
playsound('data.mp3')
def Exit():
window.destroy()
def Reset():
Msg.set("")
下一步是将command属性添加到按钮声明中，将函数连接到相应的按钮。
将文本转换为语音的最终代码
该项目的完整的最终代码如下所示。
from tkinter import *
from gtts import gTTS
from playsound import playsound
def Text_to_speech():
Message = entry_field.get()
speech = gTTS(text = Message)
speech.save('data.mp3')
playsound('data.mp3')
def Exit():
window.destroy()
def Reset():
Msg.set("")
window = Tk()
window.geometry("350x300")
window.configure(bg='#FAD7A0')
window.title("TEXT TO SPEECH")
Label(window, text = " TEXT TO SPEECH ", font = "arial 20 bold", bg='black',fg="white").pack()
Msg = StringVar()
Label(window,text ="Enter Your Text Here: ", font = 'arial 20 bold', fg ='darkgreen').place(x=5,y=60)
entry_field = Entry(window, textvariable = Msg ,width ='30',font = 'arial 15 bold',bg="lightgreen")
entry_field.place(x=5,y=100)
Button(window, text = "PLAY TEXT", font = 'arial 15 bold' , command = Text_to_speech ,width = '20',bg = 'orchid',fg="white").place(x=35,y=140)
Button(window, font = 'arial 15 bold',text = 'RESET APPLICATION', width = '20' , command = Reset,bg = 'darkgreen',fg="white").place(x=35 , y = 190)
Button(window, font = 'arial 15 bold',text = 'EXIT APPLICATION', width = '20' , command = Exit, bg = 'red',fg="white").place(x=35 , y = 240)
window.mainloop()
示例输出视频
下面的视频展示了该应用程序的工作原理。看看吧！
结论
恭喜你！我们已经成功地构建了文本到语音的 python tkinter 项目。希望你喜欢它！
感谢您的阅读！
用 Python 从头开始创建 TF-IDF 模型
原文：https://www.askpython.com/python/examples/tf-idf-model-from-scratch
TF-IDF 模型是一种用数值表示单词的方法。“你好，最近怎么样？”你很容易明白我想问你什么，但是计算机擅长处理数字而不是文字。
为了让计算机理解句子和单词，我们用数字来表示这些句子，同时希望保留上下文和含义。
TF-IDF 模型就是这样一种用数值表示单词的方法。TF-IDF 代表“词频-逆文档频率”。
这种方法消除了单词袋模型所面临的缺点。它不会对所有单词赋予相同的值，因此出现几次的重要单词将被赋予较高的权重。
在本文中，我们将从头开始一步一步地创建一些样本文本语料库的 TF-IDF 表示。
TF-IDF 简介
TF-IDF 是词频和逆文档频的乘积。下面是 TF-IDF 的计算公式。
TF-IDF = Term Frequency (TF) * Inverse Document Frequency (IDF)
你问的词频和逆文档频是什么？让我们看看它们到底是什么。
什么是词频？
它是对文档中单词出现频率的度量。它是单词在文档中出现的次数与该文档中单词总数的比率。
tf(t,d) = count of t in d / number of words in d
什么是逆文档频率？
在语料库中很少出现的单词具有高 IDF 分数。它是文档数与包含该单词的文档数之比的对数。
我们取这个比率的对数，因为当语料库变大时，IDF 值可能变大，导致它爆炸，因此取对数将抑制这种效应。
我们不能除以 0，我们通过在分母上加 1 来平滑这个值。
idf(t) = log(N/(df + 1))
TF-IDF 模型的逐步实施
让我们直接进入 Python 中 TF-IDF 模型的实现部分。
1.预处理数据
我们将从预处理文本数据开始，为训练数据中的单词建立一个词汇集，并为集中的每个单词分配一个唯一的索引。
#Importing required module
import numpy as np
from nltk.tokenize import word_tokenize
#Example text corpus for our tutorial
text = ['Topic sentences are similar to mini thesis statements.\
Like a thesis statement, a topic sentence has a specific \
main point. Whereas the thesis is the main point of the essay',\
'the topic sentence is the main point of the paragraph.\
Like the thesis statement, a topic sentence has a unifying function. \
But a thesis statement or topic sentence alone doesn’t guarantee unity.', \
'An essay is unified if all the paragraphs relate to the thesis,\
whereas a paragraph is unified if all the sentences relate to the topic sentence.']
#Preprocessing the text data
sentences = []
word_set = []
for sent in text:
x = [i.lower() for i in word_tokenize(sent) if i.isalpha()]
sentences.append(x)
for word in x:
if word not in word_set:
word_set.append(word)
#Set of vocab
word_set = set(word_set)
#Total documents in our corpus
total_documents = len(sentences)
#Creating an index for each word in our vocab.
index_dict = {} #Dictionary to store index for each word
i = 0
for word in word_set:
index_dict[word] = i
i += 1
2.创建一个用于计数的字典
然后我们创建一个字典来记录包含给定单词的文档数量。
#Create a count dictionary
def count_dict(sentences):
word_count = {}
for word in word_set:
word_count[word] = 0
for sent in sentences:
if word in sent:
word_count[word] += 1
return word_count
word_count = count_dict(sentences)
3.定义一个函数来计算词频
现在，让我们先定义一个函数来计算词频(TF)。
#Term Frequency
def termfreq(document, word):
N = len(document)
occurance = len([token for token in document if token == word])
return occurance/N
4.定义计算逆文档频率的函数
现在，使用术语频率函数集，让我们为逆文档频率(IDF)定义另一个函数
#Inverse Document Frequency
def inverse_doc_freq(word):
try:
word_occurance = word_count[word] + 1
except:
word_occurance = 1
return np.log(total_documents/word_occurance)
5.组合 TF-IDF 功能
让我们创建另一个函数，将上面的 TF 和 IDF 函数结合起来，得到我们想要的 TF-IDF 模型的输出。
def tf_idf(sentence):
tf_idf_vec = np.zeros((len(word_set),))
for word in sentence:
tf = termfreq(sentence,word)
idf = inverse_doc_freq(word)
value = tf*idf
tf_idf_vec[index_dict[word]] = value
return tf_idf_vec
6.将 TF-IDF 模型应用到我们的文本中
TF-IDF 模型在 Python 中的实现已经完成。现在，让我们将文本语料库传递给函数，看看输出向量是什么样子的。
#TF-IDF Encoded text corpus
vectors = []
for sent in sentences:
vec = tf_idf(sent)
vectors.append(vec)
print(vectors[0])
TF-IDF Encoded Vector
现在，如果模型遇到除 vocab 之外的未知单词，它会给我们一个关键错误，因为我们没有考虑任何未知的标记。
本文的目的是展示 TF-IDF 实际上是如何工作的。
你可以在我的 GitHub 库这里找到本教程的笔记本。
使用一个新的、更加通用的文本语料库来随意实现和修改代码。
结论
在本文中，我们用 Python 从头实现了一个 TF-IDF 模型。我们还专注于理解模型背后的一些理论，并最终使用我们创建的函数对我们自己的句子进行编码。
快乐学习！
Python 中推荐系统的理论介绍
原文：https://www.askpython.com/python/examples/theory-intro-recommendation-systems
读者你好！今天，我们将学习 Python 中的推荐系统。
到本文结束时，您会知道:
它是什么，它们如何工作，需求是什么，它们的分类，需要哪些 python 模块，等等。所以，读完这篇文章，了解推荐系统的所有基础知识。我们开始吧
1.什么是推荐系统？
推荐系统，或称推荐系统，顾名思义，是向用户推荐某样东西的系统。这些工具可以提供一些建议，比如买什么东西，听什么歌，看什么电影。
这是我们每个人都在某个平台上经历过的事情。你有没有注意到，你今天在社交媒体上看到的广告，无论是 Instagram、脸书还是 YouTube，都是你今天早上搜索的同一件商品？如果没有，现在就观察。比方说，如果你在谷歌上搜索运动鞋，下次你打开 YouTube，你首先看到的将是运动鞋的广告。这是推荐系统的一个很好的例子。
因此，推荐系统是一个信息过滤系统，它预测用户可能喜欢看什么、买什么或读什么。
2.推荐系统是如何工作的？
现在我们已经了解了什么是推荐系统，让我们更进一步，看看它们是如何工作的。
推荐系统是数据科学和机器学习最重要的应用之一。这些系统的主要目标是为用户提供个性化的体验。
几乎每个主要的科技公司都在使用它。亚马逊使用这个系统向用户推荐他们的产品，youtube 使用它根据你的历史向你推荐视频(类似于你看过的视频)，网飞，亚马逊 Prime，Hotstar 使用它根据不同的算法向你推荐电影，Spotify 使用它进行音乐推荐。
这些平台大多根据你的历史，或者你通常喜欢和选择观看的类型等向你推荐项目。
但是如果你是一个新用户，那么这些平台也会显示一些推荐。这些推荐是基于他们的畅销书或歌曲，可能是前 20 名。
2.1.推荐系统的机制
让推荐系统发挥作用的步骤包括:
- 数据收集
这一步包括从用户或不同来源收集数据，以便系统可以根据获得的数据个性化用户的体验。
有两种方法可以做到:
首先，明确地说。该数据由用户以电影评论、评级等形式有意提供。
第二，含蓄。这些数据仅从用户处收集，但并非有意收集。它是从其他可用的数据流中收集的，如搜索历史、订单历史、点击等。
- 数据存储
收集完数据后，我们需要高效、有序地存储这些数据。数据量大得多，要妥善管理。数据量越多，推荐系统越好。
收集的数据类型决定其存储。它可能是一个标准的 SQL 数据库，也可能没有 SQL 数据库。
- 数据过滤
存储数据后，下一步是过滤数据。我们需要过滤数据以提取相关信息，这将有助于做出最终建议。
使用现有的几种算法之一来过滤数据。我们将在下一节讨论过滤数据的不同算法。
2.2 数据分类
推荐系统在不同的基础上推荐项目，要理解，它们主要分为 3 类:
- 简单的推荐系统
- 基于内容的推荐系统
- 协同过滤推荐系统
2.2.1 简单推荐系统
这些系统以概括的方式推荐一个项目。即，不管用户的历史如何，这些推荐对于每个用户都是相同的。推荐是基于流行度的，比如 IMDb 排名前 10 的电影，或者可能是流派，比如某个特定流派的前 5 首歌曲，诸如此类。
2.2.2 基于内容的推荐系统
这些系统根据你的历史向你推荐一件商品。它使用元数据向您推荐一个与您过去观看或喜欢的项目相似的项目。一个最有经验的例子就是你的 YouTube feed。它显示的视频与你已经看过的视频相似。此外，网飞、Hotstar 等 OTT 平台也使用这一系统。
2.2.3 协同过滤推荐系统
该算法不使用特定用户的偏好。它被广泛使用。它根据具有相似品味的其他用户对某个项目的评分，向特定用户推荐他/她可能喜欢的项目。
比方说，存在两个用户 A 和 B。两者都使用书籍推荐系统，并且都被要求给几本书打分。他们给出了相似的评级。喜欢都给了一个虚构的小说 5 星，给了一个非虚构的 3 星。然后，该算法将识别用户 A 阅读但 B 未阅读的书籍，然后将这些书籍推荐给用户 B。这就是该过滤的工作方式，并且它不需要任何项目元数据。
3.用 python 实现推荐系统所需的库
既然你已经了解了关于推荐系统的几乎所有东西。让我们学习一些 python 基础知识。在这一节中，我们将讨论实现基本推荐系统所需的 python 库。
- Scikit learn :它是 python 中的一个开源机器学习库，提供了预测数据分析的简单工具。
- Pandas :是 python 中的一个开源库，主要用于数据的分析和操作。
- Numpy:这是一个 python 库，有助于线性代数、矩阵和数组领域的工作。
4.为什么需要推荐系统？
推荐系统被广泛用于增加收入。科技公司投入大量资金让他们的推荐引擎变得有效。帮助用户购买更相关的产品。电影或歌曲推荐系统不断推荐电影，以便用户保持对其平台的关注。
推荐系统帮助组织有效地做出商业决策。
这些系统对用户也很有帮助。用户不必浪费时间来做出选择。系统会为他们做这件事。
结论
恭喜你，你坚持到了最后。你已经学习了推荐系统的基本理论。
我希望这篇文章对你有帮助。
Python 中的类线程——简要指南
原文：https://www.askpython.com/python/oops/threading-with-classes
本教程将向你解释如何利用类在 Python 中构建一个线程。但是首先，让我们定义一个线程。
什么是线程？
线程是一个并行执行流。这意味着您的代码将同时进行两件事情。
一个线程是当一个进程被调度执行时，用于执行的最小处理单元。
Python 中线程化的优势
- 多个线程可以在具有多个 CPU 的计算机系统上同时运行。因此，额外的应用程序可能会并发运行，从而加快进程的速度。
- 在单个和多个 CPU 的情况下，输入都是有响应的。
- 线程有局部变量。
- 当一个全局变量在一个线程中被更新时，它也会影响其他线程，这意味着全局变量内存是在所有线程中共享的。
开始一个新线程
现在你知道什么是线程了，让我们看看如何构建一个线程。它与 Windows 和 Linux 都兼容。
thread.start_new_thread ( func, args[, kwargs] )
使用类实现线程
现在，看下面的代码来理解一个线程是如何使用一个类形成的。在这种情况下，类名是 c1。在类 c1 中，创建了两个对象 obj 和 obj1。
线程从 Obj.start() 开始。
import threading
class c1(threading.Thread) :
def run(self) :
for _ in range (2) :
print(threading.currentThread().getName())
obj= c1(name='Hello')
obj1= c1(name='Bye')
obj.start()
obj1.start()
代码的输出如下所示:
Hello
Hello
Bye
Bye
结论
恭喜你！您刚刚学习了如何使用 Python 编程语言构建线程。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
- Python 中的同步——Python 中的同步线程
- Python 中的守护线程——它们是什么，如何创建它们？
- Python 中的多线程:一个简单的参考
感谢您抽出时间！希望你学到了新的东西！！😄
使用 Python 的井字游戏
原文：https://www.askpython.com/python/examples/tic-tac-toe-using-python
在本文中，我们将从头开始介绍使用 Python 语言创建井字游戏的步骤。
https://www.askpython.com/wp-content/uploads/2020/06/tic_tac_toe.mp4
关于游戏
井字游戏是一种双人游戏，在 3×3 的方格上进行。每个玩家轮流占据一个单元，目标是在水平、垂直或对角线模式中放置三个标记。一名玩家使用十字'X'作为他的标记，而另一名玩家使用零'O'。
第一步:井字游戏设计
我们将在命令行上玩井字游戏，因此，我们要做的第一件事是为我们的井字游戏创建一个设计。
Tic-tac-toe Design
如果玩家必须标记一个特定的盒子，他必须输入网格中显示的相应数字。假设，我们希望占据中心块，那么我们将在终端中输入5。该网格可以通过以下方式生成:
# Function to print Tic Tac Toe
def print_tic_tac_toe(values):
print("\n")
print("\t | |")
print("\t {} | {} | {}".format(values[0], values[1], values[2]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[3], values[4], values[5]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[6], values[7], values[8]))
print("\t | |")
print("\n")
在上面的代码中，该函数根据作为参数传递的值创建了我们的井字游戏。这里的参数values是一个包含网格中每个单元格状态的列表。
步骤 2:使用数据结构存储信息
任何游戏的核心都是背后的游戏机制。因为这是一个相当容易创建的游戏，所以涉及的机制也很简单。
在任何时刻，我们都需要两个关键信息:
- 网格的状态—我们必须有一个数据结构来存储每个单元格的状态，即它是被占用还是空闲。
- 每个玩家的招式****–我们必须以某种方式知道每个玩家过去和现在的招式，也就是
'X'和'O'所占据的位置。
注意:这两个信息都可以使用网格的状态来访问，但是每次我们需要玩家的位置时都需要遍历它。这可以称为时间与空间复杂度的权衡。这是一种节省时间的通用技术。
# Function for a single game of Tic Tac Toe
def single_game(cur_player):
# Represents the Tic Tac Toe
values = [' ' for x in range(9)]
# Stores the positions occupied by X and O
player_pos = {'X':[], 'O':[]}
网格的状态由一个字符列表管理，它可以有三个可能的值，
' '–一个空单元格'X'–玩家 X 占据的单元格'O'–玩家 O 占据的单元格
每个玩家的走法都被存储为一个整数列表的字典。键是用于各自玩家的'X'和'O'。它们对应的列表包含了它们所占据的网格单元的编号。
注:变量
cur_player，存储当前出招的玩家，如'X'或'O'。
第三步:游戏循环
每个游戏都有某种游戏循环，一直运行到某个玩家赢了或者游戏以平局结束。在井字游戏中，每一次循环迭代指的是任何玩家的一步棋。
# Game Loop for a single game of Tic Tac Toe
while True:
print_tic_tac_toe(values)
步骤 4:处理玩家输入
在每一次游戏迭代中，玩家必须输入他的移动。
# Try exception block for MOVE input
try:
print("Player ", cur_player, " turn. Which box? : ", end="")
move = int(input())
except ValueError:
print("Wrong Input!!! Try Again")
continue
# Sanity check for MOVE inout
if move < 1 or move > 9:
print("Wrong Input!!! Try Again")
continue
# Check if the box is not occupied already
if values[move-1] != ' ':
print("Place already filled. Try again!!")
continue
我们创建了一个try块，以防玩家输入一些意外的值。这样的事件不能停止游戏，因此，我们处理ValueError的异常并继续我们的游戏。
我们需要执行一些健全性检查，比如输入的值是一个有效的位置，如果它是一个有效的位置，它是否已经被占用？
第五步:更新信息
根据玩家输入，我们需要更新信息以使游戏顺利运行。
# Update game information
# Updating grid status
values[move-1] = cur_player
# Updating player positions
player_pos[cur_player].append(move)
values列表根据当前玩家更新所占的单元格。玩家位置加上当前玩家刚刚占据的位置。
在更新了values列表并调用了print_tic_tac_toe()函数之后，网格看起来像这样:
Tic-tac-toe after 5 turns.
Last move: ‘X’ at 2
第六步:检查赢或平
在每一步棋之后，我们都要检查是否有玩家赢了游戏或者游戏已经被抽了。可以通过以下方式进行检查:
函数调用:
# Function call for checking win
if check_win(player_pos, cur_player):
print_tic_tac_toe(values)
print("Player ", cur_player, " has won the game!!")
print("\n")
return cur_player
# Function call for checking draw game
if check_draw(player_pos):
print_tic_tac_toe(values)
print("Game Drawn")
print("\n")
return 'D'
如果任何玩家赢了，那么single_game()函数将返回当前的玩家，是谁走了这步棋。万一游戏抽到了，'D'发回。
功能:
# Function to check if any player has won
def check_win(player_pos, cur_player):
# All possible winning combinations
soln = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 4, 7], [2, 5, 8], [3, 6, 9], [1, 5, 9], [3, 5, 7]]
# Loop to check if any winning combination is satisfied
for x in soln:
if all(y in player_pos[cur_player] for y in x):
# Return True if any winning combination satisfies
return True
# Return False if no combination is satisfied
return False
# Function to check if the game is drawn
def check_draw(player_pos):
if len(player_pos['X']) + len(player_pos['O']) == 9:
return True
return False
check _ win()–该函数拥有所有中奖组合。它所做的只是，检查当前玩家的位置是否满足任何获胜组合。如果是，它返回True。如果没有一个组合被满足，那么函数返回False。
check _ draw()–抽签的条件相当简单，因为当所有“九”个位置都有人时，游戏就开始抽签。
第七步:切换当前玩家
由于每个玩家一次只能移动一次，因此每次成功移动后，我们必须交换当前的玩家。
# Switch player moves
if cur_player == 'X':
cur_player = 'O'
else:
cur_player = 'X'
就单个游戏而言，这就是我们需要做的一切。但是如果玩家想玩多个游戏，本文还提供了一个记分牌系统来记录。
第八步:输入玩家名字
任何记分牌都必须显示每个球员的名字。
if __name__ == "__main__":
print("Player 1")
player1 = input("Enter the name : ")
print("\n")
print("Player 2")
player2 = input("Enter the name : ")
print("\n")
第九步:存储游戏相关信息
需要存储像当前玩家、玩家的选择(打叉或不打叉)、可用选项(打叉和不打叉)以及记分牌这样的信息。
# Stores the player who chooses X and O
cur_player = player1
# Stores the choice of players
player_choice = {'X' : "", 'O' : ""}
# Stores the options
options = ['X', 'O']
# Stores the scoreboard
score_board = {player1: 0, player2: 0}
默认情况下，当前玩家是最先输入名字的玩家。
步骤 10:设计记分牌
记分牌存储为一个字典，其中键是玩家的名字，值是他们的获胜号码。
# Function to print the score-board
def print_scoreboard(score_board):
print("--------------------------------")
print(" SCOREBOARD ")
print("--------------------------------")
players = list(score_board.keys())
print(" ", players[0], " ", score_board[players[0]])
print(" ", players[1], " ", score_board[players[1]])
print("--------------------------------\n")
为了显示记分牌，我们需要玩家的名字。使用.keys()函数提取关键字，然后将其转换为列表，以便在显示分数时可以对其进行索引。
步骤 11:外部游戏循环
我们需要另一个游戏循环，用于管理井字游戏的多场比赛。每场比赛，当前玩家选择他的标记('X'或'O')。用于选择的菜单必须在每个游戏迭代中显示:
# Game Loop for a series of Tic Tac Toe
# The loop runs until the players quit
while True:
# Player choice Menu
print("Turn to choose for", cur_player)
print("Enter 1 for X")
print("Enter 2 for O")
print("Enter 3 to Quit")
记分板和菜单如下所示:
Scoreboard and Menu
步骤 12:处理和分配玩家选择
每次迭代，我们必须处理和存储当前玩家的选择。
# Try exception for CHOICE input
try:
choice = int(input())
except ValueError:
print("Wrong Input!!! Try Again\n")
continue
# Conditions for player choice
if choice == 1:
player_choice['X'] = cur_player
if cur_player == player1:
player_choice['O'] = player2
else:
player_choice['O'] = player1
elif choice == 2:
player_choice['O'] = cur_player
if cur_player == player1:
player_choice['X'] = player2
else:
player_choice['X'] = player1
elif choice == 3:
print("Final Scores")
print_scoreboard(score_board)
break
else:
print("Wrong Choice!!!! Try Again\n")
根据玩家的选择，数据已经存储。这很重要，因为在每场游戏结束后，它会告诉我们哪个玩家赢了。
步骤 13:执行匹配
在存储了所有必要的信息后，是时候执行独立匹配并存储获胜标记了。
# Stores the winner in a single game of Tic-tac-toe
winner = single_game(options[choice-1])
步骤 14:更新记分牌
我们需要在每场井字游戏后更新记分牌。
# Updates the scoreboard according to the winner
if winner != 'D' :
player_won = player_choice[winner]
score_board[player_won] = score_board[player_won] + 1
print_scoreboard(score_board)
如果游戏没有以平局结束，那么我们更新记分牌。
第 15 步:切换选择球员
这是一个慷慨的想法，每个玩家必须有机会选择他们想要的标志。为此，我们交换了cur_player中的值。
# Switch player who chooses X or O
if cur_player == player1:
cur_player = player2
else:
cur_player = player1
完整的工作代码
# Function to print Tic Tac Toe
def print_tic_tac_toe(values):
print("\n")
print("\t | |")
print("\t {} | {} | {}".format(values[0], values[1], values[2]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[3], values[4], values[5]))
print('\t_____|_____|_____')
print("\t | |")
print("\t {} | {} | {}".format(values[6], values[7], values[8]))
print("\t | |")
print("\n")
# Function to print the score-board
def print_scoreboard(score_board):
print("\t--------------------------------")
print("\t SCOREBOARD ")
print("\t--------------------------------")
players = list(score_board.keys())
print("\t ", players[0], "\t ", score_board[players[0]])
print("\t ", players[1], "\t ", score_board[players[1]])
print("\t--------------------------------\n")
# Function to check if any player has won
def check_win(player_pos, cur_player):
# All possible winning combinations
soln = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [1, 4, 7], [2, 5, 8], [3, 6, 9], [1, 5, 9], [3, 5, 7]]
# Loop to check if any winning combination is satisfied
for x in soln:
if all(y in player_pos[cur_player] for y in x):
# Return True if any winning combination satisfies
return True
# Return False if no combination is satisfied
return False
# Function to check if the game is drawn
def check_draw(player_pos):
if len(player_pos['X']) + len(player_pos['O']) == 9:
return True
return False
# Function for a single game of Tic Tac Toe
def single_game(cur_player):
# Represents the Tic Tac Toe
values = [' ' for x in range(9)]
# Stores the positions occupied by X and O
player_pos = {'X':[], 'O':[]}
# Game Loop for a single game of Tic Tac Toe
while True:
print_tic_tac_toe(values)
# Try exception block for MOVE input
try:
print("Player ", cur_player, " turn. Which box? : ", end="")
move = int(input())
except ValueError:
print("Wrong Input!!! Try Again")
continue
# Sanity check for MOVE inout
if move < 1 or move > 9:
print("Wrong Input!!! Try Again")
continue
# Check if the box is not occupied already
if values[move-1] != ' ':
print("Place already filled. Try again!!")
continue
# Update game information
# Updating grid status
values[move-1] = cur_player
# Updating player positions
player_pos[cur_player].append(move)
# Function call for checking win
if check_win(player_pos, cur_player):
print_tic_tac_toe(values)
print("Player ", cur_player, " has won the game!!")
print("\n")
return cur_player
# Function call for checking draw game
if check_draw(player_pos):
print_tic_tac_toe(values)
print("Game Drawn")
print("\n")
return 'D'
# Switch player moves
if cur_player == 'X':
cur_player = 'O'
else:
cur_player = 'X'
if __name__ == "__main__":
print("Player 1")
player1 = input("Enter the name : ")
print("\n")
print("Player 2")
player2 = input("Enter the name : ")
print("\n")
# Stores the player who chooses X and O
cur_player = player1
# Stores the choice of players
player_choice = {'X' : "", 'O' : ""}
# Stores the options
options = ['X', 'O']
# Stores the scoreboard
score_board = {player1: 0, player2: 0}
print_scoreboard(score_board)
# Game Loop for a series of Tic Tac Toe
# The loop runs until the players quit
while True:
# Player choice Menu
print("Turn to choose for", cur_player)
print("Enter 1 for X")
print("Enter 2 for O")
print("Enter 3 to Quit")
# Try exception for CHOICE input
try:
choice = int(input())
except ValueError:
print("Wrong Input!!! Try Again\n")
continue
# Conditions for player choice
if choice == 1:
player_choice['X'] = cur_player
if cur_player == player1:
player_choice['O'] = player2
else:
player_choice['O'] = player1
elif choice == 2:
player_choice['O'] = cur_player
if cur_player == player1:
player_choice['X'] = player2
else:
player_choice['X'] = player1
elif choice == 3:
print("Final Scores")
print_scoreboard(score_board)
break
else:
print("Wrong Choice!!!! Try Again\n")
# Stores the winner in a single game of Tic Tac Toe
winner = single_game(options[choice-1])
# Edits the scoreboard according to the winner
if winner != 'D' :
player_won = player_choice[winner]
score_board[player_won] = score_board[player_won] + 1
print_scoreboard(score_board)
# Switch player who chooses X or O
if cur_player == player1:
cur_player = player2
else:
cur_player = player1
游戏时间到了！
创建游戏的所有步骤都已完成。现在是玩游戏的时候了。
Player 1
Enter the name : Luffy
Player 2
Enter the name : Sanji
--------------------------------
SCOREBOARD
--------------------------------
Luffy 0
Sanji 0
--------------------------------
Turn to choose for Luffy
Enter 1 for X
Enter 2 for O
Enter 3 to Quit
1
| |
| |
_____|_____|_____
| |
| |
_____|_____|_____
| |
| |
| |
Player X turn. Which box? : 5
| |
| |
_____|_____|_____
| |
| X |
_____|_____|_____
| |
| |
| |
Player O turn. Which box? : 1
| |
O | |
_____|_____|_____
| |
| X |
_____|_____|_____
| |
| |
| |
Player X turn. Which box? : 9
| |
O | |
_____|_____|_____
| |
| X |
_____|_____|_____
| |
| | X
| |
Player O turn. Which box? : 2
| |
O | O |
_____|_____|_____
| |
| X |
_____|_____|_____
| |
| | X
| |
Player X turn. Which box? : 3
| |
O | O | X
_____|_____|_____
| |
| X |
_____|_____|_____
| |
| | X
| |
Player O turn. Which box? : 7
| |
O | O | X
_____|_____|_____
| |
| X |
_____|_____|_____
| |
O | | X
| |
Player X turn. Which box? : 6
| |
O | O | X
_____|_____|_____
| |
| X | X
_____|_____|_____
| |
O | | X
| |
Player X has won the game!!
--------------------------------
SCOREBOARD
--------------------------------
Luffy 1
Sanji 0
--------------------------------
Turn to choose for Sanji
Enter 1 for X
Enter 2 for O
Enter 3 to Quit
2
| |
| |
_____|_____|_____
| |
| |
_____|_____|_____
| |
| |
| |
Player O turn. Which box? : 5
| |
| |
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| |
| |
Player X turn. Which box? : 3
| |
| | X
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| |
| |
Player O turn. Which box? : 2
| |
| O | X
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| |
| |
Player X turn. Which box? : 8
| |
| O | X
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| X |
| |
Player O turn. Which box? : 1
| |
O | O | X
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| X |
| |
Player X turn. Which box? : 9
| |
O | O | X
_____|_____|_____
| |
| O |
_____|_____|_____
| |
| X | X
| |
Player O turn. Which box? : 6
| |
O | O | X
_____|_____|_____
| |
| O | O
_____|_____|_____
| |
| X | X
| |
Player X turn. Which box? : 7
| |
O | O | X
_____|_____|_____
| |
| O | O
_____|_____|_____
| |
X | X | X
| |
Player X has won the game!!
--------------------------------
SCOREBOARD
--------------------------------
Luffy 2
Sanji 0
--------------------------------
Turn to choose for Luffy
Enter 1 for X
Enter 2 for O
Enter 3 to Quit
3
Final Scores
--------------------------------
SCOREBOARD
--------------------------------
Luffy 2
Sanji 0
--------------------------------
结论
我们希望这篇文章对读者来说既有趣又有益。我也在 Github 上传了代码。你可以访问这里获取代码。如果对游戏有什么建议，欢迎评论。
用 Python 解决切片问题
在本教程中，我们将了解一个非常有趣的问题，称为平铺问题。我们先来了解一下，在这个问题上，我们想达到什么目的？
理解平铺问题
在平铺问题中，我们将得到一面尺寸为 4*n 的墙，这意味着墙的高度为 4，墙的长度为 n(将取自用户)。
现在，我们将拥有无限数量的尺寸为 4*1 的小瓷砖，它们可以以两种不同的方式排列在墙上。下图显示了同样的情况。
Arrange Small Tiles Tiling Problem
我们的目标是用上面提到的两种方法中的一种来计算所有可能的图案，以填满整面墙。
Python 中平铺问题的解决方案
人们可以使用循环和 if-else 条件手工编写简单的方法，也可以使用更快的方法，即递归方法。如果你想知道更多关于递归的知识，请阅读下面提到的教程。
了解更多关于递归的知识:Python 中的递归
使用递归，我们将把一个大问题分解成更小的问题。现在让我们来看看这两种安排中的小问题。
- 布置 1: 根据方法 1 放置第一块瓷砖，该方法将墙的长度减少 4，当前瓷砖上方剩余的空间只能以一种方式填充(方法 1 为 3 块瓷砖)
- 布置 2: 其次，我们可以按照方法 2 放置第一块瓷砖，这样可以将墙的长度减少 1。
在第一次安排完成后。我们通过调用相同的函数递归调用剩余墙壁的相同操作，但是 n 的值减少了。
最终的解决方案将是每个递归调用中两种安排的可能方式的总和。让我们通过下面展示的一个小插图来了解几个例子。
Recursive Solution Tiling Problem
用 Python 实现切片问题的解决方案
def find_count_arrangements(n):
if(n<=3):
return 1
return find_count_arrangements(n-1) + find_count_arrangements(n-4)
n = int(input())
print(find_count_arrangements(n))
通过递归，代码实现非常简单。只要确保你已经理解了前面解释的解决方案。
我希望你理解了平铺问题的问题陈述、解决方案和代码实现。感谢您的阅读！
快乐学习！😇
使用 Python 进行时间序列分析简介
原文：https://www.askpython.com/python/examples/time-series-analysis-python
在这篇文章中，我们将着眼于时间序列分析。时间序列数据是时间或与时间相关的数据。准确地说，时间序列数据是以特定的时间间隔进行索引的，因此得名。时间序列数据的例子有财政年度的股票价格、特定地区 10 年来每天的降雨量等。
对于数据分析师来说，时间序列是一个极其重要的研究领域，因为 Python 是一种简单易用的语言，所以有许多库和模块可用于这种分析。今天我们将讨论其中的一些。
什么是时间序列分析？
和所有的统计分析一样，时间序列数据是为我们感兴趣的东西收集的。通过计算机对数据进行分析，得出图形和数字结果。分析师可以使用数学趋势拟合和其他方法，甚至做出逻辑上合理的预测。这些数据还提供了一幅比通常肉眼所见更清晰的真实生活画面。
时间序列是以相等的时间间隔对同一变量进行的一组数值测量。可以每年、每月、每季度、每周、每天甚至每小时收集时间序列数据。时间序列数据有四个主要方面的行为:
- 趋势
- 季节性
- 周期
- 和无法解释的变化(包括异常值)
趋势是时间序列的总体长期方向。这种趋势的一个例子将是歌手和歌曲作者受欢迎程度的长期增长。这种“趋势”是多年来定期遵循的。有些系列可能没有任何特定的趋势。
当周期性的重复行为发生时，季节性就产生了。这方面的一个例子是印度六月至九月的日降雨量趋势。我们知道这每年都会发生。
当序列遵循非季节性的涨跌模式时，就会出现周期。周期可能长短不一，这使得它们比季节性更难识别。
在所有数据中，都存在随机扰动或随机变化。这被视为数据错误。无论我们的计算有多强大，总会包含一些误差。在一些数据中，误差较大，而在一些数据中，误差较小。
用于时间序列分析的 Python 模块
有几个库可用于时间序列分析。我们将查看前 5 个使我们能够轻松进行分析的库。
飞镖模块
首先，我们将关注 darts ，这是一个专门为时间序列开发的 python 库。Dart 支持单变量和多变量数据，这使得它对于初学者和一些有经验的分析师来说都是完美的。
该库还具有训练神经网络的能力。这个库中也实现了深度学习模型。要安装库，请执行以下代码:
pip install darts
t 刷新模块
对于我们的第二个模块，我们将关注 tsfresh 模块。Tsfresh 在计算常见时间序列参数方面速度非常快，可以自动计算超过 1200 个特征，并轻松管理数据。它还支持不同的时间序列长度。由于特征选择和提取，还支持并行化。您可以通过运行以下命令来安装 tsfresh:
pip install tsfresh
kats 模块
必须包含的下一个模块是 Kats 。Kats 的一个独特之处是它可以识别和报告各种时间序列模式，如趋势、季节变化和异常值。为了安装 kats，运行下面的代码:
pip install kats
意大利面模块
其中一个有趣的模块是 Pastas 。这是一个开源 python 包，专门用于分析水文地质时间序列数据。您可以通过运行以下代码来安装 Pastas:
pip install pastas
Pastas 支持 ARMA 模型，如果预计会发现自相关，则可用于移除自相关。
PyFlux
我们最后的库是 PyFlux 。PyFlex 提供了广泛的模型和推理选项。用户可以使用这个库并提出一个完整的概率模型，这样也可以找到一些关于不确定性或误差项的东西。
然而，这是耗时的。对于小型项目，用户可以使用最大似然法。使用以下命令安装 PyFlux:
pip install pyflux
时间序列数据集
数据集通常以表格格式存储，该表中的每一列包含给定变量/特征的测量值。在时序数据集中，列可以包含一个或多个随时间重复测量的变量。因此，时间序列可以是单变量或多变量的。
现在让我们看看时间序列数据的存储格式。通常有两种格式:长格式和宽格式。在长格式中，不同时间序列的值存储在同一列中。以这种方式存储数据使得有必要拥有一个标识符列，这样我们就可以在有多个变量的情况下进行区分。
另一种格式是宽格式，其中数据的存储方式是将每个单独的时间序列存储在单独的列中。
用户将不得不决定他们的特定用例应该遵循哪种格式，因为不同种类的分析需要不同的数据类型。
摘要
我们希望您喜欢学习 Python 中的数据分析，并期待更多这样的教程。这篇文章到此为止，要获得更多关于数据分析的精彩内容，请务必查看这个链接！
Tkinter 闹钟——循序渐进指南
原文：https://www.askpython.com/python-modules/tkinter/tkinter-alarm-clock
你好。今天在本教程中，我们将开发一个基本的 Python Tkinter 闹钟。
难怪闹钟总是在我们睡觉、小睡时提醒我们，或者提醒我们我们总是不知道的工作。
推荐阅读: Python Tkinter GUI 计算器
项目介绍
该项目利用了一些 python 库，即 datetime 和 Tkinter。
该项目利用当前的日期和时间以及一个功能，根据当前的日期和时间设置一个警报。
打造 Tkinter 闹钟
让我们不要再浪费时间了，现在就开始建设这个项目吧！
1.导入所需模块
在构建任何项目之前，第一步是导入项目所需的所有必要的库和模块。
from tkinter import *
import datetime
import time
import winsound
让我们了解一下我们刚刚导入的每个模块:
2.为警报创建功能
下一步是为闹钟创建函数。让我们先看看相同的代码。
def Alarm(set_alarm_timer):
while True:
time.sleep(1)
actual_time = datetime.datetime.now()
cur_time = actual_time.strftime("%H:%M:%S")
cur_date = actual_time.strftime("%d/%m/%Y")
msg="Current Time: "+str(cur_time)
print(msg)
if cur_time == set_alarm_timer:
winsound.PlaySound("Music.wav",winsound.SND_ASYNC)
break
def get_alarm_time():
alarm_set_time = f"{hour.get()}:{min.get()}:{sec.get()}"
Alarm(alarm_set_time)
名为Alarm的函数处理应用程序的主要功能。该函数将用户在窗口输入框中设置的报警时间作为参数。
sleep函数停止程序的执行，直到得到用户输入的时间值。
然后，我们使用datetime.now函数获取当前日期和时间，并借助strftime函数将时间和日期存储到单独的变量中。
该程序检查当前时间是否与用户设置的报警时间相匹配。当条件为真时，使用winsound模块播放声音，否则计时器继续计时。
定义了一个新函数来从用户输入框中获取输入，并将其传递给前面的函数。
3.创建 Tkinter 窗口
最后一步是创建应用程序的主窗口，其中包含所有已定义的小部件和特性。相同的代码如下所示。
window = Tk()
window.title("Alarm Clock")
window.geometry("400x160")
window.config(bg="#922B21")
window.resizable(width=False,height=False)
time_format=Label(window, text= "Remember to set time in 24 hour format!", fg="white",bg="#922B21",font=("Arial",15)).place(x=20,y=120)
addTime = Label(window,text = "Hour Min Sec",font=60,fg="white",bg="black").place(x = 210)
setYourAlarm = Label(window,text = "Set Time for Alarm: ",fg="white",bg="#922B21",relief = "solid",font=("Helevetica",15,"bold")).place(x=10, y=40)
hour = StringVar()
min = StringVar()
sec = StringVar()
hourTime= Entry(window,textvariable = hour,bg = "#48C9B0",width = 4,font=(20)).place(x=210,y=40)
minTime= Entry(window,textvariable = min,bg = "#48C9B0",width = 4,font=(20)).place(x=270,y=40)
secTime = Entry(window,textvariable = sec,bg = "#48C9B0",width = 4,font=(20)).place(x=330,y=40)
submit = Button(window,text = "Set Your Alarm",fg="Black",bg="#D4AC0D",width = 15,command = get_alarm_time,font=(20)).place(x =100,y=80)
window.mainloop()
Tkinter 闹钟的完整代码
from tkinter import *
import datetime
import time
import winsound
def Alarm(set_alarm_timer):
while True:
time.sleep(1)
actual_time = datetime.datetime.now()
cur_time = actual_time.strftime("%H:%M:%S")
cur_date = actual_time.strftime("%d/%m/%Y")
msg="Current Time: "+str(cur_time)
print(msg)
if cur_time == set_alarm_timer:
winsound.PlaySound("Music.wav",winsound.SND_ASYNC)
break
def get_alarm_time():
alarm_set_time = f"{hour.get()}:{min.get()}:{sec.get()}"
Alarm(alarm_set_time)
window = Tk()
window.title("Alarm Clock")
window.geometry("400x160")
window.config(bg="#922B21")
window.resizable(width=False,height=False)
time_format=Label(window, text= "Remember to set time in 24 hour format!", fg="white",bg="#922B21",font=("Arial",15)).place(x=20,y=120)
addTime = Label(window,text = "Hour Min Sec",font=60,fg="white",bg="black").place(x = 210)
setYourAlarm = Label(window,text = "Set Time for Alarm: ",fg="white",bg="#922B21",relief = "solid",font=("Helevetica",15,"bold")).place(x=10, y=40)
hour = StringVar()
min = StringVar()
sec = StringVar()
hourTime= Entry(window,textvariable = hour,bg = "#48C9B0",width = 4,font=(20)).place(x=210,y=40)
minTime= Entry(window,textvariable = min,bg = "#48C9B0",width = 4,font=(20)).place(x=270,y=40)
secTime = Entry(window,textvariable = sec,bg = "#48C9B0",width = 4,font=(20)).place(x=330,y=40)
submit = Button(window,text = "Set Your Alarm",fg="Black",bg="#D4AC0D",width = 15,command = get_alarm_time,font=(20)).place(x =100,y=80)
window.mainloop()
抽样输出
下面的视频展示了该应用程序的工作原理。您可以根据自己的喜好自定义窗口和变量。
结论
恭喜你！今天，我们成功地学习了如何使用 Python 的 Tkinter 模块制作闹钟。我们还学习了提取当前日期和时间，并在特定时刻播放声音。
希望你喜欢它！快乐学习！
Tkinter 教程–使用 Tkinter 按钮
原文：https://www.askpython.com/python-modules/tkinter/tkinter-buttons
大家好！在今天关于 Tkinter 的文章中，我们将介绍 Tkinter 按钮小部件。
Tkinter 按钮小部件是一个非常简单易用的小部件。
让我们用一些说明性的例子来看看我们如何构造按钮并向我们的 GUI 应用程序添加功能！
Tkinter 按钮小工具
这个小部件可以用来制作不同类型的按钮。
我们可以让按钮不仅包含文本，还包含图像！
我们还可以使用回调函数让 Tkinter 按钮调用与按钮功能相对应的特定函数。
要定义一个带有特定文本和回调函数的按钮，我们可以使用下面的定义:
button = tk.Button(master, text, command)
这里，text是按钮上的文字，command是指按钮被按下时调用的回调函数。
现在让我们制作一个简单的应用程序，它有一个按钮，当点击它时，显示一个警告框，告诉我们它被点击了！
下面的代码片段说明了这一点，注释解释了每一行代码。
import tkinter as tk
from tkinter import messagebox
# Create the master object
master = tk.Tk()
# Sets the window size as "300x300"
master.geometry("300x300")
# This is the button callback function
# This must be visible to the button, so we must define it before the button widget!
def buttonCallback():
messagebox.showinfo("Message", "You have clicked the Button!")
# Create a Button widget
button = tk.Button(master, text="Click", command=buttonCallback)
# And a label for it
label_1 = tk.Label(master, text="Simple Button")
# Use the grid geometry manager to put the widgets in the respective position
label_1.grid(row=0, column=0)
button.grid(row=1, column=0)
# The application mainloop
tk.mainloop()
现在，运行这个程序，您将得到以下输出。
Button Example 1
现在，如果你想要一个图片和你的按钮在一起，让它看起来更漂亮，这是可能的！
只需在tk.Button()调用中添加另一个关键字参数，名为image！这是一个ImageTk.PhotoImage，您必须使用一个图像文件来实例化它。
要使用ImageTk，必须从PIL模块导入。我们首先创建一个PIL图像，调整它的大小，使它足够小，然后形成我们的PhotoImage。
from PIL import Image, ImageTk
# Create a tk.PhotoImage
my_image = Image.open("path/to/image.png")
# Resize it to fit button dimensions
my_image = my_image.resize((25, 25), Image.ANTIALIAS)
现在，我们准备好形成 photoimage 对象。
my_image = Imagetk.PhotoImage(my_image)
现在，我们终于可以将它添加到我们的按钮上了！
b = Button(compound=LEFT, image=my_image, text="Button")
但是，你必须小心，因为使用图标会覆盖按钮上的任何文本。
要避免这种情况，请使用compound关键字参数。该值可以设置为tk.CENTER、tk.LEFT、tk.RIGHT、tk.TOP或tk.BOTTOM。这将指定文本相对于图像的方向。
因为我们将文本放在图像的顶部，所以我们将使用tk.TOP
b = Button(compound=LEFT, image=my_image, text="Button", compound=tk.TOP)
下面我将向您展示完整的代码:
import tkinter as tk
from tkinter import messagebox
from PIL import Image, ImageTk
# Create the master object
master = tk.Tk()
# Sets the window size as "300x300"
master.geometry("300x300")
# This is the button callback function
# This must be visible to the button, so we must define it before the button widget!
def buttonCallback():
messagebox.showinfo("Message", "You have clicked the Button!")
# Create a tk.PhotoImage
my_image = Image.open("debian.png")
# Resize it to fit button dimensions
my_image = my_image.resize((25, 25), Image.ANTIALIAS)
# Finally, get the PhotoImage object
my_image = ImageTk.PhotoImage(my_image)
# Create a Button widget
button = tk.Button(master, text="Click", image=my_image, command=buttonCallback, compound=tk.TOP)
# And a label for it
label_1 = tk.Label(master, text="Simple Button")
# Use the grid geometry manager to put the widgets in the respective position
label_1.grid(row=0, column=0)
button.grid(row=1, column=0)
# The application mainloop
tk.mainloop()
输出
Button Example 2
结论
希望您也能够构建自己的 Tkinter 按钮小部件。在接下来的教程中，我们将更多地关注更多的小部件，请继续关注！
Tkinter 教程第 1 部分-制作 Tkinter 画布
原文：https://www.askpython.com/python-modules/tkinter/tkinter-canvas
大家好！让我们在本教程中学习如何创建一个 Tkinter 画布。由于 Tkinter 库非常大，我们将在接下来的时间里讨论很多有趣的话题！
Tkinter 是什么？
Tkinter 是一个 Python 接口，使用它我们可以创建 GUI (图形用户界面)。
这个库是跨平台的，这意味着它是 Python 开发人员的理想选择，因为您的应用程序代码现在可以独立于平台了！
最棒的是它已经预装了 Python 的！所以没必要单独安装这个。
但为了以防万一，我们将检查 Tkinter 是否在我们的系统上正常工作。因此，进入您的 Windows 命令提示符(或者 Linux/Mac 上的 Bash)并键入:
python -m tkinter
一个示例窗口应该如下所示，表明 Tkinter 正在工作:
-
Tkinter 检查
而你要用这个库，就一行！
import tkinter
现在，我们可以开始在 Tkinter 上编写我们的第一个程序了。为此，我将建立一个简单的程序，在屏幕上显示图像。
让我们开始构建应用程序的第一步:创建一个新画布！
创建 Tkinter 画布
步骤 1:创建应用程序和主对象句柄
在创建画布之前，我们需要实例化 Python Tkinter对象。默认的构造函数将实例化一个 Tkinter 对象。
这个对象通常被称为根对象(主对象)。这是因为您的 GUI 应用程序通过该对象使用所有调用。没有这个对象，您的应用程序无法运行。
要创建主对象，请执行以下操作:
import tkinter as tk
# Create our master object to the Application
master = tk.Tk()
我们现在已经创建了主对象。现在，为了运行应用程序，通常，这样的程序被设计成一个事件循环。
现在，我们还需要一个应用程序的句柄，这样应用程序就可以使用这个对象并将其传递给事件循环。
这个班为我们准备了这个。所以我们将创建一个继承这个类的应用程序类。所以现在我们可以直接从我们的应用程序对象调用主循环。
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
我们创建一个名为Application的应用程序类。这个类的构造函数调用基类 ( tk.Frame)构造函数并传递 master 对象，这样就可以初始化重要的东西。
现在，super.__init__(master)将实际修改主对象，所以我们将自己的副本更新为最新的副本，因为其他调用需要它。
应用程序对象app的主程序在名为app.mainloop()的主事件循环下运行。这实际上就是在你的机器上从 Python 到低级语言的所有调用。
要开始主循环，只需调用这个函数！
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
# Start the mainloop
app.mainloop()
现在，如果您运行这个程序，您将得到以下输出。
Sample Tkinter Output
第 2 部分:创建我们的 Tkinter 画布
现在，我们准备创建我们的画布！
我们可以使用tk.Canvas()方法来创建画布。
它的初始化如下:
canvas = tk.Canvas(master_object, bg="blue", width=canvas_width, height=canvas_height)
这一行将创建一个背景为蓝色的画布对象，具有指定的宽度和高度(像素)。
但是在这里，我们仍然不能直接开始循环。我们需要在画布中应用更改，并将对象打包到画布上。这需要canvas.pack()。
现在，我们可以在主循环中显示我们的空画布了！
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
def createCanvas(self, canvas_width, canvas_height):
# Create our canvas (blue background)
canvas = tk.Canvas(self.master, bg="blue", width=canvas_width, height=canvas_height)
return canvas
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
canvas = app.createCanvas(300, 300)
# Pack items into the canvas
canvas.pack()
# Start the mainloop
app.mainloop()
现在让我们运行这个程序:
Canvas Blue
太好了！这似乎像预期的那样工作。现在让我们在画布上做更多的东西。
让我们在应用程序上显示 Debian Linux 的图像。
Debian
我们可以使用tk.PhotoImage类创建一个图像项目。
img = tk.PhotoImage(file="debian.png") # Create our PhotoImage object
image = canvas.create_image(100, 100, anchor=NW, image=img) # Create the image on our canvas
让我们把它放在我们类的一个addImage()方法下。
def addImage(self, canvas, filename, image_x, image_y, direction=tk.NW):
self.img = tk.PhotoImage(file=filename) # Create our PhotoImage object
canvas.create_image(image_x, image_y, anchor=direction, image=self.img) # Create the image on our canvas
return canvas
现在，整个程序看起来像这样:
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
def createCanvas(self, canvas_width, canvas_height):
# Create our canvas (blue background)
canvas = tk.Canvas(self.master, bg="blue", width=canvas_width, height=canvas_height)
return canvas
def addImage(self, canvas, filename, image_x, image_y, direction=tk.NW):
img = tk.PhotoImage(file=filename) # Create our PhotoImage object
canvas.create_image(image_x, image_y, anchor=direction, image=img) # Create the image on our canvas
return canvas
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
canvas = app.createCanvas(300, 300)
canvas = app.addImage(canvas, "debian.png", 50, 50)
# Pack items into the canvas
canvas.pack()
# Start the mainloop
app.mainloop()
但是当你运行这个程序时，你将再次得到蓝色的画布。为什么会这样？
根据堆栈溢出的这个线程，图像对象img被 Python 垃圾收集，没有显示。
为什么？显然tk.PhotoImage对象有这个属性。因此，我们需要在我们的类中增加一个额外的引用，以确保 Python 不会立即丢弃它。因此，我们可以在我们的addImage()方法中用self.img替换img，这样就解决了问题！
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
def createCanvas(self, canvas_width, canvas_height):
# Create our canvas (blue background)
canvas = tk.Canvas(self.master, bg="blue", width=canvas_width, height=canvas_height)
return canvas
def addImage(self, canvas, filename, image_x, image_y, direction=tk.NW):
self.img = tk.PhotoImage(file=filename) # Create our PhotoImage object
canvas.create_image(image_x, image_y, anchor=direction, image=self.img) # Create the image on our canvas
return canvas
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
canvas = app.createCanvas(300, 300)
canvas = app.addImage(canvas, "debian.png", 50, 50)
# Pack items into the canvas
canvas.pack()
# Start the mainloop
app.mainloop()
如果您现在运行这个程序，您将得到正确的输出:
Canvas Image
我们已经解决了这个问题！
现在，您可以继续使用 Tkinter 做各种事情，比如绘制形状和显示类似的图像。文档可以帮助你。
结论
在本文中，我们学习了 Tkinter canvas，以及如何创建 Tkinter Canvas 并在屏幕上显示它。请继续关注本模块的更多教程！
参考
Tkinter 复选框:一个简单的参考
原文：https://www.askpython.com/python-modules/tkinter/tkinter-checkbox-and-checkbutton
可以使用 tkinter checkbutton 小部件创建 tkinter 复选框。它允许用户选择多个选项或从多个不同的选项中进行选择。它们与单选按钮不同，因为在单选按钮中用户只能做一个选择，但是 checkbox 允许多项选择。
它们被视为包含空格的方形盒子。选中复选框时，框内会出现一个勾号。
Tkinter Checkbutton 的基本实现
首先，我们将导入 Tkinter 模块并初始化框架的几何图形。
from tkinter import *
root =Tk()
root.geometry("400x400+120+120")
root.mainloop()
现在我们已经分配了框架，因此我们将使用复选框功能放置一个复选框。如下所示。然后，我们将使用 pack()函数将这个小部件放在 Tkinter 框架中。
c = Checkbutton(root, text = "Python")
c.pack()
c1 = Checkbutton(root, text = "C++")
c1.pack()
c2 = Checkbutton(root, text = "C")
c2.pack()
上面的代码只显示了三个简单的复选框，旁边有文本。它不包含任何功能，因为没有被触发的功能。
要进一步了解这一点，请继续阅读这篇文章。
下面显示的是简单复选框示例的完整代码。一定要尝试一下，并在本页末尾的评论区告诉我们你的意见。
from tkinter import *
root =Tk()
c = Checkbutton(root, text = "Python")
c.pack()
c1 = Checkbutton(root, text = "C++")
c1.pack()
c2 = Checkbutton(root, text = "C")
c2.pack()
root.geometry("400x400+120+120")
root.mainloop()
上述代码的输出如下所示。
Output
将 Tkinter 复选框值存储在变量中
首先，我们将导入tkinter并使用Tk()函数初始化根。我们也决定了框架的大小。
from tkinter import *
root = Tk()
root.geometry("400x400+120+120")
root.mainloop()
我们将在框架上放置一个复选框和按钮，如下所示。我们初始化一个变量i,如果控制台上的复选框未被选中，这个i输出 0，如果复选框被选中，输出 1。
root = Tk()
i = IntVar()
c = Checkbutton(root, text = "Python", variable=i)
c.pack()
b = Button(root,text="Click here",command=click_me)
b.pack()
点击按钮后触发的click_me()函数打印复选框变量中存储的i值。
def click_me():
print(i.get())
整个代码的图解如下所示。输出的截图也上传了。
from tkinter import *
def click_me():
print(i.get())
root =Tk()
i=IntVar()
c = Checkbutton(root, text = "Python", variable=i)
c.pack()
b = Button(root,text="Click here",command=click_me)
b.pack()
root.geometry("400x400+120+120")
root.mainloop()
上述代码的输出如下所示。
Output
结论
关于 Tkinter 复选框的教程到此结束。Tkinter 模块非常庞大，我们想让你更容易理解。因此，请关注 Tkinter 教程页面以了解更多信息！
参考
https://docs.python.org/3/library/tkinter.ttk.html
Tkinter 颜色–完整指南
原文：https://www.askpython.com/python-modules/tkinter/tkinter-colors
Tkinter 是 Python 中的一个内置模块，用于开发图形用户界面(GUI)。它允许我们开发桌面应用程序。Tkinter 非常简单，易于使用。它为我们提供了不同的小部件，如button, canvas, label, menu, message, etc.来构建 Python 中的 GUI。
你也可以探索我们所有的 Tkinter 教程！本教程将向您介绍 Tkinter 中不同颜色选项的使用。
Tkinter 有哪些颜色？
颜色主要用于使图形用户界面更有吸引力。Tkinter 将颜色视为字符串。颜色有两种说法:
- 十六进制值
Ex。#FF0000(红色)、#008000(绿色)、#FFFF00(黄色)等。 - 色名
Ex。金色、银色、蓝色等。
以下是快速参考用的颜色代码列表:
Tkinter Colour List
现在，让我们探索一下 Tkinter 提供的不同颜色选项。
Tkinter 的颜色选项
首先，让我们看看 GUI 的一般结构，我们将使用它来探索所有的颜色选项。
import tkinter as tk
from tkinter import *
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Colors")
#disabling resizing of the window
root.resizable(0, 0)
#---frame for top name---
top = Frame(root, width = 500, height = 70, bd=8, relief="raise")
top.pack(side = TOP)
#--name in the frame--
name = Label(top, text="Colour Option Name", width=30, height=2,
font = ("Lucida Console", 14, "italic"))
name.grid(padx = 18)
#--button--
button = Button(top, text="Click Here", width=20, height=3)
button.grid(padx = 2)
root.mainloop()
输出:
Tkinter Colour GUI Structure
上面是一个基本的图形用户界面，标题是“颜色间”。它由顶部的一个显示颜色选择名称的框架和下面的一个用于演示功能的按钮组成。
一个元素或部件是一个活动元素，如果将光标指向它并按下鼠标按钮，它将执行一些动作。
1.活动背景
我们可以在一个活动元素上使用这个选项来设置小部件活动时的背景颜色。
import tkinter as tk
from tkinter import *
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Colors")
#disabling resizing of the window
root.resizable(0, 0)
#---frame for top name---
top = Frame(root, width = 500, height = 70, bd=8, relief="raise")
top.pack(side = TOP)
#--name in the frame--
name = Label(top, text="Active Background", width=30, height=2,
font = ("Lucida Console", 14, "italic"))
name.grid(padx = 18)
#--button--
button = Button(top, text="Click Here", width=20, height=3,
activebackground='red')
button.grid(padx = 2)
root.mainloop()
输出:
https://www.askpython.com/wp-content/uploads/2022/10/tkinter-active-bg-gif.mp4
上面的视频显示，按钮背景在被点击时变成红色，即处于活动状态。这就是activebackground的工作方式。
2.活动前景
此选项指定小工具激活时的前景色，即激活小工具将使颜色变为代码中指定的颜色。
import tkinter as tk
from tkinter import *
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Colors")
#disabling resizing of the window
root.resizable(0, 0)
#---frame for top name---
top = Frame(root, width = 500, height = 70, bd=8, relief="raise")
top.pack(side = TOP)
#--name in the frame--
name = Label(top, text="Active Foreground", width=30, height=2,
font = ("Lucida Console", 14, "italic"))
name.grid(padx = 18)
#--button--
button = Button(top, text="Click Here", width=20, height=3,
font = ("Lucida Console", 12, "bold"), activeforeground='red')
button.grid(padx = 2)
root.mainloop()
输出: 3。
https://www.askpython.com/wp-content/uploads/2022/10/tkinter-active-fg.mp4
正如在上面的视频中看到的，当我们单击按钮时，文本“单击此处”的颜色会变成代码中提到的红色。
3.背景
此颜色表示小工具的背景颜色。它既可用于活动元素，也可用于非活动元素。背景也可以指定为bg。这里，我们没有使用按钮，而是使用一个标签作为小部件来演示这个选项。
import tkinter as tk
from tkinter import *
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Colors")
#disabling resizing of the window
root.resizable(0, 0)
#---frame for top name---
top = Frame(root, width = 500, height = 70, bd=8, relief="raise")
top.pack(side = TOP)
#--name in the frame--
name = Label(top, text="Background", width=30, height=2,
font = ("Andalus", 14))
name.grid(padx = 18)
#--label--
label = Label(top, text="Label background", width=20, height=3, borderwidth=5, relief="solid",
font = ("Lucida Console", 12, "bold"), background='yellow')
label.grid(padx = 2)
root.mainloop()
输出:
Tkinter Background Colour
这里标签的背景是黄色的。
4.前景
此颜色表示小工具的前景色。它也可用于活动和非活动元素。前景也可以指定为fg。同样，在这里，我们没有使用按钮，而是使用标签作为小部件来演示该选项。
import tkinter as tk
from tkinter import *
#main window
root = tk.Tk()
#title of the window
root.title("Tkinter Colors")
#disabling resizing of the window
root.resizable(0, 0)
#---frame for top name---
top = Frame(root, width = 500, height = 70, bd=8, relief="raise")
top.pack(side = TOP)
#--name in the frame--
name = Label(top, text="Foreground", width=30, height=2,
font = ("Andalus", 14))
name.grid(padx = 18)
#--label--
label = Label(top, text="Label foreground", width=20, height=3, borderwidth=5, relief="solid",
font = ("Lucida Console", 12, "bold"), foreground='blue')
label.grid(padx = 2)
root.mainloop()
输出:
Tkinter Foreground Colour
正如我们所见，标签的前景色在这里是蓝色的。
结论
本教程到此为止。我们已经了解了 Tkinter 的不同颜色选项。
Tkinter 创建 Oval–快速指南
原文：https://www.askpython.com/python-modules/tkinter/tkinter-create-oval
你好，程序员们！在本文中，我们将使用 Tkinter 绘制不同的形状。在之前的博客中， 使用 Tkinter 画线的话题只是这个最先进概念的一个良好开端。读者可以在这个[网址](https://www.askpython.com/python/drawing-a-line-using-tkinter(opens in a new tab))上查看。因此，在这一个前进到新的让我们画一些更多的形状。
也读: Tkinter 教程——用 Tkinter 画布画一条线
基本设置
对于我们的项目文件，建立一个新的目录总是一个好的编程实践。这有助于我们为将来的目的更快地整理东西。
- 创建一个文件夹，即:t inter Shapes。
- 创建一个保存我们的脚本/代码的 Python 文件。搞定了。我们已经准备好编码了。
- 如果任何从业者愿意，他们可以为每个代码创建单独的 Python 脚本
跳过基础知识？跳转到在 Tkinter 中创建椭圆。
创建 Tkinter 画布
Tkinter 中的画布是帮助我们进行绘图和相关工作的基本窗口。这是一个白色的屏幕，充当白板，我们有彩色粉笔，它准备好显示我们的草图。下面是画布设置的代码:
代码:
from tkinter import Tk
from tkinter import Canvas
window = Tk()
window.geometry("400x400")
window.configure(background = "grey")
window.title("Canvas - Draw Shapes")
window.resizable(False, False)
# setting up the canvas
canvas = Canvas(width = 350, height = 350, bg = "white")
canvas.pack(pady = 20)
window.mainloop()
输出:
Canvas Screen
所以，我们有一个中间有画布的 Tlkinter 窗口。
- 分辨率为 350×350 。
- 背景设置为白色。
绘制形状的函数
有在画布上绘制形状的内置函数。这些都是从 Canvas 类本身派生的。该列表如下:
- create _ line()–画一条线。
- create _ arc()–在屏幕上绘制弧线。
- create _ oval()-绘制椭圆、圆、椭圆。
- create _ polygon()–追踪六边形、五边形等。
让我们看看对我们最重要的两个函数 create _ arc()和 create_oval()方法。我们开始吧！
在 Tkinter 中创建弧
代码:
from tkinter import Tk
from tkinter import Canvas
window = Tk()
window.geometry("400x400")
window.configure(background = "grey")
window.title("Canvas - Draw Shapes")
window.resizable(False, False)
# setting up the canvas
canvas = Canvas(width = 350, height = 350, bg = "white")
canvas.pack(pady = 20)
# create a text that renders the name of our shape
canvas.create_text(175, 30, text = "Arc", font = ("Arial", 30))
#create an arc
canvas.create_arc(0, 340, 200, 100, width = 5)
window.mainloop()
输出:
Drawing an arc
说明:
- 前七行代码是窗口和画布的基本设置。
- 从八线开始，我们画一条弧线。调用 create_arc() 函数。要将其放置在轴平面上，给出坐标 (x1，y1，x2，y2)。记得按顺序给他们。最后一个参数是宽度。这是形状的厚度。
- 我们也可以使用填充参数给弧线添加颜色。只需在 create_arc() 内部调用，然后以字符串格式 : "color_name" 赋予颜色名称。
- 为了增加更多的细节，我们使用函数 create_text() 渲染一个文本。我们把它放在画布的顶部，字体为 Arial ，大小为 30 。
绘制彩色圆弧的代码:
from tkinter import Tk
from tkinter import Canvas
window = Tk()
window.geometry("400x400")
window.configure(background = "grey")
window.title("Canvas - Draw Shapes")
window.resizable(False, False)
# setting up the canvas
canvas = Canvas(width = 350, height = 350, bg = "white")
canvas.pack(pady = 20)
canvas.create_text(175, 30, text = "Arc", font = ("Arial", 30))
canvas.create_arc(0, 340, 200, 100, width = 5, fill = "orange")
window.mainloop()
输出:
A colorful arc
所以，代码和前面的一样。我们只是在 create_arc()函数中添加了 fill 参数，我们得到了一个漂亮的结果。
在 Tkinter 中创建圆形和椭圆形
准备好使用 Tkinter 创建椭圆了吗？让我们直接开始吧。
椭圆形代码:
from tkinter import Tk
from tkinter import Canvas
window = Tk()
window.geometry("400x400")
window.configure(background = "grey")
window.title("Canvas - Draw Shapes")
window.resizable(False, False)
# setting up the canvas
canvas = Canvas(width = 350, height = 350, bg = "white")
canvas.pack(pady = 20)
canvas.create_text(175, 20, text = "Circle", font = ("Arial", 30))
canvas.create_oval(175, 100, 100, 175, width = 3)
window.mainloop()
输出:
The green Oval
说明:
- 前七行是 Tkinter 和 canvas 的基本设置。
- 在 Canvas 对象中，我们调用 create_oval() 函数。这负责跟踪椭圆和圆。
- 给出坐标，然后我们就有结果了。
create_oval()方法也可以帮助你创建圆。只需确保 x1 和 y2 相同，x2 和 y1 也相同。
圆的代码:
from tkinter import Tk
from tkinter import Canvas
window = Tk()
window.geometry("400x400")
window.configure(background = "grey")
window.title("Canvas - Draw Shapes")
window.resizable(False, False)
# setting up the canvas
canvas = Canvas(width = 350, height = 350, bg = "white")
canvas.pack(pady = 20)
canvas.create_text(175, 20, text = "Circle", font = ("Arial", 30))
canvas.create_oval(175, 100, 100, 175, width = 3)
window.mainloop()
输出:
A circle
结论
所以，这样一来，我们就可以使用 Tkinter 的 Canvas 和内置的 shape 函数来绘制不同的形状。对于 GUI 编程和开发来说，这个库非常适合初学者。我建议读者试验一下代码，试着定制这些形状。我希望这将是一篇有趣的文章阅读。
Tkinter 入口小部件
原文：https://www.askpython.com/python-modules/tkinter/tkinter-entry-widget
又见面了！这是我们 Tkinter 教程系列的另一篇文章，今天我们将讨论 Tkinter 入口小部件。
上次，我们经历了一个t inter 画布窗口的概念。这一次，我们将做一些不同的事情。
今天的帖子在 Tkinter Entry 小工具上。任何小部件都是主应用程序的一部分。如果您想从用户那里获得输入，入口小部件非常有用。
我们可以在我们的主应用程序中创建一个入口小部件，还可以为我们的应用程序添加输入文本框，以便用户可以在上面键入一些内容。
我们开始吧！
Tkinter 入口小部件
这个小部件允许我们输入单行文本。
如果我们输入的字符串超过了小部件的长度，我们必须向下滚动到下一部分。
如果您想获得小字段(如姓名和电话号码)的用户输入，这很有用。
现在让我们看看如何在我们的应用程序中使用它。
入口小部件的语法
要声明入口小部件，我们可以使用以下类型的语法:
entry_object = tk.Entry(master, option, ... )
这为我们的父窗口引入了master对象句柄。这将指示我们可以放置入口对象的位置。
我们可以使用option参数提供某些选项，比如您希望将它放在哪一行和哪一列。
步骤 1:为我们的应用程序创建标签
但是在此之前，让我们为我们的应用程序创建一个Label小部件。我们可以用它来命名一个文本块。
注意:我们不能在标签等其他部件旁边使用画布，因为我们正在使用canvas.pack()。这些完全是为了不同的目的。
虽然我们不能使用Canvas，但是让我们为我们的应用程序复制一个类似的模板。
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
# Start the mainloop
app.mainloop()
要创建Label小部件，请使用以下语法:
tk.Label(master, text).grid(row)
这将使用text字符串将其插入到 man 应用程序网格的row号中！
现在让我们为我们的班级写它。我们将编写一个名为createGridLabel的函数来完成这项工作。
def createGridLabel(self, text, row_number):
# Create a label with the text, on the row number
tk.Label(self.master, text=text).grid(row=row_number)
现在，让我们看看整个程序。
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
def createGridLabel(self, text, row_number):
# Create a label with the text, on the row number
tk.Label(self.master, text=text).grid(row=row_number)
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
# Create a label with the following text, on row #0
app.createGridLabel("Name", 0)
app.createGridLabel("Phone Number", 1)
# Start the mainloop
app.mainloop()
输出
Label Widget
虽然图像很小，但是标签确实在屏幕上！现在让我们来看看这些标签的实际Entry部件。
我们可以使用tk.Entry(master)创建我们的入口对象
# Create the entry objects
e1 = tk.Entry(master)
e2 = tk.Entry(master)
现在，让我们将条目放在适当的位置。第一个条目属于行 0 和列 1(因为列 0 有我们的标签Name，而第二个条目小部件位于(1，1)。
# Place it in it's suitable position
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
现在让我们看看完整的代码。
import tkinter as tk
class Application(tk.Frame):
def __init__(self, master=None):
# We need the master object to
# initialize important stuff
super().__init__(master) # Call tk.Frame.__init__(master)
self.master = master # Update the master object after tk.Frame() makes necessary changes to it
def createGridLabel(self, text, row_number):
# Create a label with the text, on the row number
tk.Label(self.master, text=text).grid(row=row_number)
# Create our master object to the Application
master = tk.Tk()
# Create our application object
app = Application(master=master)
# Create a label with the following text, on row #0
app.createGridLabel("Name", 0)
app.createGridLabel("Phone Number", 1)
# Create the entry objects
e1 = tk.Entry(master)
e2 = tk.Entry(master)
# Place it in it's suitable position
e1.grid(row=0, column=1)
e2.grid(row=1, column=1)
# Start the mainloop
app.mainloop()
输出
Entry Widget
如你所见，它不仅显示了一个文本框，而且我还可以在上面打字！
如果您想为这些字段放置一些默认的占位符值呢？这非常简单，每个条目只需要一行代码！
我们可以使用entry.insert(0, text)，其中text是文本框所需的值。
现在让我们把这两个字段上的AskPython和12345678作为默认值。
e1.insert(0, "AskPython")
e2.insert(0, "12345678") # Must be a string, not an integer
输出
Entry Default
希望这对你也有用。我们已经成功地将默认值添加到我们的应用程序中！
结论
在本教程中，我们学习了如何使用 Tkinter 来使用入口小部件。
敬请关注 Tkinter 上的更多教程！
Python Tkinter 教程:了解 Tkinter 字体类
原文：https://www.askpython.com/python-modules/tkinter/tkinter-font-class
在本文中，我们将学习更多关于 Tkinter 字体类的知识。当涉及到设计一个功能齐全且适应各种环境的图形用户界面时，Tkinter 是最好的选择。它是一个内置的图形库，带有 Python 编程语言。所以，让我们看看这个特殊库的一些特性，让我们的 GUI 开发更上一层楼。
推荐阅读: Tkinter 教程第一部分——制作 Tkinter 画布
Tkinter 简介
Python 在互联网上发布了许多 GUI 开发库。大部分都是开源的，好用。但是当它们与一个GUI入门指南不太相关时。从这个意义上说，初学者需要投入更多的时间和资源来学习，并根据自己的知识来实现。这是其中一些库的列表:
- PyQT5
- Kivy
- wxppython等。
但是 Tkinter 处在一个非常不同的框架中。之所以内置，是因为基本的 Python 解释器 和IDLE——一个轻量级的 python IDE 都是用这个包设计的。除此之外，从基础学到进阶比其他库都非常容易。这里列出了主要部件和t 中间的等级。
- Root/Window: 是这个库的主要小部件。一个可调整大小的窗口，包含其他子部件。
- 标签:一个标签，可以处理维护每个 widget 标签的任务。它定义了它们的属性。
- 按钮:根据用户命令运行的简单按钮。
- 字体:一个特殊的类，帮助创建者设置任何子部件的字体。
- Mainloop: 这是一个主循环，它连续无限次运行 GUI，直到用户不退出。
一个带有 Tkinter 的 Hello World 小代码
在这一节中，我们将编写一段代码来创建一个 Hello World 的窗口。
代码:
from tkinter import *
root = Tk()
root.title("Hello World")
root.geometry("400x400")
输出:
Tkinter Window
这是一个我们只用几行代码创建的窗口。让我们理解每一行。
- 导入模块。
- 然后使用根变量创建一个 Tk() 类的实例。我们可以给 Tk()类的对象取任何名字。
- 使用 title() 函数设置窗口的标题。这将文本呈现在窗口的左上角。
- 然后 geometry() 函数帮助设置我们窗口的宽度和高度。
了解在 Tkinter 中打印文本的基础知识
从基础开始的原因是我们需要理解 Tkinter 中的字体并不局限于一个特定的类，它们也反映在其他一些主要的部件中。
也读作: Tkinter 框架和标签:简易参考
既然我们已经进入心流，让我们了解更多关于它的事情。最重要的是，我们设计的 GUI 应该看起来有吸引力和信息量。因此，为了做到这一点，我们使用了 Tkinter 的 Label() 小部件。它的作用是在屏幕上呈现一些文本，给出一些我们想要的信息。的语法对它来说非常简单:
label_1 = Label(active_window, foreground_color, background_color, font, height, width)
标签小部件有更多的参数，但是这些参数对于研究来说都是非常完美的。这是相同的代码。
from tkinter import *
root = Tk()
root.title("Hello World")
root.geometry("400x400")
my_label = Label(root, text = "Hello World", fg = "Green", bg = "red", font = ("Arial", 32)) # setting up the labels
my_label.pack()
root.mainloop()
输出:
Label Window Output
需要注意的要点是，字体在这里作为参数使用。我们可以给出一个由字体类型和大小组成的元组，或者直接给出名称。该参数有多种名称。下面是一些的列表。
- 天线
- 英国泰晤士报(1785 年创刊)
- 时代新罗马
- 大胆的
- 斜体的
- 粗斜体
pack()方法用于在屏幕上显示我们创建的标签。
使用 Tkinter 字体类
字体是一些很棒的自然创造的写作风格。世界各地的人们有不同的手写风格，那些知道如何将相同的字体转换成数字格式的人开发了我们使用和喜爱的字体。
使用 tkinter 字体类，您可以将打印在 Tkinter 窗口上的文本转换为粗体、斜体、罗马体，甚至可以更改字体系列。
现在我们已经操作了一些字体功能，让我们来看看从 tkinter.font 模块派生的主 font 类。该模块提供四种主要类型:
- tkinter.font.NORMAL
- tkinter.font.BOLD
- tkinter.font.ITALIC
- tkinter.font.ROMAN
要了解更多关于这个理论的信息，请阅读链接中的官方文档。
我们将直接看到代码形式的应用程序。
from tkinter import *
from tkinter.font import Font
root = Tk()
root.title("My Interface")
root.geometry('400x400')
my_font = Font(
family = 'Times',
size = 30,
weight = 'bold',
slant = 'roman',
underline = 1,
overstrike = 0
)
my_button = Button(root, text = 'Button', font = my_font)
my_button.pack(pady = 20)
root.mainloop()
Tkinter Font Output
上述代码的解释:
- 首先，我们导入所有子模块 tkinter 模块。然后从 tkinter.font 模块导入字体类。这是主要的实用程序类。
- 然后创建一个实例，即根。将标题设置为“我的界面”
- 将几何图形设置为 500×500(宽 x 高)。
- 然后创建 my_font 作为 Font 类的实例。它有一组扩展的参数:族:- 用于选择字体类型，大小:- 字体大小，粗细:- 字体粗细加粗/正常，倾斜:- 斜体罗马/斜体，下划线:- 在文本下画下划线，粗划:- 画一条删除线。
- 在那之后，一个按钮部件，只得到一个点击，什么也没有。在那里我们设置参数为默认窗口为 root，文本标签为“Button”，font = my_font。这将调用 font 类的已创建的 my_font 对象。
- 主循环运行整个代码并跟踪每一个 GUI 事件。当用户按下关闭按钮时退出。
结论
这样，我们就结束了了解 tkinter 的字体类的话题。这是一个非常容易理解和实现的主题。希望这将使 GUI 知识得到更多的提高。
Tkinter 框架和标签:简易参考
原文：https://www.askpython.com/python-modules/tkinter/tkinter-frame-and-label
在本文中，我们将讨论 Tkinter 框架和标签小部件。
让我们来谈谈 Tkinter 框架和标签小部件
我们将逐一查看这两个小部件,以了解基本原理
什么是 Tkinter 帧？
tkinter 中的框架是一个小部件，在屏幕上显示为一个矩形区域。这个小部件作为放置其他小部件的基础，例如标签、复选按钮、单选按钮等。Tkinter frame 窗口小部件基本上用于对屏幕上的其他窗口小部件进行分组。
框架不仅用于窗口小部件，还可以用于放置视频覆盖和其他外部过程。框架小部件有各种属性，如背景颜色、高度和宽度。
对 Tkinter 帧进行编码
下面是一个框架的例子。
from tkinter import *
root=Tk()
frame = Frame(width=100, height=100, bg="red", colormap="new")
frame.pack(side=LEFT)
# set size of window
root.geometry('500x500')
# set an infinite loop so window stays in view
root.mainloop()
Output For Frame Example
输出左侧的小红框是我们创建的 tkinter 帧。让我们继续创建一个标签小部件。
什么是 Tkinter 标签？
Tkinter 提供了标签小部件，可以将任何文本或图像插入到框架中。Tkinter 允许在框架上显示几行文本，但是用户只能选择一种字体。
标签类似于典型的文本框，可以是任意大小。如果用户定义了大小，那么内容会在该大小内调整，如果没有，它会根据内容的长度自行调整。
标签有foreground和background字段来指定您选择的颜色。相同的语法如下所示。
w = Label(root, text="Hey there", fg="red")
对于背景颜色，确保使用bg作为属性。
标签可用于显示照片图像和位图图像。下面也显示了它的语法。
photo = PhotoImage(file="welcome.jpg")
w = Label(root, image=photo)
w.photo = photo
给标签编码
from tkinter import *
root=Tk()
label1 = Label(root, text="hi, welcome to GUI using Tkinter")
label1.pack()
root.geometry('500x400')
root.mainloop()
上述代码的输出如下所示。
Output For Label Example
实现 Tkinter 框架和标签小部件
from tkinter import *
root=Tk()
root.title("My first GUI")
# set resizing to false
root.resizable(width=FALSE, height=FALSE)
# set size of window
root.geometry('500x400')
leftFrame = Frame(root)
leftFrame.pack(side=LEFT)
rightFrame = Frame(root)
rightFrame.pack(side=RIGHT)
label1 = Label(leftFrame, text="Left column")
label1.pack()
label3 = Label(leftFrame, text="Column content")
label3.pack()
label2 = Label(rightFrame, text="Right column")
label2.pack()
# set an infinite loop so window stays in view
root.mainloop()
上述代码的输出如下所示。
Output For Hybrid Example
结论
关于使用 Tkinter 创建框架和标签的教程到此结束。试试这段代码，并在下面的评论区告诉我们你的反馈。
Tkinter GUI 部件–完整参考
欢迎来到这个关于 tkinter GUI 部件的教程。在本文中，我将简要地向您介绍所有 Tkinter 小部件，并提供一些简单的代码片段来创建这些小部件。在本文快结束时，您将能够使用所有代码并使用 GUI 部件构建一个迷你服务。
创建主 Tkinter 窗口
这一步对于任何 Tkinter GUI 小部件都是必要的，不管它的特性如何。
from tkinter import *
root = Tk()
#optional
root.configure(background='yellow')
root.geometry('600x800)
#place any of your code lines here
#end of code
root.mainloop()
上面显示的代码片段是一个基本结构，在面板上放置任何小部件之前，必须使用它来定义 tkinter GUI 框。
在代码片段中，tkinter库已经被导入，并且使用root对象实例化了Tk()构造函数。在代码的末尾，我使用root.mainloop()调用了整个程序。
root.configure()用于向您的主机添加额外的属性。在这个例子中，我用它来添加属性background和root.geometry()来确保主框架是指定的期望尺寸。然而，这些是可选使用的。
放置 Tkinter GUI 小部件
现在我们已经初始化了 Tkinter 的主机，我们将看看不同的小部件。
我将介绍最常用的小部件，包括标签、按钮、复选按钮、条目、滑块(在 Tkinter 中称为标尺)、列表框和单选按钮。
将下面给出的代码片段添加到主窗口的代码中。
1.Tkinter 标签小部件
对于这里的标签小部件，我们将使用Label构造函数本身来定义它。标签将放在根主窗口中，文本将显示“嘿，欢迎使用我的 GUI”。
然后我们把标签放在窗口里面，我们和 pady 进行了讨论，在 y 轴上给了我们更多的空间。
label=Label(root,text="Hey, welcome to this my GUI")
label.pack(pady=10)
2.Tkinter 按钮小工具
按钮将被放置在同一个主窗口上，并使用 button()构造函数创建。按钮的文本将显示“按下按钮”。请注意，文本颜色是绿色的。为此，我们将绿色指定为前景。
当按钮被按下时，我们想要激活一个功能，我们将把该功能分配给命令参数。函数的名字是button_trigger()。当按钮被按下时，它将激活此功能，并打印一条消息说“按钮被按下”。
我们已经将按钮打包到主根窗口中。因此，当我们按下这个按钮时，它将激活这个功能，并在控制台中打印消息。
def button_trigerr():
print("Button Pressed")
button = Button(root,text="press button", foreground="green", command=button_trigger)
button.pack(pady=10)
3.Tkinter 检查按钮小工具
在下一个例子中，我们有检查按钮。
当我们选中这个框或按钮时，它会将背景变成白色，就像打开灯一样。如果我们取消选中它，它会像关灯一样把背景变成黑色。让我们试一试。
def check_button_action():
print(check_button_var.get())
if check_button_var.get()==1:
root.configure(background='white')
else:
root.configure(background='black')
check_button_var = IntVar()
check_button = tk.Checkbutton(root, text="on/off", variable=check_button_var, command= button_action)
check_button.pack(pady=10)
所以首先，使用Checkbutton()创建检查按钮。它将在根主窗口上运行。文字为“开/关”。
我们已经将一个变量与这个复选按钮相关联，它是一个整数。将由复选按钮激活的功能，名为 button_action。
复选按钮有两个默认状态，即 0 和 1，这些默认状态将被分配给此处的变量。这个变量将跟踪复选按钮的状态，并获取复选按钮的状态。
我们只是继续引用variable.get()。如果复选按钮的状态为 1，这相当于复选框被选中，我们将使窗口的背景为白色。
如果它是 0，我们将把根窗口的背景设为黑色，这给了我们开灯或关灯的效果。然后，我们将它打包到 pady 为 10 的“主”框架中。
4.Tkinter 入口小部件
条目小部件允许我们输入文本，并将文本从文本框或条目传输到控制台，并在控制台上显示消息。
为了创建入口小部件，我们已经创建了一个框架。为了创建框架，我们使用 frame()。
框架将放在主根窗口中，边框宽度为 5，具有凹陷效果。我们引用框架包，这将把框架打包到主窗口中。
entry_frame = Frame(root, borderwidth=5, relief = SUNKEN)
entry_frame.pack()
text_box=Entry(entry_frame)
text_box.pack()
def get_entry_text():
print(text_box.get())
label.configure(text=text_box.get())
button = Button(entry_frame, text='get entry', command=get_entry_text)
button.pack(pady=10)
然后，我们创建了我们的条目文本框，条目将进入框架。我们把条目装进了相框。所以框架将进入主窗口，条目将进入框架。
然后，我们继续创建一个按钮，将文本从条目传输到控制台。现在请注意，我们的条目消息被打印到控制台，并且还更新了我们在大型机中的标签。要获取文本，我们只需使用 get()方法。
5.Tkinter 缩放微件
接下来，让我们来看看这里的滑块或缩放小部件。对于这个小部件，假设您有一张餐馆账单，金额为 100 美元，您想看看不同的小费金额会如何影响总账单。
我们可以用滑块来显示小费，用输入框来显示账单，然后标签会显示账单总额。标签会给我们显示总账单。
slider_frame = Frame(root, borderwidth=5, relief=SUNKEN)
slider_frame.pack(pady=10)
def calculate_total_bill(value):
print(value)
if bill_amount_entry.get()!=' ':
tip_percent=float(value)
bill=float(bill_amount_entry.get())
tip_amount=tip_percent*bill
text=f'(bill+tip_amount)'
bill_with_tip.configure(text=text)
slider = Scale(slider_frame, from_=0.00, to=1.0,orient=HORIZONTAL, length=400, tickinterval=0.1, resolution=0.01, command=calculate_total_bill)
slider.pack()
好的，为了创建比例，我们使用 scale()，然后在这里我们为条目文本框输入所有的参数或自变量。我们在上面创建了它。
我们已经将滑块、条目文本框和标签打包到主窗口的框架中。我们像上一个例子一样创建了框架。
对于滑块所做的更改，calculate_total_bill()将被激活。该功能基本上是从输入框中提取账单金额的文本。然后，它将从滑动标尺中获取小费百分比，将小费计入账单，然后给我们显示在标签上的总账单。
6. Tkinter ListBox Widget
接下来我们来看一下列表框小部件。这里我们有一个包含五个项目的列表框。在本例中，我们将只选择其中一项。然后，我们将按下按钮，我们希望将文本从项目转移到标签。
listbox_frame=Frame(root,borderwidth=5, relief=SUNKEN)
listbox_frame.pack(pady=10)
listbox=Listbox(listbox_frame)
listbox.pack()
listbox.insert(END,"one")
for item in ["two","three","four","five"]:
listbox.insert(END, item)
def list_item_selected():
selection=listbox.curselection()
if selection:
print(listbox.get(selection[0]))
list_box_label.configure(text=listbox.get(selection[0]))
list_box_button = Button(listbox_frame,text='list item button', command=list_item_selected)
list_box_button.pack()
为了创建列表框，我们使用了Listbox()。我们将把列表框放在一个框架内。创建列表框后，我们可以继续将项目插入列表框。
如果你想插入几个条目，你可以用 for 循环来完成。这里我们创建了一个按钮，当我们按下按钮时。它将激活创建的list_item_selected()。
为了访问选择，我们引用listbox.curselection()。为了确保我们确实选择了一些东西，我们使用if selection:，如果我们选择了一个项目，我们引用列表框项目，然后我们得到实际的项目。
我们在方括号中使用零的原因是，项目通常是一个数字元组，这将只给我们数字。然后，我们想继续用我们选择的项目更新我们的标签。
7.Tkinter 单选按钮小部件
对于最后一个例子，我们来看一下单选按钮。现在，根据选择的单选按钮，我们将在这里显示一个图像。所以这里我们有山，划船和露营。
我已经创建了三个单选按钮。所有的单选按钮都将被放置在主根窗口中。对于这篇课文，我们已经指定了“山、划船和野营”。
所有单选按钮都将有一个与一个变量相关联的值，我们已经创建了该变量。
Label(root, text="choose icon")
def radio_button_func():
print(rb_icon_var.get())
if(rb_icon_var.get())==1:
radio_button_icon.configure(text='\u26F0')
elif rb_icon_var_get()==2:
radio_button_icon.configure(text='\u26F5')
elif rb_icon_var_get()==3:
radio_button_icon.configure(text='\u26FA')
rb_icon_var=IntVar()
Radiobutton(root,text="mountains",variable=rb_icon_var, value=1, command=radio_button_func).pack()
Radiobutton(root,text="boating",variable=rb_icon_var, value=2, command=radio_button_func).pack()
Radiobutton(root,text="camping",variable=rb_icon_var, value=3, command=radio_button_func).pack()
radio_button_icon = Label(root, text=' ', font=("Helvetica",150))
radio_button_icon.pack()
在这种情况下，因为您一次只能单击一个单选按钮，所以与任一单选按钮相关联的值(我们在这里指定为 1、2 或 3)将被指定给变量。
当单击一个单选按钮时，它将激活或调用“radio_button_func()”。
因此，如果为 mountains 单击第一个单选按钮，值 1 将被赋给该变量，然后我们将获取该值并测试它是否等于 1。
如果它等于 1，我们将对山脉使用 Unicode 文本表示。
结论
快速总结一下，我们已经了解了一些常用的小部件，它们的用法如下:
- 标签–显示文本或信息
- 按钮–用于工具栏、应用程序窗口、弹出窗口和对话框
- 检查按钮–用于执行开关选择。
- 输入部件–用于输入或显示单行文本
- Scale widget–当您希望用户输入一个有界的数值时，用来代替 Entry widget。
- 列表框–用于显示备选项列表。
- 单选按钮–用于向用户提供多种可能的选择，但用户只能选择其中之一。
一定要试试这些不同的部件，并在下面的评论区让我们知道你最喜欢的部件！！
Tkinter int var–带示例的 Tkinter 教程
原文:# t0]https://www . aspython . com/python-modules/tkinter-intvar/
大家好！在本教程中，我们将学习 Tkinter IntVar 函数，以及如何使用它在 Python 中存储、检索和管理整数变量。所以我们先从 IntVar()函数开始。
Tkinter IntVar()函数
Tkinter 包含内置的编程类型，其工作方式类似于普通的 python 类型，具有用于更有效地操纵像Label和Entry这样的小部件的值的附加特性，这使得它们不同于 python 数据类型。这些变量还包含 getter 和 setter 方法来访问和更改它们的值。IntVar就是其中的一个例子。
使用IntVar()函数定义的变量保存整数数据，我们可以设置整数数据，也可以使用 getter 和 setter 方法检索它。这些变量可以传递给各种小部件参数，例如，单选按钮和复选框按钮的变量参数，标签小部件的 textvariable 参数等，我们将在示例中看到。一旦这些变量连接到小部件，连接就双向进行:如果 IntVar()变量发生变化，小部件的值也会自动更新为新值。
定义 Tkinter IntVar()变量
我们需要 Tkinter IntVar()函数，它采用以下参数来定义变量:
- 主:与
IntVar()变量关联的窗口。如果没有指定，默认为根窗口。 - value :赋予 integervariable 的初始值。默认值为 0。
- 名称:已定义变量的名称。默认值为 PY_VARnum(如 PY_VAR1、PY_VAR2 等)。
import tkinter as tk
master_window = tk.Tk()
master_window.geometry("250x150")
master_window.title("IntVar Example")
integer_variable = tk.IntVar(master_window, 255)
label = tk.Label(master_window, textvariable=integer_variable, height=250)
label.pack()
master_window.mainloop()
Defining IntVar
更改 IntVar()变量的值
由于IntVar()是 Tkinter 构建的编程类型，它包含 setter 方法来改变它们的变量值。我们可以使用set()方法来改变整数数据的值。
import tkinter as tk
master_window = tk.Tk()
master_window.geometry("250x150")
master_window.title("IntVar Example")
integer_variable = tk.IntVar(master=master_window, value=1)
label = tk.Label(master_window, textvariable=integer_variable, height=250)
label.pack()
integer_variable.set(100)
master_window.mainloop()
检索 IntVar()变量的值
我们可以对IntVar()变量使用get()方法来检索变量中的文本值。
import tkinter as tk
master_window = tk.Tk()
int_var = tk.IntVar(master = master_window, value = 255)
num = int_var.get()
print(type(num))
print(num)
输出:
<class 'int'>
255
Tkinter IntVar()示例
让我们考虑一些 IntVar()不同用法的例子。
当 IntVar()变量数据改变时通知
每当IntVar()变量的值改变时，我们可以得到通知并执行一些任务。这是 Tkinter 定义的对象的一个有趣的特性，每当它的值为 read、updated 或 deleted 时都会得到通知。如果您想在对IntVar()变量进行某些操作时自动更新其他小部件，这个特性也很有帮助。
要在IntVar()对象上定义回调，我们可以在IntVar()对象上使用trace()方法，该方法有两个参数:
- 模式:对
IntVar()对象的操作类型。'write':值改变时调用回调'read':读取值时调用回调'unset':删除值时调用回调
- 回调:当对象上有操作时调用的方法。
让我们考虑一个简单的 2 个数和的例子，其中我们有 2 个输入部件来输入数字和一个显示 2 个数和的标签。每当 入口小部件 和IntVar()变量改变时，总和将自动更新。
import tkinter as tk
class SumOfTwoNumbers(tk.Tk):
def __init__(self):
super().__init__()
self.title("Sum of 2 Numbers")
self.geometry("300x300")
# define IntVar() variables A and B
self.A = tk.IntVar()
self.B = tk.IntVar()
# assign methods to notify on IntVar() variables
self.A.trace_add("write", self.calculate_sum)
self.B.trace_add("write", self.calculate_sum)
self.create_widgets()
def create_widgets(self):
self.A_label = tk.Label(self, text="A: ")
self.B_label = tk.Label(self, text="B: ")
self.A_entry = tk.Entry(self, textvariable=self.A)
self.B_entry = tk.Entry(self, textvariable=self.B)
self.sum_label = tk.Label(self, text="Sum: ")
self.result_label = tk.Label(self, text=self.A.get() + self.B.get())
self.A_label.grid(row=0, column=0, padx=5, pady=5)
self.A_entry.grid(row=0, column=1, padx=5, pady=5)
self.B_label.grid(row=1, column=0, padx=5, pady=5)
self.B_entry.grid(row=1, column=1, padx=5, pady=5)
self.sum_label.grid(row=2, column=0, padx=5, pady=5)
self.result_label.grid(row=2, column=1, padx=5, pady=5)
def calculate_sum(self, *args):
try:
num_a = self.A.get()
except:
num_a = 0
try:
num_b = self.B.get()
except:
num_b = 0
self.result_label['text'] = num_a + num_b
if __name__ == "__main__":
app = SumOfTwoNumbers()
app.mainloop()
其输出:
监视单选按钮和复选框小部件中的选定值
IntVar()变量的另一个常见应用是跟踪 RadioButton 和 CheckBox 小部件中选择的值，如下例所示:
import tkinter as tk
class RadioButtonExample(tk.Tk):
def __init__(self):
super().__init__()
self.title("Radio Button Example")
self.geometry("300x300")
# define IntVar() for selected value
self.selected_value = tk.IntVar()
self.create_widgets()
def create_widgets(self):
self.intro_label = tk.Label(
self,
text="Choose your favourite language").pack()
self.rb1 = tk.Radiobutton(
self,
text="Python",
padx=5,
pady=5,
variable=self.selected_value,
value=1).pack()
self.rb2 = tk.Radiobutton(
self,
text="Java",
padx=5,
pady=5,
variable=self.selected_value,
value=2).pack()
self.rb3 = tk.Radiobutton(
self,
text="C++",
padx=5,
pady=5,
variable=self.selected_value,
value=3).pack()
self.rb4 = tk.Radiobutton(
self,
text="Dart",
padx=5,
pady=5,
variable=self.selected_value,
value=4).pack()
self.text_label = tk.Label(
self,
text="Option selected is:",
pady=15
).pack()
self.value_label = tk.Label(
self,
textvariable=self.selected_value,
padx=5,
pady=5).pack()
if __name__ == "__main__":
app = RadioButtonExample()
app.mainloop()
其输出:
结论:
在本教程中，我们学习了 Tkinter IntVar()以及我们可以使用它的各种场景，它可以使我们的生活更轻松，但定义回调可以帮助我们自动更新其他小部件。
感谢阅读！！
Tkinter 列表框和选项菜单–如何使用列表框和选项菜单部件？
原文:# t0]https://www . aspython . com/python-modules/tkinter/tkinter-listbox-option-menu
嘿，伙计们，欢迎阅读这篇关于 Tkinter 列表框和使用 Tkinter 的选项菜单的文章。我将带你看一些同样的例子。
什么是列表框？
Tkinter 中的 Listbox 小部件广泛用于向用户显示一组项目。用户可以从这些项目中进行选择。
我们有基本的启动代码，我们总是得到，一个 400 x 400，我们有一个图标标题在那里。
from tkinter import *
root=Tk()
root.title("Listbox demo")
root.geometry("400x480")
root.mainloop()
所以要创建一个列表框，你只需要像往常一样定义它，列表框就是一种带有 tkinter 的小部件。
创建您的第一个 Tkinter listbox 小部件
让我们创建一个列表框，我们称它为my_listbox，设置它等于一个Listbox()，并把它放入root。
我们将在屏幕上打包它，让我们给它一个pack()并给它一个“pady”15。
#Listbox
my_listbox=Listbox(root)
my_listbox.pack(pady=15)
向列表框中单独添加项目
现在，为了把东西放进去，你可以用几种不同的方法。你可以手动完成，或者你可以创建一个列表，循环遍历列表，一次一个地把这些东西放进去。
我们将使用my_listbox.insert方法。这个方法有两个参数。有一个索引和一个字符串。
所以索引是索引号，我们列表框中的项目，我们想把它放进去的位置，第一个是' 0 '。
# Add item to listbox
my_listbox.insert(END, "First")
my_listbox.insert(END, "Second")
使用循环向 tkinter 列表框添加多个项目
让我们添加一个项目列表。所以我将只是create my_list，它将只是一个 python 列表，我们可以在这里放入任何我们想要的东西。所以我只要插入“一”、“二”和“三”就可以了。现在我们只需循环列表，将每一项放入其中。
my_list = ["One", "Two", "Three"]
for item in my_list:
my_listbox.insert(END, item)
添加 Tkinter 按钮删除列表框项目
现在我们知道了如何添加列表框条目，让我们创建一个t inter 按钮来删除条目。
如果我们单击其中的一个项目，它们就会突出显示，所以让我们创建一个按钮。我们将它命名为 my_button，它将位于 root 中，并用 pady 10 打包my_button。
my_button = Button(root, text="Delete", command=delete)
my_button.pack(pady=10)
现在，我们需要创建一个delete函数。当你点击列表框中的某样东西时，它会变成锚点。所以，我们要删除锚点。
def delete():
my_listbox.delete(ANCHOR)
my_label.config(text=" ")
Tkinter Listbox 小部件实现的完整代码
from tkinter import *
root=Tk()
root.title("Listbox demo")
root.geometry("400x480")
#Listbox
my_listbox=Listbox(root)
my_listbox.pack(pady=15)
# Add item to listbox
my_listbox.insert(END, "First")
my_listbox.insert(END, "Second")
my_list = ["One", "Two", "Three"]
for item in my_list:
my_listbox.insert(END, item)
def delete():
my_listbox.delete(ANCHOR)
my_label.config(text=" ")
my_button = Button(root, text="Delete", command=delete)
my_button.pack(pady=10)
global my_label
my_label=Label(root, text=" ")
my_label.pack(pady=5)
root.mainloop()
上述代码的输出如下所示:
List Item
什么是选项菜单？
OptionMenu 类是一个助手类，它创建一个弹出菜单和一个按钮来显示它。这个小部件生成一个包含许多选项值的下拉列表。
让我们创建一个简单的选项菜单结构。
创建您的第一个 Tkinter 选项菜单
基于下拉菜单创建选项菜单。第一步是列出基本的安全问题。将它们传递到选项菜单中，并为答案创建一个条目。
首先，我们将创建问题列表。
Question = [“What is your mother’s maiden name?”,
“ Who is your favorite author?”,
“ What was your first pets name? “,
“What street did you grow up on? “
]
现在我们必须通过一个变量 tkvarq 来传递这些。为了理解 tk 变量的创建，第一个通过 barrier 的替代变量是 root，并使用 set()为该变量设置问题。
这是一个字符串变量 StringVar，我们将问题传递给它，如下所示:
tkvarq = StringVar(root)
tkvarq.set(questions[0])
创建 Tkinter OptionMenu 对象
通过创建一个对象OptionMenu来显示问题，并在创建的answer_entry文本框中输入答案。这个文本框是使用Entry类创建的。
question_menu = OptionMenu(root, tkvarq, *questions)
question_menu.pack()
#Answer entry
answer_entry = Entry(root, width=30)
answer_entry.pack()
Tkinter OptionMenu 小部件实现的完整代码
from tkinter import *
root = Tk()
root.title(“Option Menu”)
root.geometry(‘700x500’)
# Create the list of questions
# Pass them into an option menu
# Create an entry for the answer
# Create submit button
def print_answers():
print (“Q: {} A: {} “,format(tkvarq.get(), answer_entry.get()))
return None
Question = [“What is your mother’s maiden name?”,
“ Who is your favorite author?”,
“ What was your first pets name? “,
“What street did you grow up on? “
]
tkvarq = StringVar(root)
tkvarq.set(questions[0])
question_menu = OptionMenu(root, tkvarq, *questions)
question_menu.pack()
#Answer entry
answer_entry = Entry(root, width=30)
answer_entry.pack()
#Submit button
submit_button = Button(root, test=’Submit’, command=print_answers)
submit_button.pack()
root.mainloop()
这段代码生成一个包含问题的选项菜单。您可以选择一个您希望回答的问题，并在提供的文本框中填写您的答案。
请注意，此代码不包含验证，这意味着它不会告诉您输入的答案是否正确。
上述代码的输出如下所示:
Option Menu
结论
关于 Tkinter 列表框和选项菜单的教程到此结束。一定要尝试这些例子，并在下面的评论部分给出你的反馈。
Tkinter Messagebox 和 RadioButton:简单介绍
原文：https://www.askpython.com/python-modules/tkinter/tkinter-messagebox-and-radiobutton
在本文中，我们将研究 Tkinter Messagebox 和 Tkinter 的 Radiobutton 小部件。
tkinter 包(“Tk 接口”)是 Tk GUI 工具包的标准 Python 接口。它改进了 Python 应用程序的用户界面，并提供了大量可以从内置包中使用的小部件。
什么是 Tkinter messagebox？
messagebox 是应用程序的基本组件，用于向用户传达他/她的代码状态。基本上，它让编码者知道编码过程中的错误或成功。
它在许多内置函数的帮助下提供了这种功能。这些函数包括 showinfo、showwarning、showerror、askquestion、askokcancel、askyesno 和 askretryignore。
Tkinter Messagebox 的基础知识
首先，我们将导入 tkinter 模块以及 messagebox 函数。
然后，我们将指定窗口(框架)，并使用 Tk()将其命名为root。
from tkinter import *
from tkinter import messagebox
root =Tk()
然后，我们将通过在root对象上实例化geometry()来指定框架的尺寸。
root.geometry("400x400+120+120")
root.mainloop()
然后我们将使用 Tkinter Button()窗口小部件定义一个名为b的按钮，该窗口小部件显示消息“点击此处”,点击该按钮将触发call_me()功能。然后，我们将使用pack()将小部件放置在框架的几何图形上。
def call_me():
messagebox.showinfo("Success","Welcome to our tutorial")
b = Button(root,text="Click here",command=call_me)
b.pack()
完整的代码如下所示:
from tkinter import *
from tkinter import messagebox
def call_me():
messagebox.showinfo("Success","Welcome to our tutorial")
root =Tk()
b = Button(root,text="Click here",command=call_me)
b.pack()
root.geometry("400x400+120+120")
root.mainloop()
输出如图所示。因此，一旦你点击“点击这里”按钮，名为“成功”的警告框显示消息“欢迎来到我们的教程”。点击“确定”按钮，该框消失。
Output 1
Success Message
Tkinter 单选按钮
单选按钮是一个 tkinter 小部件，用于在几个给定的多项选择中进行选择。还记得在多项选择题 GUI 中看到过这个吗？
为什么应该使用单选按钮？
- 它们对用户来说更快，因为他们可以通过一次点击而不是两次点击来做出更快的选择。典型的点击需要 1.2 到 2.4 秒。
- 它们提供了更好的控件自文档，无需点击任何东西。
- 对于触摸界面，点击单选按钮比浏览下拉列表更容易。
- 您可以一起提供所有的选择(就可访问性而言)
创建简单单选按钮
为了创建一个单选按钮，我们将使用 python 的 tkinter 模块。让我们看一下相同的编码。
from tkinter import *
root =Tk()
r1=Radiobutton(root, text="Yes", value=1)
r2=Radiobutton(root, text="No", value=2)
r1.pack()
r2.pack()
root.geometry("300x300+120+120")
root.mainloop()
在上面的代码片段中，我们首先导入tkinter模块，并使用Tk()初始化一个 tkinter 帧。在这个框架root中，我们使用Radiobutton()函数创建了两个单选按钮，该函数接受框架名称、文本和值等参数。然后我们使用pack()函数将这个小部件设置成行和列。
上述代码片段的输出如下所示:
Radiobutton Output
结论
这就是我们关于 Tkinter Messagebox 和 Radiobuttons 的教程的结尾。Tkinter 模块非常庞大，我们想让你很容易理解。因此，请关注 Tkinter 教程页面，了解更多信息！
参考
https://docs.python.org/3.9/library/tkinter.messagebox.html
Tkinter 教程-为你的窗户添加衬垫
原文：https://www.askpython.com/python-modules/tkinter/tkinter-padding-tutorial
嘿皮托尼斯！在本文中，我们将学习一些 GUI 基础知识。Python 有许多支持 GUI 开发并同时保持代码简单性的库。其中一个就是 Tkinter 。最棒的是 Python 也是由这个包驱动的。学习和实现都非常简单。我们可以制作很酷的 GUI 项目和应用程序。
Tkinter 中 GUI 应用的基本参数
- Tkinter 中的 GUI 应用运行在三个方面:
- 作为根的包的实例-“root = Tk()”。
- 应用程序的几何图形–屏幕宽度和屏幕高度-“root . geometry(宽度 x 高度)”
- 主循环()–保持应用程序在屏幕上运行，直到它被关闭。
创建一个简单的 Tkinter 窗口
在本节中，我们将使用 Tkinter 创建一个标题为“Hello World”的简单窗口。这样也就把上面的理论都搞清楚了。
代码:
from tkinter import * # importing the package
root = Tk() # creating a root that acts as an instance
root.title("Hello World") # setting up the title of window
root.geometry("400x400") # giving the window its height and width
root.mainloop() # the mainloop
输出:
A basic Tkinter window
这只是一个标题为“Hello World”的空白窗口。所以，为了让它更漂亮，让我们添加一些小部件。
在 Tkinter 窗口中添加填充
填充是将小部件放置在二维 GUI 根窗口中。这有助于我们根据需要调整它们。
现在，我们必须考虑窗口是如何容纳所有小部件的。在计算机图形学中，在屏幕上表示一个点的最小单位是像素。如果我们能在空白屏幕上看到一个白点，那么它的度量就是一个像素。在手机、电脑、笔记本电脑上呈现在我们面前的图像是各种彩色像素的组合调整。
- padx :将 widget 放置在 x 轴的窗口中。
- pady :将 widget 放置在 y 轴的窗口中。
添加 padx 参数
Tkinter 中的标签是具有 padx 和 pady 参数的部件之一。让我们看一个例子:
代码: 无任何填充
from tkinter import *
# basic setup
window = Tk()
window.title("Padding in Tkinter")
window.geometry("400x400")
window.config(background = "Light Blue")
# creating a label widget
label_1 = Label(window,
text = "Label_1",
bg = "white",
fg = "black",
font = ("Arial", 30))
label_1.pack()
# tkinter's mainloop
window.mainloop()
输出:
Placing the label widget without padding
说明:
- 在前六行代码中，这是 Tkinter 的基本设置。
- 下一步是我们创建一个标签小部件的实例。
- 给显示器文本 as = "Label_1
- 使用 bg 参数将背景颜色调整为白色。
- 使用 fg 将前景或文本颜色作为块。
- 设置字体样式为 Arial ，文字大小为 30 。
- 若要显示标签，请调用 pack()方法。
因此，默认情况下，Tkinter 将标签放在窗口的中央。
代码:带 padx
from tkinter import *
window = Tk()
window.title("Padding in Tkinter")
window.geometry("400x400")
window.config(background = "Light Blue")
label_1 = Label(window,
text = "Label_1",
bg = "white",
fg = "black",
font = ("Arial", 30))
label_1.pack(padx = (100, 0))
window.mainloop()
输出:
Placing the label widget with padding
现在我们可以看到，当我们设置 padx = (100，0)时，它有点偏离中心。
添加 pady 参数
此选项会将我们的标签放置或移动到离窗口上边距稍远的地方。我们只需更改参数，其余代码保持不变。
代码:
from tkinter import *
window = Tk()
window.title("Padding in Tkinter")
window.geometry("400x400")
window.config(background = "Light Blue")
label_1 = Label(window,
text = "Label_1",
bg = "white",
fg = "black",
font = ("Arial", 30))
label_1.pack(pady = 100)
window.mainloop()
输出:
Padding with “pady” parameter
这里我们可以看到 y 坐标发生了填充。标签在窗口上有了新的位置。
更多理解的示例代码
您可以使用 Tkinter 中的按钮尝试一些代码，并检查填充是否适用于它们。
代码 1:
from tkinter import *
window = Tk()
window.title("Padding in Tkinter")
window.geometry("400x400")
window.config(background = "Light Blue")
button = Button(window,
text = "Click me",
bg = "white",
fg = "red",
border = 10,
font = ("Arial", 30))
button.pack(padx = 100)
window.mainloop()
代码 2:
from tkinter import *
window = Tk()
window.title("Padding in Tkinter")
window.geometry("400x400")
window.config(background = "Light Blue")
button = Button(window,
text = "Click me",
bg = "white",
fg = "red",
border = 10,
font = ("Arial", 30))
button.pack(pady = 40)
window.mainloop()
结论
就这样，我们结束了。Tkinter 是 Python 中一个非常简单但功能强大的模块，随着 Python 新版本的推出，它有了很多改进。Padding 就是其中之一。我希望这有助于您编写 GUI 程序。
使用 Tkinter 缩放微件
原文：https://www.askpython.com/python-modules/tkinter/tkinter-scale-widget
大家好！在我们的 Tkinter 教程的这一部分，我们将介绍另一个小部件——Tkinter比例小部件。
如果您想在应用程序上显示任何类型的比例，这是一个非常有用的小部件。
我们将通过一个简单的例子来演示如何使用这个小部件。我们开始吧！
基本 Tkinter 缩放微件选项
当我们希望用户输入一个限定在一定范围内的数值时，我们可以使用这个小部件。
用户可以在标尺上移动，并为输入选择合适的值。
要使用它，基本选项的格式如下:
scale_widget = tk.Scale(master, from_, to, orient)
这里，master是 Tkinter 主对象，它是任何 Tkinter GUI 应用程序运行所必需的。
from_和to关键字参数指定滑块值的范围。
最后，方位orient可以是“水平”也可以是“垂直”。
还有一个名为resolution的可选参数，它指定值的数值分辨率。
例如，默认分辨率为 1，这将确保所有值都四舍五入为最接近的整数。您可以根据需要调整这个参数。
要使用 Tkinter scale 小部件的当前值，只需调用scale_widget.get()。而要设置 Tkinter scale 小部件，可以调用scale_widget.set(value)。
现在让我们看一个例子来说明这意味着什么。
使用 Tkinter Scale 小部件–为我们的应用程序构建一个比例
让我们为我们的虚拟应用程序构建一个水平标度，它由从 0 到 100 的整数值组成。
这意味着数值分辨率为 1。
import tkinter as tk
from tkinter import messagebox
# Create the master object
master = tk.Tk()
# Create a Scale Widget
scale_widget = tk.Scale(master, orient="horizontal", resolution=1,
from_=0, to=100)
# And a label for it
label_1 = tk.Label(master, text="Scale")
# Use the grid geometry manager to put the widgets in the respective position
label_1.grid(row=0, column=0)
scale_widget.grid(row=0, column=1)
# The application mainloop
tk.mainloop()
输出
Scale Example 1
好吧！这按预期工作，我们的 Tkinter scale 小部件显示从 0 到 100 的值。
现在让我们向应用程序添加一个按钮小部件。
当我们在设置比例值后单击按钮时，我们将调用一个函数来输出一个消息框警告，它将显示我们选择的值。
让我们将按钮小部件添加到程序中。
button = tk.Button(master, text="Click", command=buttonCallback)
button.grid(row=1, column=1)
这里，command参数指定了当这个按钮被点击时将被调用的函数。
我们将调用一个名为buttonCallback的函数，它为我们处理这个事件。
def buttonCallback():
global scale_widget
messagebox.showinfo("Message", "You have chosen value {}".format(scale_widget.get()))
我在全局范围内使用了scale_widget，这样我们就可以使用scale_widget.get()获得值。该值将打印在消息框上。
作为补充，我还将使用master.geometry()将默认的框架大小从标准的“200×200”增加到更大的“300×300”窗口。
master.geometry("300x300")
我现在将发布完整的代码。
import tkinter as tk
from tkinter import messagebox
# Create the master object
master = tk.Tk()
master.geometry("300x300")
# Create a Scale Widget
scale_widget = tk.Scale(master, orient="horizontal", resolution=1,
from_=0, to=100)
# And a label for it
label_1 = tk.Label(master, text="Scale")
# Use the grid geometry manager to put the widgets in the respective position
label_1.grid(row=0, column=0)
scale_widget.grid(row=0, column=1)
def buttonCallback():
global scale_widget
messagebox.showinfo("Message", "You have chosen value {}".format(scale_widget.get()))
button = tk.Button(master, text="Click", command=buttonCallback)
button.grid(row=1, column=1)
# The application mainloop
tk.mainloop()
现在，让我们看看输出。
Tkinter Scale Example
的确，当你点击按钮，设置好刻度值后，显示的是正确的数字！
结论
在本教程中，我们学习了如何使用 Tkinter Scale 小部件。
在接下来的文章中，我们将介绍更多的小部件，请继续关注！
Tkinter Spinbox 和 Progressbar 小工具
原文：https://www.askpython.com/python-modules/tkinter/tkinter-spinbox-and-progressbar-widgets
大家好！在这个关于 Tkinter 的系列教程中，我们将学习 Tkinter Spinbox 和 Progressbar 小部件。我们将继续探索更多可以添加到应用程序中的小部件。
让我们使用说明性的示例，逐一查看它们！
使用 Tkinter Spinbox 小部件
Tkinter Spinbox 小部件是一个允许我们从一组固定值中进行选择的小部件。
还记得 Tkinter Entry widget 吗？假设您希望限制最终用户只能从有限的选项集中进行选择，这在这里没有多大用处！
您更希望有一组固定的选项可供选择，而这正是 Spinbox 小部件给我们提供的！
现在让我们来看看如何使用它。
这与我们的入口小部件几乎相同，但是您在名为values的可选参数下指定值列表，该参数是一个 元组 。
spin_box = tk.Spinbox(master, values)
如果您的值在整数/等之间，您也可以使用from_和to参数指定一个值范围。
注意:由于from是一个保留的 Python 关键字，因此from_关键字参数的末尾有一个下划线。
spin_box = tk.Spinbox(master, from_, to)
现在让我们制作一个简单的应用程序，它有一个 spinbox 小部件，带有一些预定义的选项。
我们将使用网格几何形状管理器将我们的小部件放置在合适的位置。
我们还会给每个小部件一个标签，以便其他人可以使用一些文本来识别它。
import tkinter as tk
# Create the master object
master = tk.Tk()
# Create a spinbox widget
spinbox_1 = tk.Spinbox(master, values=("Python", "Java", "C++"))
# And a label for it
label_1 = tk.Label(master, text="Language")
# Create another spinbox widget
spinbox_2 = tk.Spinbox(master, from_=1, to=3)
# And a label for it
label_2 = tk.Label(master, text="Value")
# Use the grid geometry manager to put the widgets in the respective position
label_1.grid(row=0, column=0)
spinbox_1.grid(row=0, column=1)
label_2.grid(row=1, column=0)
spinbox_2.grid(row=1, column=1)
# The application mainloop
tk.mainloop()
输出
Spinbox Entry 1
Spinbox Entry 2
如果您自己运行这个程序，您会发现您可以从我们上面提供的特定列表中调整 spinbox 小部件的值！
关于这个小部件的更多参数和调整，您可以查看官方文档。
现在让我们看看 ProgressBar 小部件！
使用 Progressbar 小部件
Progressbar 小部件显示任何长时间运行的操作的状态。
假设您想要可视化任何事情的进度需要多长时间，您可以使用 Progressbar！
这在tkinter.ttk模块中可用，因此您必须单独导入。
import tkinter as tk
# Necessary for the Progressbar widget
import tkinter.ttk as ttk
我们将通过简单的选项来看看如何使用它。你可以在这里看完整列表。
progress_bar = ttk.Progressbar(orient, mode, maximum, value)
这里，orient指定了进度条的方向。它可以是“水平的”或“垂直的”
该小工具可以在两个mode秒内运行:
- “确定”->显示相对于工作总量的完成量
- “不确定”->简单地显示一个动画显示来表明工作正在进行。
进度条将一直持续到当前的value到达maximum为止。
要开始递增 progressbar 的值，我们必须使用progress_bar.start(interval)，它会每隔interval毫秒自动为您递增。
我们将把它保持为None，它将被设置为默认值 50 毫秒
progress_bar.start(interval=None)
我们现在将使用step()方法确保该值以amount = 10递增。
progress_bat.step(amount=10)
我会把完整的代码张贴到现在。
import tkinter as tk
import tkinter.ttk as ttk
# Create the master object
master = tk.Tk()
# Create a progressbar widget
progress_bar = ttk.Progressbar(master, orient="horizontal",
mode="determinate", maximum=100, value=0)
# And a label for it
label_1 = tk.Label(master, text="Progress Bar")
# Use the grid manager
label_1.grid(row=0, column=0)
progress_bar.grid(row=0, column=1)
# Start auto-incrementing periodically
progress_bar.start()
progress_bar.step(10)
# The application mainloop
tk.mainloop()
输出
Progress Bar 1
你得到一个移动的进度条！
这使得value每 50 毫秒从 0 到 100 递增 10 个单位。
但是我们使用的方法正确吗？
但是这里的问题是进度条在到达maximum后再次重置为 0。
为了避免这种情况，我们必须stop()进度条。
但是我意识到这也产生了比我想象的更多的问题，因为那时，我不能得到一个更新的进度条。
最大的问题是我们的主应用程序运行在tk.mainloop()函数中。因此，所有这些都必须预先计算，以便实时运行。
所以，在谷歌搜索了几次后，我发现使用start()和stop()是而不是的正确方法，因为它从来没有说进度条是如何重绘的。
因此，唯一剩下的解决方案(可悲的)是我们自己手动更新 Progressbar 的value。
这似乎确实是其他 Tkinter 程序员看到 StackOverflow 帖子上的内容后得出的结论。现在让我们继续！
我们自己修改小部件值
为此，所有 Tkinter 小部件都有字典属性，我们可以修改这些属性！是的，就这么简单。
只需更新 progressbar 值，使用:
progress_bar['value'] = 0
master.update()
然而，我们还必须使用master.update()告诉master对象这个小部件已经用新值更新了。
现在，我们将重写旧的和不正确的代码来考虑这些变化。
import tkinter as tk
import tkinter.ttk as ttk
import time
# Create the master object
master = tk.Tk()
# Create a progressbar widget
progress_bar = ttk.Progressbar(master, orient="horizontal",
mode="determinate", maximum=100, value=0)
# And a label for it
label_1 = tk.Label(master, text="Progress Bar")
# Use the grid manager
label_1.grid(row=0, column=0)
progress_bar.grid(row=0, column=1)
# Necessary, as the master object needs to draw the progressbar widget
# Otherwise, it will not be visible on the screen
master.update()
progress_bar['value'] = 0
master.update()
while progress_bar['value'] < 100:
progress_bar['value'] += 10
# Keep updating the master object to redraw the progress bar
master.update()
time.sleep(0.5)
# The application mainloop
tk.mainloop()
现在，当我们通过自己更新小部件的值来做所有艰苦的工作时，我们有了更多的控制权。
这段代码现在应该能够显示进度条的连续序列，当value达到 100 时停止。
下面是一个简单的 GIF 图，说明了这个程序的工作原理。
Progress Bar GIF
结论
最后，我们已经到了使用 Tkinter Spinbox 和 Progressbar 小部件的教程的末尾。希望您已经理解了为您的 GUI 应用程序添加更多功能的步骤！
更多 Tkinter 内容即将推出，敬请关注！
带有 Tkinter 滚动条的 Tkinter 文本小部件
原文：https://www.askpython.com/python-modules/tkinter/tkinter-text-widget-tkinter-scrollbar
大家好。在我们的 Tkinter 教程部分的这一部分，我们将看看 Tkinter 文本小部件。
虽然我在之前的教程中使用了面向对象的方法，但是现在我们将会看到单个的小部件示例，如果我直接使用这个模块的话会更简单。
因此，我将在这里直接使用 Tkinter，而没有显式的Application类。
现在，让我们开始吧！
Tkinter 文本小工具
这是一个允许我们在应用程序中轻松查看文本对象的小部件。例如，如果您想在 GUI 上显示一些行，我们可以很容易地使用文本小部件来实现我们的目标。
让我们看看怎么做。
要创建文本小部件，只需使用tk.Text(master, width, height)方法，其中master是 GUI 应用程序的主对象(使用tk.TK())。
然后我们可以使用text_widget.insert()方法添加文本。
import tkinter as tk
# Create our master object to the Application
master = tk.Tk()
# Create the text widget for two lines of text
text_widget = tk.Text(master, height=2, width=40)
# Pack it into our tkinter application
text_widget.pack()
# Insert text into the text widget
# tk.END specifies insertion after the last character in our buffer
text_widget.insert(tk.END, "First Line - Hello from AskPython\nSecond Line - Hi")
# Start the mainloop
tk.mainloop()
输出
Tkinter Text Widget 1
事实上，我们的文本小部件中似乎有两行文本！
向我们的文本小部件添加滚动条
虽然上面的输出适用于较小的文本，但是如果我们的文本大小本身大于宽度呢？
我们可以使用 Tkinter 的滚动条，并将其添加到我们的文本小部件中。现在，添加滚动条后，我们应该能够正确显示更大的文本。
要创建滚动条对象，使用tk.Scrollbar()并将其添加到我们的应用程序中！现在，在您将它打包到应用程序之后，我们可以使用滚动文本小部件来显示更长的文本！
import tkinter as tk
# Create our master object to the Application
master = tk.Tk()
# Create the text widget
text_widget = tk.Text(master, height=5, width=40)
# Create a scrollbar
scroll_bar = tk.Scrollbar(master)
# Pack the scroll bar
# Place it to the right side, using tk.RIGHT
scroll_bar.pack(side=tk.RIGHT)
# Pack it into our tkinter application
# Place the text widget to the left side
text_widget.pack(side=tk.LEFT)
long_text = """This is a multiline string.
We can write this in multiple lines too!
Hello from AskPython. This is the third line.
This is the fourth line. Although the length of the text is longer than
the width, we can use tkinter's scrollbar to solve this problem!
"""
# Insert text into the text widget
text_widget.insert(tk.END, long_text)
# Start the mainloop
tk.mainloop()
输出
Tkinter Scroll 1
Tkinter Scroll 2
您可以看到右边的滚动条，由左边的文本小部件支持。
希望您可以在此基础上向您的 GUI 应用程序添加更多的小部件，并使其更加有趣！
结论
在本教程中，我们学习了如何在 Tkinter 应用程序中添加简单的文本小部件，并添加滚动条来支持更大的文本。
在我们即将发布的 Tkinter 教程中，请继续关注更多的部件！
Tkinter TreeView 部件
原文：https://www.askpython.com/python-modules/tkinter/tkinter-treeview-widget
又见面了！作为我们的 Tkinter 教程系列的一部分，今天的帖子将涵盖 TreeView 小部件。
如果您想要显示项目的层次结构，并且所有属性都并排列出，那么 TreeView 小部件非常有用。
例如，如果您想构建一个看起来像 Windows 文件资源管理器的应用程序，我们可以使用 Tkinter 的 TreeView 小部件来实现。
Windows File Explorer 1
因此，TreeView 允许我们做的是构建一个类似树的结构，并相应地插入项目及其属性。
您可以在需要时动态地添加或删除树中的节点，因此这对于许多 GUI 应用程序非常有用。
我们可以根据自己的喜好来构造树。
如果您想要复制文件资源管理器，您应该创建一个包含文件及其属性的树形视图，并添加嵌套文件和文件夹作为父文件夹的子文件夹！
虽然我们不会做这个练习，但我建议你自己尝试一下，这样你就能很好地理解TreeView是如何工作的。
现在让我们看看如何构造一个树形视图小部件，并对其执行操作——比如插入和删除。
构建一个 TreeView 小部件
TreeView 小部件属于tkinter.ttk模块，所以我们必须导入它。
import tkinter.tk as ttk
现在，我们可以将小部件称为ttk.TreeView()。
要创建新的 TreeView 小部件，语法很简单。
tree = ttk.Treeview(master, columns)
这里，tree对应新形成的树的根节点。这里，master 指的是主 Tkinter 应用主节点。
columns是一个元组，指的是列的名称。
例如，我们可以像这样构造一个 TreeView 小部件，具有“Name”和“ID”列:
tree = ttk.Treeview(master, columns=("Name", "ID"))
该树将使用master作为基础小部件来构建。通常，您会希望它成为应用程序的主要主对象:
master = tk.Tk()
现在，虽然我们有了一个 TreeView 小部件，但是显示它是没有意义的，因为它是空的。
让我们首先插入一些对象，这样我们就可以在实际应用程序中查看 TreeView。
请记住，TreeView 节点的行仅由字符串组成，如下所示:
"Label" , "Hello", "Second Col", "Third Col"
现在，让我们向新构建的树形视图中插入一些节点。
插入到树视图
插入语法非常简单。我们获取 TreeView 对象，并插入一些用text标记的values。我们还可以使用iid参数为节点指定一个惟一的 ID。
tree.insert(parent, index, iid, text, values)
这里，我们将节点插入到parent。如果您想让parent小部件作为主(根)节点，我们可以将其设置为空字符串(")。否则，我们必须提到一个现有父节点的iid。
使用index引用该节点的子编号。
例如，如果您想在第一个孩子处插入，您可以指定index=0。如果想插在最后，可以提一下特殊值'end'。
tree.insert(parent='', index='end', iid=0, text="Label", values=("Hello", "Second Col", "Third Col"))
上面是一个插入到根节点末尾的示例，其值如下行所示:
"Label" , "Hello", "Second Col", "Third Col"
不幸的是，没有一种简单的方法来构建 TreeView，因为您需要其他小部件来正确地可视化输出。
在继续下一步之前，请确保您已经阅读了我们关于 Tkinter 按钮、网格管理器和 Tkinter 入口小部件的教程部分。
我将提供一个示例应用程序来可视化输出，使用这些小部件:
import tkinter as tk
import tkinter.ttk as ttk
class Application(tk.Frame):
def __init__(self, root):
self.root = root
self.initialize_user_interface()
def initialize_user_interface(self):
# Configure the root object for the Application
self.root.title("Application")
self.root.grid_rowconfigure(0, weight=1)
self.root.grid_columnconfigure(0, weight=1)
self.root.config(background="green")
# Define the different GUI widgets
self.name_label = tk.Label(self.root, text="Name:")
self.name_entry = tk.Entry(self.root)
self.name_label.grid(row=0, column=0, sticky=tk.W)
self.name_entry.grid(row=0, column=1)
self.idnumber_label = tk.Label(self.root, text="ID")
self.idnumber_entry = tk.Entry(self.root)
self.idnumber_label.grid(row=1, column=0, sticky=tk.W)
self.idnumber_entry.grid(row=1, column=1)
self.submit_button = tk.Button(self.root, text="Insert", command=self.insert_data)
self.submit_button.grid(row=2, column=1, sticky=tk.W)
self.exit_button = tk.Button(self.root, text="Exit", command=self.root.quit)
self.exit_button.grid(row=0, column=3)
# Set the treeview
self.tree = ttk.Treeview(self.root, columns=('Name', 'ID'))
# Set the heading (Attribute Names)
self.tree.heading('#0', text='Item')
self.tree.heading('#1', text='Name')
self.tree.heading('#2', text='ID')
# Specify attributes of the columns (We want to stretch it!)
self.tree.column('#0', stretch=tk.YES)
self.tree.column('#1', stretch=tk.YES)
self.tree.column('#2', stretch=tk.YES)
self.tree.grid(row=4, columnspan=4, sticky='nsew')
self.treeview = self.tree
self.id = 0
self.iid = 0
def insert_data(self):
self.treeview.insert('', 'end', iid=self.iid, text="Item_" + str(self.id),
values=("Name: " + self.name_entry.get(),
self.idnumber_entry.get()))
self.iid = self.iid + 1
self.id = self.id + 1
app = Application(tk.Tk())
app.root.mainloop()
在这里，我为输入创建了一些标签和条目。我还创建了一个树形视图，由两部分组成:
- 树形视图标题(显示列名)
- TreeView 列和
insert_data()方法
每当我们按下“插入”按钮时，就会在 TreeView 小部件上调用insert_data()方法。
现在，说够了。现在让我们测试我们的程序插入！
Treeview Example
好的，这看起来很有效！现在让我们添加一个删除按钮，这样我们就可以删除选中的行。
从树视图中删除行
有一种方法我们可以利用。这将从 TreeView 小部件中删除相应的节点(在我们的例子中是行)。
tree.delete(iid)
这只是获取节点的iid标识号，并将其从 TreeView 中删除！
我们将用一个叫做delete_data()的方法来总结这一点。
现在，最大的问题是我们如何从 TreeView 小部件中获得我们的行的 id 号。
嗯，这取决于你将如何执行删除操作。
每当我们用鼠标选中某一行时，我们就会删除该行。在该行突出显示后，我们可以按 delete 按钮，这将把它从TreeView小部件中删除。
为此，我们将使用TreeView.focus()方法来获取行的iid(作为一个字符串)。我们可以用这个直接删除那一行！
def delete_data(self):
row_id = int(self.tree.focus())
self.treeview.delete(row_id)
让我们添加一个删除按钮，并使用这个方法作为回调函数！
添加后，应用程序将如下所示:
import tkinter as tk
import tkinter.ttk as ttk
class Application(tk.Frame):
def __init__(self, root):
self.root = root
self.initialize_user_interface()
def initialize_user_interface(self):
# Configure the root object for the Application
self.root.title("Application")
self.root.grid_rowconfigure(0, weight=1)
self.root.grid_columnconfigure(0, weight=1)
self.root.config(background="green")
# Define the different GUI widgets
self.name_label = tk.Label(self.root, text="Name:")
self.name_entry = tk.Entry(self.root)
self.name_label.grid(row=0, column=0, sticky=tk.W)
self.name_entry.grid(row=0, column=1)
self.idnumber_label = tk.Label(self.root, text="ID:")
self.idnumber_entry = tk.Entry(self.root)
self.idnumber_label.grid(row=1, column=0, sticky=tk.W)
self.idnumber_entry.grid(row=1, column=1)
self.submit_button = tk.Button(self.root, text="Insert", command=self.insert_data)
self.submit_button.grid(row=2, column=1, sticky=tk.W)
self.delete_button = tk.Button(self.root, text="Delete", command=self.delete_data)
self.delete_button.grid(row=100, column=100)
self.exit_button = tk.Button(self.root, text="Exit", command=self.root.quit)
self.exit_button.grid(row=0, column=3)
# Set the treeview
self.tree = ttk.Treeview(self.root, columns=('Name', 'ID'))
# Set the heading (Attribute Names)
self.tree.heading('#0', text='Item')
self.tree.heading('#1', text='Name')
self.tree.heading('#2', text='ID')
# Specify attributes of the columns (We want to stretch it!)
self.tree.column('#0', stretch=tk.YES)
self.tree.column('#1', stretch=tk.YES)
self.tree.column('#2', stretch=tk.YES)
self.tree.grid(row=4, columnspan=4, sticky='nsew')
self.treeview = self.tree
self.id = 0
self.iid = 0
def insert_data(self):
self.treeview.insert('', 'end', iid=self.iid, text="Item_" + str(self.id),
values=("Name: " + self.name_entry.get(),
self.idnumber_entry.get()))
self.iid = self.iid + 1
self.id = self.id + 1
def delete_data(self):
row_id = int(self.tree.focus())
self.treeview.delete(row_id)
app = Application(tk.Tk())
app.root.mainloop()
输出
Treeview Delete
现在，我们已经完成了 TreeView 的基本结构，并且实现了基本的插入和删除操作。
我建议您通过处理其他操作，比如更新一些行，为这个应用程序添加更多的功能。您可能还会注意到，删除后项目编号没有正确排序。
这里有一个简单的update()模板函数，可以作为参考:
def update(self):
for idx, node in enumerate(self.treeview.get_children()):
self.tree.item(node, text="Updated_Item_" + str(idx))
这将更新您的TreeView的所有行，并更改您的text标签。您可以类似地修改其他属性。
这些是您可以对应用程序进行的各种改进。
结论
希望您已经使用TreeView让这个简单的应用程序工作了。我们简要地看了如何使用这个小部件来显示应用程序的行和列，结构像一棵树。
使用 NLTK 在 Python 中进行标记化
原文：https://www.askpython.com/python-modules/tokenization-in-python-using-nltk
让我们学习使用 NLTK 库在 Python 中实现标记化。作为人类，我们很大程度上依赖语言来相互交流。人工智能也需要计算机理解我们的语言。
让计算机理解和处理语言属于自然语言处理的范畴。NLP 被广泛定义为通过软件对自然语言如语音和文本的自动操作。
标记化是 NLP 下执行的常见任务。记号化是将一段文本分解成称为记号的更小单元的过程。这些令牌构成了 NLP 的构造块。
为什么我们需要标记化？
LSTM 和 RNN 等 NLP 中的深度学习架构以令牌的形式处理文本。
通过在文本语料库上运行标记化，我们可以形成词汇表。然后，以适合于相应语言模型的方式来表示这些标记。
这种表示被称为单词嵌入。最常见的单词嵌入模型有 Skipgram 和 One-Hot-Encoding 。
在本教程中，我们将学习如何标记我们的文本。
让我们编写一些 python 代码来标记一段文本。
用 NLTK 在 Python 中实现标记化
我们将使用 NLTK 模块来标记文本。NLTK 是自然语言工具包的简称。这是一个用 Python 编写的用于符号和统计自然语言处理的库。
NLTK 使得处理文本数据变得非常容易。让我们从安装 NLTK 开始。
1.正在安装 NLTK 库
在你的控制台上运行 pip 命令来安装 NLTK。
pip install nltk
要安装 NLTK 的组件，请使用:
import nltk
nltk.download()
在本教程中，我们将讨论两种类型的标记化:
- 句子标记化
- 单词标记化
2.在 Python 中设置标记化
让我们从导入必要的模块开始。
from nltk.tokenize import sent_tokenize, word_tokenize
sent_tokenize 负责基于句子的分词， word_tokenize 负责基于单词的分词。
我们要标记的文本是:
"Hello there! Welcome to this tutorial on tokenizing. After going through this tutorial you will be able to tokenize your text. Tokenizing is an important concept under NLP. Happy learning!"
将文本存储在变量中。
text = "Hello there! Welcome to this tutorial on tokenizing. After going through this tutorial you will be able to tokenize your text. Tokenizing is an important concept under NLP. Happy learning!"
3.使用 sent_tokenize()在 Python 中实现句子标记化
要根据句子进行标记，请使用:
print(sent_tokenize(text))
我们得到的输出是:
['Hello there!', 'Welcome to this tutorial on tokenizing.', 'After going through this tutorial you will be able to tokenize your text.', 'Tokenizing is an important concept under NLP.', 'Happy learning!']
它返回一个列表，列表中的每个元素都是文本中的一个句子。
4.使用 word_tokenize()在 Python 中进行单词标记化
根据我们使用的单词来标记:
print(word_tokenize(text))
我们得到的输出是:
['Hello', 'there', '!', 'Welcome', 'to', 'this', 'tutorial', 'on', 'tokenizing', '.', 'After', 'going', 'through', 'this', 'tutorial', 'you', 'will', 'be', 'able', 'to', 'tokenize', 'your', 'text', '.', 'Tokenizing', 'is', 'an', 'important', 'conceot', 'under', 'NLP', '.', 'Happy', 'learning', '!']
它返回一个列表，列表中的每个元素都是文本中的一个单词。这些现在可以作为标记进入语言模型进行训练。
使用 NLTK 完成标记化的 Python 代码
完整的代码如下:
from nltk.tokenize import sent_tokenize, word_tokenize
text = "Hello there! Welcome to this tutorial on tokenizing. After going through this tutorial you will be able to tokenize your text. Tokenizing is an important concept under NLP. Happy learning!"
print(sent_tokenize(text))
print(word_tokenize(text))
结论
本教程是关于在 python 中标记文本的。我们还讨论了使用 NLTK 在 Python 中标记化及其实现的需要。
在对文本进行标记化之后，您还可以在 Python 中识别文本的情感。看看这个用 Python 进行情感分析的教程。
改善 K8s 故障排除体验的 4 种工具
原文：https://www.askpython.com/python/tools-to-improve-k8s-troubleshooting-experiences
Kubernetes 是一个开源的容器编排工具。它是目前的市场领导者——任何使用容器的企业都已经在使用 Kubernetes 或者考虑在不久的将来使用它。然而，帮助自动化容器的部署、伸缩和管理使 Kubernetes 成为一个复杂的系统。开发人员需要专业知识来管理节点和 pod，并对其进行故障排除。
为什么我们需要故障排除工具？
即使在小型环境中，也很难在控制器或控制面板中对单个 pod 中的问题进行故障排除。在大型环境中，Kubernetes 部署在多节点集群中，有许多移动部件来支持在 pod 中运行的应用程序的弹性和高可用性。因此，IT/DevOps 团队需要多种工具来管理或排查 Kubernetes 环境中的问题。
在 Kubernetes 环境中很难排除故障。工具可以节省您识别和解决问题的时间。它们还可以帮助您监控性能，跟踪 pod 和堆栈中发生的变化，并生成 pod 的崩溃报告。
1. Komodor
Komodor 是一款 Kubernetes 本地故障排除工具，通过提供丰富的功能集，消除了 Kubernetes 故障排除的复杂性。Komodor 跟踪整个 K8s 堆栈的变化，分析它们的连锁反应，并为管理员提供排除堆栈故障所需的上下文。作为一个混合应用，web UI(服务视图)和 Komodor 代理安装在 K8s 集群中。这使得管理员很容易理解跨服务的变化。
Komodor 帮助管理员获得对 Kubernetes 堆栈的控制和完全可见性。Komodor 是一个集中式的工具，可以端到端地跟踪系统:版本控制系统中的代码、配置、K8stack 以及监控和警报工具。Komodor 时间线允许管理员看到环境中发生的变化，包括什么代码被推送，是谁推送的。
它的注释允许管理员在本地 K8 YAML 文件中配置与 Komodor 相关的所有内容。Komodor 配置更改 API 允许管理员将其配置中的更改发送到中央服务器，并作为 Komodor 服务视图的一部分进行查看。Komodor 代理支持与 Kubernetes 集群的交互，并允许管理员加快故障排除过程。
2.编织范围
Weave Scope 是对 Kubernetes 集群进行故障排除的工具。它生成基础设施拓扑的报告，帮助部署和管理团队识别在 Kubernetes 基础设施中运行的应用程序的性能瓶颈。
Weavescope 有两个组件:应用程序和探针。两者都可以使用 scope 脚本部署在单个容器中。探测器负责收集运行它的主机的信息，并将指标发送到应用程序并形成报告。
编织范围需要零配置或集成。管理员只需启动并运行。它与 Docker、K8s 和 AWS ECS 无缝集成。它有一个 Kubernetes 中运行的容器的实时视图，管理员可以使用它轻松地识别和纠正与容器化应用程序的性能相关的问题。
3.Crashd
崩溃诊断( Crashd )是一款工具，可帮助开发人员管理员对 Kubernetes 基础架构进行故障排除和自动化诊断，使他们能够轻松地与基础架构进行交互并从基础架构中收集信息。
Crashd 使用星际语言。Starlark 是 Python 的一种方言，旨在用作一种配置语言。Crashd 脚本具有普通的编程结构，如变量声明、函数定义、数据类型、复合类型等。Crashd 执行与特定应用程序和集群资源交互的 Starlark 脚本文件。
Crashd 脚本由存储在一个文件中的 Starlark 函数集合组成。它包含交互和收集诊断数据以及集群中节点和应用程序的其他信息的功能。
Crashd 可以轻松地自动与运行 K8s 的基础设施进行交互。它通过一个安全外壳与计算集群节点进行交互，并从其中捕获信息。它从 Kubernetes API 服务器捕获集群日志，并轻松地从集群 API 管理的集群中提取数据。
4.强力密封
对于像网飞这样实施了混沌工程的团队来说，PowerfulSeal 就是工具。PowerfulSeal 是一个用于 Kubernetes 集群的混沌测试工具。它通过将故障注入集群而给基础架构带来混乱，因此 DevOps 管理员可以尽早检测到问题。管理员可以写豆荚的自毁。销毁 pod 后，他们检查服务是否继续响应 HTTP 探测。这是管理员验证其系统恢复能力的方法之一。
强力封印灵感来自网飞研发的混沌猴。它随机终止运行在亚马逊网络服务上的虚拟机。混沌猴会移除开发人员认为没有它软件也能运行的节点。PowerfulSeal 提供了一种简单的方法来编写 YAML 场景，并为管理员提供了一种交互模式，同时提供了强大的制表支持。
PowerfulSeal 也有一个运行在 OpenStack 上的 K8s 的 Kubernetes 驱动程序，并有支持不同云提供商的驱动程序:Azure、AWS 和 GCP。
结论
当你有一件很复杂很难预测的事情时，真正的问题不会如期发生，问题也不会以已知的模式发生。测试、排查和调试问题的最佳方式是使用适合该环境的工具。在本帖中，我们看到了四个 Kubernetes 故障排除工具，以及它们如何帮助管理员轻松有效地排除 Kubernetes 环境中的故障。
十大 Python 编程作业帮助网站
原文：https://www.askpython.com/resources/top-10-python-programming-homework-help-sites
每一个想在编程方面取得好成绩的学生，如果他们想在学术研究中取得真正的成功，就必须应对持续的家庭作业挑战。编程中的类也不例外。关于编程的事情是，有时你可能在没有完全理解导致解决方案的整个过程的情况下应付它。
理解你的一系列行为是这一当代且具有挑战性的研究课题中最困难的部分。经常，如果不是总是，这条教育道路上最困难的部分归结为抵制“盲目”处理一切的冲动，并花时间完全理解自己的所有方面。如果你没有一个可以向你解释一切的私人老师，这篇文章为你提供了 10 个网站，专业人士可以在这些网站上扮演这个老师的角色，帮助你完成编程作业。尤其是在 Python 中。
1。书虫枢纽
BookwormHub 是一群在许多科学领域有资格的专业人士。他们的专业清单包括核心领域，包括数学、化学、生物、统计学和工程作业帮助。然而，它的主要焦点是提供包括 python 在内的编程作业帮助。
订购编程工作的整个组件是一个非常简单明了的过程，包括 4 个步骤:
- 在网站上提交你的学术请求；
- 选择一个你个人最喜欢的合适的专家；
- 在您的专家工作时，跟踪您的订单进度；
- 评价所提供援助的水平。
除了家庭作业服务，BookwormHub 还有一个博客部分，主要致力于 python 语言和包括大量数学的各种科学分支。最重要的是，该网站有一个全天候的客户支持系统。
2。做我的编码
网址:DoMyCoding.com
及时、高质量的专业编程作业帮助的最佳去处之一是 DoMyCoding 网站。这项服务拥有 5 个关键编程领域的专家，他们可以处理和解决任何程度的编程问题。这些字段包括:
- 计算机编程语言
- Java 语言(一种计算机语言，尤用于创建网站)
- C
- 超文本标记语言
- java 描述语言
在你的浏览器书签中加入 DoMyCoding 从来都不是一个坏主意，因为你永远不知道当你将来获得一个具有挑战性的家庭作业项目时，你会遇到什么样的困难。如果你有期末要交的编程作业，这可能会特别有用。
3。分配代码
网址:AssignCode.com
一项名为 AssignCode 的成熟服务可以处理任何复杂程度的编程作业，它的创建是为了保证提高你的 GPA。他们成功的原因是除了编程的 5 个主要分支之外，他们还精通数学、化学、物理、生物和工程。
- 计算机编程语言
- Java Script 语言
- 矩阵实验室
- 超文本标记语言
- 服务器端编程语言（Professional Hypertext Preprocessor 的缩写）
您可以通过滚动专家列表，从 Assign Code 中选择成就和里程碑最符合您个人需求的专家。因此，您将对解决编程问题的过程有更多的控制权。此外，作为客户，如果您对任何订单不满意，该服务的退款保证是您的理想选择。
4。CW 任务
网址:CWAassignments.com
CWAassignments 主要是一个狭隘的编程写作服务网站，为 IT 专业的学生提供家庭作业帮助。就其专业能力而言，它大有可为。以下是他们向编程客户提供的众多产品中的几个类别:
- 计算机编程语言
- Java 语言(一种计算机语言，尤用于创建网站)
- C++
- 服务器端编程语言（Professional Hypertext Preprocessor 的缩写）
- 超文本标记语言
- 结构化查询语言
- java 描述语言
- 计算机科学
- r 编程
- 数据科学
- 计算机网络
除了涵盖与 IT 相关的所有内容，CWAassignments 还提供其他密切相关或无关的主题，如数学、微积分、代数、几何、化学、工程、航空、Excel、金融、会计、管理、护理、视觉基础等。
5。任务核心
网址:AssignmentCore.com
另一个出色的服务是 AssignmentCore，它主要专注于编程帮助，但也可以处理其他领域的写作任务。特别是，它涵盖了建筑和设计，以及商业和管理，工程，数学和自然科学的几个子领域。
具体规划的援助服务清单包括以下几个部分:
- 计算机和网络编程
- 移动应用程序开发
- 计算机网络和网络安全
- 数据科学和分析
与编程关系不大的帮助服务包括:
- 数字设计、UX 和视觉设计
- 数据库设计和优化
- 质量保证和软件测试
6。可爱的编码
网址:LovelyCoding.com
LovelyCoding 的专家们随时准备接受你抛给他们的任何编程问题，想办法解决它们，让整个事情看起来简单、清晰、容易掌握。该服务提供了一个三步质量控制流程和一个持续的客户援助机制。请求流程由三个步骤组成:提交标准、支付费用，以及在任务完成后接收任务。
关于他们的专业，网站分为三个部分的编程帮助。
软件开发帮助
- 系统软件
- 应用软件
- 编程语言
编程帮助
- 计算机编程语言
- Java 语言(一种计算机语言，尤用于创建网站)
- java 描述语言
- C
- C++
- 服务器端编程语言（Professional Hypertext Preprocessor 的缩写）
- Perl 语言
- 红宝石
- HTML 和 CSS
- 数据库ˌ资料库
- 机器学习和研究
项目帮助
- 软件开发
- Web 开发
- 应用程序开发
- 计算机科学
7。FAV 导师
网址:FavTutor.com
FavTutor 是另一个严格意义上的专门面向编程帮助的网站，值得在本文中提及。它与以前网站的主要区别在于它以另一种形式提供帮助。它不是一个任务处理服务，而是一个规程解释服务。
这里有 Java 和 Python 的现场导师，他们会亲自详细解释这个主题。这个过程可以归结为三个步骤:
- 分享你的问题
- 我们指派最好的导师
- 现场和一对一会议
由于实时会议和他们的全天候可用性，您可以在一天中的任何时间与他们的老师联系。除了在线辅导，它还为您提供一套三个完整的编程课程，可以帮助您变得更加知识渊博和 it 独立。
- 数据科学
- 面向初学者的 Python
- Java 编程
8。让我们接触一下
网址:LetsTacle.com
LetsTacle 是一个专门为帮助学生解决大学课程或个人学习过程中可能出现的任何编程问题而创建的网站。它有积极的评论，主要是因为可爱的设计和每个编程领域的高素质专家的数量简单。他们擅长的科目包括:
- 实时编程帮助
- 计算机科学作业帮助
- Python 作业帮助
- Java 家庭作业帮助
- C++家庭作业帮助
- r 家庭作业帮助
- PHP 家庭作业帮助
- HTML 家庭作业帮助
- JavaScript 家庭作业帮助
- SQL 作业帮助
- 做我的编程作业
- Android 分配帮助
除了标准的家庭作业帮助服务包，LetsTacle 还提供文章和学术服务，这是购买个人在线 Python 导师服务的一个选项。
9。作业在线帮助
网址:HomeworkHelpOnline.net
HomeworkHelpOnline 是一个独特的编程家庭作业帮助网站，它为您提供订购完整作业的方式，但它也在自助部分指导您如何自己处理任务。HomeworkHelpOnline 在 4 个方向上工作:
- 物理学
- 数学
- 编程；编排
- 经济学
每个方向都由大量分支组成。编程包括以下内容:
- R /统计
- 计算机编程语言
- 矩阵实验室
- Java 语言（一种计算机语言，尤用于创建网站）
- 擅长
- 接近
- SQL 数据库
- 神经网络
- C/C++/C#
10。所有作业帮助
网址:AllAssignmentHelp.com
学术辅助网站 AllassignmentHelp 专注于几个数学相关和 IT 相关的学科。除了帮助完成包括 Python 编程在内的任务，该网站还提供了许多有用的工具和资源。列表中的资源包括:
- 博客
- 免费样品
- 题库
- 学院课程
此外，它还提供参考生成器、字数统计、语法检查和免费剽窃报告等资源。所有这些对任何类型的学术写作都非常有帮助和有益。
使用 Python 的五大工作
原文：https://www.askpython.com/python/top-5-jobs-that-use-python
你在考虑学习 Python 吗？你想知道每周投入的数百小时是否值得吗？有多少工作机会需要使用 Python？它们真的像人们声称的那样有利可图吗？我必须单独使用 Python 才能成为顶级程序员吗？所有这些涉及与编程平台的使用相关联的职业选择的问题将很快被讨论。我们开始吧！
Python Jobs
1.Python 开发者
对于那些花费大量时间练习编程语言的人来说，成为 Python 开发人员是最好的职业选择之一。自从几年前技术集成的价值上升以来，Python 开发人员的职位在组织中几乎是不可避免的。公司为 Python 开发人员提供了现成的工作，使他们的前端和后端开发保持最新。
Python 编程给你一份负责优化数据算法的工作——主要是从头开始创建后端和前端功能。Python 开发人员拥有解决主要数据分析问题和管理一般数据安全的技能。凭借出色的 Python 编程技能，你可以领导一个前端开发团队。独自负责保证高性能和更快的响应速度。
2.软件工程师
作为一名经验丰富的 Python 开发人员，你也可以扩展你的操作范围，从而在软件工程中获得更多的机会。当然，在使用其他操作系统和编程语言时，您需要更加灵活。然而，当您必须通过测试和调试代码来监督项目时，扩展的知识是有回报的。您需要理解 Python 脚本来定位和修复代码中的错误。
“丰富的 Python 知识让软件工程师在浏览其他编程语言时毫无压力，”—papersowl.com的首席数据科学作家 John Smith 解释道。这份工作也让你负责代码文档，这需要你跟踪项目的细节。像 C++和 Java 这样的其他语言会更好，因为你需要它们来编译、监控和修复数据。
3.数据科学家
数据科学家主要从事结构化和非结构化数据的分析工作。然而今天，在统计学、计算机科学和数学方面的知识有助于获得高价值的个人资料。数据科学家在需要数据提取、分析和处理的组织中工作，以设计结构化模型来实现可操作的计划。他们还帮助管理机器学习程序的数据。
数据科学领域的 Python 工作需要对数据管理有正确的理解，以便准确使用 Python 的丰富功能。仅在过去十年中，对数据科学家的需求就已经超出合理怀疑的范围。如今，成为一名使用 Python 的专业人士可能会让你跻身于世界上薪酬最高的数据科学家之列。现在学 Python，大学毕业拿到 13 万美元的工资中位数，还不晚。
4.数据分析师
网上看的、看的、听的一切都是以数据为基础的。无论您在互联网上创建或消费任何规模的信息，数据都会被无缝地整理和存储。数据专家通过互联网整理数据，以解码模式和含义。然后，这些信息被用于公司的优势，以创建更加用户友好的服务内容。
Python 提供了强大的分析和报告功能，使得数据分析变得轻而易举。该编程平台可以轻松定位互联网上的数据模式、趋势和搜索峰值，并给出清晰的信息报告。他们在所有行业工作，包括金融、银行、医疗保健、汽车、零售商店等。作为一名 Python 开发人员，您的分析技能使您的服务在各种工作中都受到欢迎。
5.机器学习工程师
当今科技界另一个高需求的 Python 工作描述是将数据输入机器。我们现在让机器学习并应用这些知识来创造看似不可能的成就，并取得了证明的结果。机器依赖于统计数据，主要是由 Python 程序员编译并输入系统的数据。像脸书、网飞和亚马逊这样的领先网站使用机器学习来运营。
所有物联网产品都使用人工智能来提供我们今天看到的惊人结果。人工智能是机器学习的一个方面，它允许系统整理用户偏心数据，以获得更好的用户体验。Python 在数据自动化方面的分析特性使编程平台成为将数据整合到机器中的完美工具。理想情况下，它是实现数据科学最有效的工具之一。
结论
还有其他工作机会，比如成为产品经理、教育家或财务顾问，来利用你的 Python 库。Python 作为一个编程平台并不仅仅意味着计算机程序员。如今，销售人员、金融分析师和数字营销专业人士对 Python 课程的需求激增。这些字段需要使用 Python 的分析要素和结果。
值得庆幸的是，要成为一名熟练的 Python 用户，你不必经过哥伦比亚大学这样的高等院校。有高质量的在线 Python 训练营和课程来获得最好的辅导和指导技巧。Python 编程为准备让世界变得更美好的专业人士提供了许多职业机会。即使在大学里，你也可以开始练习产生重大影响。现在就开始！
Python 在现实世界中的 10 大应用
原文：https://www.askpython.com/python/top-applications-of-python
今天我们来谈谈 Python 的顶级应用。Python 简单易学。这种语言促进了应用程序原型的快速开发，因为它的语法简单明了，调试功能强大。
Python 的顶级应用
Python 支持多平台操作系统，这使得应用程序的构建和实现更加容易。一些广为人知的平台有 DropBox、Instagram 等。
现在，让我们来看看 Python 的应用。
1。网络开发
- Python 可以用来快速开发各种 web 应用。
- 用 Python 开发一个 web 应用程序要容易得多，因为它提供了许多框架——参见 Flask 和 Django
- Python 框架以其确定性、可靠性和灵活性著称。
- 这些网络框架简化了诸如内容管理、数据、通信和链接到互联网进程(如 HTTP、SMTP、XML、FTP、POP 和 JSON)的任务
2。桌面图形用户界面应用程序
- Python 不仅拥有与英语相似的语法，还将架构格式和功能整合到许多操作系统中。
- 这些特性与它们丰富的文本处理工具相结合，使 Python 成为构建基于桌面的 GUI 应用程序的绝佳选择。
- Python 提供的一些库有 wxWidgets、PYQT 或 Pyside、Kivy 和 Tkinter 。
推荐阅读——Top 5 Python GUI 库
3 软件开发
- 从最简单的程序到为机器学习和人工智能解决问题的复杂数学脚本，Python 全都做了。
- 这就是为什么软件开发人员使用 Python 作为支持语言来控制构建、测试和管理。
4。商业应用
- 商业级软件或商业计划明显不同于标准应用程序，因为它们需要可伸缩、可扩展和易读的应用程序，而这正是 Python 所提供的。
- 由于业务应用程序是在考虑到组织的操作模型的定制需求的情况下开发的，所以整个开发过程变得很复杂。这就是 Python 可以发挥重要作用的地方。
Python 用于业务应用开发的一些工具有:
- Odoo，一款一体化的管理软件，构建了一套完整的业务管理应用。
- Tryton 是一个三层、高级、通用的应用程序平台，是另一个创建业务应用程序的神奇工具。
5。基于音频或视频的应用
- 我们使用 Python 开发可以处理多媒体的应用程序。
- TimPlayer、Cplay 等视频和音频应用程序都是使用 Python 库构建的。
- 与其他媒体播放器相比，它们提供了更好的稳定性和性能。
- 几个多媒体库有:Gstreamer，Pyglet，QT Phonon
6。游戏开发
- Python 打包了许多有用的扩展，有利于开发交互式游戏。
- 例如， PyGame 和 PySoy(一个支持 Python 3 的 3D 游戏引擎)等库就是两个广泛用于游戏开发的基于 Python 的库。
- Python 是流行游戏的基础，如《战地 2》、《坦克世界》、《织女星打击》和《文明 4》。
- 除了游戏开发之外，游戏创作者还可以使用 Python 来开发这种机制，这将简化许多具体的操作，如关卡设计等。
7。数学和科学应用
- Python 广泛的库基础已经成为计算机科学中的重要工具。
- Python 提供了各种科学和数学库，这使得解决许多复杂问题变得更加容易。
下面提到了一些用于科学和数字应用的流行 Python 框架/包:
8。机器学习和人工智能
- AI 和 ML 的模型和项目自然不同于传统的软件模型。
- 当涉及到 AI/ML 项目时，所使用的工具和技术以及所需的技能与标准软件项目的构建完全不同。
- Python 拥有开发人员创建人工智能算法所需的所有功能，因此，Python 已经成为数据科学专家最流行的语言之一。
Python 的简单性、一致性、平台独立性、大量知识丰富的库和工作社区使其成为开发 AI 和 ML 程序的理想工具。一些最好的 Python AI 和 ML 包是:
- 用于通用数据分析的熊猫
- Keras, TensorFlow, and Scikit-learn for ML
- 高级计算科学
9。教育计划和培训课程
- 如果有任何编程语言，首先，它是 Python。
- Python 简单的学习曲线和简单性是它成为教育项目中使用最广泛的语言之一的两个重要原因，无论是在小学还是在大学。
10。语言发展
- 多年来，Python 设计和模块开发一直是许多编程语言(如 Boo、Swift、Coffee-Script、Cobra 和 OCaml)开发的驱动力。
- 由于对象模型、语法和缩进等原因，所有这些语言都与 Python 有许多相似之处。
最后的话…
在了解了所有这些丰富多样的应用程序之后，可以有把握地得出结论，Python 能够管理几乎任何开发需求。
在过去的几年里，Python 程序在数据科学领域也获得了新的发展空间，尤其是在机器学习领域。
Python 的 5 大最佳 ide
原文：https://www.askpython.com/python/top-best-ides-for-python
我们 AskPython 热爱这门语言！Python 是我们的最爱，今天我们将讨论 Python 的最佳 ide。作为一名程序员，我们花了太多时间在文本编辑器或 IDE 上，我们需要它成为最适合我们需求的。
因此，在开始列出 ide 之前，让我们先回答两个简单的问题。
什么是 Python IDE，我们为什么需要它？
IDE 代表集成开发环境，是一个功能丰富的软件工具，配有调试器。它们具有自动完成的特性，允许轻松编码，因此使它们成为沉重的包。ide 比文本编辑器需要更多的系统资源，占用更多的内存。
文本编辑器与 IDE 有什么不同？
文本编辑器是 IDE 的简化版本，占用较少的内存空间，用户可以安装必要的插件来简化编码和提高性能。因此，代码编辑器更适合不太先进的机器。
Python 的 5 大最佳 ide
这里有一个最好的 Python IDEs 的快速列表:
-
py charm IDE-最流行的 Python IDE！
-
崇高的文本(Sublime Text)–一个可扩展的文本编辑器，可以在文本编辑器中轻松运行 Python 脚本
-
VS 代码–微软开发的代码编辑器是 Python 的完美 IDE。它非常光滑，非常稳定，而且非常轻便。
-
Atom 编辑器–另一个非常可扩展的文本编辑器，完全有能力成为 Python 的最佳 IDE。非常光滑和现代的界面与美丽的主题。
-
VIM 编辑器——这是给 Python 爱好者的。这是一个基于命令行的文本编辑器，具有高度的可定制性，超过了列表中的其他编辑器。它有一个入门的学习曲线。
1.PyCharm IDE——最流行的 Python IDE
PyCharm IDE
PyCharm 是专门为 Python 开发设计的 IDE。尽管它与其他语言兼容，但它对于处理 Python 代码以及 Python 模块和像 Django 这样的框架非常强大。它使用 PEP8 风格的动态编码验证建议，并与 Anaconda 和其他版本控制系统无缝集成。
与 VS 代码编辑器非常相似，它也是一个强大的调试器。它有能力安装各种插件和软件包。
PyCharm 提供的数据库和服务器连接特性非常通用和高效。
PyCharm 的一个缺点是使用了大量的系统资源，从而使其成为一个沉重的 IDE。它在索引文件时停止加载。
PyCharm 有两个版本，即社区版和专业版。然而，对于新开发人员，我们建议使用社区版，因为它是免费的，在各种网站上都有大量的支持。
PyCharm 可在https://www.jetbrains.com/pycharm/download/下载
2.sublime Text——Python 的最佳文本编辑器集成开发环境
Sublime Text
Sublime Text 是一个轻量级编辑器，用于小型项目和一些轻量级脚本。用户界面简单，简约，直观，容易适应程序员。它非常快，很少遇到任何问题。
软件包控制功能允许安装必要的插件。这确保了仅由用户挑选并应用于工作空间的附加组件，并因此确保了用户不会被任何其他附加组件及其建议分散注意力。
编辑器可在https://www.sublimetext.com/下载
3.VS 代码——微软为 Python 和其他语言开发了 IDE
Visual Studio Code By Microsoft
VS Code 是微软公司维护的一个 IDE，并不断获得许多附加特性。与其他 IDE 相比，它是一个轻量级的 IDE。它包括一个调试器和一个内置的编译器和解释器。
由于兼容每一种编程语言，许多程序员更喜欢 VS 代码用于 web 开发和更大的项目。
用户界面非常好，尽管许多用户觉得它过于拥挤。然而 Python 不是 VS 代码中的默认语言，需要安装在编辑器上才能得到支持。
此外，VS 代码包含 Zen 模式，它将完整模式的 IDE 变成了一个极简编辑器。
IDE 可在https://code.visualstudio.com/download下载
4.atom——一个现代化的文本编辑器，有许多插件来增加功能
Atom Editor
Atom 是一个时尚、轻量级的编辑器，受到很多开发人员的喜爱。这是免费的，易于安装。它最初由 GitHub 开发，包含许多插件，可以用来实现类似 IDE 的功能。
用户界面非常好，默认设置下不会占用很多系统资源。Atom 是高度可定制的，并带有许多插件。对于新手来说是一个很棒的选择。对于 Atom，您可能会错过的一个特性是调试器
atom 编辑器可在https://atom.io/下载
5.Vim 编辑器 Python 的最佳 CLI 文本编辑器，具有高度的可定制性
Vim Editor
Vim 是一个非常轻量级但非常强大的命令行文本编辑器。它可以在任何操作系统上运行。它也可以从命令行打开和使用。Vim 有强大的键盘快捷键，但定制有限。
它有大量可用的插件。VIm 的一个警告是其陡峭的学习曲线！对于许多只想开始使用 Python 脚本的程序员来说，这可能是一个障碍。
但是对于爱好者、黑客和极客来说，这个文本编辑器可以满足你对文本编辑器的所有需求，甚至更多！
Vim 编辑器可在https://www.vim.org/download.php下载
我们的裁决
我们喜欢所有这 5 个！但是作为一群完全的 Python 爱好者，我们大多数人坚持将 VIM 作为 Python 代码的首选编辑器/解释器。
如果您喜欢 GUI，我强烈建议尝试一下 Atom。它非常漂亮，你实际上想继续使用它，只是因为它看起来如此光滑。
最后，如果您想让 Python 编程开箱即用，PyCharm 是您的最佳选择。
最后…
仅此而已。是的，这是一个很短的列表，但是我们只想列出那些我们个人在团队中使用过的编辑器或 ide。我们非常喜欢所有这些 IDEs 编辑器，尤其是 Atom 和 VIm。
但是现在聚光灯对准了你。你最喜欢的 Python IDE 是什么？请在下面的评论中告诉我们！
Python:顶级机器学习库
原文：https://www.askpython.com/python-modules/top-best-machine-learning-libraries
你好，初学者！你是机器学习爱好者吗？
机器学习让你兴奋吗？！如果你的答案是肯定的，那么你一定知道我下面列出的库。
Library 1: Python Keras
模块的目的
Keras 是一个开源库，主要用于在 CPU 和 GPU 上实现深度学习概念和模型。它主要用于以更快更有效的方式实现神经网络。
优势
- 它能够直接、快速和有效地实现深度神经网络。
- 它还支持 TensorFlow 的大多数核心库(python 中的另一个库)
- 它也带来了巨大的社区支持。
不足之处
- 有时，它的用户友好性甚至使它在 GPU 上运行缓慢。
- Keras 中的错误日志很难调试，这有时会很烦人。
程式库 2: Python Matplotlib
模块的目的
Matplotlib 库主要用于图像、各种类型的绘图和图像的可视化。它不受平台限制，可以在 Windows、Mac OS 和 Linux 网络上运行。
Matplotlib 已经成为与 Python 编程语言一起使用最广泛的图形库之一，用于数字和数据图形绘制。
优势
- 这是一个开源库，这意味着人们不需要通过游戏来获得使用该库的许可
- 这是一个非常可定制和可扩展的库
- 非常便携。
要深入图书馆，请查看本教程。
库 3: Python NLTK
模块的目的
NLTK 是最受欢迎的用于教育和研究目的的图书馆之一。这是精确文本分析的最佳选择之一。
该库附带了许多预先训练好的模型和语料库(大量数据)，这使得数据分析对我们来说更加容易。
优势
- 与 Python 中的其他库相比，该库支持更多的语言
- 在 NLTK 下，Python 程序员可以使用各种各样的开源 NLP 库
不足之处
- 它是缓慢的，最初难以使用和理解
- 不支持神经网络实现
要深入了解图书馆，请查看下面提到的教程:
库 4: Python NumPy
模块的目的
NumPy 代表 Numerical Python，它帮助程序员以数组的形式有效地存储和处理大量数据。这是一个开源库，你可以免费使用。
优势
- 与列表和元组相比，占用更少的内存空间和运行速度。
- 非常适合数据分析
- 支持阵列上的复杂操作
不足之处
- 对于 numpy 数组来说，插入和删除操作的成本会很高
- 处理 NaN(非数字)值
要快速了解 numpy 模块的实现，请点击这里查看教程右侧的。
库 5: 熊猫
模块的目的
Pandas library 负责处理数据加载、处理和分析，包括数据集的加载、准备、操作、建模和分析。这是一个非常灵活和高效的库。
优势
- 用更少的代码完成更多的结果
- 使用熊猫可以有效处理大量数据
不足之处
- 熊猫的一些指令比其他指令更复杂
- 有一个非常陡峭的学习曲线
要从 pandas 模块实现开始，请点击这里查看教程右侧。
库 6: Scikit-Learn
模块的目的
Sklearn 或 scikit-learn 库是最有用的开源库之一，可用于在 Python 中实现机器学习模型。一些模型包括回归、分类、维数减少和聚类。
优势
- 使用方便
- 非常通用和方便
- 提供详细的 API 文档
不足之处
这个库并不是深度学习算法的最佳选择。
Library 7: TensorFlow
模块的目的
Tensorflow 是 Google 构建和开发的开源机器学习框架。它提供了一种抽象和高级的方法，用于在低级上安排计算编程。
该库还包括支持库，可以允许我们的软件在常规 CPU 上运行而无需更改。它也受到各种设备的支持。
优势
- 更好的图形表示
- 可扩展且高效
- 出色的社区支持
- 高性能
不足之处
- 很难发现错误，也很难调试
- 非常低的水平，学习曲线很陡
- 找不到对 OpenCL 的支持。
结论
在本文中，您了解了一些用 Python 编写的用于机器学习的顶层库。库/模块有助于程序员避免反复编写一些代码。
敬请期待阅读更多！
感谢您的阅读！
6 种编程语言将在 2021 年占据主导地位
原文：https://www.askpython.com/python/top-best-programming-languages-dominate
我们生活在一个相当不可预测的时代，然而，编程行业仍然相当稳定，我们已经可以看到今年的编程趋势。让我们仔细看看最有可能在 2021 年占据主导地位的 6 种编程语言。
让我们开始吧！
2021 年的 6 种主流语言
在这一部分，我们将揭示 6 种相互竞争的编程语言。它们没有特定的顺序，所以如果你看到你最喜欢的语言列在其他语言下面，不要担心。
1.Java 语言(一种计算机语言，尤用于创建网站)
通常，Java 似乎正在离开主屏幕，但是当我们看一下统计数据时，Java 设法在所有其他语言中占据了最高的位置。正如你所知道的，我们在全球有 800 万 Java 开发人员，仅仅这个数字就足以计算出这种编程语言的其余部分。
下面是一些可靠的资源，您可以从中学习 Java 开发:
一个游戏化的交互式 Java 学习平台，拥有 1200 多个任务和一个超级活跃的开发者社区。CodeGym 非常容易理解，通过 500 多个小时的练习，你可以从高质量专家创建的课程中获得你真正期望的东西。
CodeChef 是另一个很好的学习门户，旨在满足有抱负的 Java 开发人员的需求。
- Java 基础知识由 Pluralsight
Pluralsight 提供了一个相当打包的交易，其中包含了 Java 编程语言各个主题的课程。这个平台提供了一种实用的方法，让你理解如何用 Java 编码。
2.计算机编程语言
Python 的 Redmonk 排名真的很例外。当谈到人工智能系统的开发时，Python 是想到的一个，并且肯定会在今年大放异彩。
如果您想学习这种编程语言，请浏览以下资源开始学习:
这确实是一个非常丰富的 Python 学习门户，它提供了一些专题讲座，您可以参与其中并发展所需的技能。如果你在某个地方陷入困境，一个超过 50 万开发人员的庞大社区会帮你摆脱困境。
这一系列的 Python 学习是为了教授和测试您的能力。如果你选择使用这个平台，你会得到代码来猜测输出，这样，你就可以一直提高解决问题的能力。
这个平台的座右铭是“火箭科学用编程，但编程不是火箭科学”！当谈到 Python 相关的东西时，这个在线门户是得天独厚的。
3.我的锅
Kotlin 也被称为 JVM 家族的语言，被广泛用于 Android 编程，对这种语言的普遍看法是非常积极的。特别是由于它能够在各种系统环境中运行，Kotlin 是函数式编程特性和过程式编程特性的完美结合。
想学科特林？请参考以下资源:
如果您已经是一名 Java 开发人员，学习 Kotlin 就像吃一块馅饼一样简单！等你注册了“面向 Java 开发人员的 Kotlin”课程，你就能亲眼看到了。
到目前为止，您已经知道 Kotlin 与 Java 有些关系。记住这一点，这个完整的开发者课程将告诉你两种语言之间的细微差别。如果你想充分利用你的编程生涯，一定要报名参加这个课程。
顾名思义，这门课程从科特林的基础开始教你。您将了解导致高级 Kotlin 初始阶段的基本结构、构造、循环和变量。
4.迅速发生的
iOS 移动开发者需求的快速增长，让 Swift 语言的图形暴涨。它基本上是由苹果公司推出的，你可以掌握它，开始作为一名 iOS 开发人员的职业生涯。以下是您可以用来掌握这门语言的资源:
本课程将通过让您了解 Swift 基础知识，让您掌握创建与增强现实领域相关的应用的艺术。通过苹果新的 ARKit 框架，你还将学习如何利用机器学习来使用 AR。
- iOS 12 & Swift 5 — App 设计、UI/UX Plus 开发
Udemy 的这门课程是最热门的销售课程之一。这是一个 3 合 1 的一揽子交易，在这个交易中，你将学习 iOS 应用程序的设计、开发和 UI/UX。
- iOS 11 & Swift 4 —完整的 iOS 应用开发训练营
这是另一门很棒的课程，提供了大量学习 iOS 应用程序的整个 SDLC 的机会。从通向高级知识的基础开始，你将学习关于 iOS 框架范例和应用程序开发的一切。
5.C/C++
毫无疑问，C/C++是最古老的编程语言之一，但它们从未失去可信度和可用性。事实上，这两种语言都是当今流行的许多高级编程语言的基础。
以下是一些可以用来学习这些语言的资源:
- Udemy: C 和 C++编程:分步教程
使用本教程启动您的学习过程将在许多方面对您有所帮助，因为它从非常基础的代码示例开始，并以超越数据结构的方式结束。
- Udemy: C，C++，Java 面向初学者的编程大词典
这是一门相当复杂的课程，如果你已经对这些语言中的每一种有了基本的了解，你就应该去学。本课程充满了互动环节，讲师将让您参与到积极的学习训练营中。
- Udemy: 掌握 C++编程——从零到英雄
你需要上这门课，因为它是基础知识、中间概念和高级数据结构的混合计算。要跟上这门课的进度，你需要做的就是在教学过程中保持警惕。
6.JavaScript (JS)
如果有一个奖项颁发给一种如此通用的语言，它现在涵盖了后端和前端，JS 将会是最终的赢家。JavaScript 用包括 React、Vue.js 和 Angular 在内的前端框架和包括 Node.js 和 Electron.js 在内的后端框架杀死了它！
当学习 JS 在队列中时，以下资源是必须遵循的:
- Udemy: 现代 JavaScript 从头开始
凭借 4.7 星的评级和超过 11，000 名满意的 JS 学习者，该课程无疑是最优秀的课程之一。它有大约 22 小时的点播视频和 100 多个可下载的视频。有了这门课程，你可以很容易地理清你的 JS 概念，成为一名狂热的 JS 程序员。
- Udemy: JavaScript:理解奇怪的部分
本课程大约有 12 个小时的点播视频讲座，可以自学完成。此外，它还包括 7 篇关于这个主题的文章和 50 多篇资源丰富的下载资料。然而，给你一个额外的建议是，如果你对 JS 有中等水平的了解，就报名参加这个课程，只有这样，它才会让你受益。
- Udemy: 高级 JavaScript 概念
到目前为止，我们相信您已经完成了基础知识，现在您希望掌握更高级的概念。“高级 JavaScript 概念”课程包括 24 小时的点播视频讲座、24 篇关于该主题的可下载文章以及其他可靠资源，利用这些资源，您可以成为发展迅速的受尊敬的学习者社区的一员。
包扎
既然我们已经列出了将在 2021 年占主导地位的 6 种编程语言，那么我们就把选择哪种语言的决定权交给你了！做出最好的决定，继续学习这门语言，今天就开始学习吧！
前 5 名最佳 Python GUI 库
原文：https://www.askpython.com/python-modules/top-best-python-gui-libraries
在本文中，我们将介绍可以在项目中使用的前 5 个 Python GUI 库。请继续阅读，了解它们。
什么是图形用户界面？
GUI 或图形用户界面是一种交互式环境，用于在各种情况下(如表单、文档、测试等)接收用户的响应。它为用户提供了一个比传统命令行界面(CLI)更好的交互式屏幕。
最佳 Python GUI 库列表
让我们进入正题，看看 Python 的顶级 GUI 库。
1.PyQT5
PyQT5 是 Python 的图形用户界面(GUI)框架。它在开发人员中很受欢迎，GUI 可以通过编码或 QT 设计器来创建。QT 开发框架是一个可视化框架，允许拖放小部件来构建用户界面。
它是一个免费的开源绑定软件，是为跨平台应用开发框架而实现的。在 Windows、Mac、Android、Linux、树莓 PI 上使用。
对于 PyQT5 的安装，您可以使用以下命令:
pip install pyqt5
这里演示了一个简单的代码:
from PyQt5.QtWidgets import QApplication, QMainWindow
import sys
class Window(QMainWindow):
def __init__(self):
super().__init__()
self.setGeometry(300, 300, 600, 400)
self.setWindowTitle("PyQt5 window")
self.show()
app = QApplication(sys.argv)
window = Window()
sys.exit(app.exec_())
上述代码的输出如下:
PyQt5
ScienceSoft 的团队 Python 开发者 强调了使用 PyQt 的好处:
PyQt 是一套成熟的 Python 绑定到 Qt，用于桌面应用的跨平台开发。它提供了丰富的内置小部件和工具，用于定制小部件的创建，以形成复杂的 GUI，以及强大的 SQL 数据库支持，以连接到数据库并与之交互。
2.Python Tkinter
另一个 GUI 框架叫做 Tkinter 。Tkinter 是用于开发桌面应用程序的最流行的 Python GUI 库之一。它是 TK 和 python 标准 GUI 框架的组合。
Tkinter 提供了各种各样的小部件，比如在图形用户界面应用程序中使用的标签、按钮、文本框、复选框。
按钮控件小部件用于显示和开发应用程序，而画布小部件用于绘制线条、多边形、矩形等形状。在应用程序中。再者，Tkinter 是 Python 内置的库，不需要像其他 GUI 框架一样安装。下面给出了一个使用 Tkinter 编码的例子。
from tkinter import *
class Root(Tk):
def __init__(self):
super(Root,self).__init__()
self.title("Python Tkinter")
self.minsize(500,400)
root = Root()
root.mainloop()
上述代码的输出如下所示:
Tkinter
3.PySide 2
我们将要讨论的第三个 Python GUI 库是 PySide2，或者你可以称之为 Python 的 QT。Qt for Python 提供了 Qt 的官方 Python 绑定(PySide2)，支持在 Python 应用程序中使用其 API，以及一个绑定生成器工具(Shiboken2)，可用于将 C++项目公开到 Python 中。
Python 的 Qt 可以在 LGPLv3/GPLv3 和 Qt 商业许可下获得。
现在让我向您展示安装过程和一个例子。因此，对于安装，您可以简单地使用:
pip install PySide2
下面是一个使用 PySide2 建立 GUI 框架的例子。
from PySide2.QtWidgets import QtWidgets, QApplication
import sys
class Window(QtWidgets):
def __init__(self):
super().__init__()
self.setWindowTitle("Pyside2 Window")
self.setGeometry(300,300,500,400)
app = QApplication(sys.argv)
window=Window()
window.show()
app.exec_()
上述代码的输出如下所示:
Pyside2
4. Kivy
我们将要讨论的另一个 GUI 框架叫做 Kivy。Kivy 是一个开源 Python 库，用于快速开发利用创新用户界面的应用程序，如多点触摸应用程序。
Kivy 可以在 Linux、Windows、OS X、Android、iOS 和 Raspberry Pi 上运行。您可以在所有支持的平台上运行相同的代码。它可以本机使用大多数输入，协议和设备，包括 WM_Touch，WM_Pen，Mac OS X 触控板和 Magic Mouse，Mtdev，Linux 内核 HID。
在麻省理工学院的许可下，Kivy 可以 100%免费使用。
该工具包是专业开发、支持和使用的。你可以在商业产品中使用它。该框架是稳定的，有一个记录良好的 API，外加一个编程指南来帮助您入门。
Kivy 的图形引擎是在 OpenGL ES 2 上构建的，使用了一个现代化的快速图形管道。
该工具包附带了 20 多个小部件，都是高度可扩展的。许多部分都是使用 Cython 用 C 语言编写的，并用回归测试进行了测试。
来到 Kivy 的安装，需要安装依赖项“glew”。您可以使用如下的 pip 命令:
pip install docutils pygments pypiwin32 kivy.deps.sdl2 kivy.deps.glew
输入这个命令并按回车键，它将被安装。之后，您需要键入以下命令来安装 Kivy:
pip install Kivy
所以在安装之后，让我给你看一个简单的 Kivy 的例子来说明它有多简单。
from kivy.app import App
from kivy.uix.button import Button
class TestApp(App):
def build(self):
return Button(text= " Hello Kivy World ")
TestApp().run()
上述代码的输出如下所示:
Kivy
5.wxPython
所以我们要讨论的最后一个 GUI 框架是 wxPython。wxPython 是 Python 编程语言的跨平台 GUI 工具包。
它允许 Python 程序员简单方便地创建具有健壮、高功能图形用户界面的程序。它是作为一组 Python 扩展模块实现的，这些模块包装了流行的 wxWidgets 跨平台库的 GUI 组件，该库是用 C++编写的。
与 Python 和 wxWidgets 一样，wxPython 也是开源的。
wxPython 是一个跨平台的工具包。这意味着同一个程序无需修改就可以在多个平台上运行。目前，支持的平台是微软视窗系统，苹果 OS X 和苹果操作系统，以及 Linux。
现在，我将向您展示安装过程，并创建一个简单的示例。因此，对于安装，只需键入以下命令:
pip install wxPython
这里有一个例子:
import wx
class MyFrame(wx.Frame):
def __init__(self,parent,title):
super(MyFrame,self).__init__(parent,title=title,size=(400,300))
self.panel=MyPanel(self)
class MyPanel(wx.Panel):
def __init__(self,parent):
super(MyPanel,self).__init__(parent)
class MyApp(wx.App):
def OnInit(self):
self.frame=MyFrame(parent=None, title= "wxPython Window")
self.frame.show()
return True
app = MyApp()
app.MainLoop()
上述代码的输出如下所示:
WxPython
结论
现在我们已经看到了 5 个 Python GUI 库，在我看来，PySide2 和 pyQt5 是更强大的 GUI 框架。但是它们有商业许可证，这解释了为什么它们功能丰富。Tkinter、Kivy 和 wxPython 是 Python 的免费 GUI 库。
Python 中你最喜欢的 GUI 库是什么？
你必须知道的 Python 中的 5 大机器学习算法
原文：https://www.askpython.com/python/examples/top-machine-learning-algorithms
下面是五个最适合初学者的机器学习算法。机器学习已经发展到用复杂的方法解决当前挑战的最流行的方法。
算法 1:神经网络
我们最优秀的成就之一是一个 人工神经网络 。如图所示，我们开发了一个节点网络，这些节点相互连接，类似于我们大脑中的神经元。
通俗地说，每个神经元从另一个神经元接收信息，进行处理，然后作为输出发送给另一个神经元。
Neural Network Demonstration
每个圆形节点代表一个人工神经元，每个箭头象征一个神经元的输出和另一个神经元的输入之间的联系。
神经网络不是预测购买或出售决策，而是在用于发现不同资产类别之间的相互依赖性时更有效。
如果你想了解更多关于神经网络的知识，请查看下面提到的教程:
算法 2:朴素贝叶斯
朴素贝叶斯分类器 是一个众所周知的概率分类器，可以区分众多项目。
由于其速度和精度，它以其实时分类而闻名。贝叶斯定理主要确定事件发生的可能性。
Naive Bayes Demonstration
预测测试数据集的种类既简单又快捷。它还擅长多类预测。
由于其优越的数学方法，朴素贝叶斯模型易于实现，并且对于非常大的数据集特别有用。
由于其实时分类的能力，该方法优于另一种算法。
如果你想了解更多关于朴素贝叶斯的知识，请参考下面的教程:
算法 3: K 均值聚类
这些机器学习算法的目的是基于数据点的相似性来标记数据点。因此，我们在运行该方法之前没有定义集群；相反，算法在运行时会发现这些聚类。
KMeans Demonstration
k-均值聚类可能对那些相信不同资产之间可能存在表面上看不到的共性的交易者有利。
如果您想了解更多关于 KMeans 的知识，请查看下面提到的教程:
算法 4:逻辑回归
对于二元分类，逻辑回归是最适合的。逻辑回归是 f(x)= 1/(1+ex)的函数。这个函数是一个衰减的指数函数，最大值为 1。
Logistic Regression Demonstration
回归的基本目标是识别最佳系数。我们可以用这些系数来减少结果中的误差。
算法 5:主成分分析
通过减少变量，主成分分析(PCA)用于使数据更容易分析和显示。
在一个新的坐标系中捕捉数据的最大方差，该坐标系的轴称为“主分量”每个正交分量都是原始变量的线性组合。
成员之间正交性的存在意味着这些组件之间没有相关性。
第一个主成分捕获了数据中最大的变化量。第二个主成分代表数据中的剩余变量，但包含与第一个无关的变量。
类似地，所有随后的主成分捕获剩余的变化，同时保持与先前的成分无关。
结论
恭喜你！您刚刚了解了 Python 编程语言中最值得学习的 5 种机器学习算法。希望你喜欢它！😇
感谢您抽出时间！希望你学到了新的东西！！😄
如果你想了解更多关于逻辑回归的知识，请查看下面提到的教程:
将 WordPress 网站转换成移动应用的顶级插件
原文：https://www.askpython.com/python/top-plugins-to-convert-a-wordpress-site-into-a-mobile-app
你想把你的 WP 网站转换成应用程序吗？你可以选择一个 WP 应用插件来帮助你做到这一点，而不必支付昂贵的开发费用。
在这篇文章中，我们将详细讨论八个最好的 WordPress 应用构建器插件，它们为你的 WordPress 站点提供了两种不同类型的应用:
- 原生 app 是大多数人听到 app 这个词想到的。你的访问者通过他们设备上的应用商店下载它。
- 渐进式网络应用程序允许在网站上与访问者互动，而无需安装自己的应用程序。访问者仍然可以在他们的主屏幕上添加这样的应用程序，并且你可以启用离线功能和推送通知。
在我们进入插件列表之前，重要的是要提到，即使是特殊插件的使用也只能委托给专业人员。如果你的网站是由 WordPress 开发者团队开发的，那么最好也把插件的工作委托给 pros。
1.app presser——Android 和 iOS 的原生应用
AppPresser 是最著名的 WordPress 应用程序创建工具之一。它是这样工作的:使用单独的 AppPresser 应用程序接口创建应用程序。然后你使用 WordPress 上的一个免费插件，通过 REST API 将你的 WordPress 站点连接到 AppPresser。这个连接允许你同步你的应用程序数据和你的 WP 站点。
AppPresser 拥有比你能找到的许多其他插件更深入的功能。它特别支持以下插件:
- Woocommerce，
- 巴迪出版社，
- LearnDash。
该插件还允许您:
- 从你的手机相机里拍照，然后上传到 WordPress。
- 以几种有趣的方式使用地理定位。
- 发送推送通知。
- 通过应用程序登录 WordPress/注册。
总的来说，如果你想为你的用户提供更个性化的体验，AppPresser 是一个很好的选择。
2.WordPress Mobile Pack——用于渐进式网络应用程序
这是一个免费的插件，可以很容易地把你的 WP 网站变成一个进步的网络应用程序。WordPress Mobile Pack 附带了几个主题，可以快速建立一个设计美观的网站。您可以选择应用程序中应包含哪些内容，以及是否从 Google Ad Manager 添加广告。
总的来说，如果您想快速、轻松地创建一个优秀的渐进式 web 应用程序，这是一个不错的选择。虽然 WordPress.org 上有一个基本的免费版本，但您可能需要付费版本，因为它将提供:
- 更多可用主题，
- 弹出通知，
- 离线模式，
- HTTPS 支持。
3.Android app——Android 和 iOS 的本地应用
它非常擅长组织本地应用。而且，尽管名字如此，它在 Android 和 iOS 上都可以做到。您可以从几个应用程序主题中进行选择，您的应用程序可能包括:
- 弹出通知，
- 通过 Admob 或 Appnext 货币化，
- 社会交换，
- 评论支持，
- 无尽滚动。
在定制应用程序时，你有相当多的选择，包括包含你自己代码的空间。然而，这个插件不提供像 AppPresser 这样的内置集成。
4.超级渐进式网络应用
正如你从名字中可以猜到的，超级渐进式网络应用程序是一个很好的工具，可以将你的 WP 网站转换成渐进式网络应用程序。
这很容易设置:
- 选择多种颜色，
- 选择起始页，
- 选择一个方向。
如果你需要更多的功能，两个免费的插件可以让你添加 UTM 跟踪和安装苹果触摸图标。
5.WP-app kit——灵活的本地或渐进式 Web 应用
WP-AppKit 提供功能集成，让你最大限度地控制你的应用程序的工作方式。如果您正在寻找即插即用的解决方案，这不是一个好的选择。但是，如果你想定制你的应用程序的功能，并控制它显示的信息，WP-AppKit 给了你正确的控制水平。
例如，当您要构建应用程序时，您将能够添加单个组件，然后将这些组件添加到菜单中。组件可以是页面、文章类型等。如果您是开发人员，您可以使用钩子创建自己的组件。
除了您在上面看到的免费功能之外，还有两个付费附加组件:
- 谷歌分析整合，
- Pushwoosh 用于推送通知。
这个插件肯定更侧重于开发者和有经验的用户。但是如果那是你想要的，试着掌握这个提供更多控制的好插件。
6.WAP press/iwapp press—Android 和 iOS 的原生应用
Wapppress 和 iWappPress 是来自同一个开发者的两个插件。如果你一起使用它们，这允许你为 Android 和 iOS 创建本地应用。
两者的独特卖点是创建一键式应用程序。换句话说，他们可以把你的 WordPress 站点变成一个本地应用，而不需要任何技术知识或者详细的配置。它们都是 CodeCanyon 的优质解决方案。他们有详细的演示，您可以在做出选择之前使用。
您只需运行一些基本的配置选项，单击一个按钮，然后等待应用程序被创建。其他功能包括:
- 弹出通知，
- 在 Google AdMob 中整合广告，
- 多个应用程序主题可供选择。
7.MobiLoud——WordPress 应用构建器服务
根据创建者的说法，MobiLoud 是“一个专门为 WordPress 设计的应用创建服务。”这并不便宜，但服务包括:
- App 创作，
- 在应用程序商店中发布应用程序，
- 应用支持。
所以，如果你不想深究将 WP 网站转换成应用的细节，这可能是你的一个好选择。你只是为了方便而付钱！
8.frontity——为高流量网站定制的 WordPress 渐进式网络应用程序
Frontity 肯定不适合所有人，因为他们只接受最低流量的网站。但是，如果你是一个大型网站的所有者，并且想开发一个 WordPress 渐进式网络应用程序，这可能是一个不错的选择。
我们希望上述推荐的应用程序中至少有一个能够满足您的需求和期望。
软件开发人员的首要生产力技巧
原文：https://www.askpython.com/python/top-productivity-tips-for-software-developers
软件行业是一个价值数万亿美元的行业，并且每年都在呈指数级增长。各种软件产品和服务都有机会。一个软件的生命周期从几天到几年甚至几十年，这使得它成为投资和在这个行业中获利的最佳选择。
此外，在这个信息技术的时代，任何企业都不能远离软件。软件行业是最具竞争力的，因为它直接与其他公司竞争，以更低的成本提供更好的服务和产品。竞争意味着开发者的工作机会。公司也拥抱软件并建立创新中心，投资创业公司，或外包应用程序开发。
因此，如果你想加入这个行业，你需要比联盟中的其他人更聪明，更快，更有成效。
所以，为了帮助你，这里有一些提高效率的技巧，比如打字速度，快捷方式等等。，可以将您的编程提升到一个新的水平。
五大生产力技巧
软件开发不是一件容易处理的任务；有时会变得很激烈，让你感到筋疲力尽。但是如果你的生产力达到标准，你可以把自己从这样的低谷中拯救出来。
所以，不浪费任何时间，让我们深入研究这 10 个能提高你工作效率的技巧。
开始编码前的大纲
在写一段代码之前，你必须计划好你将如何构建你的软件。它不仅能帮助你编写代码，还能帮助你更好地理解项目。
所以，养成一个习惯，拿起你的铅笔，勾勒出你将要做什么和如何做。坚持设计，尽善尽美及时完成工作。
利用键盘快捷键
使用键盘快捷键可以在编程过程中为您节省大量时间，因为它减少了鼠标移动和点击，这在编码时通常需要时间。如果你想掌握这些快捷方式，建议你经常练习。
以下是大多数人使用的一些通用快捷方式:
- Windows 键+ R :运行命令提示符。
- Ctrl+S :保存你的工作。
- Ctrl+T :在浏览器中打开一个新标签页。
- Ctrl + Z :撤销你之前犯下的任何错误。
- Esc 键:取消当前流程，关闭窗口。
- Home 键:转到一行的开头。
- 结束键:转到一行的末尾。
- Ctrl + A: 选择当前屏幕或窗口中的所有内容。
更多类似这样的键盘快捷键可以节省你的时间，提高生产力，让你在软件开发工作中更加轻松。
使用触摸打字技术提高打字速度
触摸打字是一种不用看键盘就能在键盘上打字的方式。这种方法有助于避免在出现重要事情时看键盘，以及在你必须赶去开会但不小心按了“caps lock”而不是“shift”时看键盘，等等。
初学者掌握这项技术需要时间，所以在使用它之前，请确保您经常练习。
使用自动化
作为一名开发人员，你应该使用自动化工具来自动化重复的任务，以迅速完成工作，而不会出现任何问题。
自动化您经常做的活动，例如命令行、文本操作、日志挖掘、重构、构建、部署和集成。如果在开始时，您自动执行重复性的、需要很多时间才能完成的任务，那么您可以节省很多时间。
了解如何用任何流行的编程语言(如 Ruby、Python 或 JavaScript)创建自动化脚本。一开始这可能会令人生畏，但是掌握这种才能会让你在以后的职业生涯中受益。
马上使用批处理
批处理是在时间紧迫的情况下，利用计算机能力进行软件开发，同时完成多项任务的一种方式。在开始编码之前计划好你想做什么总是好的，因为如果计划得好，这种方法可以极大地提高你的生产率。这将帮助你节省时间，这些时间可以用在其他地方，以尽早完成项目。
下次当您试图分析许多数据源的结果时，使用一个脚本来自动化这个过程。
改变你的环境
有时，即使是最好的开发人员也很难为他们代码中的问题开发解决方案。其中一个选择是通过参与其他活动来改变你的环境。例如，如果你在办公室，打打乒乓球或者尝试不同的活动，比如和同事聊聊天。
如果你在家工作，你可能有有限的选择来转移对代码的注意力。然而，你可以搬到一家咖啡店，改变你的环境，和一些人聊天。简单拿着笔记本电脑，看看风景的变化是否会给你一个新的视角。然而，你不应该在像咖啡店这样的地方连接免费的无线网络。网络可能缺乏保护，导致你的数据泄露给附近窥探的个人。
幸运的是，有一个选项可以连接到任何网络而不用担心。用于计算机的 VPN 是保护您数据安全的有效解决方案。它加密互联网流量，确保您的请求保持安全，即使您连接到一个可疑的网络。因此，你可以选择在任何地方工作，随心所欲地改变场景。
结论
对于软件开发人员来说，这些是最好的生产力提示，无论你是刚从大学毕业准备开始职业生涯的人，还是经验丰富的老手，都可以使用它们。应用这些工作习惯可以丰富你的工作质量，有助于增加利润。
自然语言处理的 5 大 Python 库
原文：https://www.askpython.com/python/top-python-libraries-for-natural-language-processing
自然语言处理(NLP) 是 数据科学 和 人工智能 的交叉领域。它旨在理解人类语言的语义和内涵。
它的主要重点是从文本中找到有意义的信息，下一步是根据获得的见解训练数据模型。NLP 函数广泛用于文本挖掘、文本分类、文本分析、情感分析、语音识别和机器翻译。
这一切之所以成为可能，只是因为 Python 中提供了大量的 NLP 库。所有库的基本目标是正确地将自由文本句子转换成结构化特征，并且它必须能够有效地实现最新的算法和模型。
因此，在本文中，我们将介绍在解决现实世界问题时非常有用的 5 大自然语言库和工具。
也读:顶级机器学习库
Python 的顶级自然语言处理库
现在让我们来探索一下 Python 可用的 5 个不同的 NLP 库，它们可用于文本生成和训练。您甚至可以使用这些来创建 Python 中的聊天机器人。
1.自然语言工具包(NLTK)
它是构建 Python 程序的重要库之一，使我们能够处理人类语言数据并从中获得洞察力。
它为 50 多个语料库(用于语言研究的大量书面或口头文本)和词汇资产(如 WordNet)提供了简单的接口。
NLTK 还帮助建立文本预处理库，用于 NLP 库和主动对话讨论的标记、解析、分类、词干、标记化和语义推理包装器。
NLTK 是免费和开源的。Windows、Mac OS 和 Linux 都可以轻松访问它。由于功能范围很广，所以速度很慢，有时很难满足生产使用的需求。
NLTK的特点包括词性标注、实体抽取、分词、解析、语义推理、词干、文本分类。
安装
pip install nltk
2. Gensim
Gensim 是一个非常流行的自然语言处理作品库。它具有通过使用向量空间建模来识别两个文档之间的语义相似性的特殊特征。它的算法与内存无关，这意味着我们可以很容易地处理大于 RAM 的输入。
它是为“大型语料库(用于语言研究的大量书面或口头文本的集合)的主题建模、文档索引和相似性检索”而设计的。它广泛用于数据分析、文本生成应用和语义搜索应用。它给了我们一套在自然语言作品中非常重要的算法。
gensim 的一些算法是分层狄利克雷过程(HDP)、随机投影(RP)、潜在狄利克雷分配(LDA)、潜在语义分析(LSA/SVD/LSI)或 word2vec 深度学习。
安装
pip install — upgrade gensim
3.酷睿 NLP
Standford CoreNLP 包含一组人类语言技术工具。CoreNLP 旨在使使用语义分析工具对一段文本的分析变得简单而熟练。在 CoreNLP 的帮助下，你可以提取所有类型的文本属性(如命名实体识别、词性标注等。)只用了几行代码。
由于 CoreNLP 是用 java 编写的，所以需要在你的设备上安装 Java。然而，它确实提供了许多流行编程语言的编程接口，包括 Python。它整合了许多 Standford 的 NLP 工具，如解析器、情感分析、引导模式学习、命名实体识别器(NER)和共指解析系统、词性标记器等等。
此外，CoreNLP 支持除英语、中文、德语、法语、西班牙语和阿拉伯语之外的四种语言。
安装
pip install stanfordnlp
4.空间
SpaCy 是一个开源的 Python 自然语言处理库。它是专门为解决现实世界中的问题而设计的，它有助于处理大量的文本数据。它配备了预先训练的统计模型和词向量，并且 SpaCy 是在 Cython 中用 python 编写的(Cython 语言是 Python 语言的超集)，这就是为什么它在处理大量文本数据时更快更有效。
SpaCy 的主要特点是:
- 它提供了像伯特一样的训练有素的变形金刚。
- 提供超过 49 种语言的标记化。
- 提供文本分类、句子分割、词汇化、词性标注、命名实体识别等功能。
- 它比其他库快得多。
- 它可以对文本进行预处理，用于深度学习。
- 它拥有超过 17 种语言的 55 条训练有素的管道。
安装(以及依赖关系)
pip install –U setuptools wheel
pip install –U spacy
python -m spacy download en_core_web_sm
5.图案
Pattern 是 Python 中一个非常有用的库，可以用来实现自然语言处理任务。它是开源的，任何人都可以免费使用。它可以用于 NLP、文本挖掘、web 挖掘、网络分析和机器学习。
它附带了一系列用于数据挖掘的工具(谷歌、维基百科 API、网络爬虫和 HTML DOM 解析器)、NLP (n-gram 搜索、情感分析、WordNet、词性标签)、ML(向量空间模型、聚类、SVM)以及具有图形中心性和可视化的网络分析。
对于科学和非科学的观众来说，这是一个非常强大的工具。它的语法非常简单明了，最棒的是函数名和参数的选择方式使得命令一目了然，它还可以作为 web 开发人员的快速开发框架。
安装
pip install pattern
结论
在本文中，我们浏览了自然语言处理中最常用的 5 个 python 库，并讨论了根据我们的需求何时必须使用哪个库。我希望你能从这个博客中学到一些东西，这对你的项目来说是最好的。
参考
https://medium . com/nl planet/awesome-NLP-21-popular-NLP-libraries-of-2022-2e 07a 914248 b
进一步阅读
使用 LSA 的主题建模:完全指南
原文：https://www.askpython.com/python/examples/topic-modeling-using-lsa
对于今天和明天越来越智能的应用程序来说，开发一个无缝的人机交互界面始终是一个关键问题。
自然语言处理(NLP)是一项先进的技术，它衍生了我们现在看到的许多形式的人工智能。
谈到 NLP，主题建模是其最重要的主题之一。在本文中，让我们试着理解什么是主题建模，以及如何用 python 语言实现它。
什么是主题建模？
NLP 的主题建模技术用于从一组文档的文本中推断它们是关于什么的。它的工作原理是扫描一组文档，识别其中的单词和短语模式，然后自动聚类最能描述一组文档的单词组和相关短语。它发现隐藏的模式或数据分组。
在本文中，让我们尝试使用潜在语义分析(LSA)算法来实现主题建模。但是在我们开始实施之前，让我们先了解一下 LSA 的概念。
还可以使用潜在的狄利克雷分配(LDA)来实现主题建模。要了解更多信息，请阅读 Python 中的 潜在狄利克雷分配(LDA)算法
什么是 LSA？
一种在自然语言处理中使用的技术，称为潜在语义分析(LSA)，特别是分布式语义，通过使用统计创建与文档和术语相关的概念集合来评估文档集合和它们所包括的术语之间的联系。它通常用于文本分析领域中的数据聚类和数据收集。
概念搜索和自动文档分类也是 LSA 的两个主要用途。这是一种无监督的学习方法，这意味着有一个特定的目标要实现，或者没有标签或标记被分配。潜在语义分析的目标是根据这些主题或潜在特征产生文本数据的表示。
潜伏这个词本身就意味着隐藏。我们关注的是潜在的(隐藏的)或数据本身固有的任何东西。作为其副产品，我们将能够减少原始的基于文本的数据收集的维度。
LSA 是如何工作的？
潜在语义分析的工作主要包括四个步骤。第二个和第三个更重要，也更难理解。步骤如下所示
- 收集原始文本数据
- 生成文档术语矩阵
- 执行奇异值分解(SVD)
- 检查主题编码数据
收集原始文本数据
主题建模产生的数据总是文本格式的。所提供的输入通常是文档的集合。为了理解这个概念，下面给出一个例子。但是当在实际项目中工作时，数据通常来自各种公开来源，如社交媒体、报告等。
- 文献 1 :世界上最小的国家
- 文件二 :世界上最大的国家。
- 文献 3 :我国最大的城市。
- 文献 4 :世界上最小的城市。
Implementation
文档术语矩阵
文档术语矩阵是一个数学矩阵，它表示术语在一组文档中出现的频率。在文档-术语矩阵中，列代表集合中的术语，行代表集合中的文档。该矩阵是文档-特征矩阵的示例，其中“特征”可以不仅仅与文档中的术语相关。
另一种常见的格式是转置，或术语-文档矩阵，其中术语是行，文档是列。文档术语矩阵背后的基本概念是，文本文档可以表示为欧几里得空间中的点，也称为向量。
让我们通过一个例子来理解这个概念，
Implementation
在这里，使用 Scikit-Learn，我们已经将一直在分析的四个文档定义为一个列表中的四个字符串。计数矢量器模型可用于生成文档术语矩阵。如您所见，我们从 Scikit-Learn 特征提取点文本模块中导入了计数矢量器。
在创建了计数矢量器之后，我们拟合并转换我们的身体为一个单词集合。当我们在自然语言处理中使用短语“单词包”时，我们指的是文档术语矩阵的最基本应用。
奇异值分解
奇异值分解(SVD)是一种数学方法，用于将一大段文本压缩成一个矩阵，每个文档有字数(行代表唯一的单词，列代表每个文档)。这种技术减少了行数，同时保持了列之间的相似结构。
由列形成的任何两个向量所产生的角度的余弦然后被用于比较文档，这是由两个向量的归一化所形成的点积。接近 1 的值表示文档非常相似，而接近 0 的值表示文档非常不同。
与主成分分析类似，奇异值分解如果你熟悉这种统计方法，使用潜在语义分析用这些潜在特征编码原始数据集将最小化其维数。这些潜在特征对应于原始文本数据的主题。
下一步是执行我们的奇异值分解；这可以使用 Scikit-Learn 的模型的截断 SVD 来完成。我们从 SK learn 分解中导入截断的 SVD，并使用它来拟合，然后将单词包转换为我们的 LSA。“截断”这个词指的是这样一个事实，我们不会得到和开始时一样多的向量。
Implementation
主题编码数据
这旨在将我们的原始数据转换成主题编码的数据。数据现在应该由两列组成，每列代表我们从截断的 SVD 请求的两个主题中的一个，回想一下这个值 2 作为参数传递给截断的 SVD。
为了查看我们 LSA 的结果，我们将使用 熊猫库 。在这里，我们可以看到开始时的四个原始文档，以及两个主题中每个主题的数值。第一和第四个文档大约是最大的位置，而第二和第三个文档大约是最小的位置。
请注意，所有四个文档在主题一中都很强，但在主题二中，第二个和第三个文档以及第一个和第四个文档之间有明显的区别。
Implementation
LSA 的副产品
潜在语义分析的一大好处是，它会产生一些副产品，可以帮助我们理解每个主题编码的是什么，我们要看的两个副产品是:
字典—字典是至少在一个文档体中出现的所有单词的集合。
编码矩阵—编码矩阵用于将文档编码成主题编码的表示形式，通过检查可以更好地理解每个主题所代表的内容。
Implementation
让我们看一下作为拟合计数矢量器模型的属性的字典，可以使用获取特征名称方法来访问它。我们可以检查这个矩阵来获得对身体潜在主题的理解。让我们看看这个编码矩阵，其中每行代表我们字典中的一个单词，每列代表我们两个主题中的一个，数值可以被认为是给定主题中该单词的表达式。
接下来，我们将解释我们可能感兴趣的编码矩阵，每个主题的热门词是什么，或者词空间的哪些维度解释了大部分差异。在数据中，请注意，我们将需要查看主题中每个单词表达的绝对值，当我们解释主题时，具有强烈负面表征的单词与具有强烈正面图像的单词一样重要。
让我们看看主题一，你可以看到最重要的单词是单词，但在后面的视频中，我们会删除像这样没有太多意义的单词。让我们看看题目二，你可以看到最重要的两个词是最大和最小，但让我们看看最初的计算。
我们可以看到，最大是非常积极的，而最小是非常消极的，这告诉我们，主题 2 将是一个很好的主题，可以帮助我们表示该文档是最大的还是最小的。
Implementation
Implementation
摘要
主题建模用于文本挖掘，在本文中，我们已经了解了它的实现使用潜在语义分配。
Python 中的汉诺塔:完整的分步
原文：https://www.askpython.com/python/examples/tower-of-hanoi-in-python
汉诺塔是一个数学问题(难题),由 3 根柱子和 n 个圆盘组成，每个圆盘有不同的直径。
汉诺塔问题的目标
这个问题的目的或目标是将所有的“n”个盘从源极转移到目的极，以这样的方式，我们得到与以前相同的盘排列。但是这个目标必须通过坚持规则来实现。
规则和约束
解决问题时必须满足的约束条件是
- 一次只能移动一张光盘。
- 只能取出最上面的光盘
- 较大的光盘不能放在较小的光盘上面。
汉诺塔问题的可视化表示
下图显示了河内塔的分步解决方案，该塔有 3 个极点(源点、中间点和目的点)和 3 个圆盘。目标是将所有 3 个圆盘从 A 极移动到 c 极。
从上面的解决方案中我们可以看到，3 个圆盘所需的移动次数= 8。因此，我们需要的总移动次数的通用公式是:
总移动次数= n²–1
其中“n”是光盘的总数。
用 Python 解决汉诺塔问题
def TowerOfHanoi(n , s_pole, d_pole, i_pole):
if n == 1:
print("Move disc 1 from pole",s_pole,"to pole",d_pole)
return
TowerOfHanoi(n-1, s_pole, i_pole, d_pole)
print("Move disc",n,"from pole",s_pole,"to pole",d_pole)
TowerOfHanoi(n-1, i_pole, d_pole, s_pole)
n = 3
TowerOfHanoi(n, 'A', 'C', 'B')
# A, C, B are the name of poles
在上面的代码中，我们递归地调用函数 TowerOfHanoi 来处理 3 个磁盘。
这里:
- s 极:源极
- i_pole:中间极点
- d_pole:目的极
上面代码的输出是:
结论
这就是我们解决汉诺塔问题的方法。
这个代码可以推广到任何数量的光盘。因此，如果您想要 4 个光盘的解决方案，只需在 n = 4 时将 n 的值从 3 更改为 4，输出将显示为 4 个光盘，依此类推。
理解 Python 中的回溯
原文：https://www.askpython.com/python/examples/tracebacks-in-python
Traceback 是 Python 提供的消息或信息或带有一些数据的一般报告，帮助我们了解程序中发生的错误。专业术语也叫 养异常 。对于任何开发工作，错误处理都是编写程序时的关键部分之一。因此，处理错误的第一步是了解我们在代码中会遇到的最常见的错误。
回溯为我们提供了大量的信息和一些关于运行程序时发生的错误的消息。因此，对最常见的错误有一个大致的了解是非常重要的。
也读作:Python 中更容易调试的技巧
回溯通常被称为某些其他名称，如 栈跟踪 、回溯或栈回溯。堆栈是所有编程语言中的一个抽象概念，它只是指系统内存或处理器内核中的一个位置，在那里指令被逐个执行。每当在检查代码时出现错误，回溯会试图告诉我们位置以及在执行这些指令时遇到的错误类型。
Python 中一些最常见的回溯
这里列出了我们在 Python 中遇到的最常见的回溯。随着本文的深入，我们还将尝试理解这些错误的一般含义。
- 句法误差
- NameError
- 索引错误
- TypeError
- 属性错误
- KeyError
- ValueError
- module 找不到和导入错误
Python 中回溯的概述
在讨论最常见的回溯类型之前，让我们试着了解一下一般堆栈跟踪的结构。
# defining a function
def multiply(num1, num2):
result = num1 * num2
print(results)
# calling the function
multiply(10, 2)
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 6, in <module>
multiply(10, 2)
File "d:\Python\traceback.py", line 3, in multiply
print(results)
NameError: name 'results' is not defined. Did you mean: 'result'?
解释:
Python 正试图帮助我们，给我们关于在执行程序时发生的错误的所有信息。输出的最后一行说这应该是一个名称错误，甚至建议我们一个解决方案。 Python 也试图告诉我们可能是错误来源的行号。
我们可以看到我们的代码中有一个变量名不匹配。我们没有使用 "result" ，正如我们之前在代码中声明的那样，我们编写了 "results "，，在执行程序时抛出一个错误。
所以，这是 Python 中回溯的一般结构层次，这也意味着 Python 回溯应该自底向上读取，这在大多数其他编程语言中不是这样。
了解回溯
1.语法错误
所有编程语言都有其特定的语法。如果我们错过了那个语法，程序将抛出一个错误。代码必须首先被解析，然后它将给出我们想要的输出。因此，我们必须确保它正确运行的正确语法。
让我们试着看看 Python 引发的 SyntaxError 异常。
# defining a function
def multiply(num1, num2):
result = num1 * num2
print "result"
# calling the function
multiply(10, 2)
输出:
File "d:\Python\traceback.py", line 4
print "result"
^^^^^^^^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?
解释:
当我们试图运行上面的代码时，我们看到 Python 引发了一个 SyntaxError 异常。要在 Python3.x 中打印输出，我们需要用括号将它括起来。我们也可以看到错误的位置，在我们的错误下面显示“^”符号。
2. NameError
在编写任何程序时，我们都要声明变量、函数和类，还要将模块导入其中。当在我们的程序中使用这些时，我们需要确保声明的东西应该被正确引用。相反，如果我们犯了某种错误，Python 会抛出一个错误并引发一个异常。
让我们看一个 Python 中的 NameError 的例子。
# defining a function
def multiply(num1, num2):
result = num1 * num2
print(result)
# calling the function
multipli(10, 2)
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 8, in <module>
multipli(10, 2)
NameError: name 'multipli' is not defined. Did you mean: 'multiply'?
解释:
我们的回溯表明名字“multiplie”没有定义，是一个名字错误。我们没有定义变量、【乘数】、，因此出现了错误。
3.索引错误
使用索引是 Python 中一种非常常见的模式。我们必须迭代 Python 中的各种数据结构来对它们执行操作。索引表示数据结构的顺序，例如列表或元组。每当我们试图从数据结构中不存在的系列或序列中检索某种索引数据时，Python 都会抛出一个错误，指出我们的代码中有一个 IndexError 。
让我们看一个例子。
# declaring a list
my_list = ["apple", "orange", "banana", "mango"]
# Getting the element at the index 5 from our list
print(my_list[5])
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 5, in <module>
print(my_list[5])
IndexError: list index out of range
解释:
我们的回溯表明在第 5 行有一个 IndexError 。从堆栈跟踪中可以明显看出，我们的列表在索引 5 处不包含任何元素，因此超出了范围。
4. TypeError
当试图执行一个操作或使用一个函数时，Python 抛出一个 TypeError 错误类型的对象被一起用于该操作。
让我们看一个例子。
# declaring variables
first_num = 10
second_num = "15"
# Printing the sum
my_sum = first_num + second_num
print(my_sum)
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 6, in <module>
my_sum = first_num + second_num
TypeError: unsupported operand type(s) for +: 'int' and 'str'
解释:
在我们的代码中，我们试图计算两个数的和。但是 Python 抛出了一个异常，说第 6 行的操作数“+”有一个类型错误。堆栈跟踪告诉我们添加一个整数和一个字符串是无效的，因为它们的类型不匹配。
5.属性错误
每当我们试图访问一个特定对象上不可用的属性时，Python 就会抛出一个属性错误。
我们来看一个例子。
# declaring a tuple
my_tuple = (1, 2, 3, 4)
# Trying to append an element to our tuple
my_tuple.append(5)
# Print the result
print(my_tuple)
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 5, in <module>
my_tuple.append(5)
AttributeError: 'tuple' object has no attribute 'append'
解释:
Python 说第 5 行的对象“元组”有一个 AttributeError 。由于 元组是不可变的数据结构 ，我们试图对其使用“追加”方法。因此，这里有一个由 Python 引发的异常。Tuple 对象没有属性“append ”,因为我们试图改变它，这在 Python 中是不允许的。
6. KeyError
字典是 Python 中的另一种数据结构。我们在程序中一直使用它。它由键:值对组成，我们需要在任何需要的时候访问这些键和值。但是，如果我们试图在字典中搜索一个不存在的键，会发生什么呢？
让我们尝试使用一个不存在的键，看看 Python 对此有什么说法。
# dictionary
my_dict = {"name": "John", "age": 54, "job": "Programmer"}
# Trying to access info from our dictionary object
get_info = my_dict["email"]
# Print the result
print(get_info)
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 5, in <module>
get_info = my_dict["email"]
KeyError: 'email'
解释:
在上面的例子中，我们试图访问关键字" email "的值。嗯，Python 在我们的 dictionary 对象中搜索了关键字“email ”,并使用堆栈跟踪引发了一个异常。回溯说，在我们程序的第 5 行有一个键错误。在指定的对象中找不到提供的键，因此出现错误。
7. ValueError
每当指定的数据类型中有不正确的值时，Python 就会引发 ValueError 异常。提供的参数的数据类型可能是正确的，但是如果它不是一个合适的值，Python 将会抛出一个错误。
让我们看一个例子。
import math
# Variable declaration
my_num = -16
# Check the data type
print(f"The data type is: {type(my_num)}") # The data type is: <class 'int'>
# Trying to get the square root of our number
my_sqrt = math.sqrt(my_num)
# Print the result
print(my_sqrt)
输出:
The data type is: <class 'int'>
Traceback (most recent call last):
File "d:\Python\traceback.py", line 10, in <module>
my_sqrt = math.sqrt(my_num)
ValueError: math domain error
解释:
在上面的例子中，我们试图使用 Python 中内置的数学模块来得到一个数的平方根。我们使用正确的数据类型“int”作为函数的参数，但是 Python 抛出了一个带有 ValueError 的回溯作为例外。
这是因为我们不能得到一个负数的平方根，因此，这是一个不正确的参数值，Python 在第 10 行告诉我们这个错误是一个 ValueError 。
8.ImportError 和 ModuleNotFoundError
当导入不存在的特定模块出错时，Python 会引发 ImportError 异常。当模块的指定路径无效或不正确时，ModuleNotFound 作为异常出现。
让我们来看看这些错误是如何发生的。
导入错误示例:
# Import statement
from math import addition
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 2, in <module>
from math import addition
ImportError: cannot import name 'addition' from 'math' (unknown location)
ModuleNotFoundError Example:
import addition
输出:
Traceback (most recent call last):
File "d:\Python\traceback.py", line 1, in <module>
import addition
ModuleNotFoundError: No module named 'addition'
解释:
ModuleNotFoundError 是 ImportError 的子类，因为它们输出相似类型的错误，并且可以使用 Python 中的 try 和 except 块来避免。
摘要
在本文中，我们讨论了在编写 Python 代码时遇到的最常见的错误或回溯类型。对于所有级别的开发人员来说，在我们编写的任何程序中犯错误或引入 bug 都是很常见的。Python 是一种非常流行、用户友好且易于使用的语言，它有一些很棒的内置工具，可以在我们开发东西时尽可能地帮助我们。回溯是这些工具中的一个很好的例子，也是学习 Python 时需要理解的一个基本概念。
参考
用 Python 追踪冠状病毒统计数据的简单方法
原文：https://www.askpython.com/python/examples/track-corona-virus-statistics-in-python
在本教程中，我们将使用 COVID19Py 库来跟踪 Python 中的 Corona 病毒统计数据。
大家好！我们正在经历这个困难时期，尽我们所能帮助我们周围的人是有意义的。作为程序员，您可以帮助传播关于 COVID 病毒的信息，帮助人们找到获得疫苗的地方，等等。
这是一个用 Python 编写的预建的 Corona 病毒统计跟踪器。你所要做的就是安装它，执行某些功能，你就可以访问来自世界各地的信息。所以让我们开始吧。
设置 COVID19Py
Python 安装非常简单。只需在命令提示符下键入 pip 命令。
pip install COVID19Py
在. py 文件中键入以下命令以导入此包:
import COVID19Py
这个包只有一行预处理，使用起来非常简单。
covid19 = COVID19Py.COVID19()
追踪 Python 中的 COVID19 信息
现在我们有了一个 package 对象，我们可以开始使用它的方法了。
使用 getLatest()函数收集关于受影响者、已康复者以及全球死亡人数的最新统计数据。它给你一个字典列表。
L= covid19.getLatest()
print(L)
{'confirmed': 277161199, 'deaths': 5377197, 'recovered': 0}
然后使用 getLocations()函数过滤收集的大量数据。
LS = covid19.getLocations()
print(LS[0])
{'id': 0, 'country': 'Afghanistan', 'country_code': 'AF', 'country_population': 37172386, 'province': '', 'last_updated': '2021-12-23T08:34:35.628637Z', 'coordinates': {'latitude': '33.93911', 'longitude': '67.709953'}, 'latest': {'confirmed': 157841, 'deaths': 7341, 'recovered': 0}}
需要国家代码来查看某个国家的数据。因此，这里有一个简单的方法来获取捆绑包中包含的所有国家代码。
C= {}
for i in locations:
C[i.get('country')] = i.get('country_code')
只需输入这段代码就可以获得印度的统计数据。
code = C.get('India')
india = covid19.getLocationByCountryCode("IN")
for i in india:
print(i.get("latest"))
{'confirmed': 34765976, 'deaths': 478759, 'recovered': 0}
结论
既然你已经掌握了所有的工具，找到你想要的所有数据，这样你就可以比较和对比其他国家的统计数据。
您还可以使用 Google Trends API 来查看 Corona 病毒在整个互联网中的趋势。
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
在 PyTorch 训练你的第一个 GAN
原文：https://www.askpython.com/python-modules/training-gan-in-pytorch
自 2014 年 Goodfellow 成立以来，甘一直是人们谈论的话题。在本教程中，您将学习在 PyTorch 中训练您的第一个 GAN。我们还试图解释 GAN 的内部工作原理，并通过 PyTorch 实现一个简单的 GAN。
要导入的库
我们首先导入将在实现中使用的库和函数。
import torch
from torch import nn
from torchvision import transforms
from torchvision.utils import make_grid
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
from IPython.display import clear_output
什么是甘？
生成网络可以简单地描述为能够从训练数据中学习并生成类似训练数据的数据的网络。设计生成模型有多种方法，其中一种是对抗性的。
在一个生成对抗网络中，有两个子模型——生成器和鉴别器。我们将更详细地研究这些子模型:
1.发电机
顾名思义，生成器的任务是生成图像。
生成器接受小的低维输入(通常是 1-D 向量),并给出 128×128×3 的图像数据作为输出。
这种将低维缩放到高维的操作是使用系列反卷积和卷积层来实现的。
我们的生成器可以被认为是接收低维数据并将其映射到高维图像数据的函数。
在训练期间，生成器学习如何越来越有效地将低维数据映射到高维数据。
生成器的目标是生成一个可以欺骗鉴别器的真实图像。
Fig 1: Working of the Generator
发电机类别:
class Generator(nn.Module):
def __init__(self, z_dim, im_chan, hidden_dim=64):
super().__init__()
self.z_dim = z_dim
self.gen = nn.Sequential(
# We define the generator as stacks of deconvolution layers
# with batch normalization and non-linear activation function
# You can try to play with the values of the layers
nn.ConvTranspose2d(z_dim, 4*hidden_dim, 3, 2),
nn.BatchNorm2d(4*hidden_dim),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(hidden_dim * 4, hidden_dim * 2, 4, 1),
nn.BatchNorm2d(hidden_dim*2),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(hidden_dim * 2, hidden_dim ,3 ,2),
nn.BatchNorm2d(hidden_dim),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(hidden_dim, im_chan, 4, 2),
nn.Tanh()
)
def forward(self, noise):
# Define how the generator computes the output
noise = noise.view(len(noise), self.z_dim, 1, 1)
return self.gen(noise)
# We define a generator with latent dimension 100 and img_dim 1
gen = Generator(100, 1)
print("Composition of the Generator:", end="\n\n")
print(gen)
Compostion of the Generator:
Generator(
(gen): Sequential(
(0): ConvTranspose2d(100, 256, kernel_size=(3, 3), stride=(2, 2))
(1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(2): ReLU(inplace=True)
(3): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(1, 1))
(4): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(5): ReLU(inplace=True)
(6): ConvTranspose2d(128, 64, kernel_size=(3, 3), stride=(2, 2))
(7): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(8): ReLU(inplace=True)
(9): ConvTranspose2d(64, 1, kernel_size=(4, 4), stride=(2, 2))
(10): Tanh()
)
)
补充说明:图像是一个非常高维的数据。即使是 3x128x128 尺寸的 RGB 图像，大小也是 49152。
我们想要的图像存在于这样一个巨大空间的子空间或流形中。
理想情况下，生成器应该学习子空间的位置，并从学习的子空间中随机采样以产生输出。
搜索这个理想子空间是一个计算量非常大的任务，处理这个最常见的方法是使用向前推进将一个潜在向量空间映射到数据空间。
2.鉴别器
我们的鉴别器 D 手头有一个更简单但同样重要的任务。鉴别器是一个二元分类器，它指示输入数据是来自原始源还是来自我们的生成器。一个理想的鉴别器应该把来自原始分布的数据归类为真，把来自 G 的数据归类为假。
Fig 2: Working of the disrciminator
class Discriminator(nn.Module):
def __init__(self, im_chan, hidden_dim=16):
super().__init__()
self.disc = nn.Sequential(
# Discriminator is defined as a stack of
# convolution layers with batch normalization
# and non-linear activations.
nn.Conv2d(im_chan, hidden_dim, 4, 2),
nn.BatchNorm2d(hidden_dim),
nn.LeakyReLU(0.2,inplace=True),
nn.Conv2d(hidden_dim, hidden_dim * 2, 4, 2),
nn.BatchNorm2d(hidden_dim*2),
nn.LeakyReLU(0.2,inplace=True),
nn.Conv2d(hidden_dim*2, 1, 4, 2)
)
def forward(self, image):
disc_pred = self.disc(image)
return disc_pred.view(len(disc_pred), -1)
# We define a discriminator for one class classification
disc = Discriminator(1)
print("Composition of the Discriminator:", end="\n\n")
print(disc)
Composition of the Discriminator:
Discriminator(
(disc): Sequential(
(0): Conv2d(1, 16, kernel_size=(4, 4), stride=(2, 2))
(1): BatchNorm2d(16, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(2): LeakyReLU(negative_slope=0.2, inplace=True)
(3): Conv2d(16, 32, kernel_size=(4, 4), stride=(2, 2))
(4): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(5): LeakyReLU(negative_slope=0.2, inplace=True)
(6): Conv2d(32, 1, kernel_size=(4, 4), stride=(2, 2))
)
Fig 3: Working of the model
GAN 中的损失函数
现在我们定义发生器和鉴频器的损耗。
1.发电机损耗
生成器试图生成图像来欺骗鉴别者，让他们认为这些图像是真实的。
因此，生成器试图最大化将假图像分配给真标签的概率。
所以发生器损失是鉴别器将生成的图像分类为假的期望概率。
def gen_loss(gen, disc, num_images, latent_dim, device):
# Generate the the fake images
noise = random_noise(num_images, latent_dim).to(device)
gen_img = gen(noise)
# Pass through discriminator and find the binary cross entropy loss
disc_gen = disc(gen_img)
gen_loss = Loss(disc_gen, torch.ones_like(disc_gen))
return gen_loss
2.鉴频器损耗
我们希望鉴别器最大化将真标签分配给真实图像的概率，并且最大化将假标签分配给假图像的概率。
类似于发生器损耗，鉴别器损耗是真实图像被分类为假图像和假图像被分类为真实图像的概率。
请注意我们两个模型的损失函数是如何相互作用的。
def disc_loss(gen, disc, real_images, num_images, latent_dim, device):
# Generate the fake images
noise = random_noise(num_images, latent_dim).to(device);
img_gen = gen(noise).detach()
# Pass the real and fake images through discriminator
disc_gen = disc(img_gen)
disc_real = disc(real_images)
# Find loss for the generator and discriminator
gen_loss = Loss(disc_gen, torch.zeros_like(disc_gen))
real_loss = Loss(disc_real, torch.ones_like(disc_real))
# Average over the losses for the discriminator loss
disc_loss = ((gen_loss + real_loss) /2).mean()
return disc_loss
正在加载 MNIST 训练数据集
我们加载了 MNIST 的训练数据。我们将使用火炬视觉包下载所需的数据集。
# Set the batch size
BATCH_SIZE = 512
# Download the data in the Data folder in the directory above the current folder
data_iter = DataLoader(
MNIST('../Data', download=True, transform=transforms.ToTensor()),
batch_size=BATCH_SIZE,
shuffle=True)
初始化模型
设置模型的超参数。
# Set Loss as Binary CrossEntropy with logits
Loss = nn.BCEWithLogitsLoss()
# Set the latent dimension
latent_dim = 100
display_step = 500
# Set the learning rate
lr = 0.0002
# Set the beta_1 and beta_2 for the optimizer
beta_1 = 0.5
beta_2 = 0.999
根据您是否启用了硬件加速，将设备设置为 cpu 或 cuda。
device = "cpu"
if torch.cuda.is_available():
device = "cuda"
device
现在我们初始化生成器、鉴别器和优化器。我们还初始化了层的起始/初始权重。
# Initialize the Generator and the Discriminator along with
# their optimizer gen_opt and disc_opt
# We choose ADAM as the optimizer for both models
gen = Generator(latent_dim, 1).to(device)
gen_opt = torch.optim.Adam(gen.parameters(), lr=lr, betas=(beta_1, beta_2))
disc = Discriminator(1 ).to(device)
disc_opt = torch.optim.Adam(disc.parameters(), lr=lr, betas=(beta_1, beta_2))
# Initialize the weights of the various layers
def weights_init(m):
if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
torch.nn.init.normal_(m.weight, 0.0, 0.02)
if isinstance(m, nn.BatchNorm2d):
torch.nn.init.normal_(m.weight, 0.0, 0.02)
torch.nn.init.constant_(m.bias, 0)
# Apply the initial weights on the generator and discriminator
gen = gen.apply(weights_init)
disc = disc.apply(weights_init)
设置实用功能
我们总是需要一些效用函数，这些函数并不特别适合我们的应用程序，但是可以使我们的一些任务变得更容易。我们使用 torchvision make_grid 函数定义了一个可以在网格中显示图像的函数。
def display_images(image_tensor, num_images=25, size=(1, 28, 28)):
image_unflat = image_tensor.detach().cpu().view(-1, *size)
image_grid = make_grid(image_unflat[:num_images], nrow=5)
plt.imshow(image_grid.permute(1, 2, 0).squeeze())
plt.show()
我们定义一个噪声函数来产生随机噪声，该随机噪声将被用作生成器的输入。
def random_noise(n_samples, z_dim):
return torch.randn(n_samples, z_dim)
PyTorch 中 GAN 的训练循环
# Set the number of epochs
num_epochs = 100
# Set the interval at which generated images will be displayed
display_step = 100
# Inter parameter
itr = 0
for epoch in range(num_epochs):
for images, _ in data_iter:
num_images = len(images)
# Transfer the images to cuda if harware accleration is present
real_images = images.to(device)
# Discriminator step
disc_opt.zero_grad()
D_loss = disc_loss(gen, disc, real_images, num_images, latent_dim, device)
D_loss.backward(retain_graph=True)
disc_opt.step()
# Generator Step
gen_opt.zero_grad()
G_loss = gen_loss(gen, disc, num_images, latent_dim, device)
G_loss.backward(retain_graph=True)
gen_opt.step()
if itr% display_step ==0 :
with torch.no_grad():
# Clear the previous output
clear_output(wait=True)
noise = noise = random_noise(25,latent_dim).to(device)
img = gen(noise)
# Display the generated images
display_images(img)
itr+=1
结果
这些是我们 GAN 的一些结果。
结论
我们已经看到了如何从一组图像中生成新的图像。gan 并不局限于数字的图像。现代的 GANs 足够强大，可以生成真实的人脸。gan 现在被用来创作音乐、艺术等。如果你想了解更多关于 GAN 的工作原理，你可以参考 Goodfellow 的这篇原始的 GAN 论文。
在 Python 中简化调试的技巧
原文：https://www.askpython.com/python/tricks-for-easier-debugging-in-python
即使您编写了干净、高效、可读的代码，并且用单元测试用例很好地覆盖了您的代码，也不可能只编写一次就一直完美地运行它。大多数情况下，bug 是不可避免的，调试是开发人员日常生活的一部分。因此，学习调试技巧将提高您和您的代码的性能和效率。这篇文章向你介绍了一些在 Python 中更容易调试的技巧和工具。
战略
有效调试的第一步也是最重要的一步是识别实际的错误。一旦我们获得了错误的详细信息，我们需要找到错误的位置，分析错误的情况和问题的潜在原因，并解决它。你需要有正确的策略和正确的工具。
调试有几种策略。一个是正向分析，一个是反向分析。
正向分析方法包括在调试器模式下重新运行代码，在可疑行中设置断点，并进行调试。要做正向分析，可以使用 pdb 和 IDE 高效调试。
逆向分析方法包括使用错误发生时从生产环境中收集的日志来跟踪问题。用于进行反向分析的工具，如打印功能、记录器、快照等。，工作。
使用 Lightrun Cloud 这样的工具，可以实现向前和向后分析的结合，以进行实时调试，我们将在本文的后面讨论这一点。
使用这样的工具，开发人员可以在任何类型的应用程序中执行实时调试——整体和遗留应用程序、微服务和分布式系统。通过与 APM 和其他 DevOps 工具集成，开发人员可以访问快照、日志和性能指标，从而识别 bug 并有效解决问题。
使用 Python 调试器(pdb)进行正向分析
如果您允许程序在单步模式下运行，您可以随时检查运行代码的状态。pdb 是 Python 内置的调试器工具。还有一些其他工具，比如 web-pdb，但是在大多数情况下，pdb 已经足够有用了。
要在 pdb 中运行程序，请运行以下命令:
python-m pdb add . py
程序将开始运行第一步。如果您想跳过并运行全部代码，请按 1。要执行下一行，请按 n。这将帮助您理解变量值和执行流程。
如果代码很大，并且希望设置断点，请使用 set_trace 方法:
使用 IDE 调试器进行正向分析
大多数 IDE 都有很多功能，比如设置断点、单步执行、单步进入、继续等。这些命令有助于开发人员高效地进行调试。目前一些适用于 Python 的好的 IDE 有:
JetBrains 的 PyCharm IDE 有一个集成的调试器和测试运行器，以及大量现成的工具。
Visual Studio 代码 : Visual Studio 代码有 Python 对微软 Python 扩展的支持。
如果您正在使用 Windows 10 或 11，并为 Linux 系统构建应用程序， WSL 是进行开发和测试的好方法。Visual Studio 与远程 WSL 扩展和 Python 扩展相结合，使开发人员能够在 WSL 中运行时进行编辑和远程调试。
在少数情况下，不可能重现类似的情景。在这种情况下，向后分析有助于开发人员识别和解决问题。
具有打印/断言功能的反向分析
最简单但功能强大的调试方法是将变量和事件消息打印到控制台，并检查打印的值是预期值还是代码执行中出错了。
为了克服 print 语句中的问题，开发人员可以使用 assert 语句。如果不满足其语句条件，Python 的内置 assert 方法可以引发 AssertionError。
Python 为您提供了在使用 assert 时启用或禁用的灵活性。您可以在运行代码时使用-0 参数来关闭程序中的所有 assert 语句。之后，所有的 assert 方法都将不起作用。
尽管如此，拥有大量的 assert 语句使得代码不可读并且有点混乱。
使用记录器进行反向分析
用 logger 替换所有的 print 语句是调试 log 语句最专业、最强大的方法。对于开发人员来说，它是一个重型武器，因为它给了他们更多的灵活性来启用和禁用。此外，您可以设置日志级别来启用某些日志。
使用 log 语句进行调试的最简单的方法之一是在所有方法中添加 debug 语句。因此，当任何方法被执行时，该方法将记录一个带有参数值的调试语句。开发人员可以使用 decorator 函数在内部记录参数值，而不是在所有方法中编写 log 语句。使用下面的代码片段创建一个装饰函数，并在所有要打印参数的方法前添加@ enable _ args _ debugger。
闪电云
无论应用程序是在云上运行还是在本地运行，是在应用服务器上运行还是在无服务器上运行，或者是容器化的， Lightrun Cloud 都是一款免费工具，可以帮助开发人员轻松识别问题并快速解决问题。它减少了交付时间，增加了实时添加日志或快照的灵活性，而无需更改代码。
使用 Lightrun 日志进行实时调试
在代码发布后添加日志或断言语句是一个繁琐的过程。您可以使用 Lightrun 日志来添加日志，而不是调用 CI/CD 管道来进行几行更改。它允许您在运行时在生产系统上添加任意多的日志。它可以与领先的 ide 集成。有了这个工具，开发人员可以自由地专注于花里胡哨下的核心业务逻辑。
使用 Lightrun 快照进行实时调试
在许多情况下，开发人员很难理解执行流程。如果开发人员有堆栈跟踪和变量，他们很容易理解是否缺少逻辑或者条件执行是否没有按预期工作。Lightrun 快照是虚拟断点，可以在不破坏系统的情况下提取所有数据。
使用 Lightrun，您可以拥有条件快照，与您正在使用的 IDE 集成，并在不破坏系统的情况下添加任意数量的快照。
使用 Lightrun 性能指标进行实时调试
bug 不仅仅是逻辑缺失/错误。它们也可能是瓶颈和长时间的查询。这些与性能相关的错误可以使用 Lightrun 解决。您可以添加性能指标监控和日志示例，计算特定代码的执行次数，测量两次函数执行之间的时间，并收集系统统计信息，如延迟和吞吐量计数器。开发人员和 DevOps 工程师为每种调试策略使用多种工具，如远程调试、日志传送、应用程序性能监控和内存快照。然而，Lightrun Cloud 是一个满足所有开发人员调试需求的地方，包括日志记录、指标和 APM、快照和远程调试。它还与各种 DevOps 工具相集成，从而能够顺利实现其优势。
用 Python 实现 Trie 数据结构
原文：https://www.askpython.com/python/examples/trie-data-structure
数据结构在信息检索方面非常有效。它主要用于实现字典和电话簿。
它对于实现在键盘上键入时看到的自动文本建议也很有用。
在本教程中，我们将了解如何用 Python 实现我们自己的 trie 数据结构。
在本教程中，您将学习以下内容:
- 如何实现你自己的 Trie 数据结构。
- 如何在 Trie 数据结构中插入数据？
- 如何在 Trie 数据结构中查询单词？
实现 TrieNode 类
让我们从编写 TrieNode 类的代码开始。每个 trie 节点需要具有以下字段:
- 一个角色
- 儿童名单
- 一个布尔值，它表明一个单词是否在该节点结束。
让我们为 TrieNode 类编写代码:
class TrieNode:
def __init__(self, char):
self.char = char
self.is_end = False
self.children = {}
初始化 TrieNode 时，我们需要提供一个字符。
。is_end 标记一个字是否在当前节点结束。默认情况下，它被设置为 false。
编写 Trie 数据结构类
让我们继续为我们的 Trie 类编写代码。
要初始化一个 trie，我们需要初始化一个 trie 节点，并提供在 trie 中插入和搜索的方法。
class Trie(object):
def __init__(self):
self.root = TrieNode("")
这部分负责初始化一个空的 TrieNode。
如何在我们的 Trie 中执行插入操作？
让我们看看插入是如何在 Trie 数据结构中发生的。
为了进行插入，我们需要逐个字符地遍历要插入的单词。
同时，我们需要从根开始向下移动 Trie，看看孩子的列表是否有那个字符。如果该字符不存在，那么我们需要用该字符创建一个新的 TrieNode，并将其添加到孩子列表中。
当我们到达单词的末尾时，我们需要为对应于单词最后一个字符的节点设置 is_end 为真。
下面是上面讨论的方法的实现。
def insert(self, word):
node = self.root
#traverse the word character by character
for char in word:
#check if the character is there in the list of children
if char in node.children:
node = node.children[char]
else:
# else make a new TrieNode corresponding to that character
new_node = TrieNode(char)
# add the new node to the list of children
node.children[char] = new_node
node = new_node
#after traversig the word set .is_end to true for the last #char
node.is_end = True
这将照顾我们所有的插入。
考虑一个包含以下单词的 Trie:
- 这里
- 听
- 她
- 男性
- 你好
- 怎么
对应于这些单词的 trie 将如下所示:
Trie
这里的绿色节点对应于该节点的为真。
如何在我们的 Trie 中搜索？
现在让我们看看如何在我们的特里搜索单词。我们不想为搜索执行精确匹配。相反，我们想要的是获得以我们要搜索的字符串开始的单词列表。
在搜索时，我们将只提供前缀，搜索功能应该能够返回以该前缀开始的所有单词。
例如，如果我们搜索“他”，我们应该得到以下单词。
- 男性
- 这里
- 听
- 她
- 你好
这些都是以“他”开头的词。trie 的这一方面使得它对于在键盘中实现自动完成非常有用。
在搜索单词时，我们以 DFS 的方式进行搜索。因此，我们需要编写一个函数，用于在我们的 trie 中执行 DFS 搜索。
def dfs(self, node, pre):
if node.is_end:
self.output.append((pre + node.char))
for child in node.children.values():
self.dfs(child, pre + node.char)
在调用函数时，我们需要传递一个节点和到目前为止搜索到的前缀。每当搜索到达一个节点，并且 为真时，它会将该单词附加到输出列表中。
否则，它继续以 DFS 方式在子节点中搜索。
搜索功能如下:
def search(self, x):
node = self.root
# traverse the search query and move down the trie
for char in x:
if char in node.children:
node = node.children[char]
else:
#if query doesn't match the nodes in trie
return []
self.output = []
#call DFS
self.dfs(node, x[:-1])
return self.output
在搜索时，我们遍历搜索查询并同时向下移动 trie。
然后，我们在与查询的最后一个字符对应的节点上调用 DFS。
然后，DFS 函数从最后一个字符开始向下移动，将所有完整的单词添加到输出列表中。
完全码
本教程的完整代码如下所示:
class TrieNode:
def __init__(self, char):
self.char = char
self.is_end = False
self.children = {}
class Trie(object):
def __init__(self):
self.root = TrieNode("")
def insert(self, word):
node = self.root
for char in word:
if char in node.children:
node = node.children[char]
else:
new_node = TrieNode(char)
node.children[char] = new_node
node = new_node
node.is_end = True
def dfs(self, node, pre):
if node.is_end:
self.output.append((pre + node.char))
for child in node.children.values():
self.dfs(child, pre + node.char)
def search(self, x):
node = self.root
for char in x:
if char in node.children:
node = node.children[char]
else:
return []
self.output = []
self.dfs(node, x[:-1])
return self.output
行动中的尝试
让我们试着向一个 trie 中添加一些单词，并进行搜索查询。
tr = Trie()
tr.insert("here")
tr.insert("hear")
tr.insert("he")
tr.insert("hello")
tr.insert("how ")
tr.insert("her")
这将创建一个 trie，并将这五个单词添加到其中。
现在我们可以使用下面一行进行查询:
tr.search("he")
输出:
['he', 'her', 'here', 'hear', 'hello']
让我们做另一个查询:
tr.search("her")
输出:
['her', 'here']
结论
本教程讲述了 Python 中 Trie 数据结构的实现。我们学习了如何创建一个 trie 类，如何执行插入，以及如何在 Trie 中查询单词。
在 Python 中修剪字符串的 3 种方法
原文：https://www.askpython.com/python/string/trim-a-string-in-python
修剪一个字符串是什么意思，如何在 Python 中修剪一个字符串？当你删除文本字符串周围的空白时，用专业术语来说，我们称之为修剪字符串。在本文中，我们将介绍在 Python 中修剪字符串的 3 种方法。
技巧 1:在 Python 中修剪字符串的 strip()
Python 的string.strip()函数基本上删除了特定字符串中所有的前导以及尾随空格。因此，我们可以使用这个方法在 Python 中完全修剪一个字符串。
语法:
string.strip(character)
character:是一个可选参数。如果传递给 strip()函数，它将从字符串的两端删除特定的传递字符。
举例:
inp_str = " [email protected]"
print("Input String:")
print(inp_str)
res = inp_str.strip()
print("\nString after trimming extra leading and trailing spaces:")
print(res)
输出:
Input String:
[email protected]
String after trimming extra leading and trailing spaces:
[email protected]
例 2:
inp_str = "@@Python [email protected]@@@"
print("Input String:")
print(inp_str)
res = inp_str.strip('@')
print("\nString after trimming extra leading and trailing spaces:")
print(res)
在上面的代码片段中，我们将'@【T1]'作为字符传递给 strip()函数，以便从两端进行修剪。
输出:
Input String:
@@Python [email protected]@@@
String after trimming extra leading and trailing spaces:
Python JournalDev
NumPy strip()方法
Python NumPy 模块内置了numpy.core.defchararray.strip() 方法，其功能类似于 Python string.strip() 函数。
该方法可用于修剪 Python 中嵌入数组或任何其他可迭代对象的字符串。
语法:
numpy.core.char.strip(array, chars=value)
array:需要进行修剪的输入数组。chars:可选参数。如果传递给 numpy.strip()函数，则从数组每个元素的两端修剪特定字符。
举例:
import numpy
arr = numpy.array([' JournalDev', 'Python '])
print("Input Array:")
print(arr)
res = numpy.char.strip(arr)
print("Array after performing strip():")
print(res)
输出:
Input Array:
[' JournalDev' 'Python ']
Array after performing strip():
['JournalDev' 'Python']
例 2:
import numpy
arr = numpy.array([' JournalDev', 'Python '])
print("Input Array:")
print(arr)
res = numpy.char.strip(arr, chars='Python')
print("Array after performing strip():")
print(res)
输出:
Input Array:
[' JournalDev' 'Python ']
Array after performing strip():
[' JournalDev' ' ']
技术 2: Python lstrip()
Python string.lstrip()函数修剪特定输入字符串中的所有前导空格。
语法:
string.lstrip(character)
character:是一个可选参数。如果传递给 lstrip()函数，它将从输入字符串的开头删除特定的传递字符。
举例:
inp_str = " [email protected] **"
print("Input String:")
print(inp_str)
res = inp_str.lstrip()
print("\nString after trimming Extra leading spaces:")
print(res)
输出:
Input String:
[email protected] **
String after trimming Extra leading spaces:
[email protected] **
例题 2:
inp_str = "****[email protected]*"
print("Input String:")
print(inp_str)
res = inp_str.lstrip("*")
print("\nString after trimming Extra leading characters:")
print(res)
如上所示，lstrip()函数只从输入字符串的前导部分的前部开始修剪' ***** '。
输出:
Input String:
****[email protected]*
String after trimming Extra leading characters:
[email protected]*
NumPy lstrip()方法
Python NumPy 模块具有与string.lstrip()函数功能相同的numpy.core.defchararray.lstrip() 方法。
该函数从输入数组的每个元素中删除所有前导空格或特殊字符。
语法:
numpy.char.lstrip(array, chars=value)
例 1:
import numpy
arr = numpy.array(['@@!JournalDev', '@%*Python '])
print("Input Array:")
print(arr)
res = numpy.char.lstrip(arr, chars="!%@*")
print("Array after performing lstrip():")
print(res)
输出:
Input Array:
['@@!JournalDev' '@%*Python ']
Array after performing lstrip():
['JournalDev' 'Python ']
例 2:
import numpy
arr = numpy.array([' JournalDev', ' Python'])
print("Input Array:")
print(arr)
res = numpy.char.lstrip(arr)
print("Array after performing lstrip():")
print(res)
输出:
Input Array:
[' JournalDev' ' Python']
Array after performing lstrip():
['JournalDev' 'Python']
技术 3: Python rstrip()
Python string.rstrip()方法从特定的输入字符串中删除所有的尾随空格。
语法:
string.rstrip(character)
character:是一个可选参数。如果传递给 rstrip()函数，它将从输入字符串的末尾删除传递的字符。
举例:
inp_str = "[email protected] "
print("Input String:")
print(inp_str)
print("Length of Input String:")
print(len(inp_str))
res = inp_str.rstrip()
print("\nString after trimming Extra trailing spaces:")
print(res)
print("Length of Input String after removing extra trailing spaces:")
print(len(res))
我们已经使用了string.len()函数来获得修剪前后的字符串长度。这有助于我们理解末尾多余的空格已经被删除。
输出:
Input String:
[email protected]
Length of Input String:
20
String after trimming Extra trailing spaces:
[email protected]
Length of Input String after removing extra trailing spaces:
17
例 2:
inp_str = "[email protected]****"
print("Input String:")
print(inp_str)
print("Length of Input String:")
print(len(inp_str))
res = inp_str.rstrip("*")
print("\nString after trimming Extra trailing characters:")
print(res)
print("Length of Input String after removing extra trailing spaces:")
print(len(res))
输出:
Input String:
[email protected]****
Length of Input String:
21
String after trimming Extra trailing characters:
[email protected]
Length of Input String after removing extra trailing spaces:
17
NumPy rstrip()方法
Python NumPy 模块有numpy.core.defchararray.rstrip(array, chars)方法从输入数组的每个元素中删除所有尾随空格。
语法:
numpy.char.rstrip(array, chars=value)
举例:
import numpy
arr = numpy.array([' JournalDev ', ' Python '])
print("Input Array:")
print(arr)
res = numpy.char.rstrip(arr)
print("Array after performing rstrip():")
print(res)
输出:
Input Array:
[' JournalDev ' ' Python ']
Array after performing rstrip():
[' JournalDev' ' Python']
例 2:
import numpy
arr = numpy.array([' JournalDev****', ' Python!!'])
print("Input Array:")
print(arr)
res = numpy.char.rstrip(arr, chars="*!")
print("Array after performing rstrip():")
print(res)
在上例中，我们已经通过了' *！到 numpy.rstrip() 的作用是作为要修剪的字符。这些字符从数组的每个元素的后端开始修剪。
输出:
Input Array:
[' JournalDev****' ' Python!!']
Array after performing rstrip():
[' JournalDev' ' Python']
Python 修剪字符串一目了然！
- 在 Python 中，修剪字符串意味着从输入字符串的开头和结尾删除多余的空格或特定的一组字符。
- 在 Python 中可以使用三个内置函数来修剪一个字符串:分别是: strip()、lstrip()、rstrip() 方法。
- pythonstrip . strip()方法从特定字符串的前端和后端删除空格。
- string.lstrip()方法从字符串中移除所有前导空格。
- string.rstrip()方法从一个字符串中删除所有的尾随空格。
结论
因此，在本文中，我们已经了解了在 Python 中修剪字符串的不同方法。
参考
- Python 修剪字符串 JournalDev
使用 Python 将图像转换为 ASCII 艺术
原文：https://www.askpython.com/python/examples/turn-images-to-ascii-art-using-python
在本教程中，我们将学习如何使用 Python 编程语言将任何图像转换为 ASCII 艺术。我相信你听说过 ASCII 艺术，这是一种图形设计技术，使用可打印的 ASCII 字符来显示图像。请看下图中的例子。
Image 3
现在我们清楚了在本教程结束时我们的目标是什么。让我们不要再浪费时间，开始代码实现。
使用 Python 从图像创建 ASCII 艺术作品
在本节中，您将学习如何使用 Python 从图像生成 ASCII 艺术。
加载图像
第一步也是最重要的一步是使用 PIL 库将图像加载到我们的程序中。我们将利用异常处理来确保我们预先处理了错误。我们将使用一个标志变量来知道图像是否在系统中。
推荐阅读: Python 异常处理——Python 尝试——除
import PIL.Image
img_flag = True
path = input("Enter the path to the image field : \n")
try:
img = PIL.Image.open(path)
img_flag = True
except:
print(path, "Unable to find image ")
调整图像大小
我们需要将图像的宽度和高度调整到一个更小的值，这样它就不会有太大的文本而造成混乱。
width, height = img.size
aspect_ratio = height/width
new_width = 120
new_height = aspect_ratio * new_width * 0.55
img = img.resize((new_width, int(new_height)))
将图像转换为灰度
我们可以使用convert函数，并将选项作为L传递给灰度图像输出。
img = img.convert('L')
创建一个 ASCII 字符列表
请记住，ASCII 字符是从最暗到最亮排列的，这意味着对于下面显示的列表，最暗的像素将被替换为@，最亮的像素将被替换为.。您可以根据自己的喜好更改列表。
chars = ["@", "J", "D", "%", "*", "P", "+", "Y", "$", ",", "."]
转换成 ASCI 艺术图
为了将图像转换为 ASCII 字符，我们获取图像中每个像素的像素值，并将相应的 ASCII 字符映射在一起，形成一个新的字符串。现在，我们使用to_greyscale函数将我们的图像转换成GreyScale image和pixel_to_ascii函数将我们的图像转换成 ASCII 艺术！我们还将把结果文本保存到一个文件中。
pixels = img.getdata()
new_pixels = [chars[pixel//25] for pixel in pixels]
new_pixels = ''.join(new_pixels)
# split string of chars into multiple strings of length equal to new width and create a list
new_pixels_count = len(new_pixels)
ascii_image = [new_pixels[index:index + new_width] for index in range(0, new_pixels_count, new_width)]
ascii_image = "\n".join(ascii_image)
print(ascii_image)
# write to a text file.
with open("sample_ascii_image.txt", "w") as f:
f.write(ascii_image)
完整代码
让我们看一下我们在上一节中编写的完整代码。
import PIL.Image
img_flag = True
path = input("Enter the path to the image field : \n")
try:
img = PIL.Image.open(path)
img_flag = True
except:
print(path, "Unable to find image ");
width, height = img.size
aspect_ratio = height/width
new_width = 120
new_height = aspect_ratio * new_width * 0.55
img = img.resize((new_width, int(new_height)))
img = img.convert('L')
chars = ["@", "J", "D", "%", "*", "P", "+", "Y", "$", ",", "."]
pixels = img.getdata()
new_pixels = [chars[pixel//25] for pixel in pixels]
new_pixels = ''.join(new_pixels)
new_pixels_count = len(new_pixels)
ascii_image = [new_pixels[index:index + new_width] for index in range(0, new_pixels_count, new_width)]
ascii_image = "\n".join(ascii_image)
with open("ascii_image.txt", "w") as f:
f.write(ascii_image)
一些示例输出
Image 4
Image 5
结论
继续，用许多不同的角色尝试这个练习，自己看看结果。你可能也会发现一些非常有趣的结果！让我们在下面的评论中知道哪一个最适合你。
Python 中的二维数组
原文：https://www.askpython.com/python/two-dimensional-array-in-python
**Array**基本上是一种以线性方式存储数据的数据结构。Python 中没有排他的数组对象，因为用户可以使用一个列表来执行数组的所有操作。
因此，Python 使用 list 对象执行所有与数组相关的操作。数组是按顺序排列的元素的有序集合。
声明数组的语法:
array-name = []
二维数组基本上是数组中的数组。这里，通过使用两个索引来访问数据项的位置。它被表示为数据项目的*rows and columns*的表格。
二维数组的声明
语法:
array-name = [ [d1, d2, .... dn], [e1, e2, .... en] ]
举例:
array_input = [ [10,12,14] ,[0,1,2] ]
print(array_input[0]) # printing elements of row 0
print(array_input[1]) # printing elements of row 1
输出:
Output-2D Array
二维数组的输入
二维数组的输入以行和列的形式提供。
举例:
size = int(input())
array_input = []
for x in range(size):
array_input.append([int(y) for y in input().split()])
print(array_input)
输出:
Output-Input 2D Array
如何在二维数组中Insert元素？
可以使用insert()函数指定要插入元素的索引/位置来插入 2D 数组中的元素。
from array import *
input = [[1,1,1,1], [12,12,12,12]]
print("Array before insertion of elements: ")
print(input)
input.insert(1, [1,3,5,7,9])
print("Array after insertion of elements: ")
for x in input:
for y in x:
print(y,end = " ")
print()
输出:
Output-Insertion 2D Array
如何在二维数组中Update元素？
通过使用数组的索引重新分配值，可以更新元素和更改值。
from array import *
input = [[1,1,1,1], [12,12,12,12]]
print("Array before Updation of elements: ")
print(input)
input[0] = [10,8]
input[1][1] = 9
print("Array after updation of elements: ")
for x in input:
for y in x:
print(y,end = " ")
print()
输出:
Output-Updation 2D Array
如何删除二维数组中的值？
使用del()方法可以删除二维数组中的元素。
from array import *
input = [[1,1,1,1], [12,12,12,12], [0,2]]
print("Array before Deletion of elements: ")
print(input)
del(input[1])
print("Array after Deletion of elements: ")
for x in input:
for y in x:
print(y,end = " ")
print()
输出:
Output-Deletion 2D Array
二维数组的大小
使用len()方法可以确定数组的长度。
array_input = [[3,9],[0,3,7,10]]
print(len(array_input))
输出:
2
Python 二维数组追加
可以使用append()方法将元素追加到数组中。元素被添加到数组的末尾。
from array import *
input = [[1,1,1,1], [12,12,12,12], [0,2]]
print("Array before appending the elements: ")
print(input)
input.append([1,2])
print("Array after appending of the elements: ")
for x in input:
for y in x:
print(y,end = " ")
print()
输出:
Output-Append 2D Array
Python 中二维数组的切片
数组切片用于访问数组中的多个值。
语法:
<slice_array> = <array>[start:stop]
array1 = [[1,2,3],[4,5,6,7]]
#python array slice
array2 = array1[1:3] #index 1 to 2
print(array2)
array2 = array1[:1] #index 0 to 1
print(array2)
输出:
Output-Slicing 2D Array
结论
因此，在本文中，我们已经对 Python 中的二维数组及其相关的基本功能进行了概述。
参考
- Python 数组
- Python 2D 数组
- Python 数组文档
Python 中的类型提示和注释
原文：https://www.askpython.com/python/examples/type-hinting-and-annotations
Python 是一种动态类型语言。我们不必明确提到声明的变量或函数的数据类型。Python 解释器在运行时根据变量值为变量分配类型。我们也有静态类型的语言，如 Java、C 或 C++，我们需要在声明时声明变量类型，而变量类型在编译时是已知的。
从 Python 3.5 开始，在 PEP 484 和 PEP 483 中引入了一种叫做类型提示的东西。Python 语言的这一新增功能有助于构建我们的代码，并使它看起来更像一种静态类型语言。这有助于避免错误，但同时也使代码更加冗长。
然而，Python 运行时并不强制函数和变量类型注释。它们可以被第三方工具使用，比如类型检查器、ide、linters 等等。
亦读:巨蟒中的魔蛊
类型检查、类型提示和代码编译
起初，我们有一些外部第三方库，例如开始进行类型提示的静态类型检查器如 **mypy** ，mypy 的许多想法实际上被引入了规范 Python 本身并直接集成到 Python 中。
现在，关于类型提示的事情是，它不会修改 Python 本身的运行方式。类型提示确实与代码的其余部分一起被编译，但是它们不影响 Python 执行代码的方式。
让我们看一个例子，并通过给一个函数分配类型提示得到一个概述。
代码:
def multiply(num1: int, num2: int):
return num1 * num2
print(multiply(5, 7)) # 35
print(multiply(5, "Hi")) # HiHiHiHiHi
说明:
在上面声明的函数中，我们将内置数据类型赋给参数。这是一个很好的普通函数，但是这里的语法有点不同。我们可以注意到，参数有一个分号，数据类型分配给它们 (num1: int, num2: int)
这个函数有两个参数 num1 和 **num2**，这是 Python 在运行代码时看到的。它需要两个变量。即使我们不放置任何类型提示，比如说 num1 和 num2 应该是整数，Python 也不会有问题。
因此，根据它，我们应该传递两个整数值给我们的代码，这将工作得很好。然而，如果我们试图传递一个整数和一个字符串呢？
类型提示告诉我们传入**int** 值，然而我们传入的是**str**。当我们尝试运行代码时，它运行良好，没有任何问题。如果在像 **int, str, dict,**这样的类型提示中有一个有效数据类型，Python 解释器编译代码没有问题。
为什么要使用类型提示呢？
在上面的例子中，我们看到，即使我们传递一个字符串值给它，代码也运行良好。Python 将**int** 乘以 str 没有问题。然而，即使 Python 忽略了类型提示，还是有一些很好的理由使用它们。
- 其中之一是它帮助 ide 显示上下文相关的帮助信息，例如不仅是函数参数，还有预期的类型。
- 类型提示通常用于代码文档。有多个自动代码文档生成器在生成文档时会使用类型提示，例如，如果我们正在编写自己的代码库，其中包含许多函数和类以及注释。
- 即使 Python 根本不使用类型提示，它也有助于我们在编写代码时利用它来使用更具声明性的方法，并使用外部库来提供运行时验证。
使用类型检查器
Python 有几个类型检查器。其中之一是我的小蜜蜂。
让我们使用在使用**int** 和 str 之前运行的相同代码。我们将使用静态类型检查器 mypy ，看看 Python 对我们的代码有什么看法。
- 安装
mypy
`pip install mypy`
- 带有类型提示的代码，在运行代码时使用类型检查器
代码:
def multiply(num1: int, num2: int):
return num1 * num2
print(multiply(5, "Hi"))
在终端中运行带有类型检查器前缀的文件:
mypy type-hints.py
输出:
type-hints.py:9: error: Argument 2 to "multiply" has incompatible type "str"; expected "int"
Found 1 error in 1 file (checked 1 source file)
解释:
当我们用类型检查器运行我们的文件时，现在 Python 解释器对我们的代码有了问题。预期的参数是两个参数的 int 数据类型，我们在其中一个参数中传递了一个字符串。类型检查器跟踪了这个错误，并在我们的输出中显示出来。类型检查器帮助我们解决了代码中的问题。
Python 中类型提示的更多示例
在上面的例子中，我们在提示时使用了int 和str 类型。类似地，其他数据类型也可以用于类型提示。我们也可以为函数中的 return 类型声明一个类型提示。
让我们浏览一下代码，看看一些例子。
示例:1
def some_function(a: int, b: float, c: dict, d: bool = False):
pass
解释:
这里我们为我们的参数使用不同的数据类型。请注意，如果没有提供参数，我们也可以为参数分配默认值。
示例:2
def person(name: str, age: int) -> str:
return f"{name} is a {age} year old programmer"
解释:
在上面的代码中，还声明了返回类型。当我们尝试使用 mypy 之类的类型检查器运行代码时，Python 运行代码不会有问题，因为我们有一个字符串作为返回类型，它与提供的类型提示相匹配。
示例:3
def other_function(name: str, age: int) -> None:
return f"{name} is a {age} year old programmer"
解释:
该代码的返回类型为 None 。当我们试图使用**mypy** 类型检查器运行这段代码时，Python 会抛出一个异常，因为它期望的是 None 的**return** 类型，而代码返回的是一个字符串。
示例:4
my_list: list = ["apple", "orange", "mango"]
my_tuple: tuple = ("Hello", "Friend")
my_dictionary: dict = {"name": "Peter", "age": 30}
my_set: set = {1, 4, 6, 7}
解释:
上面的代码显示了通常被称为变量注释的类型提示。就像我们在上面的例子中为函数提供类型提示一样，即使是变量也可以保存类似的信息，帮助代码更具声明性和文档化。****
typing 模块
很多时候，我们有更高级或更复杂的类型，它们必须作为参数传递给函数。Python 有一个内置的**typing** 模块，使我们能够编写这种类型的带注释的变量，使代码更加文档化。我们必须将输入模块导入到我们的文件中，然后使用这些函数。其中包括链表、字典、集合、和元组等数据结构。
让我们看看代码 a，获得一个概述，以及作为解释的注释。
from typing import List, Dict, Set, Tuple, Union
# Declaring a nested list with annotations
my_new_list: List[List[int]] = [[1, 2, 3], [4, 5]]
# Declaring a dictionary with keys as strings and values as integers
my_new_dict: Dict[str, int] = {"age": 34, "languages": 2}
# Declaring a set with only string values
my_new_set: Set[str] = {"apple", "mango"}
# Declaring a tuple with exactly 3 parameters with string values only
my_new_tuple: Tuple[str, str, str] = ("Hello", "There", "Friend")
# Declaring a list that may hold integers, floats, and strings all at once
my_union_list: List[Union[int, float, str]] = [12, "notebook", 34.56, "pencil", 78]
'''
Since Python 3.10.x we can use the pipe | character
instead of importing typing Module for using Union
'''
def func(a: str | int | float, b: int) -> str | int | float:
return a * b
摘要
在 Python 中还有许多其他利用类型提示的方法。使用类型不会影响代码的性能，我们也不会得到任何额外的功能。然而，使用类型提示为我们的代码提供了健壮性，并为以后阅读代码的人提供了文档。
这当然有助于避免引入难以发现的错误。在当前的技术场景中，编写代码时使用类型变得越来越流行，Python 也遵循这种模式，为我们提供了同样易于使用的函数。有关更多信息，请参考官方文档。
参考
[解释]机器学习的 4 种类型–简要概述
原文：https://www.askpython.com/python/examples/types-of-machine-learning
读者朋友们，你们好！在本文中，我们将详细关注机器学习的类型。所以，让我们开始吧！！🙂
什么是机器学习？
机器学习已经成为数据科学和分析领域所有开发者的热门话题。机器学习领域为我们提供了各种算法，使我们能够对数据值进行预测，从而解决现实生活中的问题。
例如，根据迄今为止的数据，如果我们希望知道未来几天的天气预报，可以通过使用机器学习算法的数据预测轻松实现。它使我们能够解决业务问题，也为业务分析轻松掌握需求预测铺平了道路。
机器学习算法的类型
机器学习为我们提供了以下类型的算法，这些算法对数据变量的类型具有选择性
- 监督机器学习
- 无监督机器学习
- 半监督机器学习
- 强化机器学习
让我们在接下来的章节中逐一查看。
1.监督 ML
监督机器学习算法通常处理数值和分类数据值。它们将标记的输入数据值馈送给模型，并且馈送的训练数据的输出也被馈送给模型。
在这里，算法从输入和历史输出数据中学习，检测数据中的模式，然后对测试数据进行预测。
对数值相关数据变量起作用的监督 ML 算法称为回归算法，而对分类数据值起作用的算法称为分类数据算法。
2.无监督 ML
在无监督的机器学习算法中，模型没有任何标记的数据值。也就是说，模型接受未标记的数据，然后从数据中检测相似的特征，并将它们分组到一个类别中。
训练数据的输出永远不会提供给模型。在这里，模型通过发现潜在的模式，通过等式和相关性等进行自我学习。
无监督机器学习算法解决聚类和关联问题等。
3.钢筋 ML
在强化学习中，模型通过试错来学习。也就是说，它包含一个称为代理的机器组件，该代理以模拟的方式从反复试验中学习。
该模型通过奖励和惩罚来强化试错法的结果，奖励和惩罚基于从试验中模型的行为和学习。
4.半监督 ML
使用半监督机器学习，馈送到模型的数据部分被标记，也部分未被标记。这些算法大多从分类相关变量开始工作，可用于数据模型的分类和聚类。
它将已标记和未标记的数据作为输入，甚至作为训练数据的输出，从模式中学习，然后得出某些预测。
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多关于 Python 机器学习的文章，敬请关注我们。
在那之前，学习愉快！！🙂
内部威胁风险及其防范的终极指南
原文：https://www.askpython.com/python/ultimate-guide-insider-threat-risks-prevention
如何确保您企业的内部威胁防护
内部风险变得越来越普遍。近年来，内部攻击大幅增加，无论是来自易受网络钓鱼攻击的无意内部人员，还是希望泄露关键数据的恶意内部人员。根据一些调查，70%的网络安全专家认为内部攻击的频率在过去一年有所增加。此外，62%的公司在过去一年中至少遭受过一次内部攻击。那么，为什么内部威胁在增加，谁是罪魁祸首，您的公司可以采取哪些内部威胁保护措施来避免它们？
什么是内部威胁，为什么您应该知道
内部威胁是指合法访问公司资产的人，他们会有意或无意地利用这种访问来破坏企业。目前的工人并不总是内部危险。有权访问组织系统或机密材料的前员工、承包商或合作伙伴可能是潜在的嫌疑人。
由于 40%的内部事件涉及有权访问公司资产的员工，企业必须以保护边界免受外部攻击者攻击的同样严谨的态度来评估每天进入其大门的危险。
安全专业人员在内部威胁检测方面有一个难题。内部人员已经可以有效访问组织的信息和资产，很难区分日常活动和可能的可疑活动。内部人员通常知道敏感数据保存在企业内部的什么地方，并且能够接触到这些数据。因此，内部威胁防护是公司必须考虑的最重要的问题之一。
内部威胁的类型
内部威胁与其他攻击的区别在于攻击者不一定是受经济利益的驱使。在其他情况下，攻击者是一名心怀不满的员工，他的唯一动机是想损害公司。网络安全内部威胁检测显示，内部风险可分为四类。他们不一定是恶意的，但他们可能仍然有重大的财务和声誉影响。
以下是恶意内部威胁的示例:
破坏
破坏的目的是对系统造成损害或破坏数据。破坏组织基础设施的一种技术是不遵循维护或 IT 流程，或者物理损坏设施和设备。另一个选择是删除代码，这样你公司的正常活动就会受到影响。
诈骗
当拥有安全网络和应用程序访问权限的人利用该权限窃取信息或金钱时，就会发生内部欺诈。可以在您的企业资源规划(ERP)平台中设置供应商帐户并支付其发票的人就是一个理想的例子。个人可以建立一个虚构的供应商，将钱分配到他们控制的账户，并支付发票给他们自己。
盗窃知识产权
公司的私人信息很有价值，试图窃取这些信息的攻击者可能会造成长期的经济损失。当有人为了个人或商业利益从您的公司网络中复制或获取数据时，就会发生这种危险。
间谍活动
现任或前任员工可能会利用他或她对公司系统或数据的访问来获取详细信息，如知识产权或私人数据/信息，从而获得竞争优势。例如，竞争对手可能会寻求拥有内部信息的员工的帮助来窃取公司机密和其他重要信息。如果攻击者将重要的商业秘密、文件或数据出售给竞争对手，他们就会受到间谍活动的威胁。
内部威胁防范最佳实践
以下是一些内部威胁解决方案，有助于降低内部威胁的风险:
- 保护重要的资产，如系统、技术、建筑和人员，这些资产可能是物理的，也可能是逻辑的。客户的数据、专有软件、图表和内部制造流程都是宝贵的资产。彻底掌握你的重要资产。考虑这样的问题:你有什么关键资产？有可能对你的资产进行优先排序吗？你对每项资产的现状了解多少？
- 实施策略—创建全面的组织策略文档，以便您可以执行这些策略并避免误解。公司中的每个人都应该了解安全协议，并理解他们的知识产权(IP ),这样他们开发的特权材料就不会被共享。
- 通过使用内部威胁监控技术来监控员工行为并关联来自众多来源的数据，从而提高可见性。例如，您可能利用欺骗技术来引诱恶意的内部人员或冒名顶替者，并获得对他们活动的洞察。
- 鼓励文化变革——确保安全不仅包括知识，还包括态度和价值观。您应该对员工进行安全问题和内部威胁防范方面的教育，并努力提高员工满意度，以应对粗心大意和解决有害活动的动机。
SpinOne 作为内部威胁检测解决方案
在 SaaS 数据安全和管理市场，SpinOne 是一个知名品牌。网络安全专家和 IT 部门在 2016 年开发了这款软件。全球超过 1，500 家企业和超过 2，000，000 家个人组织正在使用 SpinOne AI 支持的勒索软件和备份与恢复产品来保护敏感数据。
借助 SpinOne，您可以通过以下方式保护自己免受内部威胁:
- 访问 SaaS 云环境中的所有共享数据。
- 查看谁拥有哪些文件。
- 使用安全策略文件规则。
- 审计共享数据的客户。
- 查找通过电子邮件传输的重要信息。
- 查看和排序个人数据。
- 如果需要，生成并导出数据审计报告。
希望保护其所有敏感数据的公司采用了各种 SaaS 数据安全解决方案。SpinOne 是 2022 年最受欢迎的。它是最好的网络安全内部威胁检测工具之一，可以监控您的云数据环境中的异常活动、SaaS 数据滥用和其他网络安全威胁。它通过持续监控来保护您公司的云数据免受内部威胁和数据滥用。
numpy。cbrt()–返回元素的立方根
原文:# t0]https://www . aspython . com/python-modules/num py/numpy-cbrt
读者你好！欢迎来到另一个关于 NumPy 数学函数的教程。在本教程中，我们将通过各种例子详细介绍 NumPy Cuberoot 函数。
没有别的事了，我们开始吧。
立方根函数–快速概述
让我们快速修改立方根函数。
它是一个数的第三个根。这意味着，如果我们将一个数的立方根值乘以 3，那么我们将得到原来的数。例如，125 的立方根是 5，这意味着将 5 本身乘以三次，结果是 125。
什么是 NumPy cbrt？
NumPy cbrt 是 NumPy 库提供的数学函数之一。它计算输入数字的立方根(3 次方根)。
让我们看看这个函数的语法。
numpy.cbrt(input)
这里，输入可以是单个数字、数字的 NumPy 数组以及复数。
使用 NumPy cbrt
这就是函数的语法。现在让我们编写代码来更好地理解这个函数。
单个数的 NumPy cbrt
import numpy as np
print("Cube root of 1 is :",np.cbrt(1))
print("Cube root of 125 is :",np.cbrt(125))
print("Cube root of 1024 is :",np.cbrt(1024))
print("Cube root of 27000 is :",np.cbrt(27000))
输出
Cube root of 1 is : 1.0
Cube root of 125 is : 5.0
Cube root of 1024 is : 10.079368399158984
Cube root of 27000 is : 30.0
输出非常明显且易于理解。
带有 NumPy 数组的 NumPy cbrt
import numpy as np
a = np.array((1 , 1000 , -27 , -99))
print("Input Array:\n",a)
print("Cube root Values:\n",np.cbrt(a))
b = np.array((1024 , 216))
print("Input Array:\n",b)
print("Cube root Values:\n",np.cbrt(b))
输出
Input Array:
[ 1 1000 -27 -99]
Cube root Values:
[ 1\. 10\. -3\. -4.62606501]
Input Array:
[1024 216]
Cube root Values:
[10.0793684 6\. ]
现在，让我们看看当我们将一个复数作为输入传递给 NumPy cbrt 函数时会发生什么。
复数的 NumPy cbrt
import numpy as np
print(np.cbrt(1+4j))
print(np.cbrt(2-5j))
输出
TypeError: ufunc 'cbrt' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''
从上面的输出中，我们可以清楚地理解，复数不能作为输入传递给 NumPy cbrt 函数。
让我们使用 Matplotlib 库来绘制 NumPy cbrt 函数。
数字 cbrt 的图形表示
import numpy as np
import matplotlib.pyplot as plt
a = np.linspace(-10 , 10 , 20)
b = np.cbrt(a)
plt.plot(a , b , color = "green" , marker = "o")
plt.title("numpy.cbrt()")
plt.xlabel("X")
plt.ylabel("Y")
plt.show()
输出
cbrt Plot
这就是关于 NumPy cbrt 函数的全部内容。快乐学习🙂
参考
num py documentation–num py cbrt
Python 中的 Unicode 解释了 unicodedata 模块
原文：https://www.askpython.com/python-modules/unicode-in-python-unicodedata
嘿伙计们！在本教程中，我们将学习 Python 中的 Unicode 以及 Unicode 的字符属性。那么，我们开始吧。
什么是 Unicode？
Unicode 将每个字符和符号与一个称为代码点的唯一数字相关联。它支持世界上所有的书写系统，并确保可以使用任何语言组合来检索或组合数据。
码点是十六进制编码中范围从 0 到 0x10FFFF 的整数值。
要开始在 Python 中使用 Unicode 字符，我们需要理解字符串模块是如何解释字符的。
Python 中如何解释 ASCII 和 Unicode？
Python 为我们提供了一个 string 模块，其中包含了各种操作字符串的函数和工具。它属于 ASCII 字符集。
import string
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.ascii_letters)
print(string.digits)
print(string.hexdigits)
print(string.octdigits)
print(string.whitespace)
print(string.punctuation)
输出:
ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
0123456789
0123456789abcdefABCDEF
01234567
!"#$%&'()*+,-./:;<=>[email protected][\]^_`{|}~
我们可以使用 chr() 内置函数创建单字符 Unicode 字符串。它只接受一个整数作为参数，并返回给定字符的 unicode。
类似地，odr()是一个内置函数，它接受一个单字符 Unicode 字符串作为输入，并返回代码点值。
chr(57344)
ord('\ue000')
输出:
'\ue000'
57344
Python 中的字符编码是什么意思？
字符串是 Unicode 码位的序列。这些码点被转换成字节序列，以便有效存储。这个过程叫做字符编码。
有许多编码，如 UTF 8，UTF-16，ASCII 等。
默认情况下，Python 使用 UTF-8 编码。
什么是 UTF 8 编码？
UTF 8 是最流行和最常用的字符编码。UTF 代表 Unicode 转换格式，‘8’表示编码中使用了的 8 位值。
它取代了 ASCII(美国信息交换标准码),因为它提供了更多的字符，可以用于世界各地的不同语言，不像 ASCII 只限于拉丁语言。
UTF 8 字符集的前 128 个码位也是有效的 ASCII 字符。UTF-8 中的字符长度可以是 1 到 4 个字节。
使用 Python encode()函数对 UTF 8 中的字符进行编码
encode()方法将任何字符从一种编码转换成另一种编码。编码函数的语法如下所示
string.encode(encoding='UTF-8',errors='strict')
参数:
- 编码 是 python 支持使用的编码。
- 错误–不同错误类型列表如下
- strict- 默认错误为 strict ，失败时引发 UnicodeDecode 错误。
- 忽略–忽略结果中不可解码的 unicode。
- 替换–用“？”替换不可解码的 unicode
- xmlcharrefreplace- 插入 xlm 字符引用来代替不可解码的 unicode。
- backslashreplace- 插入\uNNNN 转义序列来代替不可解码的 unicode。
- namereplace- 在不可解码的 unicode 位置插入\N{…}转义序列。
如何在 Python 中通过 encode()函数使用 Unicode？
现在让我们开始理解字符串编码函数如何允许我们在 Python 中创建 unicode 字符串。
1.将字符串编码为 UTF-8 编码
string = 'örange'
print('The string is:',string)
string_utf=string.encode()
print('The encoded string is:',string_utf)
输出:
The string is: örange
The encoded string is: b'\xc3\xb6range'
2.带错误参数的编码
让我们对德语单词 wei 进行编码，它的意思是白色。
string = 'weiß'
x = string.encode(encoding='ascii',errors='backslashreplace')
print(x)
x = string.encode(encoding='ascii',errors='ignore')
print(x)
x = string.encode(encoding='ascii',errors='namereplace')
print(x)
x = string.encode(encoding='ascii',errors='replace')
print(x)
x = string.encode(encoding='ascii',errors='xmlcharrefreplace')
print(x)
x = string.encode(encoding='UTF-8',errors='strict')
print(x)
输出:
b'wei\\xdf'
b'wei'
b'wei\\N{LATIN SMALL LETTER SHARP S}'
b'wei?'
b'weiß'
b'wei\xc3\x9f'
在 python 中使用 unicode 的 unicodedata 模块
unicodedata 模块为我们提供了 Unicode 字符数据库(UCD) ，它定义了所有 Unicode 字符的所有字符属性。
让我们看看模块中定义的所有函数，并用一个简单的例子来解释它们的功能。通过使用以下函数，我们可以在 Python 中高效地使用 Unicode。
1. unicodedata.lookup(名称)
这个函数根据给定的名字查找字符。如果找到该字符，则返回相应的字符。如果找不到，则引发 Keyerror。
import unicodedata
print (unicodedata.lookup('LEFT CURLY BRACKET'))
print (unicodedata.lookup('RIGHT SQUARE BRACKET'))
print (unicodedata.lookup('ASTERISK'))
print (unicodedata.lookup('EXCLAMATION MARK'))
输出:
{
]
*
!
2. unicodedata.name(chr[，default])
该函数以字符串形式返回分配给字符 chr 的名称。如果没有定义名称，它将返回默认值，否则将引发 Keyerror。
import unicodedata
print (unicodedata.name(u'%'))
print (unicodedata.name(u'|'))
print (unicodedata.name(u'*'))
print (unicodedata.name(u'@'))
输出:
PERCENT SIGN
VERTICAL LINE
ASTERISK
COMMERCIAL AT
3. unicodedata.decimal(chr[，default])
该函数返回分配给字符 chr 的十进制值。如果没有定义值，则返回默认值，否则将引发 Keyerror，如下例所示。
import unicodedata
print (unicodedata.decimal(u'6'))
print (unicodedata.decimal(u'b'))
输出:
6
Traceback (most recent call last):
File "D:\DSCracker\DS Cracker\program.py", line 4, in <module>
print (unicodedata.decimal(u'b'))
ValueError: not a decimal
4. unicodedata.digit(chr[，default])
该函数将分配给字符 chr 的数字值作为整数返回。需要注意的一点是，这个函数接受单个字符作为输入。在本例的最后一行，我使用了“20 ”,函数抛出一个错误，指出它不能接受一个字符串作为输入。
import unicodedata
print (unicodedata.decimal(u'9'))
print (unicodedata.decimal(u'0'))
print (unicodedata.decimal(u'20'))
输出:
9
0
Traceback (most recent call last):
File "D:\DSCracker\DS Cracker\program.py", line 5, in <module>
print (unicodedata.decimal(u'20'))
TypeError: decimal() argument 1 must be a unicode character, not str
5. unicodedata.numeric(chr[，default])
该函数返回分配给字符 chr 的整数数值。如果没有定义值，则返回默认值，否则将引发 ValueError。
import unicodedata
print (unicodedata.decimal(u'1'))
print (unicodedata.decimal(u'8'))
print (unicodedata.decimal(u'123'))
输出:
1
8
Traceback (most recent call last):
File "D:\DSCracker\DS Cracker\program.py", line 5, in <module>
print (unicodedata.decimal(u'123'))
TypeError: decimal() argument 1 must be a unicode character, not str
6.unicode data . category(chr)
该函数以字符串形式返回分配给角色 chr 的一般类别。它返回字母“L ”,大写字母“u ”,小写字母“L”。
import unicodedata
print (unicodedata.category(u'P'))
print (unicodedata.category(u'p'))
输出:
Lu
Ll
7. unicodedata .双向(chr)
该函数以字符串形式返回分配给字符 chr 的双向类。如果没有定义这样的值，此函数将返回一个空字符串。
AL 表示阿拉伯字母，AN 表示阿拉伯数字，L 表示从左到右等等。
import unicodedata
print (unicodedata.bidirectional(u'\u0760'))
print (unicodedata.bidirectional(u'\u0560'))
print (unicodedata.bidirectional(u'\u0660'))
输出:
AL
L
AN
8.unicode data . combining(chr)
这个函数以字符串形式返回分配给给定字符 chr 的规范组合类。如果没有定义组合类，则返回 0。
import unicodedata
print (unicodedata.combining(u"\u0317"))
输出:
220
9.unicodedata.mirrored(chr)
这个函数以整数的形式返回一个分配给给定角色 chr 的镜像属性。如果字符在双向文本中被识别为'镜像，则返回 1 ，否则返回 0 。
import unicodedata
print (unicodedata.mirrored(u"\u0028"))
print (unicodedata.mirrored(u"\u0578"))
输出:
1
0
10. unicodedata.normalize(form，unistr)
使用此函数返回 Unicode 字符串 unistr 的常规形式。格式的有效值为“NFC”、“NFKC”、“NFD”和“NFKD”。
from unicodedata import normalize
print ('%r' % normalize('NFD', u'\u00C6'))
print ('%r' % normalize('NFC', u'C\u0367'))
print ('%r' % normalize('NFKD', u'\u2760'))
输出:
'Æ'
'Cͧ'
'❠'
结论
在本教程中，我们学习了 unicode 和定义 unicode 特征的 unicodedatabase 模块。希望你们都喜欢。敬请关注🙂
参考
如何在 Python 中从一个数据帧中获取唯一值？
原文：https://www.askpython.com/python/built-in-methods/unique-values-from-a-dataframe
读者朋友们，你们好！在本文中，我们将关注如何在 Python 中从数据帧中获取唯一值。
所以，让我们开始吧！
什么是 Python 数据帧？
Python Pandas 模块为我们提供了各种数据结构和函数来存储和操作大量数据。
DataFrame 是 Pandas 模块提供的一个数据结构化工具，用于处理多维度的大型数据集，如巨大的 csv 或 excel 文件等。
由于我们可以在一个数据框中存储大量数据，因此我们经常会遇到这样的情况:从可能包含冗余或重复值的数据集中查找唯一的数据值。
这就是pandas.dataframe.unique() function出现的时候。
现在让我们在下一节集中讨论 unique()函数的功能。
Python pandas.unique()函数从数据帧中获取唯一值
pandas.unique() function返回数据集中存在的唯一值。
它基本上使用一种基于哈希表的技术，从数据帧/系列数据结构中的值集中返回非冗余值。
让我们通过一个例子来理解独特功能的作用
考虑包含如下值的数据集:1，2，3，2，4，3，2
现在，如果我们应用 unique()函数，我们将获得以下结果:1，2，3，4。这样，我们可以很容易地找到数据集的唯一值。
现在，让我们在下一节讨论 pandas.unique()函数的结构。
Python unique()函数的语法
看看下面的语法:
pandas.unique(data)
当数据是一维的时，上述语法是有用的。它代表一维数据值中的唯一值(序列数据结构)。
但是，如果数据包含不止一个维度，即行和列，该怎么办呢？是的，我们在下面的语法中有一个解决方案
pandas.dataframe.column-name.unique()
这种语法使我们能够从数据集的特定列中找到唯一的值。
数据最好是分类类型，这样唯一函数才能获得正确的结果。此外，数据按照其在数据集中出现的顺序显示。
熊猫系列的 Python unique()函数
在下面的例子中，我们创建了一个包含冗余值的列表。
此外，我们已经将该列表转换为一个系列数据结构，因为它只有一个维度。最后，我们应用了 unique()函数从数据中获取唯一值。
举例:
lst = [1,2,3,4,2,4]
df = pandas.Series(lst)
print("Unique values:\n")
print(pandas.unique(df))
输出:
Unique values:
[1 2 3 4]
Python unique()函数与熊猫数据帧
让我们首先将数据集加载到如下所示的环境中
import pandas
BIKE = pandas.read_csv("Bike.csv")
在 这里可以找到数据集 。
pandas.dataframe.nunique() function代表数据帧每一列中的唯一值。
BIKE.nunique()
输出:
season 4
yr 2
mnth 12
holiday 2
weathersit 3
temp 494
hum 586
windspeed 636
cnt 684
dtype: int64
此外，我们使用以下代码表示了“季节”列中呈现的独特值
BIKE.season.unique()
输出:
array([1, 2, 3, 4], dtype=int64)
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
Python 中的大学录取预测
原文：https://www.askpython.com/python/examples/university-admission-prediction-in-python
大学教育正在成为 21 世纪社会和经济生活的重要支柱。这不仅在教育过程中是至关重要的，而且在保证两件重要的事情上也是至关重要的:一份好工作和财务稳定。另一方面，预测大学入学可能极具挑战性，因为学生不知道入学标准。
因此，在本教程中，我们将使用 Python 编程语言构建自己的大学录取预测模型。
数据集简介
在国外申请硕士时，有几个变量需要考虑。你必须有一个体面的 GRE 成绩，一个 sop(目的声明)，或者一封推荐信，等等。如果你不是来自英语国家，你也需要提交托福成绩。
在 可以访问数据集 。数据集包括以下属性:
- GRE 成绩(满分 340 分)
- 托福成绩(满分 120 分)
- 大学评级(满分 5 分)
- 目的陈述和推荐信强度(满分 5 分)
- 本科 GPA(满分 10 分)
- 研究经验(0 或 1)
- 录取机会(范围从 0 到 1)
用 Python 实现大学录取保护
我们将把整个代码实现分成如下所述的若干步骤:
步骤 1:导入必要的模块/库
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Dense ,Dropout,BatchNormalization
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
步骤 2:将数据集加载到程序中
df = pd.read_csv('Admission_Predict.csv')
df.head()
First5rows Of University Adm Pred Dataset
第三步:数据预处理和数据分割
在构建我们的主模型之前，我们需要一些预处理，包括删除模型不需要的任何列。
在这里,“序列号”列对于入院预测是不必要的，所以我们将其从数据中删除。
df=df.drop("Serial No.",axis=1)
在此之后，我们将把数据集分成 X 和 Y 子数据集，其中 X 将包含所有信息，Y 将包含最终概率。
Y=np.array(df[df.columns[-1]])
X=np.array(df.drop(df.columns[-1],axis=1))
现在，下一步是使用 80:20 训练测试拆分规则将数据集拆分为训练和测试数据集，其中 80%的数据用于训练，其余 20%用于测试。
X_train, X_test, y_train, y_test = train_test_split(X,Y, test_size=0.2, random_state=0)
预处理还将涉及规范化训练数据集，这可以通过下面提到的代码来实现。
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.fit_transform(X_test)
步骤 3:构建模型
下面提到的代码是描述整个模型的主要功能，包括模型的声明和向模型添加层。
该功能还涉及模型的编译和损失的计算。
def baseline_model():
model = Sequential()
model.add(Dense(16, input_dim=7, activation='relu'))
model.add(Dense(16, input_dim=7, activation='relu'))
model.add(Dense(16, input_dim=7, activation='relu'))
model.add(Dense(16, input_dim=7, activation='relu'))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
return model
第四步:模型的训练
下一步是创建模型对象，并在训练数据集上对其进行训练，如下面的代码所示。你可以根据自己的喜好保留历元的数量。
estimator = KerasRegressor(build_fn=baseline_model, epochs=50, batch_size=3, verbose=1)
estimator.fit(X_train,y_train)
培训的成果如下:
Epoch 1/50
107/107 [==============================] - 1s 3ms/step - loss: 0.1087
Epoch 2/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0065
Epoch 3/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0057
Epoch 4/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0052
Epoch 5/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0049
Epoch 6/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0050
Epoch 7/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0047
Epoch 8/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0049
Epoch 9/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0044
Epoch 10/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0043
Epoch 11/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0044
Epoch 12/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0044
Epoch 13/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0043
Epoch 14/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0041
Epoch 15/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0043
Epoch 16/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0042
Epoch 17/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0040
Epoch 18/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0043
Epoch 19/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0039
Epoch 20/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0040
Epoch 21/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0039
Epoch 22/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0042
Epoch 23/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0040
Epoch 24/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0038
Epoch 25/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0042
Epoch 26/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0038
Epoch 27/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0040
Epoch 28/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0042
Epoch 29/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0039
Epoch 30/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 31/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0038
Epoch 32/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0043
Epoch 33/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0040
Epoch 34/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 35/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0039
Epoch 36/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 37/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0038
Epoch 38/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0036
Epoch 39/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0036
Epoch 40/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0036
Epoch 41/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 42/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 43/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0036
Epoch 44/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 45/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 46/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0038
Epoch 47/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0036
Epoch 48/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0037
Epoch 49/50
107/107 [==============================] - 0s 4ms/step - loss: 0.0037
Epoch 50/50
107/107 [==============================] - 0s 3ms/step - loss: 0.0034
<keras.callbacks.History at 0x7f10c0173e10>
[19]
0s
步骤 5:测试模型
现在，让我们尝试预测测试数据集的值，并将它们与原始值进行匹配。
prediction = estimator.predict(X_test)
print("ORIGINAL DATA")
print(y_test)
print()
print("PREDICTED DATA")
print(prediction)
输出看起来有点像这样:
ORIGINAL DATA
[0.71 0.7 0.79 0.73 0.72 0.48 0.77 0.71 0.9 0.94 0.58 0.89 0.72 0.57
0.78 0.42 0.64 0.84 0.63 0.72 0.9 0.83 0.57 0.47 0.85 0.67 0.44 0.54
0.92 0.62 0.68 0.73 0.73 0.61 0.55 0.74 0.64 0.89 0.73 0.95 0.71 0.72
0.75 0.76 0.86 0.7 0.39 0.79 0.61 0.64 0.71 0.8 0.61 0.89 0.68 0.79
0.78 0.52 0.76 0.88 0.74 0.49 0.65 0.59 0.87 0.89 0.81 0.9 0.8 0.76
0.68 0.87 0.68 0.64 0.91 0.61 0.69 0.62 0.93 0.43]
PREDICTED DATA
[0.64663166 0.6811929 0.77187485 0.59903866 0.70518774 0.5707331
0.6844891 0.6232987 0.8559068 0.9225058 0.50917023 0.9055291
0.6913604 0.40199894 0.8595592 0.6155516 0.5891675 0.793468
0.5415057 0.7054745 0.8786436 0.8063141 0.55548865 0.3587063
0.77944946 0.5391258 0.43374807 0.62050253 0.90883577 0.6109837
0.64160395 0.7341113 0.73316455 0.5032365 0.7664028 0.76009744
0.59858805 0.86267006 0.60282356 0.94984144 0.7196544 0.63529354
0.7032968 0.8164513 0.8044792 0.6359613 0.54865533 0.6914524
0.589018 0.55952907 0.6446153 0.77345765 0.6449453 0.8998446
0.68746895 0.74362046 0.71107167 0.73258513 0.7594558 0.8374823
0.7504637 0.4027493 0.61975926 0.46762955 0.8579673 0.814696
0.7111042 0.8707262 0.7539967 0.7515583 0.5506843 0.8436626
0.8139006 0.5593421 0.933276 0.61958474 0.6084135 0.63294107
0.9234169 0.44476634]
您可以看到这些值在某种程度上确实匹配。但是让我们确定一下，我们也计算了平均误差。
第六步:计算平均误差
from sklearn.metrics import accuracy_score
train_error = np.abs(y_test - prediction)
mean_error = np.mean(train_error)
print("Mean Error: ",mean_error)
平均误差为0.0577927375137806，这足以说明我们的结果相当准确。
结论
恭喜你！你刚刚学习了如何制作自己的大学录取预测器。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
如何在 Python 数据帧中更新行的值？
原文：https://www.askpython.com/python-modules/pandas/update-the-value-of-a-row-dataframe
读者朋友们，你们好！在这篇文章中，我们将详细讨论用不同的方法来更新 Python 数据帧中的一行的值。
所以，让我们开始吧！
首先，行和列位于哪里？
在 Python 编程语言中，我们遇到了这个叫做 Pandas 的模块，它为我们提供了一个叫做数据帧的数据结构。
数据框以行和列的形式存储数据。因此，它可以被视为一个矩阵，在分析数据时非常有用。
让我们马上创建一个数据框架！
import pandas as pd
info= {"Num":[12,14,13,12,14,13,15], "NAME":['John','Camili','Rheana','Joseph','Amanti','Alexa','Siri']}
data = pd.DataFrame(info)
print("Original Data frame:\n")
print(data)
这里，我们使用pandas.DataFrame()函数创建了一个数据框
输出:
Original Data frame:
Num NAME
0 12 John
1 14 Camili
2 13 Rheana
3 12 Joseph
4 14 Amanti
5 13 Alexa
6 15 Siri
我们将在整篇文章中使用上面创建的数据框作为示例参考。
1.使用 Python at()方法更新行的值
Python at()方法使我们能够相对于一列一次更新一行的值。
语法:
dataframe.at[index,'column-name']='new value'
举例:
在本例中，我们为 at()函数提供了数据帧和列“NAME”的索引 6。因此，行索引 6 处的列“NAME”的值得到更新。
data.at[6,'NAME']='Safa'
输出:
Num NAME
0 12 John
1 14 Camili
2 13 Rheana
3 12 Joseph
4 14 Amanti
5 13 Alexa
6 15 Safa
2.Python loc()函数用于更改行/列的值
Python loc()方法也可以通过提供列的标签和行的索引来更新与列相关的行的值。
语法:
dataframe.loc[row index,['column-names']] = value
举例:
data.loc[0:2,['Num','NAME']] = [100,'Python']
这里，我们已经分别针对列“Num”和“NAME”更新了从索引 0 到 2 的行的值。
输出:
Num NAME
0 100 Python
1 100 Python
2 100 Python
3 12 Joseph
4 14 Amanti
5 13 Alexa
6 15 Siri
3.Python replace()方法更新数据帧中的值
使用 Python replace()方法，我们可以更新或更改数据框中任何字符串的值。我们不需要向它提供索引或标签值。
语法:
dataframe.replace("old string", "new string")
举例:
data.replace("Siri",
"Code",
inplace=True)
如上所述，我们在数据框中用“代码”替换了“Siri”一词。
输出:
Num NAME
0 12 John
1 14 Camili
2 13 Rheana
3 12 Joseph
4 14 Amanti
5 13 Alexa
6 15 Code
4.使用 iloc()方法更新行的值
使用 Python iloc()方法，可以通过提供行/列的索引值来更改或更新行/列的值。
语法:
dataframe.iloc[index] = value
举例:
data.iloc[[0,1,3,6],[0]] = 100
在本例中，我们已经更新了第 0、1、3 和 6 行相对于第一列的值，即“Num”为 100。
我们甚至可以使用 iloc()函数为函数提供行切片，从而更改多行的值。
输出:
Num NAME
0 100 John
1 100 Camili
2 13 Rheana
3 100 Joseph
4 14 Amanti
5 13 Alexa
6 100 Siri
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 相关的帖子，敬请关注，在此之前，祝你学习愉快！！🙂
文件上传到 Django——如何上传文件到 Django 服务器？
本文涵盖了将文件上传到 Django 服务器的具体步骤。大多数网络应用程序和网站都允许用户将他们的个人资料图片或文件从本地计算机上传到服务器。
我们将在我们的教程中复制相同的教程。让我们看看如何使用 Django 和 ModelForms 将文件和图像上传并处理到 web 服务器上。
上传文件到 Django
让我们来看看在 Django 中我们需要什么来允许文件上传。
1.必备知识
在上一篇关于 Django 表单的文章中，我们看到了获取表单数据；我们用请求。在表单对象中发布。
Request POST
但是为了上传文件到 Django ，我们需要包含另一个属性请求。文件也是如此，因为上传的文件存储在属性请求中。文件而不是 request.POST.
下面是代码的样子:
form = ReviewForm(request.POST,request.FILES)
Django 有单独的模型字段来处理不同的文件类型—image field 和 FileField 。
当我们只想上传图像文件时，我们使用 ImageField。jpg/。jpeg/。png 等。)
为了允许文件上传，我们需要在 <表单的> 属性中添加以下属性。
enctype ="multipart/form-data"
最后，表单 HTML 标记应该如下所示:
<form type = 'post' enctype = "multipart/form-data">
2.修改 settings.py 以存储上传的文件
现在在 settings.py 文件的末尾添加以下几行。
MEDIA_URL = ‘/media/’
MEDIA_ROOT = os.path.join(BASE_DIR, ‘media’)
这里:
- MEDIA_URL: 这里提到了 URL 端点。这是用户可以从浏览器访问并上传文件的 URL
- MEDIA_ROOT: 这一点我们已经在前面的 Django Templates 文章中的模板目录设置下看到过。
如果你现在不明白，以后在篇里你会明白的！
第二行告诉 Django 将所有上传的文件存储在一个名为‘media’的文件夹中，该文件夹是在 BASE_DIR(即项目目录)中创建的。
我们需要手动创建文件夹，这样所有上传的文件都将存储在下面带下划线的媒体文件夹中:
Django Project Directory
3.在 Django 项目中创建媒体文件夹。
现在在项目文件夹中，创建一个名为‘media’的新文件夹
Media
一旦文件夹被创建，我们将移动到创建电子书上传网页。
创建电子书上传网页
现在让我们制作一个网页，客户可以上传他们拥有的书籍的 pdf 文件。
1.在 models.py 中创建电子书模型
在 models.py 中，创建一个新的 Django 模型 " EBooksModel" ，然后添加以下代码
class EBooksModel(models.Model):
title = models.CharField(max_length = 80)
pdf = models.FileField(upload_to='pdfs/')
class Meta:
ordering = ['title']
def __str__(self):
return f"{self.title}"
这里:
- 我们使用了众所周知的模型 CharField ，它将存储客户提交的 pdf 的名称。
- FileField 用于客户端将要上传的文件。
- Upload_to 选项指定文件存储在介质中的路径。例如，我使用了“pdf/”，这意味着文件将存储在介质内名为 pdf 的文件夹中。
- 类元和定义 str: 我们在 Django 模型文章中学到了这一点
注意:上传文件不会保存在数据库中。只有文件的实例会保存在那里。因此，即使您删除该特定实例，上传的文件仍将在媒体文件夹中。
在本文的后面，你会知道我所说的文件的实例是什么意思，所以坚持住！！
2。在 forms.py 中创建 UploadBookForm
我们现在将 EBooksModel 导入 forms.py，然后创建一个新的 ModelForm " UploadBookForm。"
使用我们在 Django 表单中学到的知识创建表单
class UploadBookForm(forms.ModelForm):
class Meta:
model = EBooksModel
fields = ('title', 'pdf',)
3.在 views.py 中创建 book upload view
这里的代码类似于我们在 Django 表单中编写的代码。但是在这里，我们需要容纳上传的文件(放置在请求中)。文件而不是 request.POST.)
为此，只需添加请求。文件，随同请求。如下图所示张贴
form = UploadBookForm(request.POST,request.FILES)
因此，完整的代码将是
def BookUploadView(request):
if request.method == 'POST':
form = UploadBookForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return HttpResponse('The file is saved')
else:
form = UploadBookForm()
context = {
'form':form,
}
return render(request, 'books_website/UploadBook.html', context)
4。创建 UploadBook.html 模板
现在我们需要在模板文件中创建 <表单> 属性。
因此，创建一个模板文件" UploadBook.html." ，并添加以下内容。
<form method ='post' enctype ="multipart/form-data">
{% csrf_token %}
{{form}}
<input type="submit" value = "Submit">
</form>
不要忘记添加enctype = " multipart/form-data "否则表单将无法工作。
最后，让我们用 URL( book/upload) 映射视图
5.为 UploadBookView 创建 URL 路径
现在，在 urls.py 中，添加将 UploadBookView 链接到‘book/upload’的路径使用我们在看到的 Django URL 映射方法。
path('book/upload', BookUploadView, name ='BookUploadView')
现在我们已经创建了一个新模型，我们必须再次执行迁移。所以在 python shell 中逐个输入下面的命令。
python manage.py makemigrations
python manage.py migrate
就这样，现在让我们运行服务器并检查浏览器。
Browser
瞧，上传表格出来了！！现在选择一个 pdf 并点击提交按钮。
Browser
当你点击提交按钮，那么“文件已经保存”页面就会出现
Browser
如果您转到媒体文件夹，您将看到一个pdf文件夹，其中包含您提交的 pdf。
Media/pdfs
在管理站点中注册新创建的模型，使用:
admin.site.register(EBooksModel)
然后在浏览器中加载管理站点，转到 EBooksModel 并选择我们刚刚提交的元素。
Admin Site
现在在这里，如果你观察的话，在 pdf 字段中。你会看到一个当前:选项。
写在它前面的路径:pdf/c programming _ tutorial . pdf叫做实例。因此pdf/
Django 只保存文件的实例，而不是文件本身。因此，即使您从管理站点删除了模型，pdf 文件仍将存在于媒体文件夹中。
从浏览器前端查看上传的文件
在上面的网页中，实例显示为一个链接。但是如果你点击它，你会得到一个错误信息。
发生这种情况是因为端点未被映射。
Error Message
现在要纠正这个错误，我们需要将这个端点映射到特定的文件。为此，请访问 urls.py 并添加
from django.conf import settings
from django.conf.urls.static import static
if settings.DEBUG:
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
Urls
如果你读一读这一行，你就会大致了解我们在做什么
这里:
- 在 settings.py 中，我们已经设置了 debug = True ，所以设置。调试将总是真。
- 在端如果函数，下面的代码将添加静态(设置。MEDIA_URL，document _ root =设置。MEDIA_ROOT) 到上面呈现的 urlpatterns。
Debug 1
线路静态(设置。MEDIA_URL，document _ root =设置。【MEDIA _ ROOT)可以这样想。
主机网站( http://127.0.0.1:8000/ )是我们添加端点的地方
- MEDIA_URL (在本文开头我们保留为 '/media/' )
Media Settings
- 然后是 document_root (这是 pdf 文件在媒体文件夹中的位置。
因此，如果我想查看我之前上传的c programming _ tutorial . pdf文件，我将访问http://127 . 0 . 0 . 1:8000/MEDIA/pdf/c programming _ tutorial . pdf(观察如何使用 MEDIA_URL( '/media/' )
这就是上面的代码在 urls.py 中所做的事情。
就这样，现在如果你重新加载服务器并点击我们之前在 Django 管理页面上看到的实例，你现在不会得到错误。
Admin Site
现在点击实例链接并检查！！
Pdf Browser
因此我们现在可以通过浏览器查看 pdf 了！
结论。
就是这样！！我们希望你已经学会了上传文件到 Django 所需的一切。此外，你可以从他们的官方文档中了解更多的信息。
练习题:利用从以前文章中获得的知识，尝试制作一个网页，展示网页上所有可用的电子书，并附有查看它们的链接。
请继续关注 Django 主题的更多高级教程！
Python 中的 URL 缩写——初学者指南
想用 Python 创建一个网址缩写器？不要再看了。导航和分享长网址是一件痛苦的事。这么长的 URL 背后的原因是链接中的跟踪者数量，大量站点的加载内容(多个目录)等。我们都使用网址缩写器来把长的网址缩短为几个字符，这使得它们更容易分享和浏览，并且看起来干净优雅。
但是你有没有想过自己编码一个网址缩写？在本教程中，我们将用非常简单的步骤来解释用 Python 编写 URL shortener 的过程。
有很多不同的方法可以用来缩短 URL，其中大多数都需要 API，你只需要坚持使用一种缩短的 URL。比特里，丁尤尔等。
URL 缩写的代码
在本教程中，您将了解一个 python 包，与传统方法相比，它可以非常容易地缩短 URL。
1.安装模块
首先，我们需要安装所需的模块，这将大大简化我们编写 URL 缩写的工作。我们从使用 pip 包管理器安装 python 库开始。
Pyshorteners 是 Python 库，用来包装和消费最常用的 URL shorteners APIs。
pip install pyshorteners
2.导入、输入和初始化
在 python 文件中，我们从导入所需的模块开始。
import pyshorteners
我们在这一点上接受用户的输入，我们可以稍后在我们的代码中完成输入部分，但是那会让我们改变代码的基本/永久结构，我们将为每个 URL shortener 的 API 改变它。
long_url = input("Enter the URL to shorten: ")
现在我们初始化 pyshortener 库的类对象，开始缩短我们的 URL。
type_tiny = pyshorteners.Shortener()
3.缩短 URL–Tinyurl
现在，我们已经初始化了我们的库，我们可以从缩短 URL 开始。
如果 PDF 与 python 脚本不在同一个目录中，您需要传递名称和位置。
short_url = type_tiny.tinyurl.short(long_url)
print("The Shortened URL is: " + short_url)
在输出中，我们以类似“https://tinyurl.com/mbq3m”的形式获得了缩短的 URL。而 TinyURL 是因为 URL shortener 包——Pyshortener 默认使用 TinyURL API。
使用 TinyURL 服务的最终短代码–
import pyshorteners
long_url = input("Enter the URL to shorten: ")
#TinyURL shortener service
type_tiny = pyshorteners.Shortener()
short_url = type_tiny.tinyurl.short(long_url)
print("The Shortened URL is: " + short_url)
但是我们可以改变它，这是我们将在本教程中进一步学习的内容。
4.稍微缩短网址
Bitly 是目前最受欢迎和最广泛使用的网址缩写服务。在这里，使用我们的代码，我们现在将使用它的 API 生成缩短的 URL，该 API 由 Pyshortener 库包装。
使用上面同样的方法，现在我们需要在 Shortener 方法中传递 API 键，如下所示:
type_bitly = pyshorteners.Shortener(api_key='01b6c587cskek4kdfijsjce4cf27ce2')
short_url = type_bitly.bitly.short('https://www.google.com')
你可能想知道，你现在从哪里获得 API 密钥，所以去 Bitly 网站>创建帐户>然后去设置> API(开发者)选项。该页面将如下所示:
只需通过输入您的密码生成您的帐户的访问令牌，并复制该令牌以在代码中使用。
Bitly API access token
使用 Bitly API 通过 Python 缩短 URL 的最终代码:
import pyshorteners
long_url = input("Enter the URL to shorten: ")
#Bitly shortener service
type_bitly = pyshorteners.Shortener(api_key='01b6c587cskek4kdfijsjce4cf27ce2')
short_url = type_bitly.bitly.short('https://www.google.com')
print("The Shortened URL is: " + short_url)
Bitly 服务还提供了更多的功能，如网址扩展，获得点击你的缩短网址的总次数等。
expand_url = type_bitly.bitly.expand('https://bit.ly/TEST')
print (expand_url) # gives the url in expand or original form
count = type_bitly.bitly.total_clicks('https://bit.ly/TEST') #gives total no. of clicks.
使用 API 密钥有助于我们以更好的方式管理我们的链接，因为我们现在可以在特定的 shortening service(网站)仪表板的帐户部分检查我们链接的所有详细信息和性能。
5.使用其他服务缩短 URL
Pyshortener 库包含了各种缩短服务，你可以在他们的官方文档中看到。
各种服务的示例代码如下所示:
import pyshorteners
s = pyshorteners.Shortener()
#Chilp.it
s.chilpit.short('http://www.google.com') # gives output -> 'http://chilp.it/TEST'
s.chilpit.expand('http://chilp.it/TEST')
# Adf.ly
s = pyshorteners.Shortener(api_key='YOUR_KEY', user_id='USER_ID', domain='test.us', group_id=12, type='int')
s.adfly.short('http://www.google.com') # gives output -> 'http://test.us/TEST'
#Git.io
s = pyshorteners.Shortener(code='12345')
s.gitio.short('https://github.com/TEST') # gives output -> 'https://git.io/12345'
s.gitio.expand('https://git.io/12345')
#and many more services are supported
结论
教程到此为止。希望您已经了解了 URL 的缩短，以及如何使用 Python 和多个缩短服务提供商创建 URL 缩短器。
如何在同一个笔记本中使用 R 和 Python？
原文：https://www.askpython.com/python/examples/use-r-and-python-in-the-same-notebook
如果您熟悉数据科学领域，那么您应该知道 R 和 python 是两种非常重要的语言。数据科学几乎在每个行业都有应用，从财务部门到医疗保健到营销等等。
为什么我们需要这些语言？
在数据科学领域，R 是使用最广泛的开源语言。它通常用于结构化和非结构化数据的统计分析和数据可视化。与其他数据科学语言相比，R 支持许多特性。
Python 是一种面向对象的高级编程语言。它是一种多功能、完全解释的编程语言，有许多优点，经常被用来简化大量复杂的数据收集。
在 Google Colab 中使用 R 和 Python
现在，Google Colab (Collaboratory)允许任何人通过浏览器编写和执行任意 python 代码，特别适合机器学习、数据分析和教育。
默认情况下，Colab 创建一个 python 笔记本，但是也可以在 Colab 中创建一个 R 笔记本。为此，请单击下面的链接。
https://colab.research.google.com/#create=true&语言=r
要在同一个笔记本中同时使用 R 和 python，我们需要首先激活 rpy2 包。
%load_ext rpy2.ipython
rpy2
rpy2 是一个高级接口，使 R 函数像 Python 函数一样成为一个对象，并提供到 NumPy 和 pandas 数据结构的无缝转换。在激活之后，单元以 python 语言正常执行，通过添加一个额外的方法，代码以 R 语言执行。
方法有–单元格魔术和行魔术。
1.细胞魔法
这是用来在 R 语言中运行整个单元。单元格的第一行必须是下面给出的行，从第二行开始，我们可以开始用 R 语言编写代码，代码将会成功执行。
%%R
......
.....
2.线条魔术
这用于运行 R 语言中的一行代码。单元格可以包含 python 语言的其他代码行。包含以下代码的行将在 r 中执行。
%R ...........
基本实现
Basic Implementation
安装软件包和库
在同一个笔记本中使用 R 和 python 的最大好处是，通过将库导入到 colab 笔记本中，可以使用 Python 中 R 提供的所有包。这使得数据科学家或任何从事项目工作的人的工作更加高效。
packages
将数据从一种语言导入到另一种语言
考虑从事一个同时使用 python 和 R 语言的项目。使用 rpy2 和 magic 命令，可以将数据帧从一种语言转换为另一种语言
Python 到 R
%R -i df_1
Python to R
r 到 Python
%R -o df_i
R to Python
摘要
r 和 Python 都是数据科学领域广泛使用的语言。有时可能会出现需要同时使用两种语言的情况。在本文中，我们讨论了这种情况的解决方案。我们已经学会了如何在 google colab 平台上的一个笔记本中使用两种语言。
Python 集合模块中的 UserDict 和 UserList–概述！
原文：https://www.askpython.com/python-modules/userdict-and-userlist-in-python
读者朋友们，你们好！在本文中，我们将关注 Python 集合模块中的 UserDict 和 UserList。所以，让我们开始吧！🙂
Python 集合模块——快速刷起来！
Python 为我们提供了众多模块来处理不同形式的数据，并推动自动化和可持续发展。Python 集合模块就是这样一个模块。
集合模块为我们提供了一种简单的方法来在一个屋檐下存储相似类型的数据。顾名思义，集合是一组共享相似特征的实体，集合模块提供的特性也是如此。
在本文过程中，我们将重点关注该模块提供的以下集合——
- 用户词典
- UserList
在接下来的部分中，让我们来看看它们。
了解 Python UserDict
众所周知，Python 为我们提供了字典数据结构来处理键值形式的数据。UserDict 为其添加了定制功能。
也就是说，Dictionary 帮助我们创建一个以静态格式保存键值对的数据结构。使用 UserDict，我们可以通过创建一个定制的字典来添加一些修改过的功能。
它的行为类似于字典对象周围的一个包装类。这样，我们可以很容易地向现有的 dictionary 对象添加新的行为。
UserDict 集合接受现有字典作为参数，并触发一个存储在普通 Dict 对象中的字典结构。
看看下面的语法！
collections.UserDict(data)
举例:
在下面的例子中，我们使用现有的 dictionary 对象创建了一个 UserDict。在这种情况下，字典现在可以作为属性进行更改。
from collections import UserDict
data = {'Pune':100,
'Satara': 28,
'Mumbai': 31}
user_dict = UserDict(data)
print(user_dict.data)
输出:
{'Pune': 100, 'Satara': 28, 'Mumbai': 31}
在下面的例子中，我们展示了一个定制类对 UserDict 的定制使用。
在这里，我们已经创建了一个 UserDict，它充当了一个定制列表“mydict”的包装类。
因此，它充当一个包装类，让我们将现有字典的属性添加到 UserDict 中。
这里，我们在字典中添加了一个行为，限制元素的删除。
UserDict 将默认创建的字典包装到其中，并灌输类中声明的定制行为。
举例:
from collections import UserDict
class mydata(UserDict):
def pop(self, s = None):
raise RuntimeError("Deletion not allowed")
mydict = mydata({'x':10,
'y': 20})
print(mydict)
#Deliting From Dict
mydict.pop()
输出:
{'x': 10, 'y': 20}
Traceback (most recent call last):
File "c:/Users/HP/OneDrive/Desktop/demo.py", line 15, in <module>
mydict.pop()
File "c:/Users/HP/OneDrive/Desktop/demo.py", line 7, in pop
raise RuntimeError("Deletion not allowed")
RuntimeError: Deletion not allowed
了解 Python 用户列表
像 UserDict 一样，UserList 也为我们提供了一种在 Python 中定制列表的方法，以便灌输到类中。Python List 存储了具有不同数据类型的相似类型的数据。UserList 帮助我们定制列表，并使用它们作为属性来创建用户定义的类。将列表作为实例添加后，它会触发一个列表，该列表保存在常用的列表数据结构中。
语法:
collections.UserList(list)
举例:
在这个例子中，我们利用 UserList 将常规列表作为参数存储在其中。此外，我们可以使用 UserList 集合和属性作为一个列表来创建定制的类。
from collections import UserList
lst = [1,2,3,4,5]
user_list = UserList(lst)
print(user_list.data)
输出:
[1, 2, 3, 4, 5]
在下面的例子中，我们展示了一个定制类对 UserDict 的定制使用。
在这里，我们已经创建了一个用户列表，它作为一个自定义列表“mylist”的包装类。因此，它充当一个包装类，让我们将现有字典的属性添加到用户列表中。这里，我们向列表添加了一个行为，限制元素的删除，我们甚至通过用户列表作为包装类向列表添加/插入值。UserList 将默认创建的字典包装到其中，并灌输类中声明的定制行为。
举例:
from collections import UserList
class mydata(UserList):
def pop(self, s = None):
raise RuntimeError("Deletion not allowed")
mylist = mydata([10,20,30])
mylist.append(5)
print("Insertion..")
print(mylist)
mylist.pop()
输出:
After Insertion
[10,20,30,5]
Traceback (most recent call last):
File "c:/Users/HP/OneDrive/Desktop/demo.py", line 20, in <module>
L.pop()
File "c:/Users/HP/OneDrive/Desktop/demo.py", line 7, in pop
raise RuntimeError("Deletion not allowed")
RuntimeError: Deletion not allowed
结论
到此，我们就结束了这个话题。如果你遇到任何问题，欢迎在下面评论。
更多与 Python 编程相关的帖子，请继续关注我们。
在那之前，学习愉快！！🙂
Python 中的变量范围
原文：https://www.askpython.com/python/variable-scopes-in-python
变量范围是一个有趣、有用且易于理解的概念，python 程序员在处理变量和函数之前必须了解这个概念。在本教程中，我们将讨论什么是作用域，python 具有的作用域的类型，并且我们将理解关键字global和nonlocal。
什么是范围？
一个函数、类或任何用户定义变量的范围是可以访问它的代码区域。在函数内部声明的变量只能在函数内部访问，而不能在函数外部访问，所以函数就是变量的作用域。
例如在下面的代码中:
def funcx():
x = 1
print(x)
return
def funcy():
y = 2
print(y)
return
def funcz():
z = 3
print(z)
return
变量x在funcx中声明，所以funcx是变量的作用域。同样，y的范围是funcy，而z的范围是funcz。
理解全局、局部和非局部变量范围
在 python 中，每个变量都有一个变量作用域，也就是说，有一个明确定义的变量使用范围。根据变量的使用场合，变量可以有不同类型的作用域，我们一个一个来说。
1。全局变量范围
如果一个变量可以从 python 文件中的任何地方访问，那么这个变量就是全局变量。参见下面的代码:
x = 10
print(x)
def func():
print(x)
return
func()
变量x在任何函数外部声明。这意味着可以在整个代码的任何地方访问它。在上面的例子中，x在函数func之外以及在func之内被访问。
输出:
Global: 10
Local: 10
注意:在函数中操作一个全局变量有点复杂，我们将在后面用关键字global讨论它。
2。局部变量范围
如果一个变量是在函数内部声明的，那么它就在局部范围内。这将使得该变量只能在该特定函数内部被访问，如果没有同名的全局变量，任何在函数外部访问这样一个变量的尝试都会导致错误。
def func():
x = 10
print(x)
在上面的函数中，变量x是在函数内部创建的，所以x是func的局部变量。试图访问func外的x将导致错误。
3。非局部变量范围
为了理解非局部范围，我们需要举一个例子:
def outer_func():
x = 10
print("Outside:", x)
def inner_func():
print("Inside:", x)
return
inner_func()
return
outer_func()
在函数outer_func中，我们有一个变量x，所以很明显，x对于outer_func是局部的。但是对于inner_func，x是非本地的，意味着x对于inner_func来说不是本地的，但是也不是全局的。
我们可以从inner_func访问x作为非局部变量。这是输出结果:
Outside: 10
Inside: 10
注意:从inner_func操作x稍微复杂一点，我们将在讨论非本地关键字时看到。
操作全局和非局部变量
我们已经看到，我们可以在函数中访问一个全局的和非局部的变量，但是如果我们直接试图在函数中操作这个变量，那么就会导致错误。让我们看一个例子:
x = 10
def func():
x += 1
print(x)
return
func()
现在，从逻辑上讲，我们应该能够增加x，因为它是一个全局变量，可以在任何地方访问，但这是实际的输出:
---------------------------------------------------------------------------
UnboundLocalError Traceback (most recent call last)
<ipython-input-33-07e029a18d76> in <module>
5 return
6
----> 7 func()
<ipython-input-33-07e029a18d76> in func()
1 x = 10
2 def func():
----> 3 x += 1
4 print(x)
5 return
UnboundLocalError: local variable 'x' referenced before assignment
上面写着，UnboundLocalError: local variable 'x' referenced before assignment。
Python 假设x是本地的，并告诉我们在引用它之前给它赋值。我们知道打印x会起作用，所以这意味着如果一个全局变量在函数内部被直接改变，就会发生这样的错误。
Python 中的全局关键字
为了避免所讨论的错误，我们可以对全局变量范围使用global关键字:
x = 10
def func():
global x
x += 1
print(x)
return
func()
我们可以看到，我们在函数内部将x声明为全局的，并告诉 Pythonx已经在全局范围内声明，我们将使用那个x。输出:
11
所以这次它打印了修改后的x的值。
Python 中的外地关键字
对于非局部变量范围，我们将使用nonlocal关键字来避免所讨论的错误，如下所示:
def outer_func():
x = 10
def inner_func():
nonlocal x
x += 1
print(x)
inner_func()
return
outer_func()
我们告诉 Pythonx在inner_func函数内部是非局部的。(global不起作用，因为 x 不是全局的)。
输出:
11
结论
在本教程中，我们讨论了 python 中作用域的含义，进一步讨论了什么是全局、局部和非局部变量以及如何使用它们。我们使用了两个关键字:global和nonlocal，我们看到它们在 python 代码中工作，并输出结果。
使用 Python 计算列表方差的 3 种简单方法
原文：https://www.askpython.com/python/examples/variance-of-lists
在本教程中，我们将看看 Python 中计算列表方差的各种方法。
Python 中计算列表方差的方法
在我们深入研究计算列表方差的方法之前，让我们了解一下方差的含义。
方差是统计学中至关重要的数学工具。它是用来处理海量数据的。对于给定的数据集合，它是标准差的平方。
方差也称为分布的第二中心矩。平方的平均值减去给定数据集的平均值的平方用于计算它。
变量(X) = E[(X- )2]
方法 1: Python 方差函数
Python 包含一个计算列表方差的内置函数。下面提供了语法及其参数的解释。
variance( [data], mean )
mean:非强制参数。它使用实际平均值。
方法 2:基本方法
这是计算列表方差的最基本的方法。在下面的例子中，我们使用上述公式计算平均值，然后计算方差。
我们在这里没有使用任何内置的方法，而是通过构建公式来手动计算列表的方差。
l = [1, 2, 3, 4, 5, 6]
print("The original list is : " + str(l))
length= int(len(l))
mean = sum(l) / length
ans = sum((i - mean) ** 2 for i in l) / length
print("The variance of list is : " + str(ans))
代码的输出如下所示:
The original list is : [1, 2, 3, 4, 5, 6]
The variance of list is : 2.9166666666666665
方法 3:使用统计模块
在这个例子中，我们使用了内置函数 variance()，这使得计算列表的方差变得非常容易。
import statistics
list1 = [1, 2, 3, 4, 5, 6]
print("The original list is : " + str(list1))
ans = statistics.variance(list1)
print("The variance of list is : " + str(ans))
代码的输出如下所示:
The original list is : [1, 2, 3, 4, 5, 6]
The variance of list is : 3.5
结论
恭喜你！您刚刚学习了使用 Python 编程语言计算列表方差的三种不同方法。希望你喜欢它！😇
喜欢这个教程吗？我建议你看看下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
Python 中的矢量化——完整指南
原文：https://www.askpython.com/python-modules/numpy/vectorization-numpy
在本文中，我们将学习矢量化。如今许多复杂的系统都要处理大量的数据。与 C/C++等其他语言相比，在 python 中处理如此大量的数据可能会很慢。这就是矢量化发挥作用的地方。在本教程中，我们将学习 NumPy 中对数组的矢量化操作，通过比较 Python 程序的执行时间来加速它们的执行。
Python 中的矢量化
矢量化是一种不使用 for 循环实现数组操作的技术。相反，我们使用由各种模块定义的函数，这些函数经过高度优化，减少了代码的运行和执行时间。矢量化数组操作将比纯 Python 操作更快，对任何类型的数值计算都有最大的影响。
Python for-loops 比 C/C++要慢。Python 是一种解释型语言，大部分实现都很慢。这种缓慢计算的主要原因归结于 Python 的动态特性和编译器级优化的缺乏，这导致了内存开销。NumPy 是 Python 中数组的 C 实现，它提供了对 NumPy 数组的矢量化操作。
使用 NumPy 的矢量化运算
1.标量加/减/乘/除
当用给定的标量更新数组的所有元素时，数组与标量的加、减、乘和除会产生相同维数的数组。我们应用这个操作就像我们处理变量一样。与 for 循环实现相比，代码既小又快。
为了计算执行时间，我们将使用执行语句的timeit模块中的Timer类，然后调用重复执行语句的次数的 timeit()方法。请注意，输出计算时间并不总是完全相同，而是取决于硬件和其他因素。
import numpy as np
from timeit import Timer
# Creating a large array of size 10**6
array = np.random.randint(1000, size=10**6)
# method that adds elements using for loop
def add_forloop():
new_array = [element + 1 for element in array]
# method that adds elements using vectorization
def add_vectorized():
new_array = array + 1
# Finding execution time using timeit
computation_time_forloop = Timer(add_forloop).timeit(1)
computation_time_vectorized = Timer(add_vectorized).timeit(1)
print("Computation time is %0.9f using for-loop"%execution_time_forloop)
print("Computation time is %0.9f using vectorization"%execution_time_vectorized)
Computation time is 0.001202600 using for-loop
Computation time is 0.000236700 using vectorization
2.数组的和与最大值
为了找到数组中的 sum 和 maximum 元素，我们可以分别使用 For 循环以及 python 内置方法sum()和max()。让我们用 numpy 操作来比较这两种方法。
import numpy as np
from timeit import Timer
# Creating a large array of size 10**5
array = np.random.randint(1000, size=10**5)
def sum_using_forloop():
sum_array=0
for element in array:
sum_array += element
def sum_using_builtin_method():
sum_array = sum(array)
def sum_using_numpy():
sum_array = np.sum(array)
time_forloop = Timer(sum_using_forloop).timeit(1)
time_builtin = Timer(sum_using_builtin_method).timeit(1)
time_numpy = Timer(sum_using_numpy).timeit(1)
print("Summing elements takes %0.9f units using for loop"%time_forloop)
print("Summing elements takes %0.9f units using builtin method"%time_builtin)
print("Summing elements takes %0.9f units using numpy"%time_numpy)
print()
def max_using_forloop():
maximum=array[0]
for element in array:
if element > maximum:
maximum = element
def max_using_builtin_method():
maximum = max(array)
def max_using_numpy():
maximum = np.max(array)
time_forloop = Timer(max_using_forloop).timeit(1)
time_builtin = Timer(max_using_built-in_method).timeit(1)
time_numpy = Timer(max_using_numpy).timeit(1)
print("Finding maximum element takes %0.9f units using for loop"%time_forloop)
print("Finding maximum element takes %0.9f units using built-in method"%time_builtin)
print("Finding maximum element takes %0.9f units using numpy"%time_numpy)
Summing elements takes 0.069638600 units using for loop
Summing elements takes 0.044852800 units using builtin method
Summing elements takes 0.000202500 units using numpy
Finding maximum element takes 0.034151200 units using for loop
Finding maximum element takes 0.029331300 units using builtin method
Finding maximum element takes 0.000242700 units using numpy
这里我们可以看到 numpy 操作比内置方法快得多，内置方法比循环快得多。
3.点积
也称为内积，两个向量的点积是一种代数运算，它采用两个长度相同的向量，并返回单个标量。它被计算为两个向量的元素乘积之和。就一个矩阵而言，给定大小为nx1的两个矩阵 a 和 b，通过取第一个矩阵的转置，然后进行a^T(a的转置)和b的数学矩阵乘法来完成点积。
在 NumPy 中，我们使用dot()方法来寻找 2 个向量的点积，如下所示。
import numpy as np
from timeit import Timer
# Create 2 vectors of same length
length = 100000
vector1 = np.random.randint(1000, size=length)
vector2 = np.random.randint(1000, size=length)
# Finds dot product of vectors using for loop
def dotproduct_forloop():
dot = 0.0
for i in range(length):
dot += vector1[i] * vector2[i]
# Finds dot product of vectors using numpy vectorization
def dotproduct_vectorize():
dot = np.dot(vector1, vector2)
# Finding execution time using timeit
time_forloop = Timer(dotproduct_forloop).timeit(1)
time_vectorize = Timer(dotproduct_vectorize).timeit(1)
print("Finding dot product takes %0.9f units using for loop"%time_forloop)
print("Finding dot product takes %0.9f units using vectorization"%time_vectorize)
Finding dot product takes 0.155011500 units using for loop
Finding dot product takes 0.000219400 units using vectorization
4.外部产品
两个向量的外积产生一个矩形矩阵。给定大小为 nx1 和 mx1 的两个向量 a 和bb 和【nxm】，这些向量的外积产生大小为 的矩阵。
在 NumPy 中，我们使用outer()方法来寻找两个向量的外积，如下所示。
import numpy as np
from timeit import Timer
# Create 2 vectors of same length
length1 = 1000
length2 = 500
vector1 = np.random.randint(1000, size=length1)
vector2 = np.random.randint(1000, size=length2)
# Finds outer product of vectors using for loop
def outerproduct_forloop():
outer_product = np.zeros((length1, length2), dtype='int')
for i in range(length1):
for j in range(length2):
outer_product[i, j] = vector1[i] * vector2[j]
# Finds outer product of vectors using numpy vectorization
def outerproduct_vectorize():
outer_product = np.outer(vector1, vector2)
# Finding execution time using timeit
time_forloop = Timer(outerproduct_forloop).timeit(1)
time_vectorize = Timer(outerproduct_vectorize).timeit(1)
print("Finding outer product takes %0.9f units using for loop"%time_forloop)
print("Finding outer product takes %0.9f units using vectorization"%time_vectorize)
Finding outer product takes 0.626915200 units using for loop
Finding outer product takes 0.002191900 units using vectorization
5.矩阵乘法
矩阵乘法是第一个矩阵的行乘以第二个矩阵的列的代数运算。对于 2 维矩阵 p x q 和 r x s， 一个必要条件是 q == r 对于 2 个矩阵相乘。乘法后得到的矩阵将具有维度 p x s 。
矩阵乘法是机器学习等数学模型中广泛使用的运算。计算矩阵乘法是计算成本很高的操作，并且需要快速处理以使系统快速执行。在 NumPy 中，我们用matmul()方法求 2 个矩阵的矩阵乘法，如下图。
import numpy as np
from timeit import Timer
# Create 2 vectors of same length
n = 100
k = 50
m = 70
matrix1 = np.random.randint(1000, size=(n, k))
matrix2 = np.random.randint(1000, size=(k, m))
# Multiply 2 matrices using for loop
def matrixmultiply_forloop():
product = np.zeros((n, m), dtype='int')
for i in range(n):
for j in range(m):
for z in range(k):
product[i, j] += matrix1[i, z] * matrix2[z, j]
# Multiply 2 matrices using numpy vectorization
def matrixmultiply_vectorize():
product = np.matmul(matrix1, matrix2)
# Finding execution time using timeit
time_forloop = Timer(matrixmultiply_forloop).timeit(1)
time_vectorize = Timer(matrixmultiply_vectorize).timeit(1)
print("Multiplying matrices takes %0.9f units using for loop"%time_forloop)
print("Multiplying matrices takes %0.9f units using vectorization"%time_vectorize)
Multiplying matrices takes 0.777318300 units using for loop
Multiplying matrices takes 0.000984900 units using vectorization
6.矩阵中的元素乘积
两个矩阵的元素乘积是一种代数运算，其中第一个矩阵的每个元素都乘以第二个矩阵中相应的元素。矩阵的维数应该相同。
在 NumPy 中，我们使用*运算符来查找 2 个向量的元素乘积，如下所示。
import numpy as np
from timeit import Timer
# Create 2 vectors of same length
n = 500
m = 700
matrix1 = np.random.randint(1000, size=(n, m))
matrix2 = np.random.randint(1000, size=(n, m))
# Multiply 2 matrices using for loop
def multiplication_forloop():
product = np.zeros((n, m), dtype='int')
for i in range(n):
for j in range(m):
product[i, j] = matrix1[i, j] * matrix2[i, j]
# Multiply 2 matrices using numpy vectorization
def multiplication_vectorize():
product = matrix1 * matrix2
# Finding execution time using timeit
time_forloop = Timer(multiplication_forloop).timeit(1)
time_vectorize = Timer(multiplication_vectorize).timeit(1)
print("Element Wise Multiplication takes %0.9f units using for loop"%time_forloop)
print("Element Wise Multiplication takes %0.9f units using vectorization"%time_vectorize)
Element Wise Multiplication takes 0.543777400 units using for loop
Element Wise Multiplication takes 0.001439500 units using vectorization
结论
由于执行速度更快、代码量更少，矢量化被广泛用于复杂系统和数学模型中。现在您已经知道如何在 python 中使用矢量化，您可以应用它来使您的项目执行得更快。所以恭喜你！
感谢阅读！
Python 中的维恩图
原文：https://www.askpython.com/python/examples/venn-diagrams-in-python
维恩图是最明显的数据可视化之一，用于说明两个或三个数据类别或“集合”之间的重叠约翰·维恩在 19 世纪晚期设计了这些图表；他们在一个圆圈中描绘了每组数据，重叠部分表示各组之间的相似程度。
你可能很容易就把它们画在纸上。但是你知道你可以用 python 编程语言将它们可视化吗？你猜怎么着！只用几行代码就可以实现。
让我们开始娱乐吧！
维恩图的代码实现
使用 Matplotlib 库可以创建文氏图。最简单的方法是使用 matplotlib_venn 包，这使得用更少的代码创建 venn 图变得非常简单。
我们需要安装pandas and matplotlib库，同时，我们需要在命令提示符下使用pip install matplotlib_venn安装matplotlib_venn库。
import pandas as pd
from matplotlib import pyplot as plt
from matplotlib_venn import venn2
from matplotlib_venn import venn3
熊猫将用于生成一些合成数据，并使用文氏图进行绘制。通常，在构建文氏图时，必须指定每组中的对象数量和重叠部分。
出于本教程的目的，我们将使用包含两个类别的分类数据集，包括两种不同动物的特征:猎豹和豹子。
我们将概述这两种动物的独特和共有的特征。下面的代码片段将为我们生成数据集。
data = {'Cheetahs': ['Cat family','Speed','Yellow Fur','Day Animal',
'Black spots','Black line','Same Prey','Can not climb','Mammals','No Roar'],
'Leopards': ['Cat family','Strength','Yellow Fur','Night Animal',
'Black spots','No Black line','Same Prey','Can climb','Mammals','Roar']
}
df = pd.DataFrame(data, columns = ['Cheetahs', 'Leopards'])
print(df)
VennDiagram Dataset
要创建一个包含猎豹和豹子集合的简单维恩图，我们可以调用venn2()函数并传入两个值:这两种动物的特征列表和 set_labels 的元组，即这两种动物的名称。
plt.style.use('seaborn')
plt.figure(figsize=(10,10))
plt.title("Venn Diagram For Cheetahs v/s Leopards")
venn2([set(df['Cheetahs'].to_list()),
set(df['Leopards'].to_list())],
set_labels=('Cheetahs', 'Leopards')
)
plt.show()
VennDiagram Output 1
如果您希望空白地定义集合，并使用下面的代码传递集合的差和并的值，而不是定义数据集。
plt.style.use('seaborn')
plt.figure(figsize=(10,10))
plt.title("Venn Diagram For Random Sets")
# (Set1,Set2,Union)
venn2(subsets = (20, 10, 2),
set_labels = ('SET A', 'SET B'))
plt.show()
VennDiagram Output 2
最后，让我们试着为三个集合创建一个文氏图，而不是局限于两个集合。不同之处在于，我们将使用 venn3()函数，而不是之前使用的 venn2()函数。看看下面的代码，我们随机取了 3 个集合，分布也是随机进行的。
plt.style.use('seaborn')
plt.figure(figsize=(10,10))
plt.title("Venn Diagram For Three Random Sets")
# (Set1,Set2,1n2,Set3,1n3,2n3,1n2n3)
venn3(subsets=(10, 5, 2, 8, 6, 2, 7),
set_labels=('Group A', 'Group B', 'Group C'))
plt.show()
VennDiagram Output 3
Python 中的小提琴图——简单指南
原文：https://www.askpython.com/python/examples/violin-plots-in-python
小提琴图是箱线图和显示数据峰值的核密度图的结合。它用来显示数字数据是如何分布的。与只能提供汇总统计数据的箱线图不同，violin 图显示汇总统计数据和每个变量的密度。
Violin 图用于检查数字数据的分布，对于比较不同组之间的分布尤其有效。可以比较每组密度曲线的波峰、波谷和尾部，以确定分组的相似之处和不同之处。
Violin Plot Demonstration
为什么要使用小提琴的情节？
- 小提琴图类似于箱线图和密度图，但更胜一筹！
- 这幅小提琴图很有美感。
- 即使你的数据不符合正态分布，小提琴图也是完全可以接受的。它们在可视化定量和定性数据方面都很有效。
- 读取小提琴形状类似于读取密度图:较厚的部分表示小提琴该区域的值具有较大的频率。相比之下，较薄的部分表示频率较低。
用 Python 绘制小提琴图
在开始代码实现之前，让我们先看看 Python 中的库，这些库可用于在 Python 中实现 Violin 情节。
Python 中的库，可用于制作小提琴图
Seaborn
Seaborn 是在 Python 的基础可视化工具包 Matplotlib 之上开发的。它应该是一种补充，而不是替代。另一方面，Seaborn 有几个极其重要的特征。
了解更多关于 seaborn @ Python Seaborn 教程
Matplotlib
Matploitlib 是一个用于绘图的 Python 库。它提供了面向对象的 API，用于将情节集成到程序中。这是一个跨平台的工具包，用于从数组数据创建 2D 图表。它提供了一个面向对象的 API，用于在基于 Python GUI 工具包的应用程序中嵌入图表。
了解更多关于 seaborn @Python Matplotlib 教程
阴谋地
Python Plotly Toolkit 是一个开源库，可以轻松地可视化和理解数据。Plotly 提供了多种绘图类型，如折线图、散点图、直方图、cox 图等。
阅读更多关于 seaborn @Python Plotly 教程
使用 Seaborn 库可视化小提琴情节
下面显示的第一个代码展示了如何在 Seaborn 中创建一个水平的 violin 情节。我们正在利用来自 seaborn 图书馆的提示数据集。我们将‘total bill’列发送给sns.violinplot()方法，并利用调色板使其变为绿色。
import seaborn as sns
sns.set_theme(style="whitegrid")
T = sns.load_dataset("tips")
Ax = sns.violinplot(x=T["total_bill"], palette="Greens")
**
Violin Plot Seaborn 1**
第二段代码演示了如何组合两个变量来创建一个垂直的小提琴图。我们将可视化数据和调色板作为“冷色调”传递
Ax = sns.violinplot(x="day", y="total_bill", data=T, palette="coolwarm")
**
Violin Plot Seaborn 2**
使用 Matplotlib 库可视化小提琴情节
为了使用 matplotlib 绘制 violin 图，我们将创建一个正态分布，并将数据和 Violin 图的一些其他属性一起传递给plt.violinplot函数。
import matplotlib.pyplot as plt
import numpy as np
np.random.seed(10)
D1 = np.random.normal(100, 10, 200)
D2 = np.random.normal(80, 30, 200)
data_to_plot = [D1, D2,]
fig = plt.figure()
plt.violinplot(data_to_plot,showmeans=True, showextrema=True, showmedians=True)
plt.show()
**
Violin Plot Matplotlib**
使用 Plotly 库可视化小提琴情节
violin 图是使用 tips 数据集绘制的，该数据集在下面提到的代码中演示:
import plotly.express as px
df = px.data.tips()
fig = px.violin(df, y="total_bill")
fig.show()
**
Violin Plot Plotly**
结论
恭喜你！您刚刚学习了如何用 Python 编程语言绘制小提琴图。希望你喜欢它！😇
喜欢这个教程吗？无论如何，我建议你看一下下面提到的教程:
感谢您抽出时间！希望你学到了新的东西！！😄
