18个 Pandas中的重要函数
数据处理是分析数据的一个重要部分。这包括各种任务，如清理、重组、合并、删除重复数据、删除空值或纳数值等。Pandas提供了大量的函数来进行各种数据预处理任务。
Pandas提供了两种类型的数据结构来处理数据，包括系列和数据框架。
在过去的两年里，我一直在学习和探索Pandas和其他Python库。
任何你能在excel中完成的任务都可以用Pandas完成。
在这个故事中，我策划了一个列表，列出了我在数据预处理任务中最经常使用的18个函数。
- DataFrame.select_dtypes( )。
根据列dtypes返回DataFrame的列的子集。
当你想只选择那些具有特定数据类型的列或具有特定数据类型的值时很有用，例如："object", "int64" , np.number等。
语法:
DataFrame.select_dtypes(include = “reqd dtype”, exclude = “reqd dtype”)
Example :
#create DataFrame-----------------
df = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["A","B" , "C", "D", "E"],
'rebounds': [11, 8, 10, 6, 6]})
#checks column datatype--------------------
df.info()
#selecting reqd datatype----------------------
df.select_dtypes(include = "int64")
Output :
- DataFrame.drop_duplicates( ) :
从数据框架中移除重复的行，通常用于数据清理任务。在我们的数据集中保留重复的值会影响到进一步产生的洞察力，所以数据清理对于避免误判非常重要。
语法:
DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)
参数：
subset : 只考虑某些列来识别重复，默认使用所有的列。
keep : 可以考虑{'first', 'last', False}，默认考虑False。这个参数用来决定哪些重复的内容应该被考虑。如果你想保留第一个出现的值，那么keep = 'first'，否则是'last'，默认为False，保留所有重复的值。
inplace : 它决定是处理数据框架中的变化还是返回一个副本。
inplace = True意味着在当前数据框架中进行变化，inplace = False意味着返回一个副本并保持当前数据框架的原样。默认为false。
ignore_index : 如果是True，产生的轴将被标记为0，1，...，n-1。 默认情况下ignore_index = False。
例子
#create DataFrame----------------------------
df = pd.DataFrame({'points': [25, 12, 15, 14, 19,25,12,14],
'Player': ["A","B" , "C", "D", "E","A","B","D"],
'rebounds': [11, 8, 10, 6, 6,11,8,6]})
#drop duplicates-----------------------------------
df = df.drop_duplicates(subset = ["Player"],
keep ="first",
ignore_index = False)
df
Output:
- DataFrame.str.lower( ) :
将系列/索引中的字符串转换为小写。同样地，对于大写字母，我们可以使用DataFrame.str.upper()。
语法:
#create DataFrame-
df = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["ADam","BOB" , "COT", "DerrICK","EtHan"],
'Team' : ["a","B","C","d","e"],
'rebounds': [11, 8, 10, 6, 6]})
#converting column values of Player and Team into lowercase
#将球员和球队的列值转换为小写字母
columns = df.select_dtypes(include = 'object')
columns = list(columns.columns)
for i in columns:
df[i] = df[i].str.lower()
df
Output :
- Series.str.match() :
Series.str.match()
函数用于确定一个给定的系列对象中的数据是否与正则表达式匹配。
语法 :
Series.str.match(pat, case=True, flags=0, na=None)
参数 :
pat : 字符序列或正则表达式。
case : 如果是True，则区分大小写。默认为True。
flags : int，默认为0。
na : 缺失值的填充值。默认值取决于数组的dtype。对于对象dtype，使用numpy.nan。
例子:
city = pd.Series(['Kolkata','Delhi','Mumbai', 'Sikkim','Bangalore'])
index = ["City_1","City_2","City_3","City_4","City_5"]
city.index = index
city
res = city.str.match(pat = '(Ranchi)|(Mumbai)')
res
res = city.str.match(pat = '([A-Z]a.)')
res
- pd.set_option( ) :
data = {"Score" : [10, 15, 2, 31, 4,
51, 26, 17, 28, 29],
"Player" : ['A', 'B', 'C', 'D', 'E',
'F', 'G', 'H', 'I', 'J']}
df = pd.DataFrame(data)
df
pd.set_option("display.max_rows", 5)
df
pd.set_option( ) can also be used to format high number decimal points/scientific notation to normal notation.
Example :
import numpy as np
import pandas as pd
df = pd.DataFrame({
'Name': ['a', 'b', 'c','d','e','f','g'],
'Value': np.random.rand(7)**3
})
df
#formatting upto 2 decimal places
pd.set_option('display.float_format', lambda x: '%0.2f' % x)
df
Output :
- df.iteritems( ) :
用于遍历（列名，系列）对。遍历DataFrame的列，返回一个包含列名和内容的系列的元组。
iteritems()方法生成了一个DataFrame的迭代器对象，允许我们迭代DataFrame的每一列。
例子创建DataFrame
#create DataFrame
df = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["Adam","Bob","Cot","Derrick","Ethan"],
"Team" : ["a","B","C","d","e"],
'rebounds': [11, 8, 10, 6, 6]})
Iterate over columns :
for x, y in df.iteritems():
print(x)
print(y)
Output :
- df.iterrows( ) :
有时我们需要在不使用循环的情况下迭代一个数据框架的行和列，df.iterrows( )在这种情况下非常有用。以（索引，系列）对的形式遍历DataFrame的行。
例子创建DataFrame
#create DataFrame
df = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["Adam","Bob","Cot","Derrick","Ethan"],
"Team" : ["a","B","C","d","e"],
'rebounds': [11, 8, 10, 6, 6]})
#Iterating over DataFrame rows
for i in df.iterrows():
print(i)
Output :
- df.itertuples( ) :
语法:
DataFrame.itertuples(index=True, name='Pandas')
默认情况下，索引=True，名称='Pandas'。
迭代DataFrame的行，作为命名的图元的值。
一个对象用于迭代DataFrame中每一行的命名图元，第一个字段可能是索引，后面的字段是列值。
例子#创建DataFrame
df = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["Adam","Bob","Cot","Derrick","Ethan"],
"Team" : ["a","B","C","d","e"],
'rebounds': [11, 8, 10, 6, 6]})
for row in df.itertuples():
print(row)
Output :
- df.reset_index( ) :
Pandas reset_index()用于重置数据帧的索引。
reset_index()方法设置一个从0到数据长度的整数列表作为索引。
df = pd.read_csv('customer_data.csv')
Setting column “Name” as index:
df.set_index(["Name"], inplace = True)
df
Resetting index :
df.reset_index()
- df.astype( ) :
DataFrame.astype()函数对于我们想要将一个特定的列数据类型转换为另一个数据类型非常有用。
语法:
DataFrame.astype(dtype, copy=True, errors='raise')
参数
dtype : 使用numpy.dtype或Python类型来将整个pandas对象转换为相同的类型。或者，使用{col: dtype, ...}，其中col是一个列标签，type是numpy.dtype或Python类型，将DataFrame的一个或多个列转换为特定的列类型。
copy : 通过，默认为True。当copy=True时返回一个副本（设置copy=False要非常小心，因为对数值的改变可能会传播到其他pandas对象）。
错误：默认为'raise'。控制对所提供的dtype的无效数据引发的异常。
raise : 允许异常被提出
ignore : 抑制异常的产生。错误时返回原始对象。
例子:
df = pd.read_csv("employees.csv")
df
df.info()
改变'Team'和'Salary'列的dtype -----------
df = df.astype({"团队":'类别', "工资":'int64'})
Example :
df = pd.read_csv("employees.csv")
df
df.info()
#changing the dtype of columns 'Team' and 'Salary'-
df = df.astype({"Team":'category', "Salary":'int64'})
- pd.concat( ) :
沿着一个特定的轴将pandas对象串联起来，沿其他轴可选择设置逻辑。
也可以在串联轴上添加一层分层索引，如果标签在传递的轴号上相同（或重叠），这可能很有用。
语法:
pandas.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False, copy=True)
参数:
objs：一个序列或系列或数据框架对象的映射。
如果传递了映射，排序后的键值将被用作键值参数，除非它被传递，在这种情况下，值将被选择。任何None对象将被无声地丢弃，除非它们都是None，在这种情况下将引发ValueError。
axis：默认为0。要连接的轴。可以是0表示沿索引，1表示沿列。
join : {'inner', 'outer'}, default 'outer'.
ignore_index : bool, 默认为False。
如果为真，则不使用连接轴上的索引值。如果你在连接对象时，连接轴上没有有意义的索引信息，那么这一点很有用。注意其他轴上的索引值在连接中仍然被尊重。
- keys : sequence, default None
如果传递多个层次，应该包含图元。使用传递的key作为最外层的层次来构建层次索引。
6.level : 序列的列表，默认为无
构建MultiIndex时要使用的特定层次（唯一值）。否则它们将从键中推断出来。
names : 列表，默认无。由此产生的分层索引中各层的名称。
verify_integrity : bool, 默认为 False
检查新的串联轴是否包含重复的内容。相对于实际的数据串联，这可能是非常昂贵的。sort : bool, default False
对非串联轴进行排序，如果它在join为'外'时还没有被对齐。当join='inner'时，这没有影响，它已经保留了非连接轴的顺序。
例子Example :
import pandas as pd
df1 = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["Adam","Bob","Cot","Derrick","Ethan"],
'rebounds': [11, 8, 10, 6, 6]})
df2 = pd.DataFrame({'points': [15, 22, 75, 84, 29],
'Player': ["A","B" , "C", "D", "E"],
'rebounds': [18, 38, 90, 56, 36]})
Concatenating df1 and df2:
# Concating both the dataframes
pd.concat([df1,df2])
Assigning keys to the dataframes after concatenation :
df_concat = pd.concat([df1, df2], keys=['Set1', 'Set2'])
df_concat
The index of both the sets is duplicated. So, usingignore_index = True :
df_concat = pd.concat([df1, df2],keys=['Set1','Set2'], ignore_index=True)
df_concat
Adding the second DataFramedf2 along axis = 1:
df_concat = pd.concat([df1, df2], keys=['Set1', 'Set2'], axis=1)
df_concat
# 串联两个数据框
pd.concat([df1,df2])
在串联后给数据帧分配键。
df_concat = pd.concat([df1, df2], keys=['Set1', 'Set2'])
df_concat
这两个集合的索引是重复的。所以，使用ignore_index = True :
df_concat = pd.concat([df1, df2], keys=['Set1', 'Set2'], ignore_index=True)
df_concat
沿着轴=1添加第二个DataFramedf2。
df_concat = pd.concat([df1, df2], keys=['Set1', 'Set2'], axis=1)
df_concat
结合具有重叠列的DataFrame对象，并通过将inner传递给join关键字参数，只返回那些共享的对象。
import pandas as pd
df1 = pd.DataFrame({'points': [25, 12, 15, 14, 19],
'Player': ["Adam","Bob","Cot","Derrick","Ethan"],
'rebounds': [11, 8, 10, 6, 6]})
df2 = pd.DataFrame({'points': [15, 22, 75, 84, 29],
'Player': ["A","B" , "C", "D", "E"],
'rebounds': [18, 38, 90, 56, 36],
'Overs':[25, 12, 15, 14, 19]})
df_concat = pd.concat([df1, df2], join = 'inner')
df_concat
- df.describe( ) :
describe()函数用于生成描述性统计，包括那些总结数据集分布的中心趋势、分散度和形状的统计，不包括NaN值。
它可以分析数字和对象序列，以及混合数据类型的DataFrame列集。输出结果因所提供的数据而异。
语法。
DataFrame.describe(percentiles=None, include=None, exclude=None)
参数。
1.百分位数：类似数据类型的0-1之间的数字列表。
2.包括。描述数据框架时要包含的数据类型列表。
- 排除。在描述数据框架时要排除的数据类型列表。
例子 :
df2 = pd.DataFrame({'points': [15, 22, 75, 84, 29],
'Player': ["A","B" , "C", "D", "E"],
'rebounds': [18, 38, 90, 56, 36],
'Overs':[25, 12, 15, 14, 19]})
df2.describe()
- df.isnull( ).sum( ) :
在分析数据之前，去除缺失值，计算缺失值及其百分比是很重要的识别方法。
df.isnull().sum()函数用来计算每一列中缺失值的数量。
使用的数据：沃尔玛销售预测 | Kaggle
df = pd.read_csv('features.csv')
df.isnull().sum()
- pd.isna( ) :
检测一个数组类对象的缺失值。
这个函数接收一个标量或类似数组的对象，并指示值是否缺失（数字数组为NaN，对象数组为None或NaN，数据时间为NaT）。
对于标量输入，返回一个标量布尔值。对于数组输入，返回一个布尔数组，表示每个相应的元素是否丢失。
df.isna()
在有空值时返回True，在没有空值时返回False。
- pd.to_datetime( ) :
将参数转换为日期时间。
该函数将标量、数组类、系列或DataFrame/dict类转换为pandas日期时间对象。
s = pd.Series(['5/10/2022', '5/10/2022', '5/10/2022'] * 100)
s
将系列s的数据类型从对象改为日期时间。
pd.to_datetime(s)
- df.isin( ) :
isin()函数可以通过一个列表来检查数据框架/系列中是否存在列表中的值。
例子:
s = pd.Series(['5/10/2022', '5/11/2022', '5/12/2022'] * 100)
lst = ['5/10/2022']
s.isin(lst)
如果值存在，返回True，如果没有找到值，返回False。
- df.pivot( ) :
返回按给定索引/列值组织的重塑数据框架。
重塑数据产生一个基于列值的 "透视 "表。使用指定的索引/列的唯一值来形成生成的DataFrame的轴。此函数不支持数据聚合，多个值将导致列中的多重索引。
语法 Syntax :
DataFrame.pivot(index=None, columns=None, values=None)
Example :
df2 = pd.DataFrame({'points': [15, 22, 75, 84, 29],
'team': ["A","B" , "C", "D", "E"],
'player':['Adam','Tom','Jerry','Harry','Jon']})
df2
pivot_df2 = df2.pivot(index = 'player',columns = 'team',
values ['points'])
pivot_df2 = pivot_df2.fillna('-')
pivot_df2
- df.insert ( ) :
将列插入到DataFrame的指定位置。如果列已经包含在DataFrame中，会引发ValueError，除非allow_duplicates被设置为True。
参数 Parameters :
loc : dtype is int, Insertion index. Must verify 0 <= loc <= len(columns).
2. column: str, number, or hashable object. Label of the inserted column.
3. value : Scalar, Series, or array-like
4. allow_duplicates: bool, optional default False
Syntax :
DataFrame.insert(loc, column, value, allow_duplicates=False)
Example :
df.insert(2,'age',[45,34,23,34,56,55,45,30,33])
df
总是参考Pandas文档以获得深入的理解。用户指南 - pandas 1.4.2 文档 (pydata.org)
