python——pandas用法详解

2.2.10 DataFrame操作

2.2.10.1 列的选择、添加和删除

和Series一样，DataFrame也和字典类似，你可以在语义上将其视为Series对象的字典，这些Series对象共享相同的索引。获取、设置和删除列的语法与对应的字典操作相同：

d = {"one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),"two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"])}## # 没有传递索引和列，则结果的索引为各个Series索引的并集，列是字典的键df = pd.DataFrame(d)print(df)print(df['one'])df['three'] = df['one'] * df['two']df['flag'] = df['one'] > 2 #布尔print(df)

可以像字典操作那样将列删除或弹出：

del df['one']three = df.pop('three')print(three)

插入标量值时，这个值会填充整个列：

df['foo'] = 'bar'print(df)

当插入一个和DataFrame索引不同的Series时，只有匹配的标签的值会被保留，不在DataFrame索引中的标签值则被丢弃，Series索引中没有的标签值则设为NaN:

df['one_trunc'] = pd.Series([1,2,3,4], index=list('acef'))print(df)

也可以插入原始ndarray，但其长度必须与DataFrame索引的长度匹配:

df['array'] = np.array([5, 6, 7, 8])print(df)

默认情况下，列被插入到末尾，可以使用DataFrame.insert()方法在列中的特定位置插入：

Dataframe.insert(loc, column, value, allow_duplicates=False): 在Dataframe的指定列中插入数据。

参数介绍：

   loc:  int型，表示第几列；若在第一列插入数据，则 loc=0​   column: 给插入的列取名，如 column='新的一列'​   value：数字，array，series等都可（可自己尝试）​   allow_duplicates: 是否允许列名重复，选择Ture表示允许新的列名与已存在的列名重复。

df.insert(1, 'one','bar') #在第二列插入print(df)

2.2.10.2 在方法链中分配新列

DataFrame有一个assign()方法，可以轻松地创建从现有列派生的新列:

iris = pd.DataFrame({     'SepalLength': [5.1, 4.9, 4.7, 4.6, 5.0],     'SepalWidth': [3.5, 3.0, 3.2, 3.1, 3.6],     'PetalLength': [1.4, 1.4, 1.3, 1.5, 1.4],     'PetalWidth': [0.2, 0.2, 0.2, 0.2, 0.2],     'Name': 'Iris-setosa'})iris = iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength'])​print(iris)

也可以传递一个只接受一个参数的函数对象，在这个过程中，调用assign方法的DataFrame对象会被传递给这个函数，由这个函数产生新列：

iris = pd.DataFrame({     'SepalLength': [5.1, 4.9, 4.7, 4.6, 5.0],     'SepalWidth': [3.5, 3.0, 3.2, 3.1, 3.6],     'PetalLength': [1.4, 1.4, 1.3, 1.5, 1.4],     'PetalWidth': [0.2, 0.2, 0.2, 0.2, 0.2],     'Name': 'Iris-setosa'})# iris = iris.assign(sepal_ratio = iris['SepalWidth'] / iris['SepalLength'])iris = iris.assign(sepal_ratio=lambda x: (x['SepalWidth'] / x['SepalLength']))print(iris)

assing()返回的是数据的副本并插入新列，原始DataFrame保持不变。

assign()方法还有一个特性，它允许依赖赋值，在提供给assign方法的参数中，参数表达式是按顺序从左到右进行计算的，后面的表达式可以引用前面已经创建的列：

dfa = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})​print(dfa.assign(C=lambda x: x['A'] + x['B'], D=lambda x: x['A'] + x['C']))

2.2.10.3 索引/选择

基本的索引方式如下：

可以看到选择列还有一个语法df.col，而且列名col必须为有效的Python变量名才可以用这种语法。

data = {'one': np.array([1.0, 2.0, 3.0, 4.0]), 'two': np.array([4.0, 3.0, 2.0, 1.0])}pb = pd.DataFrame(data)# print(pb)​pc = pd.DataFrame(data, index=['a', 'b', 'c', 'd'])print(pc)​#选择列print(pc['one'])print(pc.one)​#按照标签选择行print(pc.loc['a'])print(pc.iloc[2])​#对行切片print(pc[:2])

还可以按照布尔值来取数据;

d = {"one": pd.Series([1.0, 2.0, 3.0], index=["a", "b", "c"]),"two": pd.Series([1.0, 2.0, 3.0, 4.0], index=["a", "b", "c", "d"])}## # 没有传递索引和列，则结果的索引为各个Series索引的并集，列是字典的键df = pd.DataFrame(d)print(df)print(df['one'])df['three'] = df['one'] * df['two']df['flag'] = df['one'] > 2print(df)​#按照布尔型取值print(df.flag)

2.2.10.4 数据对齐和算术运算

DataFrame对象之间的数据对齐在列和索引上自动对齐。与Series的数据对齐一样，生成的对象将具有列和行标签的并集。

df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])print(df)df2 = pd.DataFrame(np.random.randn(7, 3), columns=['A', 'B', 'C'])print(df2)print(df + df2)

在DataFrame和Series之间执行操作时，默认行为是在DataFrame列上的对齐Series索引，然后逐行广播，示例：

print(df - df.iloc[0])

与标量的算术运算则是按元素操作：

print(df * 5 - 2)print(1 / df)print(df ** 2)

布尔运算符也是按元素操作，对相同位置的元素做布尔运算：

df1 = pd.DataFrame({'a': [1, 0, 1], 'b': [0, 1, 1]}, dtype=bool)df2 = pd.DataFrame({'a': [0, 1, 1], 'b': [1, 1, 0]}, dtype=bool)print(df1 & df2)print(df1 | df2)print(df1 ^ df2)print(-df1)

2.2.10.5 装置

和ndarray一样，要进行转置，访问T属性或者调用DataFrame.transpose()方法：

print(df1.T)

2.2.10.6 DataFrame与NumPy函数的互操作

大多数NumPy函数可以在Series和DataFrame上直接调用:

df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])print(np.abs(df))print(np.square(df))print(np.asarray(df))

当传递两个pandas对象给NumPy函数时，会先进行对齐再执行函数操作：

numpy.remainder()是另一个用于在numpy中进行数学运算的函数，它返回两个数组arr1和arr2之间的除法元素余数，即arr1 % arr2 当arr2为0且arr1和arr2都是整数数组时，返回0。

ser1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])​ser2 = pd.Series([1, 3, 5], index=['b', 'a', 'c'])​print(np.remainder(ser1, ser2))

与Series一样，可以使用DataFrame.to_numpy()方法获得相应的ndarray：

df = pd.DataFrame(np.random.randn(10, 4), columns=['A', 'B', 'C', 'D'])print(df.to_numpy())

三、pandas的基本操作

3.1 导入常用库

import numpy as npimport pandas as pdimport matplotlib.pyplot as pltimport seaborn as snsimport warningsimport  sslwarnings.filterwarnings('ignore')​ssl._create_default_https_context = ssl._create_unverified_context

3.2 读写文件

读取CSV格式数据，使用 pd.read_csv()，写入文件使用DataFrame.to_csv()：

work_path = '../save_file/'os.chdir(work_path)#改变当前目录到work_pathprint(os.getcwd())#打印当前目录data = pd.read_csv(    'data.csv', encoding = 'utf-8', dtype = {'id':str, 'name':str,'age':int})  #读取data.csv文件print(data.head())data.to_csv('data_out.csv', encoding = 'utf-8')# 读到data_out.csv，没有文件的话自动创建

3.3 索引

直接索引时，列更容易定位和索引，似乎行只能连续索引，不能灵活索引：

print(data.columns)#显示列标签print(data['id'])#获取一列'user_id'print(data[['id','name']])#获取两列,这是用列表形式获取的两列，所以有2层方括号print(data[1:4])#获取1:3行,好像无法获取不连续的多行，需要用loc或iloc函数print(data[['id','name']][1:4])#获取两列,再获取这两列组成的dataframe的1:4行

3.4 通过loc函数索引

loc函数定位的是标签(index)，不是行的位置。loc函数的第一个参数是对行的操作，第二个参数是对列的操作。

print(data.loc[1:3, ['id','name']])#获取行标签为1:3,列标签为'id','name'的数据print(data.loc[data.id == '1', ['id','name']])#获id列中值为'1'的行，列标签为'user_id','name'的数据print(data.loc[data.age > 22, ])#age > 22的所有行print(data.loc[(data.age > 24) | (data.id == '1') ])#age > 24或id='1'的所有行

iloc函数定位的是行的位置。iloc函数的第一个参数是对行的操作，第二个参数是对列的操作。

print(data.iloc[[1, 3], 0:2 ])#获取第1行和第4行，0到2列print(data.iloc[[1, 3], [0, 2]])#获取第1行和第4行，0和2列

3.5 数据的增删

列的增加主要使用直接增加法，或者insert()方法，删除列主要使用drop、del方法。 行的删除也可以用drop方法，行的增加可以用_append在末尾加入，也有更好的方法。

tmp = data['age']data.insert(0,'copy购买量',tmp)#在数据中插入一列，名称‘copy购买量’，位置第0列，数字tmpprint(data)del data['copy购买量']#删除dataframe中名称为copy购买量的列data.insert(1, 'copy购买量', tmp)#在数据中插入一列，名称‘copy购买量’，位置第0列，数字tmpdata.insert(0, 'copy购买量1', tmp)#在数据中插入一列，名称‘copy购买量’，位置第0列，数字tmpdata.drop(labels = ['copy购买量', 'copy购买量1'], axis = 1, inplace = True)#上一行在数据中删除名称为'copy购买量', 'copy购买量1'的列，名称‘copy购买量’，axis = 1表示删除列，axis = 0表示删除行，inplace表示真实删除print(data.drop(labels = [0, 2], axis = 0, inplace = False))#删除行标签为0和2的行print(data.drop(labels = range(1, 3), axis = 0, inplace = False))#删除行标签1到2的行print(data._append(data))#在df的最后附加行

3.6 数据的修改和查找

用rename修改行标签或者列名称。 直接用df.series同==,>,<等逻辑运算符获取满足特定关系的df数据 也可以用between、isin方法获取在之间，匹配某些数量的数据

data.rename(columns = {'id':'用户ID'},inplace=True)#用rename修改列标签，使用字典的形式；data.rename(index = {1:11, 2:22}, inplace = True)#用rename修改行标签，使用字典的形式；print(data)data.loc[data['性别'] == 0, '性别'] = '女性'#将列标签为‘性别’的列中值等于0的元素，改为女性。data.loc[data['性别'] == 1, '性别'] = '男性'data.loc[data['性别'] == 2, '性别'] = '未知'print(data)print(data[data['age']>23])#获取名称为'age'列的数据中大于80的数据，会得到所有列print(data[(data['age'] < 23) & (data['性别'] == '男性')])print(data[data['age'].isin([12,21,20])])#age 列数值属于list[12,21,20]的数据

3.7 时间日期格式处理

使用df.to_datetime()处理pandas的各类字符串形式的时间； 使用pd.dt.strftime()处理datetime64或时间戳类型数据的以格式化字符串输出

start_datetime = np.arange('2021-11-01', '2021-11-10', dtype = 'datetime64[D]')#生成numpy起始时间序列end_datetime = np.arange('2021-11-01T12:14:30.789', '2021-11-10T12:14:30.789', 86400000, dtype = 'datetime64[ms]')segment_time = np.array([start_datetime, end_datetime]).T#建立一个起始时间的numpy数组df = pd.DataFrame(segment_time, columns = ['起始时间', '结束时间'])#新建dataframedf['持续时间'] = df['结束时间'] - df['起始时间']#增加一列持续的时间df['间隔时间'] = np.append((df['起始时间'].values[1:] - df['结束时间'].values[0:-1]), 0)#增加一列每两组之间间隔的时间df['start_time'] = df['起始时间'].dt.strftime('%A %B %d %Y %H:%M:%S.%f')#把datetime64格式转换成规定格式字符串时间df['end_time'] = df['结束时间'].dt.strftime('%a %b %d %Y %H:%M:%S.%f')df['读入起始时间'] = pd.to_datetime(df['start_time'], fORMat = '%A %B %d %Y %H:%M:%S.%f')df['读入结束时间'] = pd.to_datetime(df["end_time"], format = '%a %b %d %Y %H:%M:%S.%f')print(df)#建立df的另外一种方法：start_datetime_char = np.datetime_as_string(start_datetime, unit = 'ms')#numpy里的datetime64转换为字符串,改格式不方便end_datetime_char = np.datetime_as_string(end_datetime, unit = 'ms')#转换为字符串df_char = pd.DataFrame(start_datetime_char, columns = ['起始时间'])df_char['结束时间'] = end_datetime_charprint(df_char)

对datetime64使用pd.dt.date/time/year/month/wedk/weekday/day/hour/min/second 对timedelta64使用pd.dt.days/total_seconds() 对datetime64使用pd.dt.dayofyear/weekofyear

df_char['date_time'] = pd.to_datetime(df['结束时间'], format = '%Y-%m-%dT%H%M%S.%f')df_char['年'] = df_char['date_time'].dt.yeardf_char['周'] = df_char['date_time'].dt.isocalendar().weekdf_char['周几'] = df_char['date_time'].dt.weekdaydf_char['分'] = df_char['date_time'].dt.minutedf_char['秒'] = df_char['date_time'].dt.seconddf_char['微秒'] = df_char['date_time'].dt.microseconddf_char['总秒数'] = df['间隔时间'].dt.total_seconds()#不要忘了括号df_char['总天数'] = (df['间隔时间']).dt.days#不用括号df_char['加天序列后总天数'] = (df['间隔时间'] + np.arange(0, 9, 1, dtype = 'timedelta64[D]')).dt.days#不用括号#上面的增加np.arange()主要是用来增加间隔天数，以使显示的天数由变化。pd.set_option('display.max_columns', None)#设置pandas显示选项，以便显示所有列。print(df_char)

3.8 数据堆叠和合并

使用concat()将两个dataframe横向堆叠或纵向堆叠 使用merge()将两个dataframe按照主键合并

merge1 = pd.concat([df, df_char], axis = 0, join = 'outer')#使用列表堆叠，0轴沿着纵向拓展，即行数增加，inner表示不一致的删除，outer表示不一致的保留merge2 = pd.concat([df, df_char, data], axis = 1, join = 'outer')#使用列表堆叠，0轴沿着横向拓展，即列数增加merge3 = pd.merge(left = df, right = df_char, how = 'inner', left_on = '结束时间', right_on = 'date_time')#按照df[结束时间]和df[date_time]这两个主键关联merge4 = pd.merge(left = df, right = df_char, how = 'inner', left_on = '起始时间', right_on = 'date_time')#按照df[起始时间]和df[date_time]这两个主键关联，由于不相等且是inner模式，所以会清空所有数据merge5 = pd.merge(left = df, right = df_char, how = 'outer', left_on = '起始时间', right_on = 'date_time')#按照df[起始时间]和df[date_time]这两个主键关联，由于不相等但是是outer模式，所以会保留所有数据​print(merge1)print(merge2)print(merge3)print(merge4)print(merge5)

3.9 字符串处理

主要用到的函数名称即说明如下： pd.str. contains() 返回表示各str是否含有指定模式的字符串 。 replace() 替换字符串 lower() 返回字符串的副本,其中所有字母都转换为小写。 upper() 返回字符串的副本,其中所有字母都转换为大写。 split() 返回字符串中的单词列表。 strip() 删除前导和后置空格。 join() 返回一个字符串,该字符串是给定序列中所有字符串的连接。 还有一个判断是否包含空元素的函数pd.isnull()，经常会需要和T、any()联合起来使用 ∙ \bull ∙使用df.fillna/df.age.fillna来替换缺失值

df1 = pd.read_csv('MotorcycleData.csv', encoding = 'gbk')print(df1['Price'].str[0])#pd.str可以用切片方式实现索引print(df1['Price'].str[:2])df1['价格'] = df1['Price'].str.strip('$')#删去头尾的'$'符号df1['价格'] = df1['价格'].str.replace(',', '')#删去','符号df1['价格'] = df1['价格'].astype(int)# print(df1.info())# print(df1[['Price', '价格']])df1['位置'] = df1['Location'].str.split(',')#通过字符串中“，”将其分割成一个字符串列表# print(df1['位置'].str[1])#打印出这个列表中的第一个字符串元素# print(df1['Location'].str.len())#获取字符串长度df1.loc[df1[['Location']].isnull().T.any()] = 'aaa'#将'Location'这列中是空数据的填上字符串，避免字符串判断时出现空值而报错#上面的例子中df1[['Location']]必须用两层中括号，这样结果是DataFrame类，如果是df1['Location']就是series类了#非转置：df1.isnull().any()，得到的每一列求any()计算的结果，输出为列的Series。#转置：df1.isnull().T.any()，得到的每一行求any()计算的结果，输出为行的Series。#这里要知道那一行有Nan，所以要用转置print(df1[df1[['Location', '价格']].isnull().T.any()]['Location'])#检查'Location和价格'这两列中是是否有空数据 #替换缺失值用df.fillna更方便df1.fillna('datamiss', inplace = True)print(df1.loc[df1['Location'].str.contains('New Hampshire'), 'Location'])#找出数据中包含特定字符串的数据

3.10 数据统计和排序

数据统计信息显示采用discribe()方法； 数据排序使用: ∙ \bullet ∙ sort_values(by, axis=0, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’),基于某几行或列的值进行排列 ∙ \bullet ∙ sort_index(axis=0, level=None, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’, sort_remaining=True, by=None)，基于行或列标签进行排列

print(df1.describe())#只对数字类参数有用，输出每一列的均值、标准差、最大、最小值和25%/50%/75%的值print(df1.sort_index(axis = 1))print(df1.sort_values(by = ['Bid_Count', 'Price']))#根据指定的列名称及其优先级顺序，对整个列表进行排序。

3.11 读取txt文件

读取txt文件可以用read_csv也可以用read_table，前置默认以逗号分隔，后置必须指定分隔符。前者也可以用sep参数来指定分隔符。

数据排序使用:

dtxt = pd.read_table('sample_data_out.txt', encoding = 'gbk', header = 0, sep = ' ')dtxt = pd.read_csv('sample_data_out.txt', encoding = 'gbk', header = 0, sep = ' ')'''上面的两句功能基本相同'''print(dtxt.iloc[:,0].str.split(','))#手动分隔，结果是两层列表print(dtxt.columns.str.split(',')[0])#手动分隔列名称，结果是两层列表dtxt_deal = (dtxt.iloc[:,0].str.split(',')).apply(pd.Series, index = dtxt.columns.str.split(',')[0])dtxt_deal['buy_mount'] = dtxt_deal['buy_mount'].astype(int)print(dtxt_deal.info())

来源地址：https://blog.csdn.net/longhaierwd/article/details/131904699