人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

python之pandas包的详解与使用_pandas依赖包要求

作者：人工智能uu | 2024-08-01 10:05:06

踩

pandas依赖包要求

什么是pandas

　　pandas是一种Python数据分析的利器，是一个开源的数据分析包，最初是应用于金融数据分析工具而开发出来的，因此pandas为时间序列分析提供了很好的支持。pandas是PyData项目的一部分。

　　官网：http://pandas.pydata.org/

　　官方文档：http://pandas.pydata.org/pandas-docs/stable/

安装pandas

　　Python版本要求：2.7、3.4、3.5、3.6

　　依赖Python库：setuptools、NumPy、python-dateutil、pytz

　　安装方式：

　　　　Python的Anaconda发行版，已经安装好pandas库，不需要另外安装

　　　　使用Anaconda界面安装，选择对应的pandas进行勾选安装即可

　　　　使用Anaconda命令安装：conda install pandas

　　　　使用PyPi安装命令安装：pip install pandas

　　使用Anaconda界面安装pandas

pandas操作

　 pandas引入约定

　　from pandas import Series,

　　DataFrame import pandas as pd

　　pandas基本数据结构

　　pandas中主要有两种数据结构，分别是：Series和DataFrame。

　　Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。

　　DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Series组成的字典。

　　Series：通过一维数组创建

练习

In [2]:

import pandas as pd

import numpy as np

series创建

In [8]:

# ser01 = pd.Series([1,2,3,4])

# ser01

ser01 = pd.Series(np.array([1,2,3,4]))

ser01

print(ser01.dtype)

print(ser01.values)

print(ser01.index)

print(ser01)

int32

[1 2 3 4]

RangeIndex(start=0, stop=4, step=1)

0 1

1 2

2 3

3 4

dtype: int32

In [9]:

#设置索引(创建好后改)

ser01.index = ['a','b','c','d']

ser01

Out[9]:

a 1

b 2

c 3

d 4

dtype: int32

In [10]:

ser01 = pd.Series(np.array([1,2,3,4]),index = ['a','b','c','d'])

ser01

Out[10]:

a 1

b 2

c 3

d 4

dtype: int32

　　Series：通过字典的方式创建

练习

通过字典的方式创建

In [11]:

ser02 = pd.Series({

'a':10, #key变为索引

'b':20,

'c':30

})

ser02

Out[11]:

a 10

b 20

c 30

dtype: int64

　　Series值的获取

　　Series值的获取主要有两种方式：

　　通过方括号+索引的方式读取对应索引的数据，有可能返回多条数据

　　通过方括号+下标值的方式读取对应下标值的数据，下标值的取值范围为：[0，len(Series.values))；另外下标值也可以是负数，表示从右往左获取数据

　　Series获取多个值的方式类似NumPy中的ndarray的切片操作，通过方括号+下标值/索引值+冒号(:)的形式来截取series对象中的一部分数据。

　　Series的运算

　　NumPy中的数组运算，在Series中都保留了，均可以使用，并且Series进行数组运算的时候，索引与值之间的映射关系不会发生改变。

　　注意：其实在操作Series的时候，基本上可以把Series看成NumPy中的ndarray数组来进行操作。ndarray数组的绝大多数操作都可以应用到Series上。

练习

Series值得获取

In [15]:

print(ser02['a'])

print(ser02[0])

print(ser02[0:2])

print(ser02['a':'c'])

10

a 10

b 20

dtype: int64

a 10

b 20

c 30

dtype: int64

Series的运算

In [16]:

ser02 = pd.Series({

'a':10, #key变为索引

'b':20,

'c':30

})

ser02

Out[16]:

a 10

b 20

c 30

dtype: int64

In [20]:

ser02[ser02 > 10]

ser02/10

ser02+10

ser02*10

Out[20]:

a 100

b 200

c 300

dtype: int64

In [22]:

np.exp(ser02)

np.fabs(ser02)

Out[22]:

a 10.0

b 20.0

c 30.0

dtype: float64

　　Series缺失值检测

　　pandas中的isnull和notnull两个函数可以用于在Series中检测缺失值，这两个函数的返回时一个布尔类型的Series

　　Series自动对齐

　　当多个series对象之间进行运算的时候，如果不同series之间具有不同的索引值，那么运算会自动对齐不同索引值的数据，如果某个series没有某个索引值，那么最终结果会赋值为NaN。

　　Series及其索引的name属性

　　Series对象本身以及索引都具有一个name属性，默认为空，根据需要可以进行赋值操作

Series缺失值检测与处理

In [26]:

ser01 = pd.Series({

'a':10,

'b':20,

'c':30

})

ser01

ser02 = pd.Series(ser01,index = ['a','b','c','d'])

ser02

Out[26]:

a 10.0

b 20.0

c 30.0

d NaN

dtype: float64

In [28]:

ser02[pd.isnull(ser02)]

ser02[pd.notnull(ser02)]

Out[28]:

a 10.0

b 20.0

c 30.0

dtype: float64

In [29]:

ser01 = pd.Series([1,2,3,4],index = ['a','b','c','d'])

ser02 = pd.Series([10,20,30,40],index = ['e','a','f','b'])

ser01+ser02

Out[29]:

a 21.0

b 42.0

c NaN

d NaN

e NaN

f NaN

dtype: float64

In [32]:

#series的name属性

ser01 = pd.Series([1,2,3,4],index = ['a','b','c','d'])

ser01.name = 'aaa'

ser01.index.name = 'names'

ser01

Out[32]:

names

a 1

b 2

c 3

d 4

Name: aaa, dtype: int64

　　DataFrame: 通过二维数组创建

In [1]:

import pandas as pd

In [3]:

df01 = pd.DataFrame([['joe','susan','anne'],[79,45,67]])

df01

Out[3]:

0 1 2

0 joe susan anne

1 79 45 67

In [10]:

df01 = pd.DataFrame([['joe','susan','anne'],[79,45,67]],index = ['one','teo'],columns = ['a','b','c'])

print(df01)

print(df01.index)

print(df01.columns)

print(df01.values)

a b c

one joe susan anne

teo 79 45 67

Index(['one', 'teo'], dtype='object')

Index(['a', 'b', 'c'], dtype='object')

[['joe' 'susan' 'anne']

[79 45 67]]

　　DataFrame: 通过字典的方式创建

　　索引对象

　　不管是Series还是DataFrame对象，都有索引对象。

　　索引对象负责管理轴标签和其它元数据(eg：轴名称等等)

　　通过索引可以从Series、DataFrame中获取值或者对某个索引值进行重新赋值

　　Series或者DataFrame的自动对齐功能是通过索引实现的

　　DataFrame数据获取

　　可以直接通过列索引获取指定列的数据， eg: df[column_name]

　　如果需要获取指定行的数据的话，需要通过ix方法来获取对应行索引的行数据，eg: df.ix[index_name]

通过字典的方法创建

In [42]:

df01 = pd.DataFrame({

'name':['joe','susan','anne'],

'sex':['men','women','women'],

'age':[18,19,20],

'classid':3

},index = ['one','two','three'])

print(df01)

age classid name sex

one 18 3 joe men

two 19 3 susan women

three 20 3 anne women

DataFrame获取数据

In [43]:

#列索引获取数据

df01['name']

df01.name

Out[43]:

one joe

two susan

three anne

Name: name, dtype: object

In [44]:

#列添加

df01['address'] = ['北京','上海','广州']

df01

Out[44]:

age classid name sex address

one 18 3 joe men 北京

two 19 3 susan women 上海

three 20 3 anne women 广州

In [45]:

#列删除

df01.pop('address')

df01

Out[45]:

age classid name sex

one 18 3 joe men

two 19 3 susan women

three 20 3 anne women

In [46]:

#列修改

df01['classid'] = 4

df01

Out[46]:

age classid name sex

one 18 4 joe men

two 19 4 susan women

three 20 4 anne women

In [47]:

#行获取

df01.ix['one']

df01.loc['two']#两种方式

df01.loc['two','name']

df01.loc['two']['name']#两种方式

Out[47]:

'susan'

In [33]:

#行增加

df01.ix['four'] = [21,3,'black','men']

df01

Out[33]:

age classid name sex

one 18 4 joe men

two 19 4 susan women

three 20 4 anne wpmen

four 21 3 black men

In [48]:

#行修改

df01.ix['four'] = [23,4,'ronaldo','men']

df01

Out[48]:

age classid name sex

one 18 4 joe men

two 19 4 susan women

three 20 4 anne women

four 23 4 ronaldo men

In [35]:

#行删除

df01.drop('four')

Out[35]:

age classid name sex

one 18 4 joe men

two 19 4 susan women

three 20 4 anne wpmen

pandas基本功能

　　数据文件读取/文本数据读取

　　索引、选取和数据过滤

　　算法运算和数据对齐

　　函数的应用和映射

　　重置索引

　　pandas：数据文件读取

　　通过pandas提供的read_xxx相关的函数可以读取文件中的数据，并形成DataFrame,常用的数据读取方法为：read_csv，主要可以读取文本类型的数据

In [13]:

import pandas as pd

import numpy as np

读取文件

In [4]:

df01 = pd.read_csv('data.csv')

df01

Out[4]:

name age sex

0 joe 18 men

1 susan 19 women

2 anne 20 women

In [5]:

df02 = pd.read_excel('data.xlsx')

df02

Out[5]:

name age sex

0 joe 18 men

1 susan 19 women

2 anne 20 women

In [9]:

df03 = pd.read_csv('data.txt',sep = ';',header = None)

df03

Out[9]:

0 1 2

0 joe 18 men

1 susan 19 women

2 anne 20 women

　　pandas：数据过滤获取

　　通过DataFrame的相关方式可以获取对应的列或者数据形成一个新的DataFrame, 方便后续进行统计计算。

数据过滤

In [11]:

df01 = pd.DataFrame({

'name':['joe','susan','anne'],

'sex':['men','women','women'],

'age':[18,19,20],

'classid':3

},index = ['one','two','three'])

print(df01)

print(df01.columns)

age classid name sex

one 18 3 joe men

two 19 3 susan women

three 20 3 anne women

Index(['age', 'classid', 'name', 'sex'], dtype='object')

In [12]:

df01[df01.columns[2:]]

Out[12]:

name sex

one joe men

two susan women

three anne women

　　pandas：缺省值NaN处理方法

　　对于DataFrame/Series中的NaN一般采取的方式为删除对应的列/行或者填充一个默认值

缺失值NaN

In [32]:

df01 = pd.DataFrame(np.random.randint(1,9,size = (4,4)))

df01

Out[32]:

0 1 2 3

0 7 7 1 6

1 3 8 5 7

2 7 4 3 2

3 8 2 6 6

In [33]:

df01.ix[1:2,1] = np.NaN

df01.ix[1:2,2] = np.NaN

df01.ix[1:2,3] = np.NaN

df01

Out[33]:

0 1 2 3

0 7 7.0 1.0 6.0

1 3 NaN NaN NaN

2 7 NaN NaN NaN

3 8 2.0 6.0 6.0

In [34]:

df01.dropna()#默认只要包含NaN就会删除

Out[34]:

0 1 2 3

0 7 7.0 1.0 6.0

3 8 2.0 6.0 6.0

In [35]:

df01.ix[1,0] = np.NaN

df01.dropna(how = 'all')#指定阈值删除行

Out[35]:

0 1 2 3

0 7.0 7.0 1.0 6.0

2 7.0 NaN NaN NaN

3 8.0 2.0 6.0 6.0

In [36]:

df01.dropna(axis = 1)#删除列（包含就删除）

Out[36]:

0

1

2

3

In [37]:

df01 = pd.DataFrame(np.random.randint(1,9,size = (4,4)))

df01

Out[37]:

0 1 2 3

0 1 7 7 2

1 2 7 7 8

2 7 8 2 1

3 8 5 4 4

In [40]:

df01.ix[1,0] = np.NaN

df01.ix[1:2,1] = np.NaN

df01.ix[1:2,2] = np.NaN

df01.ix[1:2,3] = np.NaN

df01

Out[40]:

0 1 2 3

0 1.0 NaN 7.0 2.0

1 NaN NaN NaN NaN

2 7.0 NaN NaN NaN

3 8.0 5.0 4.0 4.0

In [41]:

df01.fillna(0)#将0插入

Out[41]:

0 1 2 3

0 1.0 0.0 7.0 2.0

1 0.0 0.0 0.0 0.0

2 7.0 0.0 0.0 0.0

3 8.0 5.0 4.0 4.0

In [42]:

df01.fillna({0:1,1:1,2:2,3:3})#指定列插入值

Out[42]:

0 1 2 3

0 1.0 1.0 7.0 2.0

1 1.0 1.0 2.0 3.0

2 7.0 1.0 2.0 3.0

3 8.0 5.0 4.0 4.0

　　pandas：常用的数学统计方法

100

101

102

103

数学统计方法

In [56]:

df01 = pd.DataFrame(np.random.randint(1,9,size = (5,4)))

df01

Out[56]:

0 1 2 3

0 4 2 3 6

1 5 3 1 8

2 7 1 1 7

3 8 8 2 5

4 4 4 6 7

In [50]:

df01.sum() #列求和

# df01.sum(axis = 1) #0 按照列求和 1 按照行求和

Out[50]:

0 16

1 22

2 17

3 12

dtype: int64

In [53]:

df01.min()

df01.min(axis = 1)

Out[53]:

0 1

1 2

2 2

3 2

dtype: int32

In [60]:

df01.quantile(0.25)#样本位分数位

df01.quantile(0.75)

Out[60]:

0 7.0

1 4.0

2 3.0

3 7.0

dtype: float64

In [57]:

df01.median()#中位数

Out[57]:

0 5.0

1 3.0

2 2.0

3 7.0

dtype: float64

In [61]:

df01.cumsum()#累加

Out[61]:

0 1 2 3

0 4 2 3 6

1 9 5 4 14

2 16 6 5 21

3 24 14 7 26

4 28 18 13 33

In [63]:

df01.pct_change()#计算百分数变化

Out[63]:

0 1 2 3

0 NaN NaN NaN NaN

1 0.250000 0.500000 -0.666667 0.333333

2 0.400000 -0.666667 0.000000 -0.125000

3 0.142857 7.000000 1.000000 -0.285714

4 -0.500000 -0.500000 2.000000 0.400000

In [64]:

df01.var()

Out[64]:

0 3.3

1 7.3

2 4.3

3 1.3

dtype: float64

In [65]:

df01.std()

Out[65]:

0 1.816590

1 2.701851

2 2.073644

3 1.140175

dtype: float64

In [66]:

df01.describe()

Out[66]:

0 1 2 3

count 5.00000 5.000000 5.000000 5.000000

mean 5.60000 3.600000 2.600000 6.600000

std 1.81659 2.701851 2.073644 1.140175

min 4.00000 1.000000 1.000000 5.000000

25% 4.00000 2.000000 1.000000 6.000000

50% 5.00000 3.000000 2.000000 7.000000

75% 7.00000 4.000000 3.000000 7.000000

max 8.00000 8.000000 6.000000 8.000000

　　pandas：相关系数与协方差

　　相关系数（Correlation coefficient）：反映两个样本/样本之间的相互关系以及之间的相关程度。在COV的基础上进行了无量纲化操作，也就是进行了标准化操作。

　　协方差(Covariance, COV)：反映两个样本/变量之间的相互关系以及之间的相关程度。

　　通俗理解协方差：如果有X,Y两个变量，每时刻的"X值与均值只差"乘以"Y值与其均值只差"得到一个乘积，再对这每时刻的乘积求和并求出均值。

　　如果协方差为正，说明X,Y同向变化，协方差越大说明同向程度越高；如果协方差为负，说明X,Y反向运动，协方差越小说明方向程度越高。

　　pandas：唯一值、值计数以及成员资格

　　unique方法用于获取Series中的唯一值数组(去重数据后的数组)

　　value_counts方法用于计算一个Series中各值的出现频率

　　isin方法用于判断矢量化集合的成员资格，可用于选取Series中或者DataFrame中列中数据的子集

相关系数与协方差

In [76]:

df01 = pd.DataFrame({

'GDP':[400,500,600,700],

'forgin_trade':[300,200,300,500,],

'year':['2012','2013','2014','2015']

})

df01

Out[76]:

GDP forgin_trade year

0 400 300 2012

1 500 200 2013

2 600 300 2014

3 700 500 2015

In [74]:

df01.cov()#协方差

Out[74]:

GDP forgin_trade

GDP 16666.666667 -8333.333333

forgin_trade -8333.333333 9166.666667

In [77]:

df01.corr()

Out[77]:

GDP forgin_trade

GDP 1.000000 0.718185

forgin_trade 0.718185 1.000000

In [81]:

#唯一值

ser01 = pd.Series(['a','b','c','d','a','b','c','d'])

ser01

ser02 = ser01.unique()

print(ser02.dtype)

object

In [85]:

#值计数

ser01 = pd.Series(['a','b','c','d','a','b','c','d','b','c','d'])

ser01.value_counts()

Out[85]:

c 3

b 3

d 3

a 2

dtype: int64

In [88]:

#成员资格

ser01.isin(['b','c'])

ser01[ser01.isin(['b','c'])]#过滤

Out[88]:

1 b

2 c

5 b

6 c

8 b

9 c

dtype: object

　　pandas：层次索引

　　在某一个方向拥有多个(两个及两个以上)索引级别

　　通过层次化索引，pandas能够以较低维度形式处理高纬度的数据

　　通过层次化索引，可以按照层次统计数据

　　层次索引包括Series层次索引和DataFrame层次索引

　　pandas：按照层次索引进行统计数据

层次索引

In [99]:

data = pd.Series([988.44,95678,32455,2345,4346],

index = [

['2001','2001','2001','2002','2002'],

['苹果','香蕉','西瓜','香蕉','西瓜']

])

print(data)

data['2001']

2001 苹果 988.44

香蕉 95678.00

西瓜 32455.00

2002 香蕉 2345.00

西瓜 4346.00

dtype: float64

Out[99]:

苹果 988.44

香蕉 95678.00

西瓜 32455.00

dtype: float64

In [118]:

df = pd.DataFrame({

'year':[2001,2001,2002,2002,2003],

'fruit':['apple','banana','apple','banana','apple'],

'production':[2345,3245,5567,4356,5672]

})

df

Out[118]:

fruit production year

0 apple 2345 2001

1 banana 3245 2001

2 apple 5567 2002

3 banana 4356 2002

4 apple 5672 2003

In [119]:

df2 = df.set_index(['year','fruit'])

df2

Out[119]:

production

year fruit

2001 apple 2345

banana 3245

2002 apple 5567

banana 4356

2003 apple 5672

In [121]:

df2.ix[2001,'apple']

Out[121]:

production 2345

Name: (2001, apple), dtype: int64

In [122]:

df2.sum(level = 'year')

Out[122]:

production

year

2001 5590

2002 9923

2003 5672

In [123]:

df2.mean(level='fruit')

Out[123]:

production

fruit

apple 4528.0

banana 3800.5

In [124]:

df2.min(level=['year','fruit'])

Out[124]:

production

year fruit

2001 apple 2345

banana 3245

2002 apple 5567

banana 4356

2003 apple 5672

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/913554