Series

1. 定义Series：

  • 可以传入一个列表 [1,2,3,4]
  • 可以传入一个字典 {'a':1,'b':2,'c':3},如果传入字典则key为索引列
obj1=pd.Series([9,2,4,3],index=['a','b','c','d']) #列表创建需要指定索引
obj1

a    9
b    2
c    4
d    3
dtype: int64

2. 方法：

  • isnull(): 判断是否为空. pd.isnull(series)
  • notnull(): 判断是否不为空　pd.notnull(series)　
sdata={'hanson':18,'Carter':19,'Tim':22,'Michael':10}
obj2 = pd.Series(sdata)
obj2
hanson     18
Carter     19
Tim        22
Michael    10
dtype: int64

pd.isnull(obj2)

hanson     False
Carter     False
Tim        False
Michael    False
dtype: bool

　　

　　

DataFrame

1. 定义dataframe：

  • 最常用的是传入一个由多个等长列表或者Numpy数组组成的字典
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)

In [45]: frame
Out[45]: 
   pop   state  year
0  1.5    Ohio  2000
1  1.7    Ohio  2001
2  3.6    Ohio  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002
5  3.2  Nevada  2003
  • 定义DataFrame最常用的属性有index, columns，分别制定DataFrame的行和列名。

　　

sdata = {'name':['hanson','carter','tim','jason'],
'age':[18,18,19,20],
'sex':['male','male','female','female']}

df2=pd.DataFrame(sdata,columns=['name','hige','sex','age'],index=['zero','one','two','three'])
df2

　　

 

2. 常用方法：

  • reindex : 重新定义索引列，自动和原来的索引列做匹配，无法匹配上的value值为NaN。默认是修改索引列，如果增加columns=参数则可以修改列名称。df.reindex(['a','b','c']) 或者 df.reindex(columns=['col1','col2','col3'])
  • drop:  删除行或者列。axis=0 为删除指定行，axis=1为删除指定列。df.drop(['a','b'],axis==0) 或 df.drop(['col1','col2'],axis=1)
  • loc: 根据行名和列名筛选数据。 df.loc[行名称,列名称]
one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

In [137]: data.loc['Colorado', ['two', 'three']]
Out[137]: 
two      5
three    6
Name: Colorado, dtype: int64

　　

  • iloc: 根据行号和列号筛选数据。 df.iloc[行号,列号]
In [140]: data.iloc[[1, 2], [3, 0, 1]]
Out[140]: 
          four  one  two
Colorado     7    0    5
Utah        11    8    9
  • 加减乘除 + - * / : 两个DataFrame做加减乘除操作的时候，有交集的部分会做运算，没有交集的部分会自动取并集并自动写NaN作为值。　　
  • add/radd, sub/rsub, mul/rmul, div/rdiv, floordiv/rfloordiv, pow/rpow: 两个DataFrame做加减乘除操作的时候，有交集的部分会做运算，没有交集的部分会自动取并集并填写原来各自DataFrame的值。
  • apply : DataFrame可以使用apply方法调用其他方法
In [190]: frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'),
   .....:                      index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [192]: np.abs(frame)
Out[192]: 
               b         d         e
Utah    0.204708  0.478943  0.519439
Ohio    0.555730  1.965781  1.393406
Texas   0.092908  0.281746  0.769023
Oregon  1.246435  1.007189  1.296221

In [193]: f = lambda x: x.max() - x.min()

In [194]: frame.apply(f)
Out[194]: 
b    1.802165
d    1.684034
e    2.689627
dtype: float64

In [195]: frame.apply(f, axis='columns')
Out[195]:
Utah      0.998382
Ohio      2.521511
Texas     0.676115
Oregon    2.542656
dtype: float64

　　

  • sort_index() : 按照索引或者表头排序. df.sort_index(axis=0/1,ascending=False) ，默认为升序，参数ascending=False为降序　　
  • sort_values() : 按照指定的一个或者多个列排序. df.sort_values(by=列名)
In [211]: frame = pd.DataFrame({'b': [4, 7, -3, 2], 'a': [0, 1, 0, 1]})

In [212]: frame
Out[212]: 
   a  b
0  0  4
1  1  7
2  0 -3
3  1  2

In [213]: frame.sort_values(by='b')
Out[213]: 
   a  b
2  0 -3
3  1  2
0  0  4
1  1  7

In [214]: frame.sort_values(by=['a', 'b'])
Out[214]: 
   a  b
2  0 -3
0  0  4
3  1  2
1  1  7
  • is_unique :  可以用来判断索引是否重复 df.index.is_unique --- True/False　　
  • 其他计算方法：
  • unique()  : 得到Series中的唯一值数组。
In [251]: obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
In [252]: uniques = obj.unique()

In [253]: uniques
Out[253]: array(['c', 'a', 'd', 'b'], dtype=object)