数据分析

大数据分析是指对规模巨大的数据进行分析。大数据可以概括为5个V，数据量大(Volume)、速度快(Velocity)、类型多(Variety)、价值（Value）、真实性（Veracity）

学习路线：https://www.cnblogs.com/wilson403/p/11285933.html

———————————————————————————————————————

主要是python数据分析相关库（Pandas/ Numpy/Scipy/ Matplotlib）

Pandas简介：https://www.csdn.net/gather_28/MtjaQgxsNzI2OTQtYmxvZwO0O0OO0O0O.html

Numpy简介：

https://blog.csdn.net/a373595475/article/details/79580734?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159875564519724843417126%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=159875564519724843417126&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-3-79580734.pc_ecpm_v3_pc_rank_v3&utm_term=Numpy&spm=1018.2118.3001.4187

Matplotlib简介：

https://blog.csdn.net/xiaodongxiexie/article/details/53123371?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159875575519724843459081%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=159875575519724843459081&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_click~default-2-53123371.pc_ecpm_v3_pc_rank_v3&utm_term=Matplotlib&spm=1018.2118.3001.4187

我遇到的问题及解决：

问题1！使用python的pandas库把.data文件转化为csv文件

1.问题引入

在数据分析，机器学习，深度学习中，我们经常会处理各种各样格式的数据。今天，博主在做房价预测时（采用波士顿房价数据集），从网上下载的数据集格式为.data,并不是我们喜闻乐见的csv格式，所以想采用pandas库将其转为为csv格式的数据，方便后面的训练。

2.问题分析

data格式数据展示为：
从第1列到第14列数据属性为：

代码演示

import pandas as pd

#读取data文件，指定属性，sep='[\s]*'意义为匹配一个或多个空格，因为原始数据集中数据分割是两个或者多个空格

data=pd.read_table('housing.data',header=None,names=['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B-1000','LSTAT','MEDV'],sep='[\s]*')

#生成csv文件

data.to_csv('housing.csv',index=False)

实验结果

问题2！分析了一些例子

数据挖掘例子：https://blog.csdn.net/u011403848/article/details/83148736

https://blog.csdn.net/weixin_42032917/article/details/104046758?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.edu_weight

问题3！在用pandas包和numpy包对数据进行分析和计算时，经常用到DataFrame和array类型的数据。在对DataFrame类型的数据进行处理时，需要将其转换成array类型，是以下列出了三种转换方法。

首先导入numpy模块、pandas模块、创建一个DataFrame类型数据df

import numpy as np

import pandas as pd

df=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})

1.使用DataFrame中的values方法

df.values

2.使用DataFrame中的as_matrix()方法

df.as_matrix()

3.使用Numpy中的array方法

np.array(df)

三种方法效果相同，都能实现DataFrame到array的转换，效果如下。

问题4！python中numpy矩阵运算操作大全（非常全）

python矩阵运算大全

1、矩阵的输出形式：

对于任何一个矩阵，python输出的模板是：

import numpy as np #引入numpy模块

np1=np.array([[1,2,3],[1,3,4],[1,6,2]...]) #数组化矩阵形式

print(np1) #输出矩阵

2、对于矩阵的各种操作(np1代表矩阵)：

注意：操作矩阵之前需要引入numpy的linalg模块,语句如下：

from numpy.linalg import *

(1)求矩阵的逆矩阵：inv(np1)

(2)求矩阵的转置：p1.transpose()

(3)求矩阵的行列式：det(np1)

(4)求矩阵的特征向量和特征值：eig(np1)

(5)求取线性方程组的解：

首先写出方程组的右边的y值向量：y=np.array([[y1],[y2],[y3]...])

函数值的集合等于 x=solve(np1,y)

（6）矩阵的点乘：np.dot（np1,np2）

问题5！Pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，

结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。

In [1]:

import pandas as pd

In [2]:

date1 = pd.date_range('2012-3-1', periods=1)

data1 = {"A": 1, "B": 2, "C": 3}

df1 = pd.DataFrame(data=data1, index=date1)

In [3]:

df1

Out[3]:

A B C

2012-03-01 1 2 3

In [4]:

df1 + df1

Out[4]:

A B C

2012-03-01 2 4 6

In [5]:

df1 * df1

Out[5]:

A B C

2012-03-01 1 4 9

In [6]:

df1 - df1

Out[6]:

A B C

2012-03-01 0 0 0

In [7]:

df1 / df1

Out[7]:

A B C

2012-03-01 1 1 1

如果两个对象的索引或者列不同，pandas 会自动进行数据对齐，不对齐的数据会默认用 NaN 填充。

In [8]:

date2 = pd.date_range('2012-4-1', periods=1)

data2 = {"A": 4, "B": 5, "C": 6}

df2 = pd.DataFrame(data=data2, index=date2)

In [9]:

df2

Out[9]:

A B C

2012-04-01 4 5 6

In [10]:

df1 + df2

Out[10]:

A B C

2012-03-01 NaN NaN NaN

2012-04-01 NaN NaN NaN

这可能不是你希望的结果，你只是想将两个 dataframe 合并在一起，那么可以采用 dataframe 对象的 add() 方法来相加，并指定 fill_value 参数：

In [11]:

df1.add(df2, fill_value=0)

Out[11]:

A B C

2012-03-01 1 2 3

2012-04-01 4 5 6

如果你仅仅只是需要拼接两个 dataframe，那么直接使用 append 方法即可

In [12]:

df1.append(df2)

Out[12]:

A B C

2012-03-01 1 2 3

2012-04-01 4 5 6

也许这也不是某些人想要的结果，他们希望两个 dataframe 对应的行相加，即使索引不同。这就违背了 pandas 数据对齐的特性，这也是 dataframe 行索引和列列索引存在的意义。所以 dataframe 原生不支持这样的运算，为什么是这样呢？想想如果让两个索引不同的 dataframe 的对应列相加，那么加完之后新的对象的索引该用谁的呢。当然，如果非要这么做也并不是不可，我们可以用一些迂回的办法：

1、转化成 series 后进行运算：

In [13]:

pd.DataFrame(df1.values + df2.values, columns=df1.columns)

Out[13]:

A B C

0 5 7 9

2、改变其中一个 dataframe 的行索引，使两个 dataframe 的行索引相同：

In [14]:

df2_bak = df2.copy() # 如果不希望改变原对象的索引就做一份拷贝

df2_bak.index = df1.index

In [15]:

df2_bak

Out[15]:

A B C

2012-03-01 4 5 6

In [16]:

df1 + df2_bak

Out[16]:

A B C

2012-03-01 5 7 9

3、用 reset_index() 方法重置列索引, 该方法返回一个新的 dataframe：

In [17]:

df1.reset_index()

Out[17]:

index A B C

0 2012-03-01 1 2 3

In [18]:

df2.reset_index()

Out[18]:

index A B C

0 2012-04-01 4 5 6

直接 reset 时，我们发现原来的 index 默认被作为 dataframe 的一列，这可能不是我们想要的。我们可以给 reset_index() 方法传递一个参数 drop=True：

In [19]:

df1.reset_index(drop=True)

Out[19]:

A B C

0 1 2 3

In [20]:

df2.reset_index(drop=True)

Out[20]:

A B C

0 4 5 6

In [21]:

df1.reset_index(drop=True) + df2.reset_index(drop=True)

Out[21]:

A B C

0 5 7 9

如果仅仅是列索引不同，也可以用同样的方法：

In [22]:

data3 = {"D": 7, "E": 8, "F": 9}

df3 = pd.DataFrame(data=data3, index=date1)

In [23]:

df3

Out[23]:

D E F

2012-03-01 7 8 9

In [24]:

df1 + df3

Out[24]:

A B C D E F

2012-03-01 NaN NaN NaN NaN NaN NaN

In [25]:

pd.DataFrame(df1.values + df2.values, columns=df3.columns)

Out[25]:

D E F

0 5 7 9

那么到底什么是数据对齐，就是两个 dataframe 的相应位置没有一一对应的数据。

In [26]:

data4 = {"D": 7, "E": 8, "F": 9, "G": 10}

df4 = pd.DataFrame(data=data4, index=date1)

In [27]:

df4

Out[27]:

D E F G

2012-03-01 7 8 9 10

In [28]:

df3 + df4

Out[28]:

D E F G

2012-03-01 14 16 18 NaN

这里在相加时，df3 实际上是变成了下面的样子(也就是在没有数据的位置默认用 NaN 填充)：

In [29]:

df3 = pd.DataFrame(data=data3, index=date1, columns=list("DEFG"))

In [30]:

df3

Out[30]:

D E F G

2012-03-01 7 8 9 NaN

In [31]:

df3

Out[31]:

D E F G

2012-03-01 7 8 9 NaN

之所两个 df3 + df4 的 ‘G’ 所以对应的值为 NaN，是因为任何数与 NaN 做运算都等于 NaN。

In [32]:

1 + np.nan

Out[32]:

nan

可以用 fillna 方法来重置填充值：

In [33]:

df3.fillna(0)

Out[33]:

D E F G

2012-03-01 7 8 9 0

In [34]:

df3.fillna(0) + df4

Out[34]:

D E F G

2012-03-01 14 16 18 10

In [35]:

df1

Out[35]:

A B C

2012-03-01 1 2 3

In [36]:

df1.reset_index(drop=True)

Out[36]:

A B C

0 1 2 3

In [37]:

df1

Out[37]:

A B C

问题6！Pandas：按索引合并数据集

import numpy as np

import pandas as pd

from pandas import Series,DataFrame

一、merge函数

left1 = DataFrame({'水果':['苹果','梨','草莓'],

'价格':[3,4,5],

'数量':[9,8,7]}).set_index('水果')

right1 = DataFrame({'水果':['苹果','草莓'],

'产地':['美国','中国']})

print(left1)

print(right1)

价格数量

水果

苹果 3 9

梨 4 8

草莓 5 7

产地水果

0 美国苹果

1 中国草莓

print(pd.merge(left1,right1,right_on='水果',left_index=True,how='outer'))

价格数量产地水果

0 3 9 美国苹果

1 4 8 NaN 梨

1 5 7 中国草莓

二、DataFrame的join函数

left2 = left1

right2 = right1.set_index('水果')

1.join函数默认将两个DataFrame的index进行合并

print(left2.join(right2))

价格数量产地

水果

苹果 3 9 美国

梨 4 8 NaN

草莓 5 7 中国

2.若其中一个DataFrame合并的键不在索引上，可使用on参数

print(right1.join(left1,on='水果',how='outer'))

产地水果价格数量

0 美国苹果 3 9

1 中国草莓 5 7

1 NaN 梨 4 8

3.多个DataFrame按索引合并

another = DataFrame({'水果':['苹果','香蕉','梨'],

'品质':['AA','AAAA','A']}).set_index('水果')

print(left2.join([right2,another],how='outer'))

价格数量产地品质

梨 4.0 8.0 NaN A

苹果 3.0 9.0 美国 AA

草莓 5.0 7.0 中国 NaN

香蕉 NaN NaN NaN AAAA

问题7！绘制散点图

https://blog.csdn.net/ChenHaoUESTC/article/details/76853111?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522159875579019725264646759%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=159875579019725264646759&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v3~pc_rank_v3-1-76853111.pc_ecpm_v3_pc_rank_v3&utm_term=matplotlib%E7%BB%98%E5%88%B6%E4%B8%89%E7%BB%B4%E6%95%A3%E7%82%B9%E5%9B%BE&spm=1018.2118.3001.4187

https://www.csdn.net/gather_28/MtjaQgxsNzI2OTQtYmxvZwO0O0OO0O0O.html

问题1！使用python的pandas库把.data文件转化为csv文件

1.问题引入

2.问题分析

data格式数据展示为：
从第1列到第14列数据属性为：

代码演示

import pandas as pd

#读取data文件，指定属性，sep='[\s]*'意义为匹配一个或多个空格，因为原始数据集中数据分割是两个或者多个空格

data=pd.read_table('housing.data',header=None,names=['CRIM','ZN','INDUS','CHAS','NOX','RM','AGE','DIS','RAD','TAX','PTRATIO','B-1000','LSTAT','MEDV'],sep='[\s]*')

#生成csv文件

data.to_csv('housing.csv',index=False)

实验结果

问题2！

https://blog.csdn.net/u011403848/article/details/83148736

pandas简介和运用

2018-04-08 10:13:28

pandas是python环境下最有名的数据统计包，而DataFrame翻译为数据框，是一种数据组织方式，这么说你可能无法从感性上认识它，举个例子，你大概用过Excel，而它也是一种数据组织和呈现的方式，简单说就是表格，而在在pandas中用DataFrame组织数据，如果你不print DataFrame，你看不到这些数据。

pandas和numpy的区别：

1.numpy是数值计算的扩展包，panadas是做数据处理。

2.NumPy简介：N维数组容器NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。据说NumPy将Python相当于变成一种免费的更强大的MatLab系统。

Pandas简介：表格容器 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量快速便捷地处理数据的函数和方法。使Python成为强大而高效的数据分析环境的重要因素之一。

一、生成数据表

1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用：

import numpy as np

import pandas as pd

· 1

· 2

2、导入CSV或者xlsx文件：

df = pd.DataFrame(pd.read_csv('name.csv',header=1))

df = pd.DataFrame(pd.read_excel('name.xlsx'))

· 1

· 2

· 3

3、用pandas创建数据表：

df = pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006],

"date":pd.date_range('20130102', periods=6),

"city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],

"age":[23,44,54,32,34,32],

"category":['100-A','100-B','110-A','110-C','210-A','130-F'],

"price":[1200,np.nan,2133,5433,np.nan,4432]},

columns =['id','date','city','category','age','price'])

· 1

· 2

· 3

· 4

· 5

· 6

· 7

· 8

2、数据表信息查看
1、维度查看：

df.shape

· 1

· 2

2、数据表基本信息（维度、列名称、数据格式、所占空间等）：

df.info()

· 1

· 2

3、每一列数据的格式：

df.dtypes

· 1

· 2

4、某一列格式：

df['B'].dtype

· 1

· 2

5、空值：

df.isnull()

· 1

· 2

6、查看某一列空值：

df.isnull()

· 1

· 2

7、查看某一列的唯一值：

df['B'].unique()

· 1

· 2

8、查看数据表的值：
df.values
9、查看列名称：

df.columns

· 1

· 2

10、查看前10行数据、后10行数据：

df.head() #默认前10行数据

df.tail() #默认后10 行数据

· 1

· 2

· 3

三、数据表清洗
1、用数字0填充空值：

df.fillna(value=0)

· 1

· 2

2、使用列prince的均值对NA进行填充：

df['prince'].fillna(df['prince'].mean())

· 1

· 2

3、清楚city字段的字符空格：

df['city']=df['city'].map(str.strip)

· 1

· 2

4、大小写转换：

df['city']=df['city'].str.lower()

· 1

· 2

5、更改数据格式：

df['price'].astype('int')

· 1

· 2

6、更改列名称：

df.rename(columns={'category': 'category-size'})

· 1

· 2

7、删除后出现的重复值：

df['city'].drop_duplicates()

· 1

· 2

8、删除先出现的重复值：

df['city'].drop_duplicates(keep='last')

· 1

· 2

9、数据替换：

df['city'].replace('sh', 'shanghai')

· 1

· 2

四、数据预处理

df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008],

"gender":['male','female','male','female','male','female','male','female'],

"pay":['Y','N','Y','Y','N','Y','N','Y',],

"m-point":[10,12,20,40,40,40,30,20]})

· 1

· 2

· 3

· 4

· 5

1、数据表合并

df_inner=pd.merge(df,df1,how='inner') # 匹配合并，交集

df_left=pd.merge(df,df1,how='left') #

df_right=pd.merge(df,df1,how='right')

df_outer=pd.merge(df,df1,how='outer') #并集

· 1

· 2

· 3

· 4

· 5

2、设置索引列

df_inner.set_index('id')

· 1

· 2

3、按照特定列的值排序：

df_inner.sort_values(by=['age'])

· 1

· 2

4、按照索引列排序：

df_inner.sort_index()

· 1

· 2

5、如果prince列的值>3000，group列显示high，否则显示low：

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')

· 1

· 2

6、对复合多个条件的数据进行分组标记

df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1

· 1

· 2

7、对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size

pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))

· 1

· 2

8、将完成分裂后的数据表和原df_inner数据表进行匹配

df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)

· 1

· 2

五、数据提取
主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。
1、按索引提取单行的数值

df_inner.loc[3]

· 1

· 2

2、按索引提取区域行数值

df_inner.iloc[0:5]

· 1

· 2

3、重设索引

df_inner.reset_index()

· 1

· 2

4、设置日期为索引

df_inner=df_inner.set_index('date')

· 1

· 2

5、提取4日之前的所有数据

df_inner[:'2013-01-04']

· 1

· 2

6、使用iloc按位置区域提取数据

df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。

· 1

· 2

7、适应iloc按位置单独提起数据

df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列

· 1

· 2

8、使用ix按索引标签和位置混合提取数据

df_inner.ix[:'2013-01-03',:4] #2013-01-03号之前，前四列数据

· 1

· 2

9、判断city列的值是否为北京

df_inner['city'].isin(['beijing'])

· 1

· 2

10、判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来

df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])]

· 1

· 2

11、提取前三个字符，并生成数据表

pd.DataFrame(category.str[:3])

· 1

· 2

六、数据筛选
使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。
1、使用“与”进行筛选

df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]

· 1

· 2

2、使用“或”进行筛选

df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])

· 1

· 2

3、使用“非”条件进行筛选

df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id'])

· 1

· 2

4、对筛选后的数据按city列进行计数

df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()

· 1

· 2

5、使用query函数进行筛选

df_inner.query('city == ["beijing", "shanghai"]')

· 1

· 2

6、对筛选后的结果按prince进行求和

df_inner.query('city == ["beijing", "shanghai"]').price.sum()

· 1

· 2

七、数据汇总
主要函数是groupby和pivote_table
1、对所有的列进行计数汇总

df_inner.groupby('city').count()

· 1

· 2

2、按城市对id字段进行计数

df_inner.groupby('city')['id'].count()

· 1

· 2

3、对两个字段进行汇总计数

df_inner.groupby(['city','size'])['id'].count()

· 1

· 2

4、对city字段进行汇总，并分别计算prince的合计和均值

df_inner.groupby('city')['price'].agg([len,np.sum, np.mean])

· 1

· 2

八、数据统计
数据采样，计算标准差，协方差和相关系数
1、简单的数据采样

df_inner.sample(n=3)

· 1

· 2

2、手动设置采样权重

weights = [0, 0, 0, 0, 0.5, 0.5]

df_inner.sample(n=2, weights=weights)

· 1

· 2

· 3

3、采样后不放回

df_inner.sample(n=6, replace=False)

· 1

· 2

4、采样后放回

df_inner.sample(n=6, replace=True)

· 1

· 2

5、数据表描述性统计

df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置

· 1

· 2

6、计算列的标准差

df_inner['price'].std()

· 1

· 2

7、计算两个字段间的协方差

df_inner['price'].cov(df_inner['m-point'])

· 1

· 2

8、数据表中所有字段间的协方差

df_inner.cov()

· 1

· 2

9、两个字段的相关性分析

df_inner['price'].corr(df_inner['m-point']) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关

· 1

· 2

10、数据表的相关性分析

df_inner.corr()

· 1

· 2

九、数据输出
分析后的数据可以输出为xlsx格式和csv格式
1、写入Excel

df_inner.to_excel('excel_to_python.xlsx', sheet_name='bluewhale_cc')

· 1

· 2

2、写入到CSV

df_inner.to_csv('excel_to_python.csv')

收起

Pandas库的详解和使用

2018-06-27 14:08:01

pandas 库总体说明

Pandas 基亍 NumPy、SciPy 补充了大量数据操作功能，能实现统计、凾组、排序、透规表，可以代替 Excel 的绛大部凾功能。

Pandas 主要有 2 种重要数据类型:Series、DataFrame(一维序列、二维表)。数据类型的转换需要用到 pd.Series/DataFrame.

1)Series

可以是一个样本的所有观测值戒一组样本的某一属性的观测值。

如利用 NumPy 生成一个正态凾布的随机数列，共含 4 个值。Series1 = pd.Series(np.random.randn(4))结果就自劢添加了行索引 index。

0 1 2 3

型的输出，后者给出具体的数值，仅仅输出 Series 中小亍 0 的数值。

可以使用 Key-Value 的斱式存储数据:
Series2 = pd.Series(Series1.values, index = ["row_" + unicode(i) for i in range(4)])同样，Python 的基础数据结构字典也可以转化为 Series。
Series3 = pd.Series({"China": "Beijing", "England": "GB", "Japan": "Tokyo"})输出结果依旧是一个序列，但是因为字典本身是无序的，所有有可能会打乱原字典的顸

序。如果需要顸便丌发，可以使用下面的斱法明确指定返种秩序:

Series4_IndexList = ["China", "Japan", "England"] Series4 = pd.Series(Series3, index = Series4_IndexList)

某些时候，Index 列表没有相应的对应值，返样会默认填补为空值，可以使用 isnull(0, notnull()来迒回 Boolean 结果。

Series5_IndexList = ["A", "B", "C", "C"]
Series5 = pd.Series(Series1.values, index = Series5_IndexList)

index 允许重复，但是返样容易导致错诨。

2)DataFrame

DataFrame 可以规作 Series 的有序集合，可以仍数据库、NumPy 二维数组、JSON 中定义数据框。

NumPy 二维数组:
微信公号:ChinaHadoop 新浪微博:ChinaHadoop

-1.344609 0.177173 0.554958

-0.576237
过滤 Series 的斱法是:print Series1 < 0 戒 print Series1[Series1 < 0]。前者给出 Boolean 类

DF1 = pd.DataFrame(np.asarray([("Japan", "Tokyo", 4000), ("S.Korea", "Seoul", 1000), ("China", "Beijing", 9000)]), columns = ["nation", "capital", "GDP"])

JSON:
DF2 = pd.DataFrame({"nation": ["Japan", "S.Korea", "China"], "capital": ["Tokyo", "Seoul",

"Beijing"], "GDP": [4000, 1000, 9000]})
但是字典的 key 是无序的,所以我们又要用到刚才 Series 中的类似斱法加以解决:DF3 = pd.DataFrame(DF2, columns = ["nation", "capital", "GDP"])对应地，迓可以人为指定行标秩序。
DF4 = pd.DataFrame(DF2, columns = ["nation", "capital", "GDP"], index = [2, 0, 1])

在 DataFrame 中凿片:

叏列:推荐使用 DF4["GDP"]，最好别用 DF4.GDP，容易不一些关键字(保留字)冲突

叏行:DF4[0: 1]戒者 DF4.ix[0]

区别在亍前者叏了第一行，后者叏了 index(行标)为 0 的第一行。

此外，如果要在数据框劢态增加列，丌能用.的斱式，而要用[] DF4["region"] = "East Asian"

9.3.2 代表性函数的使用介绍:

In [1]: import pandas as pd

In [2]: import numpy as np

In [3]: import matplotlib.pyplot as plt

一、创建对象

1、可以通过传递一个 list 对象来创建一个 Series:

In [4]: s = pd.Series([1,3,5,np.nan,6,8])In [5]: s
Out[5]:

1. 0 1.0

2. 1 3.0

3. 2 5.0

4. 3 NaN

5. 4 6.0

6. 5 8.0

dtype: float64

2、通过传递一个 numpy array，时间索引以及列标签来创建一个 DataFrame:

In [6]: dates = pd.date_range('20130101', periods=6)
In [7]: dates
Out[7]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',

'2013-01-05', '2013-01-06'], dtype='datetime64[ns]', freq='D')

In [8]: df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

In [9]: df

Out[9]:

2013-01-01

2013-01-02

2013-01-03

2013-01-04

2013-01-05

2013-01-06

ABCD 0.469112 -0.282863 -1.509059 -1.135632 1.212112 -0.173215 0.119209 -1.044236

-0.861849 -2.104569 -0.494929 1.071804 0.721555 -0.706771 -1.039575 0.271860 -0.424972 0.567020 0.276232 -1.087401 -0.673690 0.113648 -1.478427 0.524988

3、通过传递一个能够被转换成类似序列结构的字典对象来创建一个 DataFrame:

In [10]: df2 = pd.DataFrame({ 'A' : 1.,

· ....: 'B' : pd.Timestamp('20130102'),

· ....: 'C' :

pd.Series(1,index=list(range(4)),dtype='float32'),

· ....: 'D' : np.array([3] * 4,dtype='int32'),

· ....: 'E' :

pd.Categorical(["test","train","test","train"]),

....: 'F' : 'foo' })....:

In [11]: df2

Out[11]:

ABCDEF 0 1.0 2013-01-02 1.0 3 test foo 1 1.0 2013-01-02 1.0 3 train foo 2 1.0 2013-01-02 1.0 3 test foo 3 1.0 2013-01-02 1.0 3 train foo

4、查看不同列的数据类型:

In [12]: df2.dtypesOut[12]:

dtype: object

float64

datetime64[ns]

float32

int32

category

object

二、查看数据

1、查看 frame 中头部和尾部的行:

In [14]: df.head()

Out[14]:

ABCD 2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 2013-01-04 0.721555 -0.706771 -1.039575 0.271860 2013-01-05 -0.424972 0.567020 0.276232 -1.087401

In [15]: df.tail(3)Out[15]:

ABCD 2013-01-04 0.721555 -0.706771 -1.039575 0.271860 2013-01-05 -0.424972 0.567020 0.276232 -1.087401 2013-01-06 -0.673690 0.113648 -1.478427 0.524988

2、显示索引、列和底层的 numpy 数据:

In [16]: df.index
Out[16]:
DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-03', '2013-01-04',

'2013-01-05', '2013-01-06'], dtype='datetime64[ns]', freq='D')

In [17]: df.columns
Out[17]: Index([u'A', u'B', u'C', u'D'], dtype='object')

In [18]: df.values
Out[18]:
array([[ 0.4691, -0.2829, -1.5091, -1.1356],

[ 1.2121, -0.1732, 0.1192, -1.0442], [-0.8618, -2.1046, -0.4949, 1.0718], [ 0.7216, -0.7068, -1.0396, 0.2719], [-0.425 , 0.567 , 0.2762, -1.0874],

[-0.6737, 0.1136, -1.4784, 0.525 ]])

3、 describe()函数对于数据的快速统计汇总:

In [19]: df.describe()Out[19]:

ABCD count 6.000000 6.000000 6.000000 6.000000 mean 0.073711 -0.431125 -0.687758 -0.233103 std 0.843157 0.922818 0.779887 0.973118 min -0.861849 -2.104569 -1.509059 -1.135632 25% -0.611510 -0.600794 -1.368714 -1.076610

50% 0.022070 -0.228039 -0.767252 -0.386188 75% 0.658444 0.041933 -0.034326 0.461706 max 1.212112 0.567020 0.276232 1.071804

4、对数据的转置:

In [20]: df.T

Out[20]:

2013-01-01

A 0.469112

B -0.282863

C -1.509059

D -1.135632

2013-01-02

1.212112

-0.173215

0.119209

-1.044236

2013-01-03

-0.861849

-2.104569

-0.494929

1.071804

2013-01-04

0.721555

-0.706771

-1.039575

0.271860

2013-01-05

-0.424972

0.567020

0.276232

-1.087401

2013-01-06

-0.673690

0.113648

-1.478427

0.524988

5、按轴进行排序

In [21]: df.sort_index(axis=1, ascending=False)Out[21]:

DCBA 2013-01-01 -1.135632 -1.509059 -0.282863 0.469112 2013-01-02 -1.044236 0.119209 -0.173215 1.212112 2013-01-03 1.071804 -0.494929 -2.104569 -0.861849 2013-01-04 0.271860 -1.039575 -0.706771 0.721555 2013-01-05 -1.087401 0.276232 0.567020 -0.424972

2013-01-06 0.524988 -1.478427 0.113648 -0.673690

6、按值进行排序

In [22]: df.sort_values(by='B')Out[22]:

ABCD 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 2013-01-04 0.721555 -0.706771 -1.039575 0.271860 2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 2013-01-02 1.212112 -0.173215 0.119209 -1.044236

2013-01-06 -0.673690 0.113648 -1.478427 0.524988 2013-01-05 -0.424972 0.567020 0.276232 -1.087401

三、选择

虽然标准的 Python/Numpy 的选择和设置表达式都能够直接派上用场，但是作为工程使用的代码，推荐使用经过优化的 pandas 数据访问方式: .at, .iat, .loc, .iloc 和 .ix。

获取

1、选择一个单独的列，这将会返回一个 Series，等同于 df.A:

In [23]: df['A']

Out[23]:

2013-01-01 0.469112

2013-01-02

2013-01-03

2013-01-04

2013-01-05

2013-01-06

Freq: D, Name: A, dtype: float64

1.212112

-0.861849

0.721555

-0.424972

-0.673690

2、通过[]进行选择，这将会对行进行切片

In [24]: df[0:3]

Out[24]:

ABCD 2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804

In [25]: df['20130102':'20130104']Out[25]:

ABCD 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 2013-01-04 0.721555 -0.706771 -1.039575 0.271860

通过标签选择

1、使用标签来获取一个交叉的区域

In [26]: df.loc[dates[0]]Out[26]:

1. A 0.469112

2. B -0.282863

3. C -1.509059

4. D -1.135632

Name: 2013-01-01 00:00:00, dtype: float64

2、通过标签来在多个轴上进行选择

In [27]: df.loc[:,['A','B']]Out[27]:

AB 2013-01-01 0.469112 -0.282863 2013-01-02 1.212112 -0.173215 2013-01-03 -0.861849 -2.104569 2013-01-04 0.721555 -0.706771 2013-01-05 -0.424972 0.567020 2013-01-06 -0.673690 0.113648

3、标签切片

In [28]: df.loc['20130102':'20130104',['A','B']]Out[28]:

AB 2013-01-02 1.212112 -0.173215 2013-01-03 -0.861849 -2.104569 2013-01-04 0.721555 -0.706771

4、对于返回的对象进行维度缩减

In [29]: df.loc['20130102',['A','B']]Out[29]:
A 1.212112
B -0.173215

Name: 2013-01-02 00:00:00, dtype: float64

5、获取一个标量

In [30]: df.loc[dates[0],'A']Out[30]: 0.46911229990718628

6、快速访问一个标量(与上一个方法等价)

In [31]: df.at[dates[0],'A']Out[31]: 0.46911229990718628

通过位置选择

1、通过传递数值进行位置选择(选择的是行)

In [32]: df.iloc[3]Out[32]:

A
B
C
D
Name: 2013-01-04 00:00:00, dtype: float64

0.721555

-0.706771

-1.039575

0.271860

2、通过数值进行切片，与 numpy/python 中的情况类似

In [33]: df.iloc[3:5,0:2]Out[33]:

AB 2013-01-04 0.721555 -0.706771 2013-01-05 -0.424972 0.567020

3、通过指定一个位置的列表，与 numpy/python 中的情况类似

In [34]: df.iloc[[1,2,4],[0,2]]Out[34]:

AC 2013-01-02 1.212112 0.119209

2013-01-03 -0.861849 -0.494929 2013-01-05 -0.424972 0.276232

4、对行进行切片

In [35]: df.iloc[1:3,:]Out[35]:

ABCD 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804

5、对列进行切片

In [36]: df.iloc[:,1:3]Out[36]:

BC 2013-01-01 -0.282863 -1.509059 2013-01-02 -0.173215 0.119209 2013-01-03 -2.104569 -0.494929 2013-01-04 -0.706771 -1.039575 2013-01-05 0.567020 0.276232 2013-01-06 0.113648 -1.478427

6、获取特定的值

In [37]: df.iloc[1,1]

Out[37]: -0.17321464905330858In [38]: df.iat[1,1]
Out[38]: -0.17321464905330858

布尔索引

1、使用一个单独列的值来选择数据:

In [39]: df[df.A > 0]

Out[39]:

ABCD

2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 2013-01-04 0.721555 -0.706771 -1.039575 0.271860

2、选择数据:

In [40]: df[df > 0]

Out[40]:

ABCD

2013-01-01 0.469112

2013-01-02 1.212112

2013-01-03 NaN

NaN NaN NaN NaN 0.119209 NaN NaN NaN 1.071804

2013-01-04 0.721555 NaN NaN 0.271860 2013-01-05 NaN 0.567020 0.276232 NaN 2013-01-06 NaN 0.113648 NaN 0.524988

3、使用 isin()方法来过滤:

In [41]: df2 = df.copy()
In [42]: df2['E'] = ['one', 'one','two','three','four','three']In [43]: df2
Out[43]:

ABCDE 2013-01-01 0.469112 -0.282863 -1.509059 -1.135632 one 2013-01-02 1.212112 -0.173215 0.119209 -1.044236 one 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 two 2013-01-04 0.721555 -0.706771 -1.039575 0.271860 three 2013-01-05 -0.424972 0.567020 0.276232 -1.087401 four 2013-01-06 -0.673690 0.113648 -1.478427 0.524988 three

In [44]: df2[df2['E'].isin(['two','four'])]Out[44]:

ABCDE 2013-01-03 -0.861849 -2.104569 -0.494929 1.071804 two 2013-01-05 -0.424972 0.567020 0.276232 -1.087401 four

设置

1、设置一个新的列:

In [45]: s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))

In [46]: s1

Out[46]:

2013-01-02 1

2013-01-03 2

2013-01-04 3

2013-01-05 4

2013-01-06 5

2013-01-07 6

Freq: D, dtype: int64

In [47]: df['F'] = s1

2、通过标签设置新的值:

In [48]: df.at[dates[0],'A'] = 0

3、通过位置设置新的值:

In [49]: df.iat[0,1] = 0

4、通过一个 numpy 数组设置一组新值:

In [50]: df.loc[:,'D'] = np.array([5] * len(df))

上述操作结果如下:

In [51]: df

Out[51]:

ABCDF 2013-01-01 0.000000 0.000000 -1.509059 5 NaN 2013-01-02 1.212112 -0.173215 0.119209 5 1.0 2013-01-03 -0.861849 -2.104569 -0.494929 5 2.0 2013-01-04 0.721555 -0.706771 -1.039575 5 3.0 2013-01-05 -0.424972 0.567020 0.276232 5 4.0 2013-01-06 -0.673690 0.113648 -1.478427 5 5.0

5、通过 where 操作来设置新的值:

In [52]: df2 = df.copy()
In [53]: df2[df2 > 0] = -df2In [54]: df2
Out[54]:

ABCDF 2013-01-01 0.000000 0.000000 -1.509059 -5 NaN

2013-01-02 -1.212112 -0.173215 -0.119209 -5 -1.0 2013-01-03 -0.861849 -2.104569 -0.494929 -5 -2.0 2013-01-04 -0.721555 -0.706771 -1.039575 -5 -3.0 2013-01-05 -0.424972 -0.567020 -0.276232 -5 -4.0 2013-01-06 -0.673690 -0.113648 -1.478427 -5 -5.0

四、缺失值处理

在 pandas 中，使用 np.nan 来代替缺失值，这些值将默认不会包含在计算中

1、reindex()方法可以对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝:

In [55]: df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])In [56]: df1.loc[dates[0]:dates[1],'E'] = 1
In [57]: df1
Out[57]:

ABCDFE 2013-01-01 0.000000 0.000000 -1.509059 5 NaN 1.0 2013-01-02 1.212112 -0.173215 0.119209 5 1.0 1.0 2013-01-03 -0.861849 -2.104569 -0.494929 5 2.0 NaN 2013-01-04 0.721555 -0.706771 -1.039575 5 3.0 NaN

2、去掉包含缺失值的行:

In [58]: df1.dropna(how='any')Out[58]:

ABCDFE 2013-01-02 1.212112 -0.173215 0.119209 5 1.0 1.0

3、对缺失值进行填充:

In [59]: df1.fillna(value=5)Out[59]:

ABCDFE 2013-01-01 0.000000 0.000000 -1.509059 5 5.0 1.0 2013-01-02 1.212112 -0.173215 0.119209 5 1.0 1.0 2013-01-03 -0.861849 -2.104569 -0.494929 5 2.0 5.0 2013-01-04 0.721555 -0.706771 -1.039575 5 3.0 5.0

4、对数据进行布尔填充:

In [60]: pd.isnull(df1)Out[60]:

ABCDFE 2013-01-01 False False False False True False 2013-01-02 False False False False False False 2013-01-03 False False False False False True 2013-01-04 False False False False False True

操作

统计(相关操作通常情况下不包括缺失值)

1、执行描述性统计:

In [61]: df.mean()

Out[61]:

1. A -0.004474

2. B -0.383981

3. C -0.687758

D 5.000000

F 3.000000

dtype: float64

2、在其他轴上进行相同的操作:

In [62]: df.mean(1)Out[62]:

2013-01-01

2013-01-02

2013-01-03

2013-01-04

0.872735

1.431621

0.707731

1.395042

2013-01-05 1.883656

2013-01-06 1.592306

Freq: D, dtype: float64

3、对于拥有不同维度，需要对齐的对象进行操作。Pandas 会自动的沿着指定的维度进行广播:

In [63]: s

In [64]: s

Out[64]:

2013-01-01

2013-01-02

2013-01-03

2013-01-04

2013-01-05

2013-01-06

Freq: D, dtype: float64

In [65]: df.sub(s, axis='index')Out[65]:

ABCDF 2013-01-01 NaN NaN NaN NaN NaN 2013-01-02 NaN NaN NaN NaN NaN 2013-01-03 -1.861849 -3.104569 -1.494929 4.0 1.0

= pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)

NaN

1.0

3.0

5.0

NaN

2013-01-04 -2.278445 -3.706771 -4.039575 2.0 0.0 2013-01-05 -5.424972 -4.432980 -4.723768 0.0 -1.0 2013-01-06 NaN NaN NaN NaN NaN

Apply

1、对数据应用函数:

In [66]: df.apply(np.cumsum)Out[66]:

ABCDF

2013-01-01 0.000000 0.000000 -1.509059 5 NaN 2013-01-02 1.212112 -0.173215 -1.389850 10 1.0 2013-01-03 0.350263 -2.277784 -1.884779 15 3.0 2013-01-04 1.071818 -2.984555 -2.924354 20 6.0 2013-01-05 0.646846 -2.417535 -2.648122 25 10.0 2013-01-06 -0.026844 -2.303886 -4.126549 30 15.0

In [67]: df.apply(lambda x: x.max() - x.min())Out[67]:

1. A 2.073961

2. B 2.671590

C 1.785291

D 0.000000

F 4.000000

dtype: float64

直方图

In [68]: s = pd.Series(np.random.randint(0, 7, size=10))In [69]: s
Out[69]:
04

12 21 32 46 54 64 76 84 94 dtype: int64

In [70]: s.value_counts()Out[70]:

45 62 22 11 dtype: int64

字符串方法

Series 对象在其 str 属性中配备了一组字符串处理方法，可以很容易的应用到数组中的每个元素，如下段代码所示。变成小写。

In [71]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog','cat'])

In [72]: s.str.lower()Out[72]:
0a
1b

2c 3 aaba 4 baca 5 NaN

6 caba

7 dog

8 cat

dtype: object

六、合并

Pandas 提供了大量的方法能够轻松的对 Series，DataFrame 和 Panel 对象进行各种符合各种逻辑关系的合并操作。

用 concat()把 pandas 类合并到一起:

In [73]: df = pd.DataFrame(np.random.randn(10, 4))In [74]: df
Out[74]:

0123 0 -0.548702 1.467327 -1.015962 -0.483075 1 1.637550 -1.217659 -0.291519 -1.745505 2 -0.263952 0.991460 -0.919069 0.266046 3 -0.709661 1.669052 1.037882 -1.705775 4 -0.919854 -0.042379 1.247642 -0.009920 5 0.290213 0.495767 0.362949 1.548106 6 -1.131345 -0.089329 0.337863 -0.945867 7 -0.932132 1.956030 0.017587 -0.016692 8 -0.575247 0.254161 -1.143704 0.215897 9 1.193555 -0.077118 -0.408530 -0.862495

# break it into pieces

In [75]: pieces = [df[:3], df[3:7], df[7:]]

In [76]: pd.concat(pieces)Out[76]:

0123 0 -0.548702 1.467327 -1.015962 -0.483075 1 1.637550 -1.217659 -0.291519 -1.745505 2 -0.263952 0.991460 -0.919069 0.266046

3 -0.709661 1.669052 1.037882 -1.705775 4 -0.919854 -0.042379 1.247642 -0.009920 5 0.290213 0.495767 0.362949 1.548106 6 -1.131345 -0.089329 0.337863 -0.945867 7 -0.932132 1.956030 0.017587 -0.016692 8 -0.575247 0.254161 -1.143704 0.215897 9 1.193555 -0.077118 -0.408530 -0.862495

Join

Join 类似于 SQL 类型的合并

In [77]: left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})

In [78]: right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})In [79]: left
Out[79]:

key lval 0foo 1 1foo 2

In [80]: right

Out[80]:

key rval 0foo 4 1foo 5

In [81]: pd.merge(left, right, on='key')Out[81]:

key lval rval 0foo 1 4 1foo 1 5 2foo 2 4 3foo 2 5

Append

Append 将一行连接到一个 DataFrame 上

In [82]: df = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])In [83]: df
Out[83]:

ABCD 0 1.346061 1.511763 1.627081 -0.990582 1 -0.441652 1.211526 0.268520 0.024580 2 -1.577585 0.396823 -0.105381 -0.532532 3 1.453749 1.208843 -0.080952 -0.264610 4 -0.727965 -0.589346 0.339969 -0.693205 5 -0.339355 0.593616 0.884345 1.591431

6 0.141809 0.220390 0.435589 0.192451 7 -0.096701 0.803351 1.715071 -0.708758

In [84]: s = df.iloc[3]
In [85]: df.append(s, ignore_index=True)Out[85]:

ABCD 0 1.346061 1.511763 1.627081 -0.990582 1 -0.441652 1.211526 0.268520 0.024580 2 -1.577585 0.396823 -0.105381 -0.532532 3 1.453749 1.208843 -0.080952 -0.264610

4 -0.727965 -0.589346 0.339969 -0.693205 5 -0.339355 0.593616 0.884345 1.591431 6 0.141809 0.220390 0.435589 0.192451 7 -0.096701 0.803351 1.715071 -0.708758 8 1.453749 1.208843 -0.080952 -0.264610

七、分组

对于”group by”操作，我们通常是指以下一个或多个操作步骤: (Splitting)按照一些规则将数据分为不同的组; (Applying)对于每组数据分别执行一个函数; (Combining)将结果组合到一个数据结构中;

In [86]:

....:

df = pd.DataFrame({'A' : ['foo', 'bar', 'foo', 'bar','foo', 'bar', 'foo', 'foo'],

'B' : ['one', 'one', 'two', 'three','two', 'two', 'one', 'three'],

'C' : np.random.randn(8),'D' : np.random.randn(8)})

In [87]: df

Out[87]:

ABCD 0 foo one -1.202872 -0.055224

1 bar one -1.814470 2.395985 2 foo two 1.018601 1.552825 3 bar three -0.595447 0.166599

4 foo

5 bar

6 foo

7 foo three 1.928123 -1.623033

two 1.395433 0.047609

two -0.392670 -0.136473

one 0.007207 -0.561757

1、分组并对每个分组执行 sum 函数:

In [88]: df.groupby('A').sum()

Out[88]:

bar -2.802588 2.42611

foo 3.146492 -0.63958

2、通过多个列进行分组形成一个层次索引，然后执行函数:

In [89]: df.groupby(['A','B']).sum()Out[89]:

bar one -1.814470 2.395985

three -0.595447 0.166599

two -0.392670 -0.136473

foo one -1.195665 -0.616981

three 1.928123 -1.623033

two 2.414034 1.600434

Reshaping

Stack

In [90]:

....:

In [91]:

In [92]:

tuples = list(zip(*[['bar', 'bar', 'baz', 'baz','foo', 'foo', 'qux', 'qux'],

['one', 'two', 'one', 'two','one', 'two', 'one', 'two']]))

index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second']) df = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A',

'B'])

In [93]: df2 = df[:4]

In [94]: df2

Out[94]:

first second

bar one

two

baz one

two

0.029399 -0.542108

0.282696 -0.087302

-1.575170 1.771208

0.816482 1.100230

In [95]: stacked = df2.stack()In [96]: stacked

Out[96]:

first second bar one A

0.029399

B -0.542108

two A

B -0.087302

0.282696

baz one A
B 1.771208

-1.575170

two A

B 1.100230

dtype: float64

0.816482

In [97]: stacked.unstack()Out[97]:

first second
bar one 0.029399 -0.542108

two 0.282696 -0.087302 baz one -1.575170 1.771208 two 0.816482 1.100230

In [98]: stacked.unstack(1)Out[98]:
second one two first

bar A 0.029399 0.282696

B -0.542108 -0.087302

baz A -1.575170 0.816482

B 1.771208 1.100230

In [99]: stacked.unstack(0)Out[99]:
first bar baz

second

one A 0.029399 -1.575170

B -0.542108 1.771208

two A 0.282696 0.816482

B -0.087302 1.100230

数据透视表

In [100]: df = pd.DataFrame({'A' : ['one', 'one', 'two', 'three'] * 3,.....: 'B' : ['A', 'B', 'C'] * 4,

· .....: 'C' : ['foo', 'foo', 'foo', 'bar', 'bar', 'bar']* 2,

· .....: 'D' : np.random.randn(12),

· .....: 'E' : np.random.randn(12)})

· .....:

· In [101]: df

· Out[101]:

· ABCDE

1. 0 one A foo 1.418757 -0.179666

3. 1 one B foo -1.879024 1.291836

2
3
4
5
6
7
8
9
10
11 three C bar 0.648740 1.167115

two C foo 0.536826 -0.009614 three A bar 1.006160 0.392149 one B bar -0.029716 0.264599 one C bar -1.146178 -0.057409 two A foo 0.100900 -1.425638 three B foo -1.035018 1.024098 one C foo 0.314665 -0.106062 one A bar -0.773723 1.824375 two B bar -1.170653 0.595974

可以从这个数据中轻松的生成数据透视表:

In [102]: pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])Out[102]:
C bar foo
AB

one A -0.773723 1.418757 B -0.029716 -1.879024 C -1.146178 0.314665 three A 1.006160 NaN B NaN -1.035018 C 0.648740 NaN two A NaN 0.100900

B -1.170653 NaN

C NaN 0.536826

九、导入和保存数据

CSV

1、写入 csv 文件:

In [136]: df.to_csv('foo.csv')

2、从 csv 文件中读取:

In [137]: pd.read_csv('foo.csv')Out[137]:

Unnamed: 0

1. 0 2000-01-01

2. 1 2000-01-02

3. 2 2000-01-03

4. 3 2000-01-04

5. 4 2000-01-05

6. 5 2000-01-06

7. 6 2000-01-07

.. ...

0.266457

-1.170732

-1.734933

-1.555121

0.578117

0.478344

1.235339

...

-0.399641

-0.345873

0.530468

1.452620

0.511371

0.449933

-0.091757

...

-0.219582

1.653061

2.060811

0.239859

0.103552

-0.741620

-1.543861

...

1.186860

-0.282953

-0.515536

-1.156896

-2.428202

-1.962409

-1.084753

...

993 2002-09-20 -10.628548 -9.153563 -7.883146 28.313940 994 2002-09-21 -10.390377 -8.727491 -6.399645 30.914107 995 2002-09-22 -8.985362 -8.485624 -4.669462 31.367740 996 2002-09-23 -9.558560 -8.781216 -4.499815 30.518439 997 2002-09-24 -9.902058 -9.340490 -4.386639 30.105593 998 2002-09-25 -10.216020 -9.480682 -3.933802 29.758560 999 2002-09-26 -11.856774 -10.671012 -3.216025 29.369368

[1000 rows x 5 columns]

HDF5

1、写入 HDF5 存储:

In [138]: df.to_hdf('foo.h5','df')

2、从 HDF5 存储中读取:

In [139]: pd.read_hdf('foo.h5','df')Out[139]:

ABCD 2000-01-01 0.266457 -0.399641 -0.219582 1.186860 2000-01-02 -1.170732 -0.345873 1.653061 -0.282953 2000-01-03 -1.734933 0.530468 2.060811 -0.515536 2000-01-04 -1.555121 1.452620 0.239859 -1.156896 2000-01-05 0.578117 0.511371 0.103552 -2.428202

2000-01-06 0.478344 2000-01-07 1.235339 ... ... 2002-09-20 -10.628548 2002-09-21 -10.390377 2002-09-22 -8.985362 2002-09-23 -9.558560 2002-09-24 -9.902058 2002-09-25 -10.216020 2002-09-26 -11.856774

0.449933

-0.091757

...

-9.153563

-8.727491

-8.485624

-8.781216

-9.340490

-9.480682

-10.671012

-0.741620

-1.543861

...

-7.883146

-6.399645

-4.669462

-4.499815

-4.386639

-3.933802

-3.216025

-1.962409

-1.084753

...

28.313940

30.914107

31.367740

30.518439

30.105593

29.758560

29.369368

[1000 rows x 4 columns]

Excel

1、写入 excel 文件:

In [140]: df.to_excel('foo.xlsx', sheet_name='Sheet1')

2、从 excel 文件中读取:

In [141]: pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])

Out[141]:

2000-01-01 0.266457 2000-01-02 -1.170732 2000-01-03 -1.734933 2000-01-04 -1.555121 2000-01-05 0.578117 2000-01-06 0.478344 2000-01-07 1.235339 ... ... 2002-09-20 -10.628548 2002-09-21 -10.390377 2002-09-22 -8.985362 2002-09-23 -9.558560 2002-09-24 -9.902058 2002-09-25 -10.216020 2002-09-26 -11.856774

-0.399641

-0.345873

0.530468

1.452620

0.511371

0.449933

-0.091757

...

-9.153563

-8.727491

-8.485624

-8.781216

-9.340490

-9.480682

-10.671012

-0.219582

1.653061

2.060811

0.239859

0.103552

-0.741620

-1.543861

...

-7.883146

-6.399645

-4.669462

-4.499815

-4.386639

-3.933802

-3.216025

1.186860

-0.282953

-0.515536

-1.156896

-2.428202

-1.962409

-1.084753

...

28.313940

30.914107

31.367740

30.518439

30.105593

29.758560

29.369368

ABCD

[1000 rows x 4 columns]

收起

python 人工智能 pandas

pandas的使用

2018-10-09 21:40:27

导入pandas

import pandas as pd

pd.read_csv 读取csv文件

df = pd.read_csv('Titanic.csv') ‘Titanic.csv’文件

pd.read_csv 读取xlsx文件

df _score = pd.read_execel('score.xlsx')

df_imdb = pd.read_csv('IMDB.csv')

df_imdb.columns

df_imdb[''Title] 电影名称 = df_imdb.Title

df_imdb['Title'].head(3) 前三个

df_imdb['Revenue(Millions)'].max()获取最高票房

df_imdb['Revenue (Millions)'].idxmax()

df_imdb[50:51]

将DataFrame 第50行数据的Director列取出,取一到6的数据的时候不会吧6取出来

df_imdb[50:51]['Director']选出的导演

第一个维度是行，第二维度是列，将50到56行（包含50和56）的导演和年份取出来

df_imdb.loc[50:56,['Director','Year']]

df_imdb.iloc[1:10,2:3] 将1到10行（不包含第10行，及2到3列不包含3列）取出，使用整数索引caozuo

df _imdb[df_imdb['Revenue (Millions)',]>100]['Director']将票房大于5亿美元的电影选出来支持

df[df['Genre'].str.contains('Thriller')].含有恐怖片的

收起

numpy、pandas实用总结(遍历、重复值、缺失值、异常值、数据过滤、数据清洗)

2019-07-24 16:06:30

前言

· 最近工作中经常实用pandas，然而，却发现自己对于pandas的掌握并没有想象中的好，很多pandas的函数和用法，自己都不是特别的熟练，特此总结一下最近经常会使用的pandas用途和函数，增强记忆。

pandas用途之DataFrame遍历

· 按照行对于DataFrame进行遍历，得到每一行，然后对于行进行操作，取每一列的单个数据

· for index,row in df.iterrows():

· print(row['列名'],row['列名'])

· 如果需要得到每一行的每列的数据进行计算，则需要row[‘列名’].iloc[0]取出行中的单个元素

· 因为，单纯的取出row[‘列名’]是Series类型，会带有Series类型的一些索引等内容。

pandas用途之DataFrame数据查询重复，去除重复

· DataFrame数据查询和取出重复元素，都是根据df.duplicated来实现的

· 使用df.duplicated()来查询重复值，返回布尔类型的值

o 参数：subset，设置判断重复的时候，按照哪些列进行判断。

§ 可以使用列表的方式设置，subset = [“列a”,“列b”]

§ 可以使用字符串的方式定义，subset = “列a”

o 参数：keep，设置判断重复的时候，保留项

§ keep = “first”, 保留第一项

§ keep = “last”, 保留最后一项

§ keep = False，一个都不保留

posted @ 2020-08-30 10:54 _Origin 阅读(436) 评论(0) 收藏举报

刷新页面返回顶部

_Origin

数据分析

主要是python数据分析相关库（Pandas/ Numpy/Scipy/ Matplotlib）

Numpy简介：

Matplotlib简介：

我遇到的问题及解决：

公告