StudyTonight-Python-中文教程-三-

StudyTonight Python 中文教程（三）

原文：StudyTonight

协议：CC BY-NC-SA 4.0

Pandas 数据帧`join()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-join-method

在本教程中，我们将学习 PandasDataFrame.join()的方法。此方法用于连接另一个数据帧的列。它将列与索引或键列上的其他数据帧连接起来。通过索引，该方法可以通过传递一个列表来连接多个数据帧对象。

下图显示了DataFrame.join()方法的语法。

句法

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

参数

其他:代表数据帧、序列或数据帧列表。

on: 表示 str，str 列表，或数组状，可选。

如何:包括‘左’、‘右’、‘外’、‘内’，默认为‘左’。

lsuffix: 表示字符串，默认为' '。用于左框架重叠列的后缀。

rsuffix: 表示字符串，默认为' '。右框架重叠列中使用的后缀。

排序:表示 bool，默认为 False。它按照连接键对生成的数据帧进行字典排序。如果为 False，连接键的顺序取决于连接类型(how 关键字)。

示例:使用`DataFrame.join()`方法连接两个数据帧

这里，在这个例子中，我们将创建两个数据帧，并使用DataFrame.join()方法连接这两个数据帧。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df_1=pd.DataFrame({"A":[0,1],"B":[3,4]})
print("-----------The DataFrame is-------")
print(df_1)
df_2=pd.DataFrame({"C":[0,1],"D":[3,4,]})
print("----------------------------------")
print(df_2)
print("------------------")
print(df_1.join(df_2))

-数据帧为-
A B
0 0 3
1 1 4

C D
0 0 3
1 1 4

A B C D
0 3 0 3
1 4 1 4

示例:使用 lsuffix 和 rsuffix 连接两个数据帧

这里，我们使用后缀的方法来区分左右框架的重叠列。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df_1=pd.DataFrame({"A":[0,1],"B":[3,4]})
print("-----------The DataFrame is-------")
print(df_1)
df_2=pd.DataFrame({"A":[0,1],"B":[3,4,]})
print("----------------------------------")
print(df_2)
print("------------------")
print(df_1.join(df_2,lsuffix='_first', rsuffix='_second'))

-数据帧为-
A B
0 0 3
1 1 4

A B
0 0 3
1 1 4

A _ first B _ first A _ second B _ second
0 0 3 0 3
1 1 4 1 4

示例:`DataFrame.join()`方法

如果我们想使用“A”列进行连接，我们需要将“A”设置为 df_1 和 df_2 中的索引。连接的数据帧将以“A”作为其索引。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df_1=pd.DataFrame({"A":[0,1],"B":[3,4]})
print("-----------The DataFrame is-------")
print(df_1)
df_2=pd.DataFrame({"A":[0,1],"D":[3,4,]})
print("----------------------------------")
print(df_2)
print("------------------")
print(df_1.set_index('A').join(df_2.set_index('A')))

-数据帧为-
A B
0 0 3
1 1 4

A D
0 3
1 1 4

B D
A
0 3 3
1 4 4

结论

在本教程中，我们学习了 PandasDataFrame.join()方法。我们学习了语法，通过在数据帧上应用这种方法，我们解决了一些例子并理解了 DataFrame.join()方法。

Pandas 数据帧`keys()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-keys-method

在本教程中，我们将学习 PandasDataFrame.keys()的方法。用这种方法我们可以得到‘info axis’。这是系列的索引，数据帧的列。

下图显示了DataFrame.keys()方法的语法。

句法

DataFrame.keys()

示例:`DataFrame.keys()`方法

让我们创建一个数据帧，并获取关于数据帧的index 的信息。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[0,1],"B":[3,4],"C":[0,1],"D":[3,4,]})
print("-----------The DataFrame is-------")
print(df)
print(df.keys())

-数据帧是-
A B C D
0 0 3 0 3
1 1 4 1 4
索引(['A '，' B '，' C '，' D']，数据类型= '对象')

示例:使用`DataFrame.keys()`方法获取数据帧的索引信息

下面的例子类似于前面的例子，只是我们得到了关于数据帧索引的信息。

#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(df.keys())

-数据帧为-
姓名年龄教育
指数 _1 纳维亚 25 米科技
指数 _2 温迪亚 24 博士
指数(['姓名'，'年龄'，'教育']，数据类型= '对象')

结论

在本教程中，我们学习了 PandasDataFrame.keys()方法。我们学习了语法并将该方法应用于数据帧，以理解 DataFrame.keys()方法。

Pandas 数据帧`kurt()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-kurt-method

在本教程中，我们将学习 PandasDataFrame.kurt() 方法。此方法返回请求轴上的无偏峰度。

峰度使用费希尔峰度定义获得(正态峰度== 0.0)。用 N-1 归一化。下图显示了DataFrame.kurt() 方法的语法。

句法

DataFrame.kurt(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:。要应用的方法的轴。

skipna: bool，默认为 True。计算结果时不包括数值/空值。

级别: int 或级别名，默认无。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值: bool，默认无。只包括浮点、整型和布尔型列。如果没有，将尝试使用所有内容，然后只使用数字数据。不适用于系列。

**kwargs :要传递给方法的附加关键字参数。

示例:`DataFrame.kurt()` 方法

在这个例子中，我们沿着axis=0使用DataFrame.kurt() 方法来获得数据帧的无偏峰度。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,74,50],"B":[30,55,40,47],"C":[12,55,44,66]})
print("-----------The DataFrame is-------")
print(df)
print("-------------------------------")
print(df.kurt(axis=0))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
A B C
0 55 30 12
1 60 55 55
2 74 40 44
3 50 47 66

A 1.307557
B- 0.466318
C 1.414727
数据类型:float64

示例:使用`DataFrame.kurt()` 方法的数据帧

以下示例通过排除空值显示了DataFrame.kurt() 方法。它返回非空值。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,None,60,50],"B":[42,30,None,40,47],"C":[None,75,55,44,66]})
print(df.kurt(axis=0,skipna=True))

一旦我们运行该程序，我们将获得以下输出。

A-1.289256
B 1.704496
C-1.441136
数据类型:float64

示例:使用`DataFrame.kurt()` 方法的数据帧

下面的代码显示了DataFrame.kurt() 方法的例子，该方法只包含数值。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,None,60,50],"B":[42,30,None,40,47],"C":[None,75,55,44,66]})
print(df.kurt(axis=0,numeric_only=True))

一旦我们运行该程序，我们将获得以下输出。

A-1.289256
B 1.704496
C-1.441136
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.kurt()方法。我们学习了语法并将该方法应用于数据帧，以理解 DataFrame.kurt()方法。

Pandas 数据帧`kurtosis()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-kurtosis-method

在本教程中，我们将学习 PandasDataFrame.kurtosis() 方法。此方法返回请求轴上的无偏峰度。

峰度使用费希尔峰度定义获得(正态峰度== 0.0)。用 N-1 归一化。下图显示了DataFrame.kurtosis() 方法的语法。

句法

DataFrame.kurtosis(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:。要应用的方法的轴。

skipna: bool，默认为 True。计算结果时不包括数值/空值。

级别: int 或级别名，默认无。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值: bool，默认无。只包括浮点、整型和布尔型列。如果没有，将尝试使用所有内容，然后只使用数字数据。不适用于系列。

**kwargs :要传递给方法的附加关键字参数。

示例:`DataFrame.kurtosis()`方法

下面的代码显示了沿着轴=0 的DataFrame.kurtosis()方法的例子。它基于指定的轴返回无偏峰度，0 表示索引，1 表示列。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,74,50],"B":[30,55,40,47],"C":[12,55,44,66]})
print("-----------The DataFrame is-------")
print(df)
print("-------------------------------")
print(df.kurtosis(axis=0))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
A B C
0 55 30 12
1 60 55 55
2 74 40 44
3 50 47 66

A 1.307557
B- 0.466318
C 1.414727
数据类型:float64

示例:排除空值的数据帧

下面的代码通过排除空值显示了DataFrame.kurtosis() 方法的示例。skipna 参数跳过空值并返回一个数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,None,60,50],"B":[42,30,None,40,47],"C":[None,75,55,44,66]})
print(df.kurtosis(axis=0,skipna=True))

一旦我们运行该程序，我们将获得以下输出。

A-1.289256
B 1.704496
C-1.441136
数据类型:float64

示例:仅包含数值的数据帧

下面的代码显示了DataFrame.kurtosis() 方法的示例，该方法返回只包含数值的数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({"A":[55,60,None,60,50],"B":[42,30,None,40,47],"C":[None,75,55,44,66]})
print(df.kurtosis(axis=0,numeric_only=True))

一旦我们运行该程序，我们将获得以下输出。

A-1.289256
B 1.704496
C-1.441136
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.kurtosis()方法。我们学习了语法，并将该方法应用于数据帧，以理解 DataFrame.kurtosis()方法。

Pandas 数据帧`last()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-last-method

在本教程中，我们将学习 PandasDataFrame.last()的方法。此方法可用于根据日期偏移选择时间序列数据的最终期间。当数据帧以日期为索引时，此方法可以根据日期偏移量选择最后几行。如果索引不是日期时间索引，它将返回数据帧并引发TypeError

下图显示了DataFrame.last()方法的语法。

句法

DataFrame.last(offset)

因素

偏移量:可以是字符串、日期偏移量或日期相对偏移量，将选择数据偏移量的长度。例如，“1M”将显示第一个月内有索引的所有行。

示例:使用`DataFrame.last()`方法获取最近`n`天的行

这里，我们创建了一个以 DatetimeIdex 为索引的数据帧，我们尝试使用DataFrame.last()方法获取最近3 天的行。

在下面的例子中，返回了最近 3 个calendar days的数据，而不是数据集中观察到的最近 3 天的数据，因此没有返回 2021-01-11 的数据。见下面的例子。

#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.last('3D'))

数据帧为
A
2021-01-09 1
2021-01-11 2
2021-01-13 3
2021-01-15 4
A
2021-01-13 3
2021-01-15 4

示例:使用`DataFrame.last()`方法获取最近`n`天的行

这个例子和上一个相似。这里，在这个例子中，我们尝试使用DataFrame.last()方法获取最近2 天的行。见下面的例子。

#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.last('2D'))

数据帧为
A
2021-01-09 1
2021-01-13 2
2021-01-17 3
2021-01-21 4
A
2021-01-21 4

示例:使用`DataFrame.last()`方法获取最近`n`个月的行数

这里，在这个例子中，我们尝试使用DataFrame.last()方法获取最近 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.last('1M'))

数据帧为
A
2021-01-31 1
2021-02-28 2
2021-03-31 3
2021-04-30 4
A
2021-04-30 4

结论

在本教程中，我们学习了 PandasDataFrame.last()方法。我们学习了语法，并应用这种方法来理解 DataFrame.last()方法。

Pandas 数据帧`last_valid_index()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-last_valid_index-method

在本教程中，我们将学习 PandasDataFrame.last_valid_index() 的方法。通过使用这种方法，我们可以获得最后一个非 NA/null 值的索引。它返回一个标量，该标量是索引的类型。如果所有元素都是非空值，则返回None，对于empty DataFrame.，则返回None

下图显示了DataFrame.last_valid_index()的语法。

句法

DataFrame.last_valid_index()

例:`DataFrame.last_valid_index()` 法。

让我们创建一个空值的数据帧，并使用DataFrame.last_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 last non-NA/null value is:",df.last_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 值的索引为:5

示例:获取 Pandas 中最后一个非空值的索引

除了处理非空值之外，此示例与上一个示例相似。让我们创建一个空值的数据帧，并使用DataFrame.last_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, np.nan, np.nan],[np.nan, np.nan, np.nan],[2, 8, 0],[7, 5, 4],[np.nan,np.nan,np.nan]],columns=list('ABC'))
print("-----The DataFrame is-----")
print(df)
print("Index for last non-NA/null value is:",df.last_valid_index())

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
A B C
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 2.0 8.0 0.0
4 7.0 5.0 4.0
5 NaN NaN
最后一个非 NA/null 值的索引为:4

示例:获取最后一个非空值的索引

如果所有元素都是非空的，则DataFrame.` last_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 last non-NA/null value is:",df.last_valid_index())

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
A B C
0 NaN NaN
1 NaN NaN
2 NaN NaN
3 NaN NaN
最后一个非 NA/空值的索引为:无

结论

在本教程中，我们学习了 PandasDataFrame.last_valid_index()方法。我们学习了语法，并应用这种方法来理解 DataFrame.last_valid_index()方法。

Pandas 数据帧`le()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-le-method

在本教程中，我们将学习 PandasDataFrame.le()的方法。此方法用于获取小于或等于的 dataframe 和其他元素(二元运算符 get)。它返回 bool 的数据帧，这是比较的结果。

下图显示了DataFrame.le()方法的语法。

句法

DataFrame.le(other, axis='columns', level=None)

因素

其他:可以是任何单个或多个元素的数据结构，也可以是类似列表的对象，例如标量、序列、序列或数据帧。

轴:“0”代表索引，“1”代表列，默认为列。表示是按索引轴比较还是按列轴比较。

级别:代表 int 或 label。它跨级别广播，匹配传递的多索引级别上的索引值。

示例:使用`DataFrame.le()`方法将数据帧与常数进行比较

这里，我们使用返回 bool 类型数据帧的DataFrame.le()方法与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 le function-----")
print(df.le(200))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 le 函数后-
A B C
0 真真真
1 假真

示例:使用`DataFrame.le()`方法将数据帧与系列进行比较

这里，我们使用DataFrame.le()方法将数据帧与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 le function-----")
print(df.le(series,axis=0))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 le 函数后-
A B C
0 假真
1 假真
2 假假假假

示例:使用`DataFrame.le()`方法将数据帧与其他数据帧进行比较

这里，我们使用DataFrame.le()方法将数据帧与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 le function-----")
print(df_1.le(df_2))

-第一个数据帧是-
A B C
0 200 60 150
1 500 250 1
-第二个数据帧是-
A B C
0 200 65 100
1 550 251 10
-应用 le 函数后-
A B C
0 True True False
1 True True True

结论:

在本教程中，我们学习了 PandasDataFrame.le()方法。我们学习了语法、参数，并将该方法应用于数据帧，从而理解 DataFrame.le()方法。

Pandas 数据帧`lt()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-lt-method

在本教程中，我们将学习 PandasDataFrame.lt()的方法。此方法用于获取小于的 dataframe 和其他元素(二元运算符 lt)。它返回 bool 的数据帧，这是比较的结果。

下图显示了DataFrame.lt()方法的语法。

句法

DataFrame.lt(other, axis='columns', level=None)

因素

其他:可以是任何单个或多个元素的数据结构，也可以是类似列表的对象，例如标量、序列、序列或数据帧。

轴:“0”代表索引，“1”代表列，默认为列。表示是按索引轴比较还是按列轴比较。

级别:代表 int 或 label。它跨级别广播，匹配传递的多索引级别上的索引值。

示例:使用`DataFrame.lt()`方法将数据帧与常数进行比较

这里，我们使用返回 bool 类型数据帧的DataFrame.lt()方法将数据帧与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 lt function-----")
print(df.lt(200))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 lt 功能后-
A B C
0 假真
1 假真

示例:使用`DataFrame.lt()`方法将数据帧与系列进行比较

这里，我们使用DataFrame.lt()方法将数据帧与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 lt function-----")
print(df.lt(series,axis=0))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 lt 功能后-
A B C
0 假真假
1 假假真
2 假假假假

示例:使用`DataFrame.lt()`方法将数据帧与其他数据帧进行比较

这里，我们使用DataFrame.lt()方法将数据帧与other DataFrame进行比较。

#importing pandas as pd
import pandas as pd
#creating the DataFrames
df_1=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
df_2=pd.DataFrame({"A":[200,550],"B":[65,251],"C":[100,10]})
print("----After applying lt function-----")
print(df_1.lt(df_2))

-应用 lt 函数后-
A B C
0 假真假
1 真真真

结论:

在本教程中，我们学习了 PandasDataFrame.lt()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.lt()方法。

Pandas 数据帧`mad()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-mad-method

任何数据集中的变化都可以由平均绝对偏差(MAD) 确定，它可以定义为每个数据值和平均值之间的平均距离。在本教程中，我们将学习 Python Pandas DataFrame.mad() 方法。当DataFrame.mad()方法应用于数据帧时，它返回所请求的axis值的平均绝对偏差。

下图显示了DataFrame.mad()方法的语法。

句法

DataFrame.mad(axis=None, skipna=None, level=None)

因素

轴:“0”代表索引，“1”代表列。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。

skipna: 代表布尔(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果数据帧是多索引的，则它与特定级别一起计算，折叠成一个系列。

示例:`DataFrame.mad()`方法

让我们创建一个数据帧，并通过在DataFrame.mad()方法中指定参数axis=0 获得index轴上的值的平均绝对偏差。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,2,3],"B":[4,5,6],"C":[7,8,9],"D":[10,11,12]}) 
print("----------The DataFrame is------")
print(df)
print("---The mean absolute deviation of the DataFrame is---")
print(df.mad(axis=0))

-数据帧为-
A B C D
0 1 4 7 10
1 2 5 8 11
2 3 6 9 12
-数据帧的平均绝对偏差为-
A 0.666667
B 0.666667
C 0.66667
D 0.66667
dttype:float 64

示例:沿`column`轴的`DataFrame.mad()`方法

让我们创建一个数据帧，通过在DataFrame.mad()方法中指定参数axis=1 ，得到列轴上值的平均绝对偏差。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,2,3],"B":[4,5,6],"C":[7,8,9],"D":[10,11,12]}) 
print("----------The DataFrame is------")
print(df)
print("---The mean absolute deviation of the DataFrame is---")
print(df.mad(axis=1))

-数据帧为-
A B C D
0 1 4 7 10
1 2 5 8 11
2 3 6 9 12
-数据帧的平均绝对偏差为-
0 3.0
1 3.0
2 3.0
数据类型:float64

示例:排除空值的`DataFrame.mad()`方法

让我们创建一个具有空值的数据帧，并通过在DataFrame.mad()方法中传递参数skipna 来获得除空值之外的索引轴上的值的平均绝对偏差。在计算结果时，它会排除所有 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,None,3],"B":[None,5,6],"C":[7,8,9],"D":[10,11,None]}) 
print("----------The DataFrame is------")
print(df)
print("---The mean absolute deviation of the DataFrame is---")
print(df.mad(axis=0,skipna=True))

-数据帧为-
A B C D
0 1.0 NaN 7 10.0
1 NaN 5.0 8 11.0
2 3.0 6.0 9 NaN
-数据帧的平均绝对偏差为-
A 1.000000
B 0.500000
C 0.666667
D 0.500000
dtype

结论

在本教程中，我们学习了 PandasDataFrame.mad()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.mad()方法。

Pandas 数据帧`max()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-max-method

在本教程中，我们将讨论和学习 PandasDataFrame.max()的方法。此方法可用于获取请求轴上的最大值。它返回序列，如果指定了级别，它将返回数据帧。

下图显示了DataFrame.max()方法的语法。

句法

DataFrame.max(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时。

skipna: 代表布尔(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果数据帧是一个多索引，则它与特定级别一起计算，并折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

**kwargs :要传递给函数的附加关键字参数。

示例:查找数据帧的最大值

让我们创建一个数据帧，通过在DataFrame.max()方法中指定参数axis=0 来获得index轴上的最大值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.max(axis=0))

-数据帧为-
A B C D
0 77 16 17
1 52 45 23 22
2 78 96 135 56

A 78
B 96
C 135
D 56
数据类型:int64

示例:在`column`轴上使用`DataFrame.max()`方法找到数据帧的最大值

让我们创建一个数据帧，通过在DataFrame.max()方法中指定参数axis=1 来获得列轴上的最大值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.max(axis=1))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

0 77
1 52
2 135
数据类型:int64

示例:查找数据帧的最大值，包括空值

让我们创建一个具有空值的数据帧，并通过在DataFrame.max()方法中传递参数skipna=False 来获得除空值之外的index轴上的最大值。在计算结果时，它包括所有的 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.max(axis=0,skipna=False))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

A NAn
B NAn
C NAn
D 56.0
数据类型:float64

示例:查找除空值之外的最大值

让我们创建一个具有空值的数据帧，并通过在DataFrame.max()方法中传递参数skipna=True 来获得除空值之外的index轴上的最大值。在计算结果时，它会排除所有 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.max(axis=0,skipna=True))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

A 78.0
B 77.0
C 23.0
D 56.0
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.max()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.max()方法。

Pandas 数据帧`mean()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-mean-method

在本教程中，我们将学习 PandasDataFrame.mean()的方法。该方法可用于获得请求轴上数值的平均值。它返回序列，如果指定了级别，它将返回数据帧。

下图显示了DataFrame.mean()方法的语法。

句法

DataFrame.mean(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。

skipna: bool(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

**kwargs :要传递给方法的附加关键字参数。

示例:查找数据帧的平均值

让我们创建一个数据帧，通过在DataFrame.mean()方法中指定参数axis=0 获得index轴上的平均值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mean(axis=0))

-数据帧为-
A B C D
0 77 16 17
1 52 45 23 22
2 78 96 135 56

A 43.333333
B 72.666667
C 58.000000
D 31.66667
dtype:float 64

示例:找到数据帧的平均值

让我们创建一个数据帧，通过在DataFrame.mean()方法中指定一个参数axis=1 来获得列轴上的平均值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mean(axis=1))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

0 77
1 52
2 135
数据类型:int64

例子:Pandas 的`DataFrame.mean()`方法

让我们创建一个具有空值的数据帧，并通过在DataFrame.mean()方法中传递参数skipna=False 来获得除空值之外的index轴上的平均值值。在计算结果时，它包括所有的 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mean(axis=0,skipna=False))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

A NaN
B NaN
C NaN
D 31.66667
数据类型:float64

示例:使用排除空值的`DataFrame.mean()`方法，找到数据帧的平均值

通过在DataFrame.mean()方法中传递参数skipna=True ，创建一个具有空值的数据帧，并获得除空值之外的index轴上的平均值值。在计算结果时，它会排除所有 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mean(axis=0,skipna=True))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

A 39.0000000
B 61.000000
C 19.500000
D 31.666667
数据类型:

结论

在本教程中，我们学习了 PandasDataFrame.mean()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了 DataFrame.mean()方法。

Pandas 数据帧`median()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-median-method

在本教程中，我们将学习 PandasDataFrame.median()的方法。该方法可用于获取请求轴上的值median。它返回序列，如果指定了级别，它将返回数据帧。

下图显示了DataFrame.median()方法的语法。

句法

DataFrame.median(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时。

skipna: bool(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果数据帧是一个多索引，则它与特定级别一起计算，并折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

**kwargs :要传递给函数的附加关键字参数。

示例:使用`DataFrame.median()`方法获取`median`值

让我们创建一个数据帧，通过在DataFrame.median()方法中指定参数axis=0 ，得到index轴上的median值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.median(axis=0))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

A 52.0
B 77.0
C 23.0
D 22.0
数据类型:float64

示例:使用`DataFrame.median()`方法获取`median`值

让我们创建一个数据帧，通过在DataFrame.median()方法中指定参数axis=1 来获得列轴上的median值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.median(axis=1))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

0 16.5
1 34.0
2 87.0
数据类型:float64

示例:使用`DataFrame.median()`方法获取`median`值

让我们创建一个带有空值的数据帧，并通过在DataFrame.median()方法中传递参数skipna=False 来获得除空值之外的index轴上的median值。在计算结果时，它包括所有的 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.median(axis=0,skipna=False))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

A NAn
B NAn
C NAn
D 22.0
数据类型:float64

示例:使用`DataFrame.median()`方法获取`median`值

在这里，我们创建了一个空值的数据帧，并通过在DataFrame.median()方法中传递参数skipna=True 来获得除空值之外的index轴上的median值。在计算结果时，它会排除所有 NA/null 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.median(axis=0,skipna=True))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

A 39.0
B 61.0
C 19.5
D 22.0
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.median()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.median()方法。

Pandas 数据帧`memory_usage()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-memory_usage-method

在本教程中，我们将学习 PandasDataFrame.memory_usage()的方法。此方法以字节为单位返回每列的内存使用情况，即每列容纳多少字节。在数据帧上应用此方法后，它将返回 Series，其中索引是数据帧的列名，值是每列的内存使用量(以字节为单位)。

下图显示了DataFrame.memory_usage()方法的语法。

语法

使用这些方法所需的语法如下

DataFrame.memory_usage(index=True, deep=False)

因素

索引:表示 bool(真或假)，默认值为 True。它主要指定在返回 Series 时是否包括数据帧索引的内存使用情况。如果 index=True，则索引的内存使用量是输出中的第一项。

deep: 表示 bool(真或假)，默认值为 False。如果这是真的，则通过询问对象数据类型的系统级内存消耗来深入检查数据，并将它们包含在返回值中。

示例:使用`DataFrame.memory_usage()`方法获取内存使用情况

在下面的例子中，DataFrame.memory_usage()方法返回数据帧各列使用的内存，包括数据帧索引的内存使用情况。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame([['Abhishek',100], ['Anurag',101],['Divya',104]], columns=['Name', 'Roll No'], index=[1,2,3])
print("----------The DataFrame is---------")
print(df)
print("-----------------------------------")
print(df.memory_usage())

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
名称卷号
1 Abhishek 100
2 Anurag 101
3 Divya 104

索引 24
名称 24
卷号 24
数据类型:int64

示例:在`DataFrame.memory_usage()`方法中设置索引=假

在下面的例子中，DataFrame.memory_usage() 方法返回数据帧的列所使用的内存，这不包括数据帧索引所使用的内存。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({'int64':[24,45,78,45],'float64':[1.5,2.5,7.8,4.5]})
print("----------The DataFrame is---------")
print(df)
print("-----------------------------------")
print(df.memory_usage(index=False))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
int64 float 64
0 24 1.5
1 45 2.5
2 78 7.8
3 45 4.5

int 64 32
float 64 32
数据类型:int 64

示例:按数据帧获取总体内存消耗

我们可以使用DataFrame.memory_usage() 方法和 sum()函数获得数据帧列的总内存消耗。下面的例子显示了同样的情况。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({'int64':[24,45,78],'float64':[2.5,7.8,4.5]})
print("----------The DataFrame is---------")
print(df)
print("------------------------------------")
print(df.memory_usage(index=False))
print("-----------------------------------")
print("The total memory used by the DataFrame column's is:",df.memory_usage(index=False).sum())

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
int 64 float 64
0 24 2.5
1 45 7.8
2 78 4.5

int 64 24
float 64 24
数据类型:int64

数据帧列使用的总内存为:48

结论

在本教程中，我们学习了 PythonPandasDataFrame.memory_usage() 法。我们通过解例题了解语法，获取内存使用信息。

Pandas 数据帧`min()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-min-method

在本教程中，我们将学习 PandasDataFrame.min()的方法。该方法可用于获得要求轴上的值的最小值。它返回序列，如果指定了级别，它将返回数据帧。

下面是DataFrame.min()方法的语法。

句法

DataFrame.min(axis=None, skipna=None, level=None, numeric_only=None, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。

skipna: bool(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

**kwargs :要传递给方法的附加关键字参数。

示例 1:使用`DataFrame.min()`方法找到最小值

让我们创建一个数据帧，并通过在DataFrame.min()方法中分配参数axis=0 获得index轴上的最小值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.min(axis=0))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

A 0
B 45
C 16
D 17
数据类型:int64

示例 2:使用`DataFrame.min()`方法找到最小值

让我们创建一个数据帧，通过在DataFrame.min()方法中指定参数axis=1 获得列轴上的最小值。下面的例子显示了同样的情况。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,52,78],"B":[77,45,96],"C":[16,23,135],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.min(axis=1))

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

0
1 22
2 56
数据帧:int64

示例 3:使用`DataFrame.min()`方法找到最小值

在这里，我们创建了一个空值的数据帧，并通过在DataFrame.min()方法中传递参数skipna=False 来获得包含空值的index轴上的最小值值。在计算结果时，它包括所有的 NA/null 值。下面的例子显示了同样的情况。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.min(axis=0,skipna=False))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

A NAn
B NAn
C NAn
D 17.0
数据类型:float64

示例 4:使用`DataFrame.min()`方法找到最小值

让我们创建一个具有空值的数据帧，并通过在DataFrame.min()方法中传递参数skipna=True 来获得除空值之外的index轴上的最小值。在计算结果时，它会排除所有 NA/null 值。下面的例子显示了同样的情况。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[0,None,78],"B":[77,45,None],"C":[16,23,None],"D":[17, 22, 56]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.min(axis=0,skipna=True))

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

A 0.0
B 45.0
C 16.0
D 17.0
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.min()方法。我们学习了语法、参数，并将其应用于数据帧，以理解 DataFrame.min()方法。

Pandas 数据帧`mod()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-mod-method

在本教程中，我们将学习 PandasDataFrame.mod()的方法。该方法返回数据帧的模和其他元素。它返回带有算术运算结果的数据帧。

下面是 PandasDataFrame.mod()方法的语法。

句法

DataFrame.mod(other, axis='columns', level=None, fill_value=None)

因素

其他:表示标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。

轴:“0”代表索引，【1】代表列。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。对于输入Series，轴要匹配系列索引。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

fill_value: 表示浮动或无，默认值为无。它会在计算之前用该值填充现有的缺失值或空值，以及成功的数据帧对齐所需的任何新元素。如果两个相应数据帧位置的数据都丢失，结果也将丢失。

示例 1:使用`DataFrame.mod()`方法求模

下面的例子显示了使用DataFrame.mod()方法获取数据帧的模的常数值。

#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.mod(3))

一旦我们运行该程序，我们将获得以下输出。

a b c
0 2 2 2
1 2 1
2 0 0 0

示例 2:使用`DataFrame.mod()`方法求模

下面的示例显示了使用DataFrame.mod()方法获取数据帧的模和其他数据帧值。

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.mod(df2))

一旦我们运行该程序，我们将获得以下输出。

a b c
0 0 0 0
1 1 0 0
2 0 0 0

示例 3:使用`DataFrame.mod()`方法求模

此示例显示了使用带有fill_value=1的DataFrame.mod()方法获取数据帧与其他数据帧的模。它将在缺少的地方添加默认值，并替换空值。

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.mod(df2,fill_value=1))

一旦我们运行该程序，我们将获得以下输出。

a b c
0 0 0 0.0
1 1 0 0.0
2 0 0 0.0

结论

在本教程中，我们学习了 PandasDataFrame.mod()方法。我们学习了该方法的语法和参数，并将其应用于数据帧，以理解该方法。

Pandas 数据帧`mul()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-mul-method

在本教程中，我们将讨论和学习 PandasDataFrame.mul()的方法。该方法用于获取数据帧和其他元素的乘积。它返回一个带有乘法运算结果的数据帧。

语法如下所示。

句法

DataFrame.mul(other, axis='columns', level=None, fill_value=None)

因素

其他:可以是标量、序列、序列或数据帧。它可以是单个或多个元素数据结构，或者类似列表的对象。

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。对于输入Series，轴要匹配系列索引。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

示例 1:使用`DataFrame.mul()`方法乘以数据帧

这里，我们使用返回数据帧的DataFrame.mul()方法将数据帧乘以scalar值。它由乘法运算的输出组成。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,1,1],'b': [2,2,2],'c': [3,3,3]})
print(df1.mul(2))

a b c
0 2 4 6
1 2 4 6
2 2 4 6

示例 2:使用`DataFrame.mul()`方法乘以数据帧

这里，我们使用DataFrame.mul()方法将数据帧与other DataFrame相乘，该方法返回由乘法运算的输出组成的数据帧。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8],'c': [7,5,6]})
print("------------The result is-----------")
print(df1.mul(df2))

-结果是-
a b c
0 2 4 14
1 5 30 40
2 6 40 42

示例 3:使用`DataFrame.mul()`方法乘以数据帧

这是另一个乘法数据帧的例子，与前一个非常相似。如果两个数据帧没有对齐，则结果输出由 NaN 值组成。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8]})
print("------------The result is-----------")
print(df1.mul(df2))

-结果是-
a b c
0 2 4 NaN
1 5 30 NaN
2 6 40 NaN

示例 4:使用`DataFrame.mul()`方法乘以数据帧

这里，在这个例子中，我们将通过在DataFrame.mul()方法中传递fill_value=1 参数来填充任何缺失的值。它将用该默认值替换所有空值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [None,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [None,1,1],'b': [None,5,8]})
print("------------The result is-----------")
print(df1.mul(df2,fill_value=1))

-结果为-
a b c
0 NaN 4.0 2.0
1 5.0 30.0 8.0
2 6.0 40.0 7.0

结论

在本教程中，我们学习了 PandasDataFrame.mul()方法。我们学习了该方法的语法和参数，并将其应用于数据帧以理解该方法。

Pandas 数据帧`multiply()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-multiply-method

在本教程中，我们将讨论和学习 PandasDataFrame.multiply()的方法。该方法用于获取数据帧和其他元素的乘积。它返回一个带有乘法运算结果的数据帧。

语法如下所示。

句法

DataFrame.multiply(other, axis='columns', level=None, fill_value=None)

因素

其他:可以是标量、序列、序列或数据帧。它可以是单个或多个元素数据结构，或者类似列表的对象。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

示例 1:在 Pandas 中繁殖数据帧

这里，我们使用DataFrame.multiply()方法将数据帧与scalar值相乘，该方法返回由乘法运算的输出组成的数据帧。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,1,1],'b': [2,2,2],'c': [3,3,3]})
print(df1.multiply(2))

a b c
0 2 4 6
1 2 4 6
2 2 4 6

示例 2:在 Pandas 中繁殖数据帧

这里，我们使用返回数据帧的DataFrame.multiply()方法将数据帧乘以other DataFrame。它由乘法运算的输出组成。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8],'c': [7,5,6]})
print("------------The result is-----------")
print(df1.multiply(df2))

-结果是-
a b c
0 2 4 14
1 5 30 40
2 6 40 42

示例 3:在 Pandas 中繁殖数据帧

这个例子和上一个相似。如果两个数据帧没有对齐，则结果输出由 NaN 值组成。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8]})
print("------------The result is-----------")
print(df1.multiply(df2))

-结果是-
a b c
0 2 4 NaN
1 5 30 NaN
2 6 40 NaN

示例 4:在 Pandas 中繁殖数据帧

这里，在这个例子中，我们将通过在DataFrame.multiply()方法中传递fill_value=1 参数来填充任何缺失的值。它将用提供的值替换所有空值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [None,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [None,1,1],'b': [None,5,8]})
print("------------The result is-----------")
print(df1.multiply(df2,fill_value=1))

-结果是-
a b c
0 NaN 4.0 2.0
1 5.0 30.0 8.0
2 6.0 40.0 7.0

结论

在本教程中，我们学习了 PandasDataFrame.multiply()方法。我们学习了该方法的语法和参数，并将其应用于数据帧。

Pandas 数据帧`ne()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-ne-method

在本教程中，我们将学习 PandasDataFrame.ne()的方法。该方法用于获取数据帧的不等于以及其他元素。它返回 bool 的数据帧，这是比较的结果。

下面是DataFrame.ne()方法的语法。

句法

DataFrame.ne(other, axis='columns', level=None)

因素

其他:表示标量、序列、序列或数据帧。它可以是任何单个或多个元素的数据结构，或者类似列表的对象。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

例 1:比较 Pandas 的数据帧

这里，我们使用返回 bool 类型数据帧的DataFrame.ne()方法将数据帧与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 ne method-----")
print(df.ne(200))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 ne 方法后-
A B C
0 假真
1 真真

例 2:比较 Pandas 的数据帧

这里，我们使用DataFrame.ne()方法将数据帧与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 ne method-----")
print(df.ne(series,axis=0))

-数据帧为-
A B C
0 200 60 150
1 500 250 1
-应用 ne 方法后-
A B C
0 真真假假
1 真真假假
2 真真假假

示例:将数据帧与其他数据帧进行比较

这里，我们使用DataFrame.ne()方法将一个数据帧与另一个数据帧进行比较。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({"A":[200,500],"B":[60,250],"C":[150,1]})
df_2=pd.DataFrame({"A":[200,550],"B":[65,251],"C":[100,10]})
print("----After applying ne method-----")
print(df_1.ne(df_2))

-应用 ne 方法后-
A B C
0 假真真
1 真真真

结论

在本教程中，我们学习了 PandasDataFrame.ne()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了 DataFrame.ne()方法。

Pandas 数据帧`notna()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-notna-method

在本教程中，我们将学习 PandasDataFrame.notna()的方法。此方法用于检测现有值。它返回一个由数据帧中每个元素的布尔值组成的数据帧，该数据帧指示某个元素是否不是安娜值。

检测现有值时，DataFrame.notna()方法不将空字符串''或numpy.inf等字符视为 NA 值。

下面是DataFrame.notna()方法的语法。

句法

DataFrame.notna()

示例 1:使用`DataFrame.notna()`方法检测现有值。

这里，我们使用DataFrame.notna() 方法检测数据帧中的现有值，该方法返回由数据帧中每个元素的布尔值组成的数据帧，该值指示某个元素是否不是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.notna())

-数据帧为-
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 真假真

示例:使用`DataFrame.notna()`方法检测缺失值

这个例子类似于前面的例子，并且DataFrame.notna()方法将空字符串视为正常值。见下面的例子。在空字符串和空值的输出中，DataFrame.notna()方法返回一个True。

#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.notna())

-数据帧为-
a b
0 0
1 无
2 3

a b
0 真
1 真假
2 真

结论

在本教程中，我们学习了 PandasDataFrame.notna()方法。我们学习了语法，并使用DataFrame.notna()方法检查数据帧是否包含现有值。

Pandas 数据帧`nlargest()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-nlargest-method

在本教程中，我们将讨论和学习 PandasDataFrame.nlargest()方法。该方法用于获取数据帧的第一n 行，该行按列降序排列。该方法按降序返回列中值最大的第一个n 行。未指定的列也会返回，但不用于排序。

下面是DataFrame.nlargest()方法的语法。

句法

DataFrame.nlargest(n, columns, keep='first')

因素

n: 它指定了 int，即要返回的行数。

列:它代表标签或标签列表，是要排序的列的名称。

keep: 包含‘first’‘last’‘all’，默认为‘first’

如果存在重复值:

第一:优先处理第一个事件
最后:优先考虑最后一次出现
all:不要删除任何重复项，即使这意味着选择了 n 个以上的项目。

示例 1:按降序获取数据帧

在下面的例子中，DataFrame.nlargest()方法按'Height'列降序返回第一个2 行的数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print(df.nlargest(2,'Height'))

一旦我们运行该程序，我们将获得以下输出。

姓名年龄身高体重
2 yuvraj 30 175 75
5 雷努卡 20 165 65

示例 2:按降序获取数据帧

下例与上例类似，DataFrame.nlargest()方法按'Age'列降序返回第一个3 行的数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print("--------The DataFrame is-------")
print(df.nlargest(3,'Age'))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
姓名年龄身高体重
2 yuvraj 30 175 75
1 yashas 25 160 60
4 Sindu 25 155 55

示例 3:按降序获取数据帧

当keep='last' 出现时，DataFrame.nlargest()方法优先处理指定列的最后一次出现，并返回数据帧

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print(df.nlargest(2,'Height',keep='last'))

一旦我们运行该程序，我们将获得以下输出。

姓名年龄身高体重
2 yuvraj 30 175 75
5 雷努卡 20 165 65

结论

在本教程中，我们学习了 PandasDataFrame.nlargest()方法。我们学习了语法、参数，并将其应用于数据帧，以理解 DataFrame.nlargest()方法。

Pandas 数据帧`notnull()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-notnull-method

在本教程中，我们将学习 PandasDataFrame.notnull()的方法。此方法用于检测现有值。它返回一个由数据帧中每个元素的布尔值组成的数据帧，该数据帧指示一个元素是否不是空值。

检测现有值时，DataFrame.notnull()方法不将空字符串''或numpy.inf等字符视为空值。

下面是DataFrame.notnull()方法的语法。

句法

DataFrame.notnull()

示例 1:使用`DataFrame.notnull()`方法检测现有值

这里，我们使用DataFrame.notnull() 方法检测数据帧中的现有值，该方法返回由数据帧中每个元素的布尔值组成的数据帧，该值指示某个元素是否不是null 值。如果该值为真，则表明该元素不是空值。见下面的例子。

#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.notnull())

-数据帧为-
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 真假真

示例:使用`DataFrame.notnull()`方法检测缺失值

这个例子类似于前面的例子，并且DataFrame.notnull()方法将空字符串视为正常值。见下面的例子。在空字符串和空值的输出中，DataFrame.notnull()方法返回一个True。

#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.notnull())

-数据帧为-
a b
0 0
1 无
2 3

a b
0 真
1 真假
2 真

结论:

在本教程中，我们学习了 PandasDataFrame.notnull()方法。我们学习了语法，并使用DataFrame.notnull()方法检查数据帧是否包含现有值。

Pandas 数据帧`nsmallest()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-nsmallest-method

在本教程中，我们将学习 PandasDataFrame.nsmallest()方法。该方法用于获取数据帧的第一n 行，该行按列升序排列。该方法以升序返回列中值最小的第一个n 行。未指定的列也会返回，但不用于排序。

下面显示了DataFrame.nsmallest() 方法的语法

句法

DataFrame.nsmallest(n, columns, keep='first')

因素

n: 它指定了 int，即要返回的行数。

列:它代表标签或标签列表，是要排序的列的名称。

keep: 包括【第一】【最后】【全部】默认为【第一】

如果存在重复值:

第一:优先处理第一个事件
最后:优先考虑最后一次出现
all:不要删除任何重复项，即使这意味着选择了 n 个以上的项目。

示例 1:在 Pandas 中以升序获取数据帧

在下面的例子中，DataFrame.nsmallest()方法按照'Height'列的升序返回第一个2 行的数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print(df.nsmallest(2,'Height'))

姓名年龄身高体重
3 普贾 18 145 45
0 切坦 20 155 75

示例 2:在 Pandas 中以升序获取数据帧

下例与上例类似，DataFrame.nsmallest()方法按'Age'列升序返回第一个3 行的数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print("--------The DataFrame is-------")
print(df.nsmallest(3,'Age'))

-数据帧是-
姓名年龄身高体重
3 普贾 18 145 45
0 切坦 20 155 75
5 雷努卡 20 165 65

示例 3:在 Pandas 中以升序获取数据帧

当我们使用keep='last'时，DataFrame.nsmallest()方法对指定列的最后一次出现进行优先级排序，并返回数据帧。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':  [20,25,30,18,25,20],'Height': [155,160,175,145,155,165],'Weight': [75,60,75,45,55,65]})
print(df.nsmallest(2,'Height',keep='last'))

姓名年龄身高体重
3 普贾 18 145 45
4 辛杜 25 155 55

结论

在本教程中，我们学习了 PandasDataFrame.nsmallest()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了 DataFrame.nsmallest()方法。

Pandas 数据帧`nunique()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-nunique-method

在本教程中，我们将学习 PandasDataFrame.nunique() 的方法。此方法计算请求轴上不同或唯一观察的数量。它返回带有许多不同观察值的Series。

下面是DataFrame.nunique() 方法的语法。

句法

DataFrame.nunique(axis=0, dropna=True)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时

dropna: 表示 bool(真或假)，默认值为 True。计数中不包括 NaN。

示例 1:计算数据帧的唯一值

这里，在这个例子中，我们将使用DataFrame.nunique() 方法计算数据帧中唯一值的数量。它返回计数，而不是唯一值。

#importing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [1, 1, 1],'C': [2, 5, 5]})
print("------The DataFrame is-------")
print(df)
print("--------------------------------")
print(df.nunique(axis=0))

-数据帧为-
A B C
0 1 1 2
1 2 1 5
2 3 1 5

A 3
B 1
C 2
数据类型:int64

示例 2:计算数据帧的唯一值

此示例与上一个示例类似，DataFrame.nunique() 方法计算列轴上的唯一值。

#imporing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [1, 2, 3], 'B': [1, 1, 1],'c': [2, 5, 5]})
print("------The DataFrame is-------")
print(df)
print("--------------------------------")
print(df.nunique(axis=1))

-数据帧为-
A B c
0 1 1 2
1 2 1 5
2 3 1 5

0 2
1 3
2 3
数据类型:int64

示例 3:计算数据帧的唯一值

DataFrame.nunique() 方法将空值计为‘0’。这意味着任何包含空值的列都将被计为 0。见下面的例子。

#imporing pandas as pd
import pandas as pd
df = pd.DataFrame({'A': [1, None, 3], 'B': [1, None, 1],'C': [2, None, 5]})
print("------The DataFrame is-------")
print(df)
print("--------------------------------")
print(df.nunique(axis=1))

-数据帧为-
A B C
0 1.0 1.0 2.0
1 NaN NaN
2 3.0 1.0 5.0

0 2
1 0
2 3
数据类型:int64

结论

在本教程中，我们学习了 PandasDataFrame.nunique()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.nunique()方法。

Pandas 数据帧`pad()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pad-method

在本教程中，我们将学习 PandasDataFrame.pad()的方法。该方法类似于DataFrame.fillna()方法，使用 ffill()方法填充 NA/NaN 值。

它返回填充了缺失值的数据帧对象，如果是inplace=True，则返回None。

下图显示了DataFrame.pad()方法的语法。

句法

DataFrame.pad(axis=None, inplace=False, limit=None, downcast=None)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时

inplace: 表示 bool(真或假)，默认值为 False。如果为真，则就地填充并返回无。

限制: int，默认无。如果指定了方法，这是要向前填充的连续 NaN 值的最大数量。

示例 1:填充 Pandas 数据帧中缺失的值

这里，通过使用DataFrame.pad()方法，我们可以填充数据帧中的所有空值或缺失值。它使用 Pandas 的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.pad(axis=0))

-数据帧为-
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

示例 2:填充 Pandas 数据帧中缺失的值

这个例子和上一个类似，这里DataFrame.pad()方法沿着列轴填充空值。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, np.nan],[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.pad(axis=1))

-数据帧为-
A B C
0 2.0 NaN NAn
1 NAn NAn 5.0
2 NAn 3.0 NAn
-填充 NAn 值-
A B C
0 2.0 2.0 2.0
1 NAn 5.0
2 NAn 3.0 3.0

示例 2:用 Pandas 中的限制填充 Pandas 数据帧中缺失的值

我们可以使用DataFrame.pad()方法中的limit方法替换第一个 NaN 元素。它将限制替换数据帧中的元素。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df = pd.DataFrame([[2, np.nan, np.nan],[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.pad(axis=1,limit=1))

-数据帧为-
A B C
0 2.0 NaN NAn
1 NAn NAn 5.0
2 NAn 3.0 NAn
-填充 NAn 值-
A B C
0 2.0 2.0 NAn
1 NAn 5.0
2 NAn 3.0 3.0

结论

在本教程中，我们学习了 PandasDataFrame.pad()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.pad()方法。

Pandas 数据帧`pop()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pop-method

在本教程中，我们将学习 PandasDataFrame.pop()的方法。此方法删除或删除数据帧中的指定项，并返回该项。如果找不到指定的项目，它将引发键错误。

下面是DataFrame.pop()方法的语法。

句法

DataFrame.pop(item)

因素

项:表示作为待弹出列的标签的标签。

示例 1:从 Pandas 的数据帧中删除

这里，DataFrame.pop()方法在数据帧中删除指定的项目，并返回指定的项目。我们可以使用这个方法从数据帧中删除任何元素。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Pooja','Sindu','Renuka'],'Age':[18,25,20],'Height': [145,155,165],'Weight': [45,55,65]})
print("--------The DataFrame is-------")
print(df)
print("--------------------------------")
print(df.pop("Age"))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
姓名年龄身高体重
0 普贾 18 145 45
1 辛杜 25 155 55
2 雷努卡 20 165 65

0 18
1 25
2 20
姓名:年龄，数据类型:int64

示例 2:从 Pandas 的数据帧中删除

这里，DataFrame.pop()方法在数据帧中删除指定的项目，并返回指定的项目。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Pooja','Sindu','Renuka'],'Age':[18,25,20],'Height': [145,155,165],'Weight': [45,55,65]})
print("--------The DataFrame is-------")
print(df)
print("--------------------------------")
print(df.pop("Name"))

一旦我们运行该程序，我们将获得以下输出。

-数据帧为-
姓名年龄身高体重
0 普贾 18 145 45
1 辛杜 25 155 55
2 雷努卡 20 165 65

0 普贾
1 辛杜
2 雷努卡
姓名:姓名，数据类型:对象

示例 3:使用 pop()方法时数据帧中出现键错误

如果在数据帧中找不到指定的项目，DataFrame.pop()方法将引发KeyError 。这里，我们删除了数据帧中不存在的元素“ABC”。因此，删除该项目会引发错误。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'Name':['Pooja','Sindu','Renuka'],'Age':[18,25,20],'Height': [145,155,165],'Weight': [45,55,65]})
print(df.pop("abc"))

一旦我们运行该程序，我们将获得以下输出。

关键词错误:【abc】

结论

在本教程中，我们学习了 PandasDataFrame.pop()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法，我们解决了示例并理解了DataFrame.pop()方法。

Pandas 数据帧`pow()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pow-method

我们可以使用其中一个数据帧方法找到一个数的指数或幂(T0)的幂(b 的幂)。

在本教程中，我们将讨论和学习 PandasDataFrame.pow()的方法。此方法可用于获取指定数据帧和其他数据帧的指数幂。这个方法返回一个由一个数的幂组成的数据帧。

下面是DataFrame.pow()方法的语法。

句法

DataFrame.pow(other, axis='columns', level=None, fill_value=None)

因素

其他:可以是标量、序列、序列或数据帧。它可以是单个或多个元素数据结构，或者类似列表的对象。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

示例 1:获取数据帧值的力量

在下面的例子中，我们使用返回数据帧的DataFrame.pow()方法得到了带有scalar的数据帧的指数幂。它由数据帧的指数幂值组成。请看下面的例子。

例如，a^b. a 是数据帧值，b 是标量。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.pow(2))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A B C
0 1 16 49
1 4 25 64
2 9 36 81

示例 2:获取数据帧值的力量

在下面的示例中，我们使用DataFrame.pow()方法获取数据帧值与其他数据帧的指数幂，该方法返回由数据帧的指数幂值组成的数据帧。请看下面的例子。

例如，a^b. a 是数据帧值，b 是其他数据帧值。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,1,1],'B':[2,2,2],'C':[3,3,3]})
df_2=pd.DataFrame({'A':[1,2,3],'B':[1,2,3],'C':[1,2,3]})
print("---------------------------------")
print(df_1.pow(df_2,axis=0))

甲乙丙
0 1 2 3
1 1 4 9
2 1 8 27

示例 3:获取数据帧值的力量

在这里，我们使用DataFrame.pow()方法通过一个系列获得数据帧的幂，该方法返回一个由数据帧的指数幂值组成的数据帧。请看下面的例子。

例如，a^b. a 是数据帧值，b 是系列。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
series=pd.Series([2,2,2])
print("---------------------------------")
print(df_1.pow(series,axis=0))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A B C
0 1 16 49
1 4 25 64
2 9 36 81

示例 4:获取数据帧值的力量

这里，我们使用DataFrame.pow()方法通过sequence获得数据帧的幂，该方法返回由数据帧的指数幂值组成的数据帧。请看下面的例子。

例如，a^b. a 是数据帧值，b 是序列值。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[2,3,4],'B':[5,7,8],'C':[10,11,0]})
print("------The DataFrame is---------")
print(df_1)
tuple_1=(2,2,2)
print("---------------------------------")
print(df_1.pow(tuple_1))

-数据帧为-
A B C
0 2 5 10
1 3 7 11
2 4 8 0

A B C
0 4 25 100
1 9 49 121
2 16 64 0

结论

在本教程中，我们学习了 PandasDataFrame.pow()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。

Pandas 数据帧`prod()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-prod-method

在 Pandas 中，要找到数据帧值的乘积，我们可以使用DataFrame.prod()方法。当我们将此方法应用于数据帧时，它会返回由所需轴上的值的乘积组成的序列或数据帧。

下面是DataFrame.prod()方法的语法。

句法

DataFrame.prod(axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。

skipna: bool(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

min_count: 表示 int，默认值为 0。它指示执行操作所需的有效值数量。

**kwargs :要传递给方法的附加关键字参数。

示例:在 Pandas 中找到数据帧的产品

这里，我们使用DataFrame.prod()方法沿着索引轴寻找数据帧值的乘积。它将返回数据帧所有值的乘积。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.prod(axis=0))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A 6
B 120
C 504
数据类型:int64

示例:在 Pandas 中找到数据帧的产品

这里，我们使用DataFrame.prod()方法沿着列轴找到数据帧值的乘积。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.prod(axis=1))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

0 28
1 80
2 162
数据类型:int64

示例 3:查找空数据帧的乘积

默认情况下，DataFrame.prod()方法在执行产品操作时排除空值或缺失值。如果我们在DataFrame.prod()方法中设置 skipna=False ，则在执行产品操作时会包含空值。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,np.nan],'B':[np.nan,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.prod(axis=1,skipna=False))

-数据帧为-
A B C
0 1.0 NAn 7
1 2.0 5.0 8
2 NAn 6.0 9

0 NAn
1 80.0
2 NAn
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.prod()方法。我们学习了语法、参数，并在数据帧上应用了这种方法。

Pandas 数据帧`product()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-product-method

在 Pandas 中，要找到数据帧值的乘积，我们可以使用DataFrame.product()方法。

在本教程中，我们将通过示例讨论和学习这种方法。当我们将此方法应用于数据帧时，它会返回一个由所需轴上的值的乘积组成的序列或数据帧。

下面是DataFrame.product()方法的语法。

句法

DataFrame.product(axis=None, skipna=None, level=None, numeric_only=None, min_count=0, **kwargs)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时。

skipna: bool(真或假)。默认值为“无”。如果该参数为True，则在计算结果时，排除所有 NA/null 值。

级别:代表 int 或级别名称，默认值为 None。如果轴是一个多索引(分层)，则与特定级别一起计数，折叠成一个系列。

仅限数值:布尔(真或假)，默认值为无。如果此参数为True，则仅包括浮点、整数、布尔列。

min_count: 表示 int，默认值为 0。它指示执行操作所需的有效值数量。

**kwargs :要传递给方法的附加关键字参数。

示例:使用 D `ataFrame.product()`方法查找产品

这里，我们使用DataFrame.product()方法沿着索引轴找到数据帧值的乘积。要获得索引轴的乘积，只需在方法中设置 axis=0。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.product(axis=0))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A 6
B 120
C 504
数据类型:int64

示例 2:使用 D `ataFrame.product()`方法查找产品

这里，我们使用DataFrame.product()方法沿着列轴找到数据帧值的乘积。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.product(axis=1))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

0 28
1 80
2 162
数据类型:int64

示例:使用 D `ataFrame.product()`方法查找产品

默认情况下DataFrame.product()方法在执行产品操作时排除空值或缺失值。如果我们在DataFrame.product()方法中设置 skipna=False ，则在执行产品操作时会包含空值。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating the DataFrame
df_1=pd.DataFrame({'A':[1,2,np.nan],'B':[np.nan,5,6],'C':[7,8,9]})
print("------The DataFrame is---------")
print(df_1)
print("---------------------------------")
print(df_1.product(axis=1,skipna=False))

-数据帧为-
A B C
0 1.0 NAn 7
1 2.0 5.0 8
2 NAn 6.0 9

0 NAn
1 80.0
2 NAn
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.product()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.product()方法。

Pandas 数据帧`quantile()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-quantile-method

在统计学中，分位数是指将数据集分成两个相等部分的量。四分位数、百分位数和十分位数也是将数据分别分成四份、一百份和十份的分位数。

在本教程中，我们将讨论和学习 Python pandas DataFrame.quantile() 方法，该方法返回由所请求轴上给定分位数的值组成的序列或数据帧。在求分位数时，这种方法将数据按升序排列，我们可以用公式找到 q*(n+1) 的位置，其中q是分位数，n 是元素总数。

下图显示了DataFrame.quantile()方法的语法。

句法

DataFrame.quantile(q=0.5, axis=0, numeric_only=True, interpolation='linear')

因素

q: 表示浮点数或类似数组，默认值为 0.5 (50%分位数)。该值介于 0 < = q < = 1(要计算的分位数)之间。

轴:表示索引或列轴，索引为“0”，列为“1”，默认值为“0”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时。

numeric_only: 表示 bool(真或假)，默认值为 True。如果参数为假，还将计算日期时间和时间增量数据的分位数。

插值:包括‘线性’、‘较低’、‘较高’、‘中点’、‘最近’。此可选参数指定要使用的插值方法。

示例:使用`DataFrame.quantile()`方法找到分位数

让我们创建一个数据帧，并使用DataFrame.quantile()方法找到 0.5 的分位数。计算位置为0.5*(4+1)=2.5，表示 50%的数据低于 2.5，50%的数据高于 2.5。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Age':[12,14,11,12],'Height':[135,140,138,147],'Weight':[35,38,30,45]})
print("---------The DataFrame is---------")
print(df)
print("-----------------")
print(df.quantile(0.5))

-数据帧为-
年龄身高体重
0 12 135 35
1 14 140 38
2 11 138 30
3 12 147 45

年龄 12.0
身高 139.0
体重 36.5
姓名:0.5，数据类型:float64

示例 2:使用`DataFrame.quantile()`方法找到分位数

让我们以升序创建一个数据帧，并使用DataFrame.quantile()方法找到 0.35 的分位数。计算位置为0.35*(5+1)=2.1，表示 35%的数据低于 2.1，35%的数据高于 2.5。分位数方法将数据集精确地分成两个相等的部分。见下面的例子。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Age':[11,12,13,14,15],'Height':[135,140,138,147,145],'Weight':[35,38,30,45,45]})
print("---------The DataFrame is---------")
print(df)
print("-----------------")
print(df.quantile(0.35))

-数据帧为-
年龄身高体重
0 11 135 35
1 12 140 38
2 13 138 30
3 14 147 45
4 15 145 45

年龄 12.4
身高 138.8
体重 36.2
姓名:0.35，数据类型:float64

示例 3:使用`DataFrame.quantile()`方法找到分位数

让我们创建一个数据帧，并通过使用DataFrame.quantile()方法在列表或元组中给出值来找到 0.25 和 0.75 的分位数。DataFrame.quantile()方法返回分位数为 0.25 和 0.75 的值。见下面的例子。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Age':[11,12,13,14,15],'Height':[135,140,138,147,145],'Weight':[35,38,30,45,45]})
print("---------The DataFrame is---------")
print(df)
print("-----------------")
print(df.quantile([0.25,0.75]))

-数据帧为-
年龄身高体重
0 11 135 35
1 12 140 38
2 13 138 30
3 14 147 45
4 15 145 45

年龄身高体重
0.25 12.0 138.0 35.0
0.75 14.0 145.0 45.0

示例:使用`DataFrame.quantile()`方法找到分位数

让我们创建一个数据帧，使用列轴上的DataFrame.quantile()方法找到 0.5 的分位数。参见下面的示例，在索引“0”处，三个值的分位数是 35.0，在索引“1”处，三个值的分位数是 38.0，以此类推。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Age':[11,12,13,14,15],'Height':[135,140,138,147,145],'Weight':[35,38,30,45,45]})
print(df.quantile(0.5,axis=1))

0 35.0
1 38.0
2 30.0
3 45.0
4 45.0
名称:0.5，数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.quantile()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.quantile()方法。

Pandas 数据帧`query()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-query-method

在本教程中，我们将讨论和学习类似于滤镜方法的 Python PandasDataFrame.query()方法。该方法通过boolean表达式查询或过滤数据帧。在本教程中，我们将通过单列、比较两列以及使用“AND”运算符来过滤数据帧。

下面是DataFrame.query() 方法的语法。

句法

DataFrame.query(expr, inplace=False, **kwargs)

因素

expr: 表示作为要评估的查询字符串的字符串。

在原地:代表布尔。它指示查询应该就地修改数据还是返回修改后的副本。

**kwargs :要传递给函数的附加关键字参数。

例:Pandas 的`DataFrame.query()`方法

让我们创建一个数据帧，并使用小于和大于表达式按单个列过滤数据帧。参见下面的例子，DataFrame.query() 方法返回包含年龄大于 22、体重大于等于 60 的信息的数据帧。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':[19,26,22,24,21,23],'Height':[165,150,168,157,155,170],'Weight':[60,65,70,50,52,55]})
print("------printing the info whose age is above 22-------")
print(df.query('Age<23'))
print("------printing the info whose weight is above 60-----")
print(df.query('Weight>=60'))

-打印年龄在 22 岁以上的信息-
姓名年龄身高体重
0 车坛 19 165 60
2 yuvraj 22 168 70
4 Sindu 21 155 52
-打印体重在 60 岁以上的信息-
姓名年龄身高体重
0 车坛 19 165 60
1 yashas 26 150 65
2 yuvraj 22 168 70

示例:使用`DataFrame.query()`方法过滤数据帧

让我们创建一个数据帧，并通过使用DataFrame.query() 方法比较两列来过滤数据帧。参见下面的例子，如果 sci_Marks 列中的值大于数学 _Marks 列中的值，则DataFrame.query() 方法返回数据帧。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'sci_Marks':[85,70,75,90,95,70],'Maths_Marks':[82,79,80,89,92,70]})
print("------comparing sci_Marks and Maths_Marks columns -------")
print(df.query('sci_Marks > Maths_Marks'))

-比较 sci_Marks 和数学 _Marks 栏-
名称 sci_Marks 数学 _Marks
0 车坛 85 82
3 Pooja 90 89
4 Sindu 95 92

示例 3:使用`DataFrame.query()`方法过滤数据帧

让我们创建一个数据帧，并通过AND运算符过滤数据帧列。如果两个操作数都为真，并且返回的数据帧由条件匹配的值组成，则DataFrame.query() 方法返回数据帧。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':[19,26,22,24,21,23],'Height':[165,150,168,157,155,170],'Weight':[60,65,70,50,52,55]})
print("------printing the info whose Height is above 155 and weight is above 60-------")
print(df.query('Height > 155' and 'Weight > 60'))

-打印身高 155 以上体重 60 以上的信息-
姓名年龄身高体重
1 雅夏 26 150 65
2 yuvraj 22 168 70

示例 4:使用`DataFrame.query()`方法过滤数据帧

如果参数inplace=True，它只是根据给定的条件修改数据帧。它不返回新的数据帧，而是返回None。见下面的例子。我们可以通过检查数据帧来检查修改后的数据帧。

#importing pandas as pd
import pandas as pd
df=pd.DataFrame({'Name':['Chetan','yashas','yuvraj','Pooja','Sindu','Renuka'],'Age':[19,26,22,24,21,23],'Height':[165,150,168,157,155,170],'Weight':[60,65,70,50,52,55]})
print(df.query('Age==24',inplace=True))
print("-----The modified DataFrame is-----")
print(df)

无
-修改后的数据帧为-
姓名年龄身高体重
3 普加 24 157 50

结论

在本教程中，我们学习了 PandasDataFrame.query()方法。我们学习了语法、参数，并将该方法应用于数据帧，以理解 DataFrame.query()方法。

Pandas 数据帧`radd()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-radd-method

在本教程中，我们将讨论和学习 PandasDataFrame.radd()的方法。此方法用于获取数据帧和其他元素的添加。它返回一个带有反向加法运算结果的数据帧。

DataFrame.radd()方法的语法如下所示。

句法

DataFrame.radd(other, axis='columns', level=None, fill_value=None)

因素

其他:可以是标量、序列、序列或数据帧。它可以是单个或多个元素数据结构，或者类似列表的对象。

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0功能应用于index轴时，以及当axis=1功能应用于column轴时。对于输入Series，轴要匹配系列索引。

级别:代表 int 或标签。它跨级别广播，匹配传递的多索引级别上的索引值。

示例 1:使用`DataFrame.radd()`方法添加数据帧

这里，我们使用DataFrame.mul()方法添加带有scalar的数据帧，该方法返回由反向加法操作的输出组成的数据帧。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df = pd.DataFrame({'a': [2,5,7],'b': [1,2,3],'c': [4,5,7]})
print("---------The DataFrame is------")
print(df)
print("----------------------------")
print(df.radd(2))

-数据帧为-
a b c
0 2 1 4
1 5 2 5
2 7 3 7

a b c
0 4 3 6
1 7 4 7
2 9 5 9

示例 2:使用`DataFrame.radd()`方法添加数据帧

这里，我们使用DataFrame.radd()方法用other DataFrame添加数据帧，该方法返回由反向添加操作的输出组成的数据帧。请看下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8],'c': [7,5,6]})
print("------------The result is-----------")
print(df1.radd(df2))

-结果是-
a b c
0 3 5 9
1 6 11 13
2 7 13 13

示例 3:使用`DataFrame.radd()`方法添加数据帧

这个例子和上一个相似。如果两个数据帧没有对齐，则结果输出由 NaN 值组成。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [1,5,6],'b': [4,6,5],'c': [2,8,7]})
df2 = pd.DataFrame({'a': [2,1,1],'b': [1,5,8]})
print("------------The result is-----------")
print(df1.radd(df2))

-结果是-
a b c
0 3 5 NaN
1 6 11 NaN
2 7 13 NaN

示例 4:使用`DataFrame.radd()`方法添加数据帧

这里，在这个例子中，我们将通过在DataFrame.radd()方法中传递fill_value=2 参数来填充任何缺失的值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df1 = pd.DataFrame({'a': [None,2,6],'b': [2,1,4],'c': [2,1,0]})
df2 = pd.DataFrame({'a': [1,1,2],'b': [None,5,0]})
print("------------The result is-----------")
print(df1.radd(df2,fill_value=2))

-结果是-
a b c
0 3.0 4.0 4.0
1 3.0 6.0 3.0
2 8.0 4.0 2.0

结论

在本教程中，我们学习了 PandasDataFrame.radd()方法。我们通过在 DataFrame 上应用这个函数来学习语法、参数和求解示例，并理解了该方法。

Pandas 数据帧`pct_change()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pct_change-method

百分比变化在数据分析中很有用，如制作报告或计算月与月或年与年之间的销售差异等。

Python pandas 有一个名为DataFrame.pct_change()的方法，可以计算当前元素和先前元素之间数据帧的百分比变化。在本教程中，我们将通过解决例子来讨论和学习DataFrame.pct_change()方法。

下面是DataFrame.pct_change()方法的语法。

句法

DataFrame.pct_change(periods=1, fill_method='pad', limit=None, freq=None, **kwargs)

因素

句点:表示 int，默认值为 1。它指示需要移动多少个周期来计算百分比变化。

fill_method: 表示字符串，默认为‘pad’方法。它指示在计算百分比变化之前如何处理空值或缺失值。

极限:表示 int，默认值为 None。它指示在停止之前要填充多少个连续的空值。

freq: 表示日期偏移量、时间增量或字符串，可选。

**kwargs :表示附加的关键字参数传入 DataFrame.shift 或 Series.shift。

例 1:计算 Pandas 的百分比变化

让我们使用时间序列作为索引创建一个数据帧，并使用DataFrame.pct_change()方法计算百分比变化。

在输出中，我们可以看到第一行包含空值，因为没有前一行来计算百分比变化。正值表示百分比增加，负值表示百分比减少。见下面的例子

import pandas as pd
Values = pd.date_range('2021-01-01', periods=3, freq='5W')
df = pd.DataFrame({'coffee': [755.2,751.23,852.21],'Tea': [700.21,695.21,726.21],'Pepper':[900.14,8254.1,455.27]}, index=Values)
print("----------The dataset is----------")
print(df)
print("-------percentage change in the dataset-------")
print(df.pct_change())

-数据集为-
咖啡茶椒
2021-01-03 755.20 700.21 900.14
2021-02-07 751.23 695.21 8254.10
2021-03-14 852.21 726.21 455.27
-数据集内百分比变化-
咖啡茶椒【T7

例 1:计算 Pandas 的百分比变化

让我们使用时间序列作为索引创建一个数据帧，并使用DataFrame.pct_change()方法沿列轴计算百分比变化。

import pandas as pd
Values = pd.date_range('2021-01-01', periods=3, freq='5W')
df = pd.DataFrame({'coffee': [755.2,751.23,852.21],'Tea': [700.21,695.21,726.21],'Pepper':[900.14,8254.1,455.27]}, index=Values)
print("----------The dataset is----------")
print(df)
print("-------percentage change in the dataset-------")
print(df.pct_change(axis=1))

-数据集为-
1 月 2 月 3 月
2021-01-03 755.20 700.21 900.14
2021-02-07 751.23 695.21 8254.10
2021-03-14 852.21 726.21 455.27
-数据集百分比变化-
1 月 2 月 3 日【T7

例 3:计算 Pandas 的百分比变化

这里，在这个例子中，我们通过DataFrame.pct_change()方法中的参数period=2来计算百分比。

import pandas as pd
Values = pd.date_range('2021-01-01', periods=3, freq='5W')
df = pd.DataFrame({'coffee': [755.2,751.23,852.21],'Tea': [700.21,695.21,726.21],'Pepper':[900.14,8254.1,455.27]}, index=Values)
print("----------The dataset is----------")
print(df)
print("-------percentage change in the dataset-------")
print(df.pct_change(periods=2))

-数据集为-
咖啡茶椒
2021-01-03 755.20 700.21 900.14
2021-02-07 751.23 695.21 8254.10
2021-03-14 852.21 726.21 455.27
-数据集内百分比变化-
咖啡茶椒【T7

例 4:计算 Pandas 的百分比变化

在计算百分比变化之前，我们可以处理数据帧中的任何缺失值。我们可以将参数fill_method=pad 传递给DataFrame.pct_change()方法，该方法向前填充空值。

import pandas as pd
Values = pd.date_range('2021-01-01', periods=3, freq='5W')
df = pd.DataFrame({'coffee': [755.2,751.23,852.21],'Tea': [700.21,695.21,726.21],'Pepper':[900.14,8254.1,455.27]}, index=Values)
print("----------The dataset is----------")
print(df)
print("-------percentage change in the dataset-------")
print(df.pct_change(fill_method='ffill'))

-数据集为-
咖啡茶椒
2021-01-03 755.20 700.21 900.14
2021-02-07 751.23 695.21 8254.10
2021-03-14 852.21 726.21 455.27
-数据集内百分比变化-
咖啡茶椒【T7

结论

在本教程中，我们学习了 PandasDataFrame.pct_change()方法。我们学习了语法和参数，并将其应用于数据帧，以理解 DataFrame.pct_change()方法。

Pandas 数据帧`mode()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-mode-method

在本教程中，我们将讨论和学习 PandasDataFrame.mode()的方法。使用这种方法，我们可以沿着指定的轴获得每个元素模式。当此方法应用于数据帧时，它返回由每一列或每一行的模式组成的数据帧。

以下是DataFrame.mode()方法的语法

句法

DataFrame.mode(axis=0, numeric_only=False, dropna=True)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。

仅限数值:代表布尔(真或假)，默认值为假。如果此参数为True，则仅包括浮点、整数、布尔列。

dropna: 代表 bool，默认值为 True。它不考虑空值。

示例:查找 Pandas 中数据帧的模式值

让我们创建一个数据帧，通过在DataFrame.mode()方法中指定参数axis=0 来获得index轴上的模式值。见下面的例子。

如我们所见，DataFrame.mode()方法返回一个数据帧，该数据帧由沿着row轴的数据帧中重复次数最多的值组成。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,2,1],"B":[2,2,1],"C":[5,2,5],"D":[4,5,4]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mode(axis=0))

-数据帧为-
A B C D
0 1 2 5 4
1 2 2 2 5
2 1 5 4

A B C D
0 1 2 5 4

示例 2:Pandas 中数据帧的查找模式

让我们创建一个数据帧，通过在DataFrame.mode()方法中指定一个参数axis=1 来获得列轴上的模式值。见下面的例子。

如我们所见，DataFrame.mode()方法返回一个数据帧，该数据帧由数据帧中沿列轴重复最多的值组成。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,2,1],"B":[2,2,1],"C":[5,2,5],"D":[1,5,4]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mode(axis=1))

-数据帧为-
A B C D
0 1 2 5 1
1 2 2 2 5
2 1 5 4

0
0 1
1 2
2 1

示例 3:查找 Pandas 中数据帧的模式值

默认情况下，DataFrame.mode()方法不考虑空值或缺失值。如果我们在DataFrame.mode()方法中设置dropna=False，它也会考虑空值，模式可以是空值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A":[1,2,None],"B":[None,2,None],"C":[5,2,5],"D":[1,5,4]}) 
print("------The DataFrame is------")
print(df)
print("---------------------------")
print(df.mode(axis=1,dropna=False))

-数据帧为-
A B C D
0 1.0 NaN 5 1
1 2.0 2.0 2 5
2 NaN 5 4

0
0 1.0
1 2.0
2 NaN

结论

在本教程中，我们学习了 PandasDataFrame.mode()方法。我们学习了语法、参数，并将其应用于数据帧，我们解决了示例并理解了 DataFrame.mode()方法。

Pandas 数据帧`pipe()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pipe-method

如果我们想对整个数据帧应用一种方法，我们可以使用 Python pandas DataFrame.pipe()方法。此方法以先进先出的方式将指定的方法或多个方法(链)应用于数据帧的所有行和列。应用方法可以是用户定义的方法，也可以是内置方法。

下图显示了DataFrame.pipe() 方法的语法。

句法

DataFrame.pipe(func, *args, **kwargs)

因素

功能:是应用于指定数据帧的方法。

args: 可以迭代，可选。它表示传递到func的位置参数。

夸脱:表示映射，可选。传递到func的关键字参数字典。

示例 1:将用户定义的方法应用于数据帧

让我们创建一个数据帧，并对数据帧应用DataFrame.pipe() 方法。在这个例子中，我们定义了一个名为add() 的方法，它将'1'添加到元素中。使用DataFrame.pipe() 方法，我们可以将这个add() 方法应用到整个数据帧。见下面的例子。

#importing pandas as pd
import pandas as pd
def add(x):
    return x+1
df=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})
print("--------The DataFrame is------")
print(df)
print("---------------------")
print(df.pipe(add))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A B C
0 2 5 8
1 3 6 9
2 4 7 10

示例 2:将用户定义的方法应用于数据帧

让我们创建一个数据帧，并对数据帧应用DataFrame.pipe() 方法。在本例中，我们使用DataFrame.pipe() 方法将np.add() 方法应用于整个数据帧。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df=pd.DataFrame({'A':[1,1,1],'B':[2,2,2],'C':[3,3,3]})
print("--------The DataFrame is------")
print(df)
print("---------------------")
print(df.pipe(np.add,2))

-数据帧为-
A B C
0 1 2 3
1 1 2 3
2 1 2 3

A B C
0 3 4 5
1 3 4 5
2 3 4 5

示例 3:将用户定义的方法应用于数据帧

我们可以使用DataFrame.pipe() 方法对数据帧应用多种方法。见下面的例子。

在本例中，我们将值'2' 添加到数据帧中，并分别使用np.add() 和np.multiply() 方法将结果数据帧乘以'2' 。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
df=pd.DataFrame({'A':[1,1,1],'B':[2,2,2],'C':[3,3,3]})
print("--------The DataFrame is------")
print(df)
print("---------------------")
print(df.pipe(np.add,2).pipe(np.multiply,2))

-数据帧为-
A B C
0 1 2 3
1 1 2 3
2 1 2 3

A B C
0 6 8 10
1 6 8 10
2 6 8 10

结论

在本教程中，我们学习了 PandasDataFrame.pipe()方法。我们学习了语法、参数，并在数据帧上应用了这种方法。

Pandas 数据帧`rank()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-rank-method

在本教程中，我们将讨论和学习 PandasDataFrame.rank()的方法。这种方法简单，给数据排序。当这种方法应用于数据帧时，它沿着指定的轴给出从 1 到 n 的数字等级。

下面是DataFrame.rank()方法的语法。

句法

DataFrame.rank(axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)

因素

轴:表示索引或列轴，索引为“0”，列为“1”。当axis=0方法应用于index轴时，以及当axis=1方法应用于column轴时。它指示直接排名的索引。

方法:包括‘平均’‘最小’‘最大’‘第一’‘密集’，默认方法为‘平均’

numeric_only: 表示 bool(真或假)，可选。

na_optio: 包括【守】【上】【下】，默认为【守】

升序:表示布尔(真或假)，默认值为真。它指示数据帧中的元素是否应该按升序排列。

pct: 表示 bool(真或假)，默认值为 False。它指示是否以百分比形式显示返回的排名。

示例 1:对 Pandas 中的数据帧列进行排名

让我们创建一个数据帧，并使用DataFrame.rank()方法获得数据帧的一列的等级。在这里，我们得到了“利润”栏的排名。见下面的例子。

如我们所见，默认情况下DataFrame.rank()方法以升序给出排名。在下面的示例中，在利润列中，有四个值，较小的数字得到等级“1”，最高的数字得到等级“4”。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({'Product_Id':[1001,1002,1003,1004],'Product_Name':['Coffee powder','Black pepper','rosemary','Cardamom'],'customer_Name':['Navya','Vindya','pooja','Sinchana'],'ordered_Date':['16-3-2021','17-3-2021','18-3-2021','18-3-2021'],'ship_Date':['18-3-2021','19-3-2021','20-3-2021','20-3-2021'],'Profit':[750,652.14,753.8,900.12]})
df['ranked_profit']=df['Profit'].rank()
df

输出

示例 2:对 Pandas 中的数据帧列进行排名

这个例子和上一个相似。这里，我们将升序参数设置为 False。现在DataFrame.rank()方法按降序排列。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({'Product_Id':[1001,1002,1003,1004],'Product_Name':['Coffee powder','Black pepper','rosemary','Cardamom'],'customer_Name':['Navya','Vindya','pooja','Sinchana'],'ordered_Date':['16-3-2021','17-3-2021','18-3-2021','18-3-2021'],'ship_Date':['18-3-2021','19-3-2021','20-3-2021','20-3-2021'],'Profit':[750,652.14,753.8,900.12]})
df['ranked_profit']=df['Profit'].rank(ascending=False)
df

输出

示例 3:对 Pandas 中的数据帧列进行排名

如果数据帧由相同的值组成，我们可以使用DataFrame.rank()方法通过不同的方法对数据帧进行排序。

如果方法是average，则通过取两个数的平均值来提供排名。如果方法是min，则给出组内最低的排名。

如果方法为max，则给出组内最高等级。

如果方法是first，它会按照列在数组中出现的顺序对列进行排序。

如果方法是dense，类似于‘min’，但组与组之间的排名总是增加 1。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df=pd.DataFrame({'column_1':[1,3,3,4,7],'column_2':[1,2,3,4,5]})
df['average_rank']=df['column_1'].rank(method='average')
df['min_rank']=df['column_1'].rank(method='min')
df['max_rank']=df['column_1'].rank(method='max')
df['first_rank']=df['column_1'].rank(method='first')
df['dense_rank']=df['column_1'].rank(method='dense')
df

输出

示例 4:对 Pandas 中的数据帧列进行排名

如果数据帧由空值组成，我们可以使用**na_option**参数对它们进行排序，如果参数设置为keep，它会为 NaN 值分配 NaN 等级，如果设置为top，它会为 NaN 值分配最小等级，如果设置为bottom，如果升序，它会为 NaN 值分配最高等级。

#importing pandas as pd
import pandas as pd
#imporing numpy as np
import numpy as np
#creating DataFrame
df=pd.DataFrame({'column_1':[1,3,np.nan,4,np.nan],'column_2':[1,2,3,np.nan,np.nan]})
df['keep_rank_Nan']=df['column_2'].rank(na_option='keep')
df['Top_rank_Nan']=df['column_2'].rank(na_option='top')
df['Bottom_rank_Nan']=df['column_1'].rank(na_option='bottom')
df

Pandas 数据帧`rdiv()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-rdiv-method

在本教程中，我们将学习 PandasDataFrame.rdiv()T4 法。它返回 dataframe 和其他元素的浮点除法。它返回一个带有算术运算结果的数据帧。这是DataFrame.div()方法的反向版本。

下面是 PandasDataFrame.rdiv()方法的语法。

句法

DataFrame.rdiv(other, axis='columns', level=None, fill_value=None)

因素

其他:可以是标量、序列、序列或数据帧。任何单个或多个元素数据结构，或类似列表的对象。

轴:表示索引或列轴，索引为“0”或“索引”，列轴为“1”或“列”。当axis=0 or index方法应用于index轴时，当axis=1或columns 方法应用于column轴时。对于序列输入，轴与序列索引匹配。

级别:代表 int 或 label。它跨级别广播，匹配传递的多索引级别上的索引值。

fill_value: 浮动或无，默认无。在计算之前，用该值填充现有的缺失(NaN)值以及成功的数据帧对齐所需的任何新元素。如果两个相应数据帧位置的数据都丢失，结果也将丢失。

示例 1:使用`DataFrame.rdiv()`方法分割数据帧

以下示例显示了使用DataFrame.rdiv()方法将数据帧除以常数。对于a/b，a 是标量，b 是数据帧元素。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame({'a': [1,6,2],'b': [3,4,6],'c': [12,1,0]})
print("--------The DataFrame is----------")
print(df)
print("---------------------------------")
print(df.rdiv(12))

-数据帧为-
a b c
0 1 3 12
1 6 4 1
2 2 6 0

a b c
0 12.0 4.0 1.0
1 2.0 3.0 12.0
2 6.0 2.0 INF

示例 2:使用`DataFrame.div()`方法分割数据帧

以下示例显示了使用DataFrame.div()方法将数据帧与其他数据帧分割。对于a/b，a 是df2(other DataFrame)，b 是df1元素。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrames
df1 = pd.DataFrame({'a': [2, 2, 2],'b': [2, 2, 2],'c': [2, 2, 2]})
df2 = pd.DataFrame({'a': [2, 5, 6],'b': [8, 10, 12],'c': [14, 16, 18]})
print("---------------------------------")
print(df1.rdiv(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.rdiv()`方法分割数据帧并填充空值

以下示例显示了使用fill_value=.的DataFrame.rdiv()方法将数据帧与其他数据帧分割。请参见以下示例。这里两个数据帧没有对齐，DataFrame.rdiv()不会产生错误，而是给出 Nan 值，并使用fill_value参数填充这些 Nan 值。

import pandas as pd
df1 = pd.DataFrame({'a': [2, 5, 6],'b': [8, 10, 12]})
df2 = pd.DataFrame({'a': [2, 2, 2],'b': [2, 2, 2],'c': [2, 2, 2]})
print(df1.rdiv(df2,fill_value=2))

a b c
0 1.0 4.0 7.0
1 2.5 5.0 8.0
2 3.0 6.0 9.0

结论

在本教程中，我们学习了 PandasDataFrame.rdiv()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。

Pandas 数据帧`reindex()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-reindex-method

在本教程中，我们将讨论和学习 PandasDataFrame.reindex() 的方法。通过使用此方法，我们可以更改索引和列的名称。该方法使用可选的填充逻辑将数据帧与新索引进行协调。它将空值放在先前索引中没有值的位置。

下面是DataFrame.reindex() 方法的语法。

句法

DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)

示例 1:在 Pandas 中重新索引数据帧

这里，我们使用DataFrame.reindex()方法重新索引数据帧的索引。不在原始数据帧中的索引将自动由 NaN 值填充。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame([[1,6,2],[3,4,6],[12,1,0]],columns=['A','B','C'],index=(['index_1','index_2','index_3']))
print("--------The DataFrame is----------")
print(df)
print("---------------------------------")
index=['index_1','index_2','index_4']
print(df.reindex(index))

-数据帧为-
A B C
指数 _1 1 6 2
指数 _2 3 4 6
指数 _3 12 1 0

A B C
指数 _1 1.0 6.0 2.0
指数 _2 3.0 4.0 6.0
指数 _4 NaN NaN

示例 2:在 Pandas 中重新索引数据帧

我们也可以使用DataFrame.reindex() 方法重新索引数据帧的列。不在原始数据帧中的列将自动由 NaN 值填充。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame([[1,6,2],[3,4,6],[12,1,0]],columns=['A','B','C'],index=(['index_1','index_2','index_3']))
print("--------The DataFrame is----------")
print(df)
print("---------------------------------")
column=['A','C','D']
print(df.reindex(column,axis="columns"))

-数据帧为-
A B C
指数 _1 1 6 2
指数 _2 3 4 6
指数 _3 12 1 0

A C D
指数 _1 1 2 NaN
指数 _2 3 6 NaN
指数 _3 12 0 NaN

示例 3:在 Pandas 中重新索引数据帧

我们可以使用DataFrame.reindex() 方法中的参数fill_value=2 来填充空值。更改索引名称后，如果有空值，该空值将由值2填充。

#importing pandas as pd
import pandas as pd
#creating DataFrame
df= pd.DataFrame([[1,6,2],[3,4,6],[12,1,0]],columns=['A','B','C'],index=(['index_1','index_2','index_3']))
print("--------The DataFrame is----------")
print(df)
print("---------------------------------")
index=['index_1','index_2','index_4']
print(df.reindex(index,fill_value=2))

-数据帧为-
A B C
指数 _1 1 6 2
指数 _2 3 4 6
指数 _3 12 1 0

A B C
指数 _1 1 6 2
指数 _2 3 4 6
指数 _ 4 2 2 2 2

结论

在本教程中，我们学习了 PandasDataFrame.reindex()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法解决了一些例子。

Pandas 数据帧`pivot()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pivot-method

在本教程中，我们将讨论和学习 Python PandasDataFrame.pivot() 方法，该方法帮助我们转换或重塑数据帧。当此方法应用于数据帧时，它返回数据帧，该数据帧由给定的索引和列值重新整形和组织。

下面是DataFrame.pivot()方法的语法。

句法

DataFrame.pivot(index=None, columns=None, values=None)

因素

索引:表示字符串或对象或字符串列表，可选。它指示用于建立新框架索引的列。如果此参数为无，则使用现有索引。

列:表示字符串或对象或字符串列表。它指示用于制作新框架列的列。

值:它代表字符串、对象或之前的列表，可选。它指示用于填充新帧值的一列或多列。如果未指定此参数，将使用所有剩余的列，并且结果将具有分层索引的列。

示例 1:重塑 Pandas 的数据帧

让我们应用DataFrame.pivot()方法，并通过指定索引和列名来重塑它。在本例中，我们通过在DataFrame.pivot() 方法中传递索引和列参数，将数据帧的行轴更改为“裁剪”，列轴更改为“状态”。

见下面的例子。DataFrame.pivot()方法返回以行和多列形式表示温度和湿度的数据帧。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({'crop':['Rice','Wheat','Rice','Wheat','Rice','Wheat'],'state':['karnataka','karnataka','Tamilnadu','Tamilnadu','Kerala','Kerala'],'Tempreture':[29,29,31,31,25,25],'Humidity':[50,50,62,62,45,45]})
df = df.pivot(index='crop',columns='state')
print(df)

示例 2:使用`DataFrame.pivot()`方法重塑数据帧

在前面的例子中，我们有多个列，如果我们不想要多个列，我们可以通过传递values参数在DataFrame.pivot() 方法中指定我们想要的列名。见下面的例子。

DataFrame.pivot() 方法返回仅由温度列组成的数据帧。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({'crop':['Rice','Wheat','Rice','Wheat','Rice','Wheat'],'state':['karnataka','karnataka','Tamilnadu','Tamilnadu','Kerala','Kerala'],'Tempreture':[29,29,31,31,25,25],'Humidity':[50,50,62,62,45,45]})
df = df.pivot(index='crop',columns='state',values='Tempreture')
print(df)

示例:`DataFrame.pivot()` 方法提升`ValueError`

如果数据帧中有任何重复项，则DataFrame.pivot() 方法会在重塑数据帧时引发ValueError。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({'crop':['Rice','Rice','Wheat','Wheat','Rice','Wheat'],'state':['karnataka','karnataka','Tamilnadu','Tamilnadu','Kerala','Kerala'],'Tempreture':[29,29,31,31,25,25],'Humidity':[50,50,62,62,45,45]})
df = df.pivot(index='crop',columns='state',values='Tempreture')
print(df)

值错误:索引包含重复条目，无法重新整形

结论

在本教程中，我们学习了 PandasDataFrame.pivot()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。

Pandas 数据帧`pivot_table()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-pivot_table-method

在本教程中，我们将讨论和学习 PandasDataFrame.pivot_table()的方法。此方法可用于聚合和汇总数据帧的数据。当此方法应用于数据帧时，它会返回一个电子表格样式的数据透视表作为数据帧。

下面是DataFrame.pivot_table()方法的语法。

句法

DataFrame.pivot_table(values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All', observed=False)

因素

值:表示要聚合的列，可选。

索引:表示前一个的列、石斑鱼、数组或列表。

列:表示前一个的列、石斑鱼、数组或列表。

aggfunc: 代表功能，功能列表，dict，默认为numpy.mean

示例:使用`DataFrame.pivot_table()`方法聚合数据帧

默认情况下，DataFrame.pivot_table()方法使用函数np.mean聚合数据帧的数据。这里，在这个例子中，我们通过将“日期”作为索引轴，“状态”作为列轴来重塑数据帧，并使用DataFrame.pivot_table()方法根据此来聚合数据。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({'Date':['1/1/2021','1/1/2021','2/1/2021','2/1/2021','1/1/2021','1/1/2021','2/1/2021','2/1/2021'],
                 'state':['karnataka','karnataka','karnataka','karnataka','Tamilnadu','Tamilnadu','Tamilnadu','Tamilnadu'],
                 'Tempreture':[25,29,28,31,26,27,22,32],
                 'Humidity':[46,50,52,59,42,45,46,43]})
df.pivot_table(index='Date',columns='state')

示例:使用`DataFrame.pivot_table()`方法应用功能

我们可以使用**aggfunc** 参数将不同的函数传递给DataFrame.pivot_table()方法。见下面的例子。

DataFrame.pivot_table()方法根据指定的函数返回数据帧。

#importing pandas as pd
import pandas as pd
import numpy as np
#creating the DataFrame
df=pd.DataFrame({'Date':['1/1/2021','1/1/2021','2/1/2021','2/1/2021','1/1/2021','1/1/2021','2/1/2021','2/1/2021'],
                 'state':['karnataka','karnataka','karnataka','karnataka','Tamilnadu','Tamilnadu','Tamilnadu','Tamilnadu'],
                 'Tempreture':[25,29,28,31,26,27,22,32],
                 'Humidity':[46,50,52,59,42,45,46,43]})
df.pivot_table(index='Date',columns='state',aggfunc='max')

示例:将函数的`list`传递给 pivot_table()方法

我们可以使用**aggfunc** 参数将函数的list传递给DataFrame.pivot_table()方法。DataFrame.pivot_table()方法返回由分层列组成的数据帧，其中函数名位于顶层。见下面的例子。

#importing pandas as pd
import pandas as pd
import numpy as np
#creating the DataFrame
df=pd.DataFrame({'Date':['1/1/2021','1/1/2021','2/1/2021','2/1/2021','1/1/2021','1/1/2021','2/1/2021','2/1/2021'],
                 'state':['karnataka','karnataka','karnataka','karnataka','Tamilnadu','Tamilnadu','Tamilnadu','Tamilnadu'],
                 'Tempreture':[25,29,28,31,26,27,22,32],
                 'Humidity':[46,50,52,59,42,45,46,43]})
df.pivot_table(index='Date',columns='state',aggfunc=['sum','count'])

示例:将`margins=True`设置为`DataFrame.pivot_table()`方法

如果参数margins=True 在DataFrame.pivot_table()方法中，它会在结果数据帧中添加'All' 行和列，该数据帧由值的集合组成。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df=pd.DataFrame({'Date':['1/1/2021','1/1/2021','2/1/2021','2/1/2021','1/1/2021','1/1/2021','2/1/2021','2/1/2021'],
                 'state':['karnataka','karnataka','karnataka','karnataka','Tamilnadu','Tamilnadu','Tamilnadu','Tamilnadu'],
                 'Tempreture':[25,29,28,31,26,27,22,32],
                 'Humidity':[46,50,52,59,42,45,46,43]})
df.pivot_table(index='Date',columns='state',margins=True)

结论

在本教程中，我们学习了 Pandas DataFrame.pivot_table()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法解决了一些例子。

Pandas 数据帧`rename()`方法

原文：https://www.studytonight.com/pandas/pandas-dataframe-rename-method

在本教程中，我们将讨论和学习 PandasDataFrame.rename() 方法。通过使用这种方法，我们可以改变或改变轴标签。当此方法应用于数据帧时，如果inplace=True为，则返回数据帧或无。如果在选定的轴中找不到指定的标签，它会发出KeyError 。

下图显示了DataFrame.rename() 方法的语法。

句法

DataFrame.rename(mapper=None, index=None, columns=None, axis=None, copy=True, inplace=False, level=None, errors='ignore')

因素

映射器:可以是类似字典的函数或函数。类似 Dict 或函数的转换应用于该轴的值。使用mapper和axis中的任意一个指定要以mapper为目标的轴，或者使用index和columns为目标的轴。

索引:可以是字典状或函数。这是指定轴的替代方法。

列:可以是类似字典的或函数。这是指定轴的替代方法。

轴:表示索引或列轴，索引为“0”或“索引”，列轴为“1”或“列”。当axis=0 or index方法应用于index轴时，当axis=1或columns 方法应用于column轴时。

副本:代表 bool(真或假)，默认值为 True。它复制底层数据。

inplace: 表示 bool(真或假)，默认值为 False。它指示是否返回新的数据帧。如果参数为真，则忽略副本的值。

级别:表示 int 或 level 名称，默认为 None。

错误:包括‘忽略’、‘提高’，默认为‘忽略’。

示例 1:更改 Pandas 中数据帧的标签

这里，使用DataFrame.rename() 方法，我们更改列的名称。见下面的例子。

我们也可以使用轴参数指定我们正在哪个轴上。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6],"C": [7,8,9]})
print("-------The DataFrame is-------")
print(df)
print("----------------------------------")
print(df.rename(columns={"A": "a", "B": "b","C":"c"}))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A B C
0 1 4 7
1 2 5 8
2 3 6 9

示例:使用`DataFrame.rename()` 方法更改标签

这里，使用DataFrame.rename() 方法，我们更改索引的名称。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6],"C": [7,8,9]})
print("-------The DataFrame is-------")
print(df)
print("----------------------------------")
print(df.rename(index={0: "index_1", 1: "index_2", 2:"index_3"}))

-数据帧为-
A B C
0 1 4 7
1 2 5 8
2 3 6 9

A B C
索引 _1 1 4 7
索引 _2 2 5 8
索引 _3 3 6 9

示例:在`DataFrame.rename()`方法中设置`errors=raise`

如果在更改行或列的名称时出现任何错误，默认情况下DataFrame.rename() 方法会忽略这些错误。如果我们在DataFrame.rename() 方法中设置errors='raise'，会产生错误。见下面的例子。

在下面的示例中，DataFrame.rename() 方法会引发键错误，因为在数据帧中找不到指定的列标签。

#importing pandas as pd
import pandas as pd
#creating the DataFrame
df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6],"C": [7,8,9]})
print(df.rename(columns={"A": "a", "B": "b","D":"d"},errors="raise"))

键错误:“['D']在轴中找不到”

结论

在本教程中，我们学习了 PandasDataFrame.rename()方法。我们通过在数据帧上应用这种方法来学习语法、参数和解决示例，并理解了这种方法。

Pandas 序列参考

Pandas 序列`abs()`方法

原文：https://www.studytonight.com/pandas/pandas-series-abs-method

在本教程中，我们将讨论和学习 Pandas 的Series.abs()方法。通过使用这种方法，我们可以找到任何数字的绝对值，当这种方法应用于Series时，它返回由元素绝对值组成的数列。

该方法适用于只有数值的元素，对于复杂输入，绝对值为a2+b2。

下面是Series.abs()方法的语法。

句法

abs(x)

这里，参数x可以是任意数字，可以是正的或负的零。此方法将返回正零。

示例:获取数列的绝对值

让我们将此方法应用于 Series 并获取绝对值，其代码片段如下。

#importing pandas as pd
import pandas as pd
#creating Series
s = pd.Series([12,-0.25,-54])
print("-----Series-----")
print(s)
print("-------------------")
print(abs(s))

-系列-
0 12.00
1-0.25
2-54.00
dtype:float 64

0 12.00
1 0.25
2 54.00
dtype:float 64

示例:获取`string`的绝对值时键入错误

正如我们之前讨论的Series.abs()方法只适用于数字元素。在本例中，我们试图获得包含string元素和Series.abs()引发类型错误的序列的绝对值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s = pd.Series(['a','2','-0.32'])
print(abs(s))

类型错误:abs():字符串的操作数类型不正确

示例:获取数据帧的绝对值

这里，在这个例子中，我们将得到由复数组成的数列元素的绝对值。对于复杂输入，绝对值将为?a2+b2 Series.abs() 方法仅返回数字的幅度部分。

#importing pandas as pd
import pandas as pd
#creating Series
s = pd.Series([2.1 + 1j,-20,-11])
print("-----Series-----")
print(s)
print("-------------------")
print(abs(s))

-系列-
0 2.100000+1.00000j
1-20.000000+0.000000j
2-11.000000+0.00000j
dtype:complex 128

0 2.325941
1 20.000000
2 11.00000

结论

在本教程中，我们了解了数据帧的abs()方法。我们学习了Series.abs()方法的语法和参数，并解决了不同的例子，以更好地理解这个话题。

Pandas 序列`add()`方法

原文：https://www.studytonight.com/pandas/pandas-series-add-method

在本教程中，我们将讨论和学习 PandasSeries.add() 方法。通过使用这种方法，我们可以将级数与其他级数、标量值相加。当此方法应用于序列时，它返回一个序列。该方法支持使用参数fill_value填充 NaN 值。

下面是Series.add() 方法的语法。

句法

Series.add(other, level=None, fill_value=None, axis=0)

因素

其他:可以是级数或标量值。

fill_value: 可以是 None 或 float 值，默认值为 None (NaN)。它填充空值或缺失值。

级别:代表 int 或 name。它跨级别广播，匹配传递的多索引级别上的索引值。

示例:向系列添加值

这里，在这个例子中，我们使用Series.add() 方法将Series与scalar相加。Series中的元素逐个加上scalar值'2'，返回Series。

#importing pandas as pd
import pandas as pd
#creating Series
s = pd.Series([1,2,3,4])
print("-----Series-----")
print(s)
print("-------------------")
print(s.add(2))

-系列-
0 1
1 2
2 3
3 4
数据类型:int64

0 3
1 4
2 5
3 6
数据类型:int 64

示例:添加一个`Series`与其他`Series`

这里，在这个例子中，我们将使用Series.add() 方法将Series与其他Series相加。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([1,2,3])
s_2= pd.Series([4,5,6])
print("------After adding two series the result is------")
print(s_1.add(s_2))

-两个系列相加后的结果是-
0 5
1 7
2 9
数据类型:int64

示例:在`Series.add()` 方法中设置`fill_value='n'`

通过将fill_value=3传递给Series.add() 方法，我们可以填充序列中的空值或缺失值。

这里，在这个例子中，Series.add() 方法用值 3 填充空值，然后执行加法。如果“系列”位置和结果中的元素都有缺失值，那么它将会有缺失值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([1,None,None])
s_2= pd.Series([4,5,None])
print("------After adding two series the result is------")
print(s_1.add(s_2,fill_value=3))

-两个系列相加后的结果是-
0 5.0
1 8.0
2 NaN
数据类型:float64

结论

在本教程中，我们学习了 PandasDataFrame.add()方法。我们学习了语法、参数，并通过在数据帧上应用这种方法解决了一些例子。

Pandas 序列`agg()`方法

原文：https://www.studytonight.com/pandas/pandas-series-agg-method

在本教程中，我们将讨论和学习 PandasSeries.agg()方法。此方法使用沿指定轴的一个或多个操作来聚合系列元素。当方法由单个方法调用时，它返回标量；当方法由多个方法或方法列表调用时，它返回多个输出。

下面是Series.agg()方法的语法。

句法

Series.agg(func=None, axis=0, *args, **kwargs)

因素

func: 表示方法、字符串、列表或字典。它是用于聚合数据的方法。

轴:如果为 0 或“索引”，则对每列应用一种方法。如果为 1 或“列”，则对每行应用一个方法。默认轴值为 0 或“索引”。

*args: 表示传递给 func 的位置参数。

**kwargs: 表示传递给 func 的关键字参数。

示例:聚合 Pandas 中的系列元素

让我们使用Series.agg() 方法聚合系列元素。这里，在这个例子中，我们通过将single method传递给Series.agg() 方法来聚合Series的元素。见下面的例子。

我们使用'sum'、'min'、'max'、'mean'、'count'方法进行聚合。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([2,3,4])
print("------After aggregating the result is------")
print("The sum of the series elements is:",s.agg('sum'))
print("The min of the series elements is:",s.agg('min'))
print("The max of the series elements is:",s.agg('max'))
print("The mean of the series elements is:",s.agg('mean'))
print("The count of the series elements is:",s.agg('count'))

-合计后的结果为-
系列元素之和为:9
系列元素的最小值为:2
系列元素的最大值为:4
系列元素的平均值为:3.0
系列元素的个数为:3

示例 2:聚合系列元素

让我们使用Series.agg() 方法聚合系列元素。这里，在这个例子中，我们通过将list of methods 传递给Series.agg() 方法来聚合Series的元素。

我们将'sum'、'min'、'max' 方法传递给列表，Series.agg() 方法返回多个输出。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([2,3,4])
print("The ouput of the agg method is:\n",s.agg(['sum','min','max']))

agg 方法的输出为:
sum 9
min 2
max 4
数据类型:int64

示例 3:聚合系列元素

我们可以使用user-defined 方法聚合系列元素。创建一个用户定义的方法，在这个例子中，我们创建了add() 方法，该方法向 Series 元素添加值'1'，如果元素大于 3，则返回相同的元素。见下面的例子。

#importing pandas as pd
import pandas as pd
#defining a user-defined function
def add(x):
    if x>3:
        return x+1
    else:
        return x
#creating Series
s= pd.Series([3,7,5,2,9,4,2])
print("------After aggregating the result is------")
print(s.agg(add))

-汇总后的结果为-
0 3
1 8
2 6
3 2
4 10
5
6 2
数据类型:int64

结论

在本教程中，我们学习了 PandasDataFrame.agg()方法。我们学习了语法、参数，并通过应用这种方法解决了一些例子，理解了这种方法。

Pandas 序列`aggregate()`方法

原文：https://www.studytonight.com/pandas/pandas-series-aggregate-method

在本教程中，我们将讨论和学习 PandasSeries.aggregate()方法。此方法使用沿指定轴的一个或多个操作来聚合系列元素。当单个方法调用该方法时，它返回一个标量值，当多个方法或方法列表调用该方法时，它返回多个输出。

下面是Series.aggregate()方法的语法。

句法

Series.aggregate(func=None, axis=0, *args, **kwargs)

因素

func: 表示方法、字符串、列表或字典。它是用于聚合数据的方法。

轴:如果为 0 或“索引”，则对每列应用一种方法。如果为 1 或“列”，则对每行应用一个方法。默认轴值为 0 或“索引”。

*args: 表示传递给 func 的位置参数。

**kwargs: 表示传递给 func 的关键字参数。

例:Pandas`Series.aggregate()`方法

让我们使用Series.aggregate() 方法聚合系列元素。这里，在这个例子中，我们通过将single method传递给Series.aggregate() 方法来聚合Series的元素。见下面的例子。

我们使用'sum'、'min'、'max'、'mean'、'count'方法进行聚合。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([2,3,4])
print("------After aggregating the result is------")
print("The sum of the series elements is:",s.aggregate('sum'))
print("The min of the series elements is:",s.aggregate('min'))
print("The max of the series elements is:",s.aggregate('max'))
print("The mean of the series elements is:",s.aggregate('mean'))
print("The count of the series elements is:",s.aggregate('count'))

-合计后的结果为-
系列元素之和为:9
系列元素的最小值为:2
系列元素的最大值为:4
系列元素的平均值为:3.0
系列元素的个数为:3

例 2:Pandas`Series.aggregate()`方法

让我们使用Series.aggregate() 方法聚合系列元素。这里，在这个例子中，我们通过将list of methods 传递给Series.agg() 方法来聚合Series的元素。

我们将'sum'、'min'、'max' 方法传递给列表，Series.aggregate() 方法返回多个输出。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([2,3,4])
print("The ouput of the agg method is:\n",s.aggregate(['sum','min','max']))

agg 方法的输出为:
sum 9
min 2
max 4
数据类型:int64

例 3:Pandas`Series.aggregate()`方法

我们可以使用user-defined 方法聚合系列元素。创建一个用户定义的方法，在这个例子中，我们创建了add() 方法，该方法向 Series 的元素添加值 1 ，如果元素大于 3，则返回相同的元素。见下面的例子。

#importing pandas as pd
import pandas as pd
#defining a user-defined function
def add(x):
    if x>3:
        return x+1
    else:
        return x
#creating Series
s= pd.Series([3,7,5,2,9,4,2])
print("------After aggregating the result is------")
print(s.aggregate(add))

-汇总后的结果为-
0 3
1 8
2 6
3 2
4 10
5
6 2
数据类型:int64

结论

在本教程中，我们学习了 PandasDataFrame.aggregate()方法。我们学习了语法、参数，并通过将此方法应用于系列来解决示例。

Pandas 序列`add_prefix()`方法

原文：https://www.studytonight.com/pandas/pandas-series-add_prefix-method

如果我们想要改变系列的索引名称，我们可以通过使用Series.add_prefix()方法将前缀添加到系列索引来改变它们。此方法在每个索引或行的开头添加一个字符串标签，并返回一个带有更新标签的序列。

下面是Series.add_prefix() 方法的语法。

句法

Series.add_prefix(prefix)

因素

前缀:表示字符串，即每个标签前要添加的字符串。

例如:Pandas 序列的前缀标签

让我们创建一个Series并用Series.add_prefix() 方法在数列的行首添加字符串标签。见下面的例子。

Series.add_prefix() 方法将字符串'index_' 作为系列行的前缀。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([1,2,3])
print("---------The series is------")
print(s)
print("-------After updating, the new series is---------")
print(s.add_prefix('index_'))

-系列为-
0 1
1 2
2 3
数据类型:int64
-更新后，新系列为-
index _ 0 1
index _ 1 2
index _ 2 3
数据类型:int64

示例 2:Pandas 序列的前缀行标签

这个例子和上一个相似。让我们创建一个Series并用Series.add_prefix() 方法在Series的行首添加字符串标签。见下面的例子。

Series.add_prefix() 方法将字符串'Student_' 前缀到Series的行。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series(['Navya','Vindya','Sinchana'],index=[1,2,3])
print("---------The series is------")
print(s)
print("-------After updating, the new series is---------")
print(s.add_prefix('Student_'))

-系列为-
1 Navya
2 Vindya
3 Sinchana
数据类型:对象
-更新后，新系列为-
Student _ 1 Navya
Student _ 2 Vindya
Student _ 3 Sinchana
数据类型:对象

结论

在本教程中，我们学习了 PandasSeries.add_prefix()方法。我们通过将这种方法应用于数列来学习语法和解决例子。

Pandas 序列`add_suffix()`方法

原文：https://www.studytonight.com/pandas/pandas-series-add_suffix-method

如果我们想改变系列的索引名称，我们可以使用Series.add_suffix()方法给系列索引添加后缀来改变它们。该方法在每个索引或行的end处添加一个字符串标签，并返回一个带有更新标签的序列。

下面是Series.add_suffix() 方法的语法。

句法

Series.add_suffix(suffix)

因素

前缀:表示字符串，即每个标签后要添加的字符串。

例如:Pandas 序列的后缀标签

让我们创建一个Series并用Series.add_suffix() 方法在系列的行标签的end处添加字符串标签。见下面的例子。

Series.add_suffix() 方法将字符串'_index' 作为系列行的前缀。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series([1,2,3])
print("---------The series is------")
print(s)
print("-------After updating, the new series is---------")
print(s.add_suffix('_index'))

-系列为-
0 1
1 2
2 3
数据类型:int64
-更新后，新系列为-
0 _ index 1
1 _ index 2
2 _ index 3
数据类型:int64

例 2:Pandas 序列的后缀标签

这个例子和上一个相似。让我们创建一个Series并用Series.add_suffix() 方法在Series的行标签的end处添加字符串标签。见下面的例子。

Series.add_suffix() 方法将字符串'_Student' 前缀到Series的行。

#importing pandas as pd
import pandas as pd
#creating Series
s= pd.Series(['Navya','Vindya','Sinchana'],index=['First','Second','Third'])
print("---------The series is------")
print(s)
print("-------After updating, the new series is---------")
print(s.add_suffix('_Student'))

-系列为-
第一名纳维亚
第二名文迪亚
第三名辛查纳
数据类型:对象
-更新后，新系列为-
第一名 _ 学生纳维亚
第二名 _ 学生文迪亚
第三名 _ 学生辛查纳
数据类型:对象

结论

在本教程中，我们学习了 PandasSeries.add_suffix()方法。我们通过将这种方法应用于数列来学习语法和解决例子。

Pandas 序列`all()`方法

原文：https://www.studytonight.com/pandas/pandas-series-all-method

在本教程中，我们将学习 PandasSeries.all()方法。这个方法可以用来检查系列中的元素是True还是False。只有当所有元素都为真时，此方法才返回真，否则返回假。

下图显示了Series.all()方法的语法。

句法

Series.all(axis=0, bool_only=None, skipna=True, level=None, **kwargs)

例:Pandas`Series.all()`方法

让我们创建一个系列，并使用Series.all()方法检查元素。在这个例子中，我们用不同的元素创建了三个系列，正如你所看到的，对于第一个系列，只有我们得到了真，而对于其余的系列，我们得到了假。因为如果序列至少包含一个元素为假，则Series.all()方法返回假。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1=pd.Series([True,True])
s_2=pd.Series([False,False])
s_3=pd.Series([True,False])
print(s_1.all())
print(s_2.all())
print(s_3.all())

真
假
假

例 2:Pandas`Series.all()`方法

在这个例子中，我们正在检查由null values、'0'和'1'作为元素组成的系列以及empty Series。Series.all()方法返回null values 的False和'0'号。见下面的例子。

#importing pandas as pd
import pandas as pd
import numpy as np
#creating Series
s_1=pd.Series([True,np.NaN,np.NaN])
s_2=pd.Series([])
s_3=pd.Series([1])
s_4=pd.Series([0])
print(s_1.all(skipna=False))
print(s_2.all())
print(s_3.all())
print(s_4.all())

楠
真
真
假

例 3:Pandas`Series.all()`方法

在这个例子中，我们将检查两个系列。Series.all()方法仅在给定条件匹配时返回True，否则返回False。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1=pd.Series([1,2,3])
s_2=pd.Series([4,5,6])
print(all(s_1>s_2))
print(all(s_1<s_2))

假
真

结论

在本教程中，我们学习了如何使用 PythonPandas 的Series.all()方法。我们通过在数据帧上应用这种方法解决了一些例子。

Pandas 序列`any()`方法

原文：https://www.studytonight.com/pandas/pandas-series-any-method

在本教程中，我们将学习 PandasSeries.any()方法。这个方法可以用来检查系列中的元素是True还是False。此方法返回 True。如果序列中至少有一个元素为 True，则返回 False。

下面是Series.any()方法的语法。

句法

Series.any(axis=0, bool_only=None, skipna=True, level=None, **kwargs)

例:Pandas`Series.any()`方法

让我们创建一个系列，并使用Series.any()方法检查元素。在这个例子中，我们用不同的元素创建了三个系列，对于系列s_1和s_2 ，Series.any()方法返回True，因为这两个系列都包含至少一个元素作为'True'，对于系列s_3，它返回False，因为它包含'False'作为所有元素。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1=pd.Series([True,True])
s_2=pd.Series([False,False])
s_3=pd.Series([True,False])
print(s_1.any())
print(s_2.any())
print(s_3.any())

真
假
真

例 2:Pandas`Series.any()`方法

这里，在这个例子中，我们正在检查由null values、'0'和'1'作为元素组成的系列以及empty Series。对于序列 S1 和 S3，Series.any()方法返回真，这些序列分别由一个元素组成为真和“1”，对于empty Series 和数字'0'返回假。见下面的例子。

#importing pandas as pd
import pandas as pd
import numpy as np
#creating Series
s_1=pd.Series([True,np.NaN,np.NaN])
s_2=pd.Series([])
s_3=pd.Series([1])
s_4=pd.Series([0])
print(s_1.any(skipna=False))
print(s_2.any())
print(s_3.any())
print(s_4.any())

真
假
真
假

例 3:Pandas`Series.any()`方法

在这个例子中，我们将检查两个系列。Series.any()方法仅在给定条件匹配时返回True，否则返回False。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1=pd.Series([1,2,7])
s_2=pd.Series([4,5,6])
s_3=pd.Series([7,8,9])
print(any(s_1>s_2))
print(any(s_2>s_3))

真
假

结论

在本教程中，我们学习了如何使用 PythonPandas 的Series.any()方法。

Pandas 序列`append()`方法

原文：https://www.studytonight.com/pandas/pandas-series-append-method

如果我们想合并两个系列，我们可以使用 PandasSeries.append() 方法，该方法合并或连接两个系列并返回一个新的系列。

下面是Series.append() 方法的语法。

句法

Series.append(to_append, ignore_index=False, verify_integrity=False)

因素

to_append: 可以是序列，也可以是序列的列表/元组。它指示要附加自身的系列。

ignore_index: 表示 bool(真或假)，默认为 False。如果此参数为真，则结果轴将标记为 0，1，…，n - 1。

verify_integrity: 表示 bool(真或假)，默认为 False。如果此参数为真，则在创建重复索引时会引发异常。

示例:在 Pandas 中添加两个系列

我们可以使用Series.append()方法将一个数列追加到一个数列中。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s1 = pd.Series(['Python','Java'])
s2 = pd.Series([1,2])
print(s1.append(s2))

0 Python
1 Java
0 1
1 2
数据类型:对象

示例 2:在 Pandas 中添加两个系列

在前面的示例中，当我们追加两个系列时，它们的索引值是重叠的。我们可以通过在Series.append() 方法中传递参数ignore_index=True 来避免这种情况。见下面的例子。现在索引将从 0 开始到 n-1。

#importing pandas as pd
import pandas as pd
#creating Series
s1 = pd.Series(['Python','Java'])
s2 = pd.Series([1,2])
print(s1.append(s2, ignore_index=True))

0 Python
1 Java
2 1
3 2
数据类型:对象

示例 3:在 Pandas 中添加两个系列

当索引值重叠时，这将引发异常。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s1 = pd.Series(['Python','Java'])
s2 = pd.Series([1,2])
print(s1.append(s2,verify_integrity=True))

值错误:索引有重叠值:Int64Index([0，1]，dtype='int64 ')

结论

在本教程中，我们学习了 PythonPandasDataFrame.append()方法。我们理解了DataFrame.append()方法的语法和参数，并通过将该方法应用于系列来解决示例。

Pandas 序列`apply()`方法

原文：https://www.studytonight.com/pandas/pandas-series-apply-method

我们可以使用 PandasSeries.apply() 方法将 numpy 方法或Python方法分别应用于整个系列和系列的元素。此方法将传递的方法应用于系列的值。

下面是Series.apply() 方法的语法。

句法

Series.apply(func, convert_dtype=True, args=(), **kwds)

因素

功能:是应用 Python 方法或 NumPy ufunc 的方法。

convert_dtype: 表示 bool(真或假)，默认值为真。

args: 表示元组。它是在序列值之后传递给 func 的位置参数。

**kwds :是传递给 func 的附加关键字参数。

例:Pandas`Series.apply()`方法

让我们将np.pi 方法应用于数列的值。在这个例子中，我们传递了 lambda 方法和 numpy np.pi 方法，后者将 Series 值乘以 pi 值。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating Series
s = pd.Series([1,2,3])
print(s.apply(lambda x: x*np.pi))

0 3.141593
1 6.283185
2 9.424778
数据类型:float64

示例:将 lower()函数应用于`Series.apply()` 方法

在本例中，我们将 python lower()方法应用于 Series。Series .apply()方法通过将 Series 的元素转换成小写来返回一个 Series。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s = pd.Series(['PYTHON','JAVA'])
print(s.apply(lambda x: x.lower()))

0 python
1 java
数据类型:对象

例:Pandas`Series.apply()`方法

这里，在这个例子中，我们应用了 lambda 方法和条件。如果条件满足，则返回真，否则返回假。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating Series
s = pd.Series([2,1,8,4])
print(s.apply(lambda x: x >= 2 and x <=5))

0 真
1 假
2 假
3 真
数据类型:布尔

结论

在本教程中，我们了解了数据帧的Series.apply()方法。我们学习了Series.apply()方法的语法和参数，并创建了不同的示例来更好地理解这个主题。

Pandas 序列`argmax()`方法

原文：https://www.studytonight.com/pandas/pandas-series-argmax-method

在本教程中，我们将学习 PandasSeries.argmax() 的方法。该函数返回一个整数值，该整数值表示存在最大值的位置。

下图显示了Series.argmax() 方法的语法。

句法

Series.argmax(axis=None, skipna=True, *args, **kwargs)

因素

轴:为无。这是与 Series 保持一致的伪参数。

skipna: 是 bool(真或假)，默认值为真。当显示结果时，它排除所有空值。

args，kwargs* :是与 NumPy 兼容的附加参数和关键字。

示例:使用`Series.argmax()` 方法获取最大值的位置

让我们将Series.argmax() 方法应用于两个系列，并获得较大值的位置。见下面的例子。

这里，在系列s_1中，有不同的值，在s_2中，由重复的值组成。Series.argmax() 方法返回一个位置，如果较大的值出现在不同的位置，则返回第一行的位置。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([12,45,78,22])
s_2= pd.Series([11,45,14,45])
print("In Series s_1 the maximum value is in position:",s_1.argmax())
print("In Series s_2 the maximum value is in position:",s_2.argmax())

在序列 S1 中，最大值位于位置:2
在序列 S2 中，最大值位于位置:1

示例:获取由空值组成的 mx 值的位置

这里，在本例中，Series 元素由空值组成，默认情况下Series.argmax() 方法ignores仅通过考虑整数元素来计算空值并返回较大值的位置。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating Series
s = pd.Series([np.nan,12,100,np.nan])
print("The maximum value is in position:",s.argmax())

最大值在位置:2

结论

在本教程中，我们了解了数据帧的Series.argmax() 方法。我们学习了Series.argmax() 方法的语法和参数，并创建了不同的示例来更好地理解这个主题。

Pandas 序列`argmin()`方法

原文：https://www.studytonight.com/pandas/pandas-series-argmin-method

在本教程中，我们将学习 PandasSeries.argmin() 的方法。此方法返回整数值，该整数值指示存在最小值的位置。

下图显示了Series.argmin() 方法的语法。

句法

Series.argmin(axis=None, skipna=True, *args, **kwargs)

因素

轴:为无。这是与 Series 保持一致的伪参数。

skipna: 是 bool(真或假)，默认值为真。当显示结果时，它排除所有空值。

args，kwargs* :是与 NumPy 兼容的附加参数和关键字。

示例:使用`Series.argmin()` 方法获取较小值的位置

让我们将Series.argmin() 方法应用于两个级数，得到最小值的位置。见下面的例子。

这里，在系列s_1中，有不同的值，在s_2中，由重复的值组成。Series.argmin() 方法返回一个位置，如果最小值出现在不同的位置，则返回第一行的位置。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([45,10,78,22])
s_2= pd.Series([45,14,11,11])
print("In Series s_1 the minimum value is in the position:",s_1.argmin())
print("In Series s_2 the minimum value is in the position:",s_2.argmin())

在序列 S1 中，最小值位于位置:1
在序列 S2 中，最小值位于位置:2

示例:获取由空值组成的系列的最小值的位置

这里，在本例中，Series 元素由空值组成，默认情况下Series.argmin() 方法ignores仅通过考虑整数元素来计算空值并返回最小值的位置。见下面的例子。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating Series
s = pd.Series([np.nan,5,9,np.nan])
print("The minimum value is in the position:",s.argmin())

最小值在位置:1

示例:获取由空值组成的系列的最小值的位置

如果在求最小值的时候要考虑空值，可以通过Series.argmin() 方法中的skipna=False 来实现。见下面的例子。对于空值，它将位置返回为-1。

#importing pandas as pd
import pandas as pd
#importing numpy as np
import numpy as np
#creating Series
s = pd.Series([12,90,100,np.nan,np.nan,120])
print("The minimum value is in the position:",s.argmin(skipna=False))

最小值在位置:-1

结论

在本教程中，我们了解了数据帧的Series.argmin() 方法。我们学习了Series.argmin() 方法的语法和参数，并创建了不同的示例来更好地理解这个主题。

Pandas 序列`argsort()`方法

原文：https://www.studytonight.com/pandas/pandas-series-argsort-method

在本教程中，我们将学习 PandasSeries.argsort()方法。此方法返回由对序列值进行排序的索引组成的序列。如果序列包含空值或缺失值，Series.argsort()方法给出-1 值作为其索引。

下面是Series.argsort()方法的语法。

句法

Series.argsort(axis=0, kind='quicksort', order=None)

因素

轴:为 0 或“指数”。它没有效果，但被接受与 numpy 兼容。

种类:包括‘merge sort’‘quick sort’‘heap sort’，默认为‘quick sort’。它表示排序算法的选择。

顺序:无。它没有效果，但被接受与 numpy 兼容。

示例:使用`Series.argsort()`方法对序列元素进行排序

让我们创建一个系列并将Series.argsort()方法应用于该系列。默认情况下，Series.argsort()方法使用快速排序算法对序列的元素进行排序，并返回索引。见下面的例子。

即使我们使用“mergesort”和“heapsort”，我们也会得到相同的输出。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([2,1,4,3])
print(s_1.argsort())

0 1
1 0
2 3
3 2
数据类型:int64

示例:对由空值组成的系列元素进行排序

让我们将Series.argsort()方法应用于由空值组成的序列。Series.argsort()方法返回-1 值作为空值的索引。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
s_1= pd.Series([None,1,None,3])
print(s_1.argsort())

0 -1
1 0
2 -1
3 1
数据类型:int64

结论

在本教程中，我们了解了数据帧的Series.argsort() 方法。我们学习了Series.argsort() 方法的语法和参数，并创建了不同的示例来更好地理解这个主题。

Pandas 序列`asfreq()`

原文：https://www.studytonight.com/pandas/python-pandas-seriesasfreq-method

在本教程中，我们将学习 PandasSeries.asfreq()的方法。此方法用于将时间序列转换为指定的频率。使用这种方法，我们可以填充任何缺失的值或空值。

下图显示了Series.asfreq()方法的语法。

句法

Series.asfreq(freq, method=None, how=None, normalize=False, fill_value=None)

参数

freq: 表示日期偏移量或字符串。它是频率 DateOffset 或字符串。

方法:包括“回填”/“填充”/“填充”，默认值为“无”。它表示用于填充重新索引系列中的孔的方法。

如何:表示‘开始’、‘结束’，默认为结束。

归一化:表示布尔(真或假)，默认值为假。它指示是否将输出索引重置为午夜。

fill_value: 是标量，可选。它是用于缺失值的值，在上采样期间应用。

示例:使用`Series.asfreq()`方法转换时间序列

让我们创建一个时间序列，并使用Series.asfreq()方法将其转换为指定的频率。在这个例子中，我们将时间序列转换为“小时”。见下面的例子。

import pandas as pd
index = pd.date_range('1/4/2021', periods=4, freq='T')
series = pd.Series([1.0, None, None, 3.0], index=index)
print("--------The Series is-------")
print(series)
print("-----------After converting the Timeseries-----------")
print(series.asfreq(freq='H'))

-系列为-
2021-01-04 00:00:00 1.0
2021-01-04 00:01:00 NaN
2021-01-04 00:02:00 NaN
2021-01-04 00:03:00 3.0
Freq:T，dtype: float64
-转换时间系列后-

示例:使用 Series.asfreq()方法对时间序列进行上采样

在本例中，我们将时间序列上采样为“40”，并用标量“5.0”填充缺失的值。见下面的例子。

Series.asfreq()方法中的 fill_value 参数不会填充已经存在的缺失值。

import pandas as pd
index = pd.date_range('1/4/2021', periods=4, freq='T')
series = pd.Series([1.0, None, None, 3.0], index=index)
print("--------The Series is-------")
print(series)
print("-----------upsample Timeseries and fill value-----------")
print(series.asfreq(freq='40s',fill_value=5.0))

-系列为-
2021-01-04 00:00:00 1.0
2021-01-04 00:01:00 NaN
2021-01-04 00:02:00 NaN
2021-01-04 00:03:00 3.0
Freq:T，dtype: float64
-上采样时间系列和填充值

示例:使用`bfill`方法对时间序列进行上采样

这里，在这个例子中，我们使用'bfill'方法填充缺失的值，该方法向后填充时间序列中存在的空值。见下面的例子。

import pandas as pd
index = pd.date_range('1/4/2021', periods=4, freq='T')
series = pd.Series([1.0, None, None, 3.0], index=index)
print("-----------upsample Timeseries-----------")
print(series.asfreq(freq='70s'))
print("-----------backward fill-------")
print(series.asfreq(freq='70s',method='bfill'))

-上采样时间序列-
2021-01-04 00:00:00 1.0
2021-01-04 00:01:10 NaN
2021-01-04 00:02:20 NaN
Freq:70S，dtype: float64
-后向填充-
2021-01-04 00:00:00 1.0 【T7

结论

在本教程中，我们学习了 PythonPandasSeries.asfreq()方法。我们学习并理解了Series.asfreq()方法的语法和参数，通过将该方法应用于数据帧，我们通过将时间序列转换为指定频率、对频率进行上采样并填充缺失值来解决示例。

Pandas 序列`astype()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesastype-method

在本教程中，我们将学习 PandasSeries.astype()的方法。该方法用于转换 Pandas 对象的数据类型。使用这个方法，我们可以将对象的数据类型转换为指定的数据类型

下图显示了Series.astype()方法的语法。

句法

Series.astype(dtype, copy=True, errors='raise')

因素

数据类型:是列名的数据类型或字典。

副本:代表 bool(真或假)，默认为 True。当副本=真时，它返回一个副本

错误:包括‘提高’、‘忽略’，默认为‘提高’

示例:使用`Series.astype()`方法投射 Pandas 物体

让我们使用Series.astype()方法将 Series 对象转换为另一种数据类型。在这个例子中，我们从'int64'转换为'int32'数据类型。见下面的例子。

import pandas as pd
series = pd.Series([1,2,3,4,5]) 
print("----Before converting datatype of DataFrame-----")
print(series.dtypes)
print("----After converting datatype of DataFrame-----")
print(series.astype('int32').dtypes)

-转换数据帧数据类型前-
int64
-转换数据帧数据类型后-
int32

示例:使用`Series.astype()`方法投射 Pandas 物体

这个例子和上一个相似。让我们使用Series.astype()方法将 Series 对象转换为另一种数据类型。在这个例子中，我们从“int64”转换为“str”数据类型。见下面的例子。

import pandas as pd
series = pd.Series([1,2,3,4,5]) 
print("----Before converting datatype of DataFrame-----")
print(series.dtypes)
print("----After converting datatype of DataFrame-----")
print(series.astype(str).dtypes)

-转换数据帧数据类型前-
int64
-转换数据帧数据类型后-
int32

结论

在本教程中，我们学习了 PandasSeries.astype()方法。我们将 Series 的数据类型列转换为另一种数据类型，并检查了 Series。

Pandas 序列`at_time()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesat_time-method

在本教程中，我们将讨论和学习 PandasSeries.at_time()方法，使用该方法我们可以在一天中的特定时间选择值。如果索引中没有指定的时间，它将返回空序列；如果索引不是日期时间索引，它将引发TypeError。

下图显示了Series.at_time()方法的语法。

句法

Series.at_time(time, asof=False, axis=None)

因素

时间:是 datetime.time 或 str。

轴: {0 或'索引'，1 或'列' }，默认为 0。

示例:使用`Series.at_time()`方法选择值

让我们创建一系列数据时间索引，并使用Series.at_time()方法获取值。如果指定的时间出现在索引中，Series.at_time()方法返回这些行。见下面的例子。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=6, freq='8H')
series = pd.Series([1, 2, 3, 4, 5, 6], index=Values)
print(series)
print("-----Selecting values---------")
print(series.at_time('8:00'))

2021-04-01 00:00:00 1
2021-04-01 08:00:00 2
2021-04-01 16:00:00 3
2021-04-02 00:00 4
2021-04-02 08:00:00 5
2021-04-02 16

示例:使用`Series.at_time()`方法选择值

这个例子类似于上一个改变周期，频率和获取值的例子。见下面的例子。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=4, freq='10T')
series = pd.Series([1, 2, 3, 4], index=Values)
print(series)
print("-----Selecting values---------")
print(series.at_time('00:10:00'))

2021-04-01 00:00:00 1
2021-04-01 00:10:00 2
2021-04-01 00:20:00 3
2021-04-01 00:30:00 4
Freq:10T，dtype: int64
-选择值-
2021-04-01 00

示例:`Series.at_time()`方法返回空序列

这里，在这个例子中，Series.at_time()方法返回空序列，因为指定的时间'10:00' 不在索引中。见下面的例子。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=4, freq='10T')
series = pd.Series([1, 2, 3, 4], index=Values)
print(series)
print("-----Selecting values---------")
print(series.at_time('10:00'))

2021-04-01 00:00:00 1
2021-04-01 00:10:00 2
2021-04-01 00:20:00 3
2021-04-01 00:30:00 4
频率:10T，数据类型:int64
-选择值-
系列([]，频率:10T，数据类型

示例:`Series.at_time()`方法引发类型错误

序列的索引必须是日期时间索引，否则Series.at_time()方法在选择值时会引发TypeError。见下面的例子。

#importing pandas as pd
import pandas as pd
series = pd.Series([1, 2, 3, 4])
print(series.at_time('10:00'))

类型错误：索引必须是日期时间索引

结论

在本教程中，我们学习了 PandasSeries.at_time()方法。我们理解了函数的语法和参数，并通过在数据帧上应用Series.at_time()方法来获得指定时间的值来解决示例。

Pandas 序列`backfill()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesbackfill-method

如果我们想用其他值替换缺失值或空值，可以选择backfill 方法。在本教程中，我们将学习向后填充空值或缺失值的pythonpandsSeries.backfill()方法。如果inplace为真，则返回填充了缺失值的序列或None 。

下图显示了Series.backfill()方法的语法。

句法

Series.backfill(axis=None, inplace=False, limit=None, downcast=None)

示例:使用`Series.backfill()`方法填充缺失值

让我们使用Series.backfill()方法来填充序列中缺少的值。此方法向后填充序列中存在的空值或缺失值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,5,None,10])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.backfill())

-系列为-
0 NaN
1 5.0
2 NaN
3 10.0
dtype:float 64

0 5.0
1 5.0
2 10.0
3 10.0
dtype:float 64

示例:在`Series.backfill()`方法中设置限制

在本例中，我们将极限参数设置为某个整数。使用该参数，我们可以定义Series.backfill()方法的限制，以填充连续缺失值的数量。见下面的例子。

在下面的例子中，数列由三个连续的缺失值组成，并且Series.backfill()方法仅填充两个缺失值，因为限制被设置为 2。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,None,None,5])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.backfill(limit=2))

-系列为-
0 NaN
1 NaN
2 NaN
3 5.0
数据类型:float64

0 NaN
1 5.0
2 5.0
3 5.0
数据类型:float 64

示例:在`Series.backfill()`方法中设置`inplace=True`

这里，在这个例子中，我们已经在Series.backfill()方法中设置了inplace=True。由于该参数为True，因此Series.backfill()方法在不创建新对象的情况下填充缺失值，并返回None。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,5,None,5])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.backfill(inplace=True))

-系列为-
0 NaN
1 5.0
2 NaN
3 5.0
数据类型:float64

None
0 5.0
1 5.0
2 5.0
3 5.0
数据类型:float 64

结论

在本教程中，我们学习了 PandasSeries.backfill()方法。我们学习了该方法的语法和参数，并将该方法应用于由 None 值组成的系列，并理解了Series.backfill()方法。

Pandas 序列`bfill()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesbfill-method

如果我们想用其他值替换缺失值或空值，可以选择bfill 方法。在本教程中，我们将学习向后填充空值或缺失值的pythonpandsSeries.bfill()方法。如果inplace为真，则返回填充了缺失值的序列或None 。

下图显示了Series.bfill()方法的语法。

句法

Series.bfill(axis=None, inplace=False, limit=None, downcast=None)

示例:使用`Series.bfill()`方法填充缺失值

让我们使用Series.bfill()方法来填充序列中缺少的值。此方法向后填充序列中存在的空值或缺失值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,5,None,10])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.bfill())

-系列为-
0 NaN
1 5.0
2 NaN
3 10.0
dtype:float 64

0 5.0
1 5.0
2 10.0
3 10.0
dtype:float 64

示例:在`Series.bfill()`方法中设置限制

在本例中，我们将极限参数设置为某个整数。使用该参数，我们可以定义Series.bfill()方法的限制，以填充连续缺失值的数量。见下面的例子。

在下面的例子中，数列由三个连续的缺失值组成，并且Series.bfill()方法仅填充两个缺失值，因为限制被设置为 2。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,None,None,5])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.bfill(limit=2))

-系列为-
0 NaN
1 NaN
2 NaN
3 5.0
数据类型:float64

0 NaN
1 5.0
2 5.0
3 5.0
数据类型:float 64

示例:在`Series.bfill()`方法中设置`inplace=True`

这里，在这个例子中，我们已经在Series.bfill()方法中设置了inplace=True。由于该参数为True，因此Series.bfill()方法在不创建新对象的情况下填充缺失值，并返回None。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series=pd.Series([None,5,None,5])
print("-----------The Series is---------")
print(series)
print("---------------------------------")
print(series.bfill(inplace=True))

-系列为-
0 NaN
1 5.0
2 NaN
3 5.0
数据类型:float64

None
0 5.0
1 5.0
2 5.0
3 5.0
数据类型:float 64

结论

在本教程中，我们学习了 PandasSeries.bfill()方法。我们学习了该方法的语法和参数，并将该方法应用于由 None 值组成的系列，并理解Series.bfill()方法向后填充 Pandas 数据帧中存在的NaN值。

Pandas 序列`between_time()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesbetween_time-method

在本教程中，我们将学习 PandasSeries.between_time()方法使用该方法，我们可以选择一天中特定时间之间的值。它从原始的 Series 对象返回由指定日期范围组成的 Series，如果索引不是DatetimeIndex，它将引发TypeError 。

下图显示了Series.between_time()方法的语法。

句法

Series.between_time(start_time, end_time, include_start=True, include_end=True, axis=None)

因素

开始时间:表示作为时间过滤器限制的初始时间的datetime.time或字符串。

结束时间:表示作为时间过滤器限制的结束时间的 d atetime.time或字符串。

include_start: 代表 bool(真或假)，默认值为 True。它指示开始时间是否需要包含在结果中。

include_end: 代表 bool(真或假)，默认值为 True。表示结果中是否需要包含结束时间。

示例:从特定时间之间的序列中获取值

让我们用DatetimeIndex 创建一个序列，并使用Series.between_time()方法获取特定时间之间的值。在这个例子中，我们得到了所有的值，因为我们分别在 '0:00'和'2:00' 给出了start_time 和end_time 。见下面的例子。Series.between_time()方法返回介于并包括start_time 和end_time之间的值。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=3, freq='50T')
series = pd.Series([1, 2, 3], index=Values)
print(series)
print("-----Selecting values---------")
print(series.between_time('0:00','2:00'))

2021-04-01 00:00:00 1
2021-04-01 00:50:00 2
2021-04-01 01:40:00 3
频率:50T，数据类型:int64
-选择值-
2021-04-01 00:00:00 1
2021-04-01 00

示例:从特定时间之间的序列中获取值

这个例子与上一个类似，改变周期、频率，并通过在Series.between_time()方法中指定它们来尝试得到start_time 和end_time之间的值。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=4, freq='20T')
series = pd.Series([1, 2, 3, 4], index=Values)
print(series)
print("-----Selecting values---------")
print(series.between_time('0:00','0:40'))

2021-04-01 00:00:00 1
2021-04-01 00:20:00 2
2021-04-01 00:40:00 3
2021-04-01 01:00 4
Freq:20T，dtype: int64
-选择值-
2021-04-01 00

示例:在`Series.between_time()`方法中将 include_start 和 include_end 设置为 False

在Series.between_time()方法中，默认设置include_start 和include_end 参数为True。因此，当我们试图获取特定时间之间的值时，Series.between_time()方法会在输出中包含start_time 和end_time 。如果不想在结果中包含start_time 和end_time ，可以将include_start 和include_end 参数设置为 False。见下面的例子。

#importing pandas as pd
import pandas as pd
Values = pd.date_range('2021-04-01', periods=4, freq='20T')
series = pd.Series([1, 2, 3, 4], index=Values)
print(series)
print("-----Selecting values---------")
print(series.between_time('0:00','0:40',include_start=False,include_end=False))

2021-04-01 00:00:00 1
2021-04-01 00:20:00 2
2021-04-01 00:40:00 3
2021-04-01 01:00 4
Freq:20T，dtype: int64
-选择值-
2021-04-01 00

示例:`Series.between_time()`提升`TypeError`的方法

如果指数不是DataTimeIndex,，DataFrame.between_time()方法会提升TypeError.见下例。

#importing pandas as pd
import pandas as pd
series = pd.Series([1, 2, 3, 4])
print(series.between_time('0:00','0:50'))

类型错误：索引必须是日期时间索引

结论

在本教程中，我们学习了 PandasSeries.between_time()方法。我们理解了函数的语法和参数，并通过在数列上应用Series.between_time() 方法来求解示例，以获得指定时间之间的值。

Pandas 序列`bool()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesbool-method

在本教程中，我们将学习 PandasSeries.bool()方法。使用这种方法，我们检查给定的序列是否由单个布尔作为元素组成。元素必须是布尔scalar 值，为真或假。它返回bool，与系列中的值相同。如果序列包含多个元素并且该元素不是布尔型的，则Series.bool()方法会引发ValueError。

下图显示了Series.bool()方法的语法。

句法

Series.bool()

示例:使用`Series.bool()`方法检查系列

在这个例子中，我们创建了两个由一个布尔元素组成的系列。让我们用Series.bool()方法来检查这两个系列。由于两个序列由一个布尔元素组成，Series.bool()方法返回序列中的布尔值。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series_1 = pd.Series([True])
series_2 = pd.Series([False])
print("The element present in the Series_1 is",series_1)
print("The element present in the Series_2 is",series_2)
print("-------------------------------------------------")
print("The Series_1 contains a single bool value:",series_1.bool())
print("The Series_2 contains a single bool value:",series_2.bool())

Series _ 1 中存在的元素为 0 True
数据类型:bool
Series _ 2 中存在的元素为 0 False
数据类型:bool

Series _ 1 包含单个 bool 值:True
Series _ 2 包含单个 bool 值:False

示例:使用`Series.bool()`方法检查系列

在这个例子中，我们已经创建了两个由不止一个布尔元素组成的系列。当我们对这些数列应用Series.bool()方法时，我们会得到 ValueError。见下面的例子。

如果序列包含多个布尔元素，则Series.bool()方法会引发ValueError。

#importing pandas as pd
import pandas as pd
#creating Series
series_1 = pd.Series([True,False])
series_2 = pd.Series([True,True])
print("Does the Series_1 contains single bool value:",series_1.bool())
print("Does the Series_2 contains single bool value:",series_2.bool())

值错误:数列的真值不明确。请使用 a.empty、a.bool()、a.item()、a.any()或 a.all()。

示例:使用`Series.bool()`方法检查系列

在本例中，我们创建了两个由单个integer 值组成的系列。Series.bool()方法会产生一个ValueError，因为数列由非布尔值(整数)组成。见下面的例子。

#importing pandas as pd
import pandas as pd
#creating Series
series_1 = pd.Series([0])
series_2 = pd.Series([1])
print("Does the Series_1 contains single bool value:",series_1.bool())
print("Does the Series_2 contains single bool value:",series_2.bool())

值错误:布尔不能作用于非布尔单元素序列

结论

在本教程中，我们学习了 PythonPandasSeries.bool()方法。通过解决不同的例子，我们理解了这种方法是如何工作的。

Pandas 序列`clip()`方法

原文：https://www.studytonight.com/pandas/python-pandas-seriesclip-method

在本教程中，我们将学习蟒PandasSeries.clip()方法。使用这种方法，我们可以通过指定输入阈值(可以是奇异值或数组)来限制或修剪序列中的值。它通过替换剪辑边界之外的值返回序列，如果是inplace=True，则返回无。

下图显示了Series.clip()方法的语法。

句法

Series.clip(lower=None, upper=None, axis=None, inplace=False, *args, **kwargs)

因素

low:表示 float 或 array_like，默认值为 None。它表示最小阈值，低于该阈值的所有值都将被设置为它。

上:表示浮动或 array_like，默认值为 None。它代表最大阈值。高于此阈值的所有值都将被设置为该值。

inplace: 表示 bool(真或假)，默认值为 False。是否对数据就地执行操作。

args，kwargs* :是额外的关键词，没有效果，但可能会被接受与 NumPy 兼容。

示例:具有`upper`阈值的`Series.clip()`方法

这里，在这个例子中，我们使用upper阈值的Series.clip()方法修剪序列值。我们将上限阈值设置为4，Series.clip()方法修剪阈值以上的值，并将其设置为阈值。见下面的例子。

#importing pandas library
import pandas as pd
series = pd.Series([8,3,-6,4.5])
print("------Series--------")
print(series)
print("------After clipping the Series--------")
print(series.clip(upper=4))

-系列-
0 8.0
1 3.0
2-6.0
3 4.5
数据类型:float64
-剪裁系列-
0 4.0
1 3.0
2-6.0
3 4.0
数据类型:float64

示例:`Series.clip()`阈值较低的方法

这里，在这个例子中，我们使用lower 阈值的Series.clip()方法修剪序列值。我们将lower 阈值设置为4 ，Series.clip()方法修剪低于阈值的值并将其设置为阈值。见下面的例子。

#importing pandas library
import pandas as pd
series = pd.Series([5,2,-6,3])
print("------Series--------")
print(series)
print("------After clipping the Series--------")
print(series.clip(lower=4))

-系列-
0 5
1 2
2 -6
3 3
数据类型:int64
-剪裁系列-
0 5
1 4
2 4
3 4
数据类型:int64

示例:`Series.clip()`方法与`upper`和`lower` 阈值

我们可以在Series.clip()方法中指定下限和上限阈值，该方法根据指定的lower 和upper 阈值修剪序列值。见下面的例子。

#importing pandas library
import pandas as pd
series = pd.Series([8,-6,6,-1])
print("------Series--------")
print(series)
print("------After clipping the Series--------")
print(series.clip(-1,5))

-系列-
0 8
1 -6
2 6
3 -1
数据类型:int64
-剪裁系列-
0 5
1-1
2 5
3-1
数据类型:int64

示例:在`Series.clip()`方法中设置`inplace=True`

这里，在这个例子中，我们在Series.clip()方法中设置inpace=True。Series.clip()方法修剪值，但不会返回新的对象，因为参数 inplace 被设置为 True，而是返回None。见下面的例子。

#importing pandas library
import pandas as pd
series = pd.Series([8,-6,6,-1])
print("------Series--------")
print(series)
print("------After clipping the Series--------")
print(series.clip(-1,5,inplace=True))

-系列-
0 8
1 -6
2 6
3 -1
数据类型:int64
-剪裁系列后-
无

结论

在本教程中，我们学习了Series.clip()方法。我们学习了语法、参数，通过解决不同的例子，我们理解了Series.clip()方法。

posted @ 2024-10-24 18:15 绝不原创的飞龙阅读(6) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

StudyTonight-Python-中文教程-三-

StudyTonight Python 中文教程（三）

Pandas 数据帧join()方法

句法

参数

示例:使用DataFrame.join()方法连接两个数据帧

-数据帧为- A B 0 0 3 1 1 4

C D 0 0 3 1 1 4

示例:使用 lsuffix 和 rsuffix 连接两个数据帧

-数据帧为- A B 0 0 3 1 1 4

A B 0 0 3 1 1 4

示例:DataFrame.join()方法

-数据帧为- A B 0 0 3 1 1 4

A D 0 3 1 1 4

结论

Pandas 数据帧keys()方法

句法

示例:DataFrame.keys()方法

示例:使用DataFrame.keys()方法获取数据帧的索引信息

结论

Pandas 数据帧kurt()方法

句法

因素

示例:DataFrame.kurt() 方法

-数据帧为- A B C 0 55 30 12 1 60 55 55 2 74 40 44 3 50 47 66

示例:使用DataFrame.kurt() 方法的数据帧

示例:使用DataFrame.kurt() 方法的数据帧

结论

Pandas 数据帧kurtosis()方法

句法

因素

示例:DataFrame.kurtosis()方法

-数据帧为- A B C 0 55 30 12 1 60 55 55 2 74 40 44 3 50 47 66

示例:排除空值的数据帧

示例:仅包含数值的数据帧

结论

Pandas 数据帧last()方法

句法

因素

示例:使用DataFrame.last()方法获取最近n天的行

示例:使用DataFrame.last()方法获取最近n天的行

示例:使用DataFrame.last()方法获取最近n个月的行数

结论

Pandas 数据帧last_valid_index()方法

句法

例:DataFrame.last_valid_index() 法。

示例:获取 Pandas 中最后一个非空值的索引

示例:获取最后一个非空值的索引

结论

Pandas 数据帧le()方法

句法

因素

示例:使用DataFrame.le()方法将数据帧与常数进行比较

示例:使用DataFrame.le()方法将数据帧与系列进行比较

示例:使用DataFrame.le()方法将数据帧与其他数据帧进行比较

结论:

Pandas 数据帧lt()方法

句法

因素

示例:使用DataFrame.lt()方法将数据帧与常数进行比较

示例:使用DataFrame.lt()方法将数据帧与系列进行比较

示例:使用DataFrame.lt()方法将数据帧与其他数据帧进行比较

结论:

Pandas 数据帧mad()方法

句法

因素

示例:DataFrame.mad()方法

示例:沿column轴的DataFrame.mad()方法

示例:排除空值的DataFrame.mad()方法

结论

Pandas 数据帧max()方法

句法

因素

示例:查找数据帧的最大值

-数据帧为- A B C D 0 77 16 17 1 52 45 23 22 2 78 96 135 56

示例:在column轴上使用DataFrame.max()方法找到数据帧的最大值

-数据帧为- A B C D 0 0 77 16 17 1 52 45 23 22 2 78 96 135 56

示例:查找数据帧的最大值，包括空值

Pandas 数据帧`join()`方法

示例:使用`DataFrame.join()`方法连接两个数据帧

-数据帧为-
A B
0 0 3
1 1 4

C D
0 0 3
1 1 4

-数据帧为-
A B
0 0 3
1 1 4

A B
0 0 3
1 1 4

示例:`DataFrame.join()`方法

-数据帧为-
A B
0 0 3
1 1 4

A D
0 3
1 1 4

Pandas 数据帧`keys()`方法

示例:`DataFrame.keys()`方法

示例:使用`DataFrame.keys()`方法获取数据帧的索引信息

Pandas 数据帧`kurt()`方法

示例:`DataFrame.kurt()` 方法

-数据帧为-
A B C
0 55 30 12
1 60 55 55
2 74 40 44
3 50 47 66

示例:使用`DataFrame.kurt()` 方法的数据帧

示例:使用`DataFrame.kurt()` 方法的数据帧

Pandas 数据帧`kurtosis()`方法

示例:`DataFrame.kurtosis()`方法

-数据帧为-
A B C
0 55 30 12
1 60 55 55
2 74 40 44
3 50 47 66

Pandas 数据帧`last()`方法

示例:使用`DataFrame.last()`方法获取最近`n`天的行

示例:使用`DataFrame.last()`方法获取最近`n`天的行

示例:使用`DataFrame.last()`方法获取最近`n`个月的行数

Pandas 数据帧`last_valid_index()`方法

例:`DataFrame.last_valid_index()` 法。

Pandas 数据帧`le()`方法

示例:使用`DataFrame.le()`方法将数据帧与常数进行比较

示例:使用`DataFrame.le()`方法将数据帧与系列进行比较

示例:使用`DataFrame.le()`方法将数据帧与其他数据帧进行比较

Pandas 数据帧`lt()`方法

示例:使用`DataFrame.lt()`方法将数据帧与常数进行比较

示例:使用`DataFrame.lt()`方法将数据帧与系列进行比较

示例:使用`DataFrame.lt()`方法将数据帧与其他数据帧进行比较

Pandas 数据帧`mad()`方法

示例:`DataFrame.mad()`方法

示例:沿`column`轴的`DataFrame.mad()`方法

示例:排除空值的`DataFrame.mad()`方法

Pandas 数据帧`max()`方法

-数据帧为-
A B C D
0 77 16 17
1 52 45 23 22
2 78 96 135 56

示例:在`column`轴上使用`DataFrame.max()`方法找到数据帧的最大值

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

Pandas 数据帧`mean()`方法

-数据帧为-
A B C D
0 77 16 17
1 52 45 23 22
2 78 96 135 56

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

例子:Pandas 的`DataFrame.mean()`方法

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

示例:使用排除空值的`DataFrame.mean()`方法，找到数据帧的平均值

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

Pandas 数据帧`median()`方法

示例:使用`DataFrame.median()`方法获取`median`值

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

示例:使用`DataFrame.median()`方法获取`median`值

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

示例:使用`DataFrame.median()`方法获取`median`值

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

示例:使用`DataFrame.median()`方法获取`median`值

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

Pandas 数据帧`memory_usage()`方法

示例:使用`DataFrame.memory_usage()`方法获取内存使用情况

-数据帧为-
名称卷号
1 Abhishek 100
2 Anurag 101
3 Divya 104

示例:在`DataFrame.memory_usage()`方法中设置索引=假

-数据帧为-
int64 float 64
0 24 1.5
1 45 2.5
2 78 7.8
3 45 4.5

-数据帧为-
int 64 float 64
0 24 2.5
1 45 7.8
2 78 4.5

int 64 24
float 64 24
数据类型:int64

Pandas 数据帧`min()`方法

示例 1:使用`DataFrame.min()`方法找到最小值

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

示例 2:使用`DataFrame.min()`方法找到最小值

-数据帧为-
A B C D
0 0 77 16 17
1 52 45 23 22
2 78 96 135 56

示例 3:使用`DataFrame.min()`方法找到最小值

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NAn 45.0 23.0 22
2 78.0 NAn 56

示例 4:使用`DataFrame.min()`方法找到最小值

-数据帧为-
A B C D
0 0.0 77.0 16.0 17
1 NaN 45.0 23.0 22
2 78.0 NaN 56

Pandas 数据帧`mod()`方法

示例 1:使用`DataFrame.mod()`方法求模

示例 2:使用`DataFrame.mod()`方法求模

示例 3:使用`DataFrame.mod()`方法求模