pandas入门

最新推荐文章于 2022-03-16 14:00:32 发布

内卷炼丹师

最新推荐文章于 2022-03-16 14:00:32 发布

阅读量178

点赞数

分类专栏：用python进行数据分析

本文链接：https://blog.csdn.net/qq_44878792/article/details/107420552

版权

用python进行数据分析专栏收录该内容

4 篇文章 0 订阅

订阅专栏

panda的数据结构

Series

series的字符串表现形式和字典差不多，有索引和值（类似于键值对），当不给索引的参数时默认索引是0，1，2、、、N-1

obj = pd.Series([4,7,-5,3])
obj.values
#输出是：array([4,7,-5,3])

下例是给予索引参数：

obj2 = pd.Series([4,7,-5,3],['d','b','a','c'])

索引

obj2['a']

改value

obj2['c']=6

筛选值

obj2[obj2>0]

对每一个value进行一些函数运算

obj2*2
np.exp(obj2)

将字典作为输入变成series的数据结构

obj3 = pd.Series(sdata)
#sdata是一个字典

改变index的两种方法（仅当没有指定index或是字典可以修改index)

obj3.index=['as','df','qw','er']

obj3 = pd.Series(sdata,index=['as','df','qw','er'])

给Series取名字

obj3.name='populayion'

给Series的index取名字

obj3.index.name='pop'

DataFrame

一个简单的例子：

data = {'states' : ['Ohio','Ohio','Ohio','Nevada','Nevada','Nevada'],
           'year':[2000,2001,2002,2001,2002,2003],
           'pop':[1.5,1.7,3.6,2.5,2.7,3.2]}
frame = pd.DataFrame(data)
#可以加上columns =['states','year','pop']来指定排序顺序，也可以用参数index来添加索引

如果传入的列columns中有数据中不存在的列，则返回中产生缺失值

通过类似字典标记的方式，可以将DataFrame的列获取为一个Series

frame['state']
frame.year

形似的方法可以得到行

frame.loc['index']

添加或改变列的值

frame['states']=
#右侧可以是值，数组或者Series(两个索引会匹配，匹配不了的会被填上缺失值）

用del可以用来删除一列

del frame['states']

另一种形式是嵌套字典

pop = {'Nevada':{2000:2.4,2002:2.9},
          'Ohio':{2000:1.5,2001:1.7,2002:2.6}}
 #嵌套字典的键作为index，当然也可用index=的参数来指定
 frame = pd.DataFrame(pop)
 frame.T   #行列反转

由Series组成的字典和嵌套字典操作类似

frame.values会以ndarray的形式返回

索引对象

给定索引的DataFrame不能修改index

基本操作

重新索引

obj = pd.Series([4.5,7.2,-5.3,6.4],index=['d','b','a','c'])
obj2 = obj.reindex(['a','b','c','d'])

对于时间序列这样的有序数据，需要再reindex中增加参数method='ffill’

frame = pd.DataFrame(np.arrange(9).reshape((3,3)),
                                        index=['a','c','d'],
                                        columns=['Ohio','Texas','Californial'])
frame.reindex(['a','b','c','d'])
frame.reindex(columes=['year','month','day'])

丢弃指定轴上的项

frame.drop(['a','b']  #删除行
frame.drop(['Ohio','Texas',axis=1)  #删除列
#往drop函数里添加参数inplace=True,表示从frame中彻底删除

索引，选取和过滤

Series的切片操作和普通python切片的不同之处

obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj[2:4]   #得到的是第三个和第四个不包括第二个
obj['b':'c']  #b和c都包括了

另一种方法是用布尔型DataFrame进行索引
如data>5,返回的是满足大于5的值变成true，其他变成false
data[data<5]=0,小于5的值变成0，其他不变

用loc和iloc进行选取（对于DataFrame数据

data.loc['Colorado', ['two', 'three']]       #是字符串时用loc，是数字时用iloc,且前一个参数表示行，后一个参数表示列
data.iloc[2, [3, 0, 1]]
data.iloc[2]
data.iloc[[1, 2], [3, 0, 1]]
data.loc[:'Utah', 'two']
data.iloc[:, :3][data.three > 5]    #布尔型用来过滤行

整数索引（对于Series数据

ser = pd.Series(np.arange(3.))
ser
ser2 = pd.Series(np.arange(3.), index=['a', 'b', 'c'])
ser2[-1]  #如果没有指定Index，那么该方法可能产生错误，这种情况应该用loc
ser[:1]
ser.loc[:1]  #包括第一行和第二行
ser.iloc[:1]

算数运算和数据对齐


s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],
               index=['a', 'c', 'e', 'f', 'g'])
s1
s2
s1 + s2        #得到的结果是index的并集，对于不重叠的索引引入NA值

df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
                   index=['Ohio', 'Texas', 'Colorado'])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                   index=['Utah', 'Ohio', 'Texas', 'Oregon'])
df1
df2
df1 + df2   #得到的是行和列的并集，行和列都相同的值相加，其他的都变成NAN

df1 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'B': [3, 4]})
df1
df2
df1 - df2  #df1的列名是A，df2的列名是B，因此得到的都是NAN

在算数方法中填充值

df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),
                   columns=list('abcd'))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),
                   columns=list('abcde'))
df2.loc[1, 'b'] = np.nan
df1
df2
df1 + df2
df1.add(df2, fill_value=0)    #两者中其中一个没有的部分看作0，再相加

df1.reindex(columns=df2.columns, fill_value=0)    #变成和df2一样的4*5的结构，没有的部分用0填充

DataFrame和Series之间的运算

arr = np.arange(12.).reshape((3, 4))
arr
arr[0]
arr - arr[0]    #每一行都减去第一行，这也叫广播broadcasting

frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                     columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.iloc[0]
frame
series
frame - series   #每一行减去第一行
series2 = pd.Series(range(3), index=['b', 'e', 'f'])
frame + series2  #列名称的并，重叠部分相加，不重叠部分用NA填充

series3 = frame['d']     #取其中一列'd'
frame
series3
frame.sub(series3, axis='index')    #每一列减去列'd',并且可以改为axis=0

函数应用和映射

frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame
np.abs(frame)     #把frame中的每个值都取绝对值
f = lambda x: x.max() - x.min()
frame.apply(f)     #在每列执行该函数
frame.apply(f, axis='columns')   #在每行执行该函数

def f(x):
    return pd.Series([x.min(), x.max()], index=['min', 'max'])     #传递到apply的函数可以返回由多个值组成的Series
frame.apply(f)

format = lambda x: '%.2f' % x
frame.applymap(format)     #保留两位小数的浮点数，用applymap可以得到frame中各个浮点值的格式化字符串
frame['e'].map(format)       #列e保留两位小数

排序和排名

obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
obj.sort_index()           #对index进行排序
frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                     index=['three', 'one'],
                     columns=['d', 'a', 'b', 'c'])
frame.sort_index()
frame.sort_index(axis=1)            #对列名进行排序
frame.sort_index(axis=1, ascending=False)       #降序排列

obj = pd.Series([4, 7, -3, 2])
obj.sort_values()    #对value的值进行排序
frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame
frame.sort_values(by='b')      #对列‘b’的value的值进行排序
frame.sort_values(by=['a', 'b'])    #对列a和列b的value的值进行排序

带有重复标签的轴索引

#汇总和计算描述统计

df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=['a', 'b', 'c', 'd'],
                  columns=['one', 'two'])
df
df.sum()                    #按列进行求和
df.sum(axis='columns')     #按行进行求和，不全是NA值时把NA值看成0，全是NA值则返回NA值，也可换成axis=1 
df.mean(axis='columns', skipna=False)    #存在NA值就要返回NA值
df.idxmax()    #得到最大值的索引
df.cumsum()    #按列计算的累计值
df.describe()       #按列得到一些汇总统计
obj = pd.Series(['a', 'a', 'b', 'c'] * 4)
obj.describe()