Pandas入门——Series和DataFrame的创建、索引、基本操作

Pandas

Pandas基于Numpy构建，是数据分析的核心模块，可直接读取数据进行处理，兼容各种数据库，支持各种分析算法。因为之前了解到Python安装Pandas很慢，所以直接下载了Anaconda，感觉自己很机智哈哈哈！
因为各种镜像源都挂了，下载真的好慢，所以分享一个Anaconda3-5.1.0-Windows-x86_64网盘链接：https://pan.baidu.com/s/1Pj6Kmk6Tur3iMXLxxcRGJA
Series和DataFrame是Pandas中最主要的两种数据结构，个人抽象理解为带索引的一维数组和带索引的表格。

Series

Series类似一维数组，由带索引index的一组values构成，values可以是任何数据类型。可以将Series理解为带索引的ndarray，也可以将Series理解为有顺序的dict字典。
s.index可以查看索引，是pandas中所有对象都具有的属性，返回索引的生成器
s.values可以查看值，返回numpy.ndarray，默认数据类型是float64
name是数据表名称属性，可以看作数据表的表名

import numpy as np
import pandas as pd
ar=np.random.rand(10)
s=pd.Series(ar,name='Series s')
print(ar,type(ar))
print(s,type(s))
print('------------')
print(s.index)# index可以看做标签的生成器，所有pandas中的数据结构都有index
print(list(s.index),type(s.index))
print(s.values,type(s.values))#values实际上是numpy.ndarray

生成Series

• 公式
  pd.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
  index默认从0编号，可以自定义list，index可以不唯一，但尽量唯一
  dtype与data的数据类型相同，一般默认float64

• 创建
  Series可以通过字典、一维数组、标量来创建。
  字典创建时，字典的key是Series的index，字典的values是Series的values。
  一维数组创建时，自定义index必须和values长度相同。
  标量创建时，index长度是values长度。

#用字典创建
dic={'a':1,'b':2,'c':3}
s=pd.Series(dic)
print(s)
#用一维数组创建
ar=np.random.rand(5)*100
s=pd.Series(ar,index=list('abcde'))
print(s)
#标量创建
s=pd.Series(100,index=range(4))
print(s)

Series索引

和ndarray，list类似，可以使用位置下标、标签、切片、bool索引。
需要注意多个标签需要用s[[‘a’,‘b’]]，索引顺序不一定要按照index顺序

# 位置下标
s=pd.Series(np.random.rand(5)*10,index=list('abcde'))
print(s)
print(s[0])#位置下标从0开始
print(s[3],type(s[3]),s[3].dtype)
# 不能被逆序排列print(s[-1])

#标签索引
print(s['a'])
print(s[['c','a']])#多个标签需要用[[]]表示列表，索引顺序不一定要按照series的顺序

#切片
print(s[1:3])#位置索引左闭右开，不含右侧边际
print(s['b':'d'])#index索引闭区间
print(s[:2])

#添加空值
# (None代表空值，NaN代表有问题的数值，两个都会识别为空值)
print('---------')
s['a']=None
print(s)
s[2]=np.nan
print(s)
#.isnull() 空值为Ture/ .notnull()非空为True 
print(s.isnull())
print(s.notnull())

#bool型
print(s>3)
print(s[s>1])
print(s[s.isnull()])
print(s[s.notnull()])

Series基本操作

• 查看数据头尾
  s.head() 查看数据头，默认查看5行，可赋值
  s.tail(3) 查看数据尾，默认查看5行，可赋值
• 依据索引排序 s.reindex()
  保留已有索引及对应value，增加不存在索引及对应values为空值NaN

# reindex 依据索引重新排序，而非重命名索引index，也增加index数目
s=pd.Series(np.random.rand(5))
print(s)
s1=s.reindex([0,2,1,'a','b'])#保留数据已有索引，不存在索引返回空值NaN
print(s1)
s2=s.reindex([0,2,1,'a','b','c'],fill_value=1)#保留数据已有索引，不存在索引返回fill_value
print(s2)

#将series作为参数调用Series无法改变原有对象索引
s3=pd.Series(s,index=list('abcde'))
print(s3)

#改变原有对象的索引
s.index=['a','b','c','d','e']
print(s)
'''
0    0.996371
1    0.274122
2    0.688167
3    0.813712
4    0.780905
dtype: float64
0    0.996371
2    0.688167
1    0.274122
a         NaN
b         NaN
dtype: float64
0    0.996371
2    0.688167
1    0.274122
a    1.000000
b    1.000000
c    1.000000
dtype: float64
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
dtype: float64
a    0.996371
b    0.274122
c    0.688167
d    0.813712
e    0.780905
dtype: float64
'''

• 对齐
  只保留两个Series中都存在的index对应的数据，其余填充NaN

s1=pd.Series(np.random.rand(3),index=['a','b','c'])
s2=pd.Series(np.random.rand(3),index=['b','c','d'])
print(s1+s2)#缺失值将显示Nan
'''
a         NaN
b    0.674737
c    1.297640
d         NaN
'''

• 删除 s.drop
  drop默认inplace=False生成新对象，若inplace=True则更改原有对象
  drop的参数是index的索引名
  多个参数需要增加[]，作为list参数

s=pd.Series(np.random.rand(5),index=[0,1,2,'a','b'])
print(s)
s1=s.drop(0)#drop默认inplace=False生成新对象，若inplace=True则更改原有对象
s2=s.drop([0,'a','b'])#drop多个元素需要列表作为参数
print(s1)
print(s2)
'''
dtype: float64
0    0.525237
1    0.082962
2    0.826343
a    0.644302
b    0.942987
dtype: float64
1    0.082962
2    0.826343
a    0.644302
b    0.942987
dtype: float64
1    0.082962
2    0.826343
'''

• 添加和修改 s.append

s1=pd.Series(np.random.rand(5))
print(s1)
s1[4]=5 #如果series中存在该索引则更改对应values 
print(s1)
s1[[1,5]]=0#如果series中不存在该索引则增加索引及value
print(s1)
s2=pd.Series({'a':1,'b':2,'c':3})
print(s1.append(s2))#append可以增加一个series，指向新数组
print(s1)

• 运算
  将计算结果返回新对象，不改变原有series

s=pd.Series([1,2,3,4,5])
print(s)
print(s+2)
print(s*2)
print(s/2)#除
print(s**2)# 幂

DataFrame

Dataframe是一个表格型的数据结构，包含一组有序的列，每一列的数据类型可以不同，可以是数值、字符串、布尔值等。
Dataframe中index是索引，columns是列标签（key），values是值。

df = pd.DataFrame({'name':['Alice','Bob','Cathy'],
                   'gender':['female','male','female'],
                   'score':[40,70,80],
                   'valid':[False,True,True]})
print(df)
print(type(df))
print('index\n',df.index,type(df.index),list(df.index))#RangeIndex
print('columns\n',df.columns,type(df.columns))#Index
print('values\n',df.values,type(df.values))#ndarray
'''
  name  gender  score  valid
0  Alice  female     40  False
1    Bob    male     70   True
2  Cathy  female     80   True

index
 RangeIndex(start=0, stop=3, step=1)  [0, 1, 2]
columns
 Index(['name', 'gender', 'score', 'valid'], dtype='object') 
values
 [['Alice' 'female' 40 False]
 ['Bob' 'male' 70 True]
 ['Cathy' 'female' 80 True]] 
'''

创建

DataFrame创建主要通过dict和二维数组，也可以通过由字典组成的列表或由字典组成的字典。

dict创建DataFrame

当使用dict组成DataFrame时，dict的key对应dataframe的columns，具体可以分为以下两种情况：

• dict的values是list或者np.ndarray
  1、dict的key对应dataframe的columns
  2、dict不同key对应各个value的长度相同
  3、columns不能改变，可以增删，新标签值为NaN
  4、index可以被改变但不能增减，必须与dict中value长度相同。
• dict的value是Series
  1、dict的key对应dataframe的columns，key对应的Series的index是生成dataframe的index
  2、dict不同key对应Series的长度不必相同
  3、columns不能改变，可以增删，新标签对应NaN
  4、当dict中的Series标签相同且长度相同时，可以声明时赋值index，当Series长度不同，标签不同，生成datafram可以看作并集，没有对应index标签的values被赋值NaN。
  5、有标签的Series的index可以增删，新标签对应NaN。

#dict的values是list
dict1={'a':[1,2,3,4],'b':[2,3,4,5],'c':[3,4,5,6]}#字典中值必须相同长度
print(data1)
print(pd.DataFrame(dict1))
print(pd.DataFrame(dict1,index=['aaa','bbb','ccc','ddd']))#index必须与行数相同
print(pd.DataFrame(dict1,columns=['a','b','d']))#colums参数选择部分列,如果有不存在的参数时则填充NaN

#dict的values是np.ndarray
dict2={'x':np.random.rand(3),'y':np.random.rand(3)}
print(dict2)
print(pd.DataFrame(dict2))
'''
{'a': [1, 2, 3, 4], 'b': [2, 3, 4, 5], 'c': [3, 4, 5, 6]}
   a  b  c
0  1  2  3
1  2  3  4
2  3  4  5
3  4  5  6
     a  b  c
aaa  1  2  3
bbb  2  3  4
ccc  3  4  5
ddd  4  5  6
   a  b    d
0  1  2  NaN
1  2  3  NaN
2  3  4  NaN
3  4  5  NaN
{'x': array([0.64433399, 0.55618886, 0.74822528]), 'y': array([0.41651619, 0.66279534, 0.37896431])}
          x         y
0  0.644334  0.416516
1  0.556189  0.662795
2  0.748225  0.378964
'''

#dict的value是Series，不同key对应的Series的长度不必一样

#两个Series的标签相同且长度相同，无自定义index则默认从0开始编号
dict1={'X':pd.Series(np.random.rand(4)*10),
      'Y':pd.Series(np.random.rand(4)*10)}
print(pd.DataFrame(dict1))

#Series中如果自定义index，则生成的dataframe的index也变成series中自定义
dict2={'X':pd.Series(np.random.rand(4)*10,index=list('abcd')),
      'Y':pd.Series(np.random.rand(4)*10,index=list('abcd'))}
print(pd.DataFrame(dict2))

#两个Series长度不同，标签不同，生成datafram可以看作并集
#没有对应index标签的values被赋值NaN
dict3={'X':pd.Series(np.random.rand(4),index=list('abcd')),
      'Y':pd.Series(np.random.rand(3),index=list('abe'))}
print(pd.DataFrame(dict3))
print(pd.DataFrame(dict3,index=['a','b',0]))
print(pd.DataFrame(dict3,columns=['X']))
'''
X         Y
0  1.346173  2.366167
1  0.507209  5.003882
2  3.113913  5.879678
3  8.061057  9.573074
          X         Y
a  0.718481  7.559523
b  3.376450  8.906252
c  8.825367  3.104184
d  4.299418  3.715730
          X         Y
a  0.610915  0.267013
b  0.993462  0.987552
c  0.793687       NaN
d  0.728292       NaN
e       NaN  0.228734
          X         Y
a  0.610915  0.267013
b  0.993462  0.987552
0       NaN       NaN
          X
a  0.610915
b  0.993462
c  0.793687
d  0.728292
'''

二维数组创建DataFrame

因为DataFrame可以被看做一个表格，二维数组创建方法最便于理解，即数组作为构造函数的data，为其添加行索引index和列索引columns。

• ndarray的行对应dataframe的index，列对应columns
• 构造函数中index和columns应于ndarray的形状对应
• index和columns可以通过赋值改变，但不能增删。

ar=np.random.rand(12).reshape(4,3)
#默认index和columns索引都从0排序
df1=pd.DataFrame(ar)
print(df1)
#index长度必须和二维数组行数相同，columns长度必须和二维数组列数相同
df2=pd.DataFrame(ar,
                index=['a','b','c','d'],
                columns=['x','y','z'])
print(df2)
'''
   0         1         2
0  0.256452  0.550808  0.619352
1  0.529326  0.734800  0.450460
2  0.392424  0.273264  0.928764
3  0.771616  0.772426  0.594913
          x         y         z
a  0.256452  0.550808  0.619352
b  0.529326  0.734800  0.450460
c  0.392424  0.273264  0.928764
d  0.771616  0.772426  0.594913
'''

其他

• 字典组成的字典
  1、字典组成的字典，外层字典长度可不同
  2、字典最外层的key对应dataframe的columns
  3、字典内层的key对应dataframe的index
• 字典组成的列表
  1、字典的长度可以不相同
  2、字典dict的key是dataframe的columns
  3、列表每一个元素（dict），是dataframe的一行数据

#字典组成的字典
data = {'Jack':{'math':90,'english':89,'art':78},
       'Marry':{'math':82,'english':95,'art':92},
       'Tom':{'math':78,'english':67}}
df1 = pd.DataFrame(data)
print(df1)
'''
 Jack  Marry   Tom
math       90     82  78.0
english    89     95  67.0
art        78     92   NaN
'''
#字典组成的列表
data = [{'a': [1,2], 'b': [2,3]}, {'a': 6, 'b': 7, 'c': 8}]
print(pd.DataFrame(data))
'''
   a       b    c
0  [1, 2]  [2, 3]  NaN
1       6       7  8.0’
'''

DataFrame 索引

将DataFrame理解为表格，每一行是一组数据，每一列是一个字段

直接索引

单个标签索引，多个标签索引，切片索引。
按columns选择列：df[‘a’]单独一列为Series，df[[‘a’,‘b’]]选择多列为dataframe。
按index索引名选择行df.loc[1:3]:单独选择一行为Series，选择多行为dataframe
按index位置坐标选择行df.iloc[0:3]:行标从0开始标号

# 直接索引选择列
df=pd.DataFrame(np.random.randint(1,100,size=(4,5)),columns=list('abcde'))
print(df)
#直接索引为选择列,不能增加新的列
print(df['a'],type(df['a']))
print(df[['a','b']],type(df[['a','b']]))
'''
  a   b   c   d   e
0  40  86  98  82  81
1  37  28  52  32  68
2  40  56  52  33  46
3  61  49  58  64  83
0    40
1    37
2    40
3    61
Name: a, dtype: int32 
    a   b
0  40  86
1  37  28
2  40  56
3  61  49 
'''
#选择行
#df.loc索引选择行，选择一行为series，多行为DataFrame
df=pd.DataFrame(np.random.randint(1,100,size=(4,5)),
                columns=list('abcde'),index=('AAA','BBB','CCC','DDD'))
print(df)
print(df.loc['AAA'])#单个标签索引
print(df.loc[['DDD','AAA']])#多个标签索引
print(df.loc['AAA':'CCC'])#切片索引

#df.iloc[]按照整数位置（0开始）选择行
print(df.iloc[0:3])
print(df.iloc[-1])
'''
 a   b   c   d   e
AAA  65  22  92  89  34
BBB  57  69  51  11  79
CCC  87  75  87   8  89
DDD  70  20  75  62  12
a    65
b    22
c    92
d    89
e    34
Name: AAA, dtype: int32
      a   b   c   d   e
DDD  70  20  75  62  12
AAA  65  22  92  89  34
      a   b   c   d   e
AAA  65  22  92  89  34
BBB  57  69  51  11  79
CCC  87  75  87   8  89
      a   b   c   d   e
AAA  65  22  92  89  34
BBB  57  69  51  11  79
CCC  87  75  87   8  89
a    70
b    20
c    75
d    62
e    12
Name: DDD, dtype: int32
'''

bool型索引

在进行单列判断的时候，不保留全部数据，结果只保留判断列中满足条件的对应行。
其他情况均返回所有数据，但False对应空值NaN。

#bool型索引
df=pd.DataFrame(np.random.randint(1,100,size=(3,4)),
                index=['x','y','z'],columns=list('abcd'))
print(df)
#所有元素
#结果保留所有元素，不满足条件显示NaN
print(df[df>50],'\n')#所有大于50

#单列判断(唯一不保留全部数据)
#结果只保留判断列中满足条件的对应行
mask1=df['a']>50
print(mask1)
print(df[mask1],'\n')

#多列判断
#结果保留所有元素，True显示元素，其余均为NaN
mask2=df[['a','b']]>30
print(mask2)
print(df[mask2],'\n')#单列判断，保留满足判断条件的对应行

#多行判断
mask4 = df.loc[['x','y']] < 50
print(mask4)
print(df[mask4]) 
'''
  a   b   c   d
x   6  39  76  81
y  13   2  80  35
z  61  88  17  43
      a     b     c     d
x   NaN   NaN  76.0  81.0
y   NaN   NaN  80.0   NaN
z  61.0  88.0   NaN   NaN 

x    False
y    False
z     True
Name: a, dtype: bool
    a   b   c   d
z  61  88  17  43 

       a      b
x  False   True
y  False  False
z   True   True
      a     b   c   d
x   NaN  39.0 NaN NaN
y   NaN   NaN NaN NaN
z  61.0  88.0 NaN NaN 

      a     b      c      d
x  True  True  False  False
y  True  True  False   True
      a     b   c     d
x   6.0  39.0 NaN   NaN
y  13.0   2.0 NaN  35.0
z   NaN   NaN NaN   NaN
'''

多重索引

bool型索引、行索引、列索引可以复合使用，先列索引后行索引。

df=pd.DataFrame(np.random.randint(1,100,size=(3,4)),
                index=['x','y','z'],columns=list('abcd'))
print(df)
print(df['a'].loc[['x','y']])
print(df[['b','c','d']].iloc[0:3])
print(df[df['a']>20].iloc[:2])
'''
  a   b   c   d
x  83  19  12  35
y  63  17  83  92
z  30  93  65  71
x    83
y    63
Name: a, dtype: int32
    b   c   d
x  19  12  35
y  17  83  92
z  93  65  71
    a   b   c   d
x  83  19  12  35
y  63  17  83  92
'''

DataFrame基本操作

• 查看数据
  基本同Series，使用df.head()查看前五行，df.tail()查看末尾五行，df.T生成一个转置后的新对象。

df=pd.DataFrame(np.random.randint(1,100,size=(6,5)),
                columns=list('abcde'))
print(df)
print(df.T)#转置生成新对象
print(df.head())#head读取前5行，默认参数是5行
print(df.tail(2))#tail读取末尾2行

• 添加与修改
  当使用新的行索引或列索引时，增加该行/列，可以通过使用标量或者使用list（长度相同）的方法。
  而如果索引已存在，则对原油数据进行修改。

df=pd.DataFrame(np.random.randint(1,100,size=(3,4)),
                columns=list('abcd'))
print(df)
#增加行或列
df.loc[4]=20#使用标量增加行
df['e']=[10,20,30,40]#使用list增加列
print(df)
#赋值修改
df['a']=10
df['e'].loc[4]=0
print(df)
'''

   a   b   c   d
0  10  40  39  52
1  60   6  11  15
2   9  80  30  56
    a   b   c   d   e
0  10  40  39  52  10
1  60   6  11  15  20
2   9  80  30  56  30
4  20  20  20  20  40
    a   b   c   d   e
0  10  40  39  52  10
1  10   6  11  15  20
2  10  80  30  56  30
4  10  20  20  20   0
'''’

• 删除
  del删除一列，drop根据参数删除行或列。
  df.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors=‘raise’)
  axis=0，默认删除行，axis=1删除列
  inplace=False，默认生成新对象，inplace=True则改变原有对象。

df=pd.DataFrame(np.random.randint(1,100,size=(3,4)),columns=list('abcd'))
print(df,'\n')
#删除列 del 
del df['a']
print(df,'\n')

#drop关键参数axis inplace
df2=df.drop(0)#默认删除行 默认创建新对象
print(df2)
print(df,'\n')
df3=df.drop('b',axis=1)#axis=1删除列，默认创建新对象
print(df3)
df4=df.drop('b',axis=1)#axis=1删除列，默认创建新对象
print(df4,'\n')
df.drop('b',axis=1,inplace=True)#inplace=True则改变原有对象
print(df)

• 对齐
  两组数据不必形状相同，只保留索引相同位置的数据叠加，缺失填充NaN

df1 = pd.DataFrame(np.random.randn(3,4), columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randn(4,5), columns=['A', 'B', 'C','D','E'])
print(df1 + df2)
''

          A         B         C         D   E
0 -0.606321  0.375047 -0.163161 -2.222533 NaN
1  1.654818 -0.061153 -0.729434  1.265396 NaN
2 -1.059547  1.270026  1.139287 -0.282398 NaN
3       NaN       NaN       NaN       NaN NaN
'''

• 排序
  df.sort_values 按所选列的值排序，ascending=True默认升序，inplace=False默认生成新对象。
  df.sort_index索引排序，默认升序，指向新对象。当索引为数值类则按大小排序，当索引为字母则按字母排序

#按值排序.sort_values，默认升序，指向新对象
df = pd.DataFrame(np.random.rand(3,4)*100, columns=['A', 'B', 'C', 'D'])
print(df)
#按照所选列，排序整个表格
print(df.sort_values(['A'],ascending=True))#升序
print(df)
df.sort_values(['A'],ascending=False,inplace=True)#降序
print(df)
#列中存在相同值的时候，可以多列排序

#索引排序.sort_index，默认升序，指向新对象
df=pd.DataFrame(np.random.rand(3,4)*100,
               index=[2,3,1])
print(df)
print(df.sort_index())#按index升序排列，如果是字母则按字母排序
df.sort_index(inplace=True,ascending=False)
print(df)