Pandas数据处理基础知识

时间:2022-12-20 22:26:18

本宝宝只是为了方便以后自己学习方便,有错误的地方还请大家谅解咯。

而且我经常用的是Ipython

1.1   安装Pandas

安装Pandas之前需要确保操作系统之中还有Numpy。当然,如果有Anacoda,Pandas是已经下载安装完成了的。

安装方法:1.打开cmd,进入到pip所在文件下,pip install pandas,耐心等待就好啦

              2.如果有Pycharm的话,在Pycharm中点击-File-Settings-Project:PytohnDataSciene-Project Interpreter,然后可以在偏右上方的部分看到一个绿色的小加号,点击,搜索pandas,在左下角Install Package就好。

                3.下载安装Anaconda。

                4.官方安装方法,参考Pandas官方文档(http://pandas.pydata.org/).

Pandas 安装好后可以检查一下版本号

import pandas as pd
pd.__version__
0.21.1

与导入Numpy使用别名 np 一样,我们通常用Pandas的别名pd


1.2   Pandas内置文档查询

可以按下Tab键显示pandas命名空间的所有内容

pd.<Tab>

显示Pandas文档:

pd?

更多可以参考http://pandas.pydata.org/


1.3  Pandas的对象简介

Pandas就是基于Numpy的增强版结构化数组,可以在行列上加上标签。

在学习Pandas之前,先看看她的三个基本数据结构:Series,DataFrame和Index。

import numpy as np
import pandas as pd
1.3.1   Series对象

Series:是一个带索引数据构成一维数组。

用一个一位数组创建Series对象:

data = pd.Series([0.25,0.5,0.75,1.0])
data
Out[110]: 
0    0.25
1    0.50
2    0.75
3    1.00
dtype: float64

所以Series对象是将一位数组和一组索引值绑定在一起的,

data.values    ###values属性
Out[111]: array([0.25, 0.5 , 0.75, 1.  ])
data.index     ###index属性
Out[112]: RangeIndex(start=0, stop=4, step=1)

同numpy一样,可以用中括号索引取值:

data[1]
Out[113]: 0.5
data[1:3]
Out[114]: 
1    0.50
2    0.75
dtype: float64

1.Series :通用numpy数组

Series对象通过显式定义的索引与数值关联。(索引可以不再只是整数):

data = pd.Series([0.25,0.5,0.75,1.0],index=['a','b','c','d'])
data
Out[116]: 
a    0.25
b    0.50
c    0.75
d    1.00
dtype: float64

获取数值的方法也和之前一样:

data['a']
Out[117]: 0.25

还可以不连续,不按顺序:

data = pd.Series([0.25,0.5,0.75,1.0],index=[2,5,3,7])
data
Out[119]: 
2    0.25
5    0.50
3    0.75
7    1.00
dtype: float64
data[5]
Out[121]: 0.5

2.  Series 是特殊的字典

Pandas的Series对象可以看成是python的特殊字典。字典就是一种将任意键映射到一组任意值的数据结构,而Series对象其实是一种将类型键映射到一组类性质的数据结构。类型很重要:
下面用字典来创建一个对象

population_dict = {'California':38332521,'Texas':26448193,'New York':19651127,'Florida':19552860,'Illinois':12882135}
population = pd.Series(population_dict)
population
Out[124]: 
California    38332521
Florida       19552860
Illinois      12882135
New York      19651127
Texas         26448193
dtype: int64  

字典获取方式依然有效:

population['California']
Out[125]: 38332521
Series对象还支持数组形式的操作,如切片:
population['California':'Illinois']
Out[126]: 
California    38332521
Florida       19552860
Illinois      12882135
dtype: int64
3.创建Series对象
>>>pd.Series(data,index=index)

data可以是列表或Numpy数组,甚至可以是标量,字典,index默认值为整数数列:

pd.Series([2,4,6])
Out[127]: 
0    2
1    4
2    6
dtype: int64
pd.Series(5,index=[100,200,300])  ###标量
Out[128]: 
100    5
200    5
300    5
dtype: int64
pd.Series({2:'a',1:'b',3:'c'})###字典
Out[130]: 
1    b
2    a
3    c
dtype: object
pd.Series({2:'a',1:'b',3:'c'},index=[3,2])###通过索引来筛选
Out[129]: 
3    c
2    a
dtype: object

1.2.2   Pandas的DataFrame对象

Pandas第二个数据结构是DataFrame对象。

既可以作为Numpy数组,也可以看作特殊的Python字典。

1.DataFrame是通用的Numpy数组

DataFrame是一种基既有灵活的行索引,又有灵活列名的二维数组。即可以把二维数组看成是有序排列的一位数组,或有序排列的若干Series对象。

area_dict = {'California':423967,'Texas':695662,'New York':141297,'Florida':170312,'Illinois':149995}
area = pd.Series(area_dict)
area
Out[7]: 
California    423967
Florida       170312
Illinois      149995
New York      141297
Texas         695662
dtype: int64

结合之前创建的population的Series对象,用字典来创建一个包含这些信息的二维对象:

states = pd.DataFrame({'population':population,'area':area})
states
Out[10]: 
              area  population
California  423967    38332521
Florida     170312    19552860
Illinois    149995    12882135
New York    141297    19651127
Texas       695662    26448193

和Series对象一样,DataFrame也有一个index属性可以获取索引标签:

states.index
Out[11]: Index(['California', 'Florida', 'Illinois', 'New York', 'Texas'], dtype='object')

还有columns属性,用来存放列标签的Index对象:

states.columns
Out[12]: Index(['area', 'population'], dtype='object')

2.DataFrame是 特殊的字典

把DataFrame看成字典时,DataFrame的一列映射一个Series的数据。

 
states['area']  ###通过‘area’的列属性可以返回包含面积数据的Series对象
Out[13]: 
California    423967
Florida       170312
Illinois      149995
New York      141297
Texas         695662
Name: area, dtype: int64

3.创建DataFrame对象

Pandas的DataFrame的创建:

(1)通过单个Series对象创建。DataFrame是一组Series对象的集合,可以用单个Series创建一个单列的DataFrame:

pd.DataFrame(population,columns=['population'])
Out[14]: 
            population
California    38332521
Florida       19552860
Illinois      12882135
New York      19651127
Texas         26448193

(2)通过字典列表创建。任何元素是字典的列表都可以变成DataFrame。用一个简单的列表综合来创建一些数据:

data = [{'a':i,'b':2*i} for i in range(3)]
pd.DataFrame(data)
Out[16]: 
   a  b
0  0  0
1  1  2
2  2  4

即使字典中有些值不存在,Pandas也会用哪个缺失值NaN(not a number)来表示:

pd.DataFrame([{'a':1,'b':2},{'b':3,'c':4}])
Out[17]: 
     a  b    c
0  1.0  2  NaN
1  NaN  3  4.0
(3)通过Series对象字典创建。
pd.DataFrame({'population':population,'area':area})
Out[18]: 
              area  population
California  423967    38332521
Florida     170312    19552860
Illinois    149995    12882135
New York    141297    19651127
Texas       695662    26448193

(4)通过Numpy二维数组创建。

pd.DataFrame(np.random.rand(3,2),columns=['foo','bar'],index=['a','b','c'])
Out[19]: 
        foo       bar
a  0.232374  0.257281
b  0.171938  0.151926
c  0.705263  0.819819

(5)通过Numpy结构化数组创建。

A = np.zeros(3,dtype=[('A','i8'),('B','<f8')])
pd.DataFrame(A)
Out[21]: 
   A    B
0  0  0.0
1  0  0.0
2  0  0.0

1.2.3    Pandas的Index对象

Index对象是一个有趣的数据结构。可以将它看成是一个不可变数组或有序集(但有可能会有重复值)。

ind = pd.Index([2,3,5,7,11])
ind
Out[5]: Int64Index([2, 3, 5, 7, 11], dtype='int64')

1. 将Index看成不可变数组

Index许多操作都像数组:

ind[1]
Out[6]: 3
ind[::2]
Out[7]: Int64Index([2, 5, 11], dtype='int64')
Index还有许多与Numpy数组相似的属性:
print(ind.size,ind.shape,ind.ndim,ind.dtype)
5 (5,) 1 int64

但刚刚就说了Index相当于一个不可变的数组,所以不可以改变一个Index对象的某个值:

ind[1] = 0
Traceback (most recent call last):
  File "D:\python\lib\site-packages\IPython\core\interactiveshell.py", line 2910, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-9-906a9fa1424c>", line 1, in <module>
    ind[1] = 0
  File "C:\Users\DELL\AppData\Roaming\Python\Python36\site-packages\pandas\core\indexes\base.py", line 1724, in __setitem__
    raise TypeError("Index does not support mutable operations")
TypeError: Index does not support mutable operations

Index对象的不可变特征使得这样可以避免因为粗心大意而犯下的错误。

2.将Index看作有序集合

indA = pd.Index([1,3,5,7,9])
indB = pd.Index([2,3,5,7,11])
indA&indB
Out[12]: Int64Index([3, 5, 7], dtype='int64')
indA|indB
Out[13]: Int64Index([1, 2, 3, 5, 7, 9, 11], dtype='int64')
indA^indB
Out[14]: Int64Index([1, 2, 9, 11], dtype='int64')

当然如果你想,还可以用调用对象方法来实现,

ind.intersection(indB)
Out[15]: Int64Index([2, 3, 5, 7, 11], dtype='int64')

---------------------------------------------------------------------------------------------------------------------------

参考资料:

Python Data Science Handbook(Python数据科学手册)-------Jake VanderPlas  (陶俊杰,陈小莉译)