【原】《利用Python进行数据分析》学习笔记之Pandas基础

1. Series

类似于一维数组的对象： 由一组数据（各种numpy对象）和一组与之相关的索引组成。分别有两个属性，.values 和 .index

(1)创建Series

• 直接定义,包括定义index
• 输入一个dict，转成Series

import pandas as pd
from pandas import DataFrame,Series
import numpy as np
from numpy import random
#直接定义Series
obj=Series([-4,7,8,9],index=[‘a‘,‘b‘,‘c‘,‘d‘])
#用字典创建Series
dict={‘a‘:-4,‘b‘:7,‘c‘:8,‘d‘:9}
obj1=Series(dict)

（2）利用索引查找数据

obj[‘a‘]
obj[[‘a‘,‘b‘]]

a   -4
b    7
dtype: int64

（3）利用布尔型索引过滤数据

obj[obj>0]

b    7
c    8
d    9
dtype: int64

（4）Series自动对齐不同索引数据

• 重传index到已有index的Series,或者dict中，则values会自动与index对齐。（找不到values的index,会填充NAN）

#在有index的Series传入index
obj1=Series(obj,index=[‘c‘,‘d‘,‘e‘,‘f‘])   
#在有index的dict传入index
obj2=Series(dict,index=[‘c‘,‘d‘,‘e‘,‘f‘]) 

2. DataFrame

是表格型数据结构，含有一组有序的列，每列可以是不同的值类型。
可看作是由一组Series组成(共用同一个索引)

(1)创建DataFrame

• 直接定义,,包括index,columns
• 输入一个有列表或者numpy数组的dict，转成DataFrame

#直接定义
data = [[1,2,3],[4,5,6]]
index = [0,1]
columns=[‘a‘,‘b‘,‘c‘]
df = pd.DataFrame(data=data, index=index, columns=columns)
#利用dict转成DataFrame
dict={‘a‘:[1,2,3],‘b‘:[4,5,6],‘c‘:[7,8,9]}
df1=DataFrame(dict,index=[‘one‘,‘two‘,‘three‘])

（2）利用列名取数据

• 通过列名或者属性的方式可以从DataFrame获取一组Series

df1[‘a‘]
df1.a

one      1
two      2
three    3
Name: a, dtype: int64

(3)赋值、创建新列

df1[‘a‘]=1
df1[‘d‘]=4

(4)删除列

del df1[‘d‘]

3.Series和DataFrame基本功能

(1)重新索引

df2=df1.reindex(index=[‘two‘,‘one‘,‘four‘,‘three‘],columns=[‘b‘,‘c‘,‘a‘,‘e‘],fill_value=22)
print (df2)

        b   c   a   e
two     5   8   1  22
one     4   7   1  22
four   22  22  22  22
three   6   9   1  22

df3=df2.drop(‘four‘)
df3=df2.drop(‘e‘,axis=1)

s1=df3[‘b‘]
s1[‘two‘]
s1[[‘two‘,‘one‘]] # 用数组列出，要用[ ]括起来
s1[‘two‘:‘four‘]  # 标签切片的右区间是闭合的
s1[1:3]           # 标号切片的右区间是开放的

one      4
four    22
Name: b, dtype: int64

df3[‘b‘]
df3[[‘b‘,‘c‘]]

df3.loc[[‘two‘,‘one‘]]   #索引多行，行名用数组
df3.loc[‘two‘:‘three‘]   #索引多行，行名用切片
df3.loc[‘two‘,[‘b‘,‘a‘]] #索引某行多列，列名用数组
df3.loc[‘two‘,‘b‘:‘a‘]   #索引某行多列，列名用切片
df3.loc[:,[‘b‘,‘a‘]]     #索引某列

df3.iloc[1:3,1:3]

df3[df3[‘a‘]<2]  #先用某一列过滤，返回一个布尔数组，然后通过布尔数组再过滤行

df3[df3<2]=0 #选取特定的值重新赋值

s1 = df3.loc[‘two‘]
s2 = df3[‘b‘]

# df4=df3+s1
df4=df3.add(s1)
print (df3)
print (s1)
print (df4)

        b   c   a
two     5   8   0
one     4   7   0
four   22  22  22
three   6   9   0
b    5
c    8
a    0
Name: two, dtype: int64
        b   c   a
two    10  16   0
one     9  15   0
four   27  30  22
three  11  17   0

df5=df3.add(s2,axis=0) #指定s2的索引是匹配行标签，则是按列广播
print (df3)
print (s2)
print (df5)

        b   c   a
two     5   8   0
one     4   7   0
four   22  22  22
three   6   9   0
two       5
one       4
four     22
three     6
Name: b, dtype: int64
        b   c   a
two    10  13   5
one     8  11   4
four   44  44  44
three  12  15   6

df3.sort_index()  #默认axis=0,按行标签排序
df3.sort_index(axis=1,ascending=False)  #按列标签排序

df3.sort_values(by=‘b‘)

df3.rank(axis=0,method=‘first‘) # axis=0 为按列排名， axis=1 为按行排名

obj=Series([‘a‘,‘a‘,‘c‘,‘d‘,‘e‘,‘a‘,‘b‘])
obj.unique()  # 返回的是一个nparray

array([‘a‘, ‘c‘, ‘d‘, ‘e‘, ‘b‘], dtype=object)

obj1=obj.value_counts()  #常用于统计某个离散值各个类别的频率
print(obj1)

a    3
d    1
c    1
b    1
e    1
dtype: int64

obj2=obj.isin([‘b‘,‘c‘])
print(obj2)

0    False
1    False
2     True
3    False
4    False
5    False
6     True
dtype: bool

import numpy as np
from numpy import nan as NA
data=Series([1,NA,3.5,NA,10])
data.dropna()         #用.dropna（）的方法
data[data.notnull()]   #通过布尔索引来过滤

0     1.0
2     3.5
4    10.0
dtype: float64

df3[‘d‘]=NA
df4=df3.dropna(axis=1)   #axis=0 为丢掉所有含NAN的行，axis=1 为丢掉所有含NAN的列
df4=df3.dropna(how=‘all‘)  # how=‘all‘
df4=df3.dropna(thresh=2)  

df3[‘d‘]=[6,7,8,9]
df3.iloc[0:2,2:4]=NA

df3.fillna(1)    #可对所有缺失值赋值
df3.fillna({‘a‘:4,‘d‘:5}) #可用词典对不同的列填充不同的值

data=Series(np.random.randn(6),index=[[‘a‘,‘a‘,‘b‘,‘b‘,‘c‘,‘c‘],[1,2,1,2,1,2]])
print(data)

a  1   -2.403726
   2    0.534817
b  1    1.007619
   2   -0.555399
c  1   -0.715177
   2   -0.850348
dtype: float64

data[‘a‘:‘b‘]
data.loc[[‘a‘,‘c‘]]
data.loc[:,2]    #类似DataFrame中先选行再选列，在层次化索引中先选外层再选内层

a    0.534817
b   -0.555399
c   -0.850348
dtype: float64

data.unstack()       #从层次化索引转换成DataFrame
data.unstack().stack()  #从DataFrame转换成层次化索引

a  1   -2.403726
   2    0.534817
b  1    1.007619
   2   -0.555399
c  1   -0.715177
   2   -0.850348
dtype: float64

frame=DataFrame(np.arange(12).reshape(4,3),index=[[‘a‘,‘a‘,‘b‘,‘b‘],[1,2,1,2]],columns=[[‘Ohio‘,‘Ohio‘,‘Colorado‘],[‘Green‘,‘Red‘,‘Green‘]])
frame.index.names=[‘key1‘,‘key2‘]
frame.columns.names=[‘state‘,‘color‘]
frame

frame.swaplevel(‘key1‘,‘key2‘)
# frame.swaplevel(‘key1‘,‘key2‘).sort_index(level=‘key2‘)
frame.swaplevel(0,1).sort_index(level=0)

frame=DataFrame({‘a‘:range(7),‘b‘:range(7,0,-1),‘c‘:[‘one‘,‘one‘,‘one‘,‘two‘,‘two‘,‘two‘,‘two‘],‘d‘:[0,1,2,0,1,2,3]})
frame.set_index([‘c‘,‘d‘])   #把某列作为行索引，该列从DataFrame中移除
frame.set_index([‘c‘,‘d‘],drop=False)   #把某列作为行索引，该列在DataFrame中保留
frame.reset_index( )     #将层次化索引的级别会转到列里面

frame=DataFrame(np.arange(12).reshape(4,3),index=[[‘a‘,‘a‘,‘b‘,‘b‘],[1,2,1,2]],columns=[[‘Ohio‘,‘Ohio‘,‘Colorado‘],[‘Green‘,‘Red‘,‘Green‘]])
frame.index.names=[‘key1‘,‘key2‘]
frame.columns.names=[‘state‘,‘color‘]
frame

frame[‘Ohio‘]             #取最外层的列标签
frame[‘Ohio‘,‘Green‘]     #取内层的单个列标签
frame[‘Ohio‘][[‘Red‘,‘Green‘]]  #取内层的多个列标签,先取外层得出一个DataFrame，再取内层

frame.loc[‘a‘]        #取最外层的行标签
frame.loc[‘a‘,1]      #取内层层的单个行标签
frame.ix[‘a‘,[1,2]]      #取内层层的单个行标签

E:\WinPython\WPy-3662\python-3.6.6.amd64\lib\site-packages\ipykernel_launcher.py:3: DeprecationWarning: 
.ix is deprecated. Please use
.loc for label based indexing or
.iloc for positional indexing

See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated
  This is separate from the ipykernel package so we can avoid doing imports until

frame.loc[‘a‘][‘Ohio‘,‘Green‘]     #先索引行标签，在基础上取列

key2
1    0
2    3
Name: (Ohio, Green), dtype: int32

df=DataFrame({‘key1‘:[‘a‘,‘a‘,‘b‘,‘b‘,‘a‘],‘key2‘:[‘one‘,‘two‘,‘one‘,‘two‘,‘one‘],‘data1‘:np.random.randn(5),‘data2‘:np.random.randn(5)})
df

df[‘data1‘].groupby(df[‘key1‘]).mean()
df[‘data1‘].groupby([df[‘key1‘],df[‘key2‘]]).mean()
year=np.array([2005,2005,2006,2005,2006])
df[‘data1‘].groupby(year).mean()

2005    0.284774
2006    0.243356
Name: data1, dtype: float64

df.groupby(‘key1‘).mean()   #结果中没有key2，因为key2是非数值列被排除

df.groupby([‘key1‘,‘key2‘]).size()

key1  key2
a     one     2
      two     1
b     one     1
      two     1
dtype: int64

frame.sum(level=‘key1‘)

df.groupby(‘key1‘)   #返回的是一个groupby对象
for key1,group in df.groupby(‘key1‘):
    print (key1)
    print (group)
    
for (key1,key2),group in df.groupby([‘key1‘,‘key2‘]):
    print (key1,key2)
    print (group)

a
  key1 key2     data1     data2
0    a  one -0.847544  0.003861
1    a  two  1.510283  0.623520
4    a  one  0.586113 -0.571834
b
  key1 key2     data1     data2
2    b  one -0.099401  0.038992
3    b  two  0.191581 -0.927451
a one
  key1 key2     data1     data2
0    a  one -0.847544  0.003861
4    a  one  0.586113 -0.571834
a two
  key1 key2     data1    data2
1    a  two  1.510283  0.62352
b one
  key1 key2     data1     data2
2    b  one -0.099401  0.038992
b two
  key1 key2     data1     data2
3    b  two  0.191581 -0.927451

#以下两种方法是等价的
df[‘data1‘].groupby(df[‘key1‘])
df.groupby(‘key1‘)[‘data1‘]

<pandas.core.groupby.groupby.SeriesGroupBy object at 0x000001C35A75F358>

#groupby转成字典
# dict(list(df.groupby(‘key1‘)))
#字典转成groupby
mapping={‘data1‘:‘a‘,‘data2‘:‘b‘,‘key1‘:‘c‘,‘key2‘:‘d‘}
df.groupby(mapping,axis=1).sum()  #以后面的值为分组键

【原】《利用Python进行数据分析》学习笔记之Pandas基础

原文：https://www.cnblogs.com/laiyaling/p/10062278.html