dataframe中加入series python dataframe,series

pandas主要有两个数据结构：series和dataframe

一、序列

import numpy as np
import pandas as pd

obj = pd.Series([2,1,4,3])
obj.values  ##序列的值
obj.index   ##序列的索引
obj[2]  
obj2 = pd.Series([4,3,5,2],index = ['a','b','c','d'])  ##给序列添加索引
obj2[['b','a']]
obj2[obj2>3]
obj2*2
np.exp(obj2)
'b' in obj2
'e' in obj2
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}  ##将字典直接传入序列
obj3 = pd.Series(sdata)   
states = ['California', 'Ohio', 'Oregon', 'Texas']   
obj4 = pd.Series(sdata, index=states)
##判断序列是否存在缺失值
pd.isnull(obj4)
pd.notnull(obj4)
obj4.isnull()

obj3 + obj4  ##序列的对齐功能
obj4.name = 'population'   ##命名
obj4.index.name = 'state'
obj4.name
obj4.index.name

二、dataframe

##dataframe
data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002, 2003],
        'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)
frame.head()  ##查看前5行
pd.DataFrame(data,columns = ['year','state','pop'])
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
                     index=['one', 'two', 'three', 'four',
                            'five', 'six'])  #传入的列没有值会显示nan
frame2
frame2.index
frame2.columns
frame2.isnull()
pd.isnull(frame2)
pd.notnull(frame2)
frame2.year
frame2['year']
frame2.loc['three']  ##取第二行
frame2.iloc[2,:]   #取第二行
frame2['debt'] = 16.5
frame2['debt'] = np.arange(6.)
##将序列赋值传入
val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])
frame2['debt'] = val
frame2
frame2['eastern'] = frame2.state == 'Ohio'
frame2
del frame2['eastern']  ##删除列
frame2.columns

三、其他数据形式

##其他数据形式
pop = {'Nevada': {2001: 2.4, 2002: 2.9},
      'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = pd.DataFrame(pop)  #如果嵌套字典传给DataFrame，pandas就会被解释为：外层字典的键作为列，内层键则作为行索引：
frame3 
frame3.T  ##转置

pdata = {'Ohio': frame3['Ohio'][:-1],
         'Nevada': frame3['Nevada'][:2]}
pd.DataFrame(pdata)
frame3.values
frame3.index
frame2.values

四、索引对象--index

 

 

 五、基本功能

1.重新索引

#重新索引
obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
obj.reindex(['a','b','c','d'])
#对于时间序列这样的有序数据，重新索引时可能需要做一些插值处理。method选项即可达到此目的，例如，使用ffill可以实现前向值填充
obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4]) 
obj3.reindex(range(6),method = 'ffill') ##method = ffill:向前填充

frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
                     index=['a', 'c', 'd'],
                     columns=['Ohio', 'Texas', 'California'])

frame2 = frame.reindex(['a','b','c','d'])
frame2
state = ['Ohio','pop','Texas','California']
frame3 = frame2.reindex(columns = state)
frame3

2.drop

obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
obj
new_obj = obj.drop('c')
new_obj
obj.drop(['d', 'c'])

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=['Ohio', 'Colorado', 'Utah', 'New York'],
                      columns=['one', 'two', 'three', 'four'])

data.drop(['Ohio', 'Colorado'])
data.drop('two',axis = 1)
data.drop(['two', 'four'], axis='columns')

3.索引、选取和过滤

##索引、选取、过滤
obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])
obj['b']
obj[1]
obj[2:4]
obj[['b', 'a', 'd']]
obj[[1, 3]]
obj[obj < 2]
obj['b':'c']  ##利用标签的切片运算与普通的Python切片运算不同，其末端是包含的：
obj['b':'c'] = 5 
obj
data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                 index=['Ohio', 'Colorado', 'Utah', 'New York'],
                   columns=['one', 'two', 'three', 'four'])
data['two']   ##选取单一列
data[['three', 'one']]  ##选取多列
data[:2]  ##选择行
data[data['three'] > 5]  ##选择多行
data[data<5] = 0  ##通过布尔型DataFrame（比如下面这个由标量比较运算得出的）进行索引
data

##使用轴标签（loc）或整数索引（iloc）
data.loc['Colorado', ['two', 'three']]
data.iloc[2, [3, 0, 1]]  #整数索引从0开始
data.iloc[2]  #第二行
data.iloc[2,3]   #第二行第三列
data.iloc[[1, 2], [3, 0, 1]]
data.loc[:'Utah', 'two']
data.iloc[:, :3][data.three > 5]

4.算术运算和数据对齐

##算术对齐
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  #自动的数据对齐操作在不重叠的索引处引入了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 = pd.DataFrame({'A': [1, 2]})
df2 = pd.DataFrame({'B': [3, 4]})
df1 - df2

#在算术方法中填充值
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.add(df2)  ## 会产生nan值
df1.add(df2, fill_value=0)  ##没有nan值，指定一个填充值0。
1/df1
df1.div(1)  ##df1/1
df1.rdiv(1)   ##1/df1
df1.rsub(1)   ##1-df1
df1.sub(1)    ##df1-1

df1.reindex(columns=df2.columns, fill_value=0) ##在对Series或DataFrame重新索引时，也可以指定一个填充值：

 

 

 5.DataFrame和Series之间的运算

arr = np.arange(12.).reshape((3, 4))
arr
arr[0]
arr-arr[0]  ##广播
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                      columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])

series = frame.iloc[0]
frame - series  ##DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播：
series2 = pd.Series(range(3), index=['b', 'e', 'f'])
frame + series2  ##如果某个索引值在DataFrame的列或Series的索引中找不到，则参与运算的两个对象就会被重新索引以形成并集：
series3 = frame['d']
frame.sub(series3, axis='index') ##如果你希望匹配行且在列上广播，则必须使用算术运算方法。

6.函数的应用和映射

frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
                     index=['Utah', 'Ohio', 'Texas', 'Oregon'])
frame
np.abs(frame)

f = lambda x: x.max() - x.min()
frame.apply(f)  #各列的最大值减去最小值
frame.apply(f,axis = 'index')   ##列
frame.apply(f, axis='columns')   ##行执行


def f(x):
    return pd.Series([x.min(), x.max()], index=['min', 'max'])

frame.apply(f)  ##返回每列的多个值
frame.apply(f,axis = 'columns')    #每行

format = lambda x: '%.2f' % x   #frame中各个浮点值的格式化字符串，使用applymap即可：
frame.applymap(format)  

frame['e'].map(format)  ##之所以叫做applymap，是因为Series有一个用于应用元素级函数的map方法：
##frame.map(format)  错误

 7.排序和排名

##排序和排名
##按索引排序
obj = pd.Series(range(4),index = ['b','a','c','d'])
obj.sort_index()
obj.sort_values()
frame = pd.DataFrame(np.arange(8).reshape(2,4),index=['three', 'one'],
                     columns = ['d','a','b','a'])
frame.sort_index()    ##默认对行排序
frame.sort_index(axis = 1)  ##1是对列排序，0是对行排序
frame
frame.sort_index(axis = 1,ascending = False)  ##默认是升序，即ascending = True

#按值排序
obj = pd.Series([4, 7, np.nan,-3, 2])
obj.sort_values()   #缺失值会放在最后
frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})
frame.sort_values(by='b',ascending = False)
frame.sort_values(by=['a', 'b'])

##rank:返回排序的序号
obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj.rank() ##默认按照平均值排序
obj.rank(method='first')  #值在原数据中出现的顺序给出排名
obj.rank(ascending=False, method='max')  #按照降序排名，返回出现的最大排名
frame = pd.DataFrame({'b': [4.3, 7, -3, 2], 'a': [0, 1, 0, 1],
                      'c': [-2, 5, 8, -2.5]})
frame.rank(axis = 0)
frame.rank(axis = 1)