StudyTonight-Python-中文教程-二-
StudyTonight Python 中文教程（二）
原文：StudyTonight
NumPy center()功能
在本教程中，我们将介绍 Numpy 库中 char 模块的center()功能。
center()功能用于返回所需宽度的输入数组的副本，以便字符串的输入数组居中并用 fillchar 进行左右填充。
- 简单来说，这个函数从输入字符串中创建并返回一个新字符串，这个新字符串是，在左侧和右侧都填充了指定的字符。
- 这个函数基本上对数组的每个元素都调用
str.center。
numpy.char.center()的语法:
使用该函数所需的语法如下:
numpy.char.center(a, width, fillchar=' ')
以上语法表明center()函数取两个参数。
参数:
现在让我们看看这个函数的参数:
-
a
该参数表示将应用函数的字符串或字符串数组。 -
宽度
该参数表示结果字符串的长度。 -
填充字符
该参数表示要用作填充符的填充字符，该参数的默认值为空格。
返回值:
这个函数返回一个用指定字符填充的新字符串。
示例 1:使用字符串
代码片段如下，我们将使用带有简单字符串的center()函数:
import numpy as np
a1 = "StudyTonight!"
print("Padding the Inut string through left and right with the fill char ^:");
x = np.char.center(a1, 30, '^')
print(x)
用填充字符^:
^^^^^^^^StudyTonight 填充 Inut 字符串的左右两端！^^^^^^^^^
示例 2:使用字符串数组
在下面的代码中，我们将对字符串数组使用center()函数。这个函数对数组中的每个字符串元素都以相同的方式起作用，就像它对上面例子中的单个字符串所做的那样。
import numpy as np
arr= np.array(['StudyTonight', 'Online', 'Portal'])
print("The Original Array :")
print(arr)
output = np.char.center(arr, 30, '^')
print("\nThe Resultant array :")
print(output)
原阵:
【【StudyTonight】【上线】【传送门】】
合阵:
【'^^^^^^^^studytonight^^^^^^^^' '^^^^^^^^^^^online^^^^^^^^^^^'
'^^^^^^^^^^^portal^^^^^^^^^^^'】
摘要
在本教程中，我们介绍了用于向数组中的字符串或字符串元素添加填充的center()函数。我们介绍了两个不同的代码示例，展示了针对单个字符串和字符串数组的center()函数。
NumPy join()函数
在本教程中，我们将介绍 Python 中 Numpy 库的 char 模块中的join()函数。
join()函数用于向任意给定字符串或给定字符串数组的所有元素添加分隔符或字符串。举个简单的例子，如果你有一个字符串“ STUDY ”，你想用“ - ”作为分隔符，那么使用join()函数输出的将是“ S-T-U-D-Y ”。
这个函数基本上在数组的每个元素内部调用str.join函数。
numpy.char.join()的语法:
使用该函数所需的语法如下:
numpy.char.join(sep, seq)
以上语法表明join()函数取两个参数。
参数:
现在让我们看看这个函数的参数:
-
sep
这个参数代表一个用作分隔符的字符串/字符数组。 -
seq
此参数指示将对其执行操作的输入数组或字符串。
返回值:
此函数返回带有连接元素的字符串或 Unicode 输出数组。
示例 1:使用简单的字符串
该函数的基本示例如下:
import numpy as np
a = np.char.join(':','DG')
print("The Joined string in the output:")
print(a)
输出中的连接字符串:
D:G
示例 2:使用字符串数组
在下面的代码片段中，我们将对字符串数组使用join()函数，该函数对数组中的每个字符串元素使用唯一的搜索符。
import numpy as np
inp = np.array(['Apple', 'Python', 'NumPy','StudyTonight'])
print ("The original Input array : \n", inp)
sep = np.array(['^', '+', '*','-'])
output= np.char.join(sep, inp)
print ("The Output joined array: ", output)
原始输入数组:
[' apple ' ' python ' ' numpy ' ' study now ']
输出连接数组:【'apple' ' p+y+t+h+o+n ' ' n * u * m * p * y ' s-t-u-d-y-t-o-n-I-g-h-t ']
示例 3:使用分隔符字符串
在这个代码示例中，我们将对给定数组的所有字符串元素使用单个分隔符字符串。
import numpy as np
inp = np.array(['Apple', 'Python', 'NumPy','StudyTonight'])
print ("The original Input array : \n", inp)
sep = np.array(['^^^'])
output= np.char.join(sep, inp)
print ("The Output joined array: ", output)
原始输入数组:
[“apple”“python”“numpy”“study now”]
输出连接数组:【'a^^p^p^l^^e' 'p^^y^t^h^o^^n' 'n^^u^m^p^^y'
's^^t^u^d^y^t^o^n^i^g^h^^t'】
摘要
在本教程中，我们介绍了 Numpy 库的join()函数，该函数用于通过提供分隔符或字符串向任何字符串或字符串数组的所有元素添加分隔符。
NumPy split()函数
在本教程中，我们将介绍 Numpy 库中 char 模块的split()功能。
split()功能用于在输入字符串被指定分隔符 (sep) 打断后返回字符串列表。
这个函数通常在数组的每个元素上内部调用str.split。
numpy.char.split()的语法:
使用该函数所需的语法如下:
numpy.char.split(a, sep=None, maxsplit=None)
以上语法表明split()函数取两个参数。
参数:
让我们讨论一下这个函数的参数:
-
a
该参数表示输入字符串或字符串的输入数组 -
sep
可以是字符串，也可以是 Unicode(单字符)。如果没有指定sep或者是None，那么默认情况下空白字符串用作分隔符。 -
maxsplit
是整数，如果给定，最多做 maxsplit splits。
返回值:
该函数将返回一个分裂字符串值列表的数组作为输出。
示例 1:使用简单的字符串
代码片段如下，我们将在其中使用split()函数:
import numpy as np
a = "How you doing?"
print("The input is :\n",a)
y = np.char.split(a)
print("after applying split() method output is:\n",y)
输入是:
你好吗？
应用 split()方法后输出为:
[“怎么样”、“你”、“在干什么？”]
示例 2:带maxsplit参数
在下面的例子中，我们将使用split()函数的maxsplit参数。在下面的代码中，我们将尝试基于逗号(，)来拆分给定的字符串，您会看到虽然完整的字符串中有 2 个逗号，但该字符串只会被拆分一次，因为我们提供的maxsplit参数值为 1 。
import numpy as np
x = "We, very happily, welcome you all!"
print("The String is:\n", x)
out = np.char.split(x, sep=',', maxsplit=1)
print("The output is:", out)
字符串是:
我们，非常高兴，欢迎大家！
输出是:【‘我们’，‘非常高兴，欢迎大家！’]
如果我们不提供 maxsplit 参数，那么输出将是: [“我们”，“非常高兴”，“欢迎大家！”】
就像在上面的例子中，我们已经在字符串上使用了函数，我们也可以在字符串数组上使用函数。
示例 3:使用字符串数组
在下面的示例中，我们将对字符串数组应用 split()方法。
import numpy as np
inp = np.array(['Dance-Tonight', 'Sleep-Tonight', 'Walk-Tonight','Study-Tonight'])
print ("The original Input array : \n", inp)
output= np.char.split(inp, sep='-', maxsplit=1)
print ("The output split array: ", output)
原输入数组:
【“跳舞-今晚”“睡觉-今晚”“散步-今晚”“学习-今晚”】
输出拆分数组:【列表(【“跳舞”、“今晚”】)列表(【“睡觉”、“今晚”】)
列表(【“散步”、“今晚”】)列表(【“学习”、“今晚”】)】】
摘要
在本教程中，我们已经用多个代码示例介绍了 Numpy 库的split()函数，以帮助您理解split()函数。
NumPy title()函数
在本教程中，我们将介绍 Numpy 库的title()功能。
title()功能用于将输入字符串转换为标题大小写版本。
-
需要注意的是，标题大小写单词总是以大写字符开头，其余所有字符都是小写字符。如果一个字符串有多个单词，那么所有的单词都被转换成标题大小写。例如，如果我们有一个字符串“我爱 StudyTonight”，如果我们在这个字符串上使用 title()函数，它将被更改为“我爱 StudyTonight”。
-
这个函数在内部为数组的所有元素调用
str.title。 -
对于 8 位字符串，该函数依赖于区域设置。
numpy.char.title()的语法:
使用该函数所需的语法如下:
numpy.char.title(arr)
以上语法表明title()函数取两个参数。
在上面的语法中，参数arr表示将应用该方法的字符串输入数组。
返回值:
该函数将返回对应于原始字符串的标题字符串。如果您提供一个字符串数组，那么所有的字符串元素都将被更改为 titlecased。
示例 1:使用字符串
下面是一个基本的代码示例，我们在一个线程上使用了title()函数:
import numpy as np
a = "this is my string"
print("The original string:")
print(a)
print("\n")
print("Applying title() method :")
x = np.char.title(a)
print(x)
原弦:
这是我的弦
施题()法:
这是我的弦
例 2:
在本例中，我们将使用带有大写字符的字符串的title()函数来查看title()函数如何改变它:
import numpy as np
a = "Titlecased StrINg "
print("The original string:")
print(a)
print("\n")
print("Applying title() method :")
x = np.char.title(a)
print(x)
原字符串:
标题字符串
应用标题()方法:
标题字符串
示例 3:使用字符串数组
现在让我们使用带有字符串值数组的title()函数:
import numpy as np
arr = np.array(['what aRE YOUR', 'plans for Tonight', 'will you','study tonight'])
print ("The original Input array : \n", arr)
output = np.char.title(arr)
print ("The output titlecased array: ", output)
原始输入数组:
[“你今晚有什么计划”“你今晚会学习吗”]
输出标题数组:【“你今晚有什么计划”“你今晚会学习吗”】
摘要
在本教程中，我们学习了 Numpy 库的title()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及几个例子，看看这个函数如何处理字符串和字符串数组。
NumPy lower()函数
在本教程中，我们将介绍 Numpy 库中 char 模块的lower()功能。
lower()功能用于将所有大写字符转换为小写字符。如果给定字符串中没有大写字符，那么这个方法将返回原始字符串本身。
这个函数在内部为任何给定数组的每个元素调用str.lower。
对于 8 位字符串，该函数依赖于区域设置。
numpy.char.lower()的语法:
使用该函数所需的语法如下:
numpy.char.lower(arr)
以上语法表明lower()函数取两个参数。
在上面的语法中，参数arr表示将应用此方法的字符串的输入数组。
返回值:
这个函数将返回一个对应于原始字符串的小写字符串。如果您提供一个字符串数组作为输入，那么它将返回一个所有字符串都是小写的数组。
示例 1:使用简单的字符串
在下面的代码片段中，我们将对字符串使用lower()函数:
import numpy as np
a = "THIS IS A String in NUMPY"
print("The original string:")
print(a)
print("\n")
print("Applying lower() method :")
x = np.char.lower(a)
print(x)
原弦:
这是 numpy 中的弦
应用 lower()方法:
这是 NUMPY 中的弦
例 2:
下面我们有一个代码片段，其中我们将使用一个已经是小写的字符串，然后检查输出是否相同:
import numpy as np
a = "string1"
print("The original string:")
print(a)
print("\n")
print("Applying lower() method :")
x = np.char.lower(a)
print(x)
原弦:
弦 1
敷下()法:
弦 1
示例 3:使用字符串数组
现在让我们对字符串数组使用 lower()函数。它将对数组的每个字符串元素起作用，就像这个函数对单个字符串起作用一样。
import numpy as np
arr = np.array(['what aRE YOUR', 'Plans for Tonight', 'WILL you','Studyonight'])
print ("The original Input array : \n", arr)
output = np.char.lower(arr)
print ("The output lowercased array: ", output)
原始输入数组:
[“你今晚有什么计划”“你会‘学习’吗”]
输出低位数组:【“你今晚有什么计划”“你会‘学习’吗】
摘要
在本教程中，我们已经介绍了 Numpy 库的lower()功能。我们介绍了如何使用它的语法和这个函数返回的值，并提供了几个示例来查看函数的运行情况。
NumPy isupper()函数
原文：https://www.studytonight.com/numpy/numpy-isupper-function
在本教程中，我们将介绍 Numpy 库中可用的 char 模块的isupper()功能。
如果字符串元素的所有字符都是大写的，则isupper()函数为数组的每个字符串元素返回真。否则，该功能将返回假。对于空字符串和特殊字符，它将返回假。
该函数在内部为数组的每个元素调用str.isupper。
对于 8 位字符串，该函数依赖于区域设置。
numpy.char.isupper()的语法:
使用该函数所需的语法如下:
numpy.char.isupper(arr)
以上语法表明isupper()函数取单个参数。
在上面的语法中，参数arr主要用于指示将应用该函数的字符串的输入数组。
返回值:
该函数将返回一个布尔值的输出数组，根据字符串是否大写，每个字符串元素对应一个真值和一个假值。
示例 1:使用字符串
在下面的例子中，我们将使用带有简单字符串的isupper()函数:
import numpy as np
string1 = "THIS IS AN APPLE"
x = np.char.isupper(string1)
print("After applying isupper() Function:")
print(x)
应用 isupper()函数后:
真
例 2:
在下面的代码片段中，我们将对字符串数组使用isupper()函数:
import numpy as np
inp_ar = np.array(['ss4Q', 'OOPS', 'WooHoo2'])
print ("The input array : \n", inp_ar)
output = np.char.isupper(inp_ar)
print ("The output array :\n", output)
输入数组:
[' ss4Q ' ' OOPS ' ' wooo 2 ']
输出数组:
[假真假]
摘要
在本教程中，我们学习了 Numpy 库中的isupper()函数。我们介绍了如何使用它的语法和这个函数返回的值。有两个例子可以帮助你理解这个函数的工作原理。
NumPy isnumeric()函数
原文：https://www.studytonight.com/numpy/numpy-isnumeric-function
在本教程中，我们将介绍 Numpy 库中 char 模块的isnumeric()功能。
如果字符串中只有数字字符，NumPy 库的isnumeric()函数将返回真，否则，该函数将返回假。
-
该函数以元素方式调用
unicode.isnumeric。 -
需要注意的是，数字字符通常包括数字字符和所有具有 Unicode 数值属性的字符(意味着字符有一个数值，该数值可以是十进制的，包括零和负数，也可以是普通分数)
isnumeric()的语法:
使用该函数所需的语法如下:
numpy.char.isnumeric(arr)
以上语法表明isnumeric()函数取单个参数。
在上面的语法中，参数arr主要用于指示字符串或单个字符串的输入数组，该函数将应用于该数组。
返回值:
该函数将返回一个布尔值的输出数组，根据字符串是否为数字，每个字符串元素对应真和假值。
示例 1:使用字符串
在下面的例子中，我们将使用带有简单字符串的isnumeric()函数:
import numpy as np
string1 = "12Apple90"
print("The Input string is:")
print(string1)
x = np.char.isnumeric(string1)
print("The Output is:")
print(x)
输入字符串为:
12 应用 90
输出为:
假
示例 2:使用数组
代码片段如下，我们将在其中使用isnumeric()函数:
import numpy as np
inp_ar = np.array([ '1', '2000','90','3.5','0'] )
print ("The Input array : ")
print(inp_ar)
outp_arr = np.char.isnumeric(inp_ar)
print ("The Output array: ")
print(outp_arr)
输入数组:
['1' '2000' '90' '3.5' '0']
输出数组:
【真真假假真】
正如您在上面代码示例的输出中看到的那样，isnumeric()函数返回 False 作为带有十进制数值的字符串。
摘要
在本教程中，我们学习了 Numpy 库的isnumeric()功能。我们介绍了如何使用它的语法和这个函数返回的值。有两个例子可以帮助你理解这个函数的工作原理。
NumPy isalpha()函数
原文：https://www.studytonight.com/numpy/numpy-isalpha-function
在本教程中，我们将介绍 Numpy 库中 char 模块的isalpha()功能。
如果字符串元素中的所有字符都是字母，则isalpha()函数返回真，否则，该函数将返回假。
该函数在内部为数组的每个元素调用str.isalpha。
对于 8 位字符串，该函数依赖于区域设置。
-
如果元素包含混合字符(字母和数字)，则该函数将返回假。
-
如果字符串中有空格，该函数也返回假。
isalpha()的语法:
使用该函数所需的语法如下:
numpy.char.isalpha(arr)
以上语法表明isalpha()函数取单个参数。
在上面的语法中，参数arr主要用于指示将应用该函数的字符串的输入数组。
返回值:
该函数将返回一个布尔值的输出数组，根据字符串是否大写，每个字符串元素对应 True 和 False 值。
示例 1:使用字符串数组
让我们以字符串数组作为第一个例子:
import numpy as np
inp_ar = np.array([ 'Ram', 'Mohan', 'Apple9','Chair s'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isalpha(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
[“拉姆”“莫汉”“苹果 9”“椅子的”]
输出为:
【真真假假】
示例 2:使用字母数值数组
在下面的代码片段中，我们将对数组中的字母数字值使用isalpha()函数:
import numpy as np
inp_ar = np.array([ 'Superb !', 'Amazing!', 'fab','cool123'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isalpha(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
['太好了！'“太神奇了！”fab' 'cool123']
输出为:
【假假真假】
摘要
在本教程中，我们学习了 Numpy 库的isalpha()功能。我们通过一些代码示例介绍了如何使用它的语法和这个函数返回的值。
NumPy index()函数
在本教程中，我们将介绍 Numpy 库中 char 模块的index()功能。
index()函数用于在给定的字符串数组中执行字符串搜索操作。如果我们有一个字符串数组，那么这个函数将提供要搜索的任何子字符串的第一个索引，如果它存在于数组元素中的话。
-
该函数类似于 # NumPy
find()函数，但index()和find()函数之间唯一的区别是，如果没有为任何字符串找到子串，则index()函数将引发值错误异常。 -
该函数为给定数组的每个元素调用
str.index。
index()的语法:
使用该函数所需的语法如下:
numpy.char.index(a, sub, start=0, end=None)
以上语法表示index()函数取 4 个参数，如上图。
参数:
现在让我们讨论这个函数的参数:
-
a
该参数表示字符串或 Unicode 的数组。 -
子
该参数表示要搜索的子串。 -
开始
这是一个可选的参数，指示子串应该从哪里开始搜索的起始索引。 -
end
这是一个可选参数，指示子串应该搜索到的结束索引。
返回值:
该函数将返回一个整数值的输出数组，其中包含对应于输入数组中每个字符串元素的子字符串(如果找到)的索引值。如果在所有数组元素中没有找到子串，那么这个函数将抛出一个值错误。
例 1:
现在，我们将看一下代码片段，其中我们想要搜索输入字符串中存在的子字符串，并查看相同的输出:
import numpy as np
ar = np.array(['bBaBaBb', 'baAbaB', 'abBABba'])
print ("The Input array :\n ", ar)
output = np.char.index(ar, sub ='b')
print ("The Output array:\n", output)
输入数组:
[' bBaBaBb ' ' baAbaB ' ' abbaba ']
输出数组:
[0 0 1]
例 2:
下面是我们想要搜索输入字符串中不存在的子字符串的代码片段，并查看其输出:
import numpy as np
ar = np.array(['bBaBaBb', 'baAbaB', 'abBABba'])
print ("The Input array :\n ", ar)
output = np.char.index(ar, sub ='c')
print ("The Output array:\n", output)
输入数组:
[' bBaBaBb ' ' baAbaB ' ' abbaba ']
值错误:找不到子字符串
摘要
在本教程中，我们介绍了 Numpy 库的index()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及一些简单的代码示例。
NumPy startswith()函数
原文：https://www.studytonight.com/numpy/numpy-startswith-function
在本教程中，我们将介绍 Numpy 库中 char 模块的startswith()功能。
startswith()函数返回一个布尔数组，其值可以是真或假。如果给定字符串以函数中指定的前缀值开始，该函数将返回真。因此这个函数名副其实。
如果与数组一起使用，这个函数调用str.startswith来执行数组的所有字符串元素。
startswith()的语法:
使用该函数所需的语法如下:
numpy.char.startswith(a, prefix, start=0, end=None)
以上语法表明isspace()函数取 4 个参数。
在上面的语法中，参数“a”主要用于指示将应用此函数的字符串的输入数组。
参数:
现在让我们讨论这个函数的参数:
-
a
该参数表示字符串或 Unicode 的数组。 -
前缀
该参数表示在所有字符串中检查的前缀值。 -
开始，结束
这两个参数都是可选的。使用可选的开始参数，搜索从该位置开始，使用可选的结束参数，功能在该位置停止比较。
返回值:
这个函数返回一个布尔值数组。
例 1:
如果前缀确实存在于输入字符串中，让我们检查这个函数的输出:
import numpy as np
arr = "The Grass is greener on the other side always"
print("The Input:\n",arr)
prefix = 'Th'
x = np.char.startswith(arr, prefix, start = 0, end = None)
print("The output is :")
print (x)
输入:
那边的草总是更绿
输出为:
真
例 2:
如果输入字符串中不存在前缀，让我们检查这个函数的输出:
import numpy as np
arr = "The Grass is greener on the other side always"
print("The Input:\n",arr)
prefix = 'It'
x = np.char.startswith(arr, prefix, start = 0, end = None)
print("The output is :")
print (x)
输入:
那边的草总是更绿
输出为:
假
摘要
在本教程中，我们学习了 Numpy 库的startswith()功能。我们介绍了如何使用它的语法和这个函数返回的值。有几个例子是为了了解这个函数的工作原理。
NumPy isspace()函数
原文：https://www.studytonight.com/numpy/numpy-isspace-function
在本教程中，我们将介绍 Python 中 Numpy 库的 char 模块中的isspace()函数。
如果元素中的所有字符都是空格，NumPy 库的isspace()函数返回真，否则，该函数将返回假。
-
该函数为数组的每个元素调用
str.isspace。 -
对于 8 位字符串，该函数依赖于区域设置。
isspace()的语法:
使用该函数所需的语法如下:
numpy.char.isspace(arr)
以上语法表明isspace()函数取单个参数。
在上面的语法中，参数arr主要用于指示将要应用该函数的字符串的输入数组。
返回值:
该函数将返回一个布尔值的输出数组，根据字符串是否只有空格，每个字符串元素对应的值为真和假。
例 1:
在下面的例子中，我们将对包含空格和一些字母的字符串使用这个函数。
import numpy as np
inp_ar = np.array([ 'Superb !', 'Amazing!'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isspace(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
['太好了！'“太神奇了！”】
输出为:
【假假】
例 2:
在下面的代码片段中，我们将使用带有空格和换行符的字符串的isspace()函数:
import numpy as np
inp_ar = np.array([ '\n', '\t',' ','abc nb'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isspace(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
[' \ n ' ' \ t ' ' ' ABC nb ']
输出为:
【真真假】
摘要
在本教程中，我们学习了 Numpy 库中的isspace()函数。我们已经介绍了如何使用它的语法和这个函数返回的值。
NumPy isdigit()函数
原文：https://www.studytonight.com/numpy/numpy-isdigit-function
在本教程中，我们将介绍 Numpy 库的 char 模块的isdigit()功能。
isdigit()函数返回真如果元素中的所有字符都是数字或数字，则该函数返回假。
-
该函数对数组的每个元素调用
str.isdigit。 -
对于 8 位字符串，该函数依赖于区域设置。
numpy.char.isdigit()的语法:
使用该函数所需的语法如下:
numpy.char.isdigit(arr)
以上语法表明isdigit()函数取单个参数。
在上面的语法中，参数arr主要用于指示将应用该函数的字符串的输入数组。
返回值:
该函数将返回一个布尔值的输出数组，根据字符串是否只包含数字，每个字符串元素对应真和假值。
例 1:
下面我们有一个简单的代码示例，其中我们将isdigit()函数用于字符串数组，其中一些字符串只包含数字，而另一些字符串也包含其他字符:
import numpy as np
inp_ar = np.array([ '20002', '10009', '12345ab','01'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isdigit(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
[' 20002 ' ' 10009 ' ' 12345 ab ' ' 01 ']
输出为:
【真真假假真】
例 2:
在代码片段中，我们将使用带有字符串数组的isdigit()函数，其中一些字符串包含空格和其他字符(数字除外):
import numpy as np
inp_ar = np.array([ '20002 2', 'a10009', '12345 ab','01'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isdigit(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
[' 20002 2 ' ' a 10009 ' ' 12345 ab ' ' 01 ']
输出为:
【假假假真】
摘要
在本教程中，我们学习了 Numpy 库的isdigit()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及一些使用这个函数的例子。
NumPy isdecimal()函数
原文：https://www.studytonight.com/numpy/numpy-isdecimal-function
在本教程中，我们将介绍 Numpy 库中 char 模块的isdecimal()功能。
如果元素中只有十进制字符，则isdecimal()函数返回真，否则，该函数将返回假。
这个函数为数组的每个字符串元素调用unicode.isdecimal。
需要注意的是十进制字符包括数字字符和所有可以用来形成十进制基数数字的字符，例如 U+0661 、阿拉伯-印度数字一等。
isdecimal()的语法:
使用该函数所需的语法如下:
numpy.char.isdecimal(arr)
以上语法表明isdecimal()函数取单个参数。
在上面的语法中，参数arr主要用来表示字符串的输入数组。
返回值:
该函数将返回一个布尔值的输出数组，其形状类似于输入数组。
例 1:
在这个代码示例中，我们将使用带有简单字符串的isdecimal()函数:
import numpy as np
string1 = "12342"
print("The Input string is:")
print(string1)
x = np.char.isdecimal(string1)
print("The Output is:")
print(x)
输入字符串为:
12342
输出为:
真
例 2:
在下面的代码片段中，我们将对字符串数组使用isdecimal()函数:
import numpy as np
inp_ar = np.array([ '20002 2', 'a10009', '12345 ab','01'] )
print("The Input string is:")
print(inp_ar)
x = np.char.isdecimal(inp_ar)
print("The Output is:")
print(x)
输入字符串为:
[' 20002 2 ' ' a 10009 ' ' 12345 ab ' ' 01 ']
输出为:
【假假假真】
摘要
在本教程中，我们学习了 Numpy 库中的isdecimal()函数。我们介绍了如何使用它的语法和这个函数返回的值，以及多个代码示例。
NumPy upper()函数
在本教程中，我们将介绍 Numpy 库中 char 模块的upper()功能。
upper()功能用于将字符串的所有小写字符转换为大写。如果给定字符串中没有小写字符，那么这个函数将返回原始字符串。
-
这个函数通常对数组的所有元素调用
str.upper。 -
对于 8 位字符串，该函数依赖于区域设置。
numpy.char.upper()的语法:
使用该函数所需的语法如下:
numpy.char.upper(arr)
以上语法表明upper()`` 函数取两个参数。
在上面的语法中，参数arr主要用于指示将应用此方法的字符串的输入数组。
返回值:
这个函数将返回一个对应于原始字符串的大写字符串。
示例 1:使用字符串
在下面的代码片段中，我们将对一个简单的字符串使用upper()函数:
import numpy as np
a = "this is a string in numPy"
print("The original string:")
print(a)
print("\n")
print("Applying upper() method :")
x = np.char.upper(a)
print(x)
原弦:
这是 NUMPY 中的弦
应用上()方法:
这是 numPy 中的弦
例 2:
下面是一个代码片段，我们将使用一个已经大写的字符串，然后检查输出是否相同:
import numpy as np
a="THIS IS AN UPPERCASE STRING"
print("The original string:")
print(a)
print("\n")
print("Applying upper() method :")
x=np.char.upper(a)
print(x)
原弦:
这是大写的弦
应用上()方法:
这是大写的弦
示例 3:使用字符串数组
就像上面两个例子一样，如果我们创建一个字符串数组，然后将这个函数用于数组，它会将所有字符串元素转换为大写。
import numpy as np
arr = np.array(['what aRE YOUR', 'plans for Tonight', 'will you','study tonight'])
print ("The original Input array : \n", arr)
output = np.char.upper(arr)
print ("The output array: ", output)
原始输入数组:
[“你今晚有什么计划”“你今晚会学习吗”]
输出数组:【“你今晚有什么计划”“你今晚会学习吗”】
摘要
在本教程中，我们介绍了 Numpy 库中的upper()函数。我们介绍了如何使用它的语法和这个函数返回的值，以及多个代码示例。
NumPy capitalize()函数
原文：https://www.studytonight.com/numpy/numpy-capitalize-function
在本教程中，我们将介绍 Numpy 库中 char 模块的capitalize()功能。
capitalize()功能基本上是用来将字符串的第一个字符转换成大写的(大写)字母。如果字符串的第一个字符已经是大写的，那么这个函数将返回原始字符串本身。
该函数以元素方式调用str.capitalize。
对于 8 位字符串，此函数依赖于区域设置。
capitalize()的语法:
使用该函数所需的语法如下:
numpy.char.capitalize(arr)
以上语法表明capitalize()函数取两个参数。
在上面的语法中，参数arr主要用于指示将应用该函数的字符串的输入数组。
返回值:
该函数将返回一个以大写字母开头的字符串。
示例 1:使用字符串
代码片段如下，我们将使用带有简单字符串的capitalize()函数:
import numpy as np
a = "welcome to StudyTonight!!"
print("The original string:")
print(a)
print("Capitalizing the string using capitalize() function :")
x = np.char.capitalize(a)
print(x)
原弦:
欢迎 StudyTonight！！
使用大写()函数将字符串大写:
欢迎 StudyTonight！！
例 2:
下面是一个代码片段，我们将使用一个已经大写的字符串作为输入，然后检查输出是否相同:
import numpy as np
a = "StudyTonight is a best place to learn coding online"
print("The original string:\n")
print(a)
print("\n")
print("Capitalizing the string using capitalize() function:\n")
x = np.char.capitalize(a)
print(x)
原字符串:
学习今晚是在线学习编码的最佳地点
使用大写()函数将字符串大写:
学习今晚是在线学习编码的最佳地点
示例 3:使用字符串数组
在这个例子中，我们将获取一个字符串数组，并将使用capitalize()函数:
import numpy as np
arr = np.array(['what aRE YOUR', 'plans for Tonight', 'will you','study tonight'])
print ("The original Input array : \n", arr)
output = np.char.capitalize(arr)
print ("The output array: ", output)
原始输入数组:
[“你今晚有什么计划”“你今晚会学习吗”]
输出数组:【“你今晚有什么计划”“你今晚会学习吗”】
在输出中，您应该注意到，该函数不仅将字符串中的第一个字符更改为大写，而且如果其他字符是大写的，它也会将它们更改为小写，就像上面示例中对字符串“ what aRE YOUR 所做的那样。
摘要
在本教程中，我们学习了 Numpy 库中的capitalize()函数。我们介绍了如何使用它的语法和这个函数返回的值，以及多个代码示例。
NumPy swapcase()函数
原文：https://www.studytonight.com/numpy/numpy-swapcase-function
在本教程中，我们将介绍 Numpy 库中 char 模块的swapcase()功能。
swapcase()函数主要用于返回字符串的逐元素副本，字符串的大写字符转换为小写字符，小写字符转换为大写字符。简而言之，它交换或改变给定字符串中字符的大小写。
对于 8 位字符串，此函数依赖于区域设置。
swapcase()的语法:
使用该函数所需的语法如下:
numpy.char.swapcase(arr)
以上语法表明capitalize()函数取两个参数。
注: 在上面的语法中，arr参数表示输入数组，可以是字符串或 Unicode 的形式。
返回值:
该函数将返回小写大写值的字符串副本，反之亦然。
让我们介绍一些与此功能相关的示例。
例 1:
在下面给出的代码片段中，我们将对包含字符串的数组应用swapcase()函数:
import numpy as np
inp = np.array(['A4B C', '4c Rb', 'B Ec4', 'rp4q'])
print("The input array is: ")
print(inp)
outp = np.char.swapcase(inp)
print("The output swapcased array :")
print(outp)
输入数组为:
[' A4B C ' ' 4C Rb ' ' B Ec4 ' ' RP4Q ']
输出数组为:
['a4b c' '4C rB' 'b eC4' 'RP4Q']
例 2:
我们再举一个例子:
import numpy as np
a= np.array(['WELCOMe', 'to', 'StuDyToNIGHT'])
print ("The input array is: ", a)
b = np.char.swapcase(a)
print ("The output swapcased array :", b)
输入数组为:[“欢迎”到“StudyTonight”]
输出数组为:[“欢迎”到“StudyTonight”]
摘要
在本教程中，我们学习了 Numpy 库中的swapcase()函数。我们介绍了如何使用它的语法和这个函数返回的值，以及多个代码示例。
NumPy strip()函数
在本教程中，我们将介绍 Numpy 库的 char 模块中可用的strip()函数。
strip()功能用于为数组中的每个元素去除前导和尾随字符。我们可以指定要删除的字符，否则默认情况下，该函数将从字符串中删除多余的前导空格和尾随空格。
这个函数基本上以元素方式调用str.strip。
numpy.char.strip()的语法:
使用该函数所需的语法如下:
numpy.char.strip(a, chars=None)
以上语法表明strip()函数取两个参数。
参数:
现在让我们看看这个函数的参数:
-
a
该参数表示将应用该函数的数组。 -
字符
chars参数基本上是一个字符串，指定要删除的字符集。如果该参数未提供或未作为无提供，则默认删除空白。
返回值:
该函数将返回一个字符串的输出数组，字符串中的字符在strip()函数中被删除。
例 1:
在下面的代码片段中，我们将使用strip()函数:
import numpy as np
str = " welcome to studytonight "
print("The Original String:")
print(str)
print("After Removing the leading and trailing whitespaces from the string :")
a = np.char.strip(str)
print(a)
输出:
例 2:
我们再举一个例子。
import numpy as np
inp = np.array(['Sunday ', ' Monday ', ' Tues '])
print ("The Input array : ", inp)
output = np.char.strip(inp)
print ("The Output array: ", output)
输出:
例 3:
在下面给出的例子中，我们将从数组的元素中去除字符‘S’，其代码片段如下:
import numpy as np
inp = np.array([ 'Studytonight', 'For', 'oo'] )
print ("The Input array : ")
print(inp)
output = np.char.strip(inp, chars ='S')
print ("The Output array: \n", output)
输入数组:
[“StudyTonight”为“oo”]
输出数组:
[“晚上学习”为“oo”]
摘要
在本教程中，我们学习了 Numpy 库中的strip()函数。我们介绍了如何使用它的语法和这个函数返回的值，以及几个例子。
NumPy partition()函数
原文：https://www.studytonight.com/numpy/numpy-charpartition-function
在本教程中，我们将介绍 Python 中 Numpy 库的 char 模块中的char.partition()函数。
numpy.char.partition()函数主要用于围绕指定的分隔符对给定输入数组中的每个元素进行划分。
该函数以元素方式调用str.partition。
对于给定数组中的每个元素，该函数将在遇到给定分隔符字符串的第一次出现时拆分元素。该函数将返回 3 个字符串，包含分隔符前的部分、分隔符本身和分隔符后的部分。如果没有找到分隔符，那么返回的 3 个字符串将包含字符串本身，后跟两个空字符串。
char.partition()的语法:
使用该函数所需的语法如下:
numpy.char.partition(a, sep)
以上语法表明partition()函数取两个参数。
参数:
让我们讨论这个函数的上述参数:
-
a
该参数表示字符串的输入数组。 -
sep
该参数用于指示分隔符，该分隔符用于拆分输入数组中的每个字符串元素。
返回值:
该函数将返回依赖于输入类型的字符串输出数组。输出数组主要有一个额外的维度，每个输入元素有 3 个元素。
例 1:
代码片段如下，我们将在其中使用partition()函数:
import numpy as np
a = "StudyTonight-Education Simplified"
sep ='None'
print("The Input is:")
print(a)
out = np.char.partition(a, sep)
print ("The Output is :")
print(out)
在上面的例子中，由于分隔符的值是无，所以它将在输出中给出 3 个字符串，即原始字符串和两个空字符串。让我们看看同样的输出。
输出:
例 2:
在下面的代码中，我们将为sep参数提供一个值，然后查看分区结果:
import numpy as np
a = "StudyTonight-Education Simplified"
sep ='Ed'
print("The Input is:")
print(a)
out = np.char.partition(a, sep)
print ("The Output is :")
print(out)
输出:
摘要
在本教程中，我们学习了 Numpy 库中 char 模块的partition()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及一些代码示例。
Numpy 统计函数
NumPy amin()函数
在本教程中，我们将介绍 Numpy 库的numpy.amin()功能。
这是 NumPy 库的一个统计函数，用于沿轴返回数组的最小元素或最小元素。
numpy.amin()的语法:
使用该函数所需的语法如下:
numpy.amin(a, axis, out, keepdims=<no value>, initial=<no value>, where=<no value>)
参数:
现在是时候讨论这个方法的参数了:
-
a
该参数表示以数组形式输入的数据。 -
轴
它是一个可选的参数，指示要沿其操作的一个或多个轴。该参数的值可以是int或一组int值，默认值为无。 -
输出
该可选的参数用于指示存储结果的替代输出数组。该参数的值采用数组的形式。 -
保留
借助这个可选的参数(具有布尔值)，结果将根据输入数组正确广播。如果该选项设置为真，减少的轴将作为尺寸为 1 的尺寸留在结果中。 -
初始
这是一个标量和可选的参数，用于指示输出元素的最大值。 -
其中
这是一个可选的参数，用于指示要比较的元素的最小值
返回值:
该函数用于返回任意给定数组的最小值。如果轴为无，则结果为标量值。如果给出轴，则结果是维度a.ndim - 1的数组。
示例 1:基本示例
我们现在将介绍一个使用该函数的基本示例:
import numpy as np
a = np.array([[2,15,20],[80,43,31],[22,43,10]])
print("The original array:\n")
print(a)
print("\nThe minimum element among the array:",np.amin(a))
print("\nThe minimum element among the rows of array",np.amin(a,0))
print("\nThe minimum element among the columns of array",np.amin(a,1))
原阵:
[[2 15 20]
[80 43 31]
[22 43 10]]
T6]阵中最小元素:2
阵中行间最小元素[ 2 15 10]
阵列间最小元素[ 2 31 10]
例 2:
另一个代码示例如下:
a = np.arange(9).reshape((3,3))
print("The Array is :")
print(a)
print("Minimum element in the array is:",np.amin(a))
print("Minimum element along the first axis of array is:",np.amin(a, axis=0))
print("Minimum element along the second axis of array is:",np.amin(a, axis=1))
数组为:
【【0 1 2】
【3 4 5】
【6 7 8】】
数组中最小元素为:0
沿数组第一轴的最小元素为:【0 1 2】
沿数组第二轴的最小元素为:【0 3 6】
np.amin(a, where=[False, True], initial=10, axis=0)
数组([10，1])
摘要
在本教程中，我们介绍了 Numpy 库的numpy.amin()统计函数及其语法、参数和返回值。以及一些代码示例来帮助您理解这个函数是如何工作的。
NumPy amax()函数
在本教程中，我们将介绍 Numpy 库的numpy.amax()功能。
这是 NumPy 库的一个统计函数，用于返回一个数组的最大元素或一个轴上的最大元素。
为了找到数组的最小值，我们使用 numpy.amin()函数。
numpy.amax()的语法:
使用该函数所需的语法如下:
numpy.amax(a, axis, out, keepdims=<no value>, initial=<no value>, where=<no value>)
参数:
现在是时候讨论这个函数的参数了，如下所示:
-
a
该参数表示以数组形式输入的数据。 -
轴
它是一个可选的参数，指示要沿其操作的一个或多个轴。该参数的值可以是int或一组int值，默认值为无。 -
输出
该可选的参数用于指示存储结果的替代输出数组。该参数的值采用数组的形式。 -
保留
借助这个可选的参数(具有布尔值)，结果将根据输入数组正确广播。如果该选项设置为真，减少的轴将作为尺寸为 1 的尺寸留在结果中。 -
初始
这是一个标量和可选的参数，用于指示输出元素的最大值。 -
其中
这是一个可选的参数，用于指示要比较的元素的最大值
返回值:
该函数用于返回一个数组的最大值。如果轴为无，则结果为标量值。如果给出轴，则结果是维度a.ndim - 1的数组。
例 1:
我们现在将介绍一个使用该函数的基本示例:
import numpy as np
a = np.array([[2,15,20],[80,43,31],[22,43,10]])
print("The original array:\n")
print(a)
print("\nThe maximum element among the array:",np.amax(a))
print("\nThe maximum element among the rows of array",np.amax(a,0))
print("\nThe maximum element among the columns of array",np.amax(a,1))
输出:
例 2:
另一个代码示例如下:
a = np.arange(9).reshape((3,3))
print("The Array is :")
print(a)
print("Maximum element in the array is:",np.amax(a))
print("Maximum element along the first axis of array is:",np.amax(a, axis=0))
print("Maximum element along the second axis of array is:",np.amax(a, axis=1))
输出:
摘要
在本教程中，我们介绍了 Numpy 库的numpy.amax()统计函数及其语法、参数和返回值，以及一些代码示例。
NumPy ptp()函数
在本教程中，我们将介绍 NumPy 库的numpy.ptp()功能。
在统计功能numpy.ptp()中，“ ptp 代表峰到峰。
-
该功能用于沿轴返回一系列值。
-
可以使用范围=最大值-最小值来计算范围。
numpy.ptp()的语法:
使用该函数所需的语法如下:
numpy.ptp(a, axis=None, out=None, keepdims=<no value>)
参数:
下面是这个函数接受的参数的描述:
-
a
该参数用于指示输入数组。 -
轴
这个参数用来表示我们想要取范围值的轴。默认情况下，输入数组被展平(即在所有轴上工作)。这里轴= 0 表示沿列的，轴= 1** 表示沿行的工作。** -
out
这是一个可选的参数，用于指示一个备选数组，我们希望在其中存储该函数的结果或输出。阵列必须具有与预期输出相同的尺寸。
返回值:
此函数返回数组的范围(如果轴为无，它将返回标量值)或具有沿指定轴的值范围的数组。
例 1:
在下面给出的代码片段中，我们将 1D 数组的最后一个元素作为 NaN ，并检查结果:
import numpy as np
input_arr = [1, 10, 7, 20, 11, np.nan]
print("The Input array is : ")
print(input_arr)
print("The Range of input array is : ")
print(np.ptp(input_arr))
输入数组为:
【1，10，7，20，11，nan】
输入数组的范围为:
nan
注: 若阵中某值为 NaN 则其范围也为 NaN 。
现在，我们将采用一个包含所有数字的 1D 阵列:
import numpy as np
input_arr = [1, 10, 7, 20,11,56,67]
print("The Input array is : ")
print(input_arr)
print("The Range of input array is : ")
print(np.ptp(input_arr))
输入数组为:
【1，10，7，20，11，56，67】
输入数组的范围为:
66
例 2:
现在我们将举另一个例子，我们将使用这个函数的不同参数:
import numpy as np
inp = [[15, 18, 16, 63, 44], [19, 4, 29, 5, 20], [24, 4, 54, 6, 4,]]
print("\nThe Input array is:")
print(inp)
# The Range of the flattened array is calculated as:
print("\nThe Range of the array when the axis = None : ")
print(np.ptp(inp))
# The Range along the first axis where axis=0 means vertical
print("The Range of the array when the axis = 0 : ")
print(np.ptp(inp, axis = 0))
# Range along the second axis where axis=1 means horizontal
print("The Range of the array when the axis = 1: ")
print(np.ptp(inp, axis = 1))
输入数组为:
【【15，18，16，63，44】、【19，4，29，5，20】、【24，4，54，6，4】】
当轴=无时数组的范围:
59
当轴= 0 时数组的范围:
【9 14 38 58 40】
当轴= 1 时数组的范围:
【40】
摘要
在本教程中，我们介绍了 Numpy 库的numpy.ptp()统计功能及其语法、参数和返回值以及一些代码示例。
NumPy median()函数
在本教程中，我们将介绍 NumPy 库的numpy.median()功能。
术语中值基本上被定义为用于将较高范围的数据样本与较低范围的数据样本分开的值。
-
NumPy 库中的
numpy.median()统计函数用于计算任意指定轴的中间值。 -
因此，该函数返回数组元素的中值作为输出。
-
该函数用于计算一维和多维数组的中值。
numpy.median()的语法:
使用该函数所需的语法如下:
numpy.median(a, axis = None,out,dtype)
参数:
下面是这个函数使用的参数描述:
-
a
该参数用于指示输入数组。 -
轴
这个参数用来表示我们要计算中位数的轴。默认情况下，输入数组被展平(即在所有轴上工作)。这里，对于轴的值，轴= 0 表示沿列的，轴= 1** 表示沿行工作的。** -
out
这是一个可选的参数，用于指示我们想要放置结果的可选数组。数组必须具有与预期输出相同的维度。 -
数据类型
这是一个可选的参数，用于在计算中位数时指示我们想要的类型。
返回值:
该函数返回数组的中值(如果轴是无，它将返回一个标量值)或一个沿指定轴有中值的数组。
用于计算中位数的步骤:
以下是用于计算中位数的步骤:
-
有一些给定的数据点作为输入。
-
第二步，按升序排列。
-
如果项目总数为奇数，则中位数计算为中位数=中期
-
如果条款总数为偶数，则中位数计算为中位数=中间条款的平均值
例 1:
下面给出了一个基本示例，向您展示了该功能的工作原理:
import numpy as np
a = [26, 2, 73, 13, 34]
print("The Input Array is : ")
print(a)
print("The median of 1D array is : ")
print(np.median(a))
输入数组为:
【26，2，73，13，34】
1D 数组的中位数为:
26.0
例 2:
现在，我们将在二维数组上应用此方法，并将检查输出:
import numpy as np
inp = [[1, 17, 19, 33, 49], [14, 6, 87, 8, 19], [34, 2, 54, 4, 7]]
print("\nThe median of array when axis = None : ")
print(np.median(inp))
# calculating median along the axis = 0
print("\nThe median of array when axis = 0 : ")
print(np.median(inp, axis = 0))
#calculating median along the axis = 1
print("\nThe median of array when axis = 1 : ")
print(np.median(inp, axis = 1))
轴=无时阵的中位数:
17.0
轴= 0 时阵的中位数:
【14。6.54.8.19.】
轴= 1 时数组的中位数:
【19】。14.7.]
摘要
在本教程中，我们学习了 Numpy 库中的统计函数numpy.median()。我们介绍了这个函数返回的中值、语法、参数和值，以及多个相同的例子。
NumPy mean()函数
在本教程中，我们将介绍 NumPy 库的numpy.mean()功能。
-
只需将数组的所有项目相加并将除以数组元素的总数，就可以很容易地计算出平均值。
-
NumPy 库中的
numpy.mean()函数用于计算数组中沿指定轴的算术平均值。 -
所以这个函数主要是返回数组元素的平均值。默认情况下，平均值是在展平的数组上计算的，否则，它将在指定的轴上计算。
numpy.mean()的语法:
使用该函数所需的语法如下:
numpy.mean(a, axis=None, out, dtype)
参数:
下面是该函数使用的参数描述:
-
a
该参数用于指示输入数组。 -
轴
这个参数用来表示我们要计算中位数的轴。默认情况下，输入数组被展平(即在所有轴上工作)。这里，对于轴的值，轴= 0 表示沿列的，轴= 1** 表示沿行工作的。** -
out
这是一个可选的参数，用于指示我们想要放置结果的可选数组。数组必须具有与预期输出相同的维度。 -
数据类型
这是一个可选的参数，用于在计算平均值时指示我们想要的类型。
返回值:
该函数主要返回数组的算术平均值(如果轴为无，则返回标量值)或沿指定轴有平均值的数组。
例 1:
下面给出了一个基本示例，向您展示了该功能的工作原理:
import numpy as np
x= [80, 23, 17, 1, 39]
print("The Input array is : ")
print(x)
print("The mean of the array is : ")
print(np.mean(x))
输入数组为:
【80，23，17，1，39】
数组的平均值为:
32.0
例 2:
现在，我们将在二维数组上应用此函数，并将检查输出:
import numpy as np
p = [[14, 19, 12, 34, 43], [16, 8, 28, 8, 20], [25, 5, 55, 1, 2]]
# calculating mean of the flattened array
print("\nThe mean of the array when axis = None : ")
print(np.mean(p))
# calculating the mean along the axis = 0
print("\nThe mean of the array when axis = 0 : ")
print(np.mean(p, axis = 0))
# calculating the mean along the axis = 1
print("\nThe mean of the array when axis = 1 : ")
print(np.mean(p, axis = 1))
out_arr = np.arange(3)
print("\nout_arr : ", out_arr)
print("mean of arr, axis = 1 : ")
print(np.mean(p, axis = 1, out = out_arr))
当轴=无时数组的平均值:
19.33333333333332
当轴= 0 时数组的平均值:
【18.3333333333 10.666666731.666666714.333333321.666666667】
当轴= 1 时数组的平均值:
17.6]
out _ arr:[0 1 2]
arr 平均值，轴= 1:
【24 16 17】
摘要
在本教程中，我们介绍了numpy.mean()，Numpy 库中的一个统计函数。我们介绍了什么是 mean，mean()函数的语法，mean()函数参数以及一些代码示例。
NumPy std()函数
在本教程中，我们将介绍 Numpy 库的另一个名为numpy.std()的统计函数。
在numpy.std()功能中“标准”代表标准偏差。让我们首先告诉你什么是标准差均值，然后我们将介绍这个方法。
什么是标准差？
标准差基本上是一组值的变异量或离差的度量。****
它也被称为平均值的平方偏差平均值的平方根。
让我们看看标准差公式:
std = sqrt(mean(abs(x - x.mean())**2))
要了解如何计算数组值的平均值，您可以查看: Numpy numpy.mean()函数。
NumPy numpy.std()功能:
numpy.std()功能用于计算沿指定轴的标准偏差。
-
该函数用于寻找标准偏差，该标准偏差是阵列元素分布的扩散的度量。
-
默认情况下，标准偏差是为展平数组计算的，否则，它是在指定的轴上计算的。
numpy.std()的语法:
使用该函数所需的语法如下:
numpy.std(a, axis, dtype, out)
参数:
下面是这个函数使用的参数描述:
-
a
该参数用于指示输入数组。 -
轴
这个参数用来表示我们要计算中位数的轴。默认情况下，输入数组被展平(即在所有轴上工作)。这里，对于轴的值，轴= 0 表示沿列的，轴= 1** 表示沿行工作的。** -
out
这是一个可选的参数，用于指示输出将存储在其中的替代数组。数组必须具有与预期输出相同的维度。 -
数据类型
这是一个可选的参数，用于在计算标准差时指示我们想要的类型。
返回值:
此函数返回数组的标准偏差(如果轴为无，它将返回标量值)或具有沿指定轴的标准偏差值的数组。如果out 参数为 None ，则该函数将返回一个包含标准差的新数组，否则将返回一个对输出数组的引用。
例 1:
下面我们有一个代码示例，其中我们将使用numpy.std()函数来计算 2D 阵列的标准偏差:
import numpy as np
a = np.array([[11, 2], [13, 44]])
print("The array is:\n",a)
print("Standard Deviation is :")
print(np.std(a))
print("Standard Deviation along axis 0:")
print(np.std(a, axis=0))
print("Standard Deviation along axis 1:")
print(np.std(a, axis=1))
数组为:
【【11 2】
【13 44】】
标准差为:
15.850867484147358
沿 0 轴标准差:
【1。21.】
沿轴 1 的标准偏差:
【4.5±15.5】
例 2:
import numpy as np
inp = [22, 2, 17, 11, 34]
print("The input array is : ")
print(inp)
print("The standard deviation of the Input Array is: ")
print(np.std(inp))
print ("\nTo get More precision with float32")
print("Thus std of array is : ", np.std(inp, dtype = np.float32))
print ("\nTo get More accuracy with float64")
print("The std of array is : ", np.std(inp, dtype = np.float64))
输入数组为:
【22，2，17，11，34】
输入数组的标准差为:
10.721940122944167
用 float32
获得更高的精度因此数组的 std 为:10.72194
用 float64
获得更高的精度数组的 std 为:10.720000000006
注: 为了更准确地计算标准差dtype使用了float64。
摘要
在本教程中，我们介绍了numpy.std()统计函数。我们还介绍了标准差的含义及其数学公式。然后我们通过一些代码示例理解了numpy.std()函数的语法、参数以及该方法返回的值。
矩阵库
NumPy eye()函数
在本教程中，我们将介绍 Numpy 库的numpy.matlib.eye()功能。
numpy.matlib.eye()函数用于返回一个矩阵，所有的对角元素初始化为 1 ，其他地方的为零值。
numpy.matlib是用来配置矩阵的矩阵库，而不是数组对象。
matlib.eye()的语法:
使用该函数所需的语法如下:
numpy.matlib.eye(n, m, k, dtype,order)
参数:
现在让我们介绍一下该函数使用的参数:
-
n
此参数用于表示结果矩阵中的行数。 -
m
此参数用于表示列数，默认值为n。 -
k
该参数用于表示对角线的指数，默认情况下该参数的值为 0。如果 k >的值为 0，则表示对角线高于主对角线，反之亦然。 -
数据类型
该参数用于表示矩阵的数据类型。该参数的默认值为float。这是一个可选的参数。 -
顺序
这是一个可选的参数，用于指示矩阵的插入顺序。主要表示是以 C-还是 Fortran-contact 顺序存储结果，默认值为‘C’。
返回值:
此方法将返回一个 n x M 矩阵，其中所有元素都等于零，除了 kth 对角线，其值等于一。
例 1:
下面给出了理解这个函数的一个基本例子:
import numpy as np
import numpy.matlib
x = numpy.matlib.eye(n = 4, M = 3, k = 0, dtype = int)
print("The Output is :")
print(x)
输出为:
【【100 0】
【010】
【001】
【000】】
例 2:
我们再举一个例子，创建一个不同维度的矩阵。
import numpy as np
import numpy.matlib
x = numpy.matlib.eye(n = 5, M = 4, k = 1, dtype = int)
print("The Output is :")
print(x)
上述代码的输出:
eye()和identity()的区别:
# NumPy identity()函数和eye()函数之间有区别，也就是说，identity 函数返回一个主对角线上有 1 的正方形矩阵，如下所示:
虽然eye()函数返回的矩阵在对角线上有 1 ，在其他地方有 0 关于 K 参数的值，如果 K > 0 的值，那么它意味着主对角线之上的对角线，反之亦然。
摘要
在本教程中，我们学习了 Numpy 库的numpy.eye()数学函数。我们还介绍了它的语法、参数以及这个函数返回的值，还有几个例子。
NumPy identity()函数
原文：https://www.studytonight.com/numpy/numpy-identity-function
在本教程中，我们将介绍 Numpy 库的numpy.matlib.identity()功能。
numpy.matlib.identity()函数用于返回给定大小的单位矩阵。让我们先了解下恒等式矩阵的概念。
一个单位矩阵是一个所有对角元素初始化为 1 并且其余所有元素为零的矩阵。
matlib.identity()的语法:
使用该函数所需的语法如下:
numpy.matlib.identity(n, dtype)
参数:
现在让我们介绍一下该函数使用的参数:
-
n
此参数用于指示返回的身份矩阵的大小。 -
数据类型
该参数用于表示矩阵的数据类型。该参数的默认值为float。
返回值:
该方法将返回一个主对角线元素设置为 1，所有其他元素设置为零的n×n矩阵。
例 1:
下面是这个方法的一个基本例子:
import numpy as np
import numpy.matlib
a = numpy.matlib.identity(4)
print("The Identity matrix as output is :")
print(a)
作为输出的身份矩阵为:
[[1。0.0.0.】
【0。1.0.0.】
【0。0.1.0.】
【0。0.0.1.]]
例 2:
下面给出了一个基本的例子，我们将提到数组元素的dtype
import numpy as np
import numpy.matlib
a = numpy.matlib.identity(6, dtype = int)
print("The Identity matrix as an output is :")
print(a)
作为输出的身份矩阵为:
[[1 0 0 0 0 0]
[0 1 0 0 0]
[0 0 1 0 0]
[0 0 1 0]
[0 0 0 1 0]
[0 0 0 0 1]]
identity()和eye()的区别:
identity()和 # NumPy eye()函数有一个区别，那就是恒等式函数返回一个正方形矩阵，主对角线上有一个像这样的矩阵；
而eye()函数返回对角线上有 1 和其他地方有 0 的矩阵，该矩阵基于 K 参数的值。如果 K > 0 的值，则表示主对角线上方的对角线，反之亦然
摘要
在本教程中，我们学习了 Numpy 库的numpy.matlib.identity()数学函数。我们介绍了它的语法、参数以及这个函数返回的值，还有一些代码示例。
NumPy rand()函数
在本教程中，我们将介绍 Numpy 库的numpy.matlib.rand()功能。
numpy.matlib.rand()功能用于生成一个矩阵，其中所有条目用一些随机值初始化。
numpy.matlib是一个矩阵库，用来配置矩阵而不是数组对象。
该功能有助于创建一个给定形状的矩阵，并填充范围[0, 1)内的随机值。因此，我们可以使用这种方法创建一个给定形状的随机值矩阵。
matlib.rand()的语法:
使用该函数所需的语法如下:
numpy.matlib.rand(*args)
注意: 在上面的语法中 *args 代表参数，它表示输出的形状。如果 *args 给出为 N 个整数，那么每个整数指定一个维度的大小。如果 *args 作为元组给出，那么这个元组给出完整的形状。
返回值:
该方法将返回一个随机值矩阵，其形状由 *args 给出。
matlib.rand()基本示例:
下面给出了如何使用上述方法创建随机矩阵的基本示例:
import numpy as np
import numpy.matlib
x = numpy.matlib.rand(4,3)
print("The Random Matrix is :")
print(x)
上面代码的输出:
例 2:
在下面的例子中，我们将以元组的形式使用一个参数，这里需要注意的是，如果一个参数是元组，那么该方法将忽略其他参数:
import numpy as np
import numpy.matlib
x = numpy.matlib.rand((5, 6), 4)
print(x)
上面代码的输出:
摘要
在本教程中，我们学习了 Numpy 库的numpy.rand()数学函数。我们还介绍了它的语法、参数以及这个函数返回的值和一个代码示例。
NumPy empty()函数
在本教程中，我们将介绍 Numpy 库的numpy.matlib.empty()功能。
numpy.matlib.empty()函数用于返回一个没有初始化条目的新矩阵。
numpy.matlib是一个矩阵库，用来配置矩阵而不是数组对象。
matlib.empty()的语法:
使用该函数所需的语法如下:
numpy.matlib.empty(shape,dtype,order)
参数:
现在让我们介绍一下该函数使用的参数:
-
形状
该参数采用元组的形式，用于定义矩阵的形状。 -
数据类型
该参数用于指示矩阵的数据类型。该参数的默认值为float。这是一个可选参数。 -
顺序
这是一个可选的参数，用于指示矩阵的插入顺序。主要表示结果是以 C-还是 Fortran-连续顺序存储，默认值为‘C’。
返回值:
这个函数主要返回一个有初始化条目的新矩阵。
现在是时候介绍这个函数的几个例子了:
例 1:
下面给出了理解这个函数的一个基本例子:
import numpy as np
import numpy.matlib
print(numpy.matlib.empty((4,4)))
[[0.00000000 e+000 0.0000000 e+000 0.00000000 e+000 0.00000000000 e+000]
[0.00000000 e+000 0.0000000000 e+000.0000000000]
]
例 2:
现在我们还将在下面给出的代码片段中使用type参数:
import numpy as np
import numpy.matlib
print(numpy.matlib.empty((2,3), int))
[-1192611712 306 0]
[0 131074 0]]
例 3:
在下面的代码示例中，我们还将使用empty()功能指定第三个参数order:
import numpy as np
import numpy.matlib
print(numpy.matlib.empty((4), int, 'C'))
[[ 0 0 65793 1]]
摘要
在本教程中，我们学习了 Numpy 库中的numpy.empty()数学函数。我们还介绍了它的语法、参数以及这个函数返回的值，以及它的代码示例。
NumPy ones()函数
在本教程中，我们将介绍 Numpy 库的numpy.matlib.ones()功能。
功能numpy.matlib.ones()用于返回给定形状和类型的矩阵。此功能将矩阵的所有值初始化为一(1) 。
numpy.matlib是用来配置矩阵而不是数组对象的矩阵库。
matlib.ones()的语法:
使用该函数所需的语法如下:
numpy.matlib.ones(shape,dtype,order)
参数:
现在让我们介绍一下该函数使用的参数:
-
形状
该参数采用元组的形式，用于定义矩阵的形状。 -
数据类型
该参数用于表示矩阵的数据类型。该参数的默认值为float。这是一个可选的参数。 -
顺序
这是一个可选的参数，用于指示矩阵的插入顺序。它主要指示是以 C 还是 Fortran 连续顺序存储结果，默认值为“C”。
返回值:
该函数将返回一个矩阵，所有条目初始化为 1 。
现在是时候介绍这个函数的几个例子了。
例 1:
下面给出了理解这个函数的一个基本例子:
import numpy as np
import numpy.matlib
print(numpy.matlib.ones((5,4)))
【【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.]]
例 2:
现在我们还将在下面给出的代码片段中使用类型和顺序参数:
import numpy as np
import numpy.matlib
print("The Output matrix is :\n",numpy.matlib.ones((3,4),int))
输出矩阵为:
[[1 1 1 1]
[1 1 1]
[1 1 1]]
例 3:
再举一个例子，
import numpy as np
# 1-d array with 5 elements
np.matlib.ones(5)
矩阵([[1。, 1., 1., 1., 1.]])
摘要
在本教程中，我们学习了 Numpy 库中的numpy.ones()数学函数。我们还介绍了它的语法、参数以及这个函数返回的值，并提供了一些代码示例。
NumPy zeros()函数
在本教程中，我们将介绍 Numpy 库的numpy.matlib.zeros()功能。
功能numpy.matlib.zeros()用于返回给定形状和类型的矩阵。这个方法用零填充矩阵。
numpy.matlib是用来配置矩阵而不是数组对象的矩阵库。
matlib.zeros()的语法:
使用该函数所需的语法如下:
numpy.matlib.zeros(shape,dtype,order)
参数:
现在让我们介绍一下该函数使用的参数:
-
形状
该参数采用元组的形式，用于定义矩阵的形状。 -
数据类型
该参数用于表示矩阵的数据类型。该参数的默认值为float。这是一个可选的参数。 -
顺序
这是一个可选的参数，用于指示矩阵的插入顺序。它主要指示是以 C 还是 Fortran 连续顺序存储结果，默认值为“C”。
返回值:
这个函数主要返回给定形状、数据类型和顺序的零矩阵。
现在是时候介绍这个函数的几个例子了。
例 1:
下面给出了理解这个函数的一个基本例子:
import numpy as np
import numpy.matlib
print("The matrix is:\n",numpy.matlib.zeros((4,3)))
矩阵为:
【【0。0.0.】
【0。0.0.】
【0。0.0.】
【0。0.0.]]
例 2:
现在我们还将在下面给出的代码片段中使用类型和顺序参数:
import numpy as np
import numpy.matlib
print("The 3x4 matrix with all elements in integer is as follows:\n",numpy.matlib.zeros((3,4), int, 'C'))
所有元素均为整数的 3x4 矩阵如下:
[[0 0 0 0]
[0 0 0]
[0 0 0]]
例 3:
需要注意的是，如果shape的长度为 1，即(N,)，或者是标量N，那么在输出中，会有一个形状为(1,N)的单行矩阵。理解该语句的代码片段如下:
import numpy as np
np.matlib.zeros(4)
矩阵([[0。, 0., 0., 0.]])
摘要
在本教程中，我们学习了 Numpy 库中的numpy.zeros()数学函数。我们还介绍了它的语法、参数以及这个函数返回的值，还有一些代码示例。
二元运算
NumPy left_shift()函数
原文：https://www.studytonight.com/numpy/numpy-left_shift-function
在本教程中，我们将介绍left_shift，这是 Numpy 库的二进制操作。
在 Numpy 中，left_shift()功能主要用于执行左移操作。
left_shift()功能主要用于向左移动整数的位。
numpy.left_shift()的语法:
使用该函数所需的语法如下:
numpy.left_shift(x1, x2, /, out, *, where, casting='same_kind', order='K', dtype, ufunc 'left_shift')
由于数字的内部表示主要是二进制格式，因此左移操作相当于 x1 乘以 2x2** 。
在此功能的帮助下，通过在 x1 的右侧追加 x2 个 0(零)位，位被向左移动。
参数:
现在让我们看看这个函数的参数:
-
x1
该参数用于表示输入值，采用数组形式。 -
x2
此参数用于指示要追加到 x1 右侧的位数。必须是非负数数。如果x1.shape != x2.shape，那么它们必须是可宽铸的一个共同的形状，并且该形状成为输出的形状。 -
出
该参数表示存储结果的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将被设置为 ufunc 结果，否则输出数组将保留其原始值。
返回值:
该功能会将x1返回到左侧位移位x2次。如果x1和x2都是标量，返回值就是标量。
例 1:
在下面的例子中，我们将说明left_shift()函数的用法:
import numpy as np
input_num = 40
bit_shift = 2
print ("The Input number is: ")
print(input_num)
print ("The Number of bit shift : ")
print(bit_shift )
output = np.left_shift(input_num, bit_shift)
print ("After the shifting of 2 bits to left : ")
print(output)
输入数为:
40
左移 2 位后移位数:
2
:
160
例 2:
现在我们将向您展示一个代码片段，其中我们将把left_shift()应用到一个输入数组上:
import numpy as np
input_arr = [2, 8, 10]
bit_shift =[3, 4, 5]
print ("The Input array is: ")
print(input_arr)
print ("The Number of bit shift : ")
print(bit_shift )
output = np.left_shift(input_arr, bit_shift)
print ("After left shifting of bits,the output array is: ")
print(output)
输入数组为:
【2，8，10】
移位位数:
【3，4，5】
左移位后，输出数组为:
【16 128 320】
摘要
在本教程中，我们介绍了 NumPy 库的left_shift()功能。我们介绍了它的基本语法和参数，然后介绍了这个函数返回的值以及该函数的一些代码示例。
NumPy right_shift()函数
原文：https://www.studytonight.com/numpy/numpy-right_shift-function
在本教程中，我们将介绍right_shift()函数，它是 Numpy 库的二进制操作。
在 Numpy 中，right_shift()功能主要用于执行右移操作。
-
right_shift()功能主要用于向右移动整数的位。 -
该函数主要将操作数的二进制表示中的位向右移动指定的位置，并且从左侧追加相等数量的0。
numpy.right_shift()的语法:
使用该函数所需的语法如下:
numpy.right_shift(x1, x2, /, out, *, where, casting='same_kind', order='K',dtype,subok=True[, signature, extobj]) = <ufunc 'right_shift'>
由于数字的内部表示主要采用二进制格式，因此右移操作相当于将 x1 除以 2x2** 。
参数:
现在让我们看看这个函数的参数:
-
x1
该参数用于表示输入值，采用数组形式。 -
x2
此参数用于指示 x1 右侧要删除的位数。如果x1.shape != x2.shape，那么它们必须是可宽铸的一个共同的形状，并且该形状成为输出的形状。 -
out
该参数主要表示结果存储的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将被设置为 ufunc 结果，否则输出数组将保留其原始值。
返回值:
该功能将返回 x1 ，其位向右移动 x2 次。如果 x1 和 x2 都是标量，则返回值是标量。
例 1:
在下面的例子中，我们将说明right_shift()函数的用法:
import numpy as np
input_num = 40
bit_shift = 2
print ("The Input number is: ")
print(input_num)
print ("The Number of bit shift : ")
print(bit_shift )
output = np.right_shift(input_num, bit_shift)
print ("After the shifting of 2 bits to right : ")
print(output)
输入数为:
40
右移 2 位后移位数:
2
:
10
例 2:
现在我们将向您展示一个代码片段，其中我们将把right_shift()应用到一个输入数组上:
import numpy as np
input_arr = [8, 28, 55]
bit_shift =[3, 4, 2]
print ("The Input array is: ")
print(input_arr)
print ("The Number of bit shift : ")
print(bit_shift )
output = np.right_shift(input_arr, bit_shift)
print ("After right shifting of bits,the output array is: ")
print(output)
输入数组为:
【8，28，55】
位移位数:
【3，4，2】
右移位后，输出数组为:
【1 1 13】
摘要
在本教程中，我们介绍了 NumPy 库的right_shift()功能。我们介绍了它的基本语法和参数，以及这个函数返回的值和一些例子。
NumPy bitwise_xor()函数
原文：https://www.studytonight.com/numpy/numpy-bitwise_xor-function
在本教程中，我们将使用 Numpy 库的bitwise_xor()函数来介绍bitwise_xor二进制运算。
在 Numpy 中，bitwise_xor()函数主要用于执行按位异或运算。
-
该函数将按元素计算两个数组的按位异或。
-
bitwise_xor()函数计算输入数组中整数的基础二进制表示的按位异或。 -
对于异或运算，函数
bitwise_XOR()实现^(C/Python 运算符)。
numpy.bitwise_xor()的语法:
使用该函数所需的语法如下:
numpy.bitwise_xor(x1, x2, /, out, *, where=True, casting='same_kind', order='K', dtype, subok=True[, signature, extobj]) = <ufunc 'bitwise_xor'>
参数:
现在让我们看看这个函数的参数:
-
x1，x2
这两个是输入数组，用这个函数只处理整数和布尔类型。如果x1.shape != x2.shape，那么它们必须可宽铸为一个共同的形状(并且这个形状将成为输出的形状)。 -
out
该参数主要表示结果存储的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将被设置为 ufunc 结果，否则输出数组将保留其原始值。
返回值:
如果 x1 和 x2 都是标量，这个函数将返回一个标量。
例 1:
在下面的例子中，我们将说明bitwise_xor()函数的用法:
import numpy as np
num1 = 15
num2= 20
print ("The Input number1 is :", num1)
print ("The Input number2 is :", num2)
output = np.bitwise_xor(num1, num2)
print ("The bitwise_xor of 15 and 20 is: ", output)
输入数字 1 是:15
输入数字 2 是:20
15 和 20 的按位异或是:27
例 2:
在这个例子中，我们将使用两个数组，然后对它们应用bitwise_xor()函数:
import numpy as np
ar1 = [2, 8, 135]
ar2 = [3, 5, 115]
print ("The Input array1 is : ", ar1)
print ("The Input array2 is : ", ar2)
output_arr = np.bitwise_xor(ar1, ar2)
print ("The Output array after bitwise_xor: ", output_arr)
输入数组 1 为:[2，8，135]
输入数组 2 为:[3，5，115]
按位异或后的输出数组:[ 1 13 244]
摘要
在本教程中，我们介绍了 Numpy bitwise_xor()函数。我们介绍了它的基本语法和参数，以及这个函数返回的值和多个代码示例。
NumPy invert()函数
在本教程中，我们将介绍 Numpy 库的bitwise NOT二进制操作。
-
NumPy 中的
invert()函数用于以元素方式计算逐位反转，或逐位非。 -
如果将任何有符号整数传递给该函数，将返回有符号整数的 2 补码。
numpy.invert()的语法:
使用该函数所需的语法如下:
numpy.invert(x, /, out, *, where=True, casting='same_kind', order='K', dtype, subok=True[, signature, extobj]) = <ufunc 'invert'>
参数:
现在让我们看看这个函数的参数:
-
x
该参数表示输入数组，使用该函数，只处理整数和布尔类型。 -
out
该参数主要表示结果存储的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将设置为 ufunc 结果。否则输出数组将保留其原始值。
返回值:
如果 x 是标量，这个函数将返回一个标量。
例 1:
在下面的例子中，我们将说明invert()函数的用法:
import numpy as np
inp_num = 12
print ("The Input number is: ", inp_num)
outp_num = np.invert(inp_num)
print ("The inversion of 12 is: ", outp_num)
输入数字为:12
12 的反转为:-13
例 2:
在本例中，我们将使用带有整数数组的invert()函数:
import numpy as np
inp_arr = [1, 10, 15]
print ("The Input array is: ", inp_arr)
out_arr = np.invert(inp_arr)
print ("The Output array after inversion: ", out_arr)
输入数组为:【1，10，15】
求逆后的输出数组:[ -2 -11 -16]
摘要
在本教程中，我们介绍了 Numpy invert()函数。我们介绍了它的基本语法和参数，以及这个函数返回的值和多个代码示例。
NumPy bitwise_or()函数
原文：https://www.studytonight.com/numpy/numpy-bitwise_or-function
在本教程中，我们将介绍 Numpy 库的bitwise_or二进制操作。
在 Numpy 中，bitwise_or()功能主要用于执行bitwise_or操作。
-
该函数将按元素计算两个数组的位或。
-
bitwise_or()函数计算输入数组中整数的基础二进制表示的位或。 -
需要注意的是，如果操作数中的一个对应位为 1 ，则或运算输出中的合成位将被设置为 1 ，否则将被设置为 0 。
下面给出的是“或”运算的“T0”真值表“T1”，如果其中一位为 1，你会看到两位的“或”结果为 1，否则结果为 0。
bitwise_or()的语法:
使用该函数所需的语法如下:
numpy.bitwise_or(x1, x2, /, out, *, where=True, casting='same_kind', order='K', dtype, subok=True[, signature, extobj]) = <ufunc 'bitwise_or'>
参数:
现在让我们看看这个函数的参数:
-
x1，x2
这两个是输入数组，用这个函数只处理整数和布尔类型。如果x1.shape != x2.shape，那么它们必须可宽铸为一个共同的形状(并且这个形状将成为输出的形状)。 -
out
该参数主要表示结果存储的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将被设置为 ufunc 结果，否则输出数组将保留其原始值。
返回值:
如果 x1 和 x2 都是标量，该函数将返回一个标量。
例 1:
在下面的例子中，我们将说明bitwise_or()函数的用法:
import numpy as np
num1 = 15
num2 = 20
print ("The Input number1 is: ", num1)
print ("The Input number2 is: ", num2)
output = np.bitwise_or(num1, num2)
print ("The bitwise_or of 15 and 20 is: ", output)
输入数字 1 是:15
输入数字 2 是:20
15 和 20 的位“或”是:31
例 2:
在下面的例子中，我们将使用带有两个数组的bitwise_or()函数:
import numpy as np
ar1 = [2, 8, 135]
ar2 = [3, 5, 115]
print ("The Input array1 is : ", ar1)
print ("The Input array2 is : ", ar2)
output_arr = np.bitwise_or(ar1, ar2)
print ("The Output array after bitwise_or:", output_arr)
输入数组 1 为:[2，8，135]
输入数组 2 为:[3，5，115]
按位“或”后的输出数组:[ 3 13 247]
摘要
在本教程中，我们介绍了 NumPy 库的bitwise_or()功能。我们介绍了它的基本语法和参数，以及这个函数返回的值和多个代码示例。
NumPy bitwise_and()函数
原文：https://www.studytonight.com/numpy/numpy-bitwise_and-function
在本教程中，我们将介绍 Numpy 库中的bitwise_and二进制运算。
在 Numpy 中，bitwise_and()功能主要用于执行bitwise_and操作。
-
该函数将按元素计算两个数组的位与。
-
bitwise_and()函数计算输入数组中整数的底层二进制表示的位“与”。
让我们来看看“与”运算的真值表:
如果且仅当两个位都为 1，则两个位的“与”结果的输出为 1，否则为 0。
bitwise_and()的语法:
使用该函数所需的语法如下:
numpy.bitwise_and(x1, x2, /, out, *, where=True, casting='same_kind', order='K', dtype,subok=True[, signature, extobj]) = <ufunc 'bitwise_and'>
参数:
现在让我们看看这个函数的参数:
-
x1，x2
这两个是输入数组，这个函数只处理整数和布尔类型。如果x1.shape != x2.shape，那么它们必须可宽铸为一个共同的形状(并且这个形状将成为输出的形状)。 -
out
该参数主要表示结果存储的位置。如果提供了此参数，它必须具有输入广播到的形状。如果未提供该参数或该参数为无，则返回新分配的数组。 -
其中
该参数用于指示通过输入广播的条件。在条件为真的位置，输出数组将被设置为 b 结果，否则输出数组将保留其原始值。
返回值:
如果 x1 和 x2 都是标量，该函数将返回一个标量。
例 1:
在下面的例子中，我们将说明bitwise_and()函数的用法:
import numpy as np
num1 = 15
num2 = 20
print ("The Input number1 is :", num1)
print ("The Input number2 is :", num2)
output = np.bitwise_and(num1, num2)
print ("The bitwise_and of 15 and 20 is: ", output)
输入数字 1 是:15
输入数字 2 是:20
15 和 20 的位“与”是:4
例 2:
在下面的例子中，我们将对两个数组应用bitwise_and()函数:
import numpy as np
ar1 = [2, 8, 135]
ar2 = [3, 5, 115]
print ("The Input array1 is : ", ar1)
print ("The Input array2 is : ", ar2)
output_arr = np.bitwise_and(ar1, ar2)
print ("The Output array after bitwise_and: ", output_arr)
输入数组 1 为:[2，8，135]
输入数组 2 为:[3，5，115]
按位“与”后的输出数组:[2 0 3]
摘要
在本教程中，我们介绍了 NumPy 库的bitwise_and()功能。我们介绍了它的基本语法和参数，然后介绍了这个函数返回的值以及这个函数的一些例子。
线性代数
NumPy dot()函数
在本教程中，我们将介绍 Numpy 库的dot()功能。
dot()函数主要用于计算两个向量的点积。
-
这个函数可以处理 2D 阵列，但它会将它们视为矩阵，然后执行矩阵乘法。
-
在这种情况下，如果一个数组
a是一个 N-D 数组，而数组b是一个 M-D 数组(其中，M >= 2)那么它就是a最后一个轴和b倒数第二个轴的和积:
dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
numpy.dot()的语法:
使用该函数所需的语法如下:
numpy.dot(a, b, out=None)
参数:
让我们讨论一下这个函数的参数:
-
a
这是第一个参数。如果“a”是复数，那么它的复共轭用于点积的计算。 -
b
这是第二个参数。如果“b”是复数，那么它的复共轭用于点积的计算。 -
退出
这表示输出参数。这个输出必须具有如果不使用将返回的确切类型。否则它必须是连续的，并且它的dtype必须是将被返回给dot(a, b)的dtype。
返回值:
dot()功能将返回 a 和 b 的点积。如果 a 和 b 都是标量，或者如果两者都是一维数组，则返回标量值，否则返回数组。如果给出 out ，则返回。
注: 如果a的最后一个维度与b的倒数第二个维度大小不同，则ValueError升高。
例 1:
代码片段如下，我们将在其中使用dot()函数:
import numpy as np
#Let us take scalars first
a = np.dot(8, 4)
print("The dot Product of above given scalar values : ")
print(a)
# Now we will take 1-D arrays
vect_a = 4 + 3j
vect_b = 8 + 5j
dot_product = np.dot(vect_a, vect_b)
print("The Dot Product of two 1-D arrays is : ")
print(dot_product)
上述给定标量值的点积:
32
两个一维数组的点积为:
(17+44j)
两个 1D 阵列点积计算的说明:
vec _ a = 4+3j
vec _ b = 8+5j
现在计算点积:
= 4(8+5j)+3j(8–5j)
= 32+20j+24j–15
= 17+44j
例 2:
现在让我们创建两个 numpy 数组，然后使用dot()函数为它们找到点积:
import numpy as np
a = np.array([[50,100],[12,13]])
print("The Matrix a is:")
print (a)
b = np.array([[10,20],[12,21]])
print("The Matrix b is :")
print(b)
dot = np.dot(a,b)
print("The dot product of a and b is :")
print(dot)
摘要
在本教程中，我们介绍了 Numpy 库的dot()功能。我们介绍了如何使用它的语法和这个函数返回的值，以及一些代码示例。
杂项
NumPy asarray()函数
原文：https://www.studytonight.com/numpy/numpy-asarray-function
在本教程中，我们将介绍 Numpy 库的numpy.asarray()功能。
Numpy 中的numpy.asarray()功能用于将输入或任何现有数据转换为数组。
-
现有数据可以是列表、元组、元组的元组、元组的列表、列表的元组等形式。
-
如果你想把任何 python 序列转换成 Numpy 数组对象即 ndarray，那么这个函数对你是有帮助的。
numpy.asarray()的语法:
下面给出了使用该函数的基本语法:
numpy.asarray(sequence, dtype, order)
参数:
让我们讨论一下上面提到的asarray()函数的参数:
-
序列
该参数用于指示可以是任何形式的输入数据，并将其转换为数组。该参数包括列表、元组列表、元组、元组元组元组、列表元组和数组。 -
数据类型
该参数用于指示数组中每一项的数据类型。这是一个可选的参数，默认值为无。 -
顺序
此参数用于指示内存表示是使用行主(C 风格)还是列主(Fortran 风格)默认值设置为‘C’。
返回值:
该函数将返回一个数组，其中包含用于创建数组的序列中的所有值。如果输入已经是符合dtype和顺序的数组，则该函数不会创建任何副本。
现在是时候看看这个函数的一些例子了。
例 1:
在下面给出的代码片段中，我们将把一个 Python 列表转换成一个数组:
import numpy as np
mylist = [1, 2,4,5,8,10]
np.asarray(mylist)
数组([ 1，2，4，5，8，10])
例 2:
在下面的代码片段中，我们将从一个 Python 元组创建一个 NumPy 数组:
import numpy as np
inp = (10,9,1,2,3,4,5,6,7,8)
a = np.asarray(inp);
print("The output is:")
print(a)
print("The datatype of output is:")
print(type(a))
输出为:
【10 9 1 2 3 4 5 6 7 8】
输出的数据类型为:
<类>
例 3:
在下面给出的代码片段中，我们将使用多个列表创建一个数组:
import numpy as np
l = [[1,2,3,4,5,6,7],[8,9],[12,34,45]]
a = np.asarray(l);
print("The data type of output is:")
print(type(a))
print("The output array is:")
print(a)
输出的数据类型为:
<类>
输出数组为:
【list([1，2，3，4，5，6，7]) list([8，9]) list([12，34，45])
摘要
本教程介绍了 Numpy 库中的numpy.asarray()数学函数，该函数用于使用各种不同的 Python 序列(如 Lists、Tuple 等)创建 Numpy ndarrya。
NumPy frombuffer()函数
原文：https://www.studytonight.com/numpy/numpy-frombuffer-function
在本教程中，我们将介绍 Numpy 库的numpy.frombuffer()功能。
Numpy 库的numpy.frombuffer()函数用于使用指定的缓冲区创建数组。
该函数将缓冲区解释为一维数组。
frombuffer()的语法:
下面给出了用于numpy.frombuffer()功能的所需语法:
numpy.frombuffer(buffer, dtype, count, offset)
参数:
让我们讨论上述构造器的参数:
-
缓冲区
此参数用于表示一个暴露缓冲区接口的对象。 -
数据类型
该参数用于表示返回的数据类型数组的数据类型。该参数的默认值为 0 。 -
计数
该参数代表返回数组的长度。该参数的默认值为 -1 。 -
偏移
该参数表示读取的起始位置。该参数的默认值为 0 。
现在我们来讨论一些使用frombuffer()函数的例子。
基本示例:
为了理解这个函数的工作原理，下面是我们的代码片段:
import numpy as np
input = b'Welcome to StudyTonight!!!It is a best place for you to learn coding online..'
print("The type of input is:")
print(type(input))
a = np.frombuffer(input, dtype = "S1")
print("The Output is:")
print(a)
print("Type of Output is:")
print(type(a))
输入的类型为:
<类“字节”>
输出为:
【b ' w ' b ' e ' b ' l ' b ' c ' b ' o ' b ' m ' b ' e ' b ' b ' t ' b ' o ' b ' ' b ' s ' b ' t ' b ' u '
b ' d ' b ' y ' t ' b ' o ' b ' n ' b ' I ' b ' g ' h ' b ' t ' b '！b！b！b ' I ' b ' t '
b ' ' b ' I ' b ' s ' b ' ' b ' a ' b ' b ' e ' b ' b ' t ' b ' ' b ' p ' b ' l ' b ' a '
b ' c ' b ' e ' b ' ' b ' f ' b ' o ' b ' r ' b ' ' b ' y ' o ' b ' u ' b ' ' b ' t ' b ' o ' b ' '
b ' l ' b ' e ' b ' a ' b '' b '。】
输出类型为:
<类>
摘要
本教程介绍了 Numpy 库中的numpy.frombuffer()函数，该函数用于使用给定的缓冲区或字节创建 Numpy 数组。
NumPy logspace()函数
原文：https://www.studytonight.com/numpy/numpy-logspace-function
在本教程中，我们将介绍 Numpy 库的numpy.logspace()功能。
Numpy 中的numpy.logspace()函数用于通过使用对数刻度上均匀分隔的数字来创建数组。
numpy.logspace()的语法:
使用此函数的语法如下:
numpy.logspace(start, stop, num, endpoint, base, dtype)
参数:
该函数的参数如下:
-
开始
该参数用于表示开始值的区间基数。 -
停止
该参数用于表示基地区间的停止值。 -
num
该参数用于表示范围内的数值数量。 -
端点
该参数的值在布尔中，用于将 stop 表示的值作为区间的最后一个值。 -
基数
这个参数用来表示原木空间的基数。 -
数据类型
该参数用于表示数组项的数据类型。
返回值:
该函数将返回指定范围内的数组。
现在是时候看几个例子来理解这个函数了。
例 1:
下面是我们将使用这个函数的代码片段:
import numpy as np
arr = np.logspace(20, 30, num = 7,base = 4, endpoint = True)
print("The array over the given range is ")
print(arr)
给定范围内的数组为
【1.09951163 e+12 1.10823828 e+13 1.11703419 e+14 1.12589991 e+15
1.13483599 e+16 1.14384301 e+17 1.15292150 e+18】
例 2:
在下面给出的例子中，我们将使用 matplotlib 描述numpy.logspace()函数的图形表示:
import numpy as np
import matplotlib.pyplot as plt
N = 20
x1 = np.logspace(0.1, 1, N, endpoint=True)
x2 = np.logspace(0.1, 1, N, endpoint=False)
y = np.zeros(N)
plt.plot(x1, y, 'o')
plt.plot(x2, y + 0.8, 'o')
plt.ylim([-0.5, 1])
plt.show()
输出以下代码:
摘要
在本教程中，我们介绍了 Numpy 库的numpy.logspace()功能。我们学习了它的语法、参数以及这个函数返回的值和多个代码示例。
NumPy linspace()函数
原文：https://www.studytonight.com/numpy/numpy-linspace-function
在本教程中，我们将介绍 Numpy 库的numpy.linspace()功能。
该函数用于返回指定间隔内均匀分布的数字。
-
该函数类似于 # NumPy
arange()函数，唯一的区别是不是步长，而是使用num参数指定间隔之间的均匀间隔值的数量。 -
借助该功能，隐式计算步长。
-
在该功能中，区间的端点可以选择排除。
-
在最新版本的 NumPy 中，该函数支持启动和停止参数的非标量值(用于定义间隔)。
numpy.linspace()的语法:
使用该函数所需的语法如下:
numpy.linspace(start, stop, num, endpoint, retstep, dtype)
参数:
上述函数的参数如下:
-
开始
这个参数用来表示区间的开始值。 -
停止
该参数用于表示区间的停止值。 -
num
该参数表示要生成的间隔内均匀间隔样本的数量。该参数的默认值为 50 。 -
终点
该参数的真值用于表示区间中包含停止值。 -
retstep
该参数的值是一个布尔值，用于表示连续数字之间的步长和样本。 -
数据类型
该参数用于表示数组项的数据类型。
返回值:
该函数将返回指定范围内的数组。
如果retstep参数为真，该函数将返回步长值，该值通常表示样本之间的间距大小。
现在是时候看看使用这个函数的例子了。
例 1:
下面是解释如何使用这个函数的代码片段:
import numpy as np
a = np.linspace(20, 40, 8, endpoint = True)
print("The array over the given range is ")
print(a)
给定范围内的数组为
【20。22 . T2 31 . 44860 . 48868686861]
例 2:
下面是使用 Matplotlib 库的函数的图解代码片段:
import matplotlib.pyplot as plt
N = 10
y = np.zeros(N)
x1 = np.linspace(0, 20, N, endpoint=True)
x2 = np.linspace(0, 20, N, endpoint=False)
plt.plot(x1, y, '*')
plt.plot(x2, y + 0.8, 'o')
plt.show()
摘要
在本教程中，我们介绍了 Numpy 库的numpy.linspace()功能。我们介绍了它的语法、参数以及这个函数返回的值，并提供了多个代码示例。
NumPy fromiter()函数
原文：https://www.studytonight.com/numpy/numpy-fromiter-function
在本教程中，我们将介绍 Numpy 库的numpy.fromiter()功能。
numpy.fromiter()功能用于通过使用 python 可迭代对象来创建数组。此方法主要返回一维数组对象。
numpy.fromiter()的语法:
下面是使用该函数所需的语法:
numpy.fromiter(iterable, dtype, count)
参数:
让我们讨论上述函数的参数:
-
可迭代
该参数用于表示可迭代对象。 -
数据类型
该参数用于表示结果数组项的数据类型。 -
计数:
此参数用于表示从数组中的缓冲区读取的项目数。
注意: 为了提高该功能的性能，指定一个count参数是很重要的。因为count参数允许fromiter()函数预分配输出数组，而不是按需调整其大小。
返回值:
该函数将返回使用 iterable 对象创建的数组。
现在我们来讨论一些使用fromiter()函数的例子。
基本示例:
下面是使用这个函数的例子的代码片段:
import numpy as np
a = [0,2,4,9,10,8]
it = iter(a)
x = np.fromiter(it, dtype = float)
print("The output array is :")
print(x)
print("The type of output array is:")
print(type(x))
输出数组为:
【0。2.4.9.10.8.】
输出数组的类型为:
<类>
摘要
在本教程中，我们介绍了 Numpy 库中的numpy.fromiter()函数。我们还介绍了它的语法、参数以及这个函数返回的值和代码示例。
Matplotlib
Matplotlib 基础
Matplotlib 简介
原文：https://www.studytonight.com/matplotlib/introduction-to-matplotlib
在本教程中，我们将介绍 Python 中 Matplotlib 库的基本介绍，Matplotlib 中的重要模块，如何安装 Matplotlib 模块，并且我们将了解该库对于数据可视化的用处。
什么是 Matplotlib？
Matplotlib 基本上是建立在 NumPy 数组上的数据多平台可视化库。该库旨在与更广泛的 SciPy 堆栈合作，该堆栈包括用于机器学习和数据科学的不同 Python 模块。
-
Matplotlib 是默认的(排序) Python 数据可视化包。
-
由于 Matplotlib 是一个可视化库，这些可视化让我们能够像图表和绘图一样以可视化的形式表示大量的数据。
-
Matplotlib 在从数组中的数据创建 2D 图时很有用。
-
Matplotlib 库的灵感来源于 MATLAB 编程语言，它还提供了类似于的 MATLAB 图形界面。
-
该库可轻松与用于数据操作的Pandas 包 集成。
-
Pandas 和马特洛特利布 的组合，数据角力可以和可视化一起完成，人们可以从数据中获得有价值的见解。
-
Python 中的 Matplotlib 库主要被称为 Grammer of Graphics ，是 Python 中最常用的库，用于创建图表和绘图。
-
Matplotlib 可以与 Jupyter 笔记本、 web 服务器应用和IPython shell一起使用。
由约翰·d·亨特在 2003 年写成，诞生了 0.1 版本。Matplotlib 在被太空望远镜科学研究所采用为首选的绘图包时，获得了的早期提升。
目前稳定版本为 2.2.0 ，发布于 2018 年。
Matplotlib 中的重要模块
Matplotlib 库中有两个重要模块，如下所示:
1. pyplot
-
它是 Matplotlib 中的一个重要模块。在代码示例的后续教程中，您将经常看到
matplotlib.pyplot被使用。 -
这个模块主要是给我们提供了一个界面，允许我们自动隐式创建人物及其轴到实现想要的剧情。
-
这是一个很棒的模块，当你快速想要在没有实例化任何图形或任何轴的情况下绘制一些东西。
2.派尔巴
-
它是 Matplotlib 的另一个重要模块。
-
您需要将该模块安装在 matplotlib 模块旁边。
-
模块 pylab 帮助导入 NumPy 和 pyplot ，建议当需要使用数组，进行数学运算，需要访问绘图功能时使用。
-
不建议在使用 IPython 内核的情况下使用。
安装 Matplotlib
matplotlib 的相关包和 Matplotlib 本身以轮包的形式在标准 Python 包存储库中可用。因此，它可以很容易地安装在苹果操作系统，窗口，Linux 等。使用画中画包管理器。
注意:你必须在你的机器上安装 Python，才能安装 matplotlib 模块。这是我们的 Python 安装指南。
您只需要打开命令提示符，编写以下给定命令:
python -m pip install -U matplotlib
如果您正在使用 Jupyter Notebook，那么需要注意的是，Jupyter Notebook 附带了许多预安装的库，如 Numpy、Pandas、Matplotlib、Scikit-Learn，因此您不必担心单独安装这些模块/库。
总结:
因此，在本教程中，我们学习了什么是 matplotlib 模块，为什么它如此受欢迎，matplotlib 的不同模块是有用的，然后我们还学习了如何安装 matplotlib 模块。
Matplotlib 中的一般概念
原文：https://www.studytonight.com/matplotlib/general-concepts-in-matplotlib
在本教程中，我们将介绍 Matplotlib 中的一些一般概念和的一些提示供您记忆，借助哪个可视化变得容易。
我们知道 Matplotlib 是一个强大的库，用于以图的形式可视化数据。您将在我们的教程中看到，在这个库的帮助下，您可以创建许多类型的图，如线、条形图、直方图、轮廓图、散点图、提琴图等等。用于创建阵列的 2D 图。
这里有一些一般的概念，你必须先了解，然后再继续进一步的主题。使用 matplotlib 创建的图形有许多部分，这里我们将讨论这些部分，它们是:
首先，我们用了“图”字；让我们了解一下什么是 Matplotlib 中的人物？
1.图:
图是创建不同绘图的画布。Matplotlib 图形是包含一个或多个轴/绘图的画布。
2.轴:
一个 Matplotlib 图中的轴是用来生成图极限的，基本上就像一个数线。三维图可以有一个 X 轴、Y 轴和 Z 轴。
3.轴:
Axes 一般被认为是一个图。在 3D 的情况下，有三轴对象但是一个图形中有多轴。
4.艺术家
在图上能看到的一切都是艺术家。大多数艺术家都被绑上了斧头。这些像是文本对象、集合对象和 Line2D 对象等等。
在借助 matplotlib 创建可视化之前；让我们讨论一些与 Matplotlib 库相关的事情:
1.导入 Matplotlib 库
在我们的代码中导入 Matplotlib 时，我们将使用一些标准的简写:
import matplotlib as mpl
import matplotlib.pyplot as plt
The plt interface mentioned above is used often in our further tutorials.
2.设置样式
因此，我们将使用plt.style指令为我们的人物选择合适的美学风格。
现在，让我们设置经典风格，确保我们创建的情节使用经典的 Matplotlib 风格:
plt.style.use('classic')
3.显示图
地块的显示方式取决于您如何使用 Matplotlib 库。
您可以使用 Matplotlib 创建三个适用的上下文:脚本中的、T2 IPython 笔记本中的或 T4 IPython Shell 中的。
根据脚本绘图:
如果你在脚本中使用 matplotlib ，那么plt.show()函数就是你的好朋友。此功能启动一个事件循环，然后查看所有当前活动的图形对象，并打开一个或多个交互窗口，显示您的图形或图形。
注 :在每个 Python 会话中plt.show()命令只能使用一次，并且最常出现在脚本的末尾。
您不能使用多个show()命令，因为如果您愿意，它将会导致不可预测的依赖后端的行为。因此应该尽量避免。
**让我们以一个名为myplt.py的文件为例，其中的代码如下:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 10, 100)
plt.plot(x, np.sin(x))
plt.plot(x, np.cos(x))
plt.show()
在命令行提示符下运行上述脚本，使用以下命令:$ python myplot.py将打开一个窗口，显示您的图形。
从 IPython 外壳绘图
如果您指定 Matplotlib 模式，IPython 可以很好地与 Matplotlib 配合使用。如果您想启用此模式，可以在启动 ipython 后立即使用%matplotlib魔法命令:
%matplotlib
当您运行上述命令时，它会给出:
使用 matplotlib 后端:Qt5Agg
在上述命令之后，编写以下代码:
import matplotlib.pyplot as plt
现在任何plt剧情命令都会打开一个人物窗口，然后你可以进一步使用可以运行的命令来更新剧情。
某些更改(如修改已经绘制的线的属性)不会自动绘制；如果你想强制更新，那么使用plt.draw()。不需要在 Matplotlib 模式下使用plt.show()。
从 IPython 笔记本中绘图
现在 IPython Notebook 基本上是一个基于浏览器的交互式数据分析工具，用于将叙事、代码、图形、 HTML 元素等更多的东西组合成一个单一的可执行文档。
如果你想在 IPython 笔记本中交互式绘图，那么使用%matplotlib命令，它将以类似于 IPython 外壳的方式工作。在 IPython 笔记本中，您还可以选择直接在笔记本中嵌入图形，有两种可能的选择:
-
笔记本中的命令
%matplotlib会将引向嵌入在笔记本中的交互剧情。 -
命令
%matplotlib inline将有助于在笔记本中嵌入你的剧情的静态图像
首先，运行下面给出的命令:
%matplotlib inline
运行此命令后(每个内核/会话只需执行一次)，笔记本中创建绘图的任何单元格都将嵌入生成图形的 PNG 图像。
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 100)
fig = plt.figure()
plt.plot(x, np.sin(x), '-')
plt.plot(x, np.cos(x), '--')
总结:
因此，在本教程中，我们试图涵盖 Matplotlib 模块的基础知识，使用 Matplotlib 生成的绘图组件以及如何使用 Matplotlib，涵盖了 3 种不同的方法。
Jupyter 笔记本中的 Matplotlib
原文：https://www.studytonight.com/matplotlib/matplotlib-with-jupyter-notebook
在本教程中，我们将介绍 Jupyter 笔记本，其中我们将使用 Matplotlib 模块创建可视化，我们还将介绍 Jupyter 笔记本的主要功能。
Jupyter Notebook 是一款开源网络应用，借助它可以创建和共享包含实时 python 代码、可视化和代码解释的文档。
-
Jupyter Notebook 用于数据清理、数据可视化、机器学习、数值模拟，还有更多这样的用例。
-
Jupyter 主要代表 Ju lia、 Pyt hon、 R uby，最初 Jupyter Notebook 是为这三个开发的，但后来开始支持很多其他语言。
-
Ipython 由 Fernando Perez 于 2001 年开发，作为命令外壳用于交互计算在多种编程语言中以 Python 开始。然后在 2014 年，费尔南多·佩雷斯宣布了一个分拆项目，该项目被称为Jupyter项目。
-
nd 正如我们今天所知， IPython 作为 Python shell 和 Jupyter 的内核继续存在，而 IPython 的笔记本和其他语言部分则转移到了 Jupyter 的名字下。
-
Jupyter 还增加了对 Julia、R 和 Ruby 的额外支持。
Jupyter(IPython)笔记本的特点
让我们讨论一下 Jupyter Notebook 的特性，然后我们将讨论如何启动它，并将其与 Matplotlib 库一起使用:
-
Jupyter Notebook 是一个非常灵活并且非常有助于分享代码的工具，有完整的解释、评论、图片等。在一起，如果您正在学习编码，这将非常有帮助。
-
需要注意的是 Jupyter 笔记本通过网络浏览器运行，笔记本本身可以托管在您的本地机器或远程服务器上。
-
在 Jupyter 笔记本的帮助下，查看代码、执行代码、以及直接在你的网页浏览器中显示结果变得很容易。
-
借助 Jupyter 笔记本，您可以与他人共享您的代码。它允许对共享代码和数据集进行交互更改。
-
假设有一段代码，你想逐行解释它是如何工作的，通过实时反馈，你可以简单地将代码嵌入到 Jupyter 笔记本中。最好的是代码会保持全功能，你可以随着加入互动，解释、展示、讲述同时进行，这是有益的。
让我们从 Jupyter 笔记本开始。首先您需要打开 Anaconda 导航器(这是 Anaconda 中包含的桌面图形用户界面，允许您启动应用并轻松管理 Conda 包、环境和通道，而无需使用命令行命令)。
现在在你的机器上搜索 Ananconda Navigator(如果你想使用 Jupyter Notebook-https://docs.anaconda.com/anaconda/navigator/install/)，你应该提前安装它:
在打开 Python 导航器后，你会看到在其分布中安装的组件。让我们向您展示:
现在你只需要启动 Jupyter 笔记本就可以开始使用 Matpotlib 了。只需点击推出，它就会推出 Jupyter 笔记本。
正如我们在上面提到的 Jupyter Notebook 通过网络服务器运行。
启动后，您将看到以下内容:
如果你想从制作一个可以轻松完成任务的新笔记本开始，只需点击“文件选项卡中的“新建按钮”即可轻松完成。
在那里你会看到很多选项，比如制作一个终端、制作一个常规文本文件、制作一个文件夹，最后但同样重要的是，你还会看到制作一个 Python 3 笔记本的选项。让我们向您展示一个图示以供您清楚理解:
总结:
在本教程中，我们学习了如何安装 Jupyter notebook，如何使用它以及关于 Jupyter Notebook 的其他细节。我们正在讨论 Jupyter 笔记本，因为我们将把它与 Matplotlib 模块一起用于绘图和可视化。
Matplotlib PyPlot API
在本教程中，我们将详细介绍 Matplotlib 中的 Pyplot API，帮助您了解 Pyplot API 在 Matplotlib 中的使用。
matplotlib.pyplot基本上是命令风格函数的集合，这有助于使 Matplotlib 像 MATLAB 一样工作。
-
pyplot主要是打算在 Matplotlib 中制作互动剧情和简单案例的程序化剧情生成。 -
pyplot 中的各个功能对图形做了一些改变，比如有创建图形的功能，有在图形中创建绘图区域的功能，有在绘图区域中绘制一些线条的功能，有用标签装饰图形的功能等等。
Jupyter 笔记本中的新笔记本
如果你想在 Jupyter 笔记本中创建一个新的笔记本来存放你的作品，那么我们在之前的教程中已经向你展示了这个选项。现在，当你点击“新建”按钮时，你可以选择 Python3、终端、文件夹等。
只需点击 Python3 ，就会有一个 Python 笔记本为你保存，扩展名为(.ipynb)。
让我们给你看一张图片，然后你就会明白:
现在在这个笔记本中，你可以运行你的命令，可以使用 Matplotlib 绘制任何类型的图、直方图或任何你想要的东西，运行它，然后保存它。
不同类型的地块
现在让我们讨论可以借助 Matplotlib 库可视化的不同类型的图:
-
酒吧
这将创建一个酒吧情节。 -
hist
这将创建一个直方图。 -
hist2D
这将创建一个二维直方图。 -
饼图
这将创建一个饼图。 -
盒子图
这将创建一个方块和触须图。 -
剧情
这有助于剧情主线。 -
散点
这将用于绘制x对y的散点图。 -
堆叠地块
这是用来绘制堆叠区域地块的。 -
箭袋
这将有助于绘制一个二维的箭场。 -
梗
这就画一个梗的剧情。 -
极地
这将绘制一个极地的剧情。 -
步
这就画个梗图。
不同类型的图形函数
让我们讨论一些与 Matplotlib 中的图形相关的函数，如下所示:
-
figure
这将创建一个新的图形。 -
figtext
这是用来给图中添加文字的。 -
savefig
用于保存当前图形。 -
show
这是用来显示身材的。 -
close
这是用来关闭图的窗口。
不同类型的图像函数
让我们讨论一下 Matplotlib 中与图像相关的一些函数:
-
Imread
该功能用于将文件中的图像读入数组 -
Imsave
该功能用于保存图像文件中的数组。 -
Imshow
用于显示坐标轴上的图像。
不同类型的轴功能
让我们讨论一下 Matplotlib 中与轴相关的一些函数:
-
斧头
这是用来给图中添加斧头的。 -
文本
这是用来给轴添加文本的。 -
标题
用于设置当前坐标轴的标题 -
XLabel
用于设置当前轴的 x 轴标签 -
YLabel
用于设置当前轴的 y 轴标签 -
坐标
用于获取或设置当前刻度位置和标签的 x 限制。 -
YTicks
这用于获取或设置当前刻度位置和标签的 y 限制。 -
XScale
这是用来设置 x 轴的缩放比例。 -
y 缩放
这是用来设置 y 轴的缩放。 -
XLim
这用于获取或设置当前轴的 x 轴限制 -
YLim
用于获取或设置当前轴的 y 轴限制
总结:
在本教程中，我们介绍了 Matplotlib 库中 Pyplot API 的各种有用功能和属性。
Matplotlib 简单折线图
在本教程中，我们将介绍 Matplotlib 中的简单折线图。
单线功能即y=f(x)的可视化是所有功能中最简单的。让我们看一下创建这种类型的简单情节。在本教程中，我们将介绍以下简单的折线图:
-
y=f(x)型直线 -
正弦函数的图形
-
用多条线创建单个图形(正弦和余弦函数)
-
曲线
现在第一步也是最重要的一步是设置用于绘图的笔记本和导入我们将使用的那些功能:
1.正在导入 Matplotlib
要导入 Matplotlib，您只需要编写以下命令:
import matplotlib.pyplot as plt
为了方便起见，我们将导入一个别名为 plt 的 matplotlib。
2.正在导入 Numpy
我们将绘制数字；所以为了绘制数字，我们需要一个数组。在 Python 的 Numpy 模块中，有很多创建数组的功能。所以我们也会在代码中导入 Numpy 。为了方便起见，我们将使用别名 np 导入 Numpy。
其命令如下:
import numpy as np
Matplotlib 中y=f(x)类型的图形
让我们看看最简单等式的代码片段:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
print(x)
y = 2*x + 1
plt.plot(x, y)
plt.show()
在上面的代码示例中，plot(x, y)函数主要用于绘制直线。这个代码片段的输出如下所示:
Matplotlib 中正弦波的图形
现在我们将向您展示使用 matplotlib 可视化正弦波。其代码片段如下所示:
代码说明
让我们看一下代码的简要解释:
-
第一步是导入别名为 plt 的
matplotlib.pyplot。 -
下一步是用 np 的别名导入 Numpy ，以便使用与其相关的数组和函数。
-
然后我们导入了数学模块，用于可视化中所需的数学计算。
-
现在使用
arange()功能从 NumPy 库获得 0 和 2(饼图)之间的标准角度对象。 -
为了绘制两个数组的值，我们使用了
plot()函数。 -
在后面的两行中，我们已经设置了图形的 x 和 y 标签。
-
之后在下一行，我们已经借助
title()功能为图形设置了标题。 -
为了显示图形，我们使用了
show()功能。
用多条线创建单个图形
如果你想创建一个包含多条线的单一图形，那么你只需要多次调用绘图函数。
其代码如下:
用曲线创建图形
在 Matplotlib 中使用plot()方法绘制任意一条线。没有必要总是一条直线，就像我们刚刚在上面的例子中看到的，我们如何绘制一个波。我们也可以画一条曲线。
让我们举一个 Matplotlib 中的简单曲线的例子:
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 50)
y = 2**x + 1
plt.plot(x, y)
plt.show()
其输出如下所示:
在本教程中，我们已经介绍了如何绘制直线、如何绘制曲线、单正弦波，我们还介绍了绘制多条线。
这都是关于在 Matplotlib 中绘制简单函数。现在在我们的后续教程中，我们将使用 matplotlib 讲述更多神奇的事情。我们将深入探讨如何控制轴和线的外观的更多细节。
Matplotlib pylab 模块
在本教程中，我们将介绍 Matplotlib 中的 Pylab 模块。
该模块主要帮助将来自 pyplot 和 NumPy 的函数和类引入全局命名空间，这对于 Matlab 用户来说变得更加容易。
-
该模块为面向对象的Matplotlib绘图库提供程序接口。
-
该模块安装在 Matplotlib 旁边；同样地， matplotlib.pyplot 是 matplotlib 包中的一个模块。
-
这是一个非常方便的模块，因为该模块有助于在单个名称空间中批量导入
matplotlib.pyplot(用于绘图)和 NumPy (用于数学和处理数组)。
注:【Pylab】与 Python 中的各种内置函数冲突**，因此被废弃，使用不多。
导入 Pylab 模块的语法
导入 pylab 模块的基本语法如下:
from pylab import *
让我们介绍使用 pylab 模块的基本绘图:
pylab 模块使用示例:
为了绘制一条曲线，在这个代码示例中，我们将使用plot()函数。你只需要一对长度相同的数组。让我们看看相同的代码:
from numpy import *
from pylab import *
x = linspace(-1, 4, 30)
y = x**2
plot(x, y)
show()
现在让我们看看由此产生的输出:
如果需要绘制符号而不是线条，那么需要在plot()方法中提供一个额外的字符串参数。
可能的符号和颜色如下:
-
符号:-，-。, : , .、、o、^、v、< , >、s、+、x、d、d、1、2、3、4、h、h、p、|、_
-
颜色:b、g、r、c、m、y、k、w
让我们举一个活生生的例子:
使用 pylab 覆盖图
这些图也可以重叠。为此您需要使用多个plot命令。clf()功能用于清除剧情。
让我们看一个叠加图的实例:
面向对象接口
原文：https://www.studytonight.com/matplotlib/matplotlib-object-oriented-interface
在本教程中，我们将介绍 Matplotlib 中的面向对象接口。
Matplotlib 接口
Matplotlib 中有两种类型的可视化界面，如下所示:
1.使用 Pyplot 接口的类似 MATLAB 的接口
只需导入matplotlib.pyplot模块，即可在 matplotlib 库中使用 pyplot 模块轻松生成地块。
-
pyplot 界面也是一个基于状态的界面。
-
基于状态的界面的主要品质是，它允许我们在需要的时候，根据需要添加元素和/或修改绘图。
-
Pyplot 界面在语法和方法上与 MATLAB 有很多相似之处。
这个接口也有一些缺点，这就是为什么 Matplotlib 的面向对象接口开始发挥作用。当需要制作多个地块或者当我们必须制作需要大量定制的地块时，pyplot界面并不能很好地扩展。
2.Matplotlib 中的面向对象接口
为了更好地控制使用 matplotlib 创建的图，为了更好地定制图，我们使用 matplotlib 的面向对象界面。
-
面向对象的界面可以很容易的被访问，也允许我们重用对象和 matplotlib 内部使用的这个面向对象的界面。
-
当需要在画布上绘制多个图时，面向对象的方法有时更好。
-
这个界面背后的 ides 是创建图形对象，然后只需要调用该对象的方法或属性。
-
在 matplotlib 中的面向对象界面中， Pyplot 仅用于图形创建等少数功能，用户也明确创建图形、跟踪图形和轴对象。
-
在这种情况下，用户使用 Pyplot 创建图形，在这些图形的帮助下，也可以创建一个或多个轴对象。大多数打印操作都可以使用轴对象。
matplotlib 中的图主要分为两部分:
1。图形对象:
图形对象包含一个或多个轴对象。
让我们尝试运行一些代码:
import matplotlib.pyplot as plt
fig = plt.figure()
print(type(fig))
其输出如下:
<类>
2。轴对象:
坐标轴代表图形内部的一个图
让我们尝试下面给出的 axes 对象的一些代码:
from matplotlib import pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.cos(x)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title("cos wave")# used to set the title
ax.set_xlabel('angle')# used to set label for x-axis
ax.set_ylabel('cos') #used to set label for y-axis
plt.show() # used to display the plot
上述代码中使用的功能描述:
1 .plt.figure()
该函数将创建一个图形实例，提供一个空画布。
2。图 add_axes([0，0，1，1])
add _ axes()方法需要一个由 4 个元素组成的列表对象，这些元素对应于图形的左侧、底部、宽度和高度。需要注意的是，每个数字必须介于 0 和 1 之间。
上述代码的输出如下:
总结:
在本教程中，我们已经介绍了 Matplotlib 模块的各种接口和类。
Matplotlib 图形类
原文：https://www.studytonight.com/matplotlib/matplotlib-figure-class
在本教程中，我们将介绍 matplotlib 库中的图形类。
众所周知 matplotlib 是一个用来创建可视化的 python 库，也是 Numpy 库的数值扩展。
-
matplotlib 库在
matplotlib.figure模块中包含一个图形类。 -
对于所有的绘图元素图形类主要是顶层容器。
-
要实例化图形对象，您只需要调用 pyplot 模块的
figure()函数(它是 matplotlib 的基于状态的接口) -
在 pyplot 的帮助下，人们可以轻松地创建直方图、提琴图、等高线图、3D 图以及更多。
-
我们还可以扩展 Figure 类，并根据我们的需求创建一个自定义类。( Python 继承)
figure()功能
为了创建一个新的图形，在 matplotlib 库中使用了 pyplot 模块的figure()功能。
语法:
下面给出了使用该函数的语法:
matplotlib.pyplot.figure(num, figsize, dpi, facecolor, edgecolor, frameon, FigureClass, clear, **kwargs)
参数:
让我们讨论一下figure()函数的参数:
1 . num
该参数的默认值为无。您可以提供此参数，并且带有此 id 的图已经存在。
2。 figsize(float, float)
这用于以像素为单位指示宽度和高度。
3 .dpi〔t1〕
该参数用于指示图形的分辨率。默认值为无。
4 .面色
该参数用于指示背景颜色。
5. 边缘颜色
该参数用于指示边框颜色。
6. frameon
如果不想绘制图形的框架，则使用此选项。该参数的默认值为 true ，表示默认绘制框架。
7。figure class〔t1〕
该参数主要使用一个自定义的 Figure 实例。
8。清除
默认值为假。如果该参数值为真且图形已经存在，则被清除。
返回值:
该方法返回图形实例，该实例也被传递给后端的new_figure_manager。
时间示例:
让我们借助下面给出的例子来讨论这个函数:
在上面的代码示例中，我们创建了一个新的类 MyFigure 继承了原来的 Figure 类。
总结:
在本教程中，我们介绍了matplotlib.figure模块中提供的图形类。我们还学习了非常有用的figure()功能。
Matplotlib Axes类
在本教程中，我们将介绍 Matplotlib 库中基于状态的界面 (pyplot 模块)中的 Axes类。
带有数据空间的图像区域通常被称为轴对象。创建子地块的灵活的和基本的单位是轴线。
-
借助轴，可以在图中的任意位置绘图；因此，它为您提供了以灵活的方式创建子情节。
-
任何给定的图形都可能包含许多轴，但是给定的轴对象只能在一个图形中。
-
在二维的情况下，t 轴包含两个轴对象，在三维的情况下，轴包含三个轴对象。
-
要在图形中添加一个 Axes 对象，您只需要调用
add_axes()方法。 -
add_axes()方法将返回轴对象，并在矩形【左、底、宽、高】的位置添加轴，所有这些量都以图形宽度和高度的分数表示。
axes()功能
该功能主要用于创建一个带参数的坐标轴对象。
- 参数主要是 4 个元素的列表【左、底、宽、高】
下面给出了这个函数的基本语法:
axes([left, bottom, width, height])
让我们看一个最简单的例子，我们将使用 axes()函数:
import matplotlib.pyplot as plt
fig = plt.figure()
#[left, bottom, width, height]
ax = plt.axes([0.2, 0.2, 0.9, 0.9])
其输出如下:
上面例子的解释:
-
在上面的代码中，
axes([0.2, 0.2, 0.9, 0.9])，其中第一个‘0.2’表示左侧轴到图形窗口边框的距离，即图形窗口总宽度的 20% 。 -
第二个‘0.2’表示的是底侧轴线与图窗边框的距离，即图窗总高度的 20% 。
-
另外，第一个‘0.9’表示从左到右的轴宽为 90% 并且
-
后者‘0.9’表示自下而上的轴线高度为 80% 。
轴类中的成员函数
在下一节中，我们有 Axes类的成员函数，用于向图中添加不同的元素:
1.ax.legend()功能
使用轴类的legend()方法为绘图添加图例。
语法如下:
ax.legend(handles, labels, loc)
参数:
该函数采用三个参数:
-
参数标签用于指示字符串的序列，它主要处理 Line2D 的序列。
-
参数 loc 可以是字符串，也可以是整数，主要指定图例位置。
| 位置字符串 | 位置代码 |
| 最好的 | Zero |
| 右上方 | one |
| 左上角 | Two |
| 左下角 | three |
| 右下角 | four |
| 对吧 | five |
| 中间偏左 | six |
| 中间偏右 | seven |
| 下死点 | eight |
| 上中心 | nine |
| 中心 | Ten |
下面我们有一个使用legend()方法的基本例子:
import matplotlib.pyplot as plt
fig = plt.figure()
#[left, bottom, width, height]
ax = plt.axes([0.2, 0.2, 0.8, 0.8])
ax.legend(labels = ('label1', 'label2'), loc = 'center right')
该代码的输出如下:
2.add_axes()功能
如果有需要，您也可以通过调用add_axes()方法(因此这是一种替代方法)将斧子对象添加到图形中。
该方法将返回轴对象，并在【左侧、底部、宽度、高度】位置添加轴，所有这些量都是图形宽度和高度的分数。
语法如下:
add_axes([left, bottom, width, height])
让我们介绍一个使用这种方法的例子:
import matplotlib.pyplot as plt
fig = plt.figure()
#[left, bottom, width, height]
ax = fig.add_axes([1, 1, 1, 1])
上述代码示例的输出如下:
3.ax.plot()功能
轴类最基本的方法是使用将一个数组的值与另一个数组的值绘制成线或标记。
该方法可以有一个可选格式字符串参数，主要用于指定颜色、样式和线的大小和标记。
使用颜色代码:
要指定颜色，我们将使用颜色代码:
| 性格；角色；字母 | 颜色 |
| ' b ' | 蓝色 |
| g′ | 格林（姓氏）；绿色的 |
| r′ | 红色 |
| ' b ' | 蓝色 |
| c′ | 蓝绿色 |
| m′ | 品红 |
| 你好 | 黄色 |
| k′ | 黑色 |
| ' b ' | 蓝色 |
| w ' | 白色的 |
使用标记代码:
要指定标记的样式，我们将使用:
| 性格；角色；字母 | 描述 |
| '.' | 点标记 |
| 的 | 圆形标记 |
| x ' | X 标记 |
| d′ | 钻石标记 |
| ' h ' | 六边形标记 |
| s | 正方形制造者 |
| '+' | 加记号 |
使用线条样式:
您可以使用的各种线型如下:
| 性格；角色；字母 | 描述 |
| '-' | 实线 |
| '—' | 短划线 |
| '-.' | 点划线 |
| ':' | 点线 |
| ' h ' | 六边形标记 |
语法如下:
plt.plot(X, Y, ‘CLM’)
参数:
X: 该参数表示 X 轴。
Y: 该参数表示 Y 轴
CLM: 代表颜色、线条和标记。
让我们来看一个上面解释的函数的例子:
import matplotlib.pyplot as plt
import numpy as np
X = np.linspace(-np.pi, np.pi, 15)
C = np.cos(X)
S = np.sin(X)
# [left, bottom, width, height]
ax = plt.axes([0.1, 0.1, 0.8, 0.8])
ax1 = ax.plot(X, C, 'mx:')
ax2 = ax.plot(X, S, 'cD-')
ax.legend(labels = ('Cosine Function', 'Sine Function'),loc = 'upper left')
ax.set_title("Trigonometric Functions in Mathematics")
plt.show()
上述代码片段的输出如下所示:
总结:
在本教程中，我们介绍了 matplotlib Axes类，以及如何在代码示例和输出中使用它。我们还介绍了这个类的各种不同功能以及如何使用它们。
Matplotlib 使用subplots()函数的多图
原文：https://www.studytonight.com/matplotlib/matplotlib-multiplots-with-subplots-function
在本教程中，我们将介绍如何在 matplotlib 中在单个图形中绘制多个图。
你一定在想，为什么我们要在一个图中有多个图。那只会导致混乱和混乱。但是如果你需要要么在两条曲线之间做比较，要么你想在图中显示一些渐变(相对于彼此)等等。在这种情况下，多个图是有用的。
在 matplotlib 中，我们可以使用支线剧情来实现。
subplots()功能在 matplotlib 库的 pyplot 模块中，用于以有效的方式创建子剧情/多剧情。
subplots()功能
该功能将创建一个图形和一组支线剧情。它基本上是一个包装函数，用于在一次调用中创建子场景(包括包围图对象)的通用布局。
-
该函数主要返回一个图形和一个轴对象或者一个轴对象数组。
-
如果在没有任何参数的情况下使用此功能，那么它将返回一个图形对象和一个轴对象。
suplots()函数的语法:
下面给出了使用该函数的语法:
subplots(nrows, ncols, sharex, sharey, squeeze, subplot_kw, gridspec_kw, **fig_kw)
参数:
让我们讨论一下这个函数使用的参数:
-
非政府组织，ncls
参数显示表示行数，参数显示表示表示子图网格的列数。两个参数都有默认值 1 。
-
sharex，sharey
为了控制 x (
sharex)轴之间的属性共享或 y (sharey)轴之间的属性共享，使用这些参数。 -
挤压
该可选参数通常包含布尔值，默认值为真。
-
支线剧情 _kw
该参数用于用传递给
add_subplot调用的关键字指示字典，该调用用于创建每个子图。 -
电网规格 _kw
此参数用于指示带有传递给
GridSpec构造器的关键字的字典，该构造器用于创建放置子情节的网格。 -
*** 图 _kw*
传递给
.pyplot.figure调用的所有附加关键字参数都是该参数的一部分。
现在我们将介绍一些例子，以便所有的概念对您来说变得清晰。
示例 1:用一个图形和一个轴绘图
该示例的代码如下:
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2*np.pi, 400)
y = np.sin(x**2) + np.cos(x)
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('Simplest plot in the matplotlib')
现在该看看代码的输出了:
在本例中，我们使用了subplots()函数，但是我们没有向图中添加两个图。所以subplots()功能通常也可以用来创建一个单独的图表。
示例 2:堆叠图
让我们举一个堆叠图的例子。我们将通过将一个叠加在另一个上来尝试绘制一系列的图(这里是图 2)。由于有地块的堆叠，所以行数(即nrows)会发生变化，也就是说ncols保持不变 1 。此外，每个子剧情由索引参数标识。
这方面的代码片段如下:
import numpy as np
import matplotlib.pyplot as plt
plt.figure(figsize=(6, 4))
def f(x):
return np.sin(x) - x * np.cos(x)
def fp(x):
""" The derivative function of f """
return x * np.sin(x)
X = np.arange(-5, 5.0, 0.05)
fig, ax = plt.subplots(2,
sharex='col', sharey='row')
ax[0].plot(X, f(X), 'bo', X, f(X), 'k')
ax[0].set(title=' function f')
ax[1].plot(X, fp(X), 'go', X, fp(X), 'k')
ax[1].set(xlabel='X Values', ylabel='Y Values',
title='Derivative Function of f')
plt.show()
下面是上面代码的输出:
正如您在上面的输出中看到的，两个地块一个堆叠在另一个之上。情节也可以是其他类型的。但是当你想在情节之间做一些比较时，这是一个很好的方法。
示例 3:在另一个图中绘制
对于这个代码示例。让我们举一个活生生的例子。
您也可以使用上面的终端运行其他示例并查看输出。也尝试制作不同的情节。
总结:
在本教程中，我们讲述了如何使用subplots()函数在 matplotlib 中创建多个图。我们还在一张图中介绍了多个地块的不同布局。
Matplotlib subplots()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-subplots-function
在本教程中，我们将介绍 Matplotlib 库中基于状态的界面 Pyplot 中的subplots()函数。
Matplotlib 中的subplots()函数充当实用程序包装器。该功能有助于创建支线剧情的通用布局，并且在一次调用中还包括包围图形对象。
-
这个功能的主要目的是创建一个带有一组支线剧情的人物。
-
matplotlib 支持的各种支线剧情有 2x1 垂直、 2x1 水平或 2x2 网格。
Matplotlib subplots()函数
使用该功能的基本语法如下:
matplotlib.pyplot.subplots(nrows, ncols, sharex, sharey, squeeze, subplot_kw, gridspec_kw, **fig_kw)
Matplotlib subplots()功能参数
让我们讨论一下这个函数使用的参数:
-
非政府组织，ncls
参数显示表示行数，参数显示表示表示子图网格的列数。
-
sharex，sharey
为了控制 x 轴(共享)或 y 轴(共享)之间的属性共享，使用这些参数。
-
挤压
该可选参数通常包含布尔值，默认值为真。
-
支线剧情 _kw
此参数用于指示带有关键字的 dict，这些关键字被传递给用于创建每个子批次的 add _ sub 批次调用。
-
电网规格 _kw
此参数用于指示带有传递给 GridSpec 构造器的关键字的 dict，该构造器用于创建放置子情节的网格。
Matplotlib subplots()函数返回值
这些函数返回的值如下:
-
图:此方法用于返回图布局。
-
斧:此法主要用于回斧。它可以是轴对象或轴对象的数组。
让我们借助几个例子来理解这个方法:
例 1:
通过下面给出的代码片段，我们将创建一个具有 2 行 2 列子场景的图形。
import matplotlib.pyplot as plt
import numpy as np
fig, ax = plt.subplots(2, 2)
x = np.linspace(0, 8, 1000)
ax[0, 0].plot(x, np.sin(x), 'c') #row=0, col=0
ax[1, 0].plot(x, np.tan(x), 'r') #row=1, col=0
ax[0, 1].plot(range(50), 'y') #row=0, col=1
ax[1, 1].plot(x, np.cos(x), 'k') #row=1, col=1
fig.show()
上述代码的输出如下:
让我们用一个真实的例子来更详细地理解这个函数。
示例 2
让我们理解下面给出的实时示例的代码，其中我们已经绘制了两个子图。
总结:
如果要在一个图中创建多个子图来显示一个数据的不同方面，那么应该使用subplots()功能。
Matplotlib subplot2grid()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-subplot2grid-function
在本教程中，我们将介绍基于状态的界面中的subplot2grid()函数，即 Matplotlib 库中的 Pyplot
该功能用于在网格内的特定指定位置创建轴对象时提供额外的灵活性。
-
对于轴对象跨越多行或多列的，我们将使用这种方法。
-
subplot2grid()功能也被称为子图形布局管理器。 -
简而言之，我们将使用该功能在同一图形内创建多个图表。
Matplotlib subplot2grid()函数
subplot2grid()功能或matplotlib.pyplot.subplot2grid功能可以很容易地用于在同一个图形内创建多个图表，下面是其语法:
matplotlib.pyplot.subplot2grid(shape, location, rowspan, colspan)
Matplotlib subplot2grid()参数:
让我们讨论一下这个函数使用的参数:
-
形状
形状参数用于指示图形内部要绘制的网格的形状。这是对这个方法的强制性论证。
通常作为两个数字的列表或元组传递，主要负责网格的布局，第一个数字表示的行数，而第二个数字表示的列数。
-
位置
该参数也是该功能取的强制参数。这种方法类似于形状参数，通常也作为两个数字的列表或元组传递。用于指定放置子图的行号和列号。需要注意的一点是指数总是从 0** 开始。**
所以 (0，0) 是网格的第一行和第一列的单元格。
-
行跨度
使用位置(loc)参数设置网格布局和起始索引后，如果需要，还可以扩展选择以使用此参数占据更多行。这是一个可选参数，默认值为 1。
-
colspan
该参数与行跨度参数相似，用于排序扩展选择以占用更多列。这也是一个可选参数，默认值为 1。
示例:
让我们绘制一个图形对象的 3x3 网格，该网格由不同大小的轴对象以行和列跨度填充。其代码片段如下所示:
import matplotlib.pyplot as plt
def annotate_axes(fig):
for i, ax in enumerate(fig.axes):
ax.text(0.5, 0.5, "block%d" % (i+1), va="center", ha="center")
ax.tick_params(labelbottom=False, labelleft=False)
fig = plt.figure()
ax1 = plt.subplot2grid((3, 3), (0, 0), colspan=3)
ax2 = plt.subplot2grid((3, 3), (1, 0), colspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)
ax4 = plt.subplot2grid((3, 3), (2, 0))
ax5 = plt.subplot2grid((3, 3), (2, 1))
annotate_axes(fig)
plt.show()
上述代码片段的输出如下:
总结:
所以现在你知道如何使用 Matplotlib subplot2grid()函数在一个图形中制作多个轴对象，这个函数很容易使用，正如我们在上面的代码示例中看到的。
Matplotlib 网格
在本教程中，我们将介绍图中的网格是什么，以及如何使用 Matplotlib 中的grid()函数对其进行定制。
什么是网格？
在任何图表或任何数据集的图形表示中，制作网格是为了让您更好地理解整个图形/图表，并将绘图上的点与比例值相关联，因为背景中有网格线。网格使图形/图表的内部基本上由直线(垂直、水平和角度)或主要用于表示数据的曲线相交而成。
-
借助 matplotlib 中的网格，您可以更好地理解图形。
-
您可以很容易地获得数据点的参考。
-
matplotlib.pyplot.grid()是用来轻松创建网格的功能，你也可以自定义，因为有很多选项。
Matplotlib grid()函数
这个函数基本上用于创建网格。
-
在轴对象中，
grid()功能用于设置图形内网格的可见性。它可以开也可以关。 -
线型和线宽属性可以在
grid()功能中设置。 -
您可以根据自己的需求定制网格，因为有许多可用的选项。
Matplot lib grid()语法
下面我们有使用函数matplotlib.pyplot.grid()函数的基本语法:
matplotlib.pyplot.grid(b, which, axis, **kwargs)
让我们讨论一下这个函数中使用的参数:
-
b
该参数表示布尔值，用于指定是否显示网格线。该参数的默认值为真。
-
哪个
此参数用于指示需要应用更改的网格线。这个值有三个:主、次或两个。
*** 轴
此参数用于表示需要应用更改的轴。该值为 **x** 、 **y** 或两者。
* ****kwargs**
此参数用于指示可选的线属性。**
**## 示例 1
让我们看一个例子，我们将在图中创建一个网格:
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 1.0 + 0.01, 0.01)
s = np.cos(2 * 2*np.pi * t)
t[41:60] = np.nan
plt.subplot(2, 1, 1)
plt.plot(t, s, '-', lw=2)
plt.xlabel('time (s)')
plt.ylabel('voltage (mV)')
plt.title('A sine wave having gap of NaNs between 0.4 and 0.6')
plt.grid(True)
plt.subplot(2, 1, 2)
t[0] = np.nan
t[-1] = np.nan
plt.plot(t, s, '-', lw=2)
plt.title('Graph with NaN in first and last point')
plt.xlabel('time (s)')
plt.ylabel('more nans')
plt.grid(True)
plt.tight_layout()
plt.show()
上述代码片段的输出如下:
在上面的函数中，我们所做的只是添加了plt.grid(True)，它显示了最终图形中的网格。
例 2
现在，在下面给出的示例中，我们将向您展示如何使用各种选项自定义图表:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 400)
y = np.sin(x ** 2)
plt.plot(x, y, 'orange')
plt.title("Customized Plots")
# customize grids
plt.grid(True, color = "black", linewidth = "1.4", linestyle = "-.")
plt.show()
以上代码的输出如下:
在上图中，可以看到网格线是由 -。我们已经使用linestyle参数指定了，线的宽度被指定为 1.4 来控制线的宽度。我们还指定了地块颜色为橙色，可以在输出中看到。
总结:
grid()功能可用于在图形中制作更好的网格。您可以尝试网格线的不同样式、颜色和宽度，以使您的图形在视觉上更好。
在 Matplotlib 中格式化轴域
原文：https://www.studytonight.com/matplotlib/formatting-the-axes-in-matplotlib
在本教程中，我们将介绍如何在 Matplotlib 中格式化轴。让我们先来学习一下 Matplotlib 中什么是 Axes。
Matplotlib 定线
包含数据空间的图像区域主要称为轴。
- Matplotlib 中的“轴”主要包含双轴(如果是【2D】对象)或三轴(如果是 3D 对象)，然后负责数据限制。
**让我们向您展示包含图表的图的不同部分:
您可以根据自己的需求更改 Axes 的不同方面，在本教程的后续章节中，我们将学习如何做到这一点。
1.x 轴和 y 轴的标签
在本节中，我们将介绍如何在 Matplotlib 中标记 x 轴和 y 轴。
以下是 x 轴和 y 轴标注的语法:
对于 x 轴:
Axes.set_xlabel(self, xlabel, fontdict=None, labelpad=None, \*\*kwargs)
对于 y 轴:
Axes.set_ylabel(self, ylabel, fontdict=None, labelpad=None, \*\*kwargs)
这样，借助上述两个函数，您可以轻松命名 x 轴和 y 轴。
标记 x 轴和 y 轴示例:
现在让我们看一个例子，我们将利用上面两个函数来命名 x 轴和 y 轴。
import matplotlib.pyplot as plt
import numpy as np
a = [1, 2, 7, 4, 12]
b = [11, 3, 7, 5, 2]
# below function will create a figure and axes
fig,ax = plt.subplots()
# setting title to graph
ax.set_title('Sample')
# label x-axis and y-axis
ax.set_ylabel('Vertical / yaxis')
ax.set_xlabel('Horizontal / xaxis')
# function to plot and show graph
ax.plot(a, b)
plt.show()
而输出:
2.设置 x 轴和 y 轴的极限
在本节中，我们将介绍如何在 Matplotlib 中设置 x 轴和 y 轴的限制。
以下是 x 轴和 y 轴标注的语法:
对于 x 轴:
Axes.set_xlim(self, left=None, right=None, emit=True, auto=False, \*, xmin=None, xmax=None)
功能参数:
-
左****右
这两个参数在浮动并且是可选的
数据坐标中的左 xlim 为起点，右 xlim 为终点。如果您将
None传递给它，那么它将保持限制不变。 -
自动
该参数在
bool中，也是可选的。如果要开启 x 轴的自动缩放，那么这个参数的值应该是真，这个参数的假值表示关闭自动缩放(这是默认动作)
None值保持不变。 -
xmin， xmax
这两个参数分别相当于左和右，如果您将将值传递给两个 xmin 和 left 或 xmax 和 right，它会导致错误。
返回值:
这将返回右侧和左侧值，即(浮动，浮动)
对于 y 轴:
Axes.set_ylim(self, bottom=None, top=None, emit=True, auto=False, \*, ymin=None, ymax=None)
功能参数:
-
底部和顶部
这两个参数在浮动并且是可选的。
数据坐标中的底部叶立德(即起点)和顶部叶立德(即终点)。如果您将
None传递给它，那么它将保持限制不变。 -
自动
该参数在
bool中，可选。如果要打开 y 轴的自动缩放，那么这个参数的值应该是真，这个参数的假值意味着关闭自动缩放，
None值保持不变。 -
ymin，ymax
这两个参数分别相当于底部和顶部，如果您将值传递给 xmin 和底部或 xmax 和顶部，则会导致错误。
返回值:
这将返回底部和左侧值，即(浮动，浮动)
设置 x 轴和 y 轴的限制示例:
现在让我们看一个例子，我们将利用以上两个函数来设置 x 轴和 y 轴的极限。
import matplotlib.pyplot as plt
import numpy as np
x = [2, 4, 9, 5, 10]
y = [10, 4, 7, 1, 2]
# create a figure and axes
fig, ax = plt.subplots()
ax.set_title('Example Graph')
ax.set_ylabel('y_axis')
ax.set_xlabel('x_axis')
# set x, y-axis limits
ax.set_xlim(0, 10)
ax.set_ylim(0, 10)
# function to plot and show graph
ax.plot(x, y)
plt.show()
以下是输出:
3.主要和次要刻度
在 Matplotlib 中，记号基本上是 x 轴和 y 轴的值。基本上次要刻度是主要刻度的划分(像厘米和毫米，其中 CM 可以是主要刻度，MM 可以是次要刻度)。
我们有两个类Locator和Formatter来控制滴答声:
-
Locator类确定刻度将显示在哪里。 -
而
Formatter类主要控制刻度的格式。
您必须从 matplotlib 导入这两个类:
1 .多重定位符()
该函数有助于在某个基数的倍数上放置刻度。
2。格式化器
它将使用一种字符串格式，例如:‘% d’或‘% 1.2f’或‘% 1.1f cm’来格式化刻度标签。
注意: 这里需要注意的是次要刻度默认为关闭，它们可以在没有标签的情况下打开，只需设置次要定位器，而次要刻度标签可以在次要格式化程序的帮助下打开。
主要和次要刻度示例:
让我们看一个例子，
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,
AutoMinorLocator)
t = np.arange(0.0, 100.0, 0.1)
s = np.sin(0.1 * np.pi * t) * np.exp(-t * 0.01)
fig, ax = plt.subplots()
ax.plot(t, s)
# Make a plot with major ticks that are multiples of 10 and minor ticks that
# are multiples of 5\. Label major ticks with '%d' formatting but don't label
# minor ticks.
ax.xaxis.set_major_locator(MultipleLocator(10))
ax.xaxis.set_major_formatter(FormatStrFormatter('%d'))
# For the minor ticks, use no labels; default NullFormatter.
ax.xaxis.set_minor_locator(MultipleLocator(5))
plt.show()
以下是输出:
总结:
在本教程中，我们介绍了在 matplotlib 图形中格式化坐标轴的各种方法，包括为坐标轴添加标签、为坐标轴设置限制以及添加主要/次要刻度。
在 Matplotlib 中设置轴限制
原文：https://www.studytonight.com/matplotlib/setting-limits-for-axis-in-matplotlib
在本教程中，我们将介绍如何在 matplotlib 中设置 X 轴和 Y 轴值的限制。
Matplotlib 库自动设置沿绘图的 x、y(和 z 轴，如果是三维绘图)轴显示的变量的最小值和最大值。
-
但是你也可以明确设置限制。
-
有两种功能可以让您轻松明确地设置限制:
-
set_xlim()用于设置 x 轴的极限 -
set_ylim()用于设置 y 轴的极限
-
现在我们将介绍两个例子，在第一个例子中，限制由 matplotlib 库自动设置，而在第二个例子中，我们将显式设置限制。
Matplotlib 默认限制:
在下面给出的例子中，限制由 matplotlib 库自动设置。
import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.log(x))
a1.set_title('Logarithm')
plt.show()
以下是输出:
在 Matplotlib 中设置自定义限制
现在在这个例子中，我们将使用上面讨论的函数显式地设置限制。让我们看看代码:
import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([1,1,1,1])
import numpy as np
x = np.arange(1, 100)
a1.plot(x, np.exp(x),'c')
a1.set_title('Exponent')
# to set the y axis limits
a1.set_ylim(0, 10000)
# to set the x axis limits
a1.set_xlim(0, 10)
plt.show()
以下是输出:
总结:
在本教程中，我们学习了如何设置 x 轴和 y 轴的限制以正确显示数据。默认情况下，matplotlib 也很好地管理这一点，但是如果您希望明确提及这些限制，您可以使用set_xlim()和set_ylim()函数。
在 Matplotlib 中设置刻度和刻度标签
原文：https://www.studytonight.com/matplotlib/setting-ticks-and-tick-labels-in-matplotlib
在本教程中，我们将学习如何在轴上设置刻度和指定自定义刻度标签，以使 matplotlib 图形更易读和直观。
在 Matplotlib 库中，记号是用于表示轴上数据点的标记。
-
需要注意的是，在 matplotlib 库中轴上间隔点的任务是自动完成的。
-
matplotlib 中的默认勾选定位器和格式化器也很好，对于大多数用例来说已经足够了。
-
这个任务可以借助两个函数明确完成:
set_xticks()和set_yticks() -
这两个函数都以一个列表对象作为参数。列表中的元素表示位置，将在这些刻度位置上显示的值是使用
set_xticklables()和set_yticklabels()功能设置的。
例如:
ax.set_xticks([2,4,6,8,12])
上面的代码将用记号标记给定位置的数据点。
然后到设置刻度线对应的标签，我们分别使用set_xticklabels()和set_yticklabels()功能。
ax.set_xlabels(['two', 'four', 'six', 'eight', 'twelve'])
现在在上面命令的帮助下，它将在 x 轴上的标记下方显示文本标签。
自定义刻度和刻度标签
现在让我们看一个在 Matplotlib 库中设置刻度和刻度标签的例子:
import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.04)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
y = np.cos(x)
ax.plot(x, y)
# this will label the x axis
ax.set_xlabel('angles')
# setting title of plot
ax.set_title('cos')
# set the tick marks for x axis
ax.set_xticks([0,2,4,6])
# provide name to the x axis tick marks
ax.set_xticklabels(['zero','two','four','six'])
ax.set_yticks([-1,0,1])
plt.show()
以下是输出:
在上面的代码中，你一定注意到了函数set_xlabel()，这个函数用来为 X 轴指定一个标签，在我们的例子中我们显示的是 X 轴上的角度，因此得名角度。
然后，我们明确指定了刻度线，并为刻度线提供了标签。
这是一种完全定制图形的好技术。
Matplotlib 双轴
在本教程中，我们将介绍 matplotlib 中双轴/双轴的概念。
在轴类中，有很多图形元素存在，如轴、勾、线 2D 、文字、多边形等。，用于设置坐标系。
当我们说双轴时，它意味着一个图形可以有双 x 轴或 y 轴。同样，当用不同的单位一起绘制曲线时，双轴也是非常有用的。
在 Matplotlib 中，twinx和twiny功能支持该任务。
Matplotlib twinx()和twiny()功能
在轴模块中，有一个名为Axes.twinx()的函数，用于创建共享 x 轴的双轴。同样，功能twiny()用于在您的图形中创建第二个 x 轴，这意味着双轴共享 y 轴。
使用此函数的语法如下:
# for x axis
Axes.twinx(self)
# for y axis
Axes.twiny(self)
注意: 这个函数不取任何参数，如果你要这样做的话就会产生错误。
该方法返回的值如下:
ax_twin: 表示将返回新创建的 Axes 实例。
现在是时候深入研究一些使用这个函数的例子了，
例 1:
下面是 matplotlib 中双轴绘图的示例:
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.01, 10.0, 0.001)
data1 = np.exp(t)
data2 = np.cos(0.4 * np.pi * t)
fig, ax1 = plt.subplots()
color = 'tab:orange'
ax1.set_xlabel('time (s)')
ax1.set_ylabel('exp', color = color)
ax1.plot(t, data1, color = color)
ax1.tick_params(axis ='y', labelcolor = color)
ax2 = ax1.twinx()
color = 'tab:cyan'
ax2.set_ylabel('cos', color = color)
ax2.plot(t, data2, color = color)
ax2.tick_params(axis ='y', labelcolor = color)
fig.suptitle('matplotlib.axes.Axes.twinx()function Example\n\n', fontweight ="bold")
plt.show()
上述代码的输出如下:
在上面的代码中，我们使用了twinx()函数，得到了共享 x 轴的双轴。
总结:
当您想要在一个图形中显示数据的多个比例或者想要在一个图形中有多个图时，使用twinx()和twiny()功能。
Matplotlib 绘图
Matplotlib 条形图bar()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-bar-plot-bar-function
在本教程中，我们将介绍 Matplotlib 中的条形图以及如何创建它。
条形图或条形图通常是一种图形/图表，主要用于用矩形条表示数据类别，矩形条的长度和高度与其所代表的值成比例。
- 您可以垂直或水平绘制这些条形。
*** 我们使用条形图主要显示离散类别数据之间的比较。
* 在柱状图中，图的一个轴用于表示**被比较的特定类别**，而另一个轴通常表示与那些类别对应的**测量值。****
**## Matplotlib bar()函数
bar()功能用于创建条形图，该条形图以矩形为边界，具体取决于该功能的给定参数。在 Matplotlib API 中，这个函数可以在 MATLAB 风格中使用，以及作为面向对象 API 。
Matplotlib bar()函数语法
将该函数用于轴对象所需的语法如下:
ax.bar(x, height, width, bottom, align)
该功能的参数描述如下:
-
x
该参数用于表示标量值的序列，该序列表示条的x 坐标。
align参数控制x 是条中心(默认)还是左边缘**** -
高度
该参数是标量或标量值序列，代表构成 y 轴值的条的高度。
-
宽度
该参数为标量或类数组，可选。该参数的默认值**为 0.8**
*** 底部
这也是一个**标量或者类似数组的**，并且是**可选的**。默认值为**无**。
* **对齐**
该参数取值为{' **中心**'、'**边缘** '}、**可选**，该参数默认值为'**中心****
**bar()函数返回一个包含所有条的 Matplotlib 容器对象。
现在是时候深入研究这个概念的一些例子了。
简单条形图:
下面给出了一个简单的条形图示例，它代表了研究所提供的书籍数量:
import numpy as np
import matplotlib.pyplot as plt
data = {'Computer Networks':20, 'DBMS':15, 'Java':30,'C':35}
courses = list(data.keys())
values = list(data.values())
fig = plt.figure(figsize = (10, 5))
plt.bar(courses, values, color ='magenta',width = 0.4)
plt.xlabel("Books offered")
plt.ylabel("No. of books provided")
plt.title("Books provided by the institute")
plt.show()
代码解释:
这里plt.bar(courses, values, color='magenta')基本上是指定要绘制的条形图，以“提供的书籍”(学院提供)列为 X 轴，以“书籍数量”为 Y 轴。
color属性基本上用于设置条的颜色(洋红色)。
语句plt.xlabel("Books offered")和plt.ylabel("books provided by the institute")用于标注对应的轴。plt.title()功能用于制作图形的标题。plt.show()功能用于显示图形作为之前命令的输出。
上述代码显示的输出如下:
自定义条形图:堆叠图
堆叠条形图用于表示不同组的数据相互叠加。条形的高度主要取决于各组结果组合的结果高度。高度从底部到数值，而不是从零到数值
现在让我们创建一个堆叠图，代码如下:
import numpy as np
import matplotlib.pyplot as plt
N = 5
group_a = (25, 37, 39, 23, 56)
group_b = (29, 36, 38, 25, 22)
ind = np.arange(N) # the x locations for the groups
width = 0.39
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(ind, group_a, width, color='c')
ax.bar(ind, group_b, width,bottom=group_a, color='b')
ax.set_ylabel('Scores')
ax.set_title('Scores by two groups')
ax.set_xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
ax.set_yticks(np.arange(0, 81, 10))
ax.legend(labels=['Group A', 'Group B'])
plt.show()
如果您将在自己的系统中运行此代码，则输出如下:
时间就是活生生的例子！
让我们看一下实时示例:
Matplotlib 直方图——hist()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-histrograms-hist-function
在本教程中，我们将介绍如何使用 matplotlib 库在 Python 中创建直方图。
什么是直方图？
在深入研究如何在 matplotlib 中创建直方图之前，让我们首先了解什么是直方图？
所以直方图是数值数据的分布的精确表示。
-
所以直方图是条形图的一种，是由卡尔·皮尔逊发明的
-
直方图主要用于表示某些组中提供的数据。
-
直方图通常由数据仓(变量的连续和非重叠间隔)组成，其中每个仓由最小值和最大值组成。
-
为了估计连续变量的概率分布，使用直方图。
创建直方图
创建直方图时，应记住以下几个步骤:
-
第一步是创建范围的箱。
-
第二步是将数值的整个范围分配到一个对应的区间序列中。
-
第三步是统计每个区间的数值。
matplotlib.pyplot.hist()功能
该函数用于创建直方图。
让我们讨论直方图的参数，详细描述如下:
-
x
此参数指示数组或数组序列。
-
箱柜
此参数指示一个整数或序列或任何字符串。
-
密度
这是一个由布尔值组成的可选参数。
-
范围
这是一个可选参数，用于指示箱的上限和下限，也是一个可选参数。
-
标签
这是一个可选参数，用于在对数刻度上设置直方图轴。
-
颜色
这是用于设置颜色的可选参数。
-
累计
如果该选项的值设置为真，则计算直方图，其中每个箱给出该箱中的计数加上较小值的所有箱。
-
组态型
这是一个可选参数，用于指定直方图的类型[即条形、条形堆积、台阶、台阶填充 ]。该参数的默认值为“栏”。
-
对齐
这是一个可选参数，用于控制数值为[ 左、右、中 ]的直方图的绘制。
让我们看几个例子来理解直方图的概念。
简单直方图示例:
下面我们有一个创建直方图的简单示例:
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
x = [21,22,23,4,5,6,77,8,9,10,31,32,33,34,35,36,37,18,49,50,100]
num_bins = 5
n, bins, patches = plt.hist(x, num_bins, facecolor='orange', alpha=0.8)
plt.show()
直方图形式的输出如下:
一个图形示例中的两个直方图:
让我们一起试试两个直方图的两个图。在下面给出的代码片段中，我们试图将两个直方图绘制在一起:
2D 直方图示例:
让我们尝试创建一个二维直方图。2D 直方图的代码片段如下:
import numpy as np
import matplotlib.pyplot as plt
mean = [0, 0]
cov = [[1, 1], [1, 2]]
x, y = np.random.multivariate_normal(mean, cov, 10000).T # x and y are array that are drawn from a multivariate Gaussian distribution
plt.hist2d(x, y, bins=30, cmap='CMRmap') #plt.hist2d is used to draw histogram for 2D
cb = plt.colorbar()
cb.set_label('counts in bin')
plt.show()
输出直方图如下:
Matplotlib 饼图——pie()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-pie-chart-pie-function
在本教程中，我们将介绍什么是饼图？以及如何使用 python matplotlib 库创建饼图来表示您的数据。
什么是饼图？
饼图基本上是一种特殊的图表，用于在饼图切片的帮助下显示数据的相对大小。因此，它是一个完整的圆来表示 100%的空间，并创建饼图切片来表示数据集。
-
用于显示的是一个圆形统计图，只有一系列数据。
-
饼图的完整区域等于给定数据的总百分比。
-
在饼图中，饼图切片的区域用于表示数据部分的百分比。
-
馅饼的切片通常被称为楔形。
-
楔形的面积主要表示该部分相对于整个数据的百分比，可以通过楔形的弧长来计算。
饼图的用途:
下面给出了几个用途:
-
业务演示(如销售、调查结果和运营)
-
提供快速摘要
Matplotlib pie()函数
matplotlib 的 pyplot 模块中的pie()函数用于创建一个饼图，表示数组中的数据。
如果图形和轴是正方形的，或者轴的纵横比相等，则可以创建最佳的饼图。
pie()函数所需的语法如下所示:
matplotlib.pyplot.pie(data, explode, labels, colors, autopct, shadow)
pie()功能参数:
让我们讨论一下这个函数的参数:
1。数据
该参数用于表示由要绘制的数据值组成的数组，每个切片的分数面积由数据/和(数据)表示。如果和(数据)< 1** ，那么数据值直接返回分数区域，这样生成的饼图将有一个大小= 1-和(数据)的空楔形。**
2。标签
该参数表示字符串序列的列表，用于设置每个楔形的标签
3 .尸检
该参数为字符串形式，用于用数值标记楔形体
4。颜色
该参数用于为楔形体提供颜色。
5。阴影
这个参数是用来创建楔形的阴影。
现在，是时候重温一下这个概念，创建一些饼图了。让我们从一些例子开始。
简单饼图示例:
在下面给出的例子中，我们将在 matplotlib 中创建一个简单的饼图:
import matplotlib.pyplot as plt
import numpy as np
subjects = ['English', 'Hindi', 'Science', 'Arts', 'Music', 'Maths']
data = [23, 17, 35, 29, 12, 41]
fig = plt.figure(figsize =(10, 7))
plt.pie(data, labels = subjects)
plt.show()
上述代码片段的输出如下所示:
现在是时候创建一些定制的饼图了。以下是自定义图的一些方面:
-
startangle参数用于在饼图的 x 轴上按逆时针方向将绘图旋转指定的度数。 -
shadow参数接受一个布尔值，如果是真，那么的阴影会出现在馅饼的边缘下方。 -
自定义饼图的楔形区使用
wedgeprop以 Python 字典为参数，名称值对用于表示楔形区属性，如线宽、边缘颜色等。 -
通过设置
frame=True坐标轴，在饼图周围绘制框架。 -
autopct参数主要控制如何在上显示百分比。
自定义饼图示例:
让我们在 matplotlib 中创建一个自定义饼图:
import matplotlib.pyplot as plt
slices = [7,2,2,13]
activities = ['sleeping','cooking','working','singing']
cols = ['c','m','r','b']
plt.pie(slices,
labels=activities,
colors=cols,
startangle=90,
shadow= True,
explode=(0,0.1,0,0),
autopct='%1.1f%%')
plt.title('Customized Graph\n')
plt.show()
其输出如下所示:
嵌套饼图示例:
现在让我们创建一个嵌套饼图(也称为圆环图)，下面给出了它的实例:
Matplotlib 散点图——scatter()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-scatter-plot-scatter-function
在本教程中，我们将介绍什么是散点图？以及如何使用 Matplotlib 库创建散点图来显示数据。
散点图是一种用于将数据显示为点的集合的图。
-
这个图主要是用来观察两个变量之间的关系。
-
散点图****使用点来表示两个变量之间的关系。
-
这些图主要用于在横轴和纵轴上绘制数据点，以显示一个变量受另一个的影响有多大。
-
在 2 维中用于比较两个变量，而在 3 维中用于进行三个变量的比较。
Matplotlib scatter()函数
Python matplotlib 库中 pyplot 模块中的方法scatter()主要用于绘制散点图。
使用该方法的语法如下所示:
matplotlib.pyplot.scatter(x_axis_data, y_axis_data, s, c, marker, cmap, vmin, vmax,alpha,linewidths, edgecolors)
功能参数:
让我们讨论一下scatter()方法的参数:
-
x_axis_data
该参数表示一个包含 x 轴数据的数组。
-
y_axis_data
该参数表示一个包含 y 轴数据的数组。
-
sT2】
该参数表示标记大小(可以是标量或大小等于 x 或 y 的数组)。为可选参数，默认值为
None。 -
c
该参数表示序列的颜色，是可选的参数，默认值等于
None。 -
标记
该参数用于指示标记样式。该参数的默认值为
None，也是可选的参数。 -
cmap
该可选参数表示 cmap 名称，默认值等于
None。 -
线宽
该参数表示标记边框的宽度，默认值为
None。 -
边缘颜色
该参数用于指示标记边框颜色，并且其默认值为
None。 -
alpha
该选项指示混合值，介于 0(透明)和 1(不透明)之间。
让我们深入一些例子，创建一些散点图。
简单散点图示例:
下面我们有一个代码片段来创建一个简单的散点图。让我们看一下代码片段:
import matplotlib.pyplot as plt
x =[5, 7, 8, 7, 2, 17, 2, 9, 4, 11, 12, 9, 6]
y =[99, 86, 87, 88, 100, 86, 103, 87, 94, 78, 77, 85, 86]
plt.scatter(x, y, c ="red")
plt.show()
当您在机器上运行上述代码时，您将看到如下所示的输出:
大数据集散点图:
让我们用不同的随机数创建另一个散点图，代码片段如下:
import numpy as np
import matplotlib.pyplot as plt
# Creating the data
N = 1000
x = np.random.rand(N)
y = np.random.rand(N)
colors = (0,0,0)
area = np.pi*3
plt.scatter(x, y, s=area, c=colors, alpha=0.5)
plt.title('Scatter plot studytonight.com')
plt.xlabel('x')
plt.ylabel('y')
plt.show()
其输出如下:
这里需要注意的是，数据可以分为几组。借助下面给出的代码片段，让我们了解如何使用该组创建散点图:
自定义散点图示例:
现在，我们将介绍 matplotlib 中高度和权重组的散点图代码片段:
Matplotlib 等高线图——contour()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-contour-plot-contour-function
在本教程中，我们将介绍什么是等高线图以及如何在 Matplotlib 中创建等高线图。
为了在二维空间中创建三维图的可视化，我们使用了 Matplotlib 中的等高线图。等高线图也称为水平图。
-
假设存在两个变量 X 和 Y ，并且您希望绘制它们，那么两个变量的响应将是 Z ，并且由于的轮廓也被称为 Z 切片或等响应，所以它将被绘制为 X-Y 平面上的切片。
-
如果想看 Z 的值是如何随着两个输入即 X 和 Y 的变化而变化的，我们应该用等高线图，就像这样 Z = f(X，Y) 。
-
两个变量的函数的一条等高线或等值线基本上是沿着的一条曲线，其中函数具有一个恒定值。
-
Matplotlib 中有两个功能，分别是
contour()(这是用来画等高线)和contourf()(这是用来画填充等高线)。
等高线图的用途:
等高线图的一些用途如下:
-
到可视化密度。
-
可视化气象部门。
-
想象山脉的高度。
Matplotlib contour()函数
当 Z = f(X，Y) 时matplotlib.pyplot.contour()功能很有用，这里 Z 随着输入 X 和 Y 的变化而变化。
matplotlib 中还有一个contourf()功能，它允许我们绘制填充轮廓。
该方法返回一个四边形控制。所需的语法如下所示:
matplotlib.pyplot.contour([X, Y, ] Z, [levels], **kwargs)
让我们讨论一下这个函数的参数:
1。x，Y
该参数表示 2-D NumPy 阵列，其形状与 Z 相同或类似于 1-D 阵列，其方式为len(X)==M和len(Y)==N(其中 M 是 Z 的行，N 是 Z 的列)
2。Z
此参数指示绘制轮廓的高度值。形状为(M，N)。
3。等级
该参数用于确定等高线的数量和位置。
让我们来介绍这个函数的一些例子。
简单等高线示例:
在本例中，我们将借助contour()函数绘制等高线:
我们再举一个等高线图的例子。
填充等高线图示例:
现在让我们借助contourf()函数绘制一个填充轮廓:
Matplotlib 抖动图-quiver()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-quiver-plot-quiver-function
在本教程中，我们将使用 Matplotlib 库来讲述抖动图。
要绘制箭头的 2D 场，我们使用 matplotlib 库中的抖动图。
- 该图主要有助于将速度矢量显示为箭头，该箭头在点
(x,y)处具有分量(u,v)。 - 抖动图对于电气工程师到可视化电势和对于机械工程师到显示应力梯度是有用的。
创建 Matplotlib 抖动图
为了创建抖动图，使用了ax.quiver()功能。
使用该功能所需的语法如下:
ax.quiver(x_pos, y_pos, x_dir, y_dir, color)
下面是这个函数的参数，你可以在上面的语法中看到:
-
x_pos 和 y_pos
该功能的这两个参数用于指示箭头的起始位置。
-
x_dir 和 y_dir
该功能的这两个参数用于指示箭头的方向。
-
颜色
该参数用于指定抖动图的颜色。
现在让我们深入探讨一些与此相关的例子。
简单抖动图示例:
在下面给出的例子中，我们将介绍如何用一个单箭头绘制抖动图:
import numpy as np
import matplotlib.pyplot as plt
x_pos = 0
y_pos = 0
x_direct = 1
y_direct = 1
fig, ax = plt.subplots(figsize = (10, 7))
ax.quiver(x_pos, y_pos, x_direct, y_direct)
ax.set_title('Quiver plot with a single arrow')
plt.show()
以下是输出:
双箭头抖动图示例:
在下面给出的例子中，我们将介绍如何用两个箭头绘制抖动图:
import numpy as np
import matplotlib.pyplot as plt
x_pos = [0, 0]
y_pos = [0, 0]
x_direct = [1, 0]
y_direct = [1, -1]
fig, ax = plt.subplots(figsize = (12, 7))
ax.quiver(x_pos, y_pos, x_direct, y_direct,scale = 8)
ax.axis([-1.5, 1.5, -1.5, 1.5])
plt.show()
以下是输出:
是时候活出榜样了！
现在我们将介绍一个使用网格绘制抖动图的实时示例:
在上面的实时示例中，您甚至可以更改代码并尝试运行其他代码，以查看不同的抖动图输出。
Matplotlib 盒子图-boxplot()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-box-plot-boxplot-function
在本教程中，我们将介绍盒子图以及使用boxplot()功能在 matplotlib 库中创建盒子图。
matplotlib 中的箱折线图主要用于显示一组数据的摘要，这些数据具有最小值、第一个四分位数、中值、第三个四分位数和最大值等属性。
-
方框图也被称为触须图。
-
在方框图中，方框是从第一个四分位数到第三个四分位数创建的，在中间位置也有一条垂直线穿过方框。
-
在箱折线图中， x 轴表示要绘制的数据，而 y 轴表示频率分布。
创建方框图
matplotlib 库中的盒子图通常是借助boxplot()功能创建的。
-
在箱折线图中
numpy.random.normal()用于创建一些随机数据，它以平均值、标准偏差和所需的数值数作为参数。 -
为
ax.boxplot()方法提供的数据值可以是 Numpy 数组或 Python 列表，也可以是数组元组
boxplot()函数所需的语法如下:
matplotlib.pyplot.boxplot(data, notch, vert, patch_artist, widths)
以下是该函数的参数:
-
数据
该参数表示绘制所需的阵列或阵列序列。
-
槽口
这是一个可选的参数，接受布尔值。将其
None设为默认值。 -
绿色
这是一个可选参数，接受布尔值，即水平图为假，垂直图为真。
-
patch_artist
这是一个可选参数，其布尔值以
None作为其默认值 -
宽度
这是一个可选参数，接受一个数组，用于设置盒子的宽度。默认值为
None。
现在我们将深入研究一些创建 Box 图的例子。
创建方框图示例:
在 Matplotlib 库中创建简单方框图的代码如下:
import matplotlib.pyplot as plt
value1 = [84,77,20,40,67,62,75,78,71,32,98,89,78,67,72,82,87,66,56,52]
value2=[62,5,91,25,35,32,96,99,3,90,95,34,27,55,100,15,71,11,37,21]
value3=[23,89,12,78,72,89,25,69,68,86,19,48,15,16,16,75,65,31,25,52]
value4=[59,73,73,16,81,61,88,98,10,87,29,72,16,23,72,88,78,99,75,30]
box_plot_data=[value1,value2,value3,value4]
plt.boxplot(box_plot_data)
plt.show()
以下是输出:
创建带有填充和标签的方框图:
在下面给出的代码片段中，我们将为箱折线图提供一个标签，并将填充箱折线图。让我们看看示例的代码:
import matplotlib.pyplot as plt
value1 = [82,76,24,40,67,62,75,78,71,32,98,89,78,67,72,82,87,66,56,52]
value2=[62,5,91,25,36,32,96,95,3,90,95,32,27,55,100,15,71,11,37,21]
value3=[23,89,12,78,72,89,25,69,68,86,19,49,15,16,16,75,65,31,25,52]
value4=[59,73,70,16,81,61,88,98,10,87,29,72,16,23,72,88,78,99,75,30]
box_plot_data=[value1,value2,value3,value4]
plt.boxplot(box_plot_data,patch_artist=True,labels=['subject1','subject2','subject3','subject4'])
plt.show()
以下是输出:
创建带凹口的方框图:
在这个例子中，我们将绘制一个有凹口的方框图。
import matplotlib.pyplot as plt
value1 = [84,76,24,46,67,62,78,78,71,38,98,89,78,69,72,82,87,68,56,59]
value2=[62,5,91,25,39,32,96,99,3,98,95,32,27,55,100,15,71,11,37,29]
value3=[23,89,12,78,72,89,25,69,68,86,19,49,15,16,16,75,65,31,25,52]
value4=[59,73,70,16,81,61,88,98,10,87,29,72,16,23,72,88,78,99,75,30]
box_plot_data=[value1,value2,value3,value4]
plt.boxplot(box_plot_data,notch='True',patch_artist=True,labels=['subject1','subject2','subject3','subject4'])
plt.show()
以下是输出:
时间就是活生生的例子！
在这个实时示例中，我们将绘制一个具有不同颜色的水平方框图。
代码说明
-
在上例中，
boxplot()函数接受参数 vert=0 ，因为我们想要绘制水平方框图。 -
上例中的
colors数组将占用四种不同的颜色，并借助patch.set_facecolor()功能传递给箱折线图的四个不同的盒子。
Matplotlib 提琴图——violinplot()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-violin-plot-violinplot-function
在本教程中，我们将介绍提琴图以及如何使用 Matplotlib 库中的violinplot()功能创建提琴图。
提琴图用于表示不同数值下数据的概率密度，与 马特洛特利布盒图 十分相似。
-
这些图主要是箱折线图和直方图的组合。
-
提琴图通常描绘数据的分布、中位数、四分位数范围。
-
其中，四分位数和中位数是统计信息，由箱折线图提供，而分布由直方图提供。
-
提琴图也用于表示不同“类别”之间可变分布的比较；就像盒子图。
-
提琴图的信息量更大，因为它们显示了数据的完整分布。
下图显示了盒式情节和提琴情节的常见组成部分:
提琴情节的创作
violinplot()方法用于提琴图的创作。
该方法所需的语法如下:
violinplot(dataset, positions, vert, widths, showmeans, showextrema,showmedians,quantiles,points=1, bw_method, *, data)
因素
该功能的参数描述如下:
-
数据集
This parameter denotes the array or sequence of vectors. It is the input data.
-
位置
This parameter is used to set the positions of the violins. In this, the ticks and limits are set automatically in order to match the positions. It is an array-like structured data with the default as = [1, 2, …, n].
-
绿色
This parameter contains the boolean value. If the value of this parameter is set to true then it will create a vertical plot, otherwise, it will create a horizontal plot.
-
显示方式
This parameter contains a
booleanvalue with false as its default value. If the value of this parameter is True, then it will toggle the rendering of the means. -
表现极端
This parameter contains the boolean values with false as its default value. If the value of this parameter is True, then it will toggle the rendering of the extrema.
-
显示中间值
This parameter contains the boolean values with false as its default value.If the value of this parameter is True, then it will toggle the rendering of the medians.
-
量词
This is an array-like data structure having None as its default value.If value of this parameter is not None then,it set a list of floats in interval [0, 1] for each violin,which then stands for the quantiles that will be rendered for that violin.
-
分
It is scalar in nature and is used to define the number of points to evaluate each of the Gaussian kernel density estimations.
-
bw_method
This method is used to calculate the estimator bandwidth, for which there are many different ways of calculation. The default rule used is Scott's Rule, but you can choose ‘silverman’, a scalar constant, or a callable.
现在是时候深入一些例子来澄清概念了:
提琴图基本示例:
下面我们有一个简单的例子，我们将为不同的数据集合创建提琴图。
import matplotlib.pyplot as plt
import numpy as np
np.random.seed(10)
collectn_1 = np.random.normal(120, 10, 200)
collectn_2 = np.random.normal(150, 30, 200)
collectn_3 = np.random.normal(50, 20, 200)
collectn_4 = np.random.normal(100, 25, 200)
data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
bp = ax.violinplot(data_to_plot)
plt.show()
输出如下:
时间就是活生生的例子！
让我们来看看提琴情节的真实例子:
总结:
在本教程中，我们通过几个例子介绍了如何创建一个提琴图，以及violinplot()方法的各种参数。
Matplotlib 3D
Matplotlib 三维绘图——折线和散点图
原文：https://www.studytonight.com/matplotlib/matplotlib-3d-plotting-line-and-scatter-plot
在本教程中，我们将介绍 Matplotlib 中的三维绘图。
需要注意的是，Matplotlib 最初设计时只考虑了二维绘图。但是后来，一些三维绘图工具被建立在 matplotlib 的二维显示之上，这为 Matplotlib 中的三维数据可视化提供了一套工具。
此外，2D 图用于显示单对轴之间的关系，即 x 和 y ，而 3D 图则允许我们探索 3 对轴之间的关系，即 x-y、x-z 和 y-z
三维绘图
在 Matplotlib 中的三维绘图可以通过启用实用工具包来完成。可以通过导入 mplot3d库来启用实用工具工具包，该库是通过 pip 与您的标准 Matplotlib 安装一起提供的。
在导入该子模块后，可以通过将关键字projection="3d"传递到 Matplotlib 中的任意常规轴创建功能来创建 3D 图。
让我们介绍一些在 matplotlib 中使用这个子模块进行三维绘图的例子。
三维折线图
以下是绘制三维折线图的语法:
Axes3D.plot(xs, ys, *args, **kwargs)
通过下面给出的代码片段，我们将介绍 Matplotlib 中的三维折线图:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(30 * z)
y = z * np.cos(30 * z)
ax.plot3D(x, y, z, 'maroon')
ax.set_title('3D line plot')
plt.show()
以下是它的输出:
三维散点图
以下是三维散点图的语法:
Axes3D.scatter(xs, ys, zs=0, zdir='z', s=20, c=None, depthshade=True, *args, **kwargs)
争论
| 争吵 | 描述 |
|---|---|
| xs 、 ys | 这两个参数指示数据点的位置。 |
| zs | 它可以是长度与 xs 和 ys 相同的数组，也可以是将所有点置于同一平面的单个值。该参数的默认值为 0 。 |
| 【T0 是】T1 | 此参数用于指示在绘制 2D 集时使用哪个方向作为 z(“x”、“y”或“z”)。 |
| s | 此参数用于以磅为单位指示大小。它可以是标量，也可以是长度与 x 和 y 相同的数组。 |
| c | 此参数用于指示颜色。 |
| 深度阴影 | 此参数用于告诉是否要为散点图着色，以给出深度的外观。该参数的默认值为真。 |
通过下面给出的代码片段，我们将介绍 Matplotlib 中的三维散点图:
fig = plt.figure()
ax = plt.axes(projection="3d")
z_line = np.linspace(0, 15, 500)
x_line = np.cos(z_line)
y_line = np.sin(z_line)
ax.plot3D(x_line, y_line, z_line, 'blue')
z_points = 15 * np.random.random(500)
x_points = np.cos(z_points) + 0.1 * np.random.randn(500)
y_points = np.sin(z_points) + 0.1 * np.random.randn(500)
ax.scatter3D(x_points, y_points, z_points, c=z_points, cmap='hsv');
plt.show()
输出结果是:
总结:
在本教程中，我们学习了 Matplotlib 中三维绘图的基础知识，以及如何通过代码示例进行线和散点图。
Matplotlib 3D 等高线图——contour3d()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-3d-contour-plot-contour3d-function
在本教程中，我们将使用 Matplotlib 库介绍三维中的等高线图。
要绘制或启用 3d 绘图，您只需导入 mplot3d 工具包。
有一个名为ax.contour3D()的函数，用于创建三维等高线图。
该功能要求所有输入数据都是二维规则网格的形式，其 Z 数据在每个点进行评估。
三维等高线图示例
在下面给出的例子中，我们将为正弦函数创建一个三维等高线图。代码片段如下所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
import math
x = [i for i in range(0, 200, 100)]
y = [i for i in range(0, 200, 100)]
X, Y = np.meshgrid(x, y)
Z = []
for i in x:
t = []
for j in y:
t.append(math.sin(math.sqrt(i*2+j*2)))
Z.append(t)
fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap=cm.cool)
ax.set_xlabel('a')
ax.set_ylabel('b')
ax.set_zlabel('c')
ax.set_title('3D contour Plot for sine')
plt.show()
上述代码中使用的函数解释如下:
-
网格网格
这是 NumPy 库的一个功能，用于从两个给定的一维数组中创建一个矩形网格，表示笛卡尔或矩阵索引。
-
plt.axes()
该功能用于创建轴的对象。
-
ax . 3d 轮廓
该功能用于创建轮廓
-
ax . set _ xlabel
该功能用于设置 x 轴的标签
-
ax.set_title()
该功能用于为地块提供标题
以下是上述代码的输出:
总结:
在上一个教程中，我们介绍了三维折线图和散点图，并介绍了 matplotlib 中的三维图。在本教程中，我们介绍了 matplotlib 中的三维等高线图。
Matplotlib 三维线框图——plot_wireframe()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-3d-wireframe-plot-plot_wireframe-function
在本教程中，我们将介绍 matplotlib 库中的三维线框图。我们已经在 Matplotlib 库中介绍了三维绘图基础知识，以及三维折线图、散点图和三维等高线图。
对于使用三维线框的数据可视化，我们需要来自matplotlib、mpl_toolkits和numpy库的一些模块。
线框图基本上是取一个值的网格，并将其投影到指定的三维表面上，这有助于使生成的三维形式非常容易可视化。
要创建三维线框图形，将使用plot_wireframe()功能。
现在是时候介绍一些三维线框图的例子了。
三维线框图基本示例:
下面我们有一个例子，我们将创建一个三维线框图:
from mpl_toolkits.mplot3d import axes3d
from matplotlib import pyplot
fig = pyplot.figure()
wf = fig.add_subplot(111, projection='3d')
x, y, z = axes3d.get_test_data(0.07)
wf.plot_wireframe(x,y,z, rstride=2, cstride=2, color='maroon')
wf.set_title('3D wireframe plot')
pyplot.show()
下面是上面代码的输出:
三维线框图示例 2:
下面是另一个例子，其代码片段如下:
from mpl_toolkits import mplot3d
import numpy
a = numpy.linspace(-5, 5, 25)
b = numpy.linspace(-5, 5, 25)
x, y = numpy.meshgrid(a, b)
z = numpy.cos(numpy.sqrt(x**2 + y**2))
fig = pyplot.figure()
wf = pyplot.axes(projection ='3d')
wf.plot_wireframe(x, y, z, color ='blue')
wf.set_title('Example 2')
pyplot.show()
下面是上面代码的输出:
Matplotlib 三维曲面图——plot_surface()函数
原文：https://www.studytonight.com/matplotlib/matplotlib-3d-surface-plot-plot_surface-function
在本教程中，我们将介绍如何在 matplotlib 库中创建三维曲面图。
在 Matplotlib 的 mpl_toolkits.mplot3d 工具包中有axes3d提供必要的功能，这些功能在创建 3D 曲面图时非常有用。
三维数据集的表示主要称为表面图。
-
有一点需要注意的是，表面图提供了 X 和 Z 两个自变量和指定的因变量 Y 之间的关系，而不仅仅是显示单个数据点。
-
曲面图是等高线图的伴生图，与线框图相似，但也有区别，它是每个线框基本上是一个填充多边形。
-
借助于此，曲面的拓扑可以非常容易地可视化。
三维曲面图的创建
为了创建三维表面图，在 matplotlib 中使用ax.plot_surface()函数。
该功能所需的语法如下所示:
ax.plot_surface(X, Y, Z)
在上面的语法中，X 和 Y 主要表示点 X 和 Y 的 2D 数组，而 Z 用于表示高度的 2D 数组。
plot_surface()属性
该功能的一些属性如下:
1。遮阳
该属性用于给面部颜色着色。
2 .面色〔t1〕
此属性用于指示单个曲面的面颜色
3。vmax
该属性指示地图的最大值。
4 .虚拟机
该属性指示地图的最小值。
5。定额
该属性作为一个实例来规范化颜色映射的值
6。颜色
该属性指示表面的颜色
7. cmap
该属性指示表面的颜色映射
8 .rcunt〔t1〕
该属性用于指示要使用的行数该属性的默认值为 50
9 .账户
该属性用于指示要使用的列数该属性的默认值为 50
10。rstride
该属性用于指示行步幅的数组(即步长)
11 时。cstride
此属性用于指示列跨度的数组(即步长)
三维表面绘图基本示例
下面我们有一个代码，我们将使用上述功能创建一个三维表面图:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-4, 4, 33), np.ones(33))
y = x.copy().T
z = (np.sin(x **2) + np.cos(y **2) )
fig = plt.figure(figsize =(14, 9))
ax = plt.axes(projection ='3d')
ax.plot_surface(x, y, z)
plt.show()
上述代码的输出如下:
梯度表面图
该图结合了三维表面图和 2D 等高线图。在“渐变”曲面图中，三维曲面的颜色与 2D 等高线图相同。表面高的部分包含不同的颜色，而不是表面低的部分。
所需的语法是:
ax.plot_surface(X, Y, Z, cmap, linewidth, antialiased)
其中cmap用于设置表面的颜色。
渐变表面绘图示例
现在是时候覆盖渐变表面图了。其代码片段如下所示:
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-3, 3, 32), np.ones(32))
y = x.copy().T
z = (np.sin(x **2) + np.cos(y **2) )
fig = plt.figure(figsize =(14, 9))
ax = plt.axes(projection ='3d')
my_cmap = plt.get_cmap('cool')
surf = ax.plot_surface(x, y, z, cmap = my_cmap, edgecolor ='none')
fig.colorbar(surf, ax = ax, shrink = 0.7, aspect = 7)
ax.set_title('Surface plot')
plt.show()
上述代码的输出如下:
杂项
在 Matplotlib 中使用文本
原文：https://www.studytonight.com/matplotlib/working-with-text-in-matplotlib
在本教程中，我们将介绍如何使用 Matplotlib 中的文本。
Matplotlib 中有广泛的文本支持，包括对数学表达式的支持、对栅格的 Truetype 支持、矢量输出，还有任意旋转的换行符分隔文本， Unicode 支持。
使用文本
Matplotlib 库有自己的matplotlib.font_manager，用于实现跨平台、符合 W3C 标准的字体查找算法。
-
在这种情况下，用户对文本属性有很大的控制，如字体大小、字体粗细、文本位置和颜色等。
-
Matplotlib 库实现了大量的 TeX 数学符号和命令，为图形中任何地方的数学表达式提供支持。
下面给出了用于在 Pyplot 界面以及面向对象界面中创建文本的命令列表:
| pyplot 界面 | 面向对象界面 | 描述 |
| 文本 | 文本 | 该命令用于在轴的任意位置添加文本。 |
| 给…作注解 | 给…作注解 | 该命令用于在任意位置添加带有可选箭头的注释。 |
| xlabel(电缆) | set_xlabel | 该命令用于向轴的 x 轴添加标签。 |
| 伊兰贝尔 | set _ ylabel-设定值 | 此命令用于向轴的 y 轴添加标签。 |
| 标题 | 设置标题 | 此命令用于向轴添加标题。 |
| fittext | 文本 | 该命令用于在图形的任意位置添加文本。 |
| 小标题 | 小标题 | 该命令用于向图形添加标题。 |
所有这些函数都创建并返回一个Text实例，该实例可以配置各种字体和其他相关属性。
比如时间！！
现在我们来看一个例子，在这个例子中，我们将以不同的风格向图中添加不同的文本信息:
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.text(3, 8, 'This is boxed italics text in data coords', style='italic',
bbox = {'facecolor': 'orange'})
ax.text(2, 6, r'an equation: $E = mc^2$', fontsize = 16)
ax.text(4, 0.05, 'This is colored text in axes coords',
verticalalignment = 'bottom', color = 'maroon', fontsize = 15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy = (2, 1), xytext = (3, 4),
arrowprops = dict(facecolor = 'maroon', shrink = 0.05))
ax.axis([0, 10, 0, 10])
plt.show()
以下是上述代码的输出:
Matplotlib 中的数学表达式
原文：https://www.studytonight.com/matplotlib/mathematical-expressions-in-matplotlib
在本教程中，我们将介绍如何在绘制任何数据集时用 matplotlib 编写数学表达式。
写数学表达式
子集 TeX 标记可以用于任何 matplotlib 文本字符串，只需将其放入一对美元符号($) 中即可。
-
为了制作下标和上标，分别使用
_和^符号。 -
要创建分数、二项式和堆叠数，可以分别使用
\frac{}{}、\binom{}{}和\genfrac{}{}{}{}{}{}命令。 -
此外，可以通过
\sqrt[]{}命令产生部首。 -
对于数学符号，默认字体是斜体。
让我们举个例子来更清楚地理解。
使用数学表达式:
在下面给出的例子中，我们将表示下标和上标:
r'$\alpha_i> \beta_i$'
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.cos(1*np.pi*t)
plt.plot(t,s)
plt.title(r'$\alpha_i> \beta_i$', fontsize=20)
plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{cos}(2 \omega t)$', fontsize = 20)
plt.xlabel('The time (s)')
plt.ylabel('volts (mV)')
plt.show()
以下是上述代码的输出:
在 Matplotlib 中使用图像
原文：https://www.studytonight.com/matplotlib/working-with-images-in-matplotlib
在本教程中，我们将介绍如何在 Matplotlib 库中处理图像。
在 Matploltlib 库中，image模块用于在图和图形中添加图像。
-
matplotlib 只支持 PNG 图像。
-
图像模块
imread(有两种有用且重要的方法，分别用于读取图像 ) 和imshow(用于显示图像)。
现在我们将介绍一些展示如何使用图像的示例:
例 1:
在代码片段中，我们将使用imread()读取图像，然后使用imshow()显示图像:
import matplotlib.pyplot as plt
import matplotlib.image as img
testImage = img.imread('C:\\Users\\StudyTonight\\Desktop\\logoo.png')
plt.imshow(testImage)
以下是输出:
例 2:
在下面给出的代码示例中，我们使用imread()读取图像，然后以数组的形式表示它:
import matplotlib.pyplot as plt
import matplotlib.image as img
testImage = img.imread('C:\\Users\\StudyTonight\\Desktop\\logoo.png')
print(testImage)
[[[1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】】
【【1】。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】】
【【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】】
...
【【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】】
【【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
【【1】。1.1.1.】
【1。1.1.1.】
【1。1.1.1.】
...
【1。1.1.1.】
【1。1.1.1.】
【1。1.1.1.]]]
例 3:
在下面给出的示例中，我们将修改图像的所有参数:
import matplotlib.pyplot as plt
import matplotlib.image as img
testImage = img.imread('C:\\Users\\StudyTonight\\Desktop\\logoo.png')
print(testImage.shape)
modifiedImage = testImage[50:200, 100:200, 1]
plt.imshow(modifiedImage)
在上面的代码中，图像的高度是 150 像素(从第 50 个像素开始显示)，宽度是 100 像素(从第 100 个像素开始显示)，模式值是 1。
以下是上述代码的输出:
结论:
至此，我们的 Matplotlib 教程到此结束。我们将继续向本教程添加更多的教程页面和指南，以及一些 Matplotlib 图和图形的应用。
Tkinter
Tkinter 基础
Tkinter 模块介绍
原文：https://www.studytonight.com/tkinter/introduction-to-python-tkinter-module
在本教程中，我们将介绍 Tkinter、它的先决条件、GUI 编程的不同方法、如何安装 Tkinter 以及它的工作原理。
Tkinter 是一个 python 中的标准库，用于为桌面应用创建图形用户界面(GUI) 。借助 Tkinter 开发桌面应用并不是一件难事。
我们将使用的主图形用户界面工具包是Tk，这是 Python 的默认图形用户界面库。我们将从其名为Tkit(Tk 接口的缩写)的 Python 接口访问Tk。
Tkinter 的先决条件
在学习 Tkinter 之前，你要有Python 的基础知识。您可以使用我们的完整 Python 教程学习 Python。
Python 中的图形用户界面编程
用 Python 开发基于图形用户界面的程序有很多方法。下面给出了这些不同的方法:
-
tkinter:
在 Python 中， Tkinter 是一个标准的 GUI (图形用户界面)包。Tkinter 是 Python 的默认 GUI 模块，也是 Python 中 GUI 编程最常用的方式。注意 Tkinter 是一组包装器，将
Tk小部件实现为 Python 类。 -
wxppython:
这基本上是一个开源的、跨平台的 GUI 工具包，用 C++ 编写。也是 Tkinter 的替代品。
-
曲面:T1
JPython 是一个面向 Java 的 Python 平台，它为本地机器提供了对 Java 类库的 Python 脚本无缝访问。
我们将介绍用 Tkinter 进行图形用户界面编程。
什么是 Tkinter？
Python 中的 Tkinter 有助于以最少的麻烦创建图形用户界面应用。在各种图形用户界面框架中，Tkinter 是唯一内置于 Python 标准库的框架。
-
有利于 Tkinter 的一个重要特性是它是跨平台，所以同样的代码可以轻松在 Windows 、 macOS 和 Linux 上运行。
-
Tkinter 是轻量级模块。
-
使用起来很简单。
**## 什么是 Tcl、Tk 和 Tkinter？
让我们通过更多地讨论 Tkinter 模块的起源来尝试了解它。
-
如上所述，Tkinter 是 Python 的默认 GUI 库，它只不过是 Tk 工具包之上的一个包装器模块。
-
Tkinter 基于 Tk 工具包，最初是为工具命令语言 (Tcl)设计的。由于 Tk 非常受欢迎，因此它被移植到了各种各样的其他脚本语言中，包括 Perl (Perl/Tk) 、 Ruby (Ruby/Tk) 和Python(Tkit)。
-
GUI 开发可移植性和 Tk 的灵活性使其成为设计和实现各种商业级 GUI 应用的合适工具。****
-
Python 配合 Tkinter 为我们提供了一种更快更高效的方式来构建有用的应用，如果你必须借助原生 OS 系统库直接用 C/C++编程，这将花费很多时间。
-
一旦我们启动并运行了 Tkinter，我们将使用称为小部件的基本构建块来创建各种桌面应用。
安装 Tkinter
有可能，Tkinter 可能已经和 Python 一起安装在您的系统上了。但并不总是如此。所以让我们首先检查它是否可用。
如果系统上没有安装 Python-先安装 Python 3.8 ，然后检查 Tkinter。
您可以通过尝试导入 Tkinter 模块来确定您的 Python 解释器是否可以使用 Tkinter-如果可以使用 Tkinter，则不会出现错误，如以下代码所示:
import tkinter
没有爆炸，所以我们知道我们有 Tkinter 可用。如果您看到任何错误，如找不到模块等，那么您的 Python 解释器没有在启用 Tkit 的情况下编译，模块导入失败，您可能需要重新编译您的 Python 解释器才能访问 Tkit。
将Tk添加到您的应用中
使用 Python 中的 Tkinter 设置 GUI 应用的基本步骤如下:
-
首先导入 Tkinter 模块。
-
第二步是创建一个顶层窗口对象，它包含了你的整个 GUI 应用。
-
然后在第三步中，您需要设置您所有的图形用户界面组件及其功能。
-
然后需要将这些 GUI 组件连接到底层应用代码。
-
然后只需使用
mainloop()进入主事件循环
以上步骤现在听起来可能有些胡言乱语。但是只要把它们都读完，我们将在继续学习本教程时解释所有内容。
第一个 Tkinter 示例
如前所述，在图形用户界面编程中，所有主要小部件都只构建在顶层窗口对象上。
顶层窗口对象由Tkinter中的Tk类创建。
让我们创建一个顶级窗口:
import tkinter as tk
win = tk.Tk()
###you can add widgets here
win.mainloop()
以上使用的方法:
使用图形用户界面创建 Python 应用时，使用了两种主要方法。你必须记住它们，这些在下面给出:
- Tk(screenName=None，baseName=None，class name =‘tk '，use uk = 1)
该方法主要用于创建主窗口。您也可以根据需要更改窗口的名称，只需将类名更改为所需的名称即可。
用于创建应用主窗口的代码是，我们也在上面的示例中使用了它:
win = tkinter.Tk() ## where win indicates name of the main window object
2。mainloop()功能
此方法用于启动应用。mainloop()功能是一个无限循环用来运行应用，它会等待一个事件发生和处理事件只要窗口没有关闭。
总结:
至此我们已经完成了对 Tkinter 的介绍，我们已经安装了 Tkinter 模块，甚至知道了什么是 Tkinter 中的 Windows 和 Widgets。我们还创建了我们的第一个 Tkinter GUI 应用并运行它。在下一个教程中，我们将了解更多关于 Tkinter 小部件的信息。
Tkinter 窗口、小部件和框架
原文：https://www.studytonight.com/tkinter/tkinter-windows-widgets-and-frames
在本教程中，我们将介绍 Tkinter 模块的基础知识，解释什么是 Tkinter 窗口、小部件和框架，它们是 Tkinter 中图形用户界面应用的构建模块。
Tkinter 窗口和小部件介绍
让我们深入一点，了解一些关于 Tkinter 模块及其工作原理的基础知识。
-
GUI 编程中的顶级窗口对象包含所有的小窗口对象，它们将成为完整 GUI 的一部分。
-
小窗口对象可以是文字标签、按钮、列表框等。，这些单独的小图形用户界面组件被称为小部件。
-
因此，拥有一个顶级窗口对象将充当一个容器，您可以在其中放置所有小部件。在 Python 中，您通常会使用以下代码这样做:
win = tkinter.Tk() -
通过调用
tkinter.Tk()返回的对象通常被称为根窗口。 -
顶级窗口主要是单机作为你的应用的一部分，还有你的 GUI 可以有多个顶级窗口，但是其中只有一个应该是你的根窗口。
-
首先，你需要完整地设计你所有的小部件，然后添加真正的功能。
-
小部件可以是独立的也可以是容器。如果一个小部件包含其他小部件，它被认为是那些小部件的父部件。
-
类似地，如果一个小部件包含在另一个小部件中，它被称为父部件的子部件，****父部件是下一个直接的封闭容器小部件。
-
小部件也有一些关联的行为，比如当按下按钮时，或者文本被填充到文本字段中，所以我们有事件附加到这些动作上。
-
小部件的行为生成事件，而 GUI 对事件的响应被称为回调 -因为他们“调用”一个函数只是为了处理发生的事件。
Tkinter 事件驱动处理
在 Tkinter 中，我们将窗口和小部件组合在一起，形成一个 GUI 应用。但是图形用户界面应用只是应用的前端。当最终用户使用这些小部件时，您可能希望执行一些代码逻辑。
每当对任何小部件执行操作时，都会生成一个事件，我们可以处理该事件来执行任何操作。
-
事件(小部件的行为)可以包括按下按钮、移动鼠标、点击回车键或回车键、获得或失去“焦点”等。
-
从开始到任何图形用户界面应用结束的整个事件系统是驱动它的因素，因此也被称为事件驱动处理。
-
让我们举一个简单的鼠标移动的例子:假设鼠标的指针正好位于您的图形用户界面应用顶部的某个地方。如果您将鼠标移动到应用的另一部分，则必须有某种东西使鼠标的移动被屏幕上的光标复制(在您的图形用户界面应用的顶部)。这些是“光标移动”事件，系统必须处理这些事件来描述您的光标在窗口中移动。在你将停止移动鼠标的时候，不再需要处理更多的事件，所以一切只是再次停留在屏幕上。
以下是一些基本定义，通过这些定义，您将能够理解 Tkinter 中的窗口、小部件和框架的概念。
Tkinter Windows
“窗口”一词在不同的上下文中有不同的含义，但一般来说“窗口”是指用户显示屏上的某个矩形区域，您可以通过它进行交互。
然后在 Tkinter 中出现了顶层窗口的概念。
顶层窗口
顶层窗口是在屏幕上独立存在的窗口。您可以使用桌面管理器的标准框架和控件来装饰顶层窗口。它通常可以在桌面上移动，如果你想的话也可以调整它的大小。
然后是小部件的概念。让我们试着去理解它。
Tkinter widgets
术语“小部件”是一个通用术语，指的是在图形用户界面中组成应用的构建块。
让我们列出核心小部件及其类别:
-
容器
在这个类别下，小部件是框架、标签框架、顶层和窗格窗口。
-
按钮
在按钮类别下，有按钮、单选按钮、复选按钮(复选框)和菜单按钮。
-
文本小部件
在文本小部件的类别下，有标签、消息和文本。
-
输入小部件
在这个类别下，小部件是缩放、滚动条、列表框、滑块、旋转框、条目(单行)、选项菜单、文本(多行)和画布(矢量和像素图形)。
现在让我们继续看 Tkinter 中的框架。
Tkinter 帧
框架基本上是一个矩形区域，可以包含其他小部件。在 Tkinter 中，有一个框架小部件，它是复杂布局的基本组织单位。它是一个小部件，没有自己的特殊样式或图形用户界面组件。它只是用来在复杂的图形用户界面布局的情况下容纳其他 Tkit 小部件。
注意: 这里需要注意的是，无论什么时候创建任何小部件，都会创建一个父子关系。举个例子，如果你在一个框架内放置一个按钮，这个框架小部件被称为按钮小部件的父部件。
Tkinter 基本示例
让我们举一个例子，我们将用一个简单的文本小部件创建一个 Tkinter 应用:
from tkinter import *
win = Tk() # Create the root (base) window
win.geometry("200x200")
w = Label(win, text="Hello, Welcome to Studytonight!") # Create a label with words
w.pack() # Put the label into the window
win.mainloop()# Start the event loop
上面的代码将创建一个带有标签小部件的窗口，输出将如上所示。我们已经创建了一个 Tkinter 窗口，然后向其中添加了一个基本的标签小部件。
总结:
在本教程中，我们学习了使用 Tkinter 的图形用户界面应用的基本构建块，它们是窗口、小部件和框架，用于开发不同的图形用户界面应用。在下一个教程中，我们将学习如何创建一个 Tkinter 窗口，这是任何应用的起点，因为在一个 Tkinter 窗口中，我们添加了所有的小部件。
Tkinter 窗口
在本教程中，我们将学习 Python 中的 Tkinter 窗口，这是图形用户界面应用的主窗口，其他所有组件都在其中运行。我们已经介绍了基本的 Tkinter GUI 应用组件，其中我们解释了 Tkinter 窗口、小部件和框架是如何构成 Tkinter 应用的。
Tkinter Windows
Tkinter 窗口是 Tkinter 图形用户界面的基础元素。Tkinter 窗口是一个容器，所有其他图形用户界面元素(小部件)都位于其中。
以下是创建基本 Tkinter 窗口的语法:
win = Tk()
是的，我们使用 Tk()函数来创建我们的 Tkinter 应用窗口，其中添加了所有其他组件。
Tkinter 窗口示例:
这里有一个简单的例子，
from tkinter import *
win = Tk()
# run the app window
win.mainloop()
在上例中，mainloop()功能用于运行 GUI 应用。
Tkinter 自定义窗口
现在让我们来看一个基本的例子，我们将使用像标题和几何图形这样的属性来创建一个基本的图形用户界面应用。
这里我们有代码来演示在创建定制的 Tkinter 窗口时使用的步骤:
from tkinter import *
window = Tk()
# You can add your widgets here
window.title('Hello StudyTonight')
window.geometry("300x200+10+20")
window.mainloop()
下面是我们在代码中所做的工作:
-
第一步是导入代码中的 Tkinter 模块。
-
导入后，第二步是通过调用
Tk()函数设置应用对象。这将创建一个顶层窗口(根)，该窗口具有一个带有标题栏和控制框的框架，带有最小化和关闭按钮，以及一个客户端区域来保存其他小部件。 -
之后，您可以在代码中添加您可能想要添加的小部件，如按钮、文本框、滚动条、标签等等。
-
window.title()功能用于向用户界面提供标题，如您在输出中所见。 -
行内
window.geometry("300x200+10+20)；geometry()方法以同样的方式定义帧左上角的宽度、高度、和坐标(所有值一般以像素为单位)。以下是语法:window.geometry("widthxheight+XPOS+YPOS") ```**
*** 之后，应用对象通过调用mainloop()方法进入事件监听循环。这样，应用现在就在上不断地等待在其中的元素上生成的任何事件。可以有类似于在文本字段中输入的文本、从下拉菜单或单选按钮中进行的**选择、鼠标的单/双击动作等事件。****
应用的功能包括响应特定类型的事件执行适当的回调函数**。
一旦点击标题栏上的关闭按钮，事件循环将终止。
总结:
在本教程中，我们学习了如何创建一个 Tkinter 窗口来创建一个 GUI 应用。that 窗口包含构成应用的所有小部件。
Tkinter 小部件
Tkinter 小部件
在本教程中，我们将概述 Python 中的 Tkinter 小部件。这些小部件是任何 Tkinter GUI 应用上的功能单元。
Tkinter widgets
有各种控件，如图形用户界面应用中使用的按钮、标签、滚动条、单选按钮和文本框。这些小组件或图形用户界面(GUI) 的控件在 Tkinter 中被称为小部件。
这些是 Tkinter 模块中提供的 19 小部件。下面我们列出了所有的小部件和基本描述:
| 小部件名称 | 描述 |
|---|---|
| 按钮 | 如果您想在应用中添加一个按钮，那么将使用按钮部件。 |
| 帆布 | 绘制复杂的布局和图片(如图形、文本等。)将使用画布小部件。 |
| 检查按钮 | 如果你想显示一些选项作为复选框，那么使用检查按钮部件。它允许您一次选择多个选项。 |
| 条目 | 显示从用户输入部件接受值的单行文本字段将被使用。 |
| 框架 | 为了分组和组织另一个小部件，将使用框架小部件。基本上，它充当了一个容纳其他小部件的容器。 |
| 标签 | 要为另一个小部件提供单行标题，将使用标签小部件。它也可以包含图像。 |
| 列表框 | 要向用户提供选项列表，将使用列表框小部件。 |
| 菜单 | 将使用向用户提供命令的菜单部件。基本上这些命令在菜单按钮中。这个小部件主要创建应用中需要的各种菜单。 |
| 菜单按钮 | 菜单按钮部件用于向用户显示菜单项。 |
| 消息 | 消息小部件主要向用户显示一个消息框。基本上是不可编辑的多行文本。 |
| 单选按钮 | 如果您希望选项的数量显示为单选按钮，那么将使用单选按钮部件。您可以一次选择一个。 |
| 刻度 | 刻度小部件主要是一个图形滑块，允许你从刻度中选择数值。 |
| 滚动条 | 要上下滚动窗口，将使用 python 中的滚动条小部件。 |
| 文字 | 文本小部件主要为用户提供一个多行文本字段，用户可以在其中输入或编辑文本，与 Entry 不同。 |
| 上一层 | 顶层小部件主要是给我们提供一个单独的窗口容器 |
| 旋转盒 | 旋转框作为“输入小部件的入口，在该小部件中，只要选择一个固定数值就可以输入数值。 |
| 平板式窗口 | 窗格也是容器小部件，主要用于处理不同的窗格。放置在其内部的窗格可以水平或垂直 |
| 标签框架 | LabelFrame 小部件也是一个容器小部件，主要用来处理复杂的小部件。 |
| 消息框 | 消息框 小部件主要用于在桌面应用中显示消息。 |
使用上面提到的所有小部件，我们可以创建令人惊叹的图形用户界面应用。
总结:
因此，在本教程中，我们获得了对小饰品的基本介绍。在接下来的教程页面中，我们将详细介绍每个小部件及其各自的代码示例。
Tkinter 几何管理器
原文：https://www.studytonight.com/tkinter/python-tkinter-geometry-manager
在本教程中，我们将学习如何在 Tkinter 几何管理器的帮助下控制应用的布局。
控制 Tkinter 应用布局
为了组织或排列或放置父窗口中的所有小部件，Tkinter 为我们提供了小部件的几何配置。图形用户界面应用布局主要由 Tkinter 的几何管理器控制。
这里需要注意的是，应用中的每个窗口和Frame只能使用一个几何管理器。此外，不同的框架可以使用不同的几何图形管理器，即使它们已经使用另一个几何图形管理器分配给一个框架或窗口。
几何管理器中主要有三种方法:
让我们逐一详细讨论每种方法。
1.Tkinter pack()几何图形管理器
pack()方法主要使用打包算法，以便按照指定的顺序在Frame或窗口中放置小部件。
这种方法主要用于将小部件组织在一个块中。
打包算法:
打包算法的步骤如下:
-
首先，该算法将计算一个矩形区域，称为包裹，该区域足够高(或宽)以容纳小部件，然后它将使用空白空间填充窗口中的剩余宽度(或高度)。
-
它将使小部件居中，直到指定了任何不同的位置。
这种方法很强大，但很难想象。
以下是使用pack()函数的语法:
widget.pack(options)
下面给出了作为该方法参数的可能选项:
-
fill
该选项的默认值设置为无。此外，我们可以将其设置为 X 或 Y ，以确定小部件是否包含任何额外空间。
-
side
该选项指定将小部件包装在的哪一侧。如果要垂直打包小部件，使用 TOP ，这是默认值。如果要水平打包小部件，使用左键。
-
expand
该选项用于指定是否应该扩展小部件以填充几何主图形中的任何额外空间。其默认值为
false。如果是false，则小部件不展开，否则小部件会展开以填充额外的空间。
Tkinter pack()几何图形管理器示例:
让我们讨论一个例子，在这个例子中，我们将看到当您将三个彩色的小部件(这里是 Tkinter Frame 小部件)放入一个窗口时会发生什么:
import tkinter as tk
win = tk.Tk()
# add an orange frame
frame1 = tk.Frame(master=win, width=100, height=100, bg="orange")
frame1.pack()
# add blue frame
frame2 = tk.Frame(master=win, width=50, height=50, bg="blue")
frame2.pack()
# add green frame
frame3 = tk.Frame(master=win, width=25, height=25, bg="green")
frame3.pack()
window.mainloop()
根据上面代码的输出，pack()方法只是默认将每个Frame放置在前面的下面，按照它们被分配到窗口的相同顺序。
带参数的 Tkinter pack()
让我们再举几个使用此函数参数的代码示例，如fill、side和expand。
您可以设置 fill 参数，以指定您希望帧填充的方向。如果要填充水平方向，则选项为tk.X，反之，tk.Y 用于垂直填充，双向填充tk.BOTH。
让我们举另一个例子，我们将堆叠三个框架，使每个框架水平填充整个窗口:
import tkinter as tk
win= tk.Tk()
frame1 = tk.Frame(master=win, height=80, bg="red")
# adding the fill argument with
# horizontal fill value
frame1.pack(fill=tk.X)
frame2 = tk.Frame(master=win, height=50, bg="yellow")
frame2.pack(fill=tk.X)
frame3 = tk.Frame(master=win, height=40, bg="blue")
frame3.pack(fill=tk.X)
win.mainloop()
在上面的输出中，您可以看到帧填满了应用窗口的整个宽度，因为我们使用了fill参数的tk.X值。
现在让我们举另一个代码示例，我们将使用所有选项，即fill、side和pack()方法的expand选项:
import tkinter as tk
win = tk.Tk()
frame1 = tk.Frame(master=win, width=200, height=100, bg="Yellow")
# setting fill, side and expand
frame1.pack(fill=tk.BOTH, side=tk.LEFT, expand=True)
frame2 = tk.Frame(master=win, width=100, bg="blue")
frame2.pack(fill=tk.BOTH, side=tk.LEFT, expand=True)
frame3 = tk.Frame(master=win, width=50, bg="green")
frame3.pack(fill=tk.BOTH, side=tk.LEFT, expand=True)
win.mainloop()
如果您将在系统中运行上面的代码，那么您可以看到这个输出能够双向扩展。
2.Tkinter grid()几何图形管理器
最常用的几何管理器是grid()，因为它提供了pack()功能的所有功能，但方式更简单、更易维护。
grid()几何管理器主要用于将窗口或框架拆分为行和列。
-
只需调用
grid()函数，并将行和列索引分别传递给row和column关键字参数，即可轻松指定小部件的位置。 -
行和列的索引都从
0开始，所以 2 的行索引和 2 的列索引告诉grid()函数在第三行的第三列放置一个小部件(0 表示第一，1 表示第二，2 表示第三)。
以下是grid()函数的语法:
widget.grid(options)
下面给出了作为该方法参数的可能选项:
-
栏
此选项指定要放置小部件的列号。最左侧列的索引为 0 。
-
行
此选项指定要放置小部件的行号。最上面的行由 0 表示。
-
柱跨
此选项指定小部件的宽度。它主要表示列扩展到的列数。
-
行跨度
此选项指定小部件的高度。它主要表示行扩展到的行数。
-
帕德克斯，帕德
该选项主要表示要添加到小部件边框外的小部件的填充像素数量。
-
ipad，ipad
该选项主要用于表示小部件边框内要添加到小部件的填充像素数量。
-
粘性
如果任意单元格大于一个小部件，那么粘性主要是用来指定小部件在单元格内的位置。基本上是代表小部件位置的粘性字母的串联。可能是北、东、西、南、东北、西北、南北、东西、东南。
Tkinter grid()几何图形管理器示例:
下面的代码脚本将帮助您创建一个由框架组成的 5 × 3 网格，其中包含Label小部件:
import tkinter as tk
win = tk.Tk()
for i in range(5):
for j in range(3):
frame = tk.Frame(
master = win,
relief = tk.RAISED,
borderwidth = 1
)
frame.grid(row=i, column=j)
label = tk.Label(master=frame, text=f"Row {i}\nColumn {j}")
label.pack()
win.mainloop()
如果您想要添加一些填充，那么您可以使用以下代码片段来完成:
import tkinter as tk
win = tk.Tk()
for i in range(5):
for j in range(3):
frame = tk.Frame(
master=win,
relief=tk.RAISED,
borderwidth=1
)
frame.grid(row=i, column=j, padx=5, pady=5)
label = tk.Label(master=frame, text=f"Row {i}\nColumn {j}")
label.pack()
win.mainloop()
正如您在上面的代码示例中看到的，我们使用了padx和pady参数，因为这些参数在小部件外部应用了填充。要在框架小部件中添加填充，请在代码中使用参数ipadx和ipady。
同样，也要尝试为grid()几何图形管理器使用其他参数。
3.韦小宝place()几何经理
place()几何管理器组织小部件，按照程序员的指示将它们放置在特定位置。
-
这个方法基本上是按照其 x 和 y 坐标来组织小部件。x 和 y 坐标都以像素为单位。
-
因此原点(其中
x和y都是0)是Frame的左上角或者窗口。 -
因此，
y参数指定了距离窗口顶部的空间的像素数，以放置小部件，x参数指定了距离窗口左侧的像素数。
以下是place()方法的语法:
widget.place(options)
下面给出了作为该方法参数的可能选项:
-
x，y
该选项以像素为单位指示水平和垂直偏移。
-
高、宽
该选项以像素为单位表示小部件的高度和重量。
-
锚
该选项主要表示小部件在容器内的精确位置。默认值(方向)是西北即(左上角)。
-
妓院模式
该选项表示边框类型的默认值为
INSIDE，也是指忽略边框内的父元素。另一种选择是OUTSIDE。 -
relx，依靠
该选项用于表示 0.0 到 1.0 之间的浮动，是水平和垂直方向上的偏移量。
-
继电器高度，继电器宽度
该选项用于表示 0.0 到 1.0 之间的浮点值，表示父代的高度和宽度的分数。
Tkinter place()几何图形管理器示例:
下面给出了这方面的代码片段:
from tkinter import *
top = Tk()
top.geometry("400x250")
Username = Label(top, text = "Username").place(x = 30,y = 50)
email = Label(top, text = "Email").place(x = 30, y = 90)
password = Label(top, text = "Password").place(x = 30, y = 130)
e1 = Entry(top).place(x = 80, y = 50)
e2 = Entry(top).place(x = 80, y = 90)
e3 = Entry(top).place(x = 95, y = 130)
top.mainloop()
在上面的代码示例中，我们使用了 Tkinter 标签和 Tkinter 输入小部件，我们将在接下来的教程中详细介绍它们。
总结:
在本教程中，我们学习了如何在图形用户界面应用的框架或窗口中定位小部件。我们了解了三个 Tkinter 几何管理器，即 pack()，grid()和 place()。
从下一个教程开始，我们将开始介绍不同的 Tkinter 小部件。
Tkinter 标签小部件
在本教程中，我们将介绍 Python 中的 Tkinter 标签小部件，它用于在 GUI 应用中创建一个标签，我们可以在其中显示任何文本或图像。
Tkinter 中的标签小部件用于显示框****可以放置图片和文字。
-
标签小部件主要用于向用户提供关于 Python 应用中使用的其他小部件的消息。
-
您可以随时在标签小部件中更改或更新 tex t。
-
这个小部件在显示一些文本时，只使用一种字体。
-
您可以执行其他任务，如给文本的某个部分加下划线，也可以将文本跨到多行。
-
在标签中显示的文本或文本的部分有各种选项可以配置。****
Tkinter Label Widget
标签小部件的语法如下所示，
W = Label(master,options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来配置文本，这些选项被写成逗号分隔的键值对。
Tkinter Label Widget 选项
以下是标签小部件使用的选项:
| 选项名称 | 描述 |
|---|---|
anchor |
该选项主要用于控制文本在提供的小部件尺寸中的位置。默认值为中心，用于对齐所提供空间中中心的文本。 |
bd |
该选项用于小部件的边框宽度。它的默认值是 2 像素。 |
bitmap |
该选项用于将位图设置为指定的图形对象，以便现在标签可以表示图形而不是文本。 |
bg |
该选项用于小部件的背景颜色。 |
cursor |
该选项用于指定当鼠标在标签上移动时显示什么类型的光标。该选项默认使用标准光标。 |
fg |
该选项用于指定写在小部件内的文本的前景色。 |
font |
该选项指定标签内文字的字体类型。 |
height |
该选项指示部件的高度 |
image |
该选项表示显示为标签的图像。 |
justify |
该选项指定标签中多条线的对齐。默认值为中心。其他值为右、左；你可以根据你的要求来证明 |
padx |
该选项表示文本的水平填充。该选项的默认值为 1 。 |
pady |
该选项指示文本的垂直填充。该选项的默认值为 1 。 |
relief |
该选项指示边框的类型。该选项的默认值为平 |
text |
此选项设置为字符串变量，它可能包含一行或多行文本 |
textvariable |
该选项与带有标签的Tinter 变量相关联。如果你改变这个变量的值，那么标签内的文本将被更新。 |
underline |
该选项用于给文本的特定部分加下划线。该选项的默认值=-1(无下划线)；您可以将其设置为 n 以内的任意整数值，计数从 0 开始。 |
width |
该选项表示小部件的宽度。 |
wraplength |
不要让只有一行作为标签文本，你可以把它分成任意多行，每一行都有这个选项指定的字符数。 |
Tkinter 标签小部件示例
现在让我们看看标签小部件的一个基本示例，下面给出了代码片段:
import tkinter
from tkinter import *
win = Tk()
var = StringVar()
label = Label( win, textvariable=var, relief=RAISED )
# set label value
var.set("Hey!? Welcome to StudyTonight")
label.pack()
win.mainloop()
在上面的代码中，我们创建了一个简单的变量StringVar()，然后给它赋值，这个变量被赋值给 Label 小部件的textvariable选项。
Tkinter 标签小部件-另一个例子
下面我们有另一个代码片段，以便更清楚地理解。让我们看看下面给出的代码片段:
from tkinter import *
win = Tk()
win.geometry("400x250")
#creating a label
username = Label(win, text = "Username").place(x = 30,y = 50)
#creating second label
password = Label(win, text = "Password").place(x = 30, y = 90)
submitbutton = Button(win, text = "Submit",activebackground = "red", activeforeground = "blue").place(x = 30, y = 120)
e1 = Entry(win,width = 20).place(x = 100, y = 50)
e2 = Entry(win, width = 20).place(x = 100, y = 90)
win.mainloop()
无论何时运行上述代码，在用户名和密码标签中输入值后，当您点击提交按钮时，其颜色变为红色。
不要担心上面代码中使用的按钮小部件和输入小部件，我们将在接下来的教程中很快介绍它们。这个例子是为了让你了解如何使用 Tinter 小部件为你的 Tinter 应用创建用户界面。
总结:
在本教程中，我们介绍了 Tkinter Label Widget，它用于在 Tkinter GUI 应用中显示文本和图像，或者添加带有表单输入字段的文本，就像我们在上面的示例中所做的那样。
Tkinter 按钮小部件
在本教程中，我们将介绍 Python 中 Tkinter 模块的按钮小部件。
Tkinter 中的按钮小部件主要用于在任意 GUI 应用中添加按钮。在 Python 中，在使用 Tkinter 按钮小部件的同时，我们可以很容易地修改按钮的样式，比如给它添加一个背景色，调整按钮的高度和宽度，或者按钮的位置等。非常容易。
-
您可以在按钮小部件的帮助下向应用添加各种类型的按钮(根据您的应用用户界面)。
-
如果您愿意，您也可以将任何方法或函数与按钮相关联，然后每当您按下按钮时，该方法将被调用。
-
按钮小部件有多个选项，您可以根据您的要求进行重置或设置。
Tkinter Button Widget
按钮小部件的语法如下所示，
W = Button(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来更改按钮的外观，这些选项被写成逗号分隔的。
Tkinter Button Widget 选项:
以下是 tkinter 按钮小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项表示鼠标悬停在按钮上时按钮的背景。 |
bd |
该选项用于以像素为单位表示边框的宽度。 |
bg |
该选项用于表示按钮的背景色。 |
command |
命令选项用于设置功能调用，该功能调用是在调用时安排的。 |
activeforeground |
该选项主要代表鼠标悬停在按钮时按钮的字体颜色。 |
fg |
该选项代表按钮的前景色。 |
font |
该选项指示按钮的字体。 |
height |
该选项指示按钮的高度。该高度在文本行的情况下表示文本行数，在图像的情况下表示像素数。 |
image |
该选项指示按钮上显示的图像。 |
higlightcolor |
此选项指示按钮上有焦点时的高亮颜色 |
justify |
该选项用于指示多条文本行的表示方式。对于左对齐，它设置为左对齐，对于右对齐，它设置为右对齐，对于中心对齐，它设置为中心对齐。 |
padx |
该选项表示按钮在水平方向的附加填充。 |
pady |
该选项表示按钮在垂直方向的附加填充。 |
underline |
该选项用于给按钮的文本加下划线。 |
width |
此选项指定按钮的宽度。对于文本按钮，它以若干字母的形式存在；对于图像按钮，它表示像素。 |
Wraplength |
在这种情况下，如果该选项的值是设置为正数，文本行将被包裹，以便适合该长度。 |
state |
该选项的值设置为禁用，使按钮无响应。激活主要代表按钮的激活状态。 |
我们将在下面的例子中使用不同的选项。
Tkinter 按钮小部件示例
现在让我们借助下面给出的代码片段创建一个简单的提交按钮:
from tkinter import *
win = Tk() ## win is a top or parent window
win.geometry("200x100")
b = Button(win, text = "Submit")
b.pack() #using pack() geometry
win.mainloop()
在上面的代码示例中，我们创建了一个给定宽度和高度的简单窗口。然后我们给它添加了一个按钮小部件，提供了作为该按钮主窗口创建的窗口，并为该按钮添加了一个文本。
Tkinter 按钮小部件-添加样式和事件处理程序
下面是另一个代码片段，我们将通过添加更多样式来改变按钮的外观。让我们看看我们是如何做到的:
import tkinter
from tkinter import *
from tkinter import messagebox
top = Tk()
top.geometry("300x150")
def click():
messagebox.showinfo("Hello", "Green Button clicked")
a = Button(top, text="yellow", activeforeground="yellow", activebackground="orange", pady=10)
b = Button(top, text="Blue", activeforeground="blue", activebackground="orange", pady=10)
# adding click function to the below button
c = Button(top, text="Green", command=click, activeforeground = "green", activebackground="orange", pady=10)
d = Button(top, text="red", activeforeground="yellow", activebackground="orange", pady=10)
a.pack(side = LEFT)
b.pack(side = RIGHT)
c.pack(side = TOP)
d.pack(side = BOTTOM)
top.mainloop()
在上面的代码中，我们使用不同的选项添加了一些样式，并添加了一个事件处理程序来处理第三个按钮的 click 事件。所以每当你点击带有绿色文字的按钮时，你会看到一个带有信息的 Tkinter 消息框。
总结:
在本教程中，我们学习了如何制作一个具有各种选项的 Tkinter Button 小部件，如改变按钮的样式、向按钮添加文本或定位按钮。我们还看到了一个代码示例，它向任何按钮添加一个事件处理函数，以便在单击按钮时执行一些操作。
Tkinter Checkbutton小部件
原文：https://www.studytonight.com/tkinter/python-tkinter-checkbutton-widget
在本教程中，我们将介绍 Python 中的 Tkinter Checkbutton 小部件，它用于在使用 Tkinter 开发桌面应用时在 GUI 上创建复选框。
如果你想在一个表单中显示多个选项，用户可以勾选选择任意选项，我们可以使用 Tkinter Checkbutton 小部件。它允许您通过单击每个选项对应的按钮，一次选择多个选项或一个单个选项。
例如，在表单中，您可以看到填写性别的选项，它有“男性”、“女性”、“其他”等选项。，您可以在任何选项上打勾，这是一个复选框。我们使用 HTML 中的 <input>标签，来创建复选框
它可以包含文本或图像。根据您的要求，有许多选项可用于配置检查按钮部件。
Tkinter 检查按钮小部件
检查按钮小部件的语法如下:
w = CheckButton(master, option=value)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来配置您的检查按钮小部件，这些选项被写成逗号分隔的键值对。
Tkinter 检查按钮小部件选项
以下是与检查按钮部件一起使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项表示检查按钮在光标下时检查按钮的背景颜色。 |
bd |
该选项指示拐角周围边框的大小。默认大小为 2 像素。 |
bg |
该选项用于表示检查按钮的背景颜色。 |
bitmap |
该选项主要用于在按钮上显示图像。 |
command |
命令选项用于设置功能调用，该功能调用安排在检查按钮状态改变时进行。 |
activeforeground |
该选项主要代表当勾选按钮在光标下时按钮的前景色。 |
fg |
该选项代表检查按钮的文本颜色。 |
font |
此选项指示 checkbutton 的字体。 |
height |
该选项指示按钮的高度。这个高度在文本行的情况下表示文本行数，在图像的情况下表示像素数。默认值为 1 。 |
| 图像 | 该选项指示代表检查按钮的图像。 |
cursor |
该选项有助于在光标位于检查按钮上时将鼠标指针更改为光标名称。 |
disableforeground |
该选项是用于指示禁用检查按钮文本的颜色。 |
higlightcolor |
当焦点在检查按钮上时，此选项指示高亮颜色 |
justify |
该选项用于指示多条文本行的表示方式。对于左对齐，它设置为左对齐，对于右对齐，它设置为右对齐，对于中心对齐，它设置为中心对齐。 |
padx |
该选项指示检查按钮在水平方向上的填充。 |
pady |
该选项指示检查按钮在垂直方向上的填充。 |
underline |
该选项用于给检查按钮的文本加下划线。 |
width |
此选项指定 checkbutton 的宽度。对于文本按钮，它以若干字母的形式存在；对于图像按钮，它表示像素。 |
Wraplength |
在这种情况下，如果该选项被设置为整数，则文本将被分解为片段数。 |
variable |
该选项主要用于表示用来跟踪检查按钮状态的关联变量 |
offvalue |
如果按钮关闭，检查按钮的关联控制变量默认设置为 0。您也可以将未选中变量的状态更改为另一个。 |
onvalue |
检查按钮的关联控制变量设置为 1(开)。通过将 onvalue 设置为该值，将为 on 状态提供任何替代值。 |
text |
该选项用于指示检查按钮旁边的标签。对于多行，请使用“\n”。 |
state |
该选项主要用于表示检查按钮的状态。其默认值=正常。可以将其更改为禁用，以使 checkbutton 无响应。当 checkbutton 处于焦点下时，此按钮的值为 ACTIVE |
selectcolor |
该选项表示设置时检查按钮的颜色。其默认值为红色。 |
selectimage |
该选项设置后显示检查按钮上的图像。 |
Tkinter 检查按钮小部件方法:
以下是 checkbutton 小部件使用的方法:
| 方法名称 | 描述 |
|---|---|
invoke() |
checkbutton 小部件中的这个方法用于调用与 checkbutton 关联的方法。 |
select() |
checkbutton 小部件中的这个方法被称为来打开check button。 |
deselect() |
checkbutton 小部件中的这个方法叫做关闭check button。 |
toggle() |
checkbutton 小部件中的这种方法是用来在不同的 check button 之间切换。 |
flash() |
checkbutton 小部件中的这种方法用于在活动颜色和正常颜色之间闪烁。 |
Tkinter 检查按钮小部件示例
下面我们有一个这个小部件的基本例子来获得对这个方法的基本理解:
from tkinter import *
root = Tk()
root.geometry("300x300")
w = Label(root, text ='StudyTonight', fg="Blue",font = "100")
w.pack()
Checkbutton1 = IntVar()
Checkbutton2 = IntVar()
Checkbutton3 = IntVar()
Button1 = Checkbutton(root, text = "Homepage",
variable = Checkbutton1,
onvalue = 1,
offvalue = 0,
height = 2,
width = 10)
Button2 = Checkbutton(root, text = "Tutorials",
variable = Checkbutton2,
onvalue = 1,
offvalue = 0,
height = 2,
width = 10)
Button3 = Checkbutton(root, text = "Contactus",
variable = Checkbutton3,
onvalue = 1,
offvalue = 0,
height = 2,
width = 10)
Button1.pack()
Button2.pack()
Button3.pack()
mainloop()
正如您在上面的代码中看到的，创建了三个IntVar()变量，然后我们创建了三个检查按钮，具有不同的文本，如主页、教程和联系人。
因此，我们在这里使用一些选项创建了检查按钮，如text、variable、onvalue、offvalue、height和width。您可以尝试使用更多选项。
摘要
因此，在本教程中，我们学习了如何使用 Tkinter checkbutton 小部件在 GUI 应用中创建复选框。
Tkinter Radiobutton小部件
在本教程中，我们将介绍 Python 中的 Tkinter Radiobutton 小部件，当我们想要在应用的 GUI 中添加一个单选按钮时会用到它。
Tkinter 单选按钮小部件用于实现多项选择选项，这些选项主要是在用户输入表单中创建的。
-
该小部件为用户提供多个选项，允许用户从给定选项中仅选择一个选项。因此，它也被称为在 Python 应用中实现一对多选择。
-
还有，不同的方法也可以和 radiobutton 关联。
-
您也可以在单选按钮上显示多行文本和图像。
-
每个单选按钮为特定的变量显示一个单值。
-
您还可以跟踪用户对单选按钮的选择，因为与单个变量相关联
Tkinter Radiobutton Widget
单选按钮小部件的语法如下:
W = Radiobutton(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改单选按钮的外观，这些选项被写成逗号分隔的键值对。
Tkinter Radiobutton Widget 选项:
以下是与 Tkinter 单选按钮小部件一起使用的选项:
| 选项名称 | 描述 |
|---|---|
anchor |
该选项用于表示文本在小部件中的确切位置，在小部件包含比文本要求更多的空间的情况下。该选项的默认值为“中心”。 |
bg |
该选项代表小部件的背景颜色。 |
activebackground |
该选项代表微件聚焦时的背景颜色。 |
activeforeground |
该选项代表微件聚焦时的字体颜色。 |
borderwidth |
该选项用于表示边框的大小。 |
bitmap |
如果您想要在小部件上显示图形，那么您可以将该小部件设置为任何图形或图像对象。 |
command |
该选项是用来设置程序，当单选按钮的状态改变时，每次必须调用该程序。 |
cursor |
该选项将鼠标指针转换为指定的光标类型，并可设置为箭头、点等。 |
font |
该选项用于表示小部件文本的字体类型。 |
fg |
该选项用于表示小部件文本的前景色。 |
height |
该选项表示小部件的垂直尺寸 |
width |
该选项表示小部件的水平尺寸，用字符数表示。 |
padx |
该选项代表小部件的水平填充。 |
pady |
该选项表示小部件的垂直填充 |
highlightcolor |
该选项用于表示小部件处于焦点下时焦点高亮的颜色 |
highlightbackground |
当部件不在焦点下时，该选项用于表示焦点高亮的颜色。 |
image |
如果您希望在小部件上显示图像，那么该选项将设置为图像而不是文本 |
justify |
该选项用于表示多行文字的对齐。默认值为中心。其他值为左，右。 |
relief |
该选项用于表示边框的类型。默认值为平。 |
selectcolor |
该选项表示选择时单选按钮的颜色 |
selectimage |
该选项表示当选择时要在单选按钮上显示的图像 |
state |
该选项用于表示单选按钮的状态。收音机按钮的默认状态是正常。您也可以将状态设置为禁用，以使收音机按钮无响应。 |
text |
该选项指示要在单选按钮上显示的文本。 |
textvariable |
该选项用于控制小部件所代表的文本。textvariable可以设置为需要在小部件上显示的文本。 |
underline |
该选项可以设置为现有的数字，以便指定字符串的第 n 个字母将带有下划线。默认值为-1，表示无下划线 |
variable |
该选项也称为控制变量，用于跟踪用户的选择。因此，该变量在所有单选按钮之间共享。 |
value |
当用户打开时，每个单选按钮的该选项被分配给控制变量。 |
wraplength |
该选项用于将文本换行到所需的行数，只需将选项设置为所需的行数，使得每行仅包含该数量的字符。 |
Tkinter 单选按钮小部件方法:
以下是 Tkinter Radiobutton 小部件使用的各种方法:
| 方法名称 | 描述 |
| deselect() | 此方法用于取消选择或关闭单选按钮 |
| select() | 此方法用于选择单选按钮 |
| invoke() | 此方法通常用于在单选按钮的状态发生变化时调用函数。 |
| flash() | 这种方法通常用于在单选按钮的正常颜色和活动颜色之间闪烁多次。 |
Tkinter 单选按钮小部件示例
下面我们有一个单选按钮小部件的基本示例。让我们看看 Radiobutton 小部件的代码片段:
#firstly ImportTkinter module
from tkinter import *
from tkinter.ttk import *
# Creating parent Tkinter window
win = Tk()
win.geometry("200x200")
# let us create a Tkinter string variable
# that is able to store any string value
v = StringVar(win, "1")
# here is a Dictionary to create multiple buttons
options = {" Option A" : "1",
"Option B" : "2",
"Option C" : "3",
"Option D" : "4"
}
# We will use a Loop just to create multiple
# Radiobuttons instaed of creating each button separately
for (txt, val) in options.items():
Radiobutton(win, text=txt, variable=v, value=val).pack(side = TOP, ipady = 4)
mainloop()
上面的代码将给出以下输出:
注意: 如果你自己尝试上面的代码片段，那么你会看到在输出中你一次只能选择一个按钮。
另一个例子
下面是这个小部件的另一个例子，我们将使用 style 类向 radiobutton 添加样式:
from tkinter import *
from tkinter.ttk import *
win= Tk()
win.geometry('200x200')
v = StringVar(win, "1")
# we will add Style class to add style to Radiobutton
style = Style(win)
style.configure("TRadiobutton", background = "light blue",
foreground = "orange", font = ("arial", 14, "bold"))
# Dictionary to create multiple buttons
values = {"RadioButton 1" : "1",
"RadioButton 2" : "2",
"RadioButton 3" : "3"
}
for (text, value) in values.items():
Radiobutton(win, text = text, variable = v,
value = value).pack(side = TOP, ipady = 3)
mainloop()
上面的代码将改变字体样式以及背景和前景色。在上图中TRadiobutton用在样式类中，它自动将样式应用于所有可用的单选按钮。
总结:
在本教程中，我们了解了 Radiobutton 小部件，它用于创建多个选项，从中可以选择一个选项。这主要在我们创建用户表单时使用，比如注册表单。
Tkinter 输入小部件
原文：https://www.studytonight.com/tkinter/python-tkinter-entry-widget
在本教程中，我们将介绍 Python 中 Tkinter 的输入小部件及其各种选项，并且借助的几个例子，我们将详细了解这个概念。
如果你需要从用户那里得到一点点文本，比如名字、电子邮件地址或联系号码，那么使用条目小部件。
-
Entry 小部件主要用于显示一个小文本框，用户可以在其中输入一些文本。
-
有许多选项可用于更改输入小部件的样式。
-
需要注意的是输入小部件仅用于从用户处获取单行文本，因为在多行文本的情况下，将使用文本小部件。
-
这个小部件主要用于接受用户的文本字符串。
Tkinter 条目小部件
条目小部件的语法如下:
w = Entry(master, option=value)
在上面的语法中，主参数表示父窗口。您可以使用许多选项来更改条目小部件 的样式，这些选项以逗号分隔。
Tkinter 条目小部件选项:
条目小部件使用的各种选项如下:
| 选项名称 | 描述 |
|---|---|
bg |
该选项用于小部件的背景颜色。 |
bd |
该选项用于边框的**宽度，单位为像素。其默认值为 2 像素。** |
cursor |
该选项有助于将鼠标指针更改为光标类型，并将其设置为箭头、点等。 |
exportselection |
需要注意的是默认情况下，写在输入框内的文本会自动复制到剪贴板。如果不想复制文本，则将导出选择的值设置为 0。 |
fg |
该选项用于指示文本的颜色。 |
font |
该选项用于表示文本的字体类型 |
highlightbackground |
该选项用于表示当微件没有输入焦点时遍历高亮区域中显示的颜色。 |
highlightcolor |
该选项用于表示当小部件有输入焦点时，围绕小部件绘制的遍历高亮矩形所使用的颜色。 |
justify |
如果文本包含多行，该选项用于指定文本在情况下的组织方式。 |
relief |
该选项用于指示边框的类型。该选项的默认值为FLAT。它有更多类似GROOVE, RAISED,RIGID的价值观。 |
selectbackground |
该选项用于指示所选文本的背景颜色。 |
selectforeground |
用于设置所选任务的字体。 |
selectborderwidth |
该选项指示围绕所选任务显示的边框宽度 |
width |
该选项指示要显示的图像的宽度或文本的宽度。 |
textvariable |
在这个选项的帮助下，你将能够从你的输入小部件中检索当前文本，你需要将这个选项设置为StringVar类的一个实例。 |
show |
该选项用于显示其他类型的输入文本，而不是字符串。例如，我们使用星号 (*)键入密码。 |
xscrollcommand |
如果你想让用户输入更多的文本而不是小部件的实际宽度，你可以将输入小部件链接到水平滚动条。 |
insertbackground |
该选项主要表示在插入光标覆盖的区域内颜色作为背景。因此这个颜色将会覆盖小部件的正常背景，T2。 |
Tkinter 输入小部件方法:
输入小部件使用的各种方法如下:
| 方法名称 | 描述 |
|---|---|
delete(first, last=None) |
此方法用于删除小部件内部的指定字符。 |
get() |
此方法用于将条目小部件的当前文本作为字符串获取。 |
icursor(index) |
该方法用于将插入光标设置在指定索引处的字符之前。 |
index(index) |
该方法用于将光标放置在指定索引处书写的字符的左侧。 |
select_clear() |
该方法是在已经做了一些选择的情况下，用来清除选择。 |
select_present() |
如果存在某个选择的，则该方法将返回true，否则将返回false。 |
insert(index, s) |
该方法主要用于在指定索引处的字符前插入指定的字符串 |
select_adjust(index) |
该方法主要包括选择出现在指定索引处的字符 |
select_form(index) |
该方法主要将锚点索引位置设置为索引指定的字符。 |
select_range(start, end) |
该方法用于选择字符存在于指定范围之间 |
select_to(index) |
该方法主要选择从开始到指定索引的所有字符 |
xview(index) |
此方法用于将条目小部件链接到水平滚动条 |
xview_scroll(number, what) |
该方法主要用于使输入小部件水平滚动 |
Tkinter 条目小部件示例
下面我们有一个 Tkinter Entry 小部件的基本例子。让我们看看代码片段:
from tkinter import *
win = Tk()
win.geometry("400x250")
name = Label(win, text = "Name").place(x = 30,y = 50)
email = Label(win, text = "Email").place(x = 30, y = 90)
password = Label(win, text = "Password").place(x = 30, y = 130)
submitbtn = Button(win, text = "Submit",activebackground = "red", activeforeground = "blue")
.place(x = 30, y = 170)
entry1 = Entry(win).place(x = 80, y = 50)
entry2 = Entry(win).place(x = 80, y = 90)
entry3 = Entry(win).place(x = 95, y = 130)
win.mainloop()
在上面的代码示例中，我们完成了以下工作:
-
创建文本标签来命名文本输入字段。对于所有 3 个文本输入字段(输入小部件)，我们已经创建了三个标签。
-
我们已经使用
place()几何管理器将标签放置在应用窗口上。 -
然后我们创建了一个按钮，即提交按钮。并使用
place()几何管理器将其定位在应用图形用户界面上。 -
最后，我们有三个条目小部件，它们将创建三个文本输入字段。并使用
place()几何管理器将其定位在应用图形用户界面上。
摘要
在本教程中，我们学习了如何在创建 GUI 应用时使用 Tkinter Entry 小部件来创建文本输入字段。
Tkinter 消息小部件
在本教程中，我们将学习 Python 中的 Tkinter 消息小部件，它用于在您使用 Tkinter 创建的 GUI 应用上显示一些文本消息。
Python 中的 Tkinter 消息小部件主要用于向使用应用的用户显示一些消息。
-
Tkinter 消息小部件显示的消息为不可编辑类型，可以是多行中的。
-
Tkinter 消息小部件显示的消息包含单字体文本。
-
这个小部件的功能非常类似于的Tkit Label 小部件、但是有一个区别，那就是消息小部件可以自动换行。
Tkinter Message Widget
Tkinter 消息小部件的语法如下所示:
W = Message(master,options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改消息的外观，这些选项被写成逗号分隔的键值对。
Tkinter Message Widget 选项:
以下是 Tkinter 消息小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
anchor |
主要用于确定文本在所提供空间内的准确位置。该选项的默认值为中心。 |
bg |
该选项表示小部件的背景颜色。 |
bd |
该选项用于指示小部件的边框宽度。这个的默认值是 2 像素。 |
bitmap |
为了在小部件上显示图形，将使用该选项。您可以将其设置为任何图形或图像对象。 |
cursor |
在此选项的帮助下，鼠标指针将变为特定的光标类型，如箭头、圆点等。 |
fg |
该选项用于指示小部件文本的字体颜色。 |
font |
该选项用于指示小部件文本的字体类型。 |
height |
该选项用于指示消息小部件的垂直尺寸。 |
image |
该选项用于指示小部件上的图像。 |
justify |
该选项用于小部件上文本的对齐。可以是中心，左，右**** |
padx |
该选项用于小部件的水平填充。 |
pady |
该选项用于小部件的垂直填充。 |
relief |
该选项用于指定边框类型。它的默认值是 FLAT |
underline |
该选项可以按顺序设置为现有数字，以指定字符串的第 n 个字母将带有下划线。其默认值为 -1 ，表示无下划线。 |
text |
如果您想在标签小部件中显示一行或多行文本，您需要将此选项设置为包含文本的字符串。您可以在中使用“\n”来输入多行**** |
textvariable |
该选项用于控制小部件所代表的文本。textvariable可以设置为需要在小部件上显示的文本。 |
width |
该选项用于以字符数而非像素表示小部件的水平尺寸。 |
wraplength |
该选项用于将文本换行到所需的行数，只需将选项设置为所需的行数，使得每行仅包含该数量的字符。 |
Tkinter 消息小部件示例
下面我们有一个 Tkinter 消息小部件的基本示例:
from tkinter import *
win = Tk()
win.geometry("300x200")
w = Label(win, text ='StudyTonight', font = "90",fg="Navyblue")
w.pack()
msg = Message(win, text = "Best place to learn coding online")
msg.pack()
win.mainloop()
在上面的代码示例中，我们创建了一个简单的标签小部件和一个包含一些文本消息的消息小部件。
总结:
至此，我们已经介绍了用于在 Tkinter GUI 应用中显示消息的 Tkineter 消息小部件。我们还可以动态创建消息小部件来显示 Tkinter 应用中的错误或成功消息。
Tkinter 菜单小部件
在本教程中，我们将介绍 Python 中的 Tkinter 菜单小部件，它用于创建带有选项供用户选择的菜单。
Tkinter 菜单小部件用于在 Python 应用中创建不同类型的菜单。
-
可以使用 Tkinter Menu 小部件创建以下类型的菜单:弹出、下拉、和顶层。
-
顶层菜单是那些显示在根窗口或任何其他顶层窗口的标题栏下的菜单。例如，所有网站都在浏览器的网址栏下方有一个顶部导航菜单。
-
菜单通常用于提供便捷的选项访问，如打开任何文件、退出任何任务、以及在应用中操作数据。
Tkinter Menu Widget
菜单小部件的语法如下:
W = Menu(master, options)
在上面的语法中，master参数表示父窗口。可以用很多options来改变菜单的外观，这些选项写成逗号分隔的键值对。
Tkinter Menu Widget 选项:
以下是菜单小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项用于在微件处于焦点下时，指示微件的背景色。 |
activeforeground |
该选项指示小部件有焦点时小部件文本的字体颜色。 |
activeborderwidth |
该选项用于指示小部件在鼠标下方时(活动时)边框的宽度。该选项的默认值为 1 像素。 |
bd |
该选项用于指示小部件的边框宽度 |
bg |
该选项指示小部件的背景颜色。 |
cursor |
当鼠标悬停在菜单上时，该选项指示光标。 |
disabledforeground |
当小部件被禁用时，该选项指示小部件的文本颜色 |
font |
该选项用于指示小部件文本的字体类型 |
fg |
该选项指定微件的前景色。 |
relief |
该选项用于指定边框类型。其默认值为升起。 |
image |
该选项用于在菜单上显示图像 |
postcommand |
该选项可以设置为鼠标悬停在菜单上时调用的任何功能。 |
tearoff |
默认情况下，菜单中的选项从位置 1 开始。但是如果我们设置tearoff=1，那么的选择将从第 0 个位置开始。 |
selectcolor |
该选项表示选择时用于显示检查按钮或单选按钮的颜色。 |
title |
如果您想更改窗口的标题，该选项被设置为窗口的标题。 |
Tkinter 菜单小部件方法:
以下是 Tkinter Menu 小部件使用的各种方法:
| 方法名称 | 描述 |
| add_command() | 此方法用于向菜单添加菜单项。 |
| add_radiobutton() | 此方法用于将单选按钮添加到菜单中。 |
| add_checkbutton() | 该方法主要用于将检查按钮添加到菜单中。 |
| add_cascade() | 该方法用于通过将给定菜单与父菜单相关联来创建父菜单的分层菜单。 |
| add_seperator() | 此方法用于在菜单项中添加分隔线。 |
| add(type, options) | 该方法用于将特定菜单项添加到菜单中。 |
| delete(startindex, endindex) | 此方法用于删除指定范围内存在的菜单项。 |
| entryconfig(index, options) | 此方法用于配置由给定索引标识的菜单项。 |
| index(item) | 此方法用于获取指定菜单项的索引。 |
| insert_seperator(index) | 此方法用于在指定索引处插入分隔符。 |
| invoke(index) | 此方法用于调用在指定索引处给定选项的关联操作。 |
| type(index) | 此方法用于获取索引指定的选择类型。 |
正如您在上面看到的，我们有很多方法与菜单小部件相关联，可用于根据您的要求配置菜单。
Tkinter 菜单小部件示例
下面我们有一个使用这个小部件的基本例子:
from tkinter import *
root = Tk()
def hello():
print("hello!")
menubar = Menu(root)
menubar.add_command(label="Hello StudyTonight!", command=hello)
menubar.add_command(label="Quit!", command=root.quit)
root.config(menu=menubar)
root.mainloop()
运行上述代码后，您将看到上面的输出。每当你点击你好 StudyTonight！菜单项然后它会打印一个你好！在你的控制台上。一边点击一边退出！菜单项，应用将关闭。
总结:
在本教程中，我们学习了如何为我们的 Tkinter 应用创建菜单，以及如何向其中添加菜单项，并在用户选择任何菜单项时执行一些操作。
Tkinter Menubutton小部件
在本教程中，我们将介绍 Python 中的 Tkinter 菜单按钮小部件，该小部件用于创建下拉菜单，用户可以点击该菜单查看
-
这个小部件用于在 Python 应用中提供各种类型的菜单。
-
需要注意的是，应用中的每个菜单按钮都与一个菜单小部件相关联，作为回报可以在用户点击该菜单按钮时显示该菜单按钮的选项。
-
Tkinter Menubutton 小部件为用户提供了一个选项，以选择应用中存在的适当选项。
Tkinter Menubutton Widget
Tkinter 菜单按钮小部件的语法如下:
W = Menubutton(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改菜单按钮的外观，这些选项被写成逗号分隔的键值对。
Tkinter Menubutton Widget 选项:
以下是 Tkinter 菜单按钮小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项指示鼠标悬停在菜单按钮上时菜单按钮的背景颜色。 |
bd |
该选项用于以像素为单位表示边框的宽度。默认值为 2 像素。 |
bitmap |
该选项将被设置为图形内容，该图形内容将被显示给小部件。 |
bg |
该选项用于表示小部件的背景颜色。 |
cursor |
当鼠标悬停在菜单按钮上时，该选项指示光标。 |
activeforeground |
该选项主要表示小部件处于焦点时小部件的字体颜色 |
fg |
该选项代表微件的前景色。 |
direction |
借助该选项，您可以指定方向，以便菜单可以显示到按钮的指定方向。您可以使用左、右或上方相应地放置小部件。 |
disabledforeground |
该选项指示小部件禁用时小部件的文本颜色 |
height |
该选项指示菜单按钮的高度。该高度在文本行的情况下表示文本行数，在图像的情况下表示像素数。 |
image |
该选项指示菜单按钮上显示的图像。 |
higlightcolor |
此选项指示按钮上有焦点时的高亮颜色 |
justify |
该选项用于指示多条文本行的表示方式。左对齐设置为左对齐，右对齐设置为右对齐，中心对齐设置为中心。 |
padx |
该选项指示小部件在水平方向的附加填充。 |
pady |
该选项指示小部件在垂直方向的附加填充。 |
menu |
该选项用于指示与菜单按钮相关联的菜单 |
width |
此选项指定小部件的宽度。对于文本按钮，它以若干字母的形式存在；对于图像按钮，它表示像素 |
Wraplength |
在这种情况下，如果该选项的值是设置为正数，文本行将被包裹，以便适合该长度。 |
state |
由于菜单按钮的正常状态为启用。可以将设置为禁用，使菜单按钮无响应。 |
text |
该选项用于在小部件上指示文本。 |
textvariable |
类字符串变量的控制变量可以与该菜单按钮相关联。如果您将设置控制变量，那么它将改变显示的文本。 |
underline |
此选项主要用于表示小部件的文本中的字符的索引，该字符将被加下划线。索引通常从文本中的零开始。 |
relief |
该选项用于指定边框类型。它的默认值是 REGISTED |
Tkinter 菜单按钮小部件示例
现在让我们看一下 Tkinter 菜单按钮小部件的代码片段:
from tkinter import *
import tkinter
win = Tk()
mbtn = Menubutton(win, text="Courses", relief=RAISED)
mbtn.grid()
mbtn.menu = Menu(mbtn, tearoff = 0)
mbtn["menu"] = mbtn.menu
pythonVar = IntVar()
javaVar = IntVar()
phpVar = IntVar()
mbtn.menu.add_checkbutton(label="Python", variable=pythonVar)
mbtn.menu.add_checkbutton(label="Java", variable=javaVar)
mbtn.menu.add_checkbutton(label="PHP", variable=phpVar)
mbtn.pack()
win.mainloop()
上述代码的输出如下:
你可以自己试试上面的例子。每当您执行上述代码时，您会看到一个窗口上有一个名为课程的 Tkinter 菜单按钮，当您点击它时，它会显示一个如下所示的下拉菜单:
总结:
在本教程中，我们介绍了用于在 Tkinter 应用中创建下拉菜单的 Tkinter Menubutton 小部件。
Tkinter 框架小部件
原文：https://www.studytonight.com/tkinter/python-tkinter-frame-widget
Tkinter 框架小部件用于以更好更友好的方式分组和组织小部件。框架小部件基本上是一个容器(一个不可见的容器)，其任务是容纳其他小部件和相对于彼此排列。Tkinter 框架部件在屏幕上组成一个矩形区域。
它基本上充当一个基础类，然后实现复杂的小部件。这就像的 HTML div 标签，它只是用来定义网页上有其他 HTML 元素的部分。
Tkinter Frame Widget
框架小部件的语法如下:
W = Frame(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改框架的外观，这些选项被写成逗号分隔的键值对。
Tkinter 框架小部件选项:
以下是框架小部件使用的各种选项:
| 选项名称 | 描述 |
| bd | 该选项用于表示边框的宽度。其默认值为 2 像素。 |
| bg | 该选项用于指示小部件的正常背景颜色。 |
| cursor | 借助该选项，可以将鼠标指针更改为光标类型，即设置为不同的值，如箭头、点等。 |
| height | 该选项用于指示框架的高度。 |
| width | 该选项用于指示框架的宽度。 |
| highlightbackground | 该选项表示背景色在对焦时的颜色。 |
| highlightthickness | 该选项用于指定小部件处于焦点下时边框周围的厚度。 |
| relief | 该选项指定框架边框的类型。其默认值为平板**** |
| highlightcolor | 该选项主要用于表示框有焦点时焦点高亮的颜色。 |
Tkinter 框架小部件示例
下面我们有一个基本的例子，我们将在一个框架小部件中组织不同的按钮小部件。让我们看看下面给出的代码片段:
from tkinter import *
root = Tk()
root.geometry("300x150")
w = Label(root, text ='StudyTonight', font = "80")
w.pack()
frame = Frame(root)
frame.pack()
bottomframe = Frame(root)
bottomframe.pack(side = BOTTOM)
button1 = Button(frame, text ="Block1", fg ="red")
button1.pack(side = LEFT)
button2 = Button(frame, text ="Block2", fg ="brown")
button2.pack(side = LEFT)
button3 = Button(frame, text ="Block3", fg ="blue")
button3.pack(side = LEFT)
button4 = Button(bottomframe, text ="Block4", fg ="orange")
button4.pack(side = BOTTOM)
button5 = Button(bottomframe, text ="Block5", fg ="orange")
button5.pack(side = BOTTOM)
button6 = Button(bottomframe, text ="Block6", fg ="orange")
button6.pack(side = BOTTOM)
root.mainloop()
在上面的代码示例中，我们创建了两个框架小部件，然后在这些框架中添加了 3 个按钮，并使用 Tkit 几何管理器在应用窗口中排列按钮，
摘要
在本教程中，我们了解了 Tkinter Frame 小部件，以及如何使用它来管理其他 Tkinter 小部件并正确定位它们。
Tkinter 画布小部件
Tkinter Canvas widget 主要作为通用 widget，也就是用来在 Tkinter 中的应用窗口上绘制任何东西。
-
这个小部件主要用于绘制图形和图、图纸、图表和显示图像。
-
可以借助画布绘制多种复杂布局，如多边形、矩形、椭圆形、文字、弧形位图、图形等。
-
画布小部件也用于创建图形编辑器。
-
有许多选项可用于配置和控制画布小部件。
Tkinter Canvas Widget
画布小部件的语法如下所示:
w = Canvas(master, option=value)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来更改画布的布局，这些选项被写成逗号分隔的键值。
Tkinter Canvas Widget 选项:
以下是画布小部件使用的各种选项:
| 选项名称 | 描述 |
| bd | 该选项主要用于设置边框的宽度，单位为像素。默认值 0px 表示无边框，1px 表示细线边框，可以增加边框宽度。 |
| bg | 该选项用于设置背景色。 |
| cursor | 光标是否使用画布上的箭头、圆点或圆圈，可以使用该选项。 |
| confine | 该选项设置为使画布在滚动区域外不可滚动。 |
| height | 该选项用于控制画布的高度。 |
| width | 该选项用于设置小部件的宽度。 |
| highlightcolor | 当有焦点在按钮上时，该选项指示高亮颜色 |
| xscrollcommand | 在这种情况下，如果画布是可滚动类型的，那么这个属性应该作为水平滚动条的set() 方法 |
| yscrollcommand | 在这种情况下，如果画布是可滚动类型的，那么这个属性应该作为垂直滚动条的set() 方法 |
| scrollregion | 这个选项主要用于表示指定为包含画布区域的元组的坐标 |
| xscrollincrement | 如果该选项的值设置为正值，则画布仅放置为该值的倍数。 |
| yscrollincrement | 主要用于垂直运动，其工作方式与xscrollincrement选项相同。 |
Tkinter 画布小部件基本示例
让我们借助画布小部件创建一个简单的画布:
from tkinter import *
# window named top
top = Tk()
# set height and width of window
top.geometry("300x300")
#creating a simple canvas with canvas widget
cv = Canvas(top, bg = "yellow", height = "300")
cv.pack()
top.mainloop()
上面的代码会创建一个简单画布，背景颜色黄色，你可以在上面画任何东西。
使用弧线的饼图
让我们在下面给出的代码片段的帮助下，创建一个画布，然后在其上绘制一个弧:
import tkinter
# init tk
root = tkinter.Tk()
# creating canvas
mCanvas = tkinter.Canvas(root, bg="white", height=300, width=300)
# drawing two arcs
coord = 10, 10, 300, 300
arc1 = mCanvas.create_arc(coord, start=0, extent=150, fill="pink")
arc2 = mCanvas.create_arc(coord, start=150, extent=215, fill="blue")
# adding canvas to window and display it
mCanvas.pack()
root.mainloop()
上面的代码会打开一个窗口，然后添加一个画布，然后在上面画两个弧线。由粉色和蓝色绘制的两条弧线共同组成一个圆，如上图所示。
总结:
在本教程中，我们了解了 Tkinter 画布小部件，它可以用来在画布上绘制任何东西，可能是图表、图像或一些动态形状。
Tkinter Listbox小部件
在本教程中，我们将介绍 Python 中的 Tkinter Listbox 小部件，该小部件用于在一个框内以列表的形式向用户显示不同类型的项目，用户可以选择这些项目。
-
项目包含同类型字体和同字体颜色。
-
这里需要注意的是只有文本项可以放在列表框小部件中。
-
从这个项目列表中，用户可以根据需要选择一个或多个项目。
Tkinter Listbox Widget
Tkinter Listbox 小部件的语法如下所示:
W = Listbox(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改列表框的外观，这些选项被写成逗号分隔的键值对。
Tkinter Listbox Widget 选项:
下面是列表框小部件使用的各种选项:
| 期权名称 | 描述 |
|---|---|
bg |
该选项指示小部件的背景颜色。 |
bd |
该选项用于表示边框的大小。默认值为 2 像素。 |
cursor |
借助该选项，鼠标指针看起来会像点、箭头等光标类型一样。 |
font |
该选项指示列表框项目的字体类型。 |
fg |
该选项指示文本的颜色。 |
height |
该选项用于表示列表框中显示的行的计数。该选项的默认值为 10。 |
highlightcolor |
当窗口小部件处于焦点下时，该选项用于指示列表框项目的颜色。 |
highlightthickness |
该选项用于指示高光的厚度。 |
relief |
此选项指示边框的类型。默认值为凹陷。 |
selectbackground |
该选项用于指示背景颜色，该颜色用于显示所选文本。 |
selectmode |
此选项用于确定可从列表中选择的项目数量。可以设置为浏览、单个、多个、扩展。 |
width |
该选项用于以字符表示小部件的宽度。 |
xscrollcommand |
该选项用于让用户水平滚动列表框。 |
yscrollcommand |
该选项用于让用户垂直滚动列表框。 |
Tkinter 列表框小部件方法:
以下是与列表框小部件相关联的方法:
| 方法 | 描述 |
|---|---|
activate(index) |
此方法主要用于选择指定索引处的行。 |
curselection() |
此方法用于返回包含所选元素行号的元组，从 0 开始计数。如果未选择任何内容，则返回一个空元组。 |
delete(first, last = None) |
此方法用于删除给定范围内存在的行。 |
get(first, last = None) |
此方法用于获取给定范围内存在的项目列表。 |
index(i) |
此方法用于将带有指定索引的行放在小部件的顶部。 |
insert(index, *elements) |
此方法用于在指定索引之前插入具有指定元素数的新行。 |
nearest(y) |
此方法用于返回列表框小部件 y 坐标的最近行的索引。 |
see(index) |
此方法用于调整列表框的位置，使索引指定的行可见。 |
size() |
此方法返回列表框小部件中的行数。 |
xview() |
此方法用于使小部件水平滚动。 |
xview_moveto(fraction) |
此方法用于使列表框水平滚动列表框中最长线条宽度的一部分。 |
xview_scroll(number, what) |
此方法用于使列表框水平滚动指定的字符数。 |
yview() |
此方法允许列表框垂直滚动。 |
yview_moveto(fraction) |
此方法用于使列表框垂直滚动列表框中最长线条宽度的一部分。 |
yview_scroll (number, what) |
此方法用于使列表框垂直滚动指定的字符数。 |
Tkinter 列表框小部件示例
下面我们有一个使用这个小部件的基本例子:
from tkinter import *
top = Tk()
top.geometry("200x250")
lbl = Label(top, text="List of Programming Languages")
listbox = Listbox(top)
listbox.insert(1,"Python")
listbox.insert(2, "Java")
listbox.insert(3, "C")
listbox.insert(4, "C++")
lbl.pack()
listbox.pack()
top.mainloop()
在上面的代码示例中，我们创建了一个简单的 Listbox 小部件，其中包含一些项目，并指定了列表框小部件上的顶部列表项目(标题)。
总结:
在本教程中，我们了解了 Tkinter Listbox 小部件、其基本语法、Listbox 小部件的常用方法以及一个代码示例。
Tkinter Scrollbar小部件
在本教程中，我们将介绍 Python 中的 Tkinter Scrollbar 小部件，使用它我们可以在我们的 Tkinter 应用的用户界面中添加一个滚动条。
要在 Python 桌面应用中向上或向下或向右或向左滚动内容，需要使用 Tkinter 滚动条小部件。
-
要滚动列表框、画布等其他小部件的内容，我们使用这个小部件。
-
水平和垂直滚动条都可以在饰品输入小部件中创建。
下面我们有一张图片，显示了与列表框一起使用的滚动条小部件:
Tkinter scrollbar widget
滚动条部件的语法如下所示:
W = Scrollbar(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来配置滚动条部件，这些选项被写成逗号分隔的键值对。
Tkinter scrollbar widget 选项:
以下是 Tkinter Scrollbar 小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项表示小部件处于焦点时的背景颜色。 |
bg |
该选项代表小部件的背景颜色 |
bd |
该选项代表小部件的边框大小。默认值为 2 像素。 |
cursor |
借助该选项，鼠标指针将变为特定的光标类型，可以是箭头、点等。 |
command |
每次移动滚动条时，该选项将被设置为相关的程序，称为。 |
elementborderwidth |
此选项主要表示箭头和滑块周围的边框宽度。该选项的默认值为-1。 |
highlightthickness |
该选项代表聚焦高光的厚度 |
highlightbackground |
当部件不在焦点下时，该选项指示高亮颜色 |
highlightcolor |
当部件处于焦点下时，该选项指示高亮颜色 |
jump |
该选项是用来控制滚动跳转的行为。如果该选项设置为 1，则在用户释放鼠标按钮时调用回调。 |
orient |
根据滚动条的方向，该选项可以设置为水平或垂直。 |
width |
该选项代表滚动条的宽度。 |
troughcolor |
该选项用于设置波谷的颜色 |
takefocus |
默认情况下可以通过这个小部件来定位焦点。如果您不想要此行为，可以将此选项设置为 0。 |
repeatdelay |
该选项主要用于在滑块开始在该方向上重复移动之前告知按钮被按下的持续时间。其默认值为 300 毫秒 |
repeatinterval |
该选项的默认值为 100 |
Tkinter 滚动条小部件方法:
Tkinter Scrollbar 小部件使用的几种方法是:
-
get():这个方法返回两个数字，假设
a和b(T2)代表滚动条的当前位置。 -
set(first, last):此方法用于将滚动条连接到任何其他小部件。也就是其他小部件的
yscrollcommand或者xscrollcommand到这个方法。
Tkinter 滚动条小部件示例
下面我们有一个滚动条小部件的基本例子。
from tkinter import *
win= Tk()
sbb = Scrollbar(win)
sbb.pack(side = RIGHT, fill = Y)
mylist = Listbox(win, yscrollcommand = sbb.set)
for line in range(45):
mylist.insert(END, "Value " + str(line))
mylist.pack(side = LEFT)
sbb.config(command = mylist.yview)
mainloop()
从上面的代码中可以看到，我们已经创建了一个列表框小部件，其中的列表项是数字。然后我们创建了一个滚动条小部件，并使用列表框小部件的yscrollcommand选项来设置滚动条小部件。我们在这里使用了滚动条部件的set功能。
总结:
因此，我们已经介绍了 Tkinter Scrollbar 小部件。当我们有一个长列表的 Tkinter 应用或者一些太长而不适合应用窗口的小部件时，这非常有用。然后，我们可以将滚动条小部件用于此类应用。
Tkinter 缩放小部件
原文：https://www.studytonight.com/tkinter/python-tkinter-scale-widget
在本教程中，我们将介绍 Python 中的 Tkinter Scale 小部件，该小部件用于添加一个图形滑块对象，用户可以滑动该对象并选择一个数字，因为数值会附加到该滑块标尺上，并且当您上下或左右移动滑块时，附加到其上的数值会增加或减少，您可以将滑块设置为您想要选择的值。
-
由提供的滑动条刻度部件有助于根据我们应用中滑动条的方向，从左右滑动或从上下滑动来选择数值。
-
如果输入小部件的目的是在给定的数值范围内从用户处获取数字输入，则刻度小部件用作输入小部件的替代品。
-
您还可以控制最小和最大值以及标尺的分辨率。
Tkinter 缩放小部件
Tkinter 缩放小部件的语法如下所示:
W = Scale(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多options来更改刻度部件的布局，这些选项被写成逗号分隔的键值。
Tkinter 缩放小部件选项:
以下是 Tkinter Scale 小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
activebackground |
该选项表示小部件处于焦点时的背景颜色。 |
bg |
该选项代表小部件的背景颜色 |
bd |
该选项代表小部件的边框大小。默认值为 2 像素。 |
cursor |
借助该选项，鼠标指针将变为特定的光标类型，可以是箭头、点等。 |
command |
该选项将被设置为每次移动滑块时被称为的程序。如果我们快速移动滑块，当稳定时，回调到程序。 |
digits |
当用于控制刻度数据的控制变量为字符串类型时，则该选项主要用于指定数字刻度转换为字符串时的位数。 |
fg |
该选项表示文本的前景色 |
font |
该选项表示文本的字体类型 |
from_ |
该选项用于表示小部件范围的一端。 |
highlightcolor |
当部件处于焦点下时，该选项指示高亮颜色 |
highlightbackground |
当部件不在焦点下时，该选项指示高亮颜色 |
label |
该选项可以设置为一些文本，然后可以显示为带有刻度的标签。如果刻度是水平的那么它显示在左上角或者如果刻度是垂直的那么它显示在右上角。 |
length |
该选项指示小部件的长度。如果标尺在水平方向上，它代表的 X 维度；如果标尺在垂直方向上，它代表的 Y 维度。**** |
relief |
该选项用于指定边框类型。它的默认值是 FLAT |
orient |
根据刻度的类型，该选项可以设置为水平或垂直。 |
resolution |
该选项将被设置为刻度值的最小变化 |
repeatdelay |
该选项主要用于在滑块开始在该方向上重复移动之前告知按钮被按下的持续时间。其默认值为 300 毫秒 |
sliderlength |
该选项表示滑块窗口沿标尺长度的长度。它的默认值是 30 像素。另外，您可以将其更改为适当的值。 |
showvalue |
默认情况下，刻度的值以文本形式显示，我们也可以将此选项设置为 0，以抑制标签。 |
state |
默认情况下，刻度部件的状态为激活状态。要使其无响应，您也可以将其设置为禁用 |
width |
该选项用于表示小部件槽部的宽度 |
variable |
该选项用于表示刻度的控制变量 |
to |
此选项用于代表一个浮点或整数值，指定刻度所代表的范围的另一端 |
takefocus |
一般来说，焦点会在刻度部件中循环。如果你不想要这个行为，你可以将这个选项设置为 0 。 |
tickinterval |
在该选项的帮助下，刻度值显示在指定刻度间隔的倍数上。此选项的默认值为 0。 |
troughcolor |
该选项用于设置波谷的颜色 |
Tkinter 缩放小部件方法
以下是缩放小部件使用的几种方法:
-
get():此方法用于获取刻度的当前值。
-
set(value):此方法用于设置刻度值。
Tkinter 缩放小部件-水平示例
下面我们有一个基本的例子，我们将创建一个水平滑动条。
from tkinter import *
win = Tk()
win.geometry("200x100")
v = DoubleVar()
scale = Scale( win, variable=v, from_=1, to=50, orient=HORIZONTAL)
scale.pack(anchor=CENTER)
btn = Button(win, text="Value")
btn.pack(anchor=CENTER)
label = Label(win)
label.pack()
win.mainloop()
在本教程中，我们创建了一个水平缩放小部件。如果您在代码中看到，我们已经为此将orient指定为水平。我们还为滑块刻度指定了数值的范围。
Tkinter 缩放小部件-垂直示例
下面我们有另一个例子，我们将创建一个垂直滑块:
from tkinter import *
win = Tk()
win.geometry("400x300")
v = DoubleVar()
def show():
sel = "The Vertical Scale Value is = " + str(v.get())
# adding scale value to label to show
scale_val.config(text=sel, font=("Courier", 16))
scl = Scale(win, variable=v, from_=60, to=1, orient=VERTICAL)
mainlabel = Label(win, text="The Vertical Slider")
btn = Button(win, text ="Show Slider Value",
command = show,
bg = "darkblue",
fg = "white")
# creating another label to show the scale value
scale_val = Label(win)
scl.pack(anchor = CENTER)
mainlabel.pack()
btn.pack()
scale_val.pack()
win.mainloop()
您可以将滑块从底部移动到顶部，因为它是一个垂直滑块。在给定的例子中，我们还在我们的应用中添加了一个按钮，并且我们定义了一个功能show()，该功能作为事件处理程序附加到按钮部件上。因此，在用户使用滑块选择任何值，然后单击按钮后，该值将显示在按钮下方的标签小部件中。
总结:
在本教程中，我们了解了 Tkinter Scale 小部件，这是一个很好的用户界面组件，用于从最终用户那里获取特定范围内的数字输入值。
Tkinter 顶层小部件
在本教程中，我们将介绍 Python 中的 Tkinter 顶层小部件，该小部件用于创建和显示顶层窗口，而不是应用窗口。
-
在 Tkinter 顶级小部件的帮助下，您可以在父窗口顶部的单独窗口中为用户提供额外信息。
-
使用顶层小部件创建的这个顶层窗口由窗口管理器直接组织和管理。
-
顶层窗口不一定要有家长在上面。
-
您可以创建多个顶层窗口。
-
使用创建的顶级窗口顶级小部件包含标题栏、边框、以及一些窗口装饰。
-
借助这个小工具，你可以在新窗口上提供弹出、一些额外信息、或者一些小工具。
Tkinter Toplevel Widget
Tkinter 顶级小部件的语法如下:
W = Toplevel(master,options)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来配置您的顶级小部件，这些选项被写成逗号分隔的键值对。
Tkinter Toplevel Widget 选项:
下面给出了与 Tkinter 顶级小部件一起使用的各种options:
| 选项名称 | 描述 |
|---|---|
bd |
来表示窗口的边框尺寸 |
bg |
来表示窗口的背景颜色 |
class_ |
一般来说，在文本小部件中选择的文本只需导出即可选择到窗口管理器。也可以将该选项的值设置为 0，使这种行为为假。 |
cursor |
该选项将鼠标指针转换为指定的光标类型，并可设置为箭头、点等。 |
width |
该选项用于表示窗口的宽度 |
height |
该选项用于表示窗口的高度 |
font |
此选项指示要插入到小部件中的文本的字体类型****。 |
fg |
该选项用于指示小部件的前景色。 |
relief |
该选项表示窗口的类型。 |
Tkinter 顶层小部件方法:
下面给出了 Tkinter 顶级小部件使用的各种方法:
| 方法 | 描述 |
|---|---|
title(string) |
该方法用于定义窗口的标题。 |
withdraw() |
该方法用于删除窗口，但不会破坏窗口。 |
positionfrom(who) |
该方法用于定义位置控制器 |
sizefrom(who) |
该方法用于定义尺寸控制器。 |
minsize(width,height) |
该方法用于声明窗口的最小尺寸 |
maxsize(width,height) |
该方法用于声明窗口的最大尺寸 |
resizable(width,height) |
此方法用于控制窗口是否可以调整大小。 |
transient([master]) |
该方法用于将窗口转换为临时窗口 |
iconify() |
此方法用于将顶层窗口转换为图标。 |
deiconify() |
这个方法是主要用来显示窗口。 |
frame() |
为了指示系统相关的窗口标识符，使用该方法。 |
group(window) |
此方法用于将顶级窗口添加到指定的窗口组 |
protocol(name,function) |
该方法用于指示将为特定协议调用的功能 |
state() |
该方法用于获取窗口的当前状态。该选项的一些可能值是正常、图标、撤回和图标。 |
Tkinter 顶层小部件示例
下面我们有一个基本的例子，我们将创建一个简单的顶层窗口。
from tkinter import *
win = Tk()
win.geometry("200x200")
def open():
top = Toplevel(win)
top.mainloop()
btn = Button(win, text="open", command=open)
btn.place(x=75, y=50)
win.mainloop()
在上面的代码中，我们已经创建了一个顶级小部件，该部件是在单击按钮时创建和启动的。
总结:
所以现在我们知道什么是 Tkinter Toplevel 小部件，以及如何创建它。Tkinter Toplevel 小部件很适合在不同的窗口中显示应用的某些部分，该窗口显示在主应用窗口的顶部。
Tkinter Spinbox小部件
在本教程中，我们将介绍 Python 中的 Tkinter Spinbox 小部件及其语法和几个示例。Python 中 Tkinter 的 Spinbox 小部件用于从指定的给定值范围中选择一个值。
它与Tkinter Scale widget(Scale widget 更时尚)在风格上有所不同，但或多或少实现了相同的目的。
例如，当您希望有一个数值下拉列表，如出生年份(从 1950 年到 2020 年)或一个下拉列表供用户选择他们的年龄时，我们可以使用 Tkinter Spinbox 小部件。
-
当我们希望用户输入一个特定范围内的数值时，这个小部件是条目小部件的替代。
-
该小部件仅在用户需要从给定的选择范围中进行选择的情况下使用。
Tkinter Spinbox 小部件
自旋盒小部件的语法如下:
w = Spinbox(master, option=value)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来配置您的 spinbox 小部件，这些选项被写成逗号分隔的键值对。
Tkinter Spinbox 小部件选项:
以下是 Tkinter Spinbox 小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
bg |
该选项用于小部件的背景颜色。 |
bd |
该选项用于小部件的边框宽度 |
command |
该选项用于指示小部件的关联功能，每次小部件状态改变时都会调用该功能。 |
cursor |
借助该选项，您的鼠标指针类型可以更改为分配给该选项的光标类型。 |
activebackground |
该选项表示微件在焦点下时的背景色 |
disabledbackground |
当禁用时，该选项用于指示小部件的背景颜色。 |
disabledforeground |
此选项用于指示小部件禁用时的前景色。 |
font |
该选项指定小部件内文本的字体类型。 |
fg |
该选项指定小部件的前景色。 |
format |
该选项主要用于格式字符串。此选项没有默认值。 |
from_ |
该选项用于指示小部件的起始范围 |
justify |
该选项指定标签中多条线的对齐。默认值为左。其他值为右和中。 |
relief |
该选项表示边框的类型。该选项的默认值为下沉。 |
state |
该选项用于表示小部件的状态。该选项的默认值为正常。其他值有“禁用”、“只读”等。 |
validate |
该选项用于控制如何验证小部件的值 |
to |
该选项代表小部件值的最大限值。另一个值由来自 _ 选项的指定 |
repeatdelay |
该选项主要用于控制自动重复按钮。这里的值以毫秒为单位。 |
repeatinterval |
该选项类似于重复延时选项。这里的值也是以毫秒为单位给出的。 |
validatecommand |
该选项与函数回调的相关联，该函数用于对小部件的内容进行验证。 |
xscrollcommand |
该选项主要与滚动条小部件的set()方法一起使用，使该小部件可水平滚动 |
wrap |
该选项主要用于收拢旋转盒的上下按钮 |
width |
该选项指示小部件的宽度。 |
vcmd |
该选项类似于 validatecommand 。 |
values |
该选项表示包含部件的值的元组**** |
textvariable |
它是一个控制变量，用于控制小部件的文本 |
Tkinter Spinbox 小部件方法:
以下是 Tkinter Spinbox 小部件使用的各种方法:
| 方法名称 | 描述 |
|---|---|
invoke(element) |
该方法用于调用与小部件相关联的回调。 |
insert(index,string) |
我们使用这个方法主要是在给定的指定索引处插入字符串 |
index(index) |
要获取给定索引的绝对值，将使用此方法 |
identify(x,y) |
该方法用于识别指定范围内的小部件元素 |
get(startindex, endindex) |
此方法用于获取指定范围内的字符 |
delete(startindex, endindex) |
此方法用于删除指定范围内的字符 |
Tkinter Spinbox Widget 示例
下面我们有一个 Spinbox 小部件的基本例子。让我们看看下面给出的代码片段:
from tkinter import *
win = Tk()
win.geometry("300x200")
w = Label(win, text ='StudyTonight', fg="navyblue",font = "50")
w.pack()
sp = Spinbox(win, from_= 0, to = 50)
sp.pack()
win.mainloop()
在上面的代码中，我们创建了一个简单的应用窗口，有一个标签小部件和一个范围从 0 到 50 的 Spinbox 小部件。
总结:
这就是 TKinter Spinbox 小部件的工作原理。它用于为用户可以选择的指定数值范围创建输入。如果我们有一个定义的数字范围，那么最好使用自旋盒小部件，而不是使用 Tkinter Entry 小部件。
Tkinter LabelFrame小部件
在本教程中，我们将介绍 Python 中的 Tkinter LabelFrame 小部件及其语法和几个示例。LabelFrame 小部件主要用于在子小部件周围绘制边框。
-
这个小部件是一个边框的容器小部件，是用来将相关的小部件分组到一个 Tkinter 应用中，为用户提供更好的用户体验。
-
例如，我们可以使用 labelframe 小部件对应用中使用的单选按钮小部件进行分组。
-
还可以为 LabelFrame 小部件添加一个标题(我们将在代码示例中看到这一点)。
-
标签框架小部件是框架小部件的一个变种，它具有框架的所有特征。
注意: 如果你已经使用 HTML 进行网页开发，那么标签框架就和 HTML fieldset 标签一样。
Tkinter LabelFrame Widget
标签框架小部件的语法如下。让我们看看:
w = LabelFrame(master, option=value)
在上面的语法中，master参数表示父窗口。您可以使用许多options来配置标签框架，这些选项被写成逗号分隔的键值对。
Tkinter LabelFrame Widget 选项:
以下是标签框架小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
height |
该选项用于表示小部件的高度。 |
width |
该选项用于表示框架的宽度。 |
text |
该选项表示包含标签文本的字符串。 |
relief |
该选项代表边框的样式。这个选项的默认值是 GROOVE |
padx |
该选项表示小部件的水平填充 |
pady |
该选项代表小部件的垂直填充 |
font |
该选项表示小部件文本的字体类型 |
highlighthickness |
该选项表示焦点高亮边框的宽度 |
highlightbackground |
该选项表示小部件没有焦点时焦点高亮边框的颜色 |
highlightcolor |
该选项指示当小部件处于焦点下时焦点高亮的颜色 |
bg |
该选项表示小部件的背景颜色 |
bd |
该选项用于表示指示器周围边框的大小。这个选项的默认值是 2 像素。 |
Class |
该选项的默认值为 LabelFrame。 |
colormap |
这个选项主要是用来指定这个小部件要使用哪个路图。在这个选项的帮助下，我们可以在这个小部件上重用另一个窗口的颜色映射。颜色图是指 256 种颜色，用于形成图形 |
container |
如果我们将此选项的值设置为真，则标签框架将成为容器小部件。这个选项的默认值是假的 |
cursor |
该选项将鼠标指针转换为指定的光标类型，并可设置为箭头、点等 |
fg |
该选项用于指示小部件的前景色 |
labelAnchor |
该选项表示小部件内文本的准确位置。该选项的默认值为西北(西北) |
labelwidget |
该选项表示标签要使用的部件。此外，如果没有指定值，框架将使用标签的文本 |
Tkinter 标签框架小部件示例
下面我们有一个 LabelFrame 小部件的基本示例。让我们看看下面给出的代码片段:
from tkinter import *
win = Tk()
win.geometry("300x200")
labelframe1 = LabelFrame(win, text="Happy Thoughts!!!")
labelframe1.pack(fill="both", expand="yes")
toplabel = Label(labelframe1, text="You can put your happy thoughts here")
toplabel.pack()
labelframe2 = LabelFrame(win, text = "Changes You want!!")
labelframe2.pack(fill="both", expand = "yes")
bottomlabel = Label(labelframe2, text = "You can put here the changes you want,If any!")
bottomlabel.pack()
win.mainloop()
正如您在上面的输出中看到的，我们已经创建了两个 labelframe 小部件，其中我们已经为 labelframe 小部件添加了文本，并且在 labelframe 小部件内部，我们有一个标签小部件。我们可以在 labelframe 小部件中拥有任意多的小部件。
总结:
因此，有了这个，我们就完成了 Tkinter labelframe 小部件，它就像 HTML fieldset 标记一样，如果你知道 HTML 的话。labelframe 小部件用于在其他小部件周围创建边框，以便对应用中的其他小部件进行分组。
Tkinter PanedWindow小部件
在本教程中，我们将介绍 Tkinter PanedWindow 小部件，它主要是一个包含一个或多个子小部件的容器小部件，也称为 Panes 。
-
该小部件以垂直的或水平的方式排列子小部件。****
-
它也被称为 几何管理器 小部件。
-
这个小部件用于在使用 Tkinter 模块创建的 Python 桌面应用中实现不同的布局。
-
用户可以通过鼠标移动分隔线和边框来调整面板窗口小部件内的子小部件的大小。
-
您可以使用面板插件实现多个面板。
这是一个简单的 Tkit 应用窗口，三个小部件垂直堆叠在一个 PanedWindow 小部件中。
Tkinter panedwindow widget
PanedWindow 小部件的语法如下所示:
W = PanedWindow(master, options)
在上面的语法中，master参数表示父窗口。您可以使用许多选项来更改面板的外观，这些选项被写成逗号分隔的。
Tkinter panedwindow widget 选项:
以下是 PanedWindow 小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
bd |
该选项用于表示小部件的 3D 边框尺寸。该选项的默认值表示槽不包含边框，箭头和滑块包含 2 像素边框尺寸。 |
bg |
该选项代表小部件的背景颜色。 |
cursor |
该选项将鼠标指针转换为指定的光标类型，并可设置为箭头、点等。 |
borderwidth |
该选项用于指示小部件的边框宽度。该选项的默认值为 2 像素。 |
handlepad |
To 表示手柄和窗扇末端之间的距离我们使用这个选项。在水平方向，它是窗扇顶部和把手之间的**距离。该选项的默认值为 8 像素** |
height |
该选项代表小部件的高度。如果我们没有指定高度，那么高度将通过子部件的高度来计算。 |
handlesize |
该选项代表手柄的大小，默认值为 8 像素。此外，手柄将始终处于方形**** |
orient |
如果我们想将和子窗口并排放置，该选项的值将被设置为水平。如果我们想从上到下放置子窗口，那么这个选项的值将被设置为垂直。 |
sashpad |
该选项用于表示围绕每个窗扇进行的填充。该选项的默认值为 0 。 |
sashwidth |
该选项指示窗扇的宽度。这个选项的默认值是 2 像素。 |
sashrelief |
该选项用于表示每个窗扇周围的类型的边框。该选项的默认值为平面**** |
showhandle |
要显示手柄，该选项的值应设置为真。该选项的默认值为假。 |
width |
该选项代表小部件的宽度。如果我们没有指定高度，那么高度将通过子部件的高度来计算。 |
relief |
该选项表示边框类型。这个选项的默认值是 FLAT 。 |
Tkinter PanedWindow 小部件方法:
以下是 PanedWindow 小部件使用的一些方法:
| 方法名称 | 描述 |
|---|---|
config(options) |
这种方法主要用于配置任何带有指定选项的小部件。 |
get(startindex,endindex) |
此方法用于获取指定给定范围内的文本。 |
add(child,options) |
此方法用于将窗口添加到父窗口。 |
Tkinter PanedWindow 小部件示例
下面我们有一个理解 PanedWindow 小部件的基本例子。让我们看看下面给出的代码片段:
from tkinter import *
# event handler for button
def addition():
x = int(e1.get())
y = int(e2.get())
leftdata = str(x+y)
leftinput.insert(1, leftdata)
# first paned window
w1 = PanedWindow()
w1.pack(fill=BOTH, expand=1)
leftinput = Entry(w1, bd=5)
w1.add(leftinput)
# second paned window
w2 = PanedWindow(w1, orient=VERTICAL)
w1.add(w2)
e1 = Entry(w2)
e2 = Entry(w2)
w2.add(e1)
w2.add(e2)
bottomBtn = Button(w2, text="Addition", command=addition)
w2.add(bottomBtn)
mainloop()
如上图所示，在输出中，我们有一个应用窗口，其中有 3 个 tkinter Entry 小部件和 1 个 tkinter button 小部件，使用 2 个 PanedWindow 小部件堆叠在一起，相互垂直排列。
如果您愿意，在右侧输入小部件中提供两个数字，然后单击加法按钮，右侧数字相加的结果，将显示在左侧的输入小部件中。
Tkinter PanedWindow 小部件-多个窗格示例
让我们看看下面给出的这个小部件的另一个代码片段:
from tkinter import *
from tkinter import tk
win = Tk()
pw = PanedWindow(orient ='vertical')
#creating Button widget
top = tk.Button(pw, text ="Just Click Me!!!\nI am a Button")
top.pack(side=TOP)
#Adding button widget to the panedwindow
pw.add(top)
#Creating Checkbutton Widget
bot = Checkbutton(pw, text="I am Checkbutton Choose Me!")
bot.pack(side=TOP)
pw.add(bot)
label = Label(pw, text="I am a Label")
label.pack(side=TOP)
pw.add(label)
string = StringVar()
entry = Entry(pw, textvariable=string, font=('arial', 15, 'bold'))
entry.pack()
# This is used to force focus on particular widget
# that means widget is already selected for some operations
entry.focus_force()
pw.add(entry)
pw.pack(fill = BOTH, expand = True)
# To show sash
pw.configure(sashrelief = RAISED)
mainloop()
在上面的代码示例中，我们已经在 panedwindow 小部件中创建了多个小部件。我们还使用了StringVar()变量，并使用了focus_force()函数在加载应用时使输入小部件处于焦点位置。
总结:
在本教程中，我们了解了 PanedWindow 小部件，如果您想在应用中创建多列网格状的小部件排列，这是一个很好的小部件。
Tkinter 文本小部件
在本教程中，我们将介绍 Python 中的 Tkinter 文本小部件。如果你想在你的桌面应用中有一个文本编辑器，那么你可以使用 Tkinter 文本小部件。
-
文本小部件用于提供一个多行文本框(输入框)，因为在 Tkinter 中单行文本框是使用 输入小部件 提供的。
-
您可以在文本小部件中使用各种样式和属性。
-
您也可以使用文本小部件中的标记和标签来定位文本的特定部分。
-
像图像和链接这样的媒体文件也可以插入到文本小部件中。
-
有一些需要多行文本的应用，比如发送消息或者从用户那里获取长输入，或者到在应用中显示可编辑的长格式文本内容等。用例由这个小部件完成。
-
因此为了显示文本信息，我们将使用文本小部件。
Tkinter Text Widget
文本小部件的语法如下所示:
W = Text(master, options)
在上面的语法中，master参数表示父窗口。可以使用很多options来配置文本编辑器，这些选项写成逗号分隔的键值对。
Tkinter Text Widget 选项:
以下是文本小部件使用的各种选项:
| 选项名称 | 描述 |
|---|---|
bd |
该选项代表小部件的边框宽度。 |
bg |
该选项指示小部件的背景颜色。 |
exportselection |
该选项用于导出窗口管理器选择中选择的文本。如果您不想导出文本，那么您可以将该选项的值设置为 0。 |
cursor |
该选项将鼠标指针转换为指定的光标类型，并可设置为箭头、点等。 |
font |
该选项用于指示文本的字体类型。 |
fg |
该选项指示小部件的文本颜色 |
height |
该选项表示宽度 t 的垂直尺寸，主要以行数表示。 |
highlightbackground |
该选项指示小部件不在焦点下时的高亮颜色。 |
higlightthickness |
该选项用于指示高光的厚度。这个选项的默认值是 1。 |
highlightcolor |
该选项指示当小部件处于焦点下时焦点高亮的颜色。 |
insertbackground |
该选项用于表示插入光标的颜色。 |
padx |
该选项指示小部件的水平填充。 |
pady |
该选项指示小部件的垂直填充。 |
relief |
该选项指示小部件的边框类型。该选项的默认值为下沉。 |
state |
如果该选项的值设置为禁用，则小部件对鼠标和键盘无响应 |
tabs |
该选项用于控制制表符如何用于文本的定位 |
width |
该选项代表小部件的宽度，以字符表示。 |
wrap |
要将较宽的线缠绕成多条线，使用该选项。这个选项的默认值是 CHAR ，它在任何字符处断开变得太宽的线 |
xscrollcommand |
如果你想让文本小部件水平滚动，那么你可以将这个选项设置为滚动条小部件的 set()方法 |
yscrollcommand |
如果你想让文本小部件垂直滚动，那么你可以将这个选项设置为滚动条小部件的 set()方法 |
spacing1 |
此选项指示要在文本的每一行上方插入的垂直空间。 |
spacing2 |
该选项用于指定当逻辑行换行时，要在显示的文本行之间增加多少额外的垂直空间。该选项的默认值为 0 |
spacing3 |
此选项指示要插入文本每行下方的垂直空间。 |
selectbackground |
该选项表示所选文本的背景颜色。 |
selectborderwidth |
该选项指示所选文本周围边框的宽度。 |
insertofftime |
该选项表示时间量(单位为毫秒)，在期间，插入光标在眨眼周期中处于关闭状态 |
insertontime |
该选项表示时间量(单位为毫秒)，在期间，插入光标在眨眼周期中位于上的 |
insertborderwidth |
为了表示光标周围边框的宽度，我们使用这个选项。该选项的默认值为 0 。 |
Tkinter 文本小部件方法:
文本小部件使用的一些方法如下:
| 方法 | 描述 |
|---|---|
index(index) |
此方法用于获取指定的索引。 |
see(index) |
此方法根据字符串在指定索引处是否可见返回 true 或 false。 |
insert(index,string) |
此方法用于在指定索引处插入字符串。 |
get(startindex,endindex) |
此方法返回指定范围内的字符 |
delete(startindex,endindex) |
此方法删除指定范围内的字符 |
标签处理的方法
主要是标签用来分别配置文本小部件的不同区域。标签基本上是给文本各个区域的名称。下面给出了一些处理标签的方法:
-
tag_config()要配置标签的属性，将使用该方法。
-
tag_add(tagname, startindex, endindex)该方法主要用于标记出现在指定索引的字符串。
-
tag_delete(tagname)这个方法主要是用来删除指定的标签。
-
tag_remove(tagname, startindex, endindex)要将标签从指定的范围中移除，使用此方法。
标记处理方法
在给定的文本小部件中，为了将书签标记到字符之间的指定位置使用了标记。下面给出了一些方法:
-
index(mark)此方法主要用于获取指定标记的索引。
-
mark_names()此方法用于获取文本小部件范围内的所有标记名称。
-
mark_gravity(mark, gravity)为了得到给定标记的重力，将使用这种方法。
-
mark_set(mark, index)此方法用于通知给定标记的新位置。
-
mark_unset(mark)为了从文本中删除给定的标记，将使用此方法。
Tkinter 文本小部件示例
让我们讨论文本小部件的一个基本示例。文本小部件示例的代码片段如下所示:
import tkinter as tk
from tkinter import *
win = Tk()
#to specify size of window.
win.geometry("250x170")
# To Create a text widget and specify size.
T = Text(win, height = 6, width = 53)
# TO Create label
l = Label(win, text = "Quote for the Day")
l.config(font =("Courier", 14))
Quote = """Success usually comes to those who are too busy to be looking for it"""
# Create a button for the next text.
b1 = Button(win, text = "Next", )
# Create an Exit button.
b2 = Button(win, text = "Exit",
command = win.destroy)
l.pack()
T.pack()
b1.pack()
b2.pack()
# Insert the Quote
T.insert(tk.END, Quote)
tk.mainloop()
上面给出的代码片段的输出如下:
如果你想破坏这个窗口，只需点击退出按钮。
总结:
在本教程中，我们学习了 Tkinter Text 小部件，当我们想要在应用中添加一个文本区域来接受大量用户输入时，会用到这个小部件。
Tkinter 消息框
在本教程中，我们将介绍如何在开发桌面应用时创建和使用 Tkinter MessageBox 。
为了在桌面应用中显示消息框，我们使用了 Tkinter 中的消息框模块。
- 该模块中存在各种功能，有助于根据的要求提供合适类型的消息。
*** 借助这个模块，我们可以创建弹出消息框，接受用户输入。
* 消息框模块的功能如下:`showError()`、`askretrycancel()`、`showwarning()`等。，所有这些都用于创建消息框。**
**## Tkinter messagebox-tkinter 信使信箱
要使用 messagebox 模块，我们首先需要在 python 脚本中导入它:
from tkinter import messagebox
下面是使用消息框的基本语法:
messagebox.function_name(title, message [, options])
在上面的语法中，我们使用了以下内容:
-
功能 _ 名称
这用于指示相应消息框函数的名称。
-
标题
这用于指示要在相应消息框的标题栏中显示的文本。
-
消息
这用于指示要在消息框中显示为消息的文本。
-
选项
它用于指示各种选项，以便配置消息框。它有两个值，分别是默认和父。
-
默认:用于指定一个默认按钮，如 ABORT、RETRY、IGNORE。
-
父级:用于指定一个窗口，我们将在该窗口的顶部显示消息框。
-
消息框模块中的功能使用相同的语法，但每个功能的功能不同。
让我们看看 Tkinter MessageBox 模块的几个功能。
Tkinter MessageBox - showwarning()
该方法用于在 Python 应用中向用户显示任何警告。
下面是相同的代码:
from tkinter import *
from tkinter import messagebox
win = Tk()
win.geometry("200x200")
messagebox.showwarning("warning","This is a Warning")
win.mainloop()
Tkinter MessageBox - askquestion()
MessageBox 中的这种方法主要用于向用户提问，可以在是或者否中回答。
此方法的代码如下:
from tkinter import *
from tkinter import messagebox
win = Tk()
win.geometry("100x100")
messagebox.askquestion("Confirm","Are you sure about it?")
win.mainloop()
Tkinter MessageBox - askretrycancel()
如果你想要求用户做任何特定的任务或者不做，那么将使用这个方法。
让我们看看相同的代码:
from tkinter import *
from tkinter import messagebox
win= Tk()
win.geometry("100x100")
messagebox.askretrycancel("Application"," wanna try again?")
win.mainloop()
Tkinter MessageBox - showerror()
要显示错误信息，将使用该方法。
让我们看看下面给出的代码片段:
from tkinter import *
from tkinter import messagebox
top = Tk()
top.geometry("100x100")
messagebox.showerror("errorWindow","oops!!!Error")
top.mainloop()
总结:
在本教程中，我们学习了不同类型的消息框，我们可以创建这些消息框来向用户显示信息或接受用户的输入，如确认任何操作等。消息框就像弹出窗口，我们可以在其中显示错误、警告等。给用户。
Tkinter 应用
Tkinter 计算器应用（Python 项目）
原文：https://www.studytonight.com/tkinter/calculator-application-using-tkinter
在本教程中，我们将介绍如何使用 Python 创建一个简单的计算器应用。
在之前的教程中，我们已经介绍了如何创建 tkinter 按钮、 tkinter 标签、 tkinter 条目、 tkinter 框架和 tkinter 检查按钮等等。现在，在前面讨论的所有小部件的帮助下，我们将使用 Tkinter 创建一个计算器应用。
下面是我们的计算器的外观，它是通过使用输入字段、按钮来实现的，为了计算的目的，我们将在函数中定义的代码中使用逻辑，例如，如果您想要将两个数字相加，那么在这之后必须有一个用于加法目的的逻辑，类似地，对于减法、乘法等，我们已经创建了任务是执行这些操作的函数。
我们有一个输入字段，其中将显示用户输入，并显示计算的最终结果。
按钮有 0、1、2、3、4、5、6、7、8、9、+、-、*、/、=、。，和 C(清除按钮)
什么是计算器？
对于那些不知道的人来说，计算器基本上是一个在计算机上的程序，它模拟任何手持计算器的行为，用于执行数学计算。它是我们日常生活中使用的一种非常基本的设备。现在所有的智能手机都有计算器应用。
创建任何图形用户界面应用主要有两个步骤:
-
第一步是创建用户界面。
-
第二步是最重要的一步，在这一步中，给图形用户界面添加功能
现在让我们从开始，使用 Python 中的 Tkinter 创建一个简单的计算器应用，用于基本算术计算。
计算器应用代码
现在是时候看看使用 Tkinter 创建计算器应用的代码了:
from tkinter import *
win = Tk() # This is to create a basic window
win.geometry("312x324") # this is for the size of the window
win.resizable(0, 0) # this is to prevent from resizing the window
win.title("Calculator")
###################Starting with functions ####################
# 'btn_click' function :
# This Function continuously updates the
# input field whenever you enter a number
def btn_click(item):
global expression
expression = expression + str(item)
input_text.set(expression)
# 'bt_clear' function :This is used to clear
# the input field
def bt_clear():
global expression
expression = ""
input_text.set("")
# 'bt_equal':This method calculates the expression
# present in input field
def bt_equal():
global expression
result = str(eval(expression)) # 'eval':This function is used to evaluates the string expression directly
input_text.set(result)
expression = ""
expression = ""
# 'StringVar()' :It is used to get the instance of input field
input_text = StringVar()
# Let us creating a frame for the input field
input_frame = Frame(win, width=312, height=50, bd=0, highlightbackground="black", highlightcolor="black", highlightthickness=2)
input_frame.pack(side=TOP)
#Let us create a input field inside the 'Frame'
input_field = Entry(input_frame, font=('arial', 18, 'bold'), textvariable=input_text, width=50, bg="#eee", bd=0, justify=RIGHT)
input_field.grid(row=0, column=0)
input_field.pack(ipady=10) # 'ipady' is internal padding to increase the height of input field
#Let us creating another 'Frame' for the button below the 'input_frame'
btns_frame = Frame(win, width=312, height=272.5, bg="grey")
btns_frame.pack()
# first row
clear = Button(btns_frame, text = "C", fg = "black", width = 32, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: bt_clear()).grid(row = 0, column = 0, columnspan = 3, padx = 1, pady = 1)
divide = Button(btns_frame, text = "/", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("/")).grid(row = 0, column = 3, padx = 1, pady = 1)
# second row
seven = Button(btns_frame, text = "7", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(7)).grid(row = 1, column = 0, padx = 1, pady = 1)
eight = Button(btns_frame, text = "8", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(8)).grid(row = 1, column = 1, padx = 1, pady = 1)
nine = Button(btns_frame, text = "9", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(9)).grid(row = 1, column = 2, padx = 1, pady = 1)
multiply = Button(btns_frame, text = "*", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("*")).grid(row = 1, column = 3, padx = 1, pady = 1)
# third row
four = Button(btns_frame, text = "4", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(4)).grid(row = 2, column = 0, padx = 1, pady = 1)
five = Button(btns_frame, text = "5", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(5)).grid(row = 2, column = 1, padx = 1, pady = 1)
six = Button(btns_frame, text = "6", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(6)).grid(row = 2, column = 2, padx = 1, pady = 1)
minus = Button(btns_frame, text = "-", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("-")).grid(row = 2, column = 3, padx = 1, pady = 1)
# fourth row
one = Button(btns_frame, text = "1", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(1)).grid(row = 3, column = 0, padx = 1, pady = 1)
two = Button(btns_frame, text = "2", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(2)).grid(row = 3, column = 1, padx = 1, pady = 1)
three = Button(btns_frame, text = "3", fg = "black", width = 10, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(3)).grid(row = 3, column = 2, padx = 1, pady = 1)
plus = Button(btns_frame, text = "+", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click("+")).grid(row = 3, column = 3, padx = 1, pady = 1)
# fourth row
zero = Button(btns_frame, text = "0", fg = "black", width = 21, height = 3, bd = 0, bg = "#fff", cursor = "hand2", command = lambda: btn_click(0)).grid(row = 4, column = 0, columnspan = 2, padx = 1, pady = 1)
point = Button(btns_frame, text = ".", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: btn_click(".")).grid(row = 4, column = 2, padx = 1, pady = 1)
equals = Button(btns_frame, text = "=", fg = "black", width = 10, height = 3, bd = 0, bg = "#eee", cursor = "hand2", command = lambda: bt_equal()).grid(row = 4, column = 3, padx = 1, pady = 1)
win.mainloop()
Tkinter 中有多种功能，在它们的帮助下变得简单和方便，只需要这个小代码就可以做一个简单的计算器。
除了 Tkinter 小部件之外，我们还在代码中定义了以下函数:
btn_click()功能:该功能处理按钮点击各种数字按钮将其添加到操作中。
bt_clear()功能:该功能用于处理清除操作，以清除计算器应用中以前的输入。
bt_equal()功能:该功能用于处理等号按钮执行操作并显示结果。
现在，我们将向您展示一个快照，作为上面代码的输出。是的，您可以在您的系统上实现它，以便更清楚地了解计算器应用使用 Tkinter:
总结:
在本教程中，我们使用 Tkinter 和 Tkinter 的各种小部件开发了一个基本的 Calculator 应用，我们已经在 Tkinter 教程中介绍了这些小部件。单击“下一步”查看更多使用 Tkinter 开发的应用，因为这将帮助您实践所学知识。
Tkinter 文本编辑器应用（Python 项目）
原文：https://www.studytonight.com/tkinter/text-editor-application-using-tkinter
在本教程中，我们将帮助您使用 Tkinter 构建一个简单的文本编辑器应用，这对于 Tkinter 来说是一个非常好的初学者项目。
文本编辑器应用是一个应用，你可以写你的文本，打开任何文本文件，你可以编辑任何文本文件，你也可以保存一个文件，如果你想。在本教程中，我们将从头开始构建一个文本编辑器应用。
文本编辑器应用的基本元素如下:
-
有一个名为
btn_open的按钮小部件 ，用于打开文件进行编辑 -
第二个是一个名为
btn_save的按钮小部件，用于保存文件 -
第三，有一个名为
txt_edit的文本小部件 ，用于创建和编辑任何文本文件。
三个小部件的排列方式是，两个按钮在窗口的左侧，文本框在右侧。整个窗口的最小高度应为 900 像素，txt_edit的最小宽度应为 900 像素。如果调整窗口大小，整个布局应该是响应的，然后txt_edit也调整大小。握住按钮的Frame的宽度不应改变。
让我们向您展示一下这个文本编辑器的大致轮廓:
文本编辑器应用的所需布局可以使用.grid()几何管理器来实现。这个布局包含一行和两列:
-
左侧有一个窄栏用于按钮
-
在右侧，文本框有一个更宽的栏
为了设置窗口和txt_edit的最小尺寸，您只需要将窗口方法.rowconfigure()和.columnconfigure()的minsize参数设置为 900 即可。为了处理尺寸调整，这些方法的weight参数将被设置为 1。
如果你希望两个按钮都在同一个列中，那么你需要创建一个名为fr_buttons的Frame部件。根据上面显示的草图，两个按钮应垂直堆叠在此框架内，顶部有btn_open。这可以由.grid()或.pack()几何经理完成。现在，您只需要坚持使用.grid()，因为使用它更容易。
让我们从构建应用的代码开始:
1.创建所有需要的小部件
使用的代码片段如下:
import tkinter as tk
window = tk.Tk()
window.title("Text Editor Application")
window.rowconfigure(0, minsize=900, weight=1)
window.columnconfigure(1, minsize=900, weight=1)
txt_edit = tk.Text(window)
fr_buttons = tk.Frame(window)
btn_open = tk.Button(fr_buttons, text="Open")
btn_save = tk.Button(fr_buttons, text="Save As...")
上述代码的解释:
-
第一个命令用于导入
tkinter。 -
然后接下来的两行用来创建一个标题为
"Text Editor Application"的新窗口。 -
接下来的两行代码用于设置行和列配置。
-
然后从 9 到 12 的行将为文本框、框架以及打开和保存按钮创建您需要的四个小部件。
window.rowconfigure(0, minsize=900, weight=1)
代码中的上一行表示.rowconfigure()的minsize参数设置为900、weight设置为1.第一个参数为0，用于将第一行的高度设置为900像素，并确保该行的高度与窗口的高度成比例增长。应用布局中只有一行，因此这些设置应用于整个窗口。
然后看看代码中的这一行:
window.columnconfigure(1, minsize=900, weight=1)
在上面的代码中.columnconfigure()将索引为1的列的width和weight属性分别设置为900和1。请记住，行和列索引是从零开始的，因此这些设置仅适用于第二列。通过配置第二列，当调整窗口大小时，文本框将自然展开和收缩，而包含按钮的列将始终保持固定宽度。
2.创建应用布局
btn_open.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
btn_save.grid(row=1, column=0, sticky="ew", padx=5)
以上两行代码将创建一个网格，在fr_buttons框架中有两行一列，因为btn_open和btn_save都将其master属性设置为fr_buttons。btn_open放在第一排，btn_save放在第二排，这样布局中btn_open出现在btn_save上方，如上图所示。
-
btn_open和btn_save都将其sticky属性设置为"ew"，这将强制按钮在两个方向上水平扩展，以便填充整个框架。它确保两个按钮大小相同。 -
只需将
padx和pady参数设置为 5，即可在每个按钮周围放置 5 像素的填充。btn_open有垂直衬垫。因为它在顶部，垂直填充使按钮从窗口顶部向下偏移一点，并确保这和btn_save之间有一个小间隙。
现在fr_buttons已经布局好了，可以开始了，现在可以为窗口的其余部分设置网格布局了:
fr_buttons.grid(row=0, column=0, sticky="ns")
txt_edit.grid(row=0, column=1, sticky="nsew")
以上两行代码用于为window创建一行两列的网格。您可以将fr_buttons放在第一列，将txt_edit放在第二列，这样fr_buttons就会出现在窗口布局中txt_edit的左侧。
fr_buttons的sticky参数将被设置为"ns"，这将迫使整个框架垂直扩展，并填充其柱的整个高度。txt_edit用于填充整个网格单元，因为您将其sticky参数设置为"nsew"，这将迫使其向各个方向扩展。
**现在我们刚刚创建了按钮，但是这些按钮在我们添加功能之前不会工作，所以让我们开始添加按钮的功能:
1.打开文件的功能
open_file 的代码片段如下:
def open_file():
"""Open a file for editing."""
filepath = askopenfilename(
filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")]
)
if not filepath:
return
txt_edit.delete(1.0, tk.END)
with open(filepath, "r") as input_file:
text = input_file.read()
txt_edit.insert(tk.END, text)
window.title(f"Text Editor Application - {filepath}")
解释:
-
第 3 行至第 5 行使用
tkinter.filedialog模块的askopenfilename对话框显示文件打开对话框，并将选择的文件路径存储至filepath。 -
第 6 行和第 7 行检查用户是否关闭对话框或点击取消按钮。如果是，那么
filepath将是None，函数将是return，不执行任何代码来读取文件和设置txt_edit的文本。 -
第 8 行使用
.delete()清除txt_edit当前内容。 -
第 9 行和第 10 行用于在将
text存储为字符串之前打开所选文件及其内容。 -
第 11 行使用
.insert()将字符串text分配给txt_edit。 -
第 12 行设置窗口标题，使其包含打开文件的路径。
2.保存文件的功能
save_file 的代码片段如下:
def save_file():
"""Save the current file as a new file."""
filepath = asksaveasfilename(
defaultextension="txt",
filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
)
if not filepath:
return
with open(filepath, "w") as output_file:
text = txt_edit.get(1.0, tk.END)
output_file.write(text)
window.title(f"Text Editor Application - {filepath}")
解释:
-
第 3 行至第 6 行使用
asksaveasfilename对话框从用户处获取所需的保存位置。选择的文件路径存储在filepath变量中。 -
第 7 行和第 8 行检查用户是否关闭对话框或点击取消按钮。如果是，那么
filepath将是None，该函数将返回，而不执行任何将文本保存到文件中的代码。 -
第 9 行在选定的文件路径创建一个新文件。
-
第 10 行使用
.get()方法从txt_edit中提取文本，并将其分配给变量text。 -
第 11 行将
text写入输出文件。 -
第 12 行更新窗口标题，使新文件路径显示在窗口标题中。
完整源代码为:
import tkinter as tk
from tkinter.filedialog import askopenfilename, asksaveasfilename
def open_file():
"""Open a file for editing."""
filepath = askopenfilename(
filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")]
)
if not filepath:
return
txt_edit.delete(1.0, tk.END)
with open(filepath, "r") as input_file:
text = input_file.read()
txt_edit.insert(tk.END, text)
window.title(f"Text Editor Application - {filepath}")
def save_file():
"""Save the current file as a new file."""
filepath = asksaveasfilename(
defaultextension="txt",
filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
)
if not filepath:
return
with open(filepath, "w") as output_file:
text = txt_edit.get(1.0, tk.END)
output_file.write(text)
window.title(f"Text Editor Application - {filepath}")
window = tk.Tk()
window.title("Text Editor Application")
window.rowconfigure(0, minsize=800, weight=1)
window.columnconfigure(1, minsize=800, weight=1)
txt_edit = tk.Text(window)
fr_buttons = tk.Frame(window, relief=tk.RAISED, bd=2)
btn_open = tk.Button(fr_buttons, text="Open", command=open_file)
btn_save = tk.Button(fr_buttons, text="Save As...", command=save_file)
btn_open.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
btn_save.grid(row=1, column=0, sticky="ew", padx=5)
fr_buttons.grid(row=0, column=0, sticky="ns")
txt_edit.grid(row=0, column=1, sticky="nsew")
window.mainloop()
正如你在输出中看到的，我们有一个基本的文本编辑器应用，在其中我们可以写一些东西，然后将文本保存在一个新的文件中，或者使用打开按钮在编辑器中打开一个文件然后编辑它。
Tkinter 音乐播放器应用（Python 项目）
原文：https://www.studytonight.com/tkinter/music-player-application-using-tkinter
在本教程中，我们将使用 Tkinter 和 Pygame 模块用 Python 创建一个音乐播放器应用。
在我们的日常生活中，我们看到每个人都有一个爱好，那就是听音乐。所以为了听音乐，他们都需要一个音乐播放器(硬件或软件)，可以播放自己喜欢的歌曲。我们必须在我们的电脑上安装这个音乐播放器，基于操作系统，即视窗、麦金塔、安卓、Linux 等。然后我们可以听我们喜欢的歌。
现在我们将帮助您从头开始编码和创建音乐播放器。
用于音乐播放器应用的库:
现在，我们将告诉您我们将在代码中使用的库:
1.Tkinter
我们已经在这个页面的标题中告诉过您，我们将使用 Tkinter 库，这是一个用于 GUI 创建的标准库。Tkinter 库是最受欢迎的，也非常容易使用，它附带了许多小部件(这些小部件有助于创建好看的图形用户界面应用)。
此外，Tkinter 是一个非常轻量级的模块，它有助于创建跨平台应用(因此相同的代码可以轻松地在 Windows 、 macOS 和 Linux 上工作)
To use all the functions of Tkinter you need to import it in your code and the command for the same is:
from tkinter import *
2.Pygame 模组
Pygame 是一个 Python 模块，可与计算机图形和声音库一起工作，设计时具有播放音频、视频等不同多媒体格式的能力。在创建我们的音乐播放器应用时，我们将使用 Pygame 的mixer.music模块为我们的音乐播放器应用提供不同的功能，这些功能通常与歌曲轨道的操作有关。
用于安装 pygame 模块的命令是:
pip install pygame
要在代码中使用该模块，您需要编写以下内容:
import pygame
3。操作系统模块
没有必要显式安装这个模块，因为它附带了 Python 的标准库。该模块提供了与操作系统交互的不同功能。在本教程中，我们将使用操作系统模块从指定目录中获取歌曲播放列表，并将其提供给音乐播放器应用。
要在代码中使用此模块，您需要导入其和命令，如下所示:
import OS
导入库和模块后，现在是时候创建一个基本窗口，我们将在其中添加我们的用户界面元素或 Tkinter 小部件。您可以在导入库之后，也可以在根窗口循环之前的末尾添加此代码，代码如下:
root = Tk() # In order to create an empty window
# Passing Root to MusicPlayer Class
MusicPlayer(root)
音乐播放器类
这里我们有在 MusicPlayer 类中定义的构造器和其他函数。
1._init_建造师
在这个构造器的帮助下，我们将为窗口设置标题，为窗口设置几何图形。我们将启动 pygame 和 pygame 混合器，然后声明轨迹变量和状态变量。
-
然后我们将为歌曲标签** & 状态标签创建轨道帧**，然后在插入歌曲轨道标签和状态标签之后。
-
之后，我们将创建按钮框和将播放、暂停、取消播放和停止按钮插入其中。
-
然后我们将创建播放列表框****并在其中添加滚动条，我们将向播放列表中添加歌曲。
代码片段如下:
def __init__(self,root):
self.root = root
# Title of the window
self.root.title("MusicPlayer")
# Window Geometry
self.root.geometry("1000x200+200+200")
# Initiating Pygame
pygame.init()
# Initiating Pygame Mixer
pygame.mixer.init()
# Declaring track Variable
self.track = StringVar()
# Declaring Status Variable
self.status = StringVar()
# Creating the Track Frames for Song label & status label
trackframe = LabelFrame(self.root,text="Song Track",font=("times new roman",15,"bold"),bg="Navyblue",fg="white",bd=5,relief=GROOVE)
trackframe.place(x=0,y=0,width=600,height=100)
# Inserting Song Track Label
songtrack = Label(trackframe,textvariable=self.track,width=20,font=("times new roman",24,"bold"),bg="Orange",fg="gold").grid(row=0,column=0,padx=10,pady=5)
# Inserting Status Label
trackstatus = Label(trackframe,textvariable=self.status,font=("times new roman",24,"bold"),bg="orange",fg="gold").grid(row=0,column=1,padx=10,pady=5)
# Creating Button Frame
buttonframe = LabelFrame(self.root,text="Control Panel",font=("times new roman",15,"bold"),bg="grey",fg="white",bd=5,relief=GROOVE)
buttonframe.place(x=0,y=100,width=600,height=100)
# Inserting Play Button
playbtn = Button(buttonframe,text="PLAYSONG",command=self.playsong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=0,padx=10,pady=5)
# Inserting Pause Button
playbtn = Button(buttonframe,text="PAUSE",command=self.pausesong,width=8,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=1,padx=10,pady=5)
# Inserting Unpause Button
playbtn = Button(buttonframe,text="UNPAUSE",command=self.unpausesong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=2,padx=10,pady=5)
# Inserting Stop Button
playbtn = Button(buttonframe,text="STOPSONG",command=self.stopsong,width=10,height=1,font=("times new roman",16,"bold"),fg="navyblue",bg="pink").grid(row=0,column=3,padx=10,pady=5)
# Creating Playlist Frame
songsframe = LabelFrame(self.root,text="Song Playlist",font=("times new roman",15,"bold"),bg="grey",fg="white",bd=5,relief=GROOVE)
songsframe.place(x=600,y=0,width=400,height=200)
# Inserting scrollbar
scrol_y = Scrollbar(songsframe,orient=VERTICAL)
# Inserting Playlist listbox
self.playlist = Listbox(songsframe,yscrollcommand=scrol_y.set,selectbackground="gold",selectmode=SINGLE,font=("times new roman",12,"bold"),bg="silver",fg="navyblue",bd=5,relief=GROOVE)
# Applying Scrollbar to listbox
scrol_y.pack(side=RIGHT,fill=Y)
scrol_y.config(command=self.playlist.yview)
self.playlist.pack(fill=BOTH)
# Changing Directory for fetching Songs
os.chdir("PATH/OF/DIRECTORY")
# Fetching Songs
songtracks = os.listdir()
# Inserting Songs into Playlist
for track in songtracks:
self.playlist.insert(END,track)
在上面的代码中，用存储歌曲文件的适当路径更改路径/OF/DIRECTORY 。
2.playsong()功能
现在我们将定义播放歌曲功能，代码为:
def playsong(self):
# Displaying Selected Song title
self.track.set(self.playlist.get(ACTIVE))
# Displaying Status
self.status.set("-Playing")
# Loading Selected Song
pygame.mixer.music.load(self.playlist.get(ACTIVE))
# Playing Selected Song
pygame.mixer.music.play()
3.stopsong()功能
停止歌曲的代码片段:
def stopsong(self):
# Displaying Status
self.status.set("-Stopped")
# Stopped Song
pygame.mixer.music.stop()
4.pausesong()功能
暂停歌曲的代码片段:
def pausesong(self):
# Displaying Status
self.status.set("-Paused")
# Paused Song
pygame.mixer.music.pause()
5.unpausesong()功能
解包歌曲的代码片段:
def unpausesong(self):
# It will Display the Status
self.status.set("-Playing")
# Playing back Song
pygame.mixer.music.unpause()
6.根窗口循环
该命令将是:
root.mainloop()
下面是我们应用的一些截图:
名为 study 的文件夹今晚放置歌曲的代码文件和文件夹如下所示:
我们将在代码中提供歌曲文件夹的路径，所有歌曲都放在该文件夹中，以便访问它们。
下面的截图向您展示了应用的外观:
每当你点击歌曲时，它会是这样的:
点击播放歌曲按钮:
点击暂停按钮:
点击停止按钮:
所以这都是关于使用 Tkinter 构建音乐播放器应用。希望大家喜欢这个应用。请与我们分享更多关于基于 Tkinter 的桌面应用的想法，我们一定会在我们的 Tkinter 教程中添加更多的 Tkinter 项目。
Tkinter 打砖块游戏（Python 项目）
原文：https://www.studytonight.com/tkinter/brick-breaker-game-using-tkinter-python-project
是时候用 Python 编写一个游戏了。我们将从一个简单的打砖块游戏开始，在这个游戏中，有一个球从一个平台反弹回来打破砖墙，玩家必须通过确保球拍始终在那里将球反弹回来来保持球的前进。
游戏将有三层砖块，每层砖块的命中能力不同，这意味着一些砖块会在单次命中时破碎，一些会要求双次命中，一些会要求三次命中。
为了简化游戏的逻辑和用户界面，下面是砖块的类型:
青砖:需要三击才能破
粉色砖块:需要两击才能破
紫砖:需要三击才能破
先决条件:
要理解 Python 中构建砖块断路器游戏的代码，您应该知道以下概念:
除此之外，还需要对 Python 有全面的了解，这也可以从我们的免费教程系列中获得 学习 Python 。
打砖块游戏的代码
我们将在代码中创建 5 个类，类的名称是:
-
游戏对象
-
球
-
涉水
-
砖
-
比赛
所有这些类都有方法在各自的游戏元素上执行各种处理和操作。
让我们看看每个类的代码。
游戏对象类
这个类是所有其他类的父类，这意味着所有其他类都将继承这个类。
这个类的代码如下:
class GameObject(object):
def __init__(self, canvas, item):
self.canvas = canvas
self.item = item
def get_position(self):
return self.canvas.coords(self.item)
def move(self, x, y):
self.canvas.move(self.item, x, y)
def delete(self):
self.canvas.delete(self.item)
这个类具有处理构成游戏的不同对象的基本生命周期的功能。
球类
下面是 Ball 类的代码:
class Ball(GameObject):
def __init__(self, canvas, x, y):
self.radius = 10
self.direction = [1, -1]
# increase the below value to increase the speed of ball
self.speed = 5
item = canvas.create_oval(x-self.radius, y-self.radius,
x+self.radius, y+self.radius,
fill='white')
super(Ball, self).__init__(canvas, item)
def update(self):
coords = self.get_position()
width = self.canvas.winfo_width()
if coords[0] <= 0 or coords[2] >= width:
self.direction[0] *= -1
if coords[1] <= 0:
self.direction[1] *= -1
x = self.direction[0] * self.speed
y = self.direction[1] * self.speed
self.move(x, y)
def collide(self, game_objects):
coords = self.get_position()
x = (coords[0] + coords[2]) * 0.5
if len(game_objects) > 1:
self.direction[1] *= -1
elif len(game_objects) == 1:
game_object = game_objects[0]
coords = game_object.get_position()
if x > coords[2]:
self.direction[0] = 1
elif x < coords[0]:
self.direction[0] = -1
else:
self.direction[1] *= -1
for game_object in game_objects:
if isinstance(game_object, Brick):
game_object.hit()
在球类中，collide()方法用于处理碰撞，并在游戏类的 check _ conflicts()函数中使用。而update()功能是在失去生命后重置球对象，游戏重新开始。
桨类
以下是 Paddle 类的代码:
class Paddle(GameObject):
def __init__(self, canvas, x, y):
# set the shape and position of paddle
self.width = 80
self.height = 10
self.ball = None
item = canvas.create_rectangle(x - self.width / 2,
y - self.height / 2,
x + self.width / 2,
y + self.height / 2,
fill='#FFB643')
super(Paddle, self).__init__(canvas, item)
def set_ball(self, ball):
self.ball = ball
def move(self, offset):
coords = self.get_position()
width = self.canvas.winfo_width()
if coords[0] + offset >= 0 and coords[2] + offset <= width:
super(Paddle, self).move(offset, 0)
if self.ball is not None:
self.ball.move(offset, 0)
除了构造器之外，这个类中的move()方法也很重要，因为可以使桨运动。
砖块类
下面是 Brick 类的代码:
class Brick(GameObject):
COLORS = {1: '#4535AA', 2: '#ED639E', 3: '#8FE1A2'}
def __init__(self, canvas, x, y, hits):
self.width = 75
self.height = 20
self.hits = hits
color = Brick.COLORS[hits]
item = canvas.create_rectangle(x - self.width / 2,
y - self.height / 2,
x + self.width / 2,
y + self.height / 2,
fill=color, tags='brick')
super(Brick, self).__init__(canvas, item)
def hit(self):
self.hits -= 1
if self.hits == 0:
self.delete()
else:
self.canvas.itemconfig(self.item,
fill=Brick.COLORS[self.hits])
我们通过设置不同砖块类型的颜色来开始类定义。然后在构造器中，定义砖块的大小和位置。然后是hit()功能，处理砖块是会消失还是会承受打击，改变颜色承受下一次打击。
游戏课
这是控制一切的主类。下面是代码:
class Game(tk.Frame):
def __init__(self, master):
super(Game, self).__init__(master)
self.lives = 3
self.width = 610
self.height = 400
self.canvas = tk.Canvas(self, bg='#D6D1F5',
width=self.width,
height=self.height,)
self.canvas.pack()
self.pack()
self.items = {}
self.ball = None
self.paddle = Paddle(self.canvas, self.width/2, 326)
self.items[self.paddle.item] = self.paddle
# adding brick with different hit capacities - 3,2 and 1
for x in range(5, self.width - 5, 75):
self.add_brick(x + 37.5, 50, 3)
self.add_brick(x + 37.5, 70, 2)
self.add_brick(x + 37.5, 90, 1)
self.hud = None
self.setup_game()
self.canvas.focus_set()
self.canvas.bind('<Left>',
lambda _: self.paddle.move(-10))
self.canvas.bind('<Right>',
lambda _: self.paddle.move(10))
def setup_game(self):
self.add_ball()
self.update_lives_text()
self.text = self.draw_text(300, 200,
'Press Space to start')
self.canvas.bind('<space>', lambda _: self.start_game())
def add_ball(self):
if self.ball is not None:
self.ball.delete()
paddle_coords = self.paddle.get_position()
x = (paddle_coords[0] + paddle_coords[2]) * 0.5
self.ball = Ball(self.canvas, x, 310)
self.paddle.set_ball(self.ball)
def add_brick(self, x, y, hits):
brick = Brick(self.canvas, x, y, hits)
self.items[brick.item] = brick
def draw_text(self, x, y, text, size='40'):
font = ('Forte', size)
return self.canvas.create_text(x, y, text=text,
font=font)
def update_lives_text(self):
text = 'Lives: %s' % self.lives
if self.hud is None:
self.hud = self.draw_text(50, 20, text, 15)
else:
self.canvas.itemconfig(self.hud, text=text)
def start_game(self):
self.canvas.unbind('<space>')
self.canvas.delete(self.text)
self.paddle.ball = None
self.game_loop()
def game_loop(self):
self.check_collisions()
num_bricks = len(self.canvas.find_withtag('brick'))
if num_bricks == 0:
self.ball.speed = None
self.draw_text(300, 200, 'You win! You the Breaker of Bricks.')
elif self.ball.get_position()[3] >= self.height:
self.ball.speed = None
self.lives -= 1
if self.lives < 0:
self.draw_text(300, 200, 'You Lose! Game Over!')
else:
self.after(1000, self.setup_game)
else:
self.ball.update()
self.after(50, self.game_loop)
def check_collisions(self):
ball_coords = self.ball.get_position()
items = self.canvas.find_overlapping(*ball_coords)
objects = [self.items[x] for x in items if x in self.items]
self.ball.collide(objects)
在本课中，我们有以下内容:
-
我们定义了生命的数量，游戏的背景颜色，以及游戏窗口的其他样式。
-
游戏设置由这个类完成。
-
添加砖块，添加桨，球和文本是由这个类完成的。
-
对生活的处理由这个班负责。
-
开始游戏和运行游戏循环，也是在这堂课上完成的。
打砖块游戏的完整代码:
这是游戏的完整代码。
import tkinter as tk
class GameObject(object):
def __init__(self, canvas, item):
self.canvas = canvas
self.item = item
def get_position(self):
return self.canvas.coords(self.item)
def move(self, x, y):
self.canvas.move(self.item, x, y)
def delete(self):
self.canvas.delete(self.item)
class Ball(GameObject):
def __init__(self, canvas, x, y):
self.radius = 10
self.direction = [1, -1]
# increase the below value to increase the speed of ball
self.speed = 5
item = canvas.create_oval(x-self.radius, y-self.radius,
x+self.radius, y+self.radius,
fill='white')
super(Ball, self).__init__(canvas, item)
def update(self):
coords = self.get_position()
width = self.canvas.winfo_width()
if coords[0] <= 0 or coords[2] >= width:
self.direction[0] *= -1
if coords[1] <= 0:
self.direction[1] *= -1
x = self.direction[0] * self.speed
y = self.direction[1] * self.speed
self.move(x, y)
def collide(self, game_objects):
coords = self.get_position()
x = (coords[0] + coords[2]) * 0.5
if len(game_objects) > 1:
self.direction[1] *= -1
elif len(game_objects) == 1:
game_object = game_objects[0]
coords = game_object.get_position()
if x > coords[2]:
self.direction[0] = 1
elif x < coords[0]:
self.direction[0] = -1
else:
self.direction[1] *= -1
for game_object in game_objects:
if isinstance(game_object, Brick):
game_object.hit()
class Paddle(GameObject):
def __init__(self, canvas, x, y):
self.width = 80
self.height = 10
self.ball = None
item = canvas.create_rectangle(x - self.width / 2,
y - self.height / 2,
x + self.width / 2,
y + self.height / 2,
fill='#FFB643')
super(Paddle, self).__init__(canvas, item)
def set_ball(self, ball):
self.ball = ball
def move(self, offset):
coords = self.get_position()
width = self.canvas.winfo_width()
if coords[0] + offset >= 0 and coords[2] + offset <= width:
super(Paddle, self).move(offset, 0)
if self.ball is not None:
self.ball.move(offset, 0)
class Brick(GameObject):
COLORS = {1: '#4535AA', 2: '#ED639E', 3: '#8FE1A2'}
def __init__(self, canvas, x, y, hits):
self.width = 75
self.height = 20
self.hits = hits
color = Brick.COLORS[hits]
item = canvas.create_rectangle(x - self.width / 2,
y - self.height / 2,
x + self.width / 2,
y + self.height / 2,
fill=color, tags='brick')
super(Brick, self).__init__(canvas, item)
def hit(self):
self.hits -= 1
if self.hits == 0:
self.delete()
else:
self.canvas.itemconfig(self.item,
fill=Brick.COLORS[self.hits])
class Game(tk.Frame):
def __init__(self, master):
super(Game, self).__init__(master)
self.lives = 3
self.width = 610
self.height = 400
self.canvas = tk.Canvas(self, bg='#D6D1F5',
width=self.width,
height=self.height,)
self.canvas.pack()
self.pack()
self.items = {}
self.ball = None
self.paddle = Paddle(self.canvas, self.width/2, 326)
self.items[self.paddle.item] = self.paddle
# adding brick with different hit capacities - 3,2 and 1
for x in range(5, self.width - 5, 75):
self.add_brick(x + 37.5, 50, 3)
self.add_brick(x + 37.5, 70, 2)
self.add_brick(x + 37.5, 90, 1)
self.hud = None
self.setup_game()
self.canvas.focus_set()
self.canvas.bind('<Left>',
lambda _: self.paddle.move(-10))
self.canvas.bind('<Right>',
lambda _: self.paddle.move(10))
def setup_game(self):
self.add_ball()
self.update_lives_text()
self.text = self.draw_text(300, 200,
'Press Space to start')
self.canvas.bind('<space>', lambda _: self.start_game())
def add_ball(self):
if self.ball is not None:
self.ball.delete()
paddle_coords = self.paddle.get_position()
x = (paddle_coords[0] + paddle_coords[2]) * 0.5
self.ball = Ball(self.canvas, x, 310)
self.paddle.set_ball(self.ball)
def add_brick(self, x, y, hits):
brick = Brick(self.canvas, x, y, hits)
self.items[brick.item] = brick
def draw_text(self, x, y, text, size='40'):
font = ('Forte', size)
return self.canvas.create_text(x, y, text=text,
font=font)
def update_lives_text(self):
text = 'Lives: %s' % self.lives
if self.hud is None:
self.hud = self.draw_text(50, 20, text, 15)
else:
self.canvas.itemconfig(self.hud, text=text)
def start_game(self):
self.canvas.unbind('<space>')
self.canvas.delete(self.text)
self.paddle.ball = None
self.game_loop()
def game_loop(self):
self.check_collisions()
num_bricks = len(self.canvas.find_withtag('brick'))
if num_bricks == 0:
self.ball.speed = None
self.draw_text(300, 200, 'You win! You the Breaker of Bricks.')
elif self.ball.get_position()[3] >= self.height:
self.ball.speed = None
self.lives -= 1
if self.lives < 0:
self.draw_text(300, 200, 'You Lose! Game Over!')
else:
self.after(1000, self.setup_game)
else:
self.ball.update()
self.after(50, self.game_loop)
def check_collisions(self):
ball_coords = self.ball.get_position()
items = self.canvas.find_overlapping(*ball_coords)
objects = [self.items[x] for x in items if x in self.items]
self.ball.collide(objects)
if __name__ == '__main__':
root = tk.Tk()
root.title('Break those Bricks!')
game = Game(root)
game.mainloop()
要运行游戏，您必须安装 Tkinter 模块。将上面给出的代码保存在一个有名字的文件中，比如说碎砖工. py 文件。然后要运行代码，请执行以下命令:
python brick-breaker.py
打砖块游戏界面:
以下是游戏外观的一些快照。
当玩家赢得游戏时:
当玩家输掉游戏时:
至此，本教程结束。希望游戏对你来说没问题。我们建议您编辑和定制代码，使游戏更好。尝试为游戏添加更多功能。
Pandas
Pandas 介绍
Pandas 的特性
我们都知道 Pandas 是一个很棒的库。但是为什么它和其他库有这么大的不同呢？它的 USP 是什么？一个人到底该不该学？这是每个初学者都会想到的几个问题。别担心，因为我们已经决定治好你的头痛，并且已经做了所有的艰苦工作。
我们为您带来了 Pandas 的顶级特色，使它成为一个伟大的库。这些是综合要点，将解释在开始 Pandas 之前需要知道的事情。
Pandas 的特点使其不可或缺:
为了能够利用像 Pandas 库这样多功能的东西的真正力量，人们应该知道以下特征。
1.出色的数据处理能力:
Pandas 库为用户提供了系列和数据帧，这两种数据帧都是管理和探索数据的高效快捷方式。它们还帮助我们高效地表示我们的数据，允许我们以各种方式操纵它。这个特性使得 Pandas 对数据科学家来说非常高效。
2.丢失数据的处理:
数据往往很复杂，很难破译。但这只是开始。数据未经处理的特性会产生许多问题，其中之一就是频繁出现缺失值和数据。正确处理所有缺失的值非常重要，否则它们会污染我们研究的最终结果。
Pandas 把丢失数据的处理集成到了它的库中，它的一些特性你已经在前面介绍过了。
3.索引和对齐:
你可能有很多数据，但是当你不知道这些数据描述了什么或者它们实际属于哪里的时候，所有的数据都是无用的。因此，给数据贴上标签至关重要。另一个重要的注意事项是保持有序。如果组织做得不正确，数据将无法读取。
Pandas 有几种独特的方法来索引和排列它的数据，这照顾到组织和标记数据的需要。
4.输入和输出工具:
Pandas 为你提供各种内置的工具，帮助你读写数据。当您试图理解您的数据时，您显然必须将其写入数据库、数据结构、web 服务等。也从这些来源阅读它们。Pandas 内置的工具让这些任务变得非常简单。
5.数据清理:
就像我们讨论过的，数据可能是未经处理的。这通常会使它变得极其掺假，对这种未经处理的数据进行任何研究或分析都会导致与现实相去甚远的结果。因此，清理我们的数据非常重要，Pandas 为我们提供了这一功能。
它们有助于使我们的代码更干净，数据也足够干净，人眼可以看到正在发生的事情。更清晰的数据带来更好的结果。
6.支持多种文件格式:
现在有各种不同的文件格式，其中存在数据。因此，有能够读取和分析不同文件格式的库变得很重要。Pandas 在支持的文件格式数量上远远落后于它的同类。Pandas 可以支持 JSON、CSV、HDF5、Excel。这是 Pandas 最大的卖点之一。
7.时间序列的多个特征:
如果你是一个初学者，这个特性现在对你来说可能没有完全的意义，但是在未来的日子里你会喜欢它的。这组功能还包括频率转换和移动窗口统计。随着我们对 Pandas 的了解越来越多，我们会意识到这些特性对从事数据科学工作的人来说有多重要。
8.连接和合并数据集:
当我们分析数据时，经常需要连接和合并不同的数据集，以创建最终的数据集进行分析。为此需要一个健壮的系统，因为如果数据集没有正确地连接或合并，我们的结果会受到影响，这是不好的。
Pandas 在合并各种数据集方面效率极高。
9.对 Python 的支持:
这个功能只是消除了 Pandas 的任何反对意见。Python 拥有令人难以置信的强大库，已经成为数据科学家使用的主要编程语言之一。
Pandas 可以成为 Python 的一部分，并让我们访问其他有用的库，如 MatPlotLib 和 NumPy。
10.最佳性能:
任何与 Pandas 有过广泛合作的人都可以证明，它确实快速、高效，适合数据科学家。Pandas 的代码是用 Python 或 C 写的，这使得它速度快，响应速度极快。
11.数据分组:
在根据您的需求对数据进行分离之后，有必要具备对数据进行分组的能力。
Pandas 有各种各样的特征，其中之一是 GroupBy ，它可以帮助你根据你给出的标准将数据分成选定的类别。这个函数分割数据并在其上实现给定的函数。然后，它组合结果。
12.数据可视化:
数据科学的一大部分是数据的可视化。这使得这项研究的结果对正常人来说是可以理解的。
Pandas 提供内置的能力，帮助你绘制数据和分析不同类型的图表。如果没有可视化，任何数据分析几乎对任何人都没有意义。
13.数据是唯一的:
在未处理的数据中，有很多重复。因此，我们必须只分析那些具有独特价值的数据。
Pandas 为我们提供了这个功能，让我们看到数据集中所有独特的值。这个函数是dataset.column.unique()，其中关键字列和数据集分别是你的列和数据集的名称。
14.屏蔽数据:
我们的数据集中总是存在不必要的数据，而我们并不需要这些数据。因此，过滤这些我们不想要的数据是非常重要的。Pandas 提供的屏蔽功能可以帮助我们准确地处理数据，因为它可以将任何符合我们给定排除标准的数据转换成丢失的数据。
15.数学运算:
Pandas 有一个名为 apply 的功能，它允许用户对他们的数据进行各种数学运算。这有很大的帮助，因为一个人的数据集的顺序可能正确，也可能不正确。这由一个简单的数学运算来解决。
结论:
这篇文章已经涵盖了 Pandas 的核心特性，使它如此动态，使用起来令人惊叹。我们希望这有助于消除你心中对 Pandas 的任何疑虑。如果你还有任何疑问，请在下面的评论区继续提问。
Pandas 在数据科学产业中的应用
原文：https://www.studytonight.com/pandas/application-of-pandas-in-data-science-industry
在生活中做任何事情时，拥有知识和知道何时、何地以及如何使用这些知识一样重要。一个具体的知识应用的想法是使你擅长任何事情的关键。在本教程中，我们列出了 Pandas 可以应用的不同领域，以及现实世界中你会发现自己使用 Pandas 的各个地方。这个列表将帮助你确定不同的行业和他们的部门，你可以申请 Pandas。我们开始吧。
Pandas 的不同应用
这份清单将涵盖相当多的行业和 Pandas 应用的领域。
1.在线平台上的推荐系统:
在网飞或 Spotify 等任何媒体频道上播放流媒体时，我们对这些网站提供的几乎总是贴近内心的推荐感到惊讶。这一切背后的魔力是深度学习。
有各种模型集，它们考虑到不同的标准并提供建议。这些系统是 Pandas 最广泛的应用之一。在大多数情况下，模型是用 python 编码的，当您在这些模型中处理过这样的数据时，pandas 是最好的库。
Pandas可以处理大量数据，这有助于它了解构建一个好的推荐系统所需的数据量。像mapping和GroupBy这样的功能有助于使这些推荐系统可行。
2.经济学:
数据分析是经济学不变的需求，因为它总是在变化。需要对数据进行分析，以创建模式和趋势，然后对这些模式和趋势进行分析和解释，以了解各个部门的经济状况，这对经济学家来说极其重要。
许多现代经济学家已经开始研究 Pandas 和 Python 来处理庞大的数据集，而 T2 解释了这些数据。Pandas 有大量的内置工具和功能，使它成为高效的软件包。
像文件处理和数据帧这样的工具对于访问数据和操纵数据以获得我们想要的结果非常有用。Pandas 的这些应用帮助世界各地的经济学家取得了他们以前无法做到的突破和研究。
3.神经科学:
自古以来，了解我们的大脑(以及整个神经系统)是如何工作的一直是医生们未能实现的愿望，因为他们相信这将有助于发现我们身体所拥有的许多奥秘的答案。
机器学习在 Pandas 众多应用的推动下，对这个领域帮助很大。Pandas 巨大的数据处理能力再次发挥了巨大的作用。他们帮助汇编了大量数据，并对其进行了分析，产生了对神经科学家来说相当重要的结果。
4.股票预测:
世界上很少有东西像股票市场一样波动。这确实是世界上最大的数据集之一。虽然预测股市的变化几乎是不可能的，但是在 Pandas 的正确应用和 MatPlotLib 和 NumPy 等少数库的帮助下，你可以很容易地制作出可以预测(在很大程度上)股市结果的模型。
这是可能的，因为我们有大量的关于股票先前行为的数据，这些数据告诉系统它们的行为是相互独立的。通过学习这些行为和动作，一个好的模型将能够相当准确地预测你的下一步应该是什么。
5.广告:
随着 21 世纪的到来，没有一个领域比市场营销更进步了。广告变得越来越个性化。这一变化再次受到深度学习和机器学习的推动。
6.统计分析:
统计本身意味着处理大量的数据。因此，像 Pandas 这样的库能够以各种方式提供帮助，因为它基本上处理各种形式的数据处理及其功能。均值、中值和模式的基本功能在基于统计执行计算时非常有用。Pandas 还有很多其他的功能可以帮助你在统计中获得更好的结果。
7.自然语言处理:
现在一个非常常见的流行语，自然语言处理，或者说自然语言处理，已经以一种时尚的方式向世界宣告了它的到来。这个概念的主要目的是帮助计算机理解正常的人类语言和它所具有的各种细微差别。这是一个相当难完成的任务，但是有 Pandas 和 Scikit-Learn 一起为您服务，您可以为 NLP 创建一个基本模型，稍后您可以增强它。您可以使用各种函数和其他库来帮助您。
8.分析:
分析无处不在。无论你想分析一个网站还是分析任何其他平台，Pandas 都可以帮助你做到这一切。其高效的数据处理能力和动态数据操作，加上其惊人的可视化能力，在帮助 it 在这一领域占据优势方面发挥了巨大作用。
9.数据科学:
我们讨论的大多数例子都是数据科学的一部分。它是一个巨大的保护伞，涵盖了数据分析、处理和操纵的所有领域。因此，几乎所有 Pandas 的申请都属于它。
10.大数据:
Python 与 Spark 和 Hadoop 有很好的联系。因此 Pandas 也可以使用大数据。
结论:
我们希望通过阅读上面给出的例子，你现在已经了解了 Pandas 可以应用于我们日常生活的各个领域。你现在知道了在 Pandas 中如何运用你所有的知识，也很好地理解了它的真正力量。如果您还有任何疑问，请在下面的评论区提问。
使用 Pandas 的利弊
原文：https://www.studytonight.com/pandas/pros-and-cons-of-using-pandas
当你开始一个新的库，这是一个非常复杂和困难的决定。这涉及到大量的家庭作业和研究，并且有许多道路可以走。这是你需要记下库的优点和缺点的地方，这将帮助你决定你是否想要学习它。
它不仅有助于您的决策，还能让您清楚地了解框架和库的确切功能，以及它是否能够满足您的期望。
为了帮助你了解 Pandas 库的优点和缺点，我们给你带来了这个教程，其中包含了它的优点和缺点的列表。
Pandas 库的优点
Pandas 库是一个强大的软件，并且充满了优势。如果我们把它们都列出来，那要比去库学习花费更多的时间。这里我们列出了 Pandas 库的核心优势:
1.出色的数据表示:
Pandas 库是任何想要进入数据科学或数据分析的人的完美工具，因为它可以以不同的方式表示和组织数据。这是一个不可忽视的非常重要的功能，因为一个人不可能分析或读取任何数据，除非它表现得足够好。
当数据难以分析和阅读时，一组组织良好的干净数据是必不可少的。
2.完成更少的编码，完成更多的工作:
通过在 Pandas 中编写 1-2 行代码，您可以轻松完成需要大约 10-15 行 C++或 Java 代码的任务，甚至可能更多。这概括了 Pandas 为你提供的效率。在数据科学中，有太多的东西需要实践，因此对于刚进入这个领域的人来说，这是一种非常有用的能力。
减少不必要的编码负担有助于数据科学爱好者和专业人士节省大量时间，这对他们进行的研究至关重要。
3.高效处理海量数据:
如前所述，对于数据科学来说，时间非常重要。因此，及时高效地使用库变得极其重要。这是 Pandas 擅长的领域。韦斯·麦金尼制作这个库的唯一目的是为了能够比世界上其他任何一个库更快、更好地处理大量数据。这使得分析大量数据变得极其重要。
4.广泛的功能集:
Pandas 真的很健壮。这个库为用户提供了一套大命令和惊人的功能，可以用来最轻松地分析给定的数据。
Pandas 帮助数据分析达到了一个全新的水平。它帮助您根据您设置的条件过滤数据，并根据您自己的偏好分离和分割数据。
5.专为 Python 打造:
Python 已经迅速发展成为世界上最常用的编程语言之一。它为用户提供了数量惊人的功能，并为他们提供了大量的生产力。因此，当有人能够用 Pandas 为 Python 编写代码时，他们就能够利用 Python 提供的一长串功能和库的真正力量。
最受欢迎的库有 NumPy、MatPlotLib 和 SciPy 等。
6.数据的灵活性和易于定制:
Pandas 为用户提供了一个庞大的功能列表，他们可以将这些功能应用到他们所拥有的数据中，以便编辑和定制这些数据，同时根据自己的自由意志和需求来旋转这些数据。这有助于他们充分利用数据，并帮助他们分析手中掌握的所有信息。
Pandas 库的缺点:
任何事物都像硬币一样有两面。有了一系列的优点，Pandas 也有自己的局限性和缺点，知道这些同样重要。这里我们列出了 Pandas 库的缺点。
1.不总是符合 Python 的复杂语法:
当您使用 Pandas 时，知道它是 Python 的一部分，它的一些语法可能会很复杂。这是一个麻烦，因为许多用户无法在正常的 python 代码和 Pandas 之间高效无缝地切换。然而，这样的问题只会在你使用高级 Pandas 的时候出现，因此我们不应该让任何新来者沮丧。
2.学习曲线:
Pandas 的学习曲线非常陡峭。虽然它在一开始看起来很容易使用和浏览，但它只是冰山一角。
随着你深入 Pandas 的框架，你可能很难熟悉库的运作方式。然而，如果你有足够的决心和良好的资源，这是一个很容易克服的障碍。所以一定要试试这个库。
3.不良文档:
这对 Pandas 来说是一个大问题，尤其是对初学者来说。当任何编程语言或库被很好地记录下来时，它会帮助人们理解它自己的真正潜力，并让他们了解它的所有特性和应用。因为缺乏好的文档，Pandas 在某种程度上成为了自己用户和想学习或尝试它的人的专属。好的文档促使越来越多的用户学习库或语言。
4.3D 矩阵兼容性差:
这是 Pandas 库最明显的缺点之一。如果你的工作涉及二维(2D)矩阵，那么对你来说没有什么比 Pandas 更好的了。然而，一旦你将你的数据升级到三维(3D)矩阵，Pandas 将没有太大的用处，你将不得不求助于其他库，如 NumPy。
结论:
虽然 Pandas 库有一些看起来很麻烦的缺点，但是从上面提到的几点可以看出，它的优点总是大于缺点。与其让缺点打击你，不如让优点驱使你。利用储存在这个库瑰宝中的无限潜力。如果你对这篇文章有任何疑问，请在下面的评论区提问。
Pandas 数据帧参考
Pandas 数据帧abs()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-abs-method
在本教程中，我们将学习 PandasDataFrame.abs() 方法。它是 pandas 模块的内置模块，并返回一个带有每个元素的绝对数值的DataFrame。
该功能仅适用于所有元素均为numeric的情况。绝对也叫modulus。为了理解 abs()的方法，我们将解决例子，并获得数据帧的绝对值，对于复数，绝对值将是 a2+b2。下面是DataFrame.abs()方法的语法。
句法
使用该函数所需的语法如下:
abs(x)
这里，参数 x 可以是任何数字，可以是正的或负的零。该函数将返回正零。
示例:获取数据帧的绝对值
让我们看一下这个函数的基本示例，其代码片段如下。
import pandas as pd
df = pd.DataFrame([[23, -85, -0.25],[2, -1.259, -85]],columns=['A', 'B','C'])
print("-----DataFrame-----")
print(df)
print(abs(df))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
甲乙丙
0 23-85.000-0.25
1 2-1.259-85.00
甲乙丙
0 23.0 85.000 0.25
1 2.0 1.259 85.00
示例:获取字符串的绝对值时出现类型错误
如果试图得到字符串的绝对值，我们将得到TypeError，因为abs()方法只允许数值。
import pandas as pd
df = pd.DataFrame([['abc','xyz','pqr'],[2, -1.259, -85]],columns=['A', 'B','C'])
print("-----DataFrame-----")
print(df)
print(abs(df))
一旦我们运行该程序，我们将获得以下输出。
-data frame-
A B C
0 ABC XYZ pqr
1 2-1.259-85
回溯(最近一次调用最后一次):
文件“<字符串>”，第 8 行，在<模块>
文件“/usr/local/lib/python 3.8/dist-packages/pandas/core/generic . py”，第 1381 行，在 abs
中返回 self.abs() 【T8
示例:用复数获取数据帧的绝对值
在下面的例子中，我们将得到带有complex numbers的绝对值序列元素。abs()方法只返回数字的幅度部分。对于complex的输入，绝对值是？a2+b2
#importing pandas as pd
import pandas as pd
df = pd.DataFrame([[1.2 + 1j,-22,-12],[2, -1.259, -85]],columns=['A', 'B','C'])
print("-----DataFrame-----")
print(df)
print(abs(df))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
A B C
0 1.200000+1.00000j-22.000-12
1 2.000000+0.00000j-1.259-85
A B C
0 1.56205 22.000 12.0
1 2.00000 1.259 85.0
示例:获取数据帧特定列的绝对值
以下示例显示了如何获取数据帧中特定列的绝对值。
import pandas as pd
df = pd.DataFrame([[23, -85, -0.25],[2, -1.259, -85],[-0.25,78.65],[2,-4,-4.256]],columns=['A', 'B','C'])
print("-----DataFrame-----")
print(df)
print("---printing absolute value of column 'A' of DataFrame---")
print(df['A'].abs())
print("---printing absolute value of column 'C' of DataFrame---")
print(df['C'].abs())
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
A B C
0 23.00-85.000-0.250
1 2.00-1.259-85.000
2-0.25 78.650 NaN
3 2.00-4.000-4.256
-打印数据帧的“A”列的绝对值-
0 23.00
1 2
结论
在本教程中，我们了解了数据帧的abs()方法。我们学习了DataFrame.abs()方法的语法和参数，并解决了不同的例子，以更好地理解这个话题。
Pandas 数据帧agg()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-agg-method
在本教程中，我们将学习 Pandas data frame . agg()方法。此方法使用指定轴(即行或列)上的一个或多个操作进行聚合。
它根据函数返回标量、序列或数据帧。当用单个函数调用 DataFrame.agg 时，它返回 Series，当用多个函数调用 DataFrame.agg 时，它返回 DataFrame。
下面展示了 Pandas 中这个函数的语法。
句法
使用该函数所需的语法如下:
DataFrame.aggregate(func=None, axis=0, *args, **kwargs)
参数
让我们看看这个函数的参数:
功能:用于汇总数据。它可以是函数、字符串函数名、函数列表或函数名。例如:[np.sum，' min']
轴:如果为 0 或“索引”，则对每列应用一个函数。如果是 1 或“列”，则为每行应用一个函数。默认轴值为 0 或“索引”。
*参数:要传递给 func 的位置参数。
**kwargs: 要传递给 func 的关键字参数。
示例:在行上用单个函数聚合数据帧
下面的例子展示了如何用单个函数应用DataFrame.agg()方法。聚合操作总是在轴上执行。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("Printing number of non-null values in DataFrame")
print(df.agg(["count"]))
print("Printing the sum of values in DataFrame")
print(df.agg(["sum"]))
一旦我们运行程序，我们将得到以下结果。
打印数据帧中非空值的数量
A B C
计数 4 4 4
打印数据帧中值的总和
A B C
总和 22 26 30
示例:在行上用单个函数聚合数据帧
下面是如何用单个函数应用DataFrame.agg()方法的另一个例子。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("Printing the minimum value in DataFrame")
print(df.agg(["min"]))
print("Printing the maximum value in DataFrame")
print(df.agg(["max"]))
一旦我们运行程序，我们将得到以下结果。
在数据帧中打印最小值
A B C
最小 1 2 3
在数据帧中打印最大值
A B C
最大 10 11 12
示例:在列上用单个函数聚合数据帧
下面的例子展示了如何用单个函数应用DataFrame.agg()方法。聚合操作总是在一个轴上执行，这里是axis=1 or 'columns'.
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("Printing number of non-null values in DataFrame")
print(df.agg(["count"],axis='columns'))
print("Printing the sum of values in DataFrame")
print(df.agg(["sum"],axis='columns'))
一旦我们运行程序，我们将得到以下结果。
打印数据帧中非空值的数量
计数
0 3
1 3
2 3
3 3
打印数据帧中值的总和
总和
0 6
1 15
2 24
3 33
示例:在列上用单个函数聚合数据帧
下面是如何用单个函数应用DataFrame.agg()方法的另一个例子。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("Printing the minimum value in DataFrame")
print(df.agg(["min"],axis='columns'))
print("Printing the maximum value in DataFrame")
print(df.agg(["max"],axis='columns'))
一旦我们运行程序，我们将得到以下结果。
打印数据帧中的最小值
min
0 1
1 4
2 7
3 10
打印数据帧中的最大值
max
0 3
1 6
2 9
3 12
示例:在列上用单个函数聚合数据帧的另一个示例。
下面是如何用单个函数应用DataFrame.agg()方法的另一个例子。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("Printing the mean of values in DataFrame")
print(df.agg(["mean"],axis='columns'))
print("Printing the median of values in DataFrame")
print(df.agg(["median"],axis='columns'))
一旦我们运行程序，我们将得到以下结果。
打印数据帧中值的平均值
平均值
0 2.0
1 5.0
2 8.0
3 11.0
打印数据帧中值的中值
中值
0 2.0
1 5.0
2 8.0
3 11.0
示例:用行和列上的函数列表聚合数据帧。
下面的例子展示了如何用函数列表应用DataFrame.agg()方法。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
print("printing sum and min of the dataframe with default axis")
print(df.agg(["sum","min"]))
print("printing sum and min of the dataframe with the axis is equal to columns")
print(df.agg(["sum","min"],axis='columns'))
一旦我们运行程序，我们将得到以下结果。
用默认轴打印数据帧的总和和最小值
A B C
总和 22 26 30
最小值 1 2 3
用轴打印数据帧的总和和最小值等于列
总和最小值
0 6 1
1 15 4
2 24 7
3 33 10
示例:在数据帧的列上聚合不同的函数。
下面的例子展示了如何用不同的函数应用DataFrame.agg()方法。
import pandas as pd
df = pd.DataFrame([[1, 2, 3],[4, 5, 6],[7,8,9],[10,11,12]],columns=['A', 'B','C'])
#print(df.agg(x=('A', sum), y=('B', min), z=('C', max)))
print(df.agg({'A':["sum"], 'B':["min","max"], 'C':["count"]}))
一旦我们运行程序，我们将得到以下结果。
A B C
计数 NaN NaN 4.0
最大 NaN 11.0 NaN
最小 NaN 2.0 NaN
总和 22.0 NaN
结论
在本教程中，我们学习了 DataFrame.agg()方法，这是 Pandas 的内置函数。我们通过在具有单个、多个函数和不同行和列函数的数据帧上应用这种方法来解决示例。
Pandas 数据帧align()函数
原文：https://www.studytonight.com/pandas/pandas-dataframe-align-function
在本教程中，我们将学习 PythonPandasDataFrame.align()方法。此方法使用指定的连接方法将两个对象在其轴上对齐。当我们希望使用不同的连接方法(如外部、内部、左侧和右侧)将一个数据帧与另一个数据帧或一个数据帧与一个系列同步时，此方法很有帮助。
句法
使用该函数所需的语法如下。
DataFrame.align(other, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None)
参数:
其他:可以是数据帧或序列。
连接:‘外’‘内’‘左’‘右’。默认值为“外部”连接。
轴:其他对象允许的轴，默认无。在索引(0)、列(1)或两者上对齐(无)。
级别: int 或级别名，默认无。跨级别广播，匹配传递的多索引级别上的索引值。
副本: bool，默认 True。总是返回新对象。如果 copy=False 并且不需要重新索引，则返回原始对象。
fill_value: 标量，缺省为 np.NaN .用于缺失值的值。默认为 NaN，但可以是任何“兼容”的值。
方法 { '回填'，'填充'，'填充'，'无' }，默认无
限制: int，默认无。
fill_axis {0 或' index '，1 或' columns'}，默认为 0。填充轴、方法和限制。
broadcast_axis {0 或' index '，1 或' columns'}，默认无。如果对齐两个不同尺寸的对象，则沿此轴广播值。
示例:创建和打印数据帧
创建两个具有不同索引、列的数据帧并打印输出。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
print("----------Printing DataFrame 1----------")
print(df1)
print("----------Printing DataFrame 2----------")
print(df2)
一旦我们运行程序，我们将得到以下结果。
-打印数据帧 1 -
名称卷无主题标记
1 Abhishek 100 Science 90
2 Anurag 101 Science 85
-打印数据帧 2 -
名称卷无标记
2 Chetan 103 75
3 Divya 104 80
4 Diya 105 92
示例:与Columns(axis=1)上的Left 连接对齐
以下示例显示了如何将两个不同的数据帧与列上的left 连接对齐。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
a1, a2 = df1.align(df2, join='left', axis=1)
print("---------After Aligning to the left DataFrame 1--------")
print(a1)
print("---------After Aligning to the left DataFrame 2--------")
print(a2)
一旦我们运行程序，我们将得到以下结果。
-对齐左侧数据帧 1 -
名称卷无主题标记
1 Abhishek 100 Science 90
2 anu rag 101 Science 85
-对齐左侧数据帧 2 -
名称卷无主题标记
2 Chetan 103 NaN 75
3 Divya 104 NaN 80
4 Diya 105 NaN 92
示例:与Columns (axis=1)上的right 连接对齐
以下示例显示了如何将两个不同的数据帧与列上的right join对齐。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
a1, a2 = df1.align(df2, join='right', axis=1)
print("---------After Aligning to the right DataFrame 1--------")
print(a1)
print("---------After Aligning to the right DataFrame 2--------")
print(a2)
一旦我们运行程序，我们将得到以下结果。
-对准右侧数据帧 1 -
名称滚动无标记
1 Abhishek 100 90
2 Anurag 101 85
-对准右侧数据帧 2 -
名称滚动无标记
2 Chetan 103 75
3 Divya 104 80
4 Diya 105 92
示例:与Columns(axis=1)上的outer 连接对齐
以下示例显示了如何将两个不同的数据帧与列上的outer 连接对齐。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
a1, a2 = df1.align(df2, join='outer', axis=1)
print("---------After Aligning to the outer DataFrame 1--------")
print(a1)
print("---------After Aligning to the outer DataFrame 2--------")
print(a2)
一旦我们运行程序，我们将得到以下结果。
-与外部数据帧 1 对齐后-
标记名称卷无主题
1 90 Abhishek 100 Science
2 85 Anurag 101 Science
-与外部数据帧 2 对齐后-
标记名称卷无主题
2 75 Chetan 103 NaN
3 80 Divya 104 NaN
4 92 Diya 105 NaN
示例:与Columns(axis=1)上的inner 连接对齐
以下示例显示了如何将两个不同的数据帧与列上的left 连接对齐。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
a1, a2 = df1.align(df2, join='inner', axis=1)
print("---------After Aligning to the inner DataFrame 1--------")
print(a1)
print("---------After Aligning to the inner DataFrame 2--------")
print(a2)
一旦我们运行程序，我们将得到以下结果。
-对准内部数据帧 1 -
名称辊无标记
1 Abhishek 100 90
2 Anurag 101 85
-对准内部数据帧 2 -
名称辊无标记
2 Chetan 103 75
3 Divya 104 80
4 Diya 105 92
示例:与index(axis=0)上的Left 连接对齐
下面的示例显示了如何将两个不同的数据帧与索引上的左连接对齐。
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'], index=[1,2])
df2 = pd.DataFrame([['Chetan',103,75], ['Divya',104,80], ['Diya',105,92]], columns=['Name', 'Roll No', 'Marks'], index=[2,3,4])
a1, a2 = df1.align(df2, join='left', axis=0)
print("---------After Aligning to the left with axis=0, DataFrame 1--------")
print(a1)
print("---------After Aligning to the left with axis=0, DataFrame 2--------")
print(a2)
一旦我们运行程序，我们将得到以下结果。
-与轴=0 对齐后向左，数据帧 1 -
名称卷无主题标记
1 Abhishek 100 Science 90
2 Anurag 101 Science 85
-与轴=0 对齐后向左，数据帧 2 -
名称卷无标记
1 NaN NaN
2 Chetan 103.0 75.0
结论
在本教程中，我们学习了 Pandas DataFrame.align()方法。我们通过不同的连接方法和轴来理解语法、参数和解决的例子。
Pandas 数据帧all()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-all-method
在本教程中，我们将学习 Pandas 的DataFrame.all()方法。Pandas DataFrame.all()方法用于检查所有元素在轴上是否为真，并返回真，除非指定对象中至少有一个元素为假。它返回序列或数据帧。
下面显示了 DataFrame.all()方法的语法。
句法
使用这些方法所需的语法如下
DataFrame.all(axis=0, bool_only=None, skipna=True, level=None, **kwargs)
因素
轴:“0”代表索引，“1”代表列，它指示应该减少哪个轴或哪些轴。如果此参数为“0”，它将减少索引并返回一个其索引为原始列标签的系列。如果此参数为“0”，它将缩小列并返回一个其索引为原始索引的 Series，如果参数为“无”，则它将缩小所有轴并返回一个标量。
bool_only: bool(真或假)，默认值为 None，它只包括布尔列。如果此参数为无，它将尝试使用所有内容，然后仅使用布尔数据。
skipna: bool(真或假)，默认值为 True。它排除所有缺失或空值。
级别:代表 int 或级别名称，默认值为 None。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。
**kwargs: 表示任意，默认为无。附加的关键字没有效果，但可能会被接受以与 NumPy 兼容。
示例:使用DataFrame.all() 方法检查数据帧
下面的例子展示了DataFrame.all() 方法是如何工作的。如果所有值都为真，则返回True，否则返回False。如果有多个列，它将逐列检查。
import pandas as pd
df_1=pd.DataFrame([True,True])
df_2=pd.DataFrame([False,False])
df_3=pd.DataFrame([True,False])
df_4=pd.DataFrame([True,False],[True,False])
print(df_1.all())
print(df_2.all())
print(df_3.all())
print(df_4.all())
一旦我们运行该程序，我们将获得以下输出。
0 true
dttype:bool
0 false
dttype:bool
0 false
dttype:bool
0 false
dttype:bool
示例:使用DataFrame.all()方法检查数据帧列
以下示例显示了如何使用DataFrame.all()方法逐列检查数据帧的对象。该函数检查数据帧中该列的所有元素，只有当所有元素都符合条件时才返回True，否则返回False。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print(df)
print(all(df['B']>df['A']))
print(all(df['B']<df['A']))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 6
1 2 7
2 3 8
3 4 9
4 5 10
真
假
示例:使用DataFrame.all()方法检查数据帧列
这个例子类似于前面的例子。在代码中，只需更改数据帧中的任何一个元素并检查输出。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,2,8,9,10]}
df = pd.DataFrame(data)
print(df)
print(all(df['B']>df['A']))
print(all(df['B']<df['A']))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 6
1 2 2
2 3 8
3 4 9
4 5 10
假
假
结论
在本教程中，我们学习了如何使用 PythonPandas 的DataFrame.all()方法。我们通过在 DataFrame 上应用这个函数解决了一些例子，并且理解了这个方法是如何工作的。
Pandas 数据帧any()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-any-method
在本教程中，我们将学习 PythonPandas 的DataFrame.any()方法。Pandas DataFrame.any()方法用于检查轴上是否有任何元素为真，并返回 False，除非指定对象中至少有一个元素为真。它返回序列或数据帧。
下图显示了DataFrame.any()方法的语法。
句法
DataFrame.any(axis=0, bool_only=None, skipna=True, level=None, **kwargs)[source]
因素
轴:“0”代表索引，“1”代表列，它指示应该减少哪个轴或哪些轴。如果此参数为“0”，它将减少索引并返回一个其索引为原始列标签的系列。如果此参数为“0”，它将缩小列并返回一个其索引为原始索引的 Series，如果参数为“无”，则它将缩小所有轴并返回一个标量。
bool_only: bool(真或假)，默认值为 None，它只包括布尔列。如果此参数为无，它将尝试使用所有内容，然后仅使用布尔数据。
skipna: bool(真或假)，默认值为 True。它排除所有缺失或空值。
级别:代表 int 或级别名称，默认无。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。
**kwargs: 表示任意，默认为无。附加的关键字没有效果，但可能会被接受以与 NumPy 兼容。
示例 1:使用DataFrame.any()方法检查数据帧
下面的例子展示了DataFrame.any()方法是如何工作的。如果数据帧中的任何值为真，则返回True，否则返回假。如果有多个列，它将逐列检查。
import pandas as pd
df_1=pd.DataFrame([True,True])
df_2=pd.DataFrame([False,False])
df_3=pd.DataFrame([True,False])
df_4=pd.DataFrame([True,False],[True,False])
print(df_1.any())
print(df_2.any())
print(df_3.any())
print(df_4.any())
一旦我们运行该程序，我们将获得以下输出。
0 true
dttype:bool
0 false
dttype:bool
0 true
dttype:bool
0 true
dttype:bool
示例 2:使用DataFrame.any()方法检查数据帧列
以下示例显示了如何使用DataFrame.any()方法逐列检查数据帧的对象。该方法检查数据帧中该列的所有元素，只有当任何元素匹配条件时才返回True，否则返回False。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print(df)
print(any(df['B']>df['A']))
print(any(df['B']<df['A']))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 6
1 2 7
2 3 8
3 4 9
4 5 10
真
假
示例 3:使用DataFrame.any()方法检查数据帧列
下面是另一个示例，展示了如何使用DataFrame.any()方法逐列检查数据帧的对象。在本例中，更改数据帧的元素并检查输出。该方法检查数据帧中该列的所有元素，只有当任何元素匹配条件时才返回True，否则返回False。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[0,1,8,2,3]}
df = pd.DataFrame(data)
print(df)
print(any(df['B']>df['A']))
print(any(df['B']<df['A']))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 0
1 2 1
2 3 8
3 4 2
4 5 3
真
真
结论
在本教程中，我们学习了如何使用 PythonPandas 的DataFrame.any()方法。我们通过在 DataFrame 上应用这种方法解决了一些例子，并理解了函数是如何工作的。
Pandas 数据帧append()方法
在本教程中，我们将学习 PandasDataFrame.append()的方法。此方法将其他行追加到调用者的末尾，并返回一个新对象，不在调用者中的其他行中的列将作为新列添加。
下面是DataFrame.append()方法的语法。在本教程中，我们将向数据帧添加数据帧，向数据帧添加系列，向数据帧添加字典。
句法
DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=False)
因素
其他:表示要追加的数据。它包括数据帧或序列/类似字典的对象，或这些对象的列表。
ignore_index: 代表 bool(真或假)，默认值为 False。如果是True，生成的轴将从 0，1，…，n - 1 开始标注。
verify_integrity: 代表 bool(真或假)，默认值为 False。如果是True，在创建重复索引时引发值错误。
排序:表示 bool(真或假)，默认值为 False。如果自身列和其他列不对齐，它会对列进行排序。
示例:创建两个数据帧
创建两个数据帧并打印输出。在本教程中，我们将使用这两个数据帧。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Chetan',103,'Maths',75], ['Divya',104,'Science',80], ['Diya',105,'Maths',92]], columns=['Name', 'Roll No','Subject', 'Marks'])
print("-------DataFrame 1---------")
print(df1)
print("-------DataFrame 2---------")
print(df2)
一旦我们运行该程序，我们将获得以下输出。
-数据帧 1 -
名称卷无科目标记
0 阿布舍克 100 科学 90
1 阿努拉格 101 科学 85
-数据帧 2 -
名称卷无科目标记
0 切坦 103 数学 75
1 迪维娅 104 科学 80
2 迪雅 105 数学 92
示例 1:使用DataFrame.append()方法追加多行
我们可以使用DataFrame.append()方法将数据帧追加到数据帧中，下面的例子也显示了这一点。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Chetan',103,'Maths',75], ['Divya',104,'Science',80], ['Diya',105,'Maths',92]], columns=['Name', 'Roll No','Subject', 'Marks'])
print(df1.append(df2))
一旦我们运行该程序，我们将获得以下输出。
姓名卷无科目成绩
0 Abhishek 100 理科 90
1 Anurag 101 理科 85
0 车坛 103 数学 75
1 Divya 104 理科 80
2 Diya 105 数学 92
示例 2:使用DataFrame.append()方法将多行追加到数据帧中
当我们将数据帧附加到数据帧时，两个数据帧的索引值会重叠。为了避免这种情况，我们可以分配ignore_index=True。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Chetan',103,'Maths',75], ['Divya',104,'Science',80], ['Diya',105,'Maths',92]], columns=['Name', 'Roll No','Subject', 'Marks'])
print(df1.append(df2,ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
姓名卷无科目成绩
0 Abhishek 100 理科 90
1 Anurag 101 理科 85
2 车坛 103 数学 75
3 Divya 104 理科 80
4 Diya 105 数学 92
示例 3:使用DataFrame.append()方法将多行追加到数据帧中
在最后一个示例中，我们学习了如何在不重叠索引值的情况下将数据帧追加到数据帧中。在这个例子中，如果我们想表示索引值的重叠，我们可以在语法中指定verify_integrity=True。当索引值重叠时，这将引发异常。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Chetan',103,'Maths',75], ['Divya',104,'Science',80], ['Diya',105,'Maths',92]], columns=['Name', 'Roll No','Subject', 'Marks'])
print(df1.append(df2,verify_integrity=True))
一旦我们运行该程序，我们将获得以下输出。
值错误:索引有重叠值:Int64Index([0，1]，dtype='int64 ')
示例 4:使用DataFrame.append()方法将单行(系列)附加到数据帧
我们可以在DataFrame后面附加一个Series。下面的例子显示了同样的情况。
import pandas as pd
series=pd.Series(['Chetan',103,'Maths',75],index=['Name', 'Roll No','Subject', 'Marks'])
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(series)
print("------DataFrame after appending series------")
print(df1.append(series,ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
名称车坛
卷号 103
科目数学
标记 75
数据类型:对象
-追加系列后的数据帧-
名称卷号科目标记
0 Abhishek 100 Science 90
1 Anurag 101 Science 85
2 车坛 103 数学 75
示例 5:使用DataFrame.append()方法将字典附加到数据帧
以下示例显示了如何将字典追加到数据帧中。
import pandas as pd
dictionary={'Name':'Chetan','Roll No':103,'Subject':'Maths','Marks':75}
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.append(dictionary,ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
点名无科目成绩
0 Abhishek 100 理科 90
1 Anurag 101 理科 85
2 车坛 103 数学 75
示例 6:使用DataFrame.append()方法将字典列表附加到数据帧
以下示例显示了如何将字典列表追加到数据帧中。
import pandas as pd
dictionary=[{'Name':'Chetan','Roll No':103,'Subject':'Maths','Marks':75},{'Name':'Divya','Roll No':104,'Subject':'Science','Marks':80}]
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.append(dictionary,ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
姓名卷无科目成绩
0 Abhishek 100 理科 90
1 Anurag 101 理科 85
2 车坛 103 数学 75
3 Divya 104 理科 80
结论
在本教程中，我们学习了 PythonPandasDataFrame.append()方法。我们理解了DataFrame.append()方法的语法和参数，并通过在数据帧上应用该方法解决了一些例子。
Pandas 数据帧apply()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-apply-method
在本教程中，我们将学习 PandasDataFrame.apply()方法。使用这种方法，我们可以在数据帧的行和列上应用不同的功能。传递给方法的对象是 Series 对象，其索引是数据帧的索引(axis=0)或数据帧的列(axis=1)。
应用该方法后，沿数据帧的给定轴返回Series或DataFrame。当我们想要在不影响其他列的情况下更改特定列时，可以使用该函数。
下图显示了DataFrame.apply()方法的语法。
句法
DataFrame.apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)
因素
函数:表示应用于每一列或每一行的函数。
轴:表示应用函数的轴，0 或“index”:将函数应用于每一列，1 或“columns”:将函数应用于每一行。
result_type: 包括‘展开’、‘缩小’、‘广播’、‘无’，默认值为无。
这些仅在axis=1(列)时起作用:
-
“扩展”:类似列表的结果将变成列。
-
' reduce ':这与' expand '相反，如果可能的话，它会返回一个 Series，而不是扩展类似列表的结果。
-
“广播”:结果将广播到数据帧的原始形状，原始索引和列将被保留。
示例 1:使用DataFrame.apply()方法将np.sum函数应用于数据帧的所有元素
下面的例子展示了我们如何将函数应用于数据帧的所有元素。这里，在这个例子中，我们选择作为np.sum的函数，用default axis(axis=0)和axis=1。
import pandas as pd
import numpy as np
df=pd.DataFrame([[10,11,12],[20,21,22]],columns=['A','B','C'])
print("Applying sum function to all the elements of DataFrame")
print(df.apply(np.sum))
print(df.apply(np.sum,axis=1))
一旦我们运行该程序，我们将获得以下输出。
示例 2:使用DataFrame.apply()方法将用户定义的函数应用于数据帧
我们可以将用户定义的函数作为参数传递给DataFrame.apply()函数。下面的例子显示了同样的情况。
import pandas as pd
df=pd.DataFrame([[10,11,12],[20,21,22]],columns=['A','B','C'])
print(df)
def add(x):
return x+1
print(df.apply(add))
一旦我们运行该程序，我们将获得以下输出。
示例 3:使用DataFrame.apply()方法将 lambda 函数应用于数据帧的所有元素
我们可以将 lambda 函数传递给DataFrame.apply() 方法。在这里，我们选择作为lambda function、axis=1、result_type='expand'的函数，这个参数将类似列表的结果转换为列。下面的例子显示了有和没有result_type参数。
df=pd.DataFrame([[10,11,12],[20,21,22]],columns=['A','B','C'])
print(df.apply(lambda x: [1,2,3], axis=1))
print(df.apply(lambda x: [1,2,3], axis=1, result_type='expand'))
一旦我们运行该程序，我们将获得以下输出。
示例 4:使用DataFrame.apply()方法将特定函数应用于选定的列
如果我们想在不影响其他人的情况下更改某个特定的列，可以使用这样的DataFrame.apply()方法。在下面的例子中，我们通过将 lambda 函数传递给DataFrame.apply()方法并打印输出，只改变了'Name'列。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',75,80,90], ['Anurag',80,90,95],['Bavya',80,82,85],['Bavana',95,92,95],['Chetan',85,90,89]], columns=['Name','Maths','Science','Social'])
df1['Name'] = df1['Name'].apply(lambda x: x.upper())
print(df1)
一旦我们运行该程序，我们将获得以下输出。
示例 5:使用DataFrame.apply()方法将特定函数应用于选定的列
在本例中，我们将通过lambda function 的'Science'列更改为DataFrame.apply()方法。
import pandas as pd
df1 = pd.DataFrame([['Abhishek',75,80,90], ['Anurag',80,90,95],['Bavya',80,82,85],['Bavana',95,92,95],['Chetan',85,90,89]], columns=['Name','Maths','Science','Social'])
df1['Science'] = df1['Science'].apply(lambda x: x+10)
print(df1)
一旦我们运行该程序，我们将获得以下输出。
结论
在本教程中，我们学习了数据帧的 PandasDataFrame.apply()方法。我们学习了语法、参数，并将不同的函数、轴和结果类型传递给DataFrame.apply()方法，我们解决了示例。这个函数在清理数据时非常有用，比如改变特定的列，改变格式等等。
Pandas 数据帧applymap()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-applymap-method
在本教程中，我们将学习 PandasDataFrame.applymap()的方法。该方法将specifiedT2 元素应用于Dataframe元素。此方法将接受并返回标量的函数应用于数据帧的每个元素。
这个函数类似于DataFrame.apply()方法，唯一不同的是DataFrame.apply()把整列作为参数，然后把结果赋给这个列，DataFrame.applymap() 把单独的单元格值作为参数，把结果赋回这个单元格。
下图显示了DataFrame.applymap()方法的语法。
句法
DataFrame.applymap(func, na_action=None)
因素
func: 表示可调用的函数。该函数从单个值返回单个值。
na_action: 表示无或“忽略”，但默认值为无。如果是“忽略”，则传播 NaN 值，而不将它们传递给 func。
示例 1:在数据帧上应用DataFrame.applymap() 方法
以下示例显示了DataFrame.applymap() 方法的工作原理，在本例中，该方法返回所有单元格中的字符数。
df = pd.DataFrame([[1.23, 2.23], [3.3, 4]],columns=['A','B'])
print("-----DataFrame-----")
print(df)
print(df.applymap(lambda x: len(str(x))))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
甲乙
0 1.23 2.23
1 3.30 4.00
甲乙
0 4
1 3 3
示例 2:在数据帧上应用DataFrame.applymap() 方法
下面是DataFrame.applymap()方法的另一个例子。在本例中，向数据帧的单元格元素添加值并打印输出。
df = pd.DataFrame([[1.23, 2.23], [3.3, 4]],columns=['A','B'])
print("----------Adding element to the DataFrame--------")
print(df.applymap(lambda x: x+1))
一旦我们运行该程序，我们将获得以下输出。
-向数据帧添加元素-
甲乙
0 2.23 3.23
1 4.30 5.00
示例 3:应用DataFrame.applymap()方法
在下面的例子中，我们将np.sum 函数作为参数传递给DataFrame.applymap() 方法。
import pandas as pd
import numpy as np
df=pd.DataFrame([[10,11,12],[20,21,22]],columns=['A','B','C'])
print("Applying sum function to all the elements of DataFrame")
print(df.applymap(np.sum))
一旦我们运行该程序，我们将获得以下输出。
对数据帧的所有元素应用和函数
A B C
0 10 11 12
1 20 21 22
结论
在本教程中，我们学习了 PythonPandasDataFrame.applymap() 法。该函数类似于 DataFrame.apply()方法。我们通过在 DataFrame 上应用这种方法来解决示例，并了解它如何将单元格值作为参数，并将结果分配回该单元格。
Pandas 数据帧asfreq()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-asfreq-method
在本教程中，我们将学习 PandasDataFrame.asfreq()方法。它将TimeSeries转换为specified frequency.它提供了一种填充方法来填充或回填缺失的值。将此方法应用于数据帧后，它将返回转换为指定频率的对象。在本教程中，我们将时间序列转换为指定的频率，对频率进行上采样，并填写缺失的值。
句法
使用此方法所需的语法如下
DataFrame.asfreq(freq, method=None, how=None, normalize=False, fill_value=None)
因素
freq: 表示日期偏移量或字符串，即频率日期偏移量或字符串。
方法:包括【回填】/【填充】/【填充】/【填充】，默认值为无。用于填充重新索引系列中的孔的方法(注意，这不会填充已经存在的孔):
pad”或“ffill”:将最后一个有效观察值向前传播到下一个有效观察值
“回填”或“填充”:使用 NEXT 有效观察进行填充。
如何:包括‘开始’、‘结束’，默认值为结束。
归一化:表示布尔(真或假)，默认值为假。是否将输出索引重置为午夜。
fill_value: 它表示一个标量(可选)，用于在上采样期间应用的缺失值。
示例 1:将时间序列转换为指定的频率
我们可以使用DataFrame.asfreq()方法将时间序列转换为不同的指定频率。
import pandas as pd
index = pd.date_range('1/1/2021', periods=4, freq='T')
series = pd.Series([0.0, None, 2.0, 3.0], index=index)
df = pd.DataFrame({'Time':series})
print(df)
print("converting to different frequency")
print(df.asfreq(freq='H'))
一旦我们运行程序，我们将得到以下结果。
时间
2021-01-01 00:00:00 0.0
2021-01-01 00:01:00 NaN
2021-01-01 00:02:00 2.0
2021-01-01 00:03:00 3.0
转换为不同频率
时间
2021-01-01 0.0
示例 2:使用DataFrame.asfreq()方法对时间序列进行上采样
下面的例子表明，我们可以对时间序列的频率进行上采样。
import pandas as pd
index = pd.date_range('1/1/2021', periods=4, freq='T')
series = pd.Series([0.0, None, 2.0, 3.0], index=index)
df = pd.DataFrame({'Time':series})
print(df)
print("-----------upsample Timeseries-----------")
print(df.asfreq(freq='50s'))
一旦我们运行程序，我们将得到以下结果。
时间
2021-01-01 00:00:00 0.0
2021-01-01 00:01:00 NaN
2021-01-01 00:02:00 2.0
2021-01-01 00:03:00 3.0
-up sample Timeseries-
时间
2021-01-01 00
示例 3:使用DataFrame.asfreq()方法对时间序列进行上采样并填充缺失值
这个例子类似于前面的例子，在这个例子中，我们用“50”对时间序列进行上采样，并填充缺失的值。
import pandas as pd
index = pd.date_range('1/1/2021', periods=4, freq='T')
series = pd.Series([0.0, None, None, 3.0], index=index)
df = pd.DataFrame({'Time':series})
print(df)
print("-----------upsample Timeseries and fill value-----------")
print(df.asfreq(freq='50s',fill_value=9.0))
一旦我们运行程序，我们将得到以下结果。
时间
2021-01-01 00:00:00 0.0
2021-01-01 00:01:00 NaN
2021-01-01 00:02:00 NaN
2021-01-00:03:00 3.0
-向上采样时间序列和填充值-
时间
2021-01-01
示例 4:使用DataFrame.asfreq()方法对时间序列进行上采样并回填缺失值
在本例中，DataFrame.asfreq()方法对时间序列进行上采样， back fill对缺失值进行上采样。
import pandas as pd
index = pd.date_range('1/1/2021', periods=4, freq='T')
series = pd.Series([0.0, None, None, 3.0], index=index)
df = pd.DataFrame({'Time':series})
print("-----------upsample Timeseries-----------")
print(df.asfreq(freq='70s'))
print("-----------backward fill-------")
print(df.asfreq(freq='70s',method='bfill'))
一旦我们运行程序，我们将得到以下结果。
-上采样时间序列-
时间
2021-01-01 00:00:00 0.0
2021-01-01 00:01:10 NaN
2021-01-01 00:02:20 NaN
-后补-
时间
2021-01-01 00:00:00 0.0
2021-021
结论
在本教程中，我们学习了 PythonPandasDataFrame.asfreq()方法。我们学习并理解了DataFrame.asfreq()方法的语法和参数，通过将该方法应用于数据帧，我们通过将时间序列转换为指定频率、对频率进行上采样并填充缺失值来解决示例。
Pandas 数据帧asof()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-asof-method
在他的教程中，我们将学习 PandasDataFrame.asof()的方法。它返回最后一行或前几行，在此之前没有任何NaNs。如果子集不是None，最后一行没有 NaN 只考虑列的子集。如果没有好的值，则返回一个系列的 NaN 值或一个数据帧的一系列 NaN 值。
下图显示了DataFrame.asof()方法的语法。
句法
DataFrame.asof(where, subset=None)
参数
其中:表示日期或类似数组的日期。返回最后一行的日期。
子集:表示 str 的字符串或数组，默认为无。对于数据帧，如果不是“无”，请仅使用这些列来检查 NaNs。
示例 1:使用DataFrame.asof()方法获取最后一行
在下面的例子中，DataFrame.asof() 方法返回指定序列的最后几行，第一个值是 NaN，因为指定序列的第一个元素在第一个索引值之前。
import pandas as pd
import numpy as np
s = pd.DataFrame({'A':[1, 2, np.nan, 4],'B':[np.nan,2,np.nan,5.0]}, index=[10, 20, 30, 40])
print(s)
print(s.asof([5,20]))
一旦我们运行该程序，我们将获得以下输出。
A B
10 1.0 NaN
20 2.0 2.0
30 NaN NaN
40 4.0 5.0
T6】A B
5 NaN NaN
20 2.0 2.0
示例 2:获取最后一行时不考虑缺失值
在下面的例子中，DataFrame.asof() 方法返回指定序列的最后几行，即使 NaN 在30的索引位置。
import pandas as pd
import numpy as np
s = pd.DataFrame({'A':[1, 2, np.nan, 4],'B':[np.nan,2,np.nan,5.0]}, index=[10, 20, 30, 40])
print(s)
print(s.asof([10, 30]))
一旦我们运行该程序，我们将获得以下输出。
A B
10 1.0 NAn
20 2.0 2.0
30 NAn NAn
40 4.0 5.0
A B
10 NAn NAn
30 2.0 2.0
示例 3:使用DataFrame.asof()方法获取最后一行
下面的例子通过考虑单个列展示了DataFrame.asof()方法的例子。
import pandas as pd
import numpy as np
s = pd.DataFrame({'A':[1, 2, np.nan, 4],'B':[np.nan,2,np.nan,5.0]}, index=[10, 20, 30, 40])
print(s)
print(s.asof([10,30],subset=['A']))
一旦我们运行该程序，我们将获得以下输出。
A B
10 1.0 NAn
20 2.0 2.0
30 NAn NAn
40 4.0 5.0
A B
10 1.0 NAn
30 2.0 2.0
结论:
在本教程中，我们学习了 PythonPandasDataFrame.asof() 法。我们学习了语法、参数，并通过求解例子获得了数据帧的最后几行。
Pandas 数据帧assign()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-assign-method
在本教程中，我们将学习 PandasDataFrame.assign()的方法。此方法向数据帧分配新列，并返回一个新对象，其中除了新列之外，还包含所有原始列。已经存在并重新分配的列将被覆盖。
下图显示了DataFrame.assign()方法的语法。
句法
DataFrame.assign(**kwargs)
因素
*** *夸脱:列名代表关键词**。如果这些值是可调用的，它们将在数据帧上计算并分配给新列。可调用的不能改变输入数据帧。如果值不可调用，如数列、标量或数组，则简单地赋值。
示例 1:使用DataFrame.assign()方法为数据帧分配新列
我们可以使用DataFrame.assign()方法向数据帧中添加一个新列。下面的例子显示了同样的情况。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----After adding a column to the DataFrame----")
print(df.assign(C=[11,12,13,14,15]))
一旦我们运行程序，我们将得到以下结果。
-在数据帧中添加一列后-
A B C
0 1 6 11
1 2 7 12
2 3 8 13
3 4 9 14
4 5 10 15
示例 2:使用DataFrame.assign()方法为数据帧分配新列
下面的示例显示了如何通过将函数传递给DataFrame.assign()方法来为数据帧分配新列。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----After adding a column to the DataFrame----")
print(df.assign(C=lambda x: x.A+1))
一旦我们运行程序，我们将得到以下结果。
-在数据帧中添加一列后-
A B C
0 1 6 2
1 2 7 3
2 3 8 4
3 4 9 5
4 5 10 6
示例 3:使用DataFrame.assign()方法为数据帧分配多列
我们可以使用DataFrame.assign()方法向数据帧中添加多列。下面的例子显示了同样的情况。
import pandas as pd
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----After adding columns to the DataFrame----")
print(df.assign(C=lambda x: x.B+1,D=lambda x: x.C+1,E=lambda x: x.A+1))
一旦我们运行程序，我们将得到以下结果。
-在数据帧中添加列后-
A B C D E
0 1 6 7 8 2
1 2 7 8 9 3
2 3 8 9 10 4
3 4 9 10 11 5
4 5 10 11 12 6
结论
在本教程中，我们学习了 PythonPandasDataFrame.assign()方法。我们理解了语法和参数，通过求解示例，我们将单列和多列添加到数据帧中。
Pandas 数据帧astype()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-astype-method
在本教程中，我们将学习 PandasDataFrame.astype()的方法。这个方法将 pandas 的对象转换为指定的类型，这意味着它允许我们将数据类型从一种类型转换为另一种类型。我们可以使用字典更改指定的列数据类型。下面是DataFrame.astype()方法的语法。
句法
DataFrame.astype(dtype, copy=True, errors='raise')
因素
数据类型:数据类型，或列名 dict->数据类型。使用numpy.dtype 或 Python 类型将整个 Pandas 对象转换为同一类型。或者，使用{col: dtype，…}，其中 col 是列标签，dtype 是numpy.dtype或 Python 类型，将一个或多个数据帧的列转换为特定于列的类型。
副本:代表布尔(真或假)，默认为真。当copy=True.时，它返回一个副本
错误:包括‘提高’、‘忽略’，默认为‘提高’。如果是，
-
raise:允许引发异常。 -
ignore:抑制异常，出错时返回原对象。
示例 1:使用DataFrame.astype()方法转换数据帧的数据类型
我们可以使用DataFrame.astype()方法将数据帧的所有列数据类型转换为另一种数据类型。下面的例子显示了同样的情况。
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----Before converting datatype of DataFrame-----")
print(df.dtypes)
print("----After converting datatype of DataFrame-----")
print(df.astype('int32').dtypes)
一旦我们运行程序，我们将得到以下结果。
-转换数据帧数据类型前-
A int64
B int64
数据类型:对象
-转换数据帧数据类型后-
A int32
B int32
数据类型:对象
示例 2:使用DataFrame.astype()方法转换数据帧的单列数据类型
我们可以使用DataFrame.astype()方法将数据帧的单列数据类型转换为另一种数据类型。下面的例子显示了同样的情况。
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----Before converting datatype of DataFrame-----")
print(df.dtypes)
print("----After converting single column datatype of DataFrame-----")
print(df.astype({'A': 'int32'}).dtypes)
一旦我们运行程序，我们将得到以下结果。
-转换数据帧数据类型前-
A int64
B int64
数据类型:对象
-转换数据帧单列数据类型后-
A int32
B int64
数据类型:对象
示例 3:使用DataFrame.astype()方法转换数据帧的单列数据类型
此示例与前面的示例类似，转换数据帧的单列数据类型并检查数据帧。
data = {'A':[1,2,3,4,5],'B':[6,7,8,9,10]}
df = pd.DataFrame(data)
print("----After converting single column datatype of DataFrame-----")
df['B']=df['B'].astype('float')
print(df.dtypes)
print("-----DataFrame after converting to float datatypes-----")
print(df)
一旦我们运行程序，我们将得到以下结果。
-转换数据帧的单列数据类型后-
A int64
B float64
数据类型:对象
-转换为 float 数据类型后的数据帧-
A B
0 1 6.0
1 2 7.0
2 3 8.0
3 4 9.0
4 5 10.0
结论
在本教程中，我们学习了 PandasDataFrame.astype()方法。我们将数据帧的数据类型列转换为另一种数据类型，并检查了数据帧。
Pandas 数据帧at_time()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-at_time-method
在本教程中，我们将学习 PandasDataFrame.at_time()方法。它用于选择一天中特定时间的行值。如果数据帧中不存在指定的输入时间，则返回empty DataFrame.，如果索引不是DataTimeIndex，则提升TypeError。
下图显示了DataFrame.at_time()方法的语法。
句法
DataFrame.at_time(time, asof=False, axis=None)
参数:
时间:代表datetime.time或 str
轴:如果是【0】表示【索引】，如果是【1】表示【列】，默认值为 0。
示例 1:使用DataFrame.at_time()方法从数据帧中获取特定时间的值
下面的例子展示了如何通过给DataFrame.at_time()方法提供一个特定的时间来获取行的值。创建日期时间索引数据帧，并在任何特定时间获取值。
import pandas as pd
Values = pd.date_range('2021-01-01', periods=4, freq='12H')
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=Values)
print(df)
print("-----Selecting values---------")
print(df.at_time('12:00'))
一旦我们运行程序，我们将得到以下结果。
A B
2021-01-01 00:00:00 1 1
2021-01-01 12:00:00 2
2021-01-02 00:00 3
2021-01-02 12:00:00 4
-选择值-
A B
2021-01-01 12:00
示例 2:使用DataFrame.at_time()方法从数据帧中获取特定时间的值
下面的例子类似于前面的例子。更改周期和频率值，并从特定时间的数据帧中获取值。
import pandas as pd
Values = pd.date_range('2020-02-01', periods=5, freq='20T')
df = pd.DataFrame({'A': [1, 2, 3, 4,5],'B': [1, 2, 3, 4,5]}, index=Values)
print(df)
print("-----Selecting values---------")
print(df.at_time('1:00'))
一旦我们运行程序，我们将得到以下结果。
A B
2020-02-01 00:00:00 1 1
2020-02-01 00:20:00 2 2
2020-02-01 00:40:00 3
2020-02-01 01:00 4
2020-02-01 01:20:00 5
-选择值
示例 3:DataFrame.at_time()方法返回空的数据帧。
当我们试图从特定时间的数据帧中获取行的值时。如果数据帧中没有指定的输入时间，则返回empty DataFrame。
import pandas as pd
Values = pd.date_range('2020-02-01', periods=5, freq='20T')
df = pd.DataFrame({'A': [1, 2, 3, 4,5],'B': [1, 2, 3, 4,5]}, index=Values)
print("-----Selecting values---------")
print(df.at_time('1:30'))
一旦我们运行程序，我们将得到以下结果。
-选择值-
空数据帧
列:[A，B]
索引:[]
示例 4:DataFrame.at_time()方法引发类型错误。
如果指数不是DataTimeIndex，DataFrame.at_time()方法会提高TypeError.
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=[1,2,3,4])
print("-----Selecting values---------")
print(df.at_time('12:00'))
一旦我们运行程序，我们将得到以下结果。
类型错误：索引必须是日期时间索引
结论
在本教程中，我们学习了 PandasDataFrame.at_time()方法。我们理解了函数的语法和参数，并通过在数据帧上应用DataFrame.at_time()方法来获得指定时间的值来解决示例。
Pandas 数据帧backfill()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-backfill-method
在本教程中，我们将学习 PythonPandasDataFrame.backfill()方法。此方法向后填充数据帧中缺少的值。这个方法类似于method='bfill'的DataFrame.fillna()方法。
下图显示了DataFrame.backfill()方法的语法。
句法
DataFrame.backfill(axis=None, inplace=False, limit=None, downcast=None)
因素
轴:“0”或指数。不支持 1 和列。
就位:为布尔型、真型或假型。默认值为假。如果为真，则填充缺少的值，但不创建新对象。
限制:为 int，默认为无。如果指定了方法，这是向后填充的连续 NaN 值的最大数量。
示例:创建数据帧
创建一个无值的数据帧并打印输出。在本教程中，我们将使用这个数据帧。
import pandas as pd
df = pd.DataFrame({'A': [None, 3, None, None],'B': [2, 4, None, 3],'C': [None, None, None, 1],'D': [0, 1, 5, 4]}, columns=['A', 'B', 'C', 'D'])
print(df)
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 NAn 2.0 NAn 0
1 3.0 4.0 NAn 1
2 NAn NAn 5
3 NAn 3.0 1.0 4
示例 1:使用DataFrame.backfill()方法填写数据帧的缺失值
以下示例显示了DataFrame.backfill() 方法如何填充缺失值。
import pandas as pd
df = pd.DataFrame({'A': [None, 3, None, None],'B': [2, 4, None, 3],'C': [None, None, None, 1],'D': [0, 1, 5, 4]}, columns=['A', 'B', 'C', 'D'])
print(df.bfill())
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 3.0 2.0 1.0 0
1 3.0 4.0 1.0 1
2 NaN 3.0 1.0 5
3 NaN 3.0 1.0 4
例 2:用axis=1用DataFrame.backfill()方法填写数据帧的缺失值
这个例子类似于前面的例子DataFrame.backfill() 方法用axis=1填充缺失的值。
import pandas as pd
df = pd.DataFrame({'A': [None, 3, None, None],'B': [2, 4, None, 3],'C': [None, None, None, 1],'D': [0, 1, 5, 4]}, columns=['A', 'B', 'C', 'D'])
print(df.bfill(axis=1))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 2.0 2.0 0.0 0.0
1 3.0 4.0 1.0 1.0
2 5.0 5.0 5.0 5.0
3 3.0 3.0 1.0 4.0
示例 3:通过设置limit值，使用DataFrame.backfill()方法填写数据帧的缺失值
我们可以在DataFrame.backfill()方法中设置限值。这表示向后填充的连续 NaN 值的最大数量。
import pandas as pd
df = pd.DataFrame({'A': [None, 3, None, None],'B': [2, 4, None, 3],'C': [None, None, None, 1],'D': [0, 1, 5, 4]}, columns=['A', 'B', 'C', 'D'])
print(df.bfill(limit=2))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 3.0 2.0 NAn 0
1 3.0 4.0 NAn 1
2 NAn 3.0 1.0 5
3 NAn 3.0 1.0 4
例 4:用inplace=True用DataFrame.backfill()方法填写数据帧的缺失值
如果在DataFrame.backfill()方法中inplace=True ，它将填充数据帧的缺失值，但不创建新对象。如果我们想检查缺失值是否被填充，我们可以通过打印数据帧来检查。
import pandas as pd
df = pd.DataFrame({'A': [None, 3, None, None],'B': [2, 4, None, 3],'C': [None, None, None, 1],'D': [0, 1, 5, 4]}, columns=['A', 'B', 'C', 'D'])
print(df.bfill(inplace=True))
print(df)
一旦我们运行该程序，我们将获得以下输出。
无
A B C D
0 3.0 2.0 1.0 0
1 3.0 4.0 1.0 1
2 NaN 3.0 1.0 5
3 NaN 3.0 1.0 4
结论
在本教程中，我们学习了 PandasDataFrame.backfill()方法。我们学习了该函数的语法和参数，并将该函数应用于包含无值的数据帧，并理解了DataFrame.backfill()方法向后填充 Pandas 数据帧中存在的NaN值。
Pandas 数据帧between_time()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-between_time-method
在本教程中，我们将学习 PandasDataFrame.between_time()方法。此方法选择一天中特定时间之间的值。通过将start_time设置为晚于end_time，可以得到两个时间之间的而不是的时间。它返回数据帧，如果索引不是DataTimeIndex，它将提升TypeError。
下图显示了DataFrame.between_time()方法的语法。
句法
DataFrame.between_time(start_time, end_time, include_start=True, include_end=True, axis=None)
因素
start_time: 表示作为时间过滤器限制的初始时间的 datetime.time 或字符串。
end_time: 表示作为时间过滤器限制的结束时间的 datetime.time 或字符串。
include_start: 代表 bool(真或假)，默认值为 True。它指示开始时间是否需要包含在结果中。
include_end: 代表 bool(真或假)，默认值为 True。表示结果中是否需要包含结束时间。
轴:如果是【0】表示【索引】，如果是【1】表示【列】，默认值为 0。它确定索引或列值的范围时间。
示例 1:从数据帧中获取特定时间之间的值
下面的例子展示了如何通过给DataFrame.between_time()方法提供一个特定的时间来获取行的值。创建一个日期时间索引，并在任何特定时间获取值。
import pandas as pd
Values = pd.date_range('2021-01-01', periods=3, freq='20T')
df = pd.DataFrame({'A': [1, 2, 3],'B': [1, 2, 3]}, index=Values)
print(df)
print("-----Selecting values---------")
print(df.between_time('00:20','1:00'))
一旦我们运行程序，我们将得到以下结果。
A B
2021-01-01 00:00:00 1 1
2021-01-01 00:20:00 2 2
2021-01-01 00:40:00 3
-选择值-
A B
2021-01-01 00:20:00 2
2021-01-01 00:40
示例 2:从数据帧中获取特定时间之间的值
下面的例子类似于前面的例子。更改周期和频率值，并从数据帧中获取特定时间之间的值。
import pandas as pd
Values = pd.date_range('2000-01-01', periods=4, freq='1D20min')
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=Values)
print(df)
print("-----Selecting values---------")
print(df.between_time('0:15', '0:45'))
一旦我们运行程序，我们将得到以下结果。
A B
2000-01-01 00:00:00 1 1
2000-01-02 00:20:00 2
2000-01-03 00:40:00 3
2000-01-04 01:00:00 4
-选择值-
A B
2000-01-02 00:200
例 3:DataFrame.between_time()方法提升TypeError
如果指数不是DataTimeIndex,，DataFrame.between_time()方法会提高TypeError.
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=[1,2,3,4])
print("-----Selecting values---------")
print(df.between_time('00:20','1:00'))
一旦我们运行程序，我们将得到以下结果。
类型错误：索引必须是日期时间索引
例 4: DataFrame.between_time()提升TypeError的方法
下面的例子类似于前面的例子。通过设置axis=1检查DataFrame.between_time()方法。
import pandas as pd
Values = pd.date_range('2000-01-01', periods=4, freq='1D20min')
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=Values)
print(df.between_time('0:15', '0:45',axis=1))
一旦我们运行程序，我们将得到以下结果。
类型错误：索引必须是日期时间索引
示例 5:将 include_start 和 include_end 设置为 False
当include_start、include_end为False时，我们在结果中得不到开始时间和结束时间。以下示例显示了结果。
import pandas as pd
Values = pd.date_range('2021-01-01', periods=4, freq='20T')
df = pd.DataFrame({'A': [1, 2, 3, 4],'B': [1, 2, 3, 4]}, index=Values)
print(df)
print("-----Selecting values---------")
print(df.between_time('00:00','1:00',include_start=False,include_end=False))
一旦我们运行程序，我们将得到以下结果。
A B
2021-01-01 00:00:00 1 1
2021-01-01 00:20:00 2 2
2021-01-01 00:40:00 3
2021-01-01 01:00:00 4
-选择值-
A B
2021-01-01 00:24
结论
在本教程中，我们学习了 PandasDataFrame.between_time()方法。我们理解了函数的语法和参数，并通过在数据帧上应用DataFrame.between_time() 方法来获取指定时间之间的值来解决示例。
Pandas 数据帧boxplot()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-boxplot-method
一个boxplot通常被称为显示数据帧五个数字摘要的方框和图。五位数汇总是数据集的最小值，第一个四分位数是数据集的 25%，中值是数据集的 50%，第三个四分位数是数据集的 75%，以及数据集的最大值。箱折线图是一种通过四分位数图形化描述数字数据组的方法。
在本教程中，我们将学习 Pandas DataFrame . box plot()方法，该方法从 data frame 列制作一个盒子图。
下图显示了DataFrame.boxplot()方法的语法。
句法
DataFrame.boxplot(column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, backend=None, **kwargs)
参数:
列:字符串或字符串列表，可选。列名或名称列表，或向量。
by: 字符串或数组状，可选。数据帧中的一列到pandas.DataFrame.groupby()。一个方框图将由中的每个列值完成。
fontsize: float 或 str。以磅为单位或以字符串为单位的刻度标签字体大小(例如，大)。
rot: int 或 float，默认为 0。标签相对于屏幕坐标系的旋转角度(度)。
网格: bool，默认 True。将此设置为“真”将显示网格。
布局:元组(行、列)，可选。例如，(3，5)将使用 3 列 5 行显示子情节，从左上角开始。
return_type: {'axes '，' dict '，' both'}或无，默认' axes '。要返回的对象的类型。默认为axes。
示例 1:使用DataFrame.boxplot()方法创建箱折线图
考虑DataFrame.boxplot()方法如何工作的一个简单例子。通过将数据帧列的名称传递给DataFrame.boxplot()方法，创建一个数据帧并生成箱折线图。
import pandas as pd
df = pd.DataFrame([['Abhishek',75,80,90], ['Anurag',80,90,95],['Bavya',80,82,85],['Bavana',95,92,92],['Chetan',85,90,89]], columns=['Name','Maths','Science','Social'])
print(df)
boxplot=df.boxplot(column=['Social'])
print(df['Social'].quantile([0.25,0.5,0.75]))
print(boxplot)
一旦我们运行该程序，我们将获得以下输出。
示例 2:通过对列值中的数据进行分组，使用DataFrame.boxplot()方法创建箱折线图
这个例子与上一个类似，但是首先，它会根据by='DOB'参数将数据帧分组到不同的组中，然后为每个DataFrame创建一个箱折线图。
import pandas as pd
df = pd.DataFrame([['Abhishek','13/6/1995',100,90], ['Anurag','13/6/1995',101,95],['Bavya','19/5/1995',102,92],['Bavana','23/10/2003',103,90],['Chetan','23/10/2003',104,89],['Chirag','19/5/1995',105,100]], columns=['Name','DOB','Roll No','Marks'])
print(df)
print(df['Marks'].quantile([0.25,0.5,0.75]))
boxplot=df.boxplot(column=['Marks'],by='DOB')
print(boxplot)
一旦我们运行该程序，我们将获得以下输出。
示例 3:使用 fontsize、rot 和 grid 参数自定义 boxplot 的 DataFrame.boxplot()方法
我们可以使用 fontsize、rot 和 grid 参数自定义 boxplot，下面的示例也是如此。
import pandas as pd
df = pd.DataFrame([['Abhishek','13/6/1995',100,90], ['Anurag','13/6/1995',101,95],['Bavya','19/5/1995',102,92],['Bavana','23/10/2003',103,90],['Chetan','23/10/2003',104,89],['Chirag','19/5/1995',105,100]], columns=['Name','DOB','Roll No','Marks'])
print(df)
print(df['Marks'].quantile([0.25,0.5,0.75]))
boxplot=df.boxplot(column=['Marks'],by='DOB',grid=False, rot=20, fontsize=10)
print(boxplot)
一旦我们运行该程序，我们将获得以下输出。
示例 4:通过自定义布局参数的 DataFrame.boxplot()方法
我们可以使用布局参数自定义 boxplot，下面的示例也是如此。它将使用 3 列 1 行显示子情节。
import pandas as pd
df = pd.DataFrame([['Abhishek','13/6/1995',100,90], ['Anurag','13/6/1995',101,95],['Bavya','19/5/1995',102,92],['Bavana','23/10/2003',103,90],['Chetan','23/10/2003',104,89],['Chirag','19/5/1995',105,100]], columns=['Name','DOB','Roll No','Marks'])
print(df)
boxplot=df.boxplot(column=['Marks'],by='DOB',layout=(3,1))
print(boxplot)
一旦我们运行该程序，我们将获得以下输出。
结论
在本教程中，我们学习了数据帧的 Pandas DataFrame.boxplot()方法。我们学习了语法、参数，并向 DataFrame.boxplot()方法传递了不同的方法，我们解决了示例并理解了方法。
Pandas 数据帧clip()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-clip-method
在本教程中，我们将学习 PandasDataFrame.clip()方法。该方法在输入阈值处调整值。它将边界外的值指定给边界值。阈值可以是奇异值或类似数组的值，在后一种情况下，在指定的轴上按元素执行裁剪。
下图显示了DataFrame.clip()方法的语法。
句法
DataFrame.clip(lower=None, upper=None, axis=None, inplace=False, *args, **kwargs)
因素
下限:表示浮点或 array_like，默认无。它表示最小阈值，低于该阈值的所有值都将被设置为它。
上:代表浮动或 array_like，默认无。它代表最大阈值。高于此阈值的所有值都将被设置为该值。
轴:表示 int 或 str 轴名称，可选。它沿着给定的轴上下对齐对象。
到位:表示 bool(真或假)，默认值为 False。是否对数据就地执行操作。
args，kwargs* :是额外的关键词，没有效果，但可能会被接受与 NumPy 兼容。
示例 1:具有upper阈值的DataFrame.clip()方法
以下示例显示了DataFrame.clip()方法如何在upper 阈值处调整值。
#importing pandas library
import pandas as pd
data = {'col_1': [9, -3, 0, -1, 12], 'col_2': [-2, -7, -6, 8, -5]}
df = pd.DataFrame(data)
print("------DataFrame--------")
print(df)
print("------After clipping the DataFrame--------")
print(df.clip(upper=6))
一旦我们运行程序，我们将得到以下结果。
-数据帧-
col _ 1 col _ 2
0 9-2
1-3-7
2 0-6
3-1 8
4 12-5
-剪切数据帧后-
col _ 1 col _ 2
0 6-2
1-3-7
2 0-6
3-1 6
4 6-5
示例 2:具有lower阈值的DataFrame.clip()方法
以下示例显示了DataFrame.clip()方法如何在lower 阈值处调整值。
#importing pandas library
import pandas as pd
data = {'col_1': [9, -3, 0, -1, 12], 'col_2': [-2, -7, -6, 8, -5]}
df = pd.DataFrame(data)
print("------DataFrame--------")
print(df)
print("------After clipping the DataFrame--------")
print(df.clip(lower=-1))
一旦我们运行程序，我们将得到以下结果。
-数据帧-
col _ 1 col _ 2
0 9-2
1-3-7
2 0-6
3-1 8
4 12-5
-剪切数据帧后-
col _ 1 col _ 2
0 9-1
1-1-1
2 0-1
3-1 8
4 12-1
示例 3:具有lower和upper阈值的DataFrame.clip()方法
以下示例显示了DataFrame.clip()方法如何在lower 和upper 阈值处修剪值。
#importing pandas library
import pandas as pd
data = {'col_1': [9, -3, 0, -1, 12], 'col_2': [-2, -7, -6, 8, -5]}
df = pd.DataFrame(data)
print("------DataFrame--------")
print(df)
print("------After clipping the DataFrame--------")
print(df.clip(-1,6))
一旦我们运行程序，我们将得到以下结果。
-数据帧-
col _ 1 col _ 2
0 9-2
1-3-7
2 0-6
3-1 8
4 12-5
-剪切数据帧后-
col _ 1 col _ 2
0 6-1
1-1-1
2 0-1
3-1 6
4 6-1
示例 4:具有lower、upper阈值和inplace=True的DataFrame.clip()方法
下面的例子显示了inplace=True时DataFrame.clip()方法如何在lower 和upper 阈值处修剪值。
DataFrame.clip()方法逐元素修剪值，如果inplace=True.则返回None
#importing pandas library
import pandas as pd
data = {'col_1': [9, -3, 0, -1, 12], 'col_2': [-2, -7, -6, 8, -5]}
df = pd.DataFrame(data)
print("------DataFrame--------")
print(df)
print("------After clipping the DataFrame--------")
print(df.clip(-1,6,inplace=True))
print(df)
一旦我们运行程序，我们将得到以下结果。
-数据帧-
col _ 1 col _ 2
0 9-2
1-3-7
2 0-6
3-1 8
4 12-5
-剪切数据帧后-
无
col _ 1 col _ 2
0 6-1
1-1-1
2 0-1
3-1 6
4 6-1
结论
在本教程中，我们学习了DataFrame.clip()方法。我们学习了语法、参数，通过解决不同的例子，我们理解了DataFrame.clip()方法。
Pandas 数据帧bool()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-bool-method
在本教程中，我们将学习 PandasDataFrame.bool()方法。它返回单个元素 DataFrame 的 bool。这必须是布尔标量值，True或False。如果数据帧没有恰好一个元素或者该元素不是布尔型的，它将引发ValueError。
下图显示了DataFrame.bool()方法的语法。
句法
使用此方法所需的语法如下。
DataFrame.bool()
示例 1:使用DataFrame.bool()方法检查数据帧
仅当数据帧包含单个布尔真元素时，DataFrame.bool()方法才返回True。
#importing pandas library
import pandas as pd
df=pd.DataFrame({'column': [True]})
print("------DataFrame-------")
print(df)
print("Is the DataFrame contains single bool value:",df.bool())
一旦我们运行程序，我们将得到以下结果。
-数据帧-
列
0 真
数据帧是否包含单个布尔值:真
示例 2:使用DataFrame.bool()方法检查数据帧
只有当数据帧包含单个 bool False 元素时，DataFrame.bool()方法才返回False。
#importing pandas library
import pandas as pd
df=pd.DataFrame({'column': [False]})
print("------DataFrame-------")
print(df)
print("Is the DataFrame contains single bool value:",df.bool())
一旦我们运行程序，我们将得到以下结果。
-数据帧-
列
0 假
数据帧是否包含单个布尔值:假
例 3:DataFrame.bool()方法提升ValueError
如果数据帧包含两个元素，DataFrame.bool()方法将引发ValueError。
#importing pandas library
import pandas as pd
df=pd.DataFrame({'column': [True,True]})
print("------DataFrame-------")
print(df)
print("Is the DataFrame contains single bool value:",df.bool())
一旦我们运行程序，我们将得到以下结果。
-数据帧-
列
0 真
1 真
值错误:数据帧的真值不明确。请使用 a.empty、a.bool()、a.item()、a.any()或 a.all()。
示例:使用整数的DataFrame.bool()方法的数据帧
如果数据帧包含整数元素，DataFrame.bool()方法将引发ValueError。
#importing pandas library
import pandas as pd
df=pd.DataFrame({'column': [1]})
print("------DataFrame-------")
print(df)
print("Is the DataFrame contains single bool value:",df.bool())
一旦我们运行程序，我们将得到以下结果。
-数据帧-
列
0 1
值错误:布尔不能作用于非布尔单元素数据帧
结论
在本教程中，我们学习了 PythonPandasDataFrame.bool()方法。通过解决不同的例子，我们理解了这种方法是如何工作的。
Pandas 数据帧combine()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-combine-method
在本教程中，我们将学习 PythonPandasDataFrame.combine()方法。它与另一个数据帧执行列组合。它使用func将一个数据帧与其他数据帧组合，以元素方式组合列。结果数据帧的行和列索引将是这两者的并集。
下图显示了DataFrame.combine()方法的语法。
句法
DataFrame.combine(other, func, fill_value=None, overwrite=True)
因素
其他:它表示要按列合并的另一个数据帧。
func: 表示以两个数列为输入，返回一个数列或一个标量的函数。它用于逐列合并两个数据帧。
fill_value: 为标量值，默认无。在将任何列传递给合并函数之前，要在 NaS 中填充的值。
覆盖:表示布尔(真或假)，默认值为真。如果为真，则自身中不存在于其他中的列将被 NaNs 覆盖。
示例 1:使用DataFrame.combine()方法将数据帧与另一个数据帧组合
以下示例显示了如何使用选择较小列的DataFrame.combine()方法组合两个数据帧。
import pandas as pd
df1 = pd.DataFrame({'A': [2, 0, 5], 'B': [2, 0, 5]})
df2 = pd.DataFrame({'A': [3, 1,10], 'B': [4, 3, -4]})
take_smaller = lambda s1, s2: s1 if s1.sum() < s2.sum() else s2
print(df1.combine(df2, take_smaller))
一旦我们运行该程序，我们将获得以下输出。
甲乙
0 2 4
1 0 3
2 5 -4
示例 2:使用DataFrame.combine()方法将数据帧与另一个数据帧组合
下面的例子类似于前面的例子。通过给DataFrame.combine()函数赋予不同的功能来组合两个数据帧。
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': [2, 0, 5], 'B': [2, 2, -0.25]})
df2 = pd.DataFrame({'A': [3, 1,10], 'B': [3, 3, -4]})
print(df1.combine(df2, np.minimum))
print(df1.combine(df2, np.maximum))
一旦我们运行该程序，我们将获得以下输出。
甲乙
0 2 2.0
1 0 2.0
2 5 -4.0
甲乙
0 3 3.00
1 3.00
2 10-0.25
示例 3:通过填充缺失值来组合数据帧
以下示例显示了在将列传递给合并函数之前填充Nones的DataFrame.combine()方法中fill_value 的用法。
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': [2, 0, 5], 'B': [2, None, -0.25]})
df2 = pd.DataFrame({'A': [3, 1,None], 'B': [3, 3, -4]})
print(df1.combine(df2, np.minimum, fill_value=2))
print(df1.combine(df2, np.maximum,fill_value=-5))
一旦我们运行该程序，我们将获得以下输出。
甲乙
0 2 2.0
1 0 2.0
2 2 -4.0
甲乙
0 3 3.00
1 3.00
2 5-0.25
示例:如果两个数据帧中的相同元素为None，则进行组合
如果两个数据帧中的同一元素为“无”，则保留“无”。下面的例子显示了同样的情况。
import pandas as pd
import numpy as np
df1 = pd.DataFrame({'A': [0, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [None, 3]})
print(df1.combine(df2, np.minimum, fill_value=-2))
一旦我们运行该程序，我们将获得以下输出。
甲乙
0 0 -2.0
1 0 3.0
结论
在本教程中，我们学习了 Pandas DataFrame.combine()方法。我们学习了 DataFrame.combine()方法的语法和参数，并使用不同的参数组合了两个具有不同功能的 DataFrame。
Pandas 数据帧combine_first()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-combine_first-method
在本教程中，我们将学习 PandasDataFrame.combine_first()的方法。它用其他中相同位置的值更新空元素，并返回数据帧。它通过用另一个数据帧中的非空值填充一个数据帧中的空值来组合两个数据帧对象。结果数据帧的行和列索引将是这两者的并集。
下图显示了DataFrame.combine_first()方法的语法。
句法
DataFrame.combine_first(other)
因素
其他:它表示用于填充空值的其他提供的数据帧。
示例 1:使用DataFrame.combine_first()方法组合数据帧
下面的例子展示了DataFrame.combine_first()方法。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
print(df1.combine_first(df2))
一旦我们运行程序，我们将得到以下结果。
甲乙
0 1.0 3.0
1 0.0 4.0
示例 2:使用DataFrame.combine_first()方法组合数据帧
下面的例子和上一个例子类似，在这个例子中尝试用df2数据帧添加df1数据帧，看看有什么不同。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [1, 1], 'B': [3, 3]})
print(df2.combine_first(df1))
一旦我们运行程序，我们将得到以下结果。
甲乙
0 1 3
1 1 3
示例 3:如果两个数据帧中的同一元素为None
如果两个数据帧中的相同元素为None i t，则两个数据帧对象以相同的空值组合。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame({'A': [None, 0], 'B': [None, 4]})
df2 = pd.DataFrame({'A': [None, 1], 'B': [None, 3]})
print(df1.combine_first(df2))
一旦我们运行程序，我们将得到以下结果。
A B
0 NaN NaN
1 0.0 4.0
示例 4:使用DataFrame.combine_first()方法组合数据帧
如果该空值的位置不存在于其他中，则空值仍然保留在数据帧中。
import pandas as pd
df1 = pd.DataFrame({'A': [None, 0], 'B': [4, None]})
df2 = pd.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
print(df1.combine_first(df2))
一旦我们运行程序，我们将得到以下结果。
A B C
0 NaN 4.0 NaN
1 0.0 3.0 1.0
2 NaN 3.0 1.0
结论
在本教程中，我们学习了 PandasDataFrame.combine_first()方法。我们解决了一些例子，理解了DataFrame.combine_first()方法有效地填充了数据帧中的空值，并为第一个数据帧中不存在的索引和列提供了值。
Pandas 数据帧compare()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-compare-method
在本教程中，我们将学习 PandasDataFrame.compare()的方法。此方法将一个数据帧与另一个数据帧进行比较，并显示差异。它返回显示并排堆叠的差异的数据帧，结果索引将是一个多索引，其中‘self’和‘other’交替堆叠在内层。当两个数据帧没有相同的标签或形状时，该函数抛出'ValueError'异常。
下图显示了DataFrame.compare()方法的语法。
句法
DataFrame.compare(other, align_axis=1, keep_shape=False, keep_equal=False)
因素
其他:数据帧。对象进行比较。
align_axis: 如果是【0】表示【索引】，如果是【1】表示【列】，默认值为 1。它确定在哪个轴上对齐比较。
keep_shape: 表示 bool(真或假)，默认值为 False。如果为真，则保留所有行和列。否则，只保留具有不同值的那些。
keep_equal: 表示 bool(真或假)，默认值为 False。如果为真，结果将保持相等的值。否则，相等的值显示为 n as。
示例 1:使用DataFrame.compare()方法比较两个数据帧
我们可以比较两个数据帧，并使用DataFrame.compare()方法查看差异。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Abhishek',100,'Maths',95], ['Anurag',101,'Maths',80]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.compare(df2))
一旦我们运行该程序，我们将获得以下输出。
学科成绩
自我他人自我他人
0 科学数学 90 95
1 科学数学 85 80
示例 2:使用DataFrame.compare()方法和align_axis=0比较两个数据帧
当align_axis=0 时，DataFrame.compare()方法返回垂直堆叠的数据帧，其中的行是从自己和他人交替绘制的。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Abhishek',100,'Maths',95], ['Anurag',101,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.compare(df2,align_axis=0))
一旦我们运行该程序，我们将获得以下输出。
科目成绩
0 自我科学 90
其他数学 95
1 自我科学 85
其他数学 75
示例 3:使用DataFrame.compare()方法比较两个数据帧
下面的例子与上一个类似，更改数据帧中的一些元素，比较并检查差异。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Abhishek',100,'Maths',95], ['Anurag',101,'Maths',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.compare(df2,align_axis=0))
一旦我们运行该程序，我们将获得以下输出。
科目成绩
0 自我科学 90.0
其他数学 95.0
1 自我科学 NaN
其他数学 NaN
示例 4:使用DataFrame.compare()方法和keep_shape=True比较两个数据帧
如果keep_shape=True，将显示结果数据帧中的所有行和列。否则，只有具有不同值的数据才会显示在结果数据帧中。
#importing pandas as pd
import pandas as pd
df1 = pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
df2 = pd.DataFrame([['Abhishek',100,'Maths',95], ['Anurag',101,'Maths',85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df1.compare(df2,keep_shape=True))
一旦我们运行该程序，我们将获得以下输出。
姓名卷无学科成绩
自我其他自我其他自我其他自我其他
0 NaN NaN NaN 理科数学 90.0 95.0
1 NaN NaN 理科数学 NaN NaN
结论
在本教程中，我们学习了 PandasDataFrame.compare()方法。我们学习了DataFrame.compare()方法的语法和参数。我们通过求解例子比较了两个数据帧，理解了DataFrame.compare()方法。
Pandas 数据帧convert_dtypes()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-convert_dtypes-method
在本教程中，我们将学习 PandasDataFrame.convert_dtypes()的方法。它使用支持pd.NA的数据类型将数据帧的列转换为最佳可能的数据类型。它返回数据帧，该数据帧是具有新数据类型的输入对象的副本。这里最可能是指最适合保存数值的类型。
下图显示了DataFrame.convert_dtypes()方法的语法。
句法
DataFrame.convert_dtypes(infer_objects=True, convert_string=True, convert_integer=True, convert_boolean=True, convert_floating=True)
因素
expert _ objects:表示 bool(真或假)，默认值为 True。它指示对象数据类型是否应该转换为可能的最佳类型。
convert_string: 表示布尔(真或假)，默认值为真。指示对象数据类型是否应转换为StringDtype()。
convert_integer: 表示 bool(真或假)，默认值为 True。如果可能，它指示是否可以转换为整数扩展类型。
convert_boolean: 表示布尔(真或假)，默认值为真。指示对象数据类型是否应转换为BooleanDtypes()。
convert_floating: 表示 bool(真或假)，默认值为 True。它指示如果可能的话，是否可以转换为浮动扩展类型。如果 convert_integer 也为 True，那么如果浮点数可以被忠实地转换为整数，那么将优先选择整数数据类型。
示例 1:使用DataFrame.convert_dtypes()方法将数据帧转换为最佳数据类型
我们可以将数据帧的列转换为可能的最佳数据类型。见下面的例子。
import pandas as pd
df = pd.DataFrame({'A': ['a', 'b', 'c'], 'B': ['d', 'e', 'f']})
print("--------DataType of DataFrame---------")
print(df.dtypes)
print("--------DataType of DataFrame after converting---------")
df1=df.convert_dtypes()
print(df1.dtypes)
一旦我们运行该程序，我们将获得以下输出。
-数据帧的数据类型-
A 对象
B 对象
数据类型:对象
-转换后数据帧的数据类型-
A 字符串
B 字符串
数据类型:对象
示例 2:使用DataFrame.convert_dtypes()方法转换数据帧
这个例子与上一个类似，我们只是尝试不同的数据类型。
import pandas as pd
df = pd.DataFrame({'A': [True,True,True], 'B': [True,2,3]})
print("--------DataType of DataFrame---------")
print(df.dtypes)
print("--------DataType of DataFrame after converting---------")
df1=df.convert_dtypes()
print(df1.dtypes)
一旦我们运行该程序，我们将获得以下输出。
-数据帧的数据类型-
布尔
B 对象
数据类型:对象
-转换后数据帧的数据类型-
布尔
B 对象
数据类型:对象
示例 3:使用DataFrame.convert_dtypes()方法转换数据帧
让我们用不同的数据类型来理解DataFrame.convert_dtypes()方法。
import pandas as pd
import numpy as np
df = pd.DataFrame({"a": pd.Series([1, 2, 3], dtype=np.dtype("int32")),"b": pd.Series(["x", "y", "z"], dtype=np.dtype("O")),
"c": pd.Series([True, False, np.nan], dtype=np.dtype("O")),"d": pd.Series(["h", "i", np.nan], dtype=np.dtype("O")),
"e": pd.Series([10, np.nan, 20], dtype=np.dtype("float")),"f": pd.Series([np.nan, 100.5, 200], dtype=np.dtype("float")),})
print("--------DataType of DataFrame---------")
print(df.dtypes)
print("--------DataType of DataFrame after converting---------")
df1=df.convert_dtypes()
print(df1.dtypes)
一旦我们运行该程序，我们将获得以下输出。
-数据帧的数据类型-
a int32
b 对象
c 对象
d 对象
e float64
f float64
数据类型:对象
-转换后数据帧的数据类型-
a Int32
b 字符串
c 布尔
d 字符串
e Int64
f float64
数据类型:对象
结论
在本教程中，我们学习了 PandasDataFrame.convert_dtypes() 方法。通过解决示例，我们了解了DataFrame.convert_dtypes() 方法如何将数据帧的列转换为可能的最佳数据类型。
Pandas 数据帧corr()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-corr-method
相关性是对两个变量之间线性关系的度量。在本教程中，我们将学习 PythonPandasDataFrame.corr()方法。此方法计算列的成对相关性，不包括空值。它返回相关矩阵数据帧。
下图显示了DataFrame.corr()函数的语法。
句法
DataFrame.corr(method='pearson', min_periods=1)
因素
方法 { '皮尔逊'，'肯德尔'，'斯皮尔曼' }或可调用
关联方法:
-
皮尔逊:标准相关系数
-
肯德尔:肯德尔τ相关系数
-
斯皮尔曼:斯皮尔曼等级关联
-
可调用:输入两个 1d 数组并返回一个浮点数即可调用。请注意，从 corr 返回的矩阵沿对角线将有 1，并且将是对称的，与可调用的行为无关。
min_periods: int，可选。每对列获得有效结果所需的最小观察次数。目前仅适用于皮尔逊和斯皮尔曼相关。
这些方法的输出介于 1 和-1 之间。
- 1 表示强烈的正关系。
- -1 表示强烈的负面关系。
- 零的结果表示根本没有关系。
示例 1:使用DataFrame.corr()方法查找数据帧各列之间的相关性
下面的例子显示了如何使用pearson方法找到数据帧各列之间的相关性。
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df = pd.DataFrame(chart)
print(df)
print(df.corr(method='pearson'))
一旦我们运行该程序，我们将获得以下输出。在输出中，我们可以看到列之间的正相关性。
姓名年龄身高体重
0 车坛 20 155 55
1 雅夏士 25 160 60
2 尤瓦拉吉 30 175 75
年龄身高体重
年龄 1.000000 0.960769 0.960769
身高 0.960769 1.00000 1.00000
体重 0.960769 1.000009
示例 2:使用DataFrame.corr()方法查找数据帧各列之间的相关性
下面的例子显示了如何使用kendall方法找到数据帧各列之间的相关性。
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df = pd.DataFrame(chart)
print(df)
print(df.corr(method='kendall'))
一旦我们运行该程序，我们将获得以下输出。
姓名年龄身高体重
0 车坛 20 155 55
1 雅夏 25 160 60
2 尤瓦拉吉 30 175 75
年龄身高体重
年龄 1.0 1.0 1.0
身高 1.0 1.0 1.0
体重 1.0 1.0 1.0
结论
在本教程中，我们学习了 Pandas DataFrame.corr()方法。我们使用皮尔逊、肯德尔和斯皮尔曼方法找到数据帧列之间的相关性。
Pandas 数据帧copy()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-copy-method
当我们想要通过添加、删除或更新数据帧来操作数据帧而不改变数据帧时，我们可以复制并进行操作。
在本教程中，我们将学习 PandasDataFrame.copy()的方法。此方法复制数据帧的数据并返回一个新对象。下图显示了 PandasDataFrame.copy()方法的语法。
句法
DataFrame.copy(deep=True)
因素
深:代表布尔(真或假)，默认为真。制作一份深度拷贝，包括数据和索引的拷贝。通过deep=False既不复制索引也不复制数据。
当deep=True(默认)时，将使用调用对象的数据和索引的副本创建一个新对象。对副本数据或索引的修改不会反映在原始对象中。
当deep=False时，将不复制调用对象的数据或索引而创建一个新对象(只复制对数据和索引的引用)。对原始数据的任何更改都将反映在浅拷贝中(反之亦然)。
示例 1:使用DataFrame.copy()方法复制数据帧
创建一个数据帧，并使用DataFrame.copy()方法复制该数据帧。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': ['a', 'b', 'c'], 'B': ['d', 'e', 'f']})
print(df)
df1=df.copy()
print(df1)
一旦我们运行该程序，我们将获得以下输出。
A B
0 A d
1 B e
2 c f
A B
0 A d
1 B e
2 c f
示例 2:使用DataFrame.copy()方法复制数据帧
让我们用另一个复制数据帧的例子来理解。
#importing pandas as pd
import pandas as pd
colors = {'first_set': ['Green','Blue','Red'],'second_set': ['Yellow','White','Blue']}
df = pd.DataFrame(colors)
print(df)
df1=df.copy()
print(df1)
一旦我们运行该程序，我们将获得以下输出。
第一 _ 套第二 _ 套
0 绿黄
1 蓝白
2 红蓝
第一 _ 套第二 _ 套
0 绿黄
1 蓝白
2 红蓝
示例 3:使用deep=False的DataFrame.copy()方法复制数据帧
当deep=False、DataFrame.copy()方法创建一个新对象时，对原始数据的任何更改都会反映在浅拷贝中。
import pandas as pd
colors = {'first_set': ['Green','Blue','Red'],'second_set': ['Yellow','White','Blue']}
df = pd.DataFrame(colors)
df1=df.copy(deep=False)
df1['first_set'] = df1['first_set'].replace(['Blue'],'Green')
print(df1)
print(df)
一旦我们运行该程序，我们将获得以下输出。
第一 _ 套第二 _ 套
0 绿黄
1 绿白
2 红蓝
第一 _ 套第二 _ 套
0 绿黄
1 绿白
2 红蓝
结论
在本教程中，我们学习了 PandasDataFrame.copy() 方法。我们学习了DataFrame.copy() 方法的参数，求解了实例，以及该方法如何复制具有不同参数和这些参数差异的数据帧。
Pandas 数据帧corrwith()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-corrwith-method
在本教程中，我们将学习 PandasDataFrame.corrwith()方法。它计算成对的相关性。成对相关性是在数据帧的行或列与序列或数据帧的行或列之间计算的。在计算相关性之前，数据帧首先沿两个轴对齐。
下图显示了DataFrame.corrwith()方法的语法。
句法
DataFrame.corrwith(other, axis=0, drop=False, method='pearson')
参数
其他:数据帧，系列。用来计算相关性的对象。
轴: {0 或'索引'，1 或'列' }，默认为 0。要使用的轴。0 或“index”表示按列计算，1 或“columns”表示按行计算。
drop: bool，默认 False。从结果中删除缺失的索引。
方法: {'pearson '，' kendall '，' spearman'}或 callable。
关联方法:
-
皮尔逊:标准相关系数
-
肯德尔:肯德尔τ相关系数
-
斯皮尔曼:斯皮尔曼等级相关性
-
callable:可调用，输入两个 1d 数组并返回一个 float。
示例:创建两个数据帧。
创建两个数据帧，在本教程中，我们将使用这些数据帧。
import pandas as pd
chart_1 = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df1 = pd.DataFrame(chart_1)
print(df1)
chart_2 = {'Name':['Pooja','Sindu','Renuka'],'Age': [18,25,20],'Height': [145,155,165],'Weight': [45,55,65]}
df2 = pd.DataFrame(chart_2)
print(df2)
一旦我们运行程序，我们将得到以下结果。
姓名年龄身高体重
0 车坛 20 155 55
1 雅夏 25 160 60
2 尤瓦拉吉 30 175 75
姓名年龄身高体重
0 普贾 18 145 45
1 辛杜 25 155 55
2 雷努卡 20 165 65
示例:使用DataFrame.corrwith()方法和pearson方法查找两个数据帧之间的相关性。
下面的例子展示了如何使用pearson方法找到两个数据帧之间的相关性。
import pandas as pd
chart_1 = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df1 = pd.DataFrame(chart_1)
chart_2 = {'Name':['Pooja','Sindu','Renuka'],'Age': [18,25,20],'Height': [145,155,165],'Weight': [45,55,65]}
df2 = pd.DataFrame(chart_2)
print(df1.corrwith(df2,method='pearson'))
一旦我们运行该程序，我们将获得以下输出。
年龄 0.277350
身高 0.960769
体重 0.960769
体型:浮动 64
示例:使用DataFrame.corrwith()方法和kendall方法查找两个数据帧之间的相关性。
下面的例子展示了如何使用kendall方法找到两个数据帧之间的相关性。
import pandas as pd
chart_1 = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df1 = pd.DataFrame(chart_1)
chart_2 = {'Name':['Pooja','Sindu','Renuka'],'Age': [18,25,20],'Height': [145,155,165],'Weight': [45,55,65]}
df2 = pd.DataFrame(chart_2)
print(df1.corrwith(df2,method='kendall'))
一旦我们运行该程序，我们将获得以下输出。
年龄 0.333333
身高 1.000000
体重 1.000000
体型:浮动 64
示例:使用DataFrame.corrwith()方法和spearman方法查找两个数据帧之间的相关性。
下面的例子展示了如何使用spearman方法找到两个数据帧之间的相关性。
import pandas as pd
chart_1 = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,160,175],'Weight': [55,60,75]}
df1 = pd.DataFrame(chart_1)
chart_2 = {'Name':['Pooja','Sindu','Renuka'],'Age': [18,25,20],'Height': [145,155,165],'Weight': [45,55,65]}
df2 = pd.DataFrame(chart_2)
print(df1.corrwith(df2,method='spearman'))
一旦我们运行该程序，我们将获得以下输出。
年龄 0.5
身高 1.0
体重 1.0
体型:浮动 64
结论
在本教程中，我们学习了 PythonPandasDataFrame.corrwith()方法。我们使用皮尔逊、肯德尔和斯皮尔曼方法找到了两个数据帧之间的相关性。
Pandas 数据帧count()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-count-method
在本教程中，我们将学习 PandasDataFrame.count()的方法。该方法对每一列或每一行的non-NA单元格进行计数。值 None、NaN、NaT 和可选的 numpy.inf 被认为是 NA。它为每一列/每一行返回数据帧或数据系列非空条目数。如果指定了级别，则返回一个数据帧。
下图显示了DataFrame.count()方法的语法。
句法
DataFrame.count(axis=0, level=None, numeric_only=False)
因素
轴: {0 或'索引'，1 或'列' }，默认为 0。如果为 0，则为每列生成“索引”计数。如果每行生成 1 或“列”计数。
级别: int 或 str，可选。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个数据帧。Str 指定级别名称。
仅限数值: bool，默认为 False。只包括浮点、整型或布尔型数据。
示例 1:使用DataFrame.count()方法计算每个row的non-NA元素
以下示例显示了DataFrame.count()方法如何计算数据帧中沿row轴出现的非空元素的数量。
import pandas as pd
df= pd.DataFrame([['Abhishek','Science',90], ['Anurag',101,None,85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df)
print("Counting the number of elements in the dataframe-----")
print(df.count())
一旦我们运行该程序，我们将获得以下输出。
名称卷无主题标记
0 Abhishek Science 90.0 NaN
1 Anurag 101 NaN 85.0
计算数据帧中的元素数量-
名称 2
卷无主题标记 2
主题 1
标记 1
数据类型:int64
示例 2:使用DataFrame.count()方法计算每个row的non-NA元素
考虑一个包含所有空元素的数据帧，并使用DataFrame.count()方法计数。
import pandas as pd
import numpy as np
df= pd.DataFrame([[np.nan,np.nan,np.nan], [None,np.nan,None,np.nan]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df)
print("-------Counting the number of elements in the dataframe-----")
print(df.count())
一旦我们运行该程序，我们将获得以下输出。
名称卷无主题标记
0 楠楠楠
1 楠楠楠
-计算数据帧中的元素数量-
名称 0
卷无 0
主题 0
标记 0
数据类型:int64
示例 3:使用DataFrame.count()方法计算每个row的non-NA元素
以下示例显示了DataFrame.count()方法如何计算数据帧中沿column轴出现的非空元素的数量。
import pandas as pd
df= pd.DataFrame([['Abhishek',101,'Science',90], ['Anurag',102,None,85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df)
print("Counting the number of elements in the dataframe-----")
print(df.count(axis=1))
一旦我们运行该程序，我们将获得以下输出。
名称卷无主题标记
0 Abhishek 101 Science 90
1 Anurag 102 None 85
计算数据帧中的元素数量-
0 4
1 3
数据类型:int64
示例 4:使用DataFrame.count()方法计算每个row的non-NA元素
以下示例显示了DataFrame.count()方法如何使用numeric_only=True计算数据帧中沿row轴出现的非空数字元素的数量。方法。
import pandas as pd
df= pd.DataFrame([['Abhishek',101,'Science',90], ['Anurag',102,None,85]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df)
print("Counting the number of elements in the dataframe-----")
print(df.count(numeric_only=True))
一旦我们运行该程序，我们将获得以下输出。
名称卷无主题标记
0 Abhishek 101 Science 90
1 Anurag 102 None 85
计算数据帧中的元素数量-
卷无 2
标记 2
数据类型:int64
结论
在本教程中，我们学习了 PandasDataFrame.count()方法。我们学习了语法、参数，并通过解决示例了解了该方法如何计算数据帧的行轴和列轴上的非空元素的数量。
Pandas 数据帧cov()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-cov-method
协方差是对两个随机变量之间关系的度量，它告诉我们两个随机变量一起变化的程度。A 正 协方差表示资产收益一起运动，而 a 负协方差表示它们反向运动。
在本教程中，我们将学习 PandasDataFrame.cov()的方法。这种方法通常用于分析时间序列数据，以了解不同度量之间跨时间的关系。
它计算列的成对协方差，不包括 NA/null 值。它计算数据帧系列之间的成对协方差，返回的数据帧是数据帧各列的协方差矩阵。
下图显示了DataFrame.cov()方法的语法。
句法
DataFrame.cov(min_periods=None, ddof=1)
因素
min_periods: int，可选。每对列获得有效结果所需的最小观察次数。
ddof: int，默认 1。δ自由度。计算中使用的除数是N - ddof，其中N代表元素的数量。
示例 1:使用DataFrame.cov()方法找到协方差
下面的例子展示了如何找到数据帧各列之间的协方差。
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,170,165],'Weight': [59,60,75]}
df = pd.DataFrame(chart)
print(df)
print("------Covariance between the columns---------")
print(df.cov())
一旦我们运行该程序，我们将获得以下输出。
姓名年龄身高体重
0 车坛 20 155 59
1 雅夏士 25 170 60
2 yuvraj 30 165 75
-列间协方差-
年龄身高体重
年龄 25.0 25.0000000 40.000000
身高 25.0 58.3333316.66667
体重 40.0 16
示例 2:使用DataFrame.cov()方法找到协方差
下面的示例显示了如何找到由空值组成的数据帧的列之间的协方差。
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,None,30],'Height': [155,170,None],'Weight': [59,60,75]}
df = pd.DataFrame(chart)
print(df)
print("------Covariance between the columns---------")
print(df.cov())
一旦我们运行该程序，我们将获得以下输出。
姓名年龄身高体重
0 车坛 20.0 155.0 59
1 雅夏士 NaN 170.0 60
2 yuvraj 30.0 NaN 75
-列间协方差-
年龄身高体重
年龄 50.0 NaN 80.000000
身高 NaN 112.5 7.500000
体重 80.0 7.5 80.3333333
示例 3:使用DataFrame.cov()方法找到协方差
下面的示例显示了如何找到数据帧的两列之间的协方差。
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,170,165],'Weight': [59,60,75]}
df = pd.DataFrame(chart)
print(df)
print("------Covariance between the Height and weight column is---------")
print(df.Height.cov(df.Weight))
一旦我们运行该程序，我们将获得以下输出。
姓名年龄身高体重
0 车坛 20 155 59
1 雅夏斯 25 170 60
2 尤瓦拉吉 30 165 75
-身高体重栏之间的协方差为-
16。56660 . 66666666666
结论
在本教程中，我们学习了 PandasDataFrame.cov()方法。通过求解例子，我们可以找到数据帧各列之间的协方差。
Pandas 数据帧cummax()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-cummax-method
在本教程中，我们将学习 PandasDataFrame.cummax()T4 法。它给出了数据帧或序列轴上的累积最大值。它返回包含cumulative maximum的相同大小的数据帧或序列。
下图显示了 PandasDataFrame.cummax()方法的语法。
句法
DataFrame.cummax(axis=None, skipna=True, *args, **kwargs)
因素
轴: {0 或'索引'，1 或'列' }，默认为 0。轴的索引或名称。0 相当于“无”或“索引”。
skipna: bool，默认为 True。排除无/空值。如果整行/整列为“无”，结果将为“无”。
args，kwargs* :额外的关键词没有效果，但是为了与 NumPy 兼容，可能会被接受。
示例 1:找到数据帧的累积最大值
以下示例显示了如何使用DataFrame.cummax()方法找到索引轴上数据帧的累积最大值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, 10, 7, 8], "C":[9, 10, 11, 12],"D":[13, 16, 15, 16]})
print(df)
print("-----------Finding cumulative maximum-------")
print(df.cummax(axis = 0))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9 9 13
1 2 10 10 16
2 8 7 11 15
3 4 8 12 16
-求累计最大值-
A B C D
0 1 9 9 13
1 2 10 10 16
2 8 10 11 16
3 8 10 12 16
例 2:求column轴上数据帧的累积最大值
以下示例显示了如何使用DataFrame.cummax()方法找到数据帧在列轴上的累积最大值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, 10, 7, 8], "C":[9, 10, 11, 12],"D":[13, 16, 15, 16]})
print(df)
print("-----------Finding cumulative maximum-------")
print(df.cummax(axis = 1))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9 9 13
1 2 10 10 16
2 8 7 11 15
3 4 8 12 16
-求累计最大值-
A B C D
0 1 9 9 13
1 2 10 16
2 8 11 15
3 4 8 12 16
示例 3:找到数据帧的累积最大值
以下示例显示了如何使用DataFrame.cummax()方法找到索引轴上具有空值的数据帧的累积最大值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, None, 7, 8], "C":[9, 10, None, 12],"D":[None, 16, 15, 16]})
print(df)
print("-----------Finding cumulative maximum-------")
print(df.cummax(skipna=False))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9.0 9.0 NaN
1 2 NaN 10.0 16.0
2 8 7.0 NaN 15.0
3 4 8.0 12.0 16.0
-求累计最大值-
A B C D
0 1 9.0 9.0 NaN
1 2 NaN 10.0 NaN
2 8 NaN NaN
3 8 NaN NaN NaN
结论
在本教程中，我们学习了 PandasDataFrame.cummax()方法。我们学习了语法、参数，通过求解例子，我们理解了DataFrame.cummax()方法。
Pandas 数据帧cummin()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-cummin-method
在本教程中，我们将学习 PandasDataFrame.cummin()T4 法。它给出了数据帧或序列轴上的累积最小值。它返回包含cumulative minimum的相同大小的数据帧或序列。
下图显示了 PandasDataFrame.cummin()方法的语法。
句法
DataFrame.cummin(axis=None, skipna=True, *args, **kwargs)
参数:
轴: {0 或'索引'，1 或'列' }，默认为 0。轴的索引或名称。0 相当于“无”或“索引”。
skipna: bool，默认为 True。排除无/空值。如果整行/整列为“无”，结果将为“无”。
args，kwargs* :额外的关键词没有效果，但是为了与 NumPy 兼容，可能会被接受。
示例 1:找到数据帧的累积最小值
以下示例显示了如何使用DataFrame.cummin()方法找到索引轴上数据帧的累积最小值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, 10, 7, 8], "C":[9, 10, 11, 12],"D":[13, 16, 15, 16]})
print(df)
print("-----------Finding cumulative minimum-------")
print(df.cummin(axis = 0))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9 9 13
1 2 10 10 16
2 8 7 11 15
3 4 8 12 16
-求累计最小值-
A B C D
0 1 9 9 13
1 9 9 13
2 1 7 9 13
3 1 7 9 13
示例 2:找到数据帧的累积最小值
以下示例显示了如何使用DataFrame.cummin()方法找到列轴上数据帧的累积最小值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, 10, 7, 8], "C":[9, 10, 11, 12],"D":[13, 16, 15, 16]})
print(df)
print("-----------Finding cumulative minimum-------")
print(df.cummin(axis = 1))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9 9 13
1 2 10 10 16
2 8 7 11 15
3 4 8 12 16
-寻找累计最小值-
A B C D
0 1 1 1 1
1 2 2 2 2
2 8 7 7
3 4 4 4 4
示例 3:找到数据帧的累积最小值
以下示例显示了如何使用DataFrame.cummin()方法在索引轴上找到具有空值的数据帧的累积最小值。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 8, 4], "B":[9, None, 7, 8], "C":[9, 10, None, 12],"D":[None, 16, 15, 16]})
print(df)
print("-----------Finding cumulative minimum-------")
print(df.cummin(skipna=False))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 9.0 9.0 NaN
1 2 NaN 10.0 16.0
2 8 7.0 NaN 15.0
3 4 8.0 12.0 16.0
-求累计最小值-
A B C D
0 1 9.0 9.0 NaN
1 1 NaN 9.0 NaN
2 1 NaN NaN
3 1 NaN NaN NaN
结论
在本教程中，我们学习了 PandasDataFrame.cummin()方法。我们学习了语法、参数，通过求解例子，我们理解了DataFrame.cummin()方法。
Pandas 数据帧cumprod()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-cumprod-method
在本教程中，我们将学习 PandasDataFrame.cumprod()方法。它给出了数据帧或序列轴上的累积积。它返回包含cumulative product的相同大小的数据帧或序列。
下图显示了 PandasDataFrame.cumprod()方法的语法。
语法
DataFrame.cumprod(axis=None, skipna=True, *args, **kwargs)
参数:
轴: {0 或'索引'，1 或'列' }，默认为 0。轴的索引或名称。0 相当于“无”或“索引”。
skipna: bool，默认为 True。排除无/空值。如果整行/整列为“无”，结果将为“无”。
args，kwargs* :额外的关键词没有效果，但是为了与 NumPy 兼容，可能会被接受。
示例 1:找到数据帧的累积乘积
下面的例子显示了如何使用DataFrame.cumprod()方法找到数据帧在索引轴上的累计乘积。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, 7, 8]})
print(df)
print("-----------Finding cumulative product-------")
print(df.cumprod(axis = 0))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5
1 2 6
2 3 7
3 4 8
-寻找累计产品-
A B
0 1 5
1 2 30
2 6 210
3 24 1680
示例 2:找到数据帧的累积乘积
下面的例子展示了如何使用DataFrame.cumprod()方法找到数据帧在列轴上的累计乘积。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, 7, 8]})
print(df)
print("-----------Finding cumulative product-------")
print(df.cumprod(axis = 1))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5
1 2 6
2 3 7
3 4 8
-寻找累计积-
A B
0 1 5
1 2 12
2 3 21
3 4 32
示例 3:找到数据帧的累积乘积
下面的例子显示了如何使用DataFrame.cumprod()方法找到索引轴上具有空值的数据帧的累积乘积。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, None, 8]})
print(df)
print("-----------Finding cumulative product-------")
print(df.cumprod(skipna=False))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5.0
1 2 6.0
2 3 NaN
3 4 8.0
-寻找累计乘积-
A B
0 1 5.0
1 2 30.0
2 6 NaN
3 24 NaN
结论
在本教程中，我们学习了 PandasDataFrame.cumprod()方法。我们学习了语法、参数，通过求解例子，我们理解了DataFrame.cumprod()方法。
Pandas 数据帧cumsum()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-cumsum-method
在本教程中，我们将学习 PandasDataFrame.cumsum()方法。它给出了数据帧或序列轴上的累计总和。它返回包含cumulative sum的相同大小的数据帧或序列。
下图显示了 PandasDataFrame.cumsum()方法的语法。
语法
DataFrame.cumsum(axis=None, skipna=True, *args, **kwargs)
因素
轴: {0 或'索引'，1 或'列' }，默认为 0。轴的索引或名称。0 相当于“无”或“索引”。
skipna: bool，默认为 True。排除无/空值。如果整行/整列为“无”，结果将为“无”。
args，kwargs* :额外的关键词没有效果，但是为了与 NumPy 兼容，可能会被接受。
示例 1:查找数据帧的累积总和
下面的例子显示了如何使用DataFrame.cumsum()方法在索引轴上找到数据帧的累积和。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, 7, 8]})
print(df)
print("-----------Finding cumulative sum-------")
print(df.cumsum(axis = 0))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5
1 2 6
2 3 7
3 4 8
-求累计和-
A B
0 1 5
1 3 11
2 6 18
3 10 26
示例 2:查找数据帧的累积总和
以下示例显示了如何使用DataFrame.cumsum()方法找到列轴上数据帧的累积和。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, 7, 8]})
print(df)
print("-----------Finding cumulative sum-------")
print(df.cumsum(axis = 1))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5
1 2 6
2 3 7
3 4 8
-求累计和-
A B
0 1 6
1 2 8
2 3 10
3 4 12
示例 3:查找数据帧的累积总和
以下示例显示了如何使用DataFrame.cumsum()方法在索引轴上查找带有空值的数据帧的累积和。
import pandas as pd
# Creating the dataframe
df = pd.DataFrame({"A":[1, 2, 3, 4], "B":[5, 6, None, 8]})
print(df)
print("-----------Finding cumulative sum-------")
print(df.cumsum(skipna=False))
一旦我们运行该程序，我们将获得以下输出。
A B
0 1 5.0
1 2 6.0
2 3 NaN
3 4 8.0
-求累计和-
A B
0 1 5.0
1 3 11.0
2 6 NaN
3 10 NaN
结论
在本教程中，我们学习了 PandasDataFrame.cumsum()方法。我们学习了语法、参数，通过求解例子，我们理解了DataFrame.cumsum()方法。
Pandas 数据帧describe()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-describe-method
在本教程中，我们将学习 PandasDataFrame.describe()T4 法。它生成描述性统计数据，包括数据集分布的中心趋势、离差和形状，不包括NaN值。
- 对于通过
DataFrame提供的混合数据类型，默认情况下只返回对numeric列的分析。 - 对于数值数据，结果的指数将包括
count、mean、std、min、max以及较低的、50和较高的百分位数。 - 对于对象数据(例如字符串或时间戳)，结果的索引将包括
count、unique、top和freq。top是最常见的价值观。
下图显示了DataFrame.describe()方法的语法。
句法
DataFrame.describe(percentiles=None, include=None, exclude=None, datetime_is_numeric=False)
示例 1:使用DataFrame.describe()方法描述DataFrame
以下示例显示了使用DataFrame.describe()方法描述DataFrame 。默认情况下，只返回numeric字段。
import pandas as pd
df= pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85],['Chetan',103,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df.describe())
一旦我们运行该程序，我们将获得以下输出。
滚动无标记
计数 3.000000 3.000000
平均值 101.333333 83.333333】标准值 1.527525 7.637626
最小值 100.000000 75.000000
25% 100.500000 80.00000
50% 101
示例 2:使用DataFrame.describe()方法描述DataFrame的所有列
以下示例显示了使用DataFrame.describe()方法描述DataFrame的所有列，而不考虑数据类型。
import pandas as pd
df= pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85],['Chetan',103,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df.describe(include='all'))
一旦我们运行该程序，我们将获得以下输出。
名称卷无主题标记
计数 3 3.0000000 3.00000
独有 3 NAn 2 NAn
top Abhishek NAn Science NAn
freq 1 NAn 2 NAn
均值 NAn 101.3333333 NAn 83.333333
STD NAn 1.527525 NAn 7.637626
min NAn 100.000000000075
示例 3:使用DataFrame.describe()方法描述DataFrame的特定列
下面的示例显示了通过将列作为属性访问来描述来自DataFrame的列。
import pandas as pd
df= pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85],['Chetan',103,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df.Marks.describe())
一旦我们运行该程序，我们将获得以下输出。
计数 3.000000
平均值 83.333333
标准 7.637626
最小值 75.000000
25% 80.000000
50% 85.000000
75% 87.500000
最大值 90.000000
名称:Marks，dtype: float64
示例 4:使用DataFrame.describe()方法描述DataFrame的特定列
下面的例子展示了如何使用带有exclude=np.number的DataFrame.describe()方法来描述一个不包含数值列的DataFrame。
import pandas as pd
df= pd.DataFrame([['Abhishek',100,'Science',90], ['Anurag',101,'Science',85],['Chetan',103,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df.describe(exclude=np.number))
一旦我们运行该程序，我们将获得以下输出。
名称主题
计数 3 3
独特的 3 2
顶级阿布舍克科学
频率 1 2
示例 5:使用由None值组成的DataFrame.describe()方法描述DataFrame
以下示例显示了DataFrame.describe()方法如何描述由无值组成的数据帧。
import pandas as pd
df= pd.DataFrame([['Abhishek',101,'Science',None], ['Anurag',None,'Science',85],['Chetan',None,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print(df.describe())
一旦我们运行该程序，我们将获得以下输出。
滚动无标记
计数 1.0 2.000000
平均值 101.0 80.000000
标准 NaN 7.071068
最小值 101.0 75.000000
25% 101.0 77.500000
50% 101.0 80.00000
75% 101.0 82.5000
结论
在本教程中，我们学习了 PandasDataFrame.describe()方法。我们学习了语法、参数，并通过在具有不同参数的数据帧上应用该方法来解决示例，并理解了该方法。
Pandas 数据帧diff()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-diff-method
在本教程中，我们将学习 PandasDataFrame.diff()T3】法。它提供了元素的第一个离散差异。它计算数据帧元素与数据帧中另一个元素的差异(默认值是前一行中的元素)。
下图显示了DataFrame.diff()方法的语法。
句法
DataFrame.diff(periods=1, axis=0)
因素
周期: int，默认 1。用于计算差值的移动周期接受负值。
轴: {0 或'索引'，1 或'列' }，默认为 0。对行(0)或列(1)求差。
示例 1:使用DataFrame.diff()方法计算差值
以下示例显示了与数据帧的前一行的区别。
import pandas as pd
df = pd.DataFrame({'a': [1, 3, 8],'b': [3, 5, 8],'c': [16, 25, 36]})
print("------DataFrame-------")
print(df)
print("------Difference with previous row------ ")
print(df.diff())
Once we run the program we will get the following output.
-数据帧-
a b c
0 1 3 16
1 3 5 25
2 8 8 36
-与前一行的差异-
a b c
0 NAn NAn
1 2.0 2.0 9.0
2 5.0 3.0 11.0
示例 2:使用DataFrame.diff()方法计算差值
以下示例显示了数据帧的前一列之间的差异。
import pandas as pd
df = pd.DataFrame({'a': [1, 3, 8],'b': [3, 5, 8],'c': [16, 25, 36]})
print("------DataFrame-------")
print(df)
print("------Difference with previous columns------ ")
print(df.diff(axis=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c
0 1 3 16
1 3 5 25
2 8 8 36
-与前几列的差异-
a b c
0 NAn 2.0 13.0
1 NAn 2.0 20.0
2 NAn 0.0 28.0
示例 3:使用DataFrame.diff()方法计算差值
下面的示例显示了与数据帧的第二个前一行的区别。
import pandas as pd
df = pd.DataFrame({'a': [1, 3, 8, 5],'b': [3, 5, 8, 6],'c': [16, 25, 36, 20]})
print("------DataFrame-------")
print(df)
print("------Difference with 2nd previous rows ------ ")
print(df.diff(periods=2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c
0 1 3 16
1 3 5 25
2 8 8 36
3 5 6 20
-与前面第 2 行的差异-
a b c
0 NAn NAn
1 NAn NAn
2 7.0 5.0 20.0
3 2.0 1.0-5.0
示例 4:使用DataFrame.diff()方法计算差值
以下示例显示了与数据帧的前三行的区别。
import pandas as pd
df = pd.DataFrame({'a': [1, 3, 8, 5, 6],'b': [3, 5, 8, 6, 7],'c': [16, 25, 36, 20, 25]})
print("------DataFrame-------")
print(df)
print("------Difference with 3rd previous rows ------ ")
print(df.diff(periods=3))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c
0 1 3 16
1 3 5 25
2 8 8 36
3 5 6 20
4 6 7 25
-与前面第 3 行的差异-
a b c
0 NAn NAn
1 NAn NAn
2 NAn NAn
3 4.0 3.0 4.0
4 3.0 2.0
结论
在本教程中，我们学习了 PandasDataFrame.diff()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。
Pandas 数据帧div()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-div-method
在本教程中，我们将学习 PandasDataFrame.div()T3】法。它返回 dataframe 和其他元素的浮点除法(二进制运算符 truediv)。它返回一个带有算术运算结果的数据帧。
下图显示了 PandasDataFrame.div()方法的语法。
句法
DataFrame.div(other, axis='columns', level=None, fill_value=None)
因素
其他:标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。
轴: {0 或‘索引’，1 或‘列’}。是按索引(0 或“索引”)还是按列(1 或“列”)进行比较。对于序列输入，轴与序列索引匹配。
级别: int 或 label。跨级别广播，匹配传递的多索引级别上的索引值。
fill_value: 浮动或无，默认无。在计算之前，用该值填充现有的缺失(NaN)值以及成功的数据帧对齐所需的任何新元素。如果两个相应数据帧位置的数据都丢失，结果也将丢失。
示例 1:使用DataFrame.div()方法分割数据帧
以下示例显示了使用DataFrame.div()方法将数据帧除以常数。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [2, 5, 6],'b': [8, 10, 12],'c': [14, 16, 18]})
print(df1.div(3))
一旦我们运行该程序，我们将获得以下输出。
a b c
0 0.6666672.666674.66667
1 1.666673.3333333 5.33333
2 2.000000 4.00000 6.000000
示例 2:使用DataFrame.div()方法分割数据帧
以下示例显示了使用DataFrame.div()方法将数据帧与其他数据帧分割。
import pandas as pd
df1 = pd.DataFrame({'a': [2, 5, 6],'b': [8, 10, 12],'c': [14, 16, 18]})
df2 = pd.DataFrame({'a': [2, 2, 2],'b': [2, 2, 2],'c': [2, 2, 2]})
print(df1.div(df2))
一旦我们运行该程序，我们将获得以下输出。
a b c
0 1.0 4.0 7.0
1 2.5 5.0 8.0
2 3.0 6.0 9.0
示例 3:使用DataFrame.div()方法分割数据帧并填充空值
以下示例显示了使用fill_value=1.的DataFrame.div()方法将数据帧与其他数据帧分割
import pandas as pd
df1 = pd.DataFrame({'a': [2, 5, 6],'b': [8, 10, 12],'c': [14, 16, 18]})
df2 = pd.DataFrame({'a': [2, 2, 2],'b': [2, 2, 2]})
print(df1.div(df2,fill_value=1))
一旦我们运行该程序，我们将获得以下输出。
a b c
0 1.0 4.0 14.0
1 2.5 5.0 16.0
2 3.0 6.0 18.0
结论
在本教程中，我们学习了 PandasDataFrame.div()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。
Pandas 数据帧dot()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-dot-method
在本教程中，我们将学习蟒PandasDataFrame.dot() 法。它计算数据帧和其他数据帧之间的矩阵乘法。该方法计算数据帧与另一个Series、DataFrame或一个 numpy array的值之间的矩阵乘积。它返回一个序列或数据帧。
-
为了计算矩阵乘法，数据帧的尺寸和其他尺寸必须兼容。
-
此外，数据帧的列名和其他的索引必须包含相同的值，因为它们将在乘法之前对齐。
下图显示了DataFrame.dot()方法的语法。
句法
DataFrame.dot(other)
因素
其他:系列，数据帧或类似数组。另一个用来计算矩阵乘积的对象。
示例 1:Pandas 中的 DataFrame.dot()方法
在下面的示例中，创建了两个数据帧，一个数据帧中的元素与另一个数据帧中的元素相乘。DataFrame.dot()方法通过将所有相乘的值相加来返回数据帧。
#importing pandas as pd
import pandas as pd
#creating DataFrames
df1=pd.DataFrame([[0,1,1, 2],[2,1,1,0]],columns=('A','B','C','D'))
df2=pd.DataFrame([[1, 2], [2, 3],[2, 3],[4,1]],index=('A','B','C','D'))
print(df1)
print(df2)
print(df1.dot(df2))
一旦我们运行该程序，我们将获得以下输出。
A B C D
0 1 1 2
1 2 1 1 0
0 1
A 1 2
B 2 3
C 2 3
D 4 1
0 1
0 12 8
1 6 10
示例 2:Pandas 中的 DataFrame.dot()方法
下面的例子类似于前面的例子。创建两个数据帧，应用DataFrame.dot()方法，得到矩阵乘法数据帧。
#importing pandas as pd
import pandas as pd
#creating DataFrames
df1= pd.DataFrame([[1, 1, 1],[2, 2, 2],[3, 3, 3]])
df2= pd.DataFrame([[1, 0, 0],[0, 1, 0],[0, 0, 1]])
print(df1.dot(df2))
一旦我们运行该程序，我们将获得以下输出。
0 1 2
0 1 1 1
1 2 2 2
2 3 3 3
示例 3:使用带有Series的 DataFrame.dot()方法计算矩阵乘法。
在下面的示例中，创建了一个数据帧和系列，一个数据帧中的元素与系列中的元素相乘。DataFrame.dot()方法通过将所有相乘的值相加来返回数据帧。
#importing pandas as pd
import pandas as pd
#creating DataFrames
df1= pd.DataFrame([[1, 1, 1],[2, 2, 2],[3, 3, 3]],columns=('a','b','c'))
df2=pd.Series([1, 1, 2],index=('a','b','c'))
print(df1)
print(df2)
print(df1.dot(df2))
一旦我们运行该程序，我们将获得以下输出。
a b c
0 1 1 1
1 2 2 2
2 3 3 3
a 1
b 1
c 2
数据类型:int64
0 4
1 8
2 12
数据类型:int64
示例 4:乘以数据帧时的值错误
如果矩阵没有对齐，我们将得到ValueError异常。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#creating DataFrames
df1=pd.DataFrame([[0, 1], [1, 2],[2, 0]])
df2=pd.DataFrame([[1, 2], [2, 3],[2, 3]])
print(df1.dot(df2))
一旦我们运行该程序，我们将获得以下输出。
值错误:矩阵未对齐
结论
在本教程中，我们学习了 PythonPandasDataFrame.dot()方法。我们通过将数据帧乘以DataFrame、Series、np.array来求解这个例子，得到了数据帧的矩阵乘法。
Pandas 数据帧drop()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-drop-method
在本教程中，我们将学习 PandasDataFrame.drop()T3】法。它从行或列中删除指定的标签。它通过指定标签名和相应的轴，或者通过直接指定索引或列名来删除行或列。使用多索引时，可以通过指定级别来移除不同级别上的标签。
-
它返回数据帧或无。没有删除索引或列标签的数据帧，或者
inplace=True.为无 -
如果在所选轴中找不到任何标签，将引发
KeyError异常。
下图显示了DataFrame.drop()方法的语法。
句法
DataFrame.drop(labels=None,axis=0,index=None,columns=None,level=None,inplace=False,errors='raise')
因素
标签:单个标签或列表状。要删除的索引或列标签。
轴: {0 或'索引'，1 或'列' }，默认为 0。是从索引(0 或“索引”)还是从列(1 或“列”)中删除标签。
索引:单个标签或列表状。指定轴的替代方法(标签，轴=0 相当于索引=标签)。
列:单个标签或列表状。指定轴的替代方法(标签，轴=1 相当于列=标签)。
级别: int 或级别名称，可选。对于多索引，标签将被移除的级别。
inplace: bool，默认 False。如果为假，则返回副本。否则，就地操作并返回无。
错误: { '忽略'，'提高' }，默认为'提高'。如果“忽略”，抑制错误，仅删除现有标签。
示例 1:使用 DataFrame.drop()方法删除行
DataFrame.drop()方法沿着row轴从数据帧中删除指定的标签。下面的例子显示了同样的情况。
import pandas as pd
df=pd.DataFrame([[0,1,2,3], [4,5,6,7],[8,9,10,11]],columns=('a','b','c','d'))
print("------DataFrame-------")
print(df)
print("------After dropping a specific label from the row of the DataFrame-------")
print(df.drop(1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c d
0 1 2 3
1 4 5 6 7
2 8 9 10 11
-从数据帧的行中删除特定标签后-
a b c d
0 1 2 3
2 8 9 10 11
示例 2:使用 DataFrame.drop()方法删除行
DataFrame.drop()方法通过交替指定轴index=1从数据帧中删除指定的标签。下面的例子显示了同样的情况。
import pandas as pd
df=pd.DataFrame([[0,1,2,3], [4,5,6,7],[8,9,10,11]],columns=('a','b','c','d'))
print("------DataFrame-------")
print(df)
print("------------After dropping a specific label from the row of the DataFrame---------")
print(df.drop(index=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c d
0 1 2 3
1 4 5 6 7
2 8 9 10 11
-从数据帧的行中删除特定标签后-
a b c d
0 1 2 3
2 8 9 10 11
示例 3:使用 DataFrame.drop()方法删除行
DataFrame.drop()方法沿着column轴从数据帧中删除指定的标签。下面的例子显示了同样的情况。
import pandas as pd
df=pd.DataFrame([[0,1,2,3], [4,5,6,7],[8,9,10,11]],columns=('a','b','c','d'))
print("------DataFrame-------")
print(df)
print("------After dropping a specific label from the column of the DataFrame-------")
print(df.drop('b',axis=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c d
0 1 2 3
1 4 5 6 7
2 8 9 10 11
-从数据帧的列中删除特定标签后-
a c d
0 2 3
1 4 6 7
2 8 10 11
示例 4:使用 DataFrame.drop()方法删除行
DataFrame.drop()方法通过交替指定轴column=’b’从数据帧中删除指定的标签。下面的例子显示了同样的情况。
import pandas as pd
df=pd.DataFrame([[0,1,2,3], [4,5,6,7],[8,9,10,11]],columns=('a','b','c','d'))
print("------DataFrame-------")
print(df)
print("------After dropping a specific label from the column of the DataFrame-------")
print(df.drop(columns='b'))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
a b c d
0 1 2 3
1 4 5 6 7
2 8 9 10 11
-从数据帧的列中删除特定标签后-
a c d
0 2 3
1 4 6 7
2 8 10 11
示例 5:使用 DataFrame.drop()方法删除行
如果在所选轴中没有找到任何标签，DataFrame.drop()方法将引发KeyError。
import pandas as pd
df=pd.DataFrame([[0,1,2,3], [4,5,6,7],[8,9,10,11]],columns=('a','b','c','d'))
print("------After dropping a specific label from the row of the DataFrame-------")
print(df.drop(5))
一旦我们运行该程序，我们将获得以下输出。
-从数据帧的行中删除特定标签后-
键错误:“[5]在轴中找不到”
结论
在本教程中，我们学习了 PythonPandasDataFrame.drop()方法。我们学习了语法、参数，并通过向方法传递不同的参数来解决示例。
Pandas 数据帧drop_duplicates()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-drop_duplicates-method
在本教程中，我们将学习 PandasDataFrame.drop_duplicates() T3】法。它返回一个删除了重复行的数据帧。考虑某些列是可选的。包括时间索引在内的索引将被忽略。
下图显示了DataFrame.drop_duplicates()方法的语法。
句法
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)
因素
子集:列标签或标签序列，可选。仅考虑用于识别重复项的特定列，默认情况下使用所有列。
keep: {'first '，' last '，False}，默认为' first '。确定要保留哪些副本(如果有)。- first:除去第一次出现的重复项。- last:除去最后一次出现的重复项。- False:删除所有重复项。
inplace: bool，默认 False。是就地删除副本还是返回副本。
ignore_index: bool，默认 False。如果为真，结果轴将被标记为 0，1，…，n - 1。
示例 1:使用 DataFrame.drop_duplicates()方法删除重复行
DataFrame.drop_duplicates()方法根据列删除重复的行。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya','Vindya', 'Navya', 'Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print(df)
print("-------After removing duplicate rows------")
print(df.drop_duplicates())
一旦我们运行该程序，我们将获得以下输出。
命名技能
0 纳芙雅 Python
1 Vindya Java
2 纳芙雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-删除重复行后-
命名技能
0 纳芙雅 Python
1 Vindya Java
4 Sinchana Java
示例 2:使用 DataFrame.drop_duplicates()方法删除重复行
DataFrame.drop_duplicates() 方法使用subset方法删除特定列上的重复行。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya', 'Vindya','Navya','Vindya','Sinchana','Sinchana'],'Skills': ['Python', 'Java','Python','Java','Java','Java']})
print(df)
print("-------After removing duplicate rows------")
print(df.drop_duplicates(subset=['Skills']))
一旦我们运行该程序，我们将获得以下输出。
命名技能
0 纳芙雅 Python
1 Vindya Java
2 纳芙雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-删除重复行后-
命名技能
0 纳芙雅 Python
1 Vindya Java
示例 3:使用 DataFrame.drop_duplicates()方法删除重复行
DataFrame.drop_duplicates()方法通过保留last occurrences并使用keep方法删除重复行。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya', 'Vindya','Navya','Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print(df)
print("-------After removing duplicate rows------")
print(df.drop_duplicates(subset=['Name', 'Skills'], keep='last'))
一旦我们运行该程序，我们将获得以下输出。
命名技能
0 纳芙雅 Python
1 Vindya Java
2 纳芙雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-删除重复行后-
命名技能
2 纳芙雅 Python
3 Vindya Java
5 Sinchana Java
结论
在本教程中，我们将学习DataFrame.drop_duplicates()方法。我们学习了语法、参数，并通过在 DataFrame 上应用此方法解决了示例，并理解了该方法。
Pandas 数据帧droplevel()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-droplevel-method
在本教程中，我们将学习 PandasDataFrame.droplevel()T4 法。它返回删除了请求的索引/列级别的数据帧。下面显示了DataFrame.droplevel()方法的语法。
句法
DataFrame.droplevel(level, axis=0)
因素
级别: int、str 或类似列表。如果给定了字符串，则必须是级别的名称。如果类似于列表，元素必须是级别的名称或位置索引。
轴: {0 或'索引'，1 或'列' }，默认为 0。移除标高的轴:
-
0 或“索引”:删除列中的级别。
-
1 或“列”:删除行中的级别。
示例 1:使用DataFrame.droplevel()方法降低液位
DataFrame.droplevel()方法沿row轴降低数据帧中的指定级别。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame([[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]).set_index([0, 1]).rename_axis(['a', 'b'])
df.columns = pd.MultiIndex.from_tuples([('c', 'e'), ('d', 'f')], names=['level_1', 'level_2'])
print(df)
print("-----After dropping the specified level------")
print(df.droplevel('a'))
一旦我们运行该程序，我们将获得以下输出。
级别 _1 c d
级别 _ 2 e f
a b
1 2 3 4
5 6 7 8
9 10 11 12
-下降指定级别后-
级别 _1 c d
级别 _ 2 e f
b
2 3 4
6 7 8
10 11 12
示例 2:使用DataFrame.droplevel()方法降低液位
DataFrame.droplevel()方法沿row轴降低数据帧中的指定级别。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame([[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]).set_index([0, 1]).rename_axis(['a', 'b'])
df.columns = pd.MultiIndex.from_tuples([('c', 'e'), ('d', 'f')], names=['level_1', 'level_2'])
print(df)
print("-----After dropping the specified level------")
print(df.droplevel(1))
一旦我们运行该程序，我们将获得以下输出。
级别 _1 c d
级别 _ 2 e f
a b
1 2 3 4
5 6 7 8
9 10 11 12
-下降指定级别后-
级别 _1 c d
级别 _ 2 e f
a
1 3 4
5 7 8
9 11 12
示例 3:使用DataFrame.droplevel()方法降低液位
DataFrame.droplevel()方法沿column轴降低数据帧中的指定级别。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame([[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]).set_index([0, 1]).rename_axis(['a', 'b'])
df.columns = pd.MultiIndex.from_tuples([('c', 'e'), ('d', 'f')], names=['level_1', 'level_2'])
print(df)
print("-----After dropping the specified level------")
print(df.droplevel('level_2', axis=1))
一旦我们运行该程序，我们将获得以下输出。
级别 _1 c d
级别 _ 2 e f
a b
1 2 3 4
5 6 7 8
9 10 11 12
-下降指定级别后-
级别 _ 1 c d
a b
1 2 3 4
5 6 7 8
9 10 11 12
结论
在本教程中，我们学习了 PandasDataFrame.droplevel()方法。我们学习了语法、参数，并通过将此方法应用于数据帧来解决示例，并理解了示例。
Pandas 数据帧dropna()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-dropna-method
在本教程中，我们将学习 PandasDataFrame.dropna()方法。它删除丢失的值，并返回数据帧，其中删除了无条目，如果inplace=True，则返回无。
下图显示了 PandasDataFrame.dropna()方法的语法。
句法
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
因素
轴: {0 或'索引'，1 或'列' }，默认为 0。确定是否删除了包含缺失值的行或列。
-
0 或“索引”:删除包含缺失值的行。
-
1 或“列”:删除包含缺失值的列。
在 1.0.0 版本中更改:将元组或列表传递到多个轴上。只允许一个轴。
how: {'any '，' all'}，默认' any '。当我们至少有一个 NA 或所有 NA 时，确定是否从数据帧中删除行或列。
-
' any ':如果存在任何 NA 值，请删除该行或列。
-
' all ':如果所有值都为 NA，则删除该行或列。
thresh: int，可选。要求许多非 NA 值。
子集:沿其他轴的类似数组的可选标签，例如，如果您要删除行，这些将是要包括的列列表。
inplace: bool，默认 False。如果为真，则就地执行操作，并返回无。
示例 1:使用DataFrame.dropna()方法删除行
在下面的例子中，由至少一个缺失值或空值组成的行将使用DataFrame.dropna()方法从数据帧中删除。
import pandas as pd
df= pd.DataFrame([['Abhishek',100,'Science',None], ['Anurag',101,'Science',85],['Chetan',103,'Maths',None]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print("------DataFrame-----")
print(df)
print("------After dropping the rows consisting of null values---------")
print(df.dropna())
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
名称卷无主题标记
0 Abhishek 100 Science NaN
1 anu rag 101 Science 85.0
2 Chetan 103 数学 NaN
-删除由空值组成的行后-
名称卷无主题标记
1 Anurag 101 Science 85.0
示例 2:使用DataFrame.dropna()方法删除行
在下面的例子中，由至少一个缺失值或空值组成的列将使用DataFrame.dropna()方法从数据帧中删除。
import pandas as pd
df= pd.DataFrame([['Abhishek',None,'Science',None], ['Anurag',101,'Science',85],['Chetan',103,'Maths',None]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print("----------DataFrame-----------")
print(df)
print("------After dropping the columns consisting of null values---------")
print(df.dropna(axis=1))
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称卷无主题标记
0 Abhishek NaN Science NaN
1 anu rag 101.0 Science 85.0
2 Chetan 103.0 数学 NaN
-删除由空值组成的列后-
名称主题
0 Abhishek Science
1 anu rag Science
2 Chetan 数学
示例 3:使用DataFrame.dropna()方法删除行
在下面的示例中，DataFrame.dropna()方法通过仅保留至少有 2 个非 NA 值的行来删除行。
import pandas as pd
df= pd.DataFrame([[None,None,'Science',None], ['Anurag',101,'Science',None],['Chetan',None,'Maths',None]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print("------DataFrame-----")
print(df)
print("------After dropping the rows consisting of null values---------")
print(df.dropna(thresh=2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧-
名称滚动无主题标记
0 无楠科学无
1 无拉格 101.0 科学无
2 车坦楠数学无
-删除由空值组成的行后-
名称滚动无主题标记
1 无拉格 101.0 科学无
2 车坦楠数学无
示例 4:使用DataFrame.dropna()方法删除行
通过在DataFrame.dropna()方法中使用子集方法定义在哪些列中查找缺失值，我们可以删除这些列。
import pandas as pd
df= pd.DataFrame([['Abhishek',None,'Science',None], ['Anurag',101,'Science',85],['Chetan',103,'Maths',75]], columns=['Name', 'Roll No', 'Subject', 'Marks'])
print("----------DataFrame-----------")
print(df)
print("------After dropping the columns consisting of null values---------")
print(df.dropna(subset=['Subject','Marks']))
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称卷无主题标记
0 Abhishek NaN Science NaN
1 anu rag 101.0 Science 85.0
2 Chetan 103.0 数学 75.0
-删除由空值组成的列后-
名称卷无主题标记
1 Anurag 101.0 科学 85.0
2 Chetan 103.0 数学 75.0
结论
在本教程中，我们学习了 PandasDataFrame.dropna()方法。我们学习了语法、参数，并通过将此方法应用于数据帧来解决示例，并理解了示例。
Pandas 数据帧duplicated()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-duplicated-method
在本教程中，我们将学习 PandasDataFrame.duplicated()方法。它返回表示重复行的布尔序列。我们可以考虑某些列，但它是可选的。它返回每个重复行的布尔序列。
下图显示了DataFrame.duplicated()方法的语法。
句法
DataFrame.duplicated(subset=None, keep='first')
因素
子集:列标签或标签序列，可选
仅考虑用于识别重复项的特定列，默认情况下使用所有列。
keep: {'first '，' last '，False}，默认为' first '
确定要标记哪些副本(如果有)。
-
first:除第一次出现外，将重复标记为True。 -
last:除最后一次出现外，将重复标记为True。 -
假:将所有重复标记为
True。
示例 1:使用DataFrame.duplicated()方法查找重复的列
下面的示例显示了默认情况下，对于数据帧中的每组重复值，第一个匹配项设置在False上，所有其他匹配项设置在True上。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya','Vindya', 'Navya', 'Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print("-----------DataFrame--------")
print(df)
print("------Finding duplicates rows-------")
print(df.duplicated())
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称技巧
0 纳维雅 Python
1 Vindya Java
2 纳维雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-查找重复行-
0 False
1 False
2 True
3 True
4 False
5 True
dtype:bool
示例 2:使用DataFrame.duplicated()方法查找重复的列
下面的例子显示了通过使用‘last’，每组重复值的最后一次出现被设置在False上，所有其他的都被设置在True上。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya','Vindya', 'Navya', 'Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print("-----------DataFrame--------")
print(df)
print("------Finding duplicates rows-------")
print(df.duplicated(keep='last'))
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称技巧
0 纳维雅 Python
1 Vindya Java
2 纳维雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-查找重复行-
0 True
1 True
2 False
3 False
4 True
5 False
dtype:bool
示例 3:使用DataFrame.duplicated()方法查找重复的列
下面的例子显示了通过在False上设置keep，所有的副本都是True。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya','Vindya', 'Navya', 'Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print("-----------DataFrame--------")
print(df)
print("------Finding duplicates rows-------")
print(df.duplicated(keep=False))
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称技巧
0 纳维雅 Python
1 Vindya Java
2 纳维雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-查找重复行-
0 True
1 True
2 True
3 True
4 True
5 True
dtype:bool
示例 4:使用DataFrame.duplicated()方法查找重复的列
以下示例显示了如何使用subset方法在特定列中查找重复项。
import pandas as pd
df = pd.DataFrame({'Name': ['Navya','Vindya', 'Navya', 'Vindya','Sinchana','Sinchana'],'Skills': ['Python','Java','Python','Java','Java','Java']})
print("-----------DataFrame--------")
print(df)
print("------Finding duplicates rows-------")
print(df.duplicated(subset=['Skills']))
一旦我们运行该程序，我们将获得以下输出。
- DataFrame -
名称技巧
0 纳维雅 Python
1 Vindya Java
2 纳维雅 Python
3 Vindya Java
4 Sinchana Java
5 Sinchana Java
-查找重复行-
0 False
1 False
2 True
3 True
4 True
5 True
dtype:bool
结论:
在本教程中，我们学习了 PandasDataFrame.duplicated()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.duplicated()方法。
Pandas 数据帧eq()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-eq-method
在本教程中，我们将学习 PandasDataFrame.eq()T4 法。它用于逐个元素地检查数据帧中的相等值。它返回由真和假组成的布尔值的数据帧。相当于==运算符，支持选择轴(行或列)和级别进行比较。
下图显示了DataFrame.eq()方法的语法。
句法
DataFrame.eq(other, axis='columns', level=None)
因素
其他:标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。
轴: {0 或‘索引’，1 或‘列’，默认‘列’。是按索引(0 或“索引”)还是按列(1 或“列”)进行比较。
级别: int 或 label。跨级别广播，匹配传递的多索引级别上的索引值。
示例:查找 dataframe 元素与指定值的比较
通过对数据帧应用DataFrame.eq()方法，我们可以得到与指定值的比较。下面的例子显示了同样的情况。
import pandas as pd
df = pd.DataFrame({"Roll no": [100, 101, 102, 103],"Marks": [60, 62, 65, 59]},index= ["Saanvi", "Hasini", "Lakshmi", "Kushi"])
print("-------The DataFrame is---------")
print(df)
print("----Find the comparison of the dataframe element with value----")
print(df.eq(62))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
滚动无标记
萨昂威 100 60
哈西尼 101 62
拉克什米 102 65
库什 103 59
-找到数据帧元素与值的比较-
滚动无标记
萨昂威假假假
哈西尼假真
拉克什米假假
库什假假假假
示例 2:查找 dataframe 元素与指定值的比较
这里，使用DataFrame.eq()方法，我们可以将数据帧元素与特定值进行比较。见下面的例子。
#Comparing different column with different value
import pandas as pd
df = pd.DataFrame({"Roll no": [100, 101, 102, 103],"Marks": [60, 62, 65, 59]},index= ["Saanvi", "Hasini", "Lakshmi", "Kushi"])
print("-------The DataFrame is---------")
print(df)
print("----Find the comparison of the dataframe element----")
print(df.eq([101,62]))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
无标记滚动
萨昂威 100 60
哈西尼 101 62
拉克希米 102 65
库什 103 59
-找到数据帧元素的对比-
无标记滚动
萨昂威假
哈西尼真
拉克希米假
库什假假假
示例:查找数据帧元素与不同值的比较
通过使用DataFrame.eq()方法，我们可以将数据帧元素的选定列与值进行比较。下面的例子显示了同样的情况。
#Comparing selected column with different value
import pandas as pd
df = pd.DataFrame({"Roll no": [100, 101, 102, 103],"Marks": [60, 62, 65, 59]},index= ["Saanvi", "Hasini", "Lakshmi", "Kushi"])
print("-------The DataFrame is---------")
print(df)
print("----Find the comparison of the dataframe element----")
print(df["Marks"].eq(62))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
滚动无标记
萨昂威 100 60
哈西尼 101 62
拉克什米 102 65
库什 103 59
-找到数据帧元素的对比-
萨昂威假
哈西尼真
拉克什米假
库什假
名称:标记，数据类型:bool
示例:查找数据帧元素的比较
使用DataFrame.eq()方法，我们可以将数据帧元素的选定列与值进行比较。下面的例子显示了同样的情况。
#Comparing selected columns with different value
import pandas as pd
chart = {'Name':['Chetan','yashas','yuvraj'],'Age': [20,25,30],'Height': [155,170,165],'Weight': [59,60,75]}
df = pd.DataFrame(chart)
print("-------The DataFrame is---------")
print(df)
print("----Find the comparison of the dataframe element----")
print(df[["Age", "Weight"]].eq([20,60]))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
名称年龄身高体重
0 车坦 20 155 59
1 雅夏 25 170 60
2 尤瓦拉吉 30 165 75
-查找数据帧元素的比较-
年龄体重
0 真假
1 假真
2 假假
示例:查找数据帧元素的比较
使用DataFrame.eq()方法，我们可以比较数据帧的列，并将结果放入数据帧列中。下面的例子显示了同样的情况。
#Comparing selected columns with different value
import pandas as pd
df = pd.DataFrame({"col1": [10, 30, 60, 40, 20],"col2": [10, 15, 60, 45, 20]})
print("-------The DataFrame is---------")
print(df)
print("----Find the comparison of the dataframe element----")
df['Result'] = df['col1'].eq(df['col2'])
print(df)
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
col 1 col 2
0 10
1 30 15
2 60 60
3 40 45
4 20 20
-查找数据帧元素的比较-
col1 col2 结果
0 10 10 True
1 30 15 False
2 60 60 True
3 40 45 False
4 220
结论
在本教程中，我们将学习 PandasDataFrame.eq()方法。我们解决了一些例子，并比较了数据帧元素、具有特定值的列，得到了 bool 的数据帧。
Pandas 数据帧equals()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-equals-method
在本教程中，我们将学习 PandasDataFrame.equals() 法。它测试两个对象是否包含相同的元素。该方法允许将两个序列或数据帧相互比较，以查看它们是否具有相同的形状和元素。同一地点的南航被认为是平等的。如果两个对象中的所有元素都相同，则返回bool、True，否则返回False。
- 行/列索引不需要具有相同的类型，只要这些值被认为是相等的。
- 相应的列必须是相同的数据类型。
下图显示了DataFrame.equals()方法的语法。
句法
DataFrame.equals(other)
因素
其他:序列或数据帧。要与第一个序列或数据帧进行比较的另一个序列或数据帧。
示例 1:DataFrame.equals()方法
这里，数据帧df1和df2的元素和列标签具有相同的类型和值，这将返回True。
import pandas as pd
df1 = pd.DataFrame({"col_1": [10,20], "col_2": [20,30]})
print("----The First DataFrame is-----")
print(df1)
df2 = pd.DataFrame({"col_1": [10,20], "col_2": [20,30]})
print("----The second DataFrame is-----")
print(df2)
print("Are the elements in two DataFrame contains same elements:",df1.equals(df2))
一旦我们运行该程序，我们将获得以下输出。
-第一个数据帧是-
col _ 1 col _ 2
0 10 20
1 20 30
-第二个数据帧是-
col _ 1 col _ 2
0 10 20
1 20 30
两个数据帧中的元素是否包含相同的元素:真
示例 2:DataFrame.equals()方法
下面的例子与前面的例子相似。由空值和同一位置的空值组成的数据帧df1和df2被视为相等。
import pandas as pd
df1 = pd.DataFrame({"col_1": [10,None], "col_2": [20,30]})
print("----The First DataFrame is-----")
print(df1)
df2 = pd.DataFrame({"col_1": [10,None], "col_2": [20,30]})
print("----The second DataFrame is-----")
print(df2)
print("Are the elements in two DataFrame contains same elements:",df1.equals(df2))
一旦我们运行该程序，我们将获得以下输出。
-第一个数据帧是-
col _ 1 col _ 2
0 10.0 20
1 NaN 30
-第二个数据帧是-
col _ 1 col _ 2
0 10.0 20
1 NaN 30
两个数据帧中的元素是否包含相同的元素:True
示例 3:DataFrame.equals()方法
数据帧df1和df2对于其元素的相同值具有不同的类型，并且将返回False，即使它们的列标签是相同的值和类型。
import pandas as pd
df1 = pd.DataFrame({"col_1": [10.0,20.0], "col_2": [20.0,30.0]})
print("----The First DataFrame is-----")
print(df1)
df2 = pd.DataFrame({"col_1": [10,20], "col_2": [20,30]})
print("----The second DataFrame is-----")
print(df2)
print("Are the elements in two DataFrame contains same elements:",df1.equals(df2))
一旦我们运行该程序，我们将获得以下输出。
-第一个数据帧是-
col _ 1 col _ 2
0 10.0 20.0
1 20.0 30.0
-第二个数据帧是-
col _ 1 col _ 2
0 10 20
1 20 30
两个数据帧中的元素是否包含相同的元素:False
结论
在本教程中，我们学习了 PandasDataFrame.equals() 方法。我们通过将该方法应用于两个不同的数据帧来解决不同的例子。
Pandas 数据帧expanding()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-expanding-method
在本教程中，我们将学习 PandasDataFrame.expanding()方法。这是 Pandas 的窗口方法之一，它提供了扩展转换。它返回一个为特定操作分类的窗口。
下图显示了DataFrame.expanding()方法的语法。
句法
DataFrame.expanding(min_periods=1, center=None, axis=0)
因素
min_periods: int，默认 1。窗口中具有一个值所需的最小观察次数(否则结果为“无”)。
中心: bool，默认 False。将标签设置在窗口的中心。
轴: int 或 str，默认为 0
示例 1:扩展数据帧
在下面的例子中，DataFrame.expanding()方法计算整个数据帧的累积总和。
import pandas as pd
df = pd.DataFrame({"A": [1, 2, 3],"B": [1, 1, 1]})
print("---The DataFrame is---")
print(df)
print("------Output of the function is-------")
print(df.expanding().sum())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B
0 1 1
1 2 1
2 3 1
-方法输出为-
A B
0 1.0 1.0
1 3.0 2.0
2 6.0 3.0
示例 2:扩展数据帧
在下面的示例中，DataFrame.expanding()方法计算数据帧中所选列的累积和，并将结果存储在另一列中。
import pandas as pd
df = pd.DataFrame({"A": [1, 2, 3],"B": [1, 1, 1]})
print("---The DataFrame is---")
print(df)
print("------Output of the function is-------")
df["result"]=df.A.expanding().sum()
print(df)
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B
0 1 1
1 2 1
2 3 1
-方法输出为-
A B 结果
0 1 1 1.0
1 2 1 3.0
2 3 1 6.0
示例 3:扩展数据帧
在下面的例子中，DataFrame.expanding()方法计算了沿着行轴的整个数据帧的累积总和。
import pandas as pd
df = pd.DataFrame({"A": [1, 2, 3],"B": [1, 1, 1]})
print("---The DataFrame is---")
print(df)
print("------Output of the function is-------")
print(df.expanding(axis=1).sum())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B
0 1 1
1 2 1
2 3 1
-方法输出为-
A B
0 1.0 2.0
1 2.0 3.0
2 3.0 4.0
示例 4:用最小周期扩展数据帧
在以下示例中，DataFrame.expanding()方法使用min_periods=2.计算整个数据帧的累积总和
import pandas as pd
df = pd.DataFrame({"A": [1, 2, 3],"B": [1, 1, 1]})
print("---The DataFrame is---")
print(df)
print("------Output of the function is-------")
print(df.expanding(min_periods=2).sum())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B
0 1 1
1 2 1
2 3 1
-方法输出为-
A B
0 NaN NaN
1 3.0 2.0
2 6.0 3.0
结论:
在本教程中，我们学习了 PandasDataFrame.expanding() 法。我们通过将这种方法应用于数据帧来解决不同的例子。我们将该方法应用于具有均值、中值、方差、协方差、相关性、等的数据帧。，并观察输出。
Pandas 数据帧explode()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-explode-method
在本教程中，我们将学习 PandasDataFrame.explode()T3】法。它将列表中的每个元素转换为一行，复制索引值。它将数据帧分解列表返回给子集列的行；将为这些行复制索引。
下图显示了DataFrame.explode()方法的语法。
句法
DataFrame.explode(column, ignore_index=False)
因素
列:字符串或元组。柱子要爆炸了。
ignore_index: bool，默认 False。如果为真，结果索引将被标记为 0，1，…，n - 1。
示例 1:使用DataFrame.explode()方法分解数据帧
如果数据帧列中的某些元素由列表组成，我们可以使用DataFrame.explode()方法将其扩展到多个列。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [[1,3],[3]], 'B': 1})
print("------The DataFrame is--------")
print(df)
print("After expanding the DataFrame")
print(df.explode('A'))
一旦我们运行该程序，我们将获得以下输出。
-展开数据帧
A B
0 1
0 3 1
1 3 1
后，数据帧为-
A B
0 1
0 3 1
1 3 1
示例 2:使用DataFrame.explode()方法分解数据帧
这个例子和前面的例子类似，只是我们使用了ignore_index=True参数，得到的索引会被标记为 0，1，…，n - 1。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [[1,3],[4]], 'B': 1})
print("------The DataFrame is--------")
print(df)
print("After expanding the DataFrame")
print(df.explode('A',ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
-展开数据帧
A B
0 1
1 3 1
2 4 1 后，数据帧为-
A B
0 [1，3] 1
1 [4] 1
示例 3:使用DataFrame.explode()方法分解数据帧
这个例子类似于前面的例子。空列表将被扩展成一个numpy.nan值。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [[1, 2], []], 'B': 1})
print("------The DataFrame is--------")
print(df)
print("After expanding the DataFrame")
print(df.explode('A',ignore_index=True))
一旦我们运行该程序，我们将获得以下输出。
-展开数据帧
A B
0 1
1 2 1
2 NaN 1 后，数据帧为-
A B
0 [1，2]1
1【】1
结论
在本教程中，我们学习了 PandasDataFrame.explode()方法。我们学习了语法、参数，并通过在由作为元素的列表组成的数据帧上应用这种方法解决了一些例子。
Pandas 数据帧ffill()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-ffill-method
在本教程中，我们将学习 PandasDataFrame.ffill()T4 法。此方法填充数据帧中缺失的值，填充代表"forward fill"，它取空值之前的最后一个值并填充它。
下图显示了 PandasDataFrame.ffill()方法的语法。
句法
DataFrame.ffill(axis=None, inplace=False, limit=None, downcast=None)
因素
轴: {0 或‘索引’，1 或‘列’}。填充缺失值的轴。
inplace: bool，默认 False。如果为真，请填写位置。T3】
注意:这将修改该对象上的任何其他视图(例如，数据帧中某列的无拷贝切片)。
限制: int，默认无。如果指定了方法，这是向前/向后填充的连续 NaN 值的最大数量。换句话说，如果有一个超过这个数量的连续 nan 的间隙，它将只被部分填充。如果未指定方法，这是沿整个轴将填充 NaNs 的最大条目数。如果不是“无”，则必须大于 0。
向下转换: dict，默认值为无。项的字典- >如果可能的话，要向下转换的数据类型，或者尝试向下转换为适当的相等类型的字符串“推断”(例如，如果可能的话，float64 到 int64)。
示例 1:使用DataFrame.ffill()方法填充缺失值
DataFrame.ffill()方法沿指定轴填充缺失值。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating DataFrame with null values
df=pd.DataFrame({"A":[2,None,4],"B":[None,4,np.nan],"C":[2,0.25,np.nan],"D":[9,4,None]})
print("---DataFrame is------")
print(df)
print("----Filling missing values--------")
print(df.ffill())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C D
0 2.0 NaN 2.00 9.0
1 NaN 4.0 0.25 4.0
2 4.0 NaN NaN
-填充缺失值-
A B C D
0 2.0 NaN 2.00 9.0
1 2.0 4.0 0 0.25 4.0
2 4.0 4.0 0 0.25 4.0
示例 2:使用DataFrame.ffill()方法填充缺失值
DataFrame.ffill()方法沿指定轴填充缺失值。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating DataFrame with null values
df=pd.DataFrame({"A":[2,None,4],"B":[None,4,np.nan],"C":[2,0.25,np.nan],"D":[9,4,None]})
print("---DataFrame is------")
print(df)
print("----Filling missing values--------")
print(df.ffill(axis=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C D
0 2.0 NAn 2.00 9.0
1 NAn 4.0 0.25 4.0
2 4.0 NAn NAn NAn
-填充缺失值-
A B C D
0 2.0 2.0 2.00 9.0
1 NAn 4.0 0 25 4.0
2 4.0 4.0 4.00 4.0
示例 3:使用DataFrame.ffill()方法填充缺失值
如果inplace=True 就地填充并返回None，则DataFrame.ffill()方法沿指定的轴填充缺失的值。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating DataFrame with null values
df=pd.DataFrame({"A":[2,None,4],"B":[None,4,np.nan],"C":[2,0.25,np.nan],"D":[9,4,None]})
print("---DataFrame is------")
print(df)
print("----Filling missing values--------")
print(df.ffill(axis=1,inplace=True))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C D
0 2.0 NAn 2.00 9.0
1 NAn 4.0 0.25 4.0
2 4.0 NAn NAn NAn
-填充缺失值-
无
示例 4:使用DataFrame.ffill()方法填充缺失值
如果指定了limit方法，这是向前填充数据帧的最大连续 NaN 值。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating DataFrame with null values
df=pd.DataFrame({"A":[2,None,4],"B":[None,4,np.nan],"C":[2,0.25,np.nan],"D":[9,4,None]})
print("---DataFrame is------")
print(df)
print("----Filling missing values--------")
print(df.ffill(axis=1,limit=2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C D
0 2.0 NAn 2.00 9.0
1 NAn 4.0 0.25 4.0
2 4.0 NAn NAn NAn
-填充缺失值-
A B C D
0 2.0 2.0 2.00 9.0
1 NAn 4.0 0 25 4.0
2 4.0 4.0 4.00 NAn
结论
在本教程中，我们学习了 PandasDataFrame.ffill()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.ffill()方法。
Pandas 数据帧fillna()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-fillna-method
在本教程中，我们将学习 PandasDataFrame.fillna() 法。此方法使用指定的方法填充 NA/NaN 值。它返回填充了缺失值的数据帧对象，如果是inplace=True，则返回None。
下图显示了DataFrame.fillna()方法的语法。
句法
DataFrame.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)
因素
值:标量、字典、序列或数据帧。用于填充孔的值(例如 0)，或者指定每个索引(对于系列)或列(对于数据帧)使用的值的字典/系列/数据帧。不在字典/序列/数据帧中的值将不会被填充。该值不能是列表。
方法: { '回填'，'填充'，'填充'，'填充'，'无' }，默认无。用于填充重新索引的系列填充板/填充孔的方法:将最后一个有效观察值向前传播到下一个有效回填/填充孔:使用下一个有效观察值填充间隙。
轴: {0 或‘索引’，1 或‘列’}。填充缺失值的轴。
inplace: bool，默认 False。如果为真，请就地填写。注意:这将修改此对象上的任何其他视图(例如，数据帧中某列的无拷贝切片)。
限制: int，默认无。如果指定了方法，这是向前/向后填充的连续 NaN 值的最大数量。换句话说，如果有一个超过这个数量的连续 nan 的间隙，它将只被部分填充。如果未指定方法，这是沿整个轴将填充 NaNs 的最大条目数。如果不是“无”，则必须大于 0。
向下转换: dict，默认值为无。项的字典- >如果可能的话，要向下转换的数据类型，或者尝试向下转换为适当的相等类型的字符串“推断”(例如，如果可能的话，float64 到 int64)。
示例 1:使用DataFrame.fillna()方法替换 NaN 元素
这里，通过使用DataFrame.fillna()方法，我们可以用指定的值替换数据帧中的所有空值或缺失值。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("-----Filling Nan values------")
print(df.fillna(2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NaN NaN 5.0
2 NaN 3.0 NaN
-填充 NaN 值-
A B C
0 2.0 2.0 0.0
1 2.0 2.0 5.0
2.0 3.0 2.0 2.0
示例 2:使用DataFrame.ffill()方法填充缺失值
通过使用DataFrame.fillna()方法，我们也可以使用ffill方法向前传播非空值。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("-----Filling Nan values------")
print(df.fillna(method='ffill'))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NaN NaN 5.0
2 NaN 3.0 NaN
-填充 NaN 值-
A B C
0 2.0 NaN 0.0
1 2.0 NaN 5.0
2.0 3.0 5.0
示例 3:使用DataFrame.ffill()方法填充缺失值
使用DataFrame.fillna()方法，我们也可以使用ffill方法沿着axis=1.向前传播非空值
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("-----Filling Nan values------")
print(df.fillna(method='ffill',axis=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NaN NaN 5.0
2 NaN 3.0 NaN
-填充 NaN 值-
A B C
0 2.0 2.0 0.0
1 NaN 5.0
2 NaN 3.0 3.0
示例 4:使用DataFrame.ffill()方法填充缺失值
使用DataFrame.fillna()方法，我们也可以使用bfill方法向后传播非空值。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("-----Filling Nan values------")
print(df.fillna(method='bfill'))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NAn NAn 5.0
2 NAn 3.0 NAn
-填充 NAn 值-
A B C
0 2.0 3.0 0.0
1 NAn 3.0 5.0
2 NAn 3.0 NAn
示例 4:使用DataFrame.ffill()方法填充缺失值
在下面的示例中，DataFrame.fillna()方法将“A”、“B”、“C”和“D”列中的所有 NaN 元素分别替换为 0、1、2 和 3。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
new_values = {'A': 0, 'B': 1, 'C': 2, 'D': 3}
print("-----Filling Nan values------")
print(df.fillna(value=new_values))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NaN NaN 5.0
2 NaN 3.0 NaN
-填充 NaN 值-
A B C
0 2.0 1.0 0.0
1 0.0 1.0 5.0
2 0.0 3.0 2.0
示例 5:使用DataFrame.ffill()方法填充缺失值
我们可以使用DataFrame.fillna()方法中的limit方法替换第一个 NaN 元素。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, 0],[np.nan, np.nan,5],[np.nan,3,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
new_values = {'A': 0, 'B': 1, 'C': 2, 'D': 3}
print("-----Filling Nan values------")
print(df.fillna(value=new_values,limit=1))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 NaN 0.0
1 NAn NAn 5.0
2 NAn 3.0 NAn
-填充 NAn 值-
A B C
0 2.0 1.0 0.0
1 0.0 NAn 5.0
2 NAn 3.0 2.0
结论
在本教程中，我们学习了 PandasDataFrame.fillna()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.fillna()方法。
Pandas 数据帧filter()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-filter-method
在本教程中，我们将学习 PandasDataFrame.filter()T3】法。此方法根据指定的索引标签对数据帧行或列进行子集化。请注意，该例程不会对数据帧的内容进行过滤。筛选器应用于索引的标签。
下图显示了DataFrame.filter()方法的语法。
句法
DataFrame.filter(items=None, like=None, regex=None, axis=None)
因素
物品:列表状。保持标签远离项目中的轴。
像: str。将标签与“标签中的相似性==真”的轴分开。
正则表达式: str(正则表达式)。从要重新搜索的轴保留标签(正则表达式，标签)=真。
轴 {0 或‘索引’，1 或‘列’，无}，默认无。要筛选的轴，表示为索引(int)或轴名(str)。默认情况下，这是信息轴，“系列”的“索引”，数据帧的“列”。
示例:在 Pandas 中创建数据帧
在本教程中，我们将使用这个数据帧来应用过滤方法。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya","Sinchana","Amrutha","Akshatha"],"Age":[25,24,25,25,26],"Education":["M.Tech","M.Tech","M.Tech","Ph.d","Ph.d"],"YOP":[2019,2020,2018,None,None]},index=["Group_1", "Group_1","Group_1","Group_2","Group_2"])
print("-------DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
- DataFrame is -
姓名年龄教育 YOP
组 _1 Navya 25 M.Tech 2019.0
组 _1 Vindya 24 M.Tech 2020.0
组 _1 Sinchana 25 M.Tech 2018.0
组 _ 2 Amrutha 25 博士 NaN
组 _2 Akshatha 26 博士 NaN
示例:使用DataFrame.filter()方法按列名过滤
使用DataFrame.filter()方法的items 参数，我们可以按特定的列过滤数据帧。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya","Sinchana","Amrutha","Akshatha"],"Age":[25,24,25,25,26],"Education":["M.Tech","M.Tech","M.Tech","Ph.d","Ph.d"],"YOP":[2019,2020,2018,None,None]},index=["Group_1", "Group_1","Group_1","Group_2","Group_2"])
print("---------Filter by columns name---------")
print(df.filter(items=["Name","Education"]))
一旦我们运行该程序，我们将获得以下输出。
-按名称按列筛选-
名称教育
第 _1 组纳维雅科技
第 _1 组温迪雅科技
第 _1 组辛查纳科技
第 _2 组阿姆鲁萨博士
第 _2 组阿克沙塔博士
示例:使用DataFrame.filter()方法按行名过滤
通过使用DataFrame.filter()方法的like 参数，我们可以按特定行过滤数据帧。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya","Sinchana","Amrutha","Akshatha"],"Age":[25,24,25,25,26],"Education":["M.Tech","M.Tech","M.Tech","Ph.d","Ph.d"],"YOP":[2019,2020,2018,None,None]},index=["Group_1", "Group_1","Group_1","Group_2","Group_2"])
print("---------Filter by rows name---------")
print(df.filter(like='Group_2', axis=0))
一旦我们运行该程序，我们将获得以下输出。
-按行筛选名称-
姓名年龄教育 YOP
组 _2 阿姆鲁萨 25 博士 NaN
组 _2 阿克沙塔 26 博士 NaN
示例:使用regex 和DataFrame.filter()方法按列名过滤
通过使用DataFrame.filter()方法的 regex 参数，我们可以按特定的列过滤数据帧。下面的例子显示了同样的情况。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya","Sinchana","Amrutha","Akshatha"],"Age":[25,24,25,25,26],"Education":["M.Tech","M.Tech","M.Tech","Ph.d","Ph.d"],"YOP":[2019,2020,2018,None,None]},index=["Group_1", "Group_1","Group_1","Group_2","Group_2"])
print("---------Filter by columns name---------")
print(df.filter(regex ='[g]'))
一旦我们运行该程序，我们将获得以下输出。
-按列名筛选-
年龄
组 _1 25
组 _1 24
组 _1 25
组 _2 25
组 _2 26
结论
在本教程中，我们学习了 PandasDataFrame.filter()方法。我们学习了语法、参数，并通过在 DataFrame 上应用此方法。
Pandas 数据帧first()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-first-method
在本教程中，我们将学习 PandasDataFrame.first()T4 法。它根据日期偏移选择时间序列数据的初始周期。当数据帧以日期为索引时，此方法可以根据日期偏移量选择前几行。如果索引不是日期时间索引，它将返回数据帧并引发TypeError。
下图显示了DataFrame.first()方法的语法。
句法
DataFrame.first(offset)
因素
偏移量: str、DateOffset 或 dateutil.relativedelta。将被选择的数据的偏移量长度。例如，“1M”将显示第一个月内有索引的所有行。
示例:使用DataFrame.first()方法获取 bu 行
以下示例显示了获取前 3 天的行。在下面的例子中，返回了前 3 个calendar days的数据，而不是数据集中观察到的前 3 天，因此没有返回 2021-01-13 的数据。
#importing pandas as pd
import pandas as pd
i = pd.date_range('2021-01-09', periods=4, freq='2D')
df = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
print("The DataFrame is")
print(df)
print(df.first('3D'))
一旦我们运行该程序，我们将获得以下输出。
数据帧为
A
2021-01-09 1
2021-01-11 2
2021-01-13 3
2021-01-15 4
A
2021-01-09 1
2021-01-11 2
示例:使用DataFrame.first()方法获取行
除了返回前两天之外，下面的示例与前面的示例相似。
#importing pandas as pd
import pandas as pd
i = pd.date_range('2021-01-09', periods=4, freq='4D')
df = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
print("The DataFrame is")
print(df)
print(df.first('2D'))
一旦我们运行该程序，我们将获得以下输出。
数据帧为
A
2021-01-09 1
2021-01-13 2
2021-01-17 3
2021-01-21 4
A
2021-01-09 1
示例:使用DataFrame.first()方法获取前 n 个月的行
以下示例显示了获取前 1 个月的行。
#importing pandas as pd
import pandas as pd
i = pd.date_range('2021-01-01', periods=4, freq='1M')
df = pd.DataFrame({'A': [1, 2, 3, 4]}, index=i)
print("The DataFrame is")
print(df)
print(df.first('1M'))
一旦我们运行该程序，我们将获得以下输出。
数据帧为
A
2021-01-31 1
2021-02-28 2
2021-03-31 3
2021-04-30 4
A
2021-01-31 1
2021-02-28 2
示例:DataFrame.first()方法中的类型错误
如果指数不是DatetimeIndex.，则DataFrame.first()方法提高TypeError
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3, 4]})
print(df.first('1M'))
一旦我们运行该程序，我们将获得以下输出。
类型错误:“第一个”只支持日期时间索引
结论
在本教程中，我们学习了 PandasDataFrame.first()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.first()方法。
Pandas 数据帧first_valid_index()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-first_valid_index-method
在本教程中，我们将学习 PandasDataFrame.first_valid_index() 的方法。通过使用这种方法，我们可以获得第一个非 NA/null 值的索引。它返回一个标量，该标量是索引的类型。如果所有元素都是非空值，则返回None，对于empty DataFrame.，则返回None
下图显示了DataFrame.first_valid_index()的语法。
句法
DataFrame.first_valid_index()
示例:DataFrame.first_valid_index()方法
用空值创建数据帧，并使用DataFrame.first_valid_index()方法获取第一个非 NA 值的索引。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[np.nan, np.nan, np.nan],[np.nan, 2,5],[1, 3, 4],[np.nan,3,np.nan],[2, 8, 0],[7, 5, 4]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("Index for first non-NA/null value is:",df.first_valid_index())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 NaN NaN
1 NaN 2.0 5.0
2 1.0 3.0 4.0
3 NaN 3.0 NaN
4 2.0 8.0 0.0
5 7.0 5.0 4.0
第一个非 NA/null 值的索引为:1
示例:使用DataFrame.first_valid_index() 方法查找第一个非 NA/null 值的索引
这是另一个更好地理解 first_valid_index()方法的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[np.nan, np.nan, np.nan],[np.nan, np.nan, np.nan],[np.nan, np.nan, np.nan],[np.nan,3,np.nan],[2, 8, 0],[7, 5, 4]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("Index for first non-NA/null value is:",df.first_valid_index())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 NAn NAn NAn
1 NAn NAn NAn
2 NAn NAn NAn
3 NAn 3.0 NAn
4 2.0 8.0 0
5 7.0 5.0 4.0
第一个非 NA/null 值的索引为:3
示例:数据帧包含所有空值
如果所有元素都是非空的，则DataFrame.first_valid_index() 方法返回None。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[np.nan, np.nan, np.nan],[np.nan, np.nan, np.nan],[np.nan, np.nan, np.nan],[np.nan, np.nan, np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("Index for first non-NA/null value is:",df.first_valid_index())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 NaN NaN
第一个非 NA/空值的索引为:无
结论
在本教程中，我们学习了 PandasDataFrame.first_valid_index()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.first_valid_index()方法。
Pandas 数据帧floordiv()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-floordiv-method
在本教程中，我们将学习 PandasDataFrame.floordiv()的方法。该方法用于获取数据帧的整数部分和其他元素部分(二进制运算符 floordiv)。它相当于dataframe // other，但支持用 fill_value 替换其中一个输入中缺失的数据。使用反向版本，可以使用 rfloordiv 方法。
下图显示了DataFrame.floordiv()方法的语法。
句法
DataFrame.floordiv(other, axis='columns', level=None, fill_value=None)
因素
其他:标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。
轴: {0 或‘索引’，1 或‘列’}。是按索引(0 或“索引”)还是按列(1 或“列”)进行比较。对于序列输入，轴与序列索引匹配。
级别: int 或 label。跨级别广播，匹配传递的多索引级别上的索引值。
fill_value: 浮动或无，默认无。在计算之前，用该值填充现有的缺失(NaN)值以及成功的数据帧对齐所需的任何新元素。如果两个相应数据帧位置的数据都丢失，结果也将丢失。
示例 1:使用DataFrame.floordiv()方法获取整数除法
让我们将DataFrame.floordiv()方法应用于数据帧，并获得带常数的整数除法。下面的例子显示了运行的代码。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df=pd.DataFrame({"A":[2,5],"B":[6,7],"C":[3,1]})
print("--------The DataFrame is---------")
print(df)
print("----After applying floordiv function-----")
print(df.floordiv(2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2 6 3
1 5 7 1
-应用楼层划分方法后
A B C
0 1 3 1
1 2 3 0
例 2:使用DataFrame.floordiv()方法得到整数除法
让我们对数据帧应用DataFrame.floordiv()方法，用Series得到整数除法。下面的例子显示了 runnig 代码。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df=pd.DataFrame({"A":[9,5],"B":[3,7],"C":[3,1]})
print("--------The DataFrame is---------")
print(df)
series = pd.Series([2, 3])
print("----After applying floordiv function-----")
print(df.floordiv(series,axis=0) )
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 9 3 3
1 5 7 1
-应用楼层划分方法后-
A B C
0 4 1
1 1 2 0
例 3:使用DataFrame.floordiv()方法得到整数除法
让我们对数据帧应用DataFrame.floordiv()方法，用fillvalue=30得到整数除法。下面的例子显示了运行的代码。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df=pd.DataFrame({"A":[2,5,None],"B":[6,7,np.nan],"C":[np.nan,3,1]})
print("--------The DataFrame is---------")
print(df)
print("----After applying floordiv function-----")
print(df.floordiv(3,fill_value = 30))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 2.0 6.0 NAn
1 5.0 7.0 3.0
2 NAn NAn 1.0
-应用楼层划分方法后-
A B C
0 0.0 2.0 10.0
1 1.0 2.0 1.0
2 10.0 10.0 0.0
结论
在本教程中，我们学习了 PandasDataFrame.floordiv()方法。我们学习了语法、参数，并通过在数据帧上应用该方法来理解 DataFrame.floordiv()方法。
Pandas 数据帧from_dict()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-from_dict-method
在本教程中，我们将学习 PandasDataFrame.from_dict()的方法。它从类数组或字典类型的字典中构造数据帧。它通过允许数据类型规范的列或索引从字典创建一个数据帧对象。
下图显示了DataFrame.from_dict()方法的语法。
句法
DataFrame.from_dict(data, orient='columns', dtype=None, columns=None)
因素
数据: dict。形式为{字段:类似数组}或{字段:dict}。
方向: {'columns '，' index'}，默认' columns '。数据的“方向”。如果传递的 dict 的键应该是结果数据帧的列，则传递“columns”(默认)。否则，如果键应该是行，则传递“index”。
数据类型:数据类型，默认无。数据类型来强制，否则推断。
列:列表，默认无。orient='index'时使用的列标签。如果与orient='columns'一起使用，将引发值错误。
示例:从字典创建数据帧
默认情况下，从字典创建数据帧时，字典的keys成为数据帧columns。
#import pandas as pd
import pandas as pd
#creating dictionary
data = {'key_1': [3, 2, 1, 0], 'key_2': ['a', 'b', 'c', 'd']}
print("The python dictionary is:",data)
#creating DataFrame
df=pd.DataFrame.from_dict(data)
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
python 字典为:{'key_1': [3，2，1，0]，' key_2': ['a '，' b '，' c '，' d']}
-数据帧为-
key _ 1 key _ 2
0 3a
1 2b
2 1c
3 0d
示例:从字典创建数据帧
当DataFrame.中的orient='index'时，字典的keys成为数据帧rows。下面的例子显示了同样的情况。
#import pandas as pd
import pandas as pd
#creating dictionary
data = {'key_1': [3, 2, 1, 0], 'key_2': ['a', 'b', 'c', 'd']}
print("The python dictionary is:",data)
#creating DataFrame
df=pd.DataFrame.from_dict(data,orient='index')
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
python 字典为:{'key_1': [3，2，1，0]，' key_2': ['a '，' b '，' c '，' d']}
-数据帧为-
0 1 2 3
key _ 1 3 2 1 0
key _ 2 a b c d
示例:从字典创建数据帧
使用‘index’方向时，可以手动指定列名。见下面的例子。
#import pandas as pd
import pandas as pd
#creating dictionary
data = {'key_1': [3, 2, 1, 0], 'key_2': ['a', 'b', 'c', 'd']}
print("The python dictionary is:",data)
#creating DataFrame
df=pd.DataFrame.from_dict(data,orient='index',columns=['A', 'B', 'C', 'D'])
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
python 字典为:{'key_1': [3，2，1，0]，' key_2': ['a '，' B '，' C '，' d']}
-数据帧为-
A B C D
key _ 1 3 2 1 0
key _ 2 A B C D
结论
在本教程中，我们学习了 PandasDataFrame.from_dict()方法。我们学习了语法、参数，并通过在数据帧上应用该方法来理解DataFrame.from_dict()方法。
Pandas 数据帧from_records()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-from_records-method
在本教程中，我们将学习 PandasDataFrame.from_records()的方法。它将结构化或记录数组转换为数据帧。它从结构化的数组中创建一个数据帧对象，该数组由元组或字典或数据帧组成。
下面是DataFrame.from_records()方法的语法。
句法
DataFrame.from_records(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None)
因素
数据:结构化数组，元组或字典的序列，或数据帧。结构化输入数据。
索引:字符串，字段列表，类似数组。要用作索引的数组字段，或者要使用的一组特定输入标签。
排除:序列，默认无。要排除的列或字段。
列:序列，默认无。要使用的列名。如果传递的数据没有关联的名称，则此参数为列提供名称。否则，此参数指示列在结果中的顺序(任何在数据中找不到的名称都将成为全无列)。
要挟 _float: bool，默认 False。尝试转换非字符串、非数字对象(如十进制)的值。十进制)转换为浮点型，对 SQL 结果集很有用。
n 显示: int，默认无。如果数据是迭代器，要读取的行数。
示例:使用DataFrame.from_records()方法创建数据帧
数据可以作为结构化的数组提供。DataFrame.from_records()方法将数组记录转换为数据帧。见下面的例子。
#import pandas as pd
import pandas as pd
#import numpy as np
import numpy as np
data = np.array([(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')],dtype=[('col_1', 'i4'), ('col_2', 'U1')])
print("ndarray is:",data)
df=pd.DataFrame.from_records(data)
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
n 数组为:[(3，' a') (2，' b') (1，' c') (0，' d')]
-数据帧为-
col _ 1 col _ 2
03 a
12 b
21 c
30d
示例 2:使用DataFrame.from_records()方法创建数据帧
在这里，我们使用一个字典列表。DataFrame.from_records()方法将字典记录列表转换为数据帧。下面的例子显示了同样的情况。
#import pandas as pd
import pandas as pd
#import numpy as np
import numpy as np
data = [{'col_1': 3, 'col_2': 'a'},{'col_1': 2, 'col_2': 'b'},{'col_1': 1, 'col_2': 'c'},{'col_1': 0, 'col_2': 'd'}]
print("list of dicts:",data)
df=pd.DataFrame.from_records(data)
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
字典列表:[{'col_1': 3，' col_2': 'a'}，{'col_1': 2，' col_2': 'b'}，{'col_1': 1，' col_2': 'c'}，{'col_1': 0，' col_2': 'd'}]
-数据帧为-
col _ 1 col _ 2
0 3a
1 2b
2 1c
3 0d
示例 2:使用DataFrame.from_records()方法创建数据帧
这里，我们使用作为元组列表。DataFrame.from_records()方法将元组记录列表转换为数据帧。下面的例子显示了同样的情况。
#import pandas as pd
import pandas as pd
#import numpy as np
import numpy as np
data = [(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')]
print("list of tuples:",data)
df=pd.DataFrame.from_records(data)
print("----------The DataFrame is----------")
print(df)
一旦我们运行该程序，我们将获得以下输出。
元组列表:[(3，' a ')、(2，' b ')、(1，' c ')、(0，' d')]
-数据帧为-
0 1
0 3a
1 2b
2 1c
3 0d
结论
在本教程中，我们学习了 PandasDataFrame.from_records()方法。我们学习了语法、参数，并通过在数据帧上应用该方法，理解了 DataFrame.from_records()方法。
Pandas 数据帧ge()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-ge-method
在本教程中，我们将学习 PandasDataFrame.ge()的方法。此方法用于获取大于或等于的 dataframe 和其他元素(二元运算符 get)。它返回 bool 类型的数据帧，这是比较的结果。
下面是DataFrame.ge()方法的语法。
句法
DataFrame.ge(other, axis='columns', level=None)
因素
其他:标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。
轴: {0 或‘索引’，1 或‘列’，默认‘列’。是按索引(0 或“索引”)还是按列(1 或“列”)进行比较。
级别: int 或 label。跨级别广播，匹配传递的多索引级别上的索引值。
示例 1:使用DataFrame.ge()方法比较数据帧
这里，我们使用返回 bool 类型数据帧的DataFrame.ge()方法与scalar进行比较。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The DataFrame is---------")
print(df)
print("----After applying ge function-----")
print(df.ge(200))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 ge 方法后-
A B C
0 真假假
1 真假
示例 2:使用DataFrame.ge()方法比较数据帧
这里，我们使用DataFrame.ge()方法与Series进行比较。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The DataFrame is---------")
print(df)
series = pd.Series([150, 200,150])
print("----After applying ge function-----")
print(df.ge(series,axis=0))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 ge 方法后-
A B C
0 真假真
1 真假
2 假假假假
示例 3:使用DataFrame.ge()方法比较数据帧
在这里，我们用DataFrame.ge()方法与other DataFrame进行比较。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The first DataFrame is---------")
print(df_1)
df_2=pd.DataFrame({"A":[200,550],"B":[65,251],"C":[100,10]})
print("--------The second DataFrame is---------")
print(df_2)
print("----After applying ge function-----")
print(df_1.ge(df_2))
一旦我们运行该程序，我们将获得以下输出。
-第一个数据帧是-
A B C
0 200 60 150
1 500 250 1
-第二个数据帧是-
A B C
0 200 65 100
1 550 251 10
-应用 ge 方法后-
A B C
0 真假真
1 假假假假
结论:
在本教程中，我们学习了 PandasDataFrame.ge()方法。我们学习了语法和参数，通过在数据帧上应用这种方法，我们理解了 DataFrame.ge()方法。
Pandas 数据帧get()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-get-method
在本教程中，我们将学习 PandasDataFrame.get()的方法。此方法用于从给定键的对象中获取项目(例如:数据帧列)。如果找不到指定的键，它将返回默认值。
下图显示了DataFrame.get()方法的语法。
句法
DataFrame.get(key, default=None)
参数:
键:对象
示例:使用DataFrame.get()方法获取数据帧的列
我们可以通过在DataFrame.get()方法中将列名定义为关键字来从数据帧中提取列。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"],"YOP":[2019,None]})
print("------The DataFrame is--------")
print(df)
print("-----Getting single columns-----")
print(df.get("Age"))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
名称年龄教育 YOP
0 纳维亚 25 M.Tech 2019.0
1 Vindya 24 博士 NaN
-获取单列-
0 25
1 24
名称:年龄，数据类型:int64
示例:使用DataFrame.get()方法获取数据帧的多列
我们可以通过在DataFrame.get()方法中将列名定义为键来从数据帧中提取多列。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"],"YOP":[2019,None]})
print("------The DataFrame is--------")
print(df)
print("-----Getting multiple columns-----")
print(df.get(["Name","Education"]))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
名龄教育 YOP
0 纳维雅 25 M.Tech 2019.0
1 Vindya 24 博士 NaN
-获取多列-
名龄教育
0 纳维雅 M.Tech
1 Vindya 博士
示例:使用DataFrame.get()方法和default方法获取数据帧的列
如果找不到指定的键，它将返回默认值。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"],"YOP":[2019,None]})
print("------The DataFrame is--------")
print(df)
print("-----Getting columns-----")
print(df.get("skills",default="Specified key is not mentioned"))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
名称年龄教育 YOP
0 纳维亚 25 M.Tech 2019.0
1 Vindya 24 博士 NaN
-获取列-
未提及指定键
结论
在本教程中，我们学习了 PandasDataFrame.get()方法。我们学习了语法，通过在数据帧上应用这个方法，我们理解了 DataFrame.get()方法。
Pandas 数据帧groupby()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-groupby-method
在本教程中，我们将学习 Python Pandas 内置方法DataFrame.groupby().``groupby()操作包括拆分对象、应用方法和组合结果的一些组合。当我们对数据帧中的某些组进行一些计算或统计时，这种方法很有帮助。它返回一个由关于组的信息组成的groupby object。
下图显示了DataFrame.groupby()方法的语法。
句法
DataFrame.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
因素
by: 映射、方法、标签或标签列表。它用于确定 groupby 的组。如果 by 是一个方法，则对对象索引的每个值调用它。如果通过了系列或系列，系列或系列值将用于确定组。如果通过了一个数组，这些值将按原样用于确定组。
轴:如果为 0 或“索引”，则对每列应用一种方法。如果为 1 或“列”，则对每行应用一个方法。默认轴值为 0 或“索引”。
级别: int，级别名称或序列，默认无。如果轴是多索引的，它将按特定级别分组。
示例:Pandas 中的 groupby()方法
以下示例显示了 groupby()方法如何对数据帧中的对象进行分组或拆分。
# import the pandas library
import pandas as pd
data = {'Name': ['Avinash', 'Amrutha', 'Chetana', 'Kartik','Nikhil'],'Percentage': [72, 98, 81, 87,85],'Course': ['Arts','B.Com','M.Tech','B.SC','BE']}
df = pd.DataFrame(data)
print(df)
grp=df.groupby('Course')
print(grp)
print(grp.groups)
一旦我们运行该程序，我们将获得以下输出。
名称百分比课程
0 Avinash 72 Arts
1 Amrutha 98 B.Com
2 Chetana 81M . Tech
3 Kartik 87 B . SC
4 Nikhil 85 BE
<pandas . core . group by . generic . data frame group by 对象位于 0x 00002429 a 175 ee0>
{【Arts】:【0】，【B . Com】:【1】，【B . SC】:【3】，【4】
示例:使用groupby()方法对数据帧对象进行分组
在本例中，我们使用 Pandas 数据帧的groupby()方法对多列进行分组。
# import the pandas library
import pandas as pd
data = {'Name': ['Avinash', 'Amrutha', 'Chetana', 'Kartik','Nikhil'],'Percentage': [72, 98, 81, 87,85],'Course': ['Arts','B.Com','M.Tech','B.SC','BE']}
df = pd.DataFrame(data)
print(df)
grp=df.groupby(['Course','Name'])
print(grp)
print(grp.groups)
一旦我们运行该程序，我们将获得以下输出。
名称百分比课程
0 Avinash 72 Arts
1 Amrutha 98 B.Com
2 Chetana 81M . Tech
3 Kartik 87 B . SC
4 Nikhil 85 BE
<pandas . core . group by . generic . data frame group by 对象位于 0x 00002429 a 1759 d0>
{(“Arts”，“Avinash”):[0]，(“B.Com”，“Amrutha”):[1]
示例:使用 get_group()方法选择单个组
我们可以使用 get_group()方法选择单个组。见下面的例子。
# import the pandas library
import pandas as pd
data = {'Name': ['Avinash','Avinash', 'Amrutha', 'Chetana', 'Kartik','Nikhil'],
'Percentage': [72, 98, 81, 87,85,98],
'Course': ['Arts','B.Com','M.Tech','B.SC','BE','M.Tech']}
df = pd.DataFrame(data)
print("--------DATAFRAME------")
print(df)
grp=df.groupby('Percentage')
print("----Selecting single group-----")
print(grp.get_group(98))
一旦我们运行该程序，我们将获得以下输出。
- DATAFRAME -
命名百分比课程
0 阿维纳什 72 艺术
1 阿维纳什 98 B.Com
2 阿姆鲁萨 81 M.Tech
3 切塔纳 87 B.SC
4 卡蒂克 85 BE
5 尼基尔 98 M.Tech
-选择单组-
命名百分比课程
1 阿维纳什 98 B.Com
5 尼基尔 98 M.Tech
示例:对groupby()方法执行聚合操作
一旦创建了groupby()对象，我们就可以对分组数据进行多次aggregation 操作。见下面的例子。
# import the numpy and pandas library
import numpy as np
import pandas as pd
data = {'Name': ['Avinash','Avinash', 'Amrutha', 'Chetana', 'Kartik','Nikhil'],
'Percentage': [72, 98, 81, 87,85,98],
'Course': ['Arts','B.Com','M.Tech','B.SC','BE','M.Tech']}
df = pd.DataFrame(data)
grp=df.groupby('Course')
print("----Performing aggregation operation on groupby object-----")
print(grp['Percentage'].agg(np.mean))
一旦我们运行该程序，我们将获得以下输出。
-对分组对象执行聚合操作-
课程
艺术 72.0
B.Com 98.0
B . SC 87.0
BE 85.0
M . Tech 89.5
名称:百分比，数据类型:float64
结论:
在本教程中，我们学习了 Pandas 内置法groupby() 法。我们理解语法、参数，并且通过在 DataFrame 上应用此方法来理解 groupby()方法的工作原理，我们有不同的示例。
Pandas 数据帧gt()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-gt-method
我们可以在 Pandas 的数据帧中找到两个数字中最大的一个，在本教程中，我们将讨论和学习 Python PandasDataFrame.gt()方法。此方法用于获取数据帧和其他元素的大于，在本教程中，我们将比较数据帧与标量、序列和其他数据帧。它返回 bool 的数据帧，这是比较的结果。
下图显示了DataFrame.gt()方法的语法。
句法
DataFrame.gt(other, axis='columns', level=None)
因素
其他:可以是任何单个或多个元素的数据结构，也可以是类似列表的对象，例如标量、序列、序列或数据帧。
轴:“0”代表索引，“1”代表列，默认为列。表示是按索引轴比较还是按列轴比较。
级别:代表 int 或 label。它跨级别广播，匹配传递的多索引级别上的索引值。
示例:使用DataFrame.gt()方法将数据帧与常数进行比较
这里，我们使用返回 bool 类型数据帧的DataFrame.gt()方法与scalar进行比较。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The DataFrame is---------")
print(df)
print("----After applying gt function-----")
print(df.gt(200))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 gt 方法后-
A B C
0 假假假
1 真真假
示例:使用DataFrame.gt()方法将数据帧与系列进行比较
这里，我们使用DataFrame.gt()方法与Series进行比较。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The DataFrame is---------")
print(df)
series = pd.Series([150, 200,150])
print("----After applying gt function-----")
print(df.gt(series,axis=0))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 gt 方法后-
A B C
0 真假假假
1 真假假
2 假假假假
示例:使用DataFrame.gt()方法将数据帧与其他数据帧进行比较
在这里，我们用DataFrame.gt()方法与other DataFrame进行比较。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
print("--------The first DataFrame is---------")
print(df_1)
df_2=pd.DataFrame({"A":[200,550],"B":[65,251],"C":[100,10]})
print("--------The second DataFrame is---------")
print(df_2)
print("----After applying gt function-----")
print(df_1.gt(df_2))
一旦我们运行该程序，我们将获得以下输出。
-第一个数据帧是-
A B C
0 200 60 150
1 500 250 1
-第二个数据帧是-
A B C
0 200 65 100
1 550 251 10
-应用 gt 方法后-
A B C
0 假假真
1 假假假假
结论:
在本教程中，我们学习了 PandasDataFrame.gt()方法。我们学习了这个方法的语法、参数，理解了 DataFrame.gt()方法。
Pandas 数据帧head()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-head-method
在本教程中，我们将学习 PandasDataFrame.head()的方法。此方法用于获取数据帧的前 n 行。当我们想要检查对象中有哪种类型的数据时，这种方法很方便。如果我们给“n”一个负值，这个方法返回除最后 n 行之外的所有行，相当于df[:-n].
下图显示了DataFrame.head()方法的语法。
句法
DataFrame.head(n=5)
参数:
n: 表示 int，默认值为 5，即选择的行数。
示例:使用DataFrame.head()方法获取数据帧的前 n 行
这里，使用DataFrame.head()方法，我们得到了数据帧的前 5 行。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df= pd.DataFrame({'Language': ['Kannada','Hindi', 'Telugu', 'Tamil', 'Malyalam','Marathi','Konkani','Tulu']})
print("----First 5 rows of the DataFrame is-----")
print(df.head())
一旦我们运行该程序，我们将获得以下输出。
-数据帧的前 5 行是-
语言
0 卡纳达语
1 印地语
2 泰卢固语
3 泰米尔语
4 马尔亚拉姆语
示例:在DataFrame.head()方法中指定行数
我们可以指定要查看的行数，在本例中，我们将n 值设为 2。DataFrame.head()方法返回前 2 行。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df= pd.DataFrame({'Language': ['Kannada','Hindi', 'Telugu', 'Tamil', 'Malyalam','Marathi','Konkani','Tulu']})
print("----First n rows of the DataFrame is-----")
print(df.head(n=2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧的前 n 行是-
语言
0 卡纳达语
1 印地语
示例:DataFrame.head()方法中'n'的负值
在这个例子中，我们给n一个负值。对于n的负值，该方法返回除last n行之外的所有行，相当于df[:-n]。
#importing pandas as pd
import pandas as pd
#creating the DataFrame
df= pd.DataFrame({'Language': ['Kannada','Hindi', 'Telugu', 'Tamil', 'Malyalam','Marathi','Konkani','Tulu']})
print("----First n rows of the DataFrame is-----")
print(df.head(-2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧的前 n 行是-
语言
0 卡纳达语
1 印地语
2 泰卢固语
3 泰米尔语
4 马尔亚拉姆语
5 马拉地语
结论:
在本教程中，我们学习了 PandasDataFrame.head()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.head()方法。
Pandas 数据帧hist()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-hist-method
为了获得可视化表示的汇总数据，我们使用了直方图，在本教程中，我们将学习 Python pandas DataFrame.hist()方法。该方法制作数据帧的直方图。一个直方图可以定义为数据分布的表示。该方法在数据帧中的每个序列上调用matplotlib.pyplot.hist()，得到每列一个直方图。
下面是DataFrame.hist()方法的语法。
句法
DataFrame.hist(column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, backend=None, legend=False, **kwargs)
DataFrame.hist()方法的一些重要参数是，
数据:Pandas 对象持有的是数据帧。
列:代表字符串或序列。如果传递此参数，它将用于将数据限制在列的子集内。
by: 表示对象，可选。如果该参数被传递，则用于形成单独组的直方图。
网格:表示布尔(真或假)，默认值为真。它指示是否显示轴网格线。
仓:为 int 或序列，默认值为 10，表示要使用的直方图仓数。如果我们给出一个整数，则计算并返回 bin+1 bin 边。如果我们将面元作为一个序列给出，它会给出面元的边，包括第一个面元的左边缘和最后一个面元的右边缘。在这种情况下，容器会不加修改地返回。
示例:使用DataFrame.hist()方法创建数据帧的列直方图
在下面的例子中，我们创建了一个数据帧，让我们将DataFrame.floordiv()方法应用于数据帧，并获得数据帧的可视化表示。我们将基于长度和宽度的数据帧列来获得图形。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],'width': [0.7, 0.2, 0.15, 0.2, 1.1]}, index=['python', 'C', 'C++', 'R', 'Pearl'])
print(df.hist())
示例:使用带箱方法的DataFrame.hist()方法创建数据帧的列直方图。
DataFrame.hist()方法根据一些索引的长度和宽度绘制直方图，显示在三个面元中。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],'width': [0.7, 0.2, 0.15, 0.2, 1.1]},index=['python', 'C', 'C++', 'R', 'Pearl'])
print(df.hist(bins=3))
示例:在DataFrame.hist()方法中设置列=“长度”
在这里，我们将列指定为长度，并且DataFrame.hist()方法基于指定的列绘制直方图。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'length': [1.5, 0.5, 1.2, 0.9, 3],'width': [0.7, 0.2, 0.15, 0.2, 1.1]},index=['python', 'C', 'C++', 'R', 'Pearl'])
print(df.hist(column="length"))
结论:
在本教程中，我们学习了 PandasDataFrame.hist()方法。我们学习了语法，通过在数据帧上应用这个函数，我们解决了一些例子并理解了DataFrame.hist()方法。
Pandas 数据帧idxmax()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-idxmax-method
在本教程中，我们将讨论和学习 PandasDataFrame.idxmax()的方法。该方法用于获取请求轴上最大值的第一次出现的索引。如果有任何空值或缺失值，将被排除。此方法返回一个序列，该序列由沿指定轴的最大值索引组成。如果数据帧中的行或列为空，它会引发值错误。
下面是DataFrame.idxmax()方法的语法。
句法
DataFrame.idxmax(axis=0, skipna=True)
因素
轴:“0”或【指数】代表行方向，【1】或【列】代表列方向。它表示使用哪个轴。
skipna: 代表 bool(真或假)，默认值为 True。当此参数为真时，它排除所有空值或缺失值。如果数据帧中的整行或整列为空值，结果也将为空。
示例:使用DataFrame.idxmax()方法获取索引
考虑一个数据集，使用DataFrame.idxmax()方法获取每列中最大值的索引。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,90,45],'Marks_2': [85,96,100]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the maximum value over the row axis----")
print(df.idxmax())
一旦我们运行代码，我们将获得以下输出。
-数据帧为-
Marks_1 Marks_2
卡纳达语 85 85
英语 90 96
科学 45 100
-行轴上最大值的索引-
Marks_1 英语
Marks_2 科学
数据类型:对象
示例:使用DataFrame.idxmax()方法获取索引
考虑一个数据集，使用DataFrame.idxmax()方法获取每行中最大值的索引。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,90,45],'Marks_2': [95,46,100]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the maximum value over the column axis----")
print(df.idxmax(axis="columns"))
一旦我们运行代码，我们将获得以下输出。
-数据帧为-
Marks_1 Marks_2
卡纳达语 85 95
英语 90 46
科学 45 100
-列轴上最大值的索引-
卡纳达语 Marks_2
英语 Marks_1
科学 Marks_2
数据类型:对象
示例:使用DataFrame.idxmax()方法获取索引
该数据集由空值组成，我们试图使用DataFrame.idxmax()方法获取每行中最大值的索引。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,None,45],'Marks_2': [None,46,None]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the maximum value over the column axis----")
print(df.idxmax(axis="columns"))
一旦我们运行代码，我们将获得以下输出。
-数据帧为-
Marks_1 Marks_2
卡纳达 85.0 NaN
英语 NaN 46.0
科学 45.0 NaN
-列轴上最大值的索引-
卡纳达 Marks_1
英语 Marks_2
科学 Marks_1
dtype: object
结论:
在本教程中，我们学习了 PandasDataFrame.idxmax()方法。我们学习了该方法的语法，并将其应用于数据帧，以理解 DataFrame.idxmax()方法。
Pandas 数据帧idxmin()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-idxmin-method
在本教程中，我们将讨论和学习 PandasDataFrame.idxmin()的方法。该方法用于获取请求轴上最小值的第一次出现的索引。如果有任何空值或缺失值，将被排除。此方法返回一个序列，该序列由沿指定轴的最大值索引组成。如果数据帧中的行或列为空，它会引发值错误。
下图显示了DataFrame.idxmin()方法的语法。
句法
DataFrame.idxmin(axis=0, skipna=True)
因素
轴:“0”或【指数】代表行方向，【1】或【列】代表列方向。它表示使用哪个轴。
skipna: 代表 bool(真或假)，默认值为 True。当此参数为真时，它排除所有空值或缺失值。如果数据帧中的整行或整列为空值，结果也将为空。
示例 1:使用DataFrame.idxmin()方法查找索引
这里，我们使用数据集，并使用DataFrame.idxmin()方法获取每列中最小值的索引。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,90,45],'Marks_2': [85,96,100]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the minimum value over the row axis----")
print(df.idxmin())
-数据帧为-
Marks_1 Marks_2
卡纳达语 85 85
英语 90 96
科学 45 100
-行轴上最小值的索引-
Marks_1 科学
Marks_2 卡纳达语
数据类型:对象
示例 2:使用DataFrame.idxmin()方法查找索引
这里，我们使用DataFrame.idxmin()方法获取每行最小值的索引。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,90,45],'Marks_2': [95,46,100]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the minimum value over the column axis----")
print(df.idxmin(axis="columns"))
-数据帧为-
Marks_1 Marks_2
卡纳达语 85 95
英语 90 46
科学 45 100
-列轴上最小值的索引-
卡纳达语 Marks_1
英语 Marks_2
科学 Marks_1
数据类型:对象
示例 2:使用DataFrame.idxmin()方法查找索引
我们有一个由空值组成的数据集，并试图使用DataFrame.idxmin()方法获取每行中最小值的索引。见下面的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'Marks_1': [85,None,45],'Marks_2': [None,46,None]},index=['Kannada', 'English', 'Science'])
print("-----The DataFrame is----")
print(df)
print("----- Index of the minimum value over the column axis----")
print(df.idxmin(axis="columns"))
-数据帧为-
Marks_1 Marks_2
卡纳达 85.0 NaN
英语 NaN 46.0
科学 45.0 NaN
-列轴上最小值的索引-
卡纳达 Marks_1
英语 Marks_2
科学 Marks_1
dtype: object
结论
在本教程中，我们学习了 PandasDataFrame.idxmin()方法。我们学习了语法，通过在数据帧上应用这个方法，我们理解了这个方法的工作原理。
Pandas 数据帧infer_objects()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-infer_objects-method
在本教程中，我们将学习 PandasDataFrame.infer_objects()的方法。它试图为对象列推断更好的数据类型。此方法尝试对象类型化列的软转换，保持非对象和不可转换列不变。推理规则与正常序列或数据帧构建期间相同。
下图显示了DataFrame.infer_objects()方法的语法。
句法
DataFrame.infer_objects()
示例 1:DataFrame.infer_objects()方法
让我们取一个数据帧，检查数据帧的数据类型。使用DataFrame.infer_objects()方法转换数据帧各列的数据类型。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'a': ["abc",7, 1, 5], 'b': ["xyz",'3','2','1']})
print("----DataTypes of the DataFrame is-----")
print(df.dtypes)
df_1 = df.iloc[1:]
print("----DataTypes of the new DataFrame is-----")
print(df_1.dtypes)
print("----After conversion DataTypes of the DataFrame is----")
df_2=df_1.infer_objects()
print(df_2.dtypes)
-数据帧的数据类型为-
a 对象
b 对象
数据类型:对象
-新数据帧的数据类型为-
a 对象
b 对象
数据类型:对象
-转换后数据帧的数据类型为-
a int64
b 对象
数据类型:对象
示例 2:DataFrame.infer_objects()方法
这是另一个使用DataFrame.infer_objects()方法转换列的数据类型的例子。
#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'a': [7, 1, 5], 'b': ['3','2','1']}, dtype='object')
print("----DataTypes of the DataFrame is-----")
print(df.dtypes)
print("----After conversion DataTypes of the DataFrame is----")
df_1=df.infer_objects()
print(df_1.dtypes)
-数据帧的数据类型为-
a 对象
b 对象
数据类型:对象
-转换后数据帧的数据类型为-
a int64
b 对象
数据类型:对象
结论
在本教程中，我们学习了 PythonPandasDataFrame.infer_objects()方法。我们使用DataFrame.infer_objects()方法转换数据帧的列类型。
Pandas 数据帧info()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-info-method
在本教程中，我们将讨论和学习 PandasDataFrame.info() 的方法。此方法可用于获取数据帧的摘要。当我们在数据帧上应用此方法时，它会打印关于数据帧的信息，包括索引数据类型和列、非空值以及内存使用情况。
下面是DataFrame.info()方法的语法。
句法
DataFrame.info(verbose=None, buf=None, max_cols=None, memory_usage=None, show_counts=None, null_counts=None)
DataFrame.info()方法的一些重要参数是，
数据:它表示数据帧，打印关于它的信息。
verbose: 表示 bool(真或假)，可选。它指示是否打印数据帧的完整摘要。
memory_usage: 表示 bool(真或假)，可选。它指定是否显示包含索引的 DataFrame 元素的总内存使用信息
show_counts: 表示 bool(真或假)，可选。它指示是否显示非空计数。
null_counts: 表示 bool(真或假)，可选。
示例:DataFrame.info()方法
DataFrame.info()方法打印数据帧的完整摘要。看，这在下面的例子中是如何工作的。
import pandas as pd
int_values = [1, 2, 3, 4, 5]
text_values = ['alpha', 'beta', 'gamma', 'delta', 'epsilon']
float_values = [0.0, 0.25, 0.5, 0.75, 1.0]
df = pd.DataFrame({"int_col": int_values, "text_col": text_values,"float_col": float_values})
print("----SUMMARY OF THE DATAFRAME IS-----")
print(df.info(verbose=True))
-数据帧的概要 IS -
<类“pandas . core . frame . Data frame”>
范围索引:5 个条目，0 到 4
数据列(总共 3 列):
列非空计数数据类型
0 int _ col 5 非空 int64
1 text_col 5 非空对象
2 float_col 5 非空 float64
数据类型:float64(1
示例:在DataFrame.info()方法中设置verbose=False
这里，我们打印的是列数及其数据类型的摘要，而不是每列信息。见下面的例子。
import pandas as pd
int_values = [1, 2, 3, 4, 5]
text_values = ['alpha', 'beta', 'gamma', 'delta', 'epsilon']
float_values = [0.0, 0.25, 0.5, 0.75, 1.0]
df = pd.DataFrame({"int_col": int_values, "text_col": text_values,"float_col": float_values})
print("----SUMMARY OF THE DATAFRAME IS-----")
print(df.info(verbose=False))
-data frame IS-
<类的概要“pandas . core . frame . data frame”>
范围索引:5 个条目，0 到 4
列:3 个条目，int_col 到 float_col
数据类型:float64(1)，int64(1)，object(1)
内存使用:248.0+字节
无
示例:DataFrame.info()方法
当我们设置参数null_counts=False,时，DataFrame.info()方法通过排除空计数来打印数据帧的完整摘要。见下面的例子。
import pandas as pd
import numpy as np
int_values = [np.nan,np.nan,np.nan,np.nan,np.nan]
text_values = ['alpha', 'beta', 'gamma','delta', 'epsilon']
float_values = [0.0, 0.25, 0.5, 0.75, 1.0]
df = pd.DataFrame({"int_col": int_values, "text_col": text_values,"float_col": float_values})
print("----SUMMARY OF THE DATAFRAME IS-----")
print(df.info(verbose=True,null_counts = False))
-Data frame IS-
<类“pandas . core . frame . Data frame”>
范围索引:5 个条目，0 到 4 个
数据列(共 3 列):
Column Dtype
0 int _ col float 64
1 text _ col object
2 float _ col float 64
dtypes:float 64(2)，object(1)
内存使用量:248
结论
在本教程中，我们学习了 PandasDataFrame.info()方法。我们学习了语法，并通过一些例子在数据帧上应用了这个方法。
Pandas 数据帧insert()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-insert-method
在本教程中，我们将学习 PandasDataFrame.insert()的方法。此方法将列插入到指定位置的数据帧中。如果该列已经包含在数据帧中，它将引发ValueError，除非 allow_duplicates 设置为 True。
下图显示了DataFrame.insert()方法的语法。
句法
DataFrame.insert(loc, column, value, allow_duplicates=False)
因素
loc: int。插入索引。必须验证 0 < = loc < = len(列)。
列:字符串、数字或散列对象。插入列的标签。
值: int、Series 或类似数组
允许重复: bool，可选
示例 1:在数据帧中插入新列
我们可以使用DataFrame.insert()方法向数据帧中插入一个新列。看，在下面的例子中它是如何工作的。
#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'A':[1,2,3,4],'B':[5,6,7,8]})
print("The DataFrame is")
print(df)
print("Adding column to the DataFrame")
df.insert(2,'C',1)
print(df)
一旦我们运行该程序，我们将获得以下输出。
数据帧为
A B
0 1 5
1 2 6
2 3 7
3 4 8
在数据帧中添加列
A B C
0 1 5 1
1 2 6 1
2 3 7 1
3 4 8 1
示例 2:在数据帧中插入新列
我们可以使用DataFrame.insert()方法插入Series作为数据帧的一列。它将在添加列后返回一个新的数据帧。
#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'A':[1,2,3,4],'B':[5,6,7,8]})
print("The DataFrame is")
print(df)
print("Adding column to the DataFrame")
df.insert(0,'C',1)
print(df)
一旦我们运行该程序，我们将获得以下输出。
数据帧为
A B
0 1 5
1 2 6
2 3 7
3 4 8
在数据帧中添加列
C A B
0 1 5
1 1 2 6
2 1 3 7
3 1 4 8
示例:将列插入数据帧时出错
如果列已经包含在数据帧中，则DataFrame.insert()方法会引发ValueError。
#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'A':[1,2,3,4],'B':[5,6,7,8]})
print("Adding column to the DataFrame")
df.insert(2,'A',1)
print(df)
一旦我们运行该程序，我们将获得以下输出。
值错误:不能插入 A，已经存在
结论
在本教程中，我们学习了 PandasDataFrame.insert()方法。我们学习了语法，并在示例中应用了该方法。
Pandas 数据帧interpolate()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-interpolate-method
在本教程中，我们将学习 PandasDataFrame.interpolate()方法。此方法使用插值方法填充 NaN 值。带有多索引的数据帧支持method='linear'。当此方法应用于数据帧时，它通过填充空值返回序列或数据帧。如果inplace=True返回无。
下图显示了DataFrame.interpolate()方法的语法。
句法
DataFrame.interpolate(method='linear', axis=0, limit=None, inplace=False, limit_direction=None, limit_area=None, downcast=None, **kwargs)
因素
方法: str，默认‘线性’。其他方法有:{线性、时间、索引、值、pad、最近、零、slinear、二次、三次、样条、重心、多项式、krogh、分片 _ 多项式、样条、pchip、akima、立方样条、from _ 导数}。
轴:“0”代表索引，“1”代表列，默认值为无。它表示沿哪个轴进行插值。
极限:代表 int，可选，但必须大于 0。它指示要填充的最大连续 nan 数。
inplace: 表示 bool(真或假)，默认值为 False。
limit_direction: 包括‘向前’、‘向后’、‘两者’可选。它表示要在指定方向上填充的连续空值。
示例:使用DataFrame.interpolate() 方法插值缺失值
使用linear方法，DataFrame.interpolate() 方法通过忽略索引来填充空值，并将这些值视为等距。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),],columns=list('abcd'))
print(df)
print("-----Filling the null values using the linear method-----")
print(df.interpolate(method='linear', limit_direction='forward'))
a b c d
0 0.0 NAn-1.0 1.0
1 NAn 2.0 NAn
2 2.0 3.0 NAn 9.0
-使用线性方法填充空值-
a b c d
0 0.0 NAn-1.0 1.0
1 1.0 2.0-1.0 5.0
2 2.0 3.0-1.0 9.0
示例:使用DataFrame.interpolate() 方法和polynomial方法向前插入缺失值。
DataFrame.interpolate() 方法使用polynomial方法填充空值。当我们使用polynomial方法时，我们必须指定样条或多项式的顺序。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),],columns=list('abcd'))
print(df)
print("-----Filling the null values using the polynomial method-----")
print(df['a'].interpolate(method='polynomial', limit_direction='forward',order=1))
a b c d
0 0.0 NAn-1.0 1.0
1 NAn 2.0 NAn
2 2.0 3.0 NAn 9.0
-使用多项式方法填充空值-
0 0.0
1 1.0
2 2.0
名称:a，数据类型:float64
示例:在DataFrame.interpolate() 方法中设置method= pad
我们可以使用pad方法在正向插入缺失值，该方法使用现有值填充 NaNs。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),],columns=list('abcd'))
print(df)
print("-----Filling the null values using the pad method-----")
print(df.interpolate(method='pad', limit_direction='forward'))
a b c d
0 0.0 NAn-1.0 1.0
1 NAn 2.0 NAn
2 2.0 3.0 NAn 9.0
-使用填充方法填充空值-
a b c d
0 0.0 NAn-1.0 1.0
1 0.0 2.0-1.0 1.0
2 2.0 3.0-1.0 9.0
结论:
在本教程中，我们学习了 PandasDataFrame.interpolate()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.interpolate()方法。
Pandas 数据帧isin()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-isin-method
在本教程中，我们将讨论和学习 PandasDataFrame.isin()的方法。此方法检查数据帧中的每个元素是否包含在指定的值中。当此方法应用于数据帧时，它返回布尔值的数据帧。如果数据帧由真组成，则元素以指定值出现，否则显示假。
下面是DataFrame.isin()方法的语法。
句法
DataFrame.isin(values)
因素
值:可以是可迭代、序列、数据帧或字典。如果值是一个序列，那就是索引。如果值是字典，则键必须是列名，列名必须匹配。如果值是数据帧，则索引和列标签必须匹配。
示例 1:使用DataFrame.isin()方法检查值
这里，我们使用DataFrame.isin()方法用list 检查数据帧。如果数据帧中的每个值都出现在list中，则返回真的布尔值数据帧，否则返回假的。见下面的例子。
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({'a': [2, 4], 'b': [2, 0], 'c':[3, 5]})
print("-----The DataFrame is----")
print(df)
print("----------------------")
df_1=df.isin([2,3])
print(df_1)
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b c
0 2 2 3
1 4 0 5
a b c
0 真真真
1 假假假
示例 2:使用DataFrame.isin()方法检查值
这里，我们使用DataFrame.isin()方法用Series 检查数据帧。如果数据帧中的每个值都出现在Series 中，则返回真的布尔值数据帧，否则返回假的。见下面的例子。
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({'a': [2, 4], 'b': [2, 0], 'c':[3, 5]})
print("-----The DataFrame is----")
print(df)
print("----------------------")
series=pd.Series([2,0,3])
df_1=df.isin(series)
print(df_1)
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b c
0 2 2 3
1 4 0 5
a b c
0 真真假假
1 假真假假
示例 3:使用DataFrame.isin()方法检查值
这里，我们使用DataFrame.isin()方法用other DataFrame 检查数据帧。如果数据帧中的每个值都出现在other DataFrame 中，则返回真的布尔值数据帧，否则返回假的。见下面的例子。
import pandas as pd
#creating the DataFrame
df_1= pd.DataFrame({'a': [2, 4], 'b': [2, 0], 'c':[3, 5]})
print("-----The DataFrame is----")
print(df_1)
print("----------------------")
df_2= pd.DataFrame({'a': [0, 4], 'b': [1, 0], 'c':[3, 2]})
print(df_2)
print("----------------------")
print(df_1.isin(df_2))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b c
0 2 2 3
1 4 0 5
a b c
0 1 3
1 4 0 2
a b c
0 假真
1 真真假
示例 4:使用DataFrame.isin()方法检查值
这里，我们使用DataFrame.isin()方法用dictionary 检查数据帧。如果数据帧中的每个值都出现在dictionary中，则返回布尔值的数据帧，否则返回假。见下面的例子。
import pandas as pd
#creating the DataFrame
df_1= pd.DataFrame({'a': [2, 4], 'b': [2, 0], 'c':[3, 5]})
print("-----The DataFrame is----")
print(df_1)
print("----------------------")
dict = {'a': [2, 1]}
print(dict)
print("----------------------")
print(df_1.isin(dict))
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b c
0 2 2 3
1 4 0 5
a b c
0 真假假
1 假假假假
结论:
在本教程中，我们学习了 PandasDataFrame.isin()方法。我们学习了语法，并通过示例将该方法应用于数据帧。
Pandas 数据帧isna()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-isna-method
在本教程中，我们将学习 PandasDataFrame.isna()方法。该方法可用于检测缺失值。当此方法应用于数据帧时，它返回布尔值的数据帧。如果结果数据帧由“真”组成，则表示该元素为空值；如果为“假”，则表示该元素不是空值。该方法不将空字符串''或numpy.inf等字符视为空值。
下面是DataFrame.isna()方法的语法。
句法
DataFrame.isna()
示例 1:检测 Pandas 的缺失值
这里，我们使用DataFrame.isna() 方法检测数据帧中缺失的值，该方法返回数据帧，该数据帧由数据帧中每个元素的布尔值组成，该值指示一个元素是否为NA 值。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),],columns=list('abcd'))
print("------The DataFrame is----------")
print(df)
print("---------------------------------")
print(df.isna())
-数据帧为-
a b c d
0 0.0 NaN-1.0 1.0
1 NaN 2.0 NaN
2 2.0 3.0 NaN 9.0
a b c d
0 假真假假
1 真假真
2 假假真假
示例 2:检测 Pandas 的缺失值
这个例子类似于前面的例子，并且DataFrame.isna()方法不考虑空字符串作为 NA 值。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame({'a':[0,1,''],'b':['',None,3]})
print("------The DataFrame is----------")
print(df)
print("---------------------------------")
print(df.isna())
-数据帧为-
a b
0 0
1 无
2 3
a b
0 假假
1 假真
2 假
结论
在本教程中，我们学习了 PandasDataFrame.isna()方法。我们学习了语法，并使用DataFrame.isna()方法检查数据帧是否包含空值。
Pandas 数据帧isnull()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-isnull-method
在本教程中，我们将学习 PandasDataFrame.isnull()方法。当此方法应用于数据帧时，它返回布尔值的数据帧。如果结果数据帧由“真”组成，则表示该元素为空值；如果为“假”，则表示该元素不是空值。该方法不将空字符串''或numpy.inf等字符视为空值。
下图显示了DataFrame.isnull()方法的语法。
句法
DataFrame.isnull()
示例 1:检测 Pandas 的缺失值
这里，我们使用DataFrame.isnull() 方法检测数据帧中缺失的值，该方法返回数据帧，该数据帧由数据帧中每个元素的布尔值组成，该值指示一个元素是否为NA 值。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame([(0.0, np.nan, -1.0, 1.0),(np.nan, 2.0, np.nan, np.nan),(2.0, 3.0, np.nan, 9.0),],columns=list('abcd'))
print("------The DataFrame is----------")
print(df)
print("---------------------------------")
print(df.isnull())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b c d
0 0.0 NaN-1.0 1.0
1 NaN 2.0 NaN
2 2.0 3.0 NaN 9.0
a b c d
0 假真假假
1 真假真
2 假假真假
示例 2:检测 Pandas 的缺失值
这个例子类似于前面的例子，并且DataFrame.isnull()方法不考虑空字符串作为 NA 值。见下面的例子。
#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df = pd.DataFrame({'a':[0,1,''],'b':['',None,3]})
print("------The DataFrame is----------")
print(df)
print("---------------------------------")
print(df.isnull())
一旦我们运行该程序，我们将获得以下输出。
-数据帧为-
a b
0 0
1 无
2 3
a b
0 假假
1 假真
2 假
结论
在本教程中，我们学习了 PandasDataFrame.isnull()方法。我们学习了语法，并使用DataFrame.isnull()方法检查数据帧是否包含空值。
Pandas 数据帧items()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-items-method
在本教程中，我们将学习 PandasDataFrame.items()方法。此方法迭代(列名、序列)对。当此方法应用于数据帧时，它会遍历数据帧列并返回一个由column name和content组成的tuple作为Series。
下面是DataFrame.items()方法的语法。
句法
DataFrame.items()
示例 1:使用DataFrame.items()方法迭代数据帧
当我们使用DataFrame.items()方法迭代数据帧的列时，它将返回generator object。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
print(df.items())
-数据帧是-
名称年龄教育
id 001 Navya 25M . Tech
id 002 Vindya 24 博士
-迭代列名-
<生成器对象数据帧项位于 0x000001E341897350 >
示例 2:使用DataFrame.items()方法迭代数据帧
在最后一个例子中，我们理解当我们使用DataFrame.items()方法迭代数据帧的列时，它将返回generator object。通过使用 for 循环，我们可以使用这个对象来生成一对column_name 和值。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("---------Iterate over column name---------")
for column_name,data in df.items():
print('column_name:',column_name,'data:',data)
-迭代列名-
列名:名称数据:id001 Navya
id002 Vindya
名称:名称，数据类型:对象
列名:年龄数据:id001 25
id002 24
名称:年龄，数据类型:int64
列名:教育数据:id001 M.Tech
id002 Ph.d
名称:教育，数据类型:对象
示例 3:使用DataFrame.items()方法迭代数据帧
我们也可以通过指定索引号来打印某一行。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
for column_name,data in df.items():
print('column_name:',column_name,'data:',data[0])
-数据帧为-
名称年龄教育
id 001 Navya 25M.Tech
id 002 Vindya 24 博士
-迭代列名-
列名:姓名数据:Navya
列名:年龄数据:25
列名:教育数据:M . Tech
示例 4:使用DataFrame.items()方法迭代数据帧
我们可以从整个数据帧中迭代指定的索引或列。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
for column_name,data in df.items():
print('column_name:',column_name,'data:',data['id001'])
-数据帧为-
名称年龄教育
id 001 Navya 25M.Tech
id 002 Vindya 24 博士
-迭代列名-
列名:姓名数据:Navya
列名:年龄数据:25
列名:教育数据:M . Tech
结论:
在本教程中，我们学习了 PandasDataFrame.items()方法。我们学习了语法并将该方法应用于数据帧，以理解 DataFrame.items()方法。
Pandas 数据帧iteritems()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-iteritems-method
在本教程中，我们将学习 PandasDataFrame.iteritems()方法。此方法迭代(列名、序列)对。当此方法应用于数据帧时，它会遍历数据帧列并返回一个由column name和content组成的tuple作为Series。
下面是DataFrame.iteritems()方法的语法。
句法
DataFrame.iteritems()
产量
标签:它代表的对象是正在迭代的数据帧中的列名。
内容:代表系列。每个标签的内容代表一个系列。
示例:使用DataFrame.iteritems()方法迭代列名
当我们使用DataFrame.items()方法迭代数据帧的列时，它将返回generator object。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
print(df.iteritems())
-数据帧是-
名称年龄教育
id 001 Navya 25M . Tech
id 002 Vindya 24 博士
-迭代列名-
<生成器对象数据帧项位于 0x000001E341897350 >
示例:使用 for 循环使用DataFrame.iteritems()方法迭代列名
在最后一个例子中，我们理解当我们使用DataFrame.iteritems()方法迭代数据帧的列时，它将返回generator object。通过使用 for 循环，我们可以使用这个对象来生成一对column_name 和data。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("---------Iterate over column name---------")
for column_name,data in df.iteritems():
print('column_name:',column_name,'data:',data)
-迭代列名-
列名:名称数据:id001 Navya
id002 Vindya
名称:名称，数据类型:对象
列名:年龄数据:id001 25
id002 24
名称:年龄，数据类型:int64
列名:教育数据:id001 M.Tech
id002 Ph.d
名称:教育，数据类型:对象
示例:使用 for 循环使用DataFrame.iteritems()方法迭代指定的索引
我们也可以通过指定索引号来打印某一行。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
for column_name,data in df.iteritems():
print('column_name:',column_name,'data:',data[0])
-数据帧为-
名称年龄教育
id 001 Navya 25M.Tech
id 002 Vindya 24 博士
-迭代列名-
列名:姓名数据:Navya
列名:年龄数据:25
列名:教育数据:M . Tech
示例:使用 for 循环使用DataFrame.iteritems()方法迭代指定的索引
我们还可以指定索引的名称，而不是索引号。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over column name---------")
for column_name,data in df.iteritems():
print('column_name:',column_name,'data:',data['id001'])
-数据帧为-
名称年龄教育
id 001 Navya 25M.Tech
id 002 Vindya 24 博士
-迭代列名-
列名:姓名数据:Navya
列名:年龄数据:25
列名:教育数据:M . Tech
结论:
在本教程中，我们学习了 PandasDataFrame.iteritems()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.iteritems()方法。
Pandas 数据帧iterrows()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-iterrows-method
在本教程中，我们将学习 PandasDataFrame.iterrows()方法。此方法以(索引、序列)对的形式迭代行。当此方法应用于数据帧时，它会遍历数据帧行并返回一个由column name和content 组成的tuple作为Series。
下图显示了DataFrame.iterrows()方法的语法。
句法
DataFrame.iterrows()
示例:使用DataFrame.iterrows()方法迭代行名
当我们使用DataFrame.iterrows()方法迭代数据帧的行时，它将返回generator object。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over rows name---------")
print(df.iterrows())
-数据帧是-
名称年龄教育
id 001 Navya 25M . Tech
id 002 Vindya 24 博士
-遍历行名称-
<生成器对象数据帧 over rows 位于 0x000001E34195B890 >
示例:DataFrame.iterrows()方法
在最后一个例子中，我们理解当我们使用DataFrame.iterrows()方法迭代数据帧的行时，它将返回generator object。通过使用 for 循环，我们可以使用这个对象来生成一对index_name 和data。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("---------Iterate over rows name---------")
for column_name,data in df.iterrows():
print('index_name:',column_name,'data:',data)
一旦我们运行该程序，我们将获得以下输出。
-遍历行名称-
index_name: id001 数据:Name Navya
Age 25
教育 M.Tech
名称:id001，dtype: object
index _ Name:id002 数据:Name Vindya
Age 24
教育博士
名称:id 002，dtype:object
示例:DataFrame.iterrows()方法
我们也可以通过指定索引号来打印某一行。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("---------Iterate over rows name---------")
for column_name,data in df.iterrows():
print('index_name:',column_name,'data:',data[0])
-遍历行名称-
索引 _ 名称:id001 数据:Navya
索引 _ 名称:id002 数据:Vindya
示例:DataFrame.iterrows()方法
我们也可以指定列名而不是列名。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['id001', 'id002'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over rows name---------")
for column_name,data in df.iterrows():
print('index_name:',column_name,'data:',data['Name'])
-数据帧为-
名称年龄教育
id 001 Navya 25M . Tech
id 002 Vindya 24 博士
-遍历行名称-
index_name: id001 数据:Navya
index_name: id002 数据:Vindya
结论:
在本教程中，我们学习了 PandasDataFrame.iterrows()方法。我们学习了语法，并通过在数据帧上应用此方法。
Pandas 数据帧itertuples()方法
原文：https://www.studytonight.com/pandas/pandas-dataframe-itertuples-method
在本教程中，我们将学习 PandasDataFrame.itertuples() 法。DataFrame.itertuples() 方法将数据帧的行迭代为namedtuples。当此方法应用于数据帧时，它会返回一个地图对象。我们可以使用返回的对象迭代 DataFrame 中每一行的 namedtuples，第一个字段可能是索引，后面的字段是列值。
下图显示了DataFrame.itertuples() 方法的语法。
句法
DataFrame.itertuples(index=True, name='Pandas')
因素
指数:是布尔。默认值为True.如果该参数为真，则该函数返回索引作为元组的第一个元素。
名称:为字符串或无。默认为“Pandas”。它代表返回的名为“T4”的夫妇的名字。如果为无，则返回正则元组。
示例:遍历数据帧的行
在下面的例子中，我们使用DataFrame.itertuples()方法创建了数据帧。我们尝试迭代数据帧的行。DataFrame.itertuples()方法返回map 对象。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['index_1', 'index_2'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over DataFrame rows---------")
print(df.itertuples())
-数据帧是- w -
名称年龄教育
索引 _1 纳维亚 25 米技术
索引 _2 文迪亚 24 博士
-迭代数据帧行-
<映射对象在 0x000001C9899720A0 >
示例:DataFrame.itertuples()方法
在前面的例子中，我们可以看到DataFrame.itertuples()方法返回映射对象来迭代数据帧的行。我们可以使用for 循环将数据帧的行显示为namedtuples。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['index_1', 'index_2'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over DataFrame rows---------")
for rows in df.itertuples():
print(rows)
由于DataFrame.itertuples() 方法的“index”和“name”参数分别为“True”和“Pandas”，因此它返回第一个元素元组作为索引，返回元组的名称为“Pandas”。
-数据帧为-
名称年龄教育
索引 _1 Navya 25 M.Tech
索引 _2 Vindya 24 博士
-迭代数据帧行-
Pandas(索引='index_1 '，名称='Navya '，年龄=25，教育='M.Tech')
Pandas(索引='index_2 '，名称='Vindya '，年龄=24，教育= '博士')
示例:在DataFrame.itertuples()方法中设置index=False
如果DataFrame.itertuples() 的索引参数是“False”，我们可以删除index 作为元组的第一个元素。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['index_1', 'index_2'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over DataFrame rows---------")
for rows in df.itertuples(index=False):
print(rows)
在下面的输出中，我们可以看到，DataFrame.itertuples()函数没有将索引显示为元组。
-数据帧为-
名称年龄教育
索引 _1 纳维雅 25 M.Tech
索引 _2 Vindya 24 博士
-迭代数据帧行-
Pandas(名称= '纳维雅'，年龄=25，教育='M.Tech')
Pandas(名称='Vindya '，年龄=24，教育= '博士')
示例:DataFrame.itertuples()方法
我们可以使用DataFrame.itertuples()函数的name 方法指定返回的命名元组的名称。默认名称将被删除，指定的名称将被显示。见下面的例子。
#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"Name":["Navya","Vindya"],"Age":[25,24],"Education":["M.Tech","Ph.d"]},index=['index_1', 'index_2'])
print("-----------The DataFrame is-------")
print(df)
print("---------Iterate over DataFrame rows---------")
for rows in df.itertuples( name='Rows'):
print(rows)
如我们所见，namedtuples 的名称显示为“Rows”。
-数据帧为-
名称年龄教育
索引 _1 Navya 25 M.Tech
索引 _2 Vindya 24 博士
-迭代数据帧行-
行(索引='index_1 '，名称='Navya '，年龄=25，教育='M.Tech')
行(索引='index_2 '，名称='Vindya '，年龄=24，教育= '博士')
结论
在本教程中，我们学习了 PandasDataFrame.itertuples()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.itertuples()方法。
