Python数据分析之pandas,matplotlib,numpy

第1章 实验环境的搭建

1-2 Anaconda和Jupyter notebook介绍

Anaconda是什么

1 最著名的Python数据科学平台
2 750流行的Python&R包
3 跨平台：windows,Mac,Linux
4 condaL:可扩展的包管理工具
5 免费分发
6 非常活跃的社区

Anaconda的安装

1 下载地址：https://www.anaconda.com/download/
2 检验是否安装成功
cd ~/anaconda
anaconda bin/conda --version

Conda的Environment管理

1 创建一个新的environment
conda create --name python34 python=3.4

2 激活一个environment 
activate python34  # for Windows
source activate python34  # for linuc & Mac

3 退出一个environment
deactivate python34  # for Windows
source deactivate python34

4 删除一个environment
conda remmove --name python34 --all

Conda的package的管理

1 Conda的包管理有点类似pip 
2 安装一个Python包
conda install numpy

3 查看已安装的Python包
conda list
conda list -n python34  # 查看指定环境安装的Python包

4 删除一个Python包
conda remove -n python34 numpy

什么是iPython

• 一个强大的交互式shell
• 是jupyter的kernel
• 支持交互式数据分析和可视化

什么是Jupyter Notebook

• 前身是IPython notebookl
• 一个开源的web application
• 可以创建和分享包含代码，视图，注释的文档、
• 可以用于数据统计，分析，建模，机器学习等领域

notebook的文件格式（.ipynb）

• 由Ipython Notebook 定义的一种格式（json）

• 可以读取在线数据，CSV/XLS文件

• 可以转化为其他格式，（py,html.pdf,md等）

NBViewer

• 一个online的ipynb格式notebook展示工具
• 可以通过URL分享
• Github集成了NBViewer
• 通过转换器轻松集成到Blogs Emails,Wikis,Books

实验室环境

1. 在Windows/Mac/Linux上安装Anaconda
2. 在使用Python3.6作为基础环境
3. 使用Jupyter Notebook 作为编程IDE

1-4 Anaconda在windows上安装演示

www.anaconda.com/products/in…

安装之后，按住win

点击jupyter botebook

浏览器输入localhost:8888

1-5 Anaconda在Linux上的安装演示

# 在linux机器中

wget https://repo.anaconda.com/archive/Anaconda3-2020.02-Linux-x86_64.sh
    
sh Anaconda3-2020.02-Linux-x86_64.sh

# 进入命令号
1 按回车
2 yes
3 选择安装目录，这个时候目录不变，回车
需要两分钟
4 安装完之后需要选择什么什么玩意，选择yes

在根目录中会看见一个anaconda的文件夹，进入文件夹可以看到很多目录
cd ~/anaconda3
cd bin

可以很多的文件夹
./anaconda --version  # 查看conda版本号

./jupyter notebook --no-browser  # 在本地运行jupyter

#要是抛错Running as root is not recommended. Use --allow-root to bypass.
 ./jupyter notebook --no-browser --allow-root

# 但是这样只能本地访问jupyter，如何实现远程访问呢？
ssh端口转发
# 在本地执行端口转发命令
ssh -N -f -L localhost:8888:localhost:8888 root@{ip地址}
>>>password


# 本地浏览器执行localhost:8888,就可以看见linux上的jupyter的页面了
执行print('hello world')

# jupyter执行命令行
:ifconfig
    
   

1-6 Jupyter-notebook的使用演示

进入jupeter浏览器中之后
点击new-->Terminal,显示命令行界面

# 换目录执行jupeter，并把当前目录当做工作目录
/root/anaconda3/bin/jupyter notebook --no-browser --allow-root

第2章 Numpy入门

2-1 数据科学领域5个常用Python库

numpy
scipy
Pandas
Matplotlib
Scikit-learn

Number

数据处理里面最基础的库

1. N维数组（矩阵），快速高效，矢量数学运算
2. 高效的index,不需要循环
3. 开源免费跨平台，运行效率足以和C/Matlab媲美

Scipy

1. 依赖于Numpy
2. 专为科学和工程设计
3. 实现了多种常用科学计算：线性代数，傅里叶变换，信号和图像处理

Pandas

1. 结构化数据分析利器（依赖Numpy）
2. 提供了多种高级数据结构：Time-Series,DataFrame,Panel
3. 强大的数据索引和处理能力

Matplotlib

1. Python 2D绘图领域使用最广泛的套件
2. 基本能取代Matlab的绘图功能（散点，曲线，柱形等）
3. 通过mplot3d可以绘制精美的3D图

Scikit-learn

1. 机器学习的Python模块
2. 建立在Scipy之上，提供了常用的机器学习算法：聚类，回归
3. 简单易学的API接口

2-2 数学基础回顾之矩阵运算

基本概念

1. 矩阵：是指1xn或者nx1的矩阵
2. 标量：1x1的矩阵
3. 数组：N维的数组，是矩阵的延伸

特殊矩阵

矩阵加减运算

1. 相加，相减的两个矩阵必须要有相同的行和列
2. 行和列对应元素相加减

数组乘法(点乘）

矩阵乘法

清华大学出版的线性代数

 	http://www.wdfxw.net/goDownFiles.aspx?key=92039718

2-3 Array的创建及访问

import munpy as np
# create from python list
list_1 = [1,2,3,4]

array_1 = np.array(list_1)  # 生成一个一维数组

list_2 = [6,7,8,9]
array_2 = np.array([list_1,list_2])  # 创建一个二维数组

print(array_2)
print(array_2.size)  #数组里元素的个数
print(array_2.shape)  # 查看矩阵或数组的维数
print(array_2.dtype)  #数组元素的类型


array_4 = np.arange(1,10,2)  # 使用arange创建数组
print(array_4)  # array([1, 3, 5, 7, 9])
np.zeros(5)  # 全0矩阵 array([0., 0., 0., 0., 0.])

np.zeros([2,3])  # 多维全0矩阵
array([[0., 0., 0.],
       [0., 0., 0.]])


np.eye(5)  # 单位矩阵
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])



# 数组的访问
a = np.arange(10)
print(a)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a[2]  # 2
a[1:5]  # array([1, 2, 3, 4])
b = np.array([[1,2,3,4],[5,6,7,8]])  # 矩阵
b[1,0]  # 矩阵取值（第二个数组第一个值）  # 5
c = np.array([[1,2,3],[4,5,6],[7,8,9]])
c[:2,1:]  # 第一个元素是行，第二个元素是列
#array([[2, 3],[5, 6]])

2-4 数组与矩阵运算

快速创建数组

import numpy as np

np.random.randn(10)  # 创建一个十维数组，且是动态分布的

"""
array([-0.7512065 ,  0.97527973, -1.24433992,  0.86890475, -0.51251532,
       -0.02522675, -0.40664444,  0.66399272, -0.94669869,  1.52843227])
"""
np.random.randint(10)  # 返回一个10以内的随机整数

np.random.randint(10, size=(2,3))  #返回一个值在10以内的2x3的数组  
"""
array([[1, 8, 1],
       [6, 1, 8]])
"""

np.random.randint(10,size=20).reshape(4,5)  #返回一个大小为20的4x5的整数随机数组
"""
array([[6, 6, 4, 8, 9],
       [0, 9, 1, 0, 8],
       [6, 2, 6, 1, 3],
       [5, 4, 8, 9, 2]])
"""

数组的运算

a = np.random.randint(10,size=20).reshape(4,5)
b = np.random.randint(10,size=20).reshape(4,5)
# 生成的a,b都是一个元素值小于10，数量为20的一个4x5的多维数组

a+b  # 多维数组相加减就是对应位置元素值相加
a-b  # 多维数组相加减就是对应位置元素值相减
a * b # 多维数组相乘就是对应位置元素值相乘
a / b # 多维数组相乘就是对应位置元素值做除法--有的时候会抛错，是因为如果数学运算中0不能做除数

矩阵

矩阵的命令其实跟数组差不多
np.mat([[1,2,3],[4,5,6]])  #创建一个矩阵
"""
matrix([[1, 2, 3],
        [4, 5, 6]])
"""

# 数组转化为矩阵
a = np.array([1,2,3])
np.mat(a)  # matrix([[1, 2, 3]])

矩阵的运算

A = np.mat(np.random.randint(10,size=20).reshape(4,5))
B = np.mat(np.random.randint(10,size=20).reshape(4,5))
A+B  # 元素相加
A-B # 元素值相减

# 矩阵的乘法运算要求第一个值得行和第二个值的列数量一致
A = np.mat(np.random.randint(10,size=20).reshape(4,5))
B = np.mat(np.random.randint(10,size=20).reshape(5,4))

A * B
"""
matrix([[ 59, 137,  69,  80],
        [ 77, 174, 124, 142],
        [ 48, 128,  44, 124],
        [ 54, 121, 102,  94]])
"""

Array常用函数

import numpy as np

a = np.random.randint(10, size=20).reshape(4,5)
np.unqiue(a)  # 数组里面的唯一值

sum(a)  #将矩阵的所有的列的和重新组合成一个数组
"""
matrix([[21, 16, 24, 17,  9]])
"""

sum(a[0])  # 计算某一行的值
sum(a[:,0])  # 计算某一列的值

A.max()  #查看数组中最大值

a.max(a[0])  # 查看第一行的最大值
a.max(a[：，0])  # 查看第一列的最大值

2-5 Array的input和output

import numpy as np
x = np.arange(10)

# 将数组保存到硬盘
f = open('x.pk1','wb') 
pickle.dump(x,f)

# 读取硬盘中的数组 
f = open('x.pk1','rb')
pickle.load(f)


np.save('one_array',x)  # 将数组序列化到硬盘
np.load('one_array.npy')  # 读取文件

a = np.arange(10)
b = np.arange(20)
np.savez('two_array.npz',a=a,b=b)  # 一个文件保存多个数组
c = np.load('two_array.npz')  # 取数组
c['a']
c['b']

第3章 Pandas入门

3-1 Pandas Series

import numpy as np
import pandas as pd
s1 = pd.Series([1,2,3,4,1])  # 创建一个Series对象
s1  # 两列数据，第一列是索引，第二列是值
"""
0    1
1    2
2    3
3    4
4    1
dtype: int64
"""
s1.values  # 获取值--array([1, 2, 3, 4, 1])
s1.index  # 获取索引--RangeIndex(start=0, stop=5, step=1)
s2 = pd.Series(np.arange(10))  # 传一个数组
s3 = pd.Series({'1':1,'2':2,'3':3})  # 传入一个字典
s3.index
"""
Index(['1', '2', '3'], dtype='object')
"""
s4 = pd.Series([1,2,3,4],index=['A','B','C','D'])
s4.values  # array([1, 2, 3, 4])
s4.index  # Index(['A', 'B', 'C', 'd'], dtype='object')
s4['A']  # 按照字典方式取值
s4[s4>2]  # 返回字典里面值大于2的数据组成一个新的数组
s4.to_dict()  # 将Series对象转化为字典
"""
{'A': 1, 'B': 2, 'C': 3, 'd': 4}
"""


s5 = pd.Series(s4.to_dict())  # Series传入字典重新生成Series对象

index_1 = ['O','A','B','C','D','E']  # 定义一个索引列表
s6 = pd.Series(s5,index=index_1)  # 替换索引
s6  # 发现索引没有对应值的时候，值为NaN
"""
O    NaN
A    1.0
B    2.0
C    3.0
D    NaN
E    NaN
dtype: float64
"""

pd.isnull(s6)  # 判断是否为空
"""
O     True
A    False
B    False
C    False
D     True
E     True
dtype: bool
"""

pd.notnull(s6)  # 判断不为空
"""
O    False
A     True
B     True
C     True
D    False
E    False
dtype: bool
"""

s6.name = 'demo'  # Series指定名字
"""
O    NaN
A    1.0
B    2.0
C    3.0
D    NaN
E    NaN
Name: demo, dtype: float64
"""

s6.index.name='demo index'  # Series的索引指定名字

"""
Index(['O', 'A', 'B', 'C', 'D', 'E'], dtype='object', name='demo index')
"""

s6.index 
"""
Index(['O', 'A', 'B', 'C', 'D', 'E'], dtype='object', name='demo index')
"""

s6.values

"""
array([nan,  1.,  2.,  3., nan, nan])
"""

3-2 Pandas DataFrame

下面就是从粘贴板上获取的数据，下文中的"df"

Jun 2020	Jun 2019	Change	Programming Language	Ratings	Change
1	2		C	17.19%	+3.89%
2	1		Java	16.10%	+1.10%
3	3		Python	8.36%	-0.16%
4	4		C++	5.95%	-1.43%
5	6		C#	4.73%	+0.24%
6	5		Visual Basic	4.69%	+0.07%
7	7		JavaScript	2.27%	-0.44%
8	8		PHP	2.26%	-0.30%
9	22		R	2.19%	+1.27%
10	9		SQL	1.73%	-0.50%

import numpy as np
import pandas as pd
from pandas import Series, DataFrame

# 自动打开一个网页
import webbrowser
link = 'https://www.tiobe.com/tiobe-index/'
webbrowser.open(link)

# 从粘贴板重获取数据存为DataFrame文件
df = pd.read_clipboard()

print(type(df))  # pandas.core.frame.DataFrame
df.columns  # 返回DataFrame所有的列
"""
Index(['Jun 2020', 'Jun 2019', 'Change', 'Programming Language', 'Ratings',
       'Change.1'],
      dtype='object')
"""

df.Change  # 获取df中某一列的数据（本次是选择Change）

# 根据表头过滤数据，生成新的dateframe
df_new = DataFrame(df,columns=['Jun 2020', 'Jun 2019', 'Change'])  
df["Jun 2019"]  # 通过字典的方式访问数据

# 新添加一个column的话，一列值都是NaN
df_new = DataFrame(df,columns=['Change', 'Programming Language', 'Ratings','new_column'])  

df_new['new_column'] = range(10)  # 为这新添加的一列所有元素赋值
df_new['new_column'] = np.arange(10)  # 使用数组赋值
df_new['new_column'] = pd.Series(np.arange(10))  # 使用Series对象赋值

# 使用Series为某一列指定行数赋值
df_new['new_column'] = pd.Series([100,200],index=[1,2]) 

3-3 深入理解Series和Dataframe

data = {
	'Country': ['Belgium','India','Brazil'],
    'Capital':['Brussels','New Belhi','Brasilia'],
	'Population':[11190846,1303171035,207847528]
}

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

# Series
# 创建一个Series对象
s1 = pd.Series(data['Country'], index=['A','B','C'])
s1
"""
A    Belgium
B      India
C     Brazil
dtype: object
"""

# 为Series对象添加名字
s1.name='Country'  

s1.values  
"""
array(['Belgium', 'India', 'Brazil'], dtype=object)
"""
s1.index
"""
Index(['A', 'B', 'C'], dtype='object')
"""

DataFrame

df1 = DataFrame(data)  # DataFrame直接传入字典
cap = df1['Capital']
# 一个DataFrame是由多个Series组成的

type(cap)  
df1.iterrows()  # DataFrame的生成器对象
[i for i in df1.iterrows()]  #  循环生成器取值

使用series对象生成DataFrame

# 生成3个Series对象
s1 = Series(data['Country'])
s2 = Series(data['Capital'])
s3 = Series(data['Population'])

# 通过series对象生成DataFrame，并添加columns
df_new = DataFrame([s1,s2,s3], index=['Country','Capital','Population'])

# 翻转行列
df_new = df_new.T

print(df_new)

3-4 Pandas-Dataframe-IO操作

pandas.pydata.org/pandas-docs…

import numpy as np
import pandas as pd 
from pandas import Series,DataFrame

import webbrowser
link = 'https://pandas.pydata.org/pandas-docs/version/0.20/io.html'
webbrowser.open(link)  # 从浏览器中打开链接

df1 = pd.read_clipboard()  # 从粘贴板读

df1.to_clipboard()  # 将df1写入到粘贴板
df1.to_csv("df1.csv")  # 将dataFrame文件写入到本地csv
!more df1.csv  # 查看csv文件

df2 = pd.read_csv('df1.csv')  # csv的读取
df1.to_json()  # 将 dataframe数据转化为json格式

pd.read_json(df1.to_json())  # 将json格式数据读取为dataframe格式
df1.to_html('df1.html')  # 将dataframe转为html
df1.to_excel('df1.xlsx')  # 将dataframe数据转存为excel
pd.read_excel('df1.xlsx')  # 从excel中读取数据

3-5 DataFrame的Selecting和indexing

import pandas as pd
import numpy as np
from pandas import Series,DataFrame

imdb = pd.read_csv('movie_metadata.csv')  # 读取csv文件
imdb.shape  # 显示（行，列）,是一个元组
imdb.head() # 返回前五行，口号里面可以写行数
imdb.tail()  # 默认但会后五行，之定义的话在括号里填写数字

# 以python字典key的方式
imdb['director_facebook_likes']  # 返回某个column下面的数据
imdb[['director_name','director_name']]  # 返回多个column的数据


sub_df = imdb[['director_name','movie_title','imdb_score']]  # 读取指定列
sub_df.iloc[10:20,0:]    # iloc指定行列，','前面是行切片，后面是列切片

tmp_df = imdb[['director_name','movie_title','imdb_score']].iloc[10:20,0:2]  #  iloc获取10行两列
tmp_df.iloc[2:4,:]  # 获取两行数据
tmp_df.loc[15:17,:'director_name']  # loc指定行，截止列

注：带有i就是基于索引的

3-6 Series和Dataframe的Reindexing

reindex Series

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

s1 = Series([1,2,3,4], index=['A','B','C','D'])  # 生成一个Series对象
s1.reindex(index=['G','A','B','C','D','F','E'])  # 更新索引，不存在值得索引值为NaN

# 更新索引，并且索引对应的值为NaN的话，赋值为10
s1.reindex(index=['G','A','B','C','D','F','E'],fill_value=10)
s2 = Series(['A','B','C'], index=[1,5,10])  # 创建一个Series对象
s2.reindex(index=range(15),method='ffill')  # 索引变成15个，索引向左填充

reindex dataframe

df1 = DataFrame(np.random.rand(25).reshape([5,5]))  # 生成一个5x5的随机小数DataFrame对象
df1 = DataFrame(np.random.rand(25).reshape([5,5]),index= ['A','B','D','E','F'],columns=['c1','c2','c3','c4','c5']) # 生成一个5x5的随机小数DataFrame对象,指定索引和column


df1.reindex(index=['A','B','C','D','E','F'])  # 更新行索引，不存在填充NAN
df1.reindex(columns=['a1','a2','c1','c2'])  # 更新列索引，不存在NaN
df1.reindex(index=['A','B','C','D','E','F'],columns=['a1','a2','c1','c2'])  # 添加行，列的索引


s1.drop('A')  # Series删除一个index
df1.drop('A',axis=0)  #Dataframe删除索引为1的一行
df1.drop('c1',axis=1)  #DataFrame删除column为c1的一列

3-7 谈一谈NaN

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

n = np.nan  # 定义域个NaN数据
type(n)  #float 是一个浮点型数据
m = 1
print(m+n)  # nan,任何数和nan相加还是nan

#定义一个含有NaN数据的Series
s1 = Series([1,2,np.nan,4,5],index=['A','B','C','D','E'])  

s1.isnull()   # 判断是否为NaN
s1.notnull()
s1.dropna()  # 把NaN数据删除掉

# 列表套列表生成DataFrame对象
dframe = DataFrame([[1,2,3],[np.nan,5,6],[7,np.nan,9],[np.nan,np.nan,np.nan]])  

dframe.isnull()
dframe.notnull()

dframe.dropna(axis=0,how='any')    # 删除有NaN的行
dframe.dropna(axis=1,how='any')    # 删除有NaN的列
# 当how='all'的时候，对应行、列都为NaN的时候才删除

删除NaN和NaN的替换

dframe2 = DataFrame([[1,2,3,n],[2,n,5,6],[n,7,n,9],[1,n,n,n]])  # 定义一个4X4的DataFrame对象
dframe2.dropna(thresh=2)  # 大于等于几个非NaN的值得行就留下
dframe2.fillna(value=1)  # 把所有的NaN改成1
dframe2.fillna(value={0:0,1:1,2:2,3:3})  # 字典里面key=列，value=值，把第几列的NaN替换成value

3-8 多级Index

s1 = Series(np.random.randn(6), index=[['1','1','1','2','2','2'],['a','b','c','a','b','c']])  # 常见一个多级index的Series对象
s1['1']['a']  # 2.371817008763328,去index对应的值

s1[:,'a']  # 忽略一级index，直接去二级的index
"""
1    2.371817
2    0.782539
dtype: float64
"""

s1.unstack()  # 拥有多级index的Series通过unstack变成DataFrame
"""
	a	b	c
1	0.487468	1.150074	-1.077194
2	1.068546	-0.459993	-0.131780
"""

df2 = DataFrame([s1['1'],s1['2']])  # 通过两个Series创建DataFrame
"""
	a	b	c
0	0.487468	1.150074	-1.077194
1	1.068546	-0.459993	-0.131780
"""

s2 = df2.T.unstack()  # 将DataFrame变成多级index的Series

df = DataFrame(np.arange(16).reshape(4,4))

# 多级index的DataFrame
df = DataFrame(np.arange(16).reshape(4,4), index=[['a','a','b','b'],[1,2,1,2]],columns=[['BJ','TJ','SH','WH'],[1,2,1,2]])

type(df['BJ'][1])  # df['BJ'][1]

3-9 Mapping和Replace

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
df1 = DataFrame({'城市':['北京','上海','广州'],'人口':[1000,2000,3000]})  # 通过字典创建一个DataFrame
df1
"""
	城市	人口
0	北京	1000
1	上海	2000
2	广州	3000
"""
df1['GDP'] = Series([0.1,0.2,0.3])  # 添加一个Column并且赋值

df1['GDP'] = df1['城市'].map({'北京':1,'上海':2,'广州':3})  # 添加columns和数据

# Replace
s1 = Series(np.arange(10))
"""
0    0
1    1
2    2
3    3
dtype: int64
"""

s1.replace(to_replace=3,value=np.nan)  # 将第三个值替换成NaN
"""
0    0.0
1    1.0
2    2.0
3    NaN
dtype: float64
"""

s1.replace([1,2,3],[10,20,30])  # 同时替换多个值

"""
s1.replace([1,2,3],[10,20,30])  # 同时替换多个值
"""

第4章 Pandas玩转数据

4-1 DataFrame的简单数学计算

Series的运算

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
s1 = Series([1,2,3], index=['A','B','C'])
s2 = Series([4,5,6,7], index=['B','C','D','E'])
s1+s2  # 两个Series之间相加，是按照index来的，有因为NaN跟任何数运算都是NaN，所以会出现下述结果
"""
A    NaN
B    6.0
C    8.0
D    NaN
E    NaN
dtype: float64
"""

DataFrame的运算

df1 = DataFrame(np.arange(9).reshape(3,3), index=['A','B','C'], columns=['BJ','SH','WH'])
df2 = DataFrame(np.arange(4).reshape(2,2), index=['A','B'], columns=['BJ','SH'])
df1+df2  # 对应行列位置的数据相加，如果一方为NaN对应数据之和也为NaN
"""
	BJ	GZ	SH
A	0.0	NaN	2.0
B	5.0	NaN	7.0
C	NaN	NaN	NaN
"""

df3 = DataFrame([[1,2,3],[4,5,np.nan],[7,8,9]],index=['A','B','C'], columns=['c1','c2','c3'])
df3.max()  # 每一个column的最大值
df3.sum()# 按照column求和
df3.min()  # 每一个column的最小值
# 注：在括号中加上axis=1就是按照index使用上述方法运算求值
df3.describe()  #  一个dataframe的详细运算信息（按照column来的）

4-2 Series和DataFrame的排序

Series排序

s1 = Series(np.random.randn(10))  # 生成一个值随机的Series
s1.sort_values(ascending=False)  #  series根据value排序，ascending默认为True，降序排列，False为升序排列
s1.sort_index(ascending=True)  # 根据index排序,ascending默认为True，降序排列，False为升序排列

DataFrame排序

df1 = DataFrame(np.random.arange(40).reshape(8,5), columns=['A','B','C','D','E'])
df1['A'].sort_values()  # 获取A这一列的数据，是一个Series，然后根据value排序
df2 = df1.sort_values('A')  # 根据A这一列的数据排序，其他列对应变化
df2.sort_index(ascending=False)  # 根据索引排序，ascending表示正序还是倒叙
df2[['A','B']]  # 获取dataframe指定column，生成一个新的DataFrame

练习

# https://www.kaggle.com/karrrimba/movie-metadatacsv
1 保留imdb_score,director_name,movie_title这几个column
2 使用imdb_score排序，倒序
3 使用一行代码

# code
df = pd.read_csv('movie_metadata.csv')[['imdb_score','director_name','movie_title']].sort_values('imdb_score',ascending=False)

df.iloc[:20,:]  # 取前20条数据
# 或者df.head(20)

4-3 重命名Dataframe的index

df1 = DataFrame(np.random.randn(9).reshape(3,3), index=['BJ','SH','GZ'], columns=['A','B','C'])
# 1直接将索引使用一个新的Series覆盖
df1.index = Series(['bi','sh','gz'])  
# 2使用map遍历每一个index,使之大写，然后覆盖原值
df1.index = df1.index.map(str.upper)  
# 3使用rename修改
df1.rename(index=str.lower,columns=str.lower)  
# 4 使用rename传入字典
df1.rename(index={'BJ':'beijing'}, columns={'A':'a'})
# rename中可以写一个自己定义的函数，然后索引元素一次作用，生成一个新的Series对象
df1.rename(index=lambda x:x+'_ABC') 

4-4 DataFrame的merge操作

df1 = DataFrame({'key':['A','y','z'],'data_set_1':[1,2,3]})
df2 = DataFrame({'key':['A','B','C'],'data_set_2':[4,5,6]})
#  how就是数据库中的内连接，左连接和右连接，外连接，on就是按照那个column做合并
pd.merge(df1,df2,how='left',on='key')  

4-5 Concatenate和Combine

arr1 = np.arange(9).reshape(3,3)
arr2 = np.arange(9).reshape(3,3)
np.concatenate([arr1,arr2])  # 连接两个矩阵，增加行数
np.concatenate([arr1,arr2],axis=1)  # 连接链两个矩阵，在同一行的数据追加

# concat
s1 = Series([1,2],index=['X','Y'])
s2 = Series([3,4], index=['A','B'])
pd.concat([s1,s2])  #  合并两个矩阵,生成一个新的Series
pd.concat([s1,s2], axis=1)  # 生成一个Dataframe

df1 = DataFrame(np.random.randn(9).reshape(3,3), columns=['X','Y','Z'])
df2 = DataFrame(np.random.randn(3,3),columns=['X','Y','A'])
pd.concat([df1,df2])  # 两个dataframe结合

#combine
s1 = Series([1,np.nan,3,np.nan], index=['A','B','C','D'])
s2 = Series([np.nan,2,np.nan,4], index=['A','B','C','D'])
s1.combine_first(s2)  # 使用combine合并两个Series

df1 = DataFrame(
    {
        'A':[1,np.nan,2,np.nan],
        'B':[3,np.nan,4,np.nan],
        'C':[5,np.nan,6,np.nan],
    }
)

df2 = DataFrame(
    {
        'A':[np.nan,2,np.nan,1],
        'X':[np.nan,3,np.nan,4],
        'Y':[np.nan,5,np.nan,6],
    }
)

df1.combine_first(df2)  # 结合两个dataframe，类似于数据库的外连接

4-6 通过apply进行数据预处理

批量改变dataframe中的一列或者一行

# 创建一个dataframe数据
df = DataFrame({
    'time':[int(time.time()),int(time.time()),int(time.time()),int(time.time()),int(time.time())],
    'data':['Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:1 Price:1623',]
})

df.to_csv('apply_demo.csv')  # 写入到csv文件
pd.read_csv('apply_demo.csv')  # 读取csv文件
df['A']=Series(['a']*5)  # 添加一个column，并且赋值为a
df['A'] = df['A'].apply(str.upper)  # 使用apply将A这个column的value变成大写


# 写一个方法
def foo(line):
    r = [i.split(':')[1] for i in line.strip().split(' ')]
    return Series([i.split(':')[1] for i in df['data'][0].strip().split(' ')])


df_tmp = df['data'].apply(foo)  # 将dataframe中的一列取出来序列化成新的dataframe
# 使用rename将datafram中的column重命名
df_tmp = df_tmp.rename(columns={0:'Symbol',1:'Seqno',2:'Price'})  

df_new = df.combine_first(df_tmp)  # 合并两个dataframe

# 删除datafram中的column
del df_new['data']
del df_new['a']

df_new.to_csv('homework/demo_duplicate.cvs')

4-7 通过去重进行数据清洗

df = pd.read_csv('demo_duplicate.csv')
del df['Unnamed: 0']  # 删除dataframe中的一列数据
df['Seqno'].duplicated()  # 查看一列数据中的数据是否唯一,是一个Series数据
df['Seqno'].unique()  #  取一列数据中的去重后的数据组成一个新的数组
df.size  #  查看DataFrame的大小
len(df)  # 查看DataFrame数据的长度
df['Seqno'].unique()  # 使用unique根据Seqno去重得到一个array
df['Seqno'].drop_duplicates()  # 去除重复 ，一个Series格式的数据

# 根据字段去重,keep默认为first,表示保留第一个，last就是保留最后一个
df.drop_duplicates(['Seqno'], keep='last')  

4-8 时间序列操作基础

from datetime import datetime
s = datetime(2017,9,14)  # 创建一个时间类型的数据

# 创建以一个DataFrame的时间类型数据
date_list = [
    datetime(2016,9,1),
    datetime(2016,9,2),
    datetime(2018,8,8),
    datetime(2017,11,18),
    datetime(2018,11,23)
]

# 生成了一个Series
s1 = Series(np.random.rand(5),index=date_list)
s1[0]  # 0.3924387445867362
s1[datetime(2016,9,1)]  #  0.3924387445867362
s1['2016-9-1']
"""
2016-09-01    0.392439
dtype: float64
"""
s1['20160901']

"""
2016-09-01    0.392439
dtype: float64
"""

s1['2016-9']




#start: 开始时间
#end: 结束时间
#periods:时间总条数
#freq: d是按照天，w是按照周，Y是按照年，5H就是时间的间隔是5小时
# freq写‘W-MON’是严格按照周一开始的数据

date_list_new = pd.date_range('2000-01-01',periods=100,freq='5H')  # 产生一段时间以内的datetime类型的数据

s2 = DataFrame(np.random.randn(100),index=date_list_new)

4-9 时间序列数据的采样和画图

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

t_range = pd.date_range('2016-01-01','2016-12-31')  # 生成一个时间类型的索引
s1 = Series(np.random.randn(len(t_range)), index=t_range)  # 生成一个Series

s1['2016-01'].mean()  #計算2016-01月份的平均值
s1_month = s1.resample('M').mean()  # 將s1按照月份重新取樣，獲取平均值

s1.resample('H').ffill()  # 按照小时取样

下面展示画图

# 下面展示画图
t_range = pd.date_range('2016-01-01','2016-12-31', freq='H')  # 创建时间索引
# 创建一个dataFrame数据
stock_df = DataFrame(index=t_range)  
# 添加一个column,并设置随机值，大小是t_range的长度
stock_df['BABA']=np.random.randint(80,160, size=len(t_range))  
stock_df['TENCENT'] = np.random.randint(30,50, size=len(t_range))

stock_df.plot() # 将dataframe变成图

析入门与实践

我们看到这个图片上面由于数据较多，折线较密集

weekly_df= DataFrame()  # 创建一个新的DataFrame数据
weekly_df['BABA'] = stock_df['BABA'].resample('W').mean()  # 按照周平均值取样
weekly_df['TENCENT'] = stock_df['TENCENT'].resample('W').mean()  # 按照周平均值取样
weekly_df.plot()

4-10 数据分箱技术Binning

score_list = np.random.randint(25,100,size=20)  # 生成一个25-100的随机数组
bins=[0,59,70,80,100]  # 一个分段数组
score_cat=pd.cut(score_list,bins)  # 进行数据分箱
pd.value_counts(score_cat)  # 只用pd.value_counts进行分组和个数显示
"""
(0, 59]      7
(70, 80]     6
(80, 100]    4
(59, 70]     3
dtype: int64
"""

# 对DataFrame数据进行分箱
df = DataFrame()
df['socre'] = score_list
# 实例化学生姓名（随机取三个字符）

df['student'] = [pd.util.testing.rands(3) for i in range(20)]  
# 将score分箱并且赋值给新的column
df['Categories ']=pd.cut(df['socre'],bins,labels=['Low','OK','Good','Great'])  
df.sort_values('socre',ascending=False)  # 根据分数排序

4-11 数据分组技术GroupBy

df1 = pd.read_csv('city_wearther.csv')

g = df1.groupby(df1['city'])  # 按照city分組
g  # 是一个DataFrameGroupBy对象
"""
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7fcf906c5910>
"""

g.groups  # 查看分組詳情
"""
{'BJ': Int64Index([0, 1, 2, 3, 4, 5], dtype='int64'),
 'GZ': Int64Index([14, 15, 16, 17, 18, 19], dtype='int64'),
 'SH': Int64Index([6, 7, 8, 9, 10, 11, 12, 13], dtype='int64')}
"""


df_bj= g.get_group('BJ')  # 使用'BJ'分组，生成一个新的Dataframe对象
df_bj.mean()  # 求dataframe平均值
"""
temperature    10.000000
wind            2.833333
dtype: float64
"""

df1.mean()  # 求分组的平均值
"""
temperature    7.10
wind           3.35
dtype: float64
"""

# list之后就是列表包含元组，元祖的第一个值就是groupby_name,第二个值是dataframe
list(g)  # 强制类型转换成列表
dict(list(g))  # g可以前置装换成字典，key是groupby_name ,value就是dataframe数据

# 循环字典
for k,v in dict(list(g)).items():
    print(k,v)

4-12 数据聚合技术Aggregation

import numpy as np
import pandas as pd
from pandas import Series,DataFrame

df = pd.read_csv('city_wearther.csv')
g = df.groupby('city')  # 使用city对数据进行分组

g.describe()  # 查看数据详情
g.get_group('BJ')  #查看BJ分组的DataFrame数据
g.agg('max')  # 聚合查询最大值

# 该方法就是最大值减去最小值
def foo(attr):
    return attr.max()-attr.min()

g.agg(foo)
"""
	temperature	wind
city		
BJ	22	3
GZ	35	4
SH	30	3
"""

g_new = df.groupby(['city','wind'])  # 使用两个字段进行分组
g_new.groups  # 分组展示
g.groups  # 查看所有分组
g_new.get_group(('BJ',2))  # 查看该分组下数据

# 循环分组结果
for (name_1,name_2), group in g_new:
    print((name_1,name_2), group)
    

4-13 透视表

为了更好地展示数据，临时的将表结构进行变更

df.pivot_table

import pandas as pd
import numpy as np
from pandas import Series,DataFrame
df = pd.read_excel('sales-funnel.xlsx')


# index就是索引，可以传多个值
# values就是保留的字段，默认为None
pd.pivot_table(df, index=['Manager','Rep'], values=['Price'])  # aggfun透视表，aggfunc='mean'表示求平均值


# aggfunc就是聚合查询
# columns就是二级column
pd.pivot_table(df, index=['Manager','Rep'], values=['Price','Quantity'],aggfunc='sum',columns=['Product'],fill_value=0) 

4-14 分组和透视功能实战

projects.fivethirtyeight.com/flights/

​

第5章 绘图和可视化之Matplotlib

5-1 Matplotlib介绍

为什么用Python画图？

• GUI太复杂
• Excel太头疼
• Python简单，免费（sorry Matlab）

什么是matplotlib?

• 一个Python包
• 用于2D绘图
• 非常强大和流行
• 有很多扩展

hello world in matplotlib

import matplotlib .pyplot as plt
import numpy as np
%matplotlib inline
# 从0到100两倍的pi间隔取数
x = np.linspace(0,2*np.pi,100)
y = np.sin(x)
plt.plot(x,y)

Matplotlib Architecture

Matplotlib的架构

• backend:主要处理把图显示到哪里和画到哪里
• Artist:图像显示成什么样
• scripting:pyplot ,python语法和API

5-2 matplotlib简单绘图之plot

import numpy as np
import matplotlib.pyplot as plt
a = [1,2,3]
b=[4,5,6]
# 传入一个列表，x=index,y=list
# 传入两个列表，x=list1,y=list2

plt.plot(a,b)

plt.show()  # 显示图像
#在jupyter中提供了一个Magical function（魔法函数）
%matplotlib inline
%timeit np.arange(10)  # 模范函数，计算执行时间
plt.plot(a,b,'r--')  # 设置线条的颜色和样式

c=[10,8,6]
d=[1,8,3]
plt.plot(a,b,c,d)  # 画一组线
#也可以执行两组线的风格和颜色
plt.plot(a,b, 'r--', c,d, 'g+')

t = np.arange(0.0,2.0,0.1)
s = np.sin(t*np.pi)	
# 设置右上角线条说明
plt.plot(t,s,'r--',label='aaaa')
plt.plot( t*2,s,'b--',label='bbbb')
# 设置label
plt.xlabel('this is x')
plt.ylabel('this is y')
# 设置标题
plt.title('this is title')
plt.legend()  #配合说明使用

5-3 matplotlib简单绘图之subplot

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0.0, 5.0)  # 生成50个数据，间隔为0.1
y1 = np.sin(np.pi*x)
y2 = np.sin(np.pi*x*2)

plt.plot(x,y1,'b--',label='sin(pi*x)')
plt.ylabel('y1 value')
plt.plot(x,y2,'r--', label='sin(pi*2x)')
plt.ylabel('y2 value')
plt.xlabel('x value')
plt.title('thsi is x-y value')
plt.legend()

# subplot  子图
# 把整个图进行切分
plt.subplot(2,1,1)  # 两行一列的数据，取第一个
plt.plot(x,y1,'b--')
plt.ylabel('y1')
plt.subplot(2,1,2)  # 两行一列的数据，取第二个
plt.plot(x,y2,'r--')
plt.ylabel('y2')
plt.xlabel('x')

还有下面这种方式画子图，两行两列，第几个

另外一种画子图的方式

figure,ax = plt.subplots(2,2)  # 将画布分为2x2的布局
ax[0][0].plot(x,y1)  # 第一行的第一列
ax[0][1].plot(x,y2)  # 第一行的第二列

5-4 Pandas绘图之Series

import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

 # cumsum中每一项都是前面几项累加的和
s1 = Series(np.random.randn(1000)).cumsum() 
s2 = Series(np.random.randn(1000)).cumsum()

# kind: bar柱状 line折线
# grid显示方格
# label图例
s1.plot(kind='line',grid=True,label='S1',title='this is Series',style='r--')
s2.plot(label='S2')
plt.legend()  # 配合label使用

# 通过子图画Series数据
fig,ax = plt.subplots(2,1)
ax[0].plot(s1)
ax[1].plot(s2)

fig,ax = plt.subplots(2,1)
# 通过设置ax指定画板，并且可以设置样式和label
s1.plot(ax=ax[0],label='S1',style='r--')
s2.plot(ax=ax[1],label='S2',style='b')

# 设置数据样式,可以截取数据
fig,ax = plt.subplots(2,1)
s1[0:10].plot(ax=ax[0],label='S1',kind='bar')
s2.plot(ax=ax[1],label='S2',kind='line')

5-5 Pandas绘图之DataFrame

import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

# 设置一个10行四列的值在1,10之间的随机DataFrame数据
df = DataFrame(
    np.random.randint(1,10,40).reshape(10,4),
    columns=['A','B','C','D']
)

# kind:line折线图，bar柱形图，barh横向柱形图
df.plot(kind='barh')

# stacked表示同一个索引下的所有的column堆叠在一起显示
df.plot(kind='bar',stacked=True)

# kind='area'填充的线形图
df.plot(kind='area')

df.iloc[5].plot()  # 第五行的取值,得到一个Series数据，并画图

# 按照行来画df中所有Series的图
for i in df.index:
    df.iloc[i].plot(label=str(i))
plt.legend()

# dataframe按照列来画图
for i in df.columns:
    df[i].plot(label=str(i))
plt.legend()

# df.plot默认按照行来画图，使用T转置
df.T.plot()

5-6 直方图和密度图

import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt

直方图

s = Series(np.random.randn(1000))
plt.hist(s,rwidth=0.9)  # 直方图

plt.hist(s,rwidth=0.9,bins=20,color='r')

密度图

s.plot(kind='kde')  # kind='kde'就是密度图，在取值范围内的密度

39.png)

第6章 绘图和可视化之Seaborn

Seaborn是对Matplotlib的进一步封装，其强大的调色功能和内置的多种多样的绘图模式，使之成为当下最流行的数据科学绘图工具。本章将介绍Seaborn的基本使用，以及和matplotlib的功能对比。

6-1 seaborn介绍

Seaborn- Powerful Matplotlib Extension :强大的Matplotlib扩展 statistical data visualization 统计数据可视化

Seaborn的优势在哪里？

简单，快捷的可视化工具包

鸢尾花长度散点图

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

iris = pd.read_csv('iris.csv')

#获取Name这一列的唯一数据，是一个数组
iris.Name.unique()  #array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object)

# 将name和颜色组成一个字典
color_map = dict(zip(iris.Name.unique(), ['blue','green','red']))

matplotlib画图

# matplotlib画图
#for species,group in iris.groupby('Name'):
#    print(species,group)
for species,group in iris.groupby('Name'):
    plt.scatter(
        group['PetalLength'],group['SepalLength'],
        color=color_map[species],
        alpha=0.3,edgecolor=None,
        label=species
        )
plt.legend(frameon=True,title='Name')  # 輔助顯示label
plt.xlabel('petalLength')  #x轴label名
plt.ylabel('sepalLength')  # y轴label名

使用seaborn画图

sns.lmplot('PetalLength','SepalLength',iris,hue='Name',fit_reg = False)

6-2 seaborn实现直方图和密度图

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
%matplotlib inline

# 导入seaborn
import seaborn as sns

s1 = Series(np.random.randn(1000))  # 生成一个随机的Series

# matplotlib实现直方图
plt.hist(s1)

# Series实现密度图
s1.plot(kind='kde')

# seaborn.displot参数
# a 就是我们传入的数据
# binds 就是分块,就是将数据等分为多少份
# hist 就是是否画直方图
# kde 就是是否画密度图
# rug 是否在支撑轴上绘制加固图,就是下方出现的小数线，反应数值密度
sns.distplot(s1,hist=True,kde=True,rug=True)  # 根据数据画直方图和密度图

seaborn直接画图

# seaboen.kdeplot参数
# shade 是否填充
# color 颜色
sns.kdeplot(s1,shade=True,color='green')

plt.hist(s1)  # 画直方图
sns.rugplot(s1)  # 实现密度

6-3 seaborn实现柱状图和热力图

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import seaborn as sns

#为了每次自动出现图片
%matplotlib inline  

获取一些试验的数据，采用下面的方法实现

# 获取线上数据进行试验
# name in ['tips','flights','exercise','titanic']
df = sns.load_dataset('flights')

Michael Waskom的github，上面有很多的csv文件实例

github.com/mwaskom/sea…

# 利用透视表来重置df数据
df = df.pivot(index='month',columns='year', values='passengers')
# 非常方便的看一年的数据

生成热力图--sns.heatmap

# 使用sns.heatmap生成热力图
# 参数展示
# annot就是展示参数的时候使用的|


sns.heatmap(df,annot=True,fmt='d')  

df.plot(kind='area') #面积图

s = df.sum()  # 默认将对应列的所有行数据相加，编程一个Series数据
sns.barplot(x=s.index,y=s.values)  # 使用sns.barplot传x,y数据成柱状图

# 使用matplotlib画一个柱状图
s.plot(kind='bar')

6-4 seaborn图形显示效果的设置

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
import seaborn as sns

%matplotlib inline

# 生成一个0到14的等差数列，数量是一百个
x = np.linspace(0,14,100)



y1 = np.sin(x)
y2 = np.sin(x+1)*1.25
def sinplot():
    plt.plot(x,y1,color='red',)
    plt.plot(x,y2,label='blue')
 
sinplot()

# seaborn自定义的五种风格,主题
style=['darkgrid','dark','white','whitegrid','tricks']

sns.set_style(style[0],{'grid.color': 'blue'})  # 设置主题，并更改主题相关

sinplot()

# 当前主题下的参数
sns.axes_style()

sns.set()   #seaborn恢复默认参数

plotting_context()and set_context()

context = ['paper','notebook','poster']  # 上下文环境

# 通过更改context可以实现改变context
# 使用rc={'grid.linewidth':3.0}可以实现网格线的微调
sns.set_context(context[1],rc={'grid.linewidth':3.0}) 
sns.plotting_context()#显示当前的context
sns.set()  # 恢复默认值

6-5 seaborn强大的调色功能

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
%matplotlib inline

# 实现一个画图的方法
def sinplot():
    x = np.linspace(0,14,100)
    plt.figure(figsize=(8,6))  # 调整图像的大小
    for i in range(4):
        plt.plot(x, np.sin(x+i)*(i+0.75),label='sin(x+{})*({}+0.75)'.format(i,i))
    plt.legend()
        

import seaborn as sns
sinplot()  # 运行之后会发现颜色发生变化

# 调色板
sns.color_palette()  #RGB 每一个tuple就是rgb，三原色

# sns.palplot()将调色板中的值绘制为水平数组。
# sns.palplot(sns.color_palette())
# 传输组，tuple,
sns.palplot([(0.2980392156862745, 0.4470588235294118, 0.6901960784313725)])

# seaborn自带的集中调色板参数
pal_style=['deep','muted','pastel','bright','dark','colorblind']

# seaborn自带的几种调色板
sns.palplot(sns.color_palette(pal_style[4]))

# 给图画设置色板
sns.set_palette(sns.color_palette(pal_style[4]))

# 临时更改画板色板的方法
# 在with下执行的画图颜色就根据with后定义的来显示，外面的代码就不会按照with里面的样式了
with sns.color_palette('dark'):
    sinplot()

# 默认色板的颜色有6种，但是我需要更多地怎么办呢？
pal2 = sns.color_palette('hls',8)  # 生成有8种颜色风格的色板
sns.palplot(pal2)  # 显示八种颜色的色板

seaborn官网消息讲述色板博文

seaborn.pydata.org/tutorial/co…

第7章 数据分析项目实战

通过前六章的学习，我们基本上掌握了数据分析领域里主要工具的使用，本章将通过一个股票市场的分析实战项目，和大家一起用学过的知识去分析数据，进而得到有用的信息。

7-1 实战准备

数据分析数据源

# B 站全站视频信息爬虫

  https://github.com/chenjiandongx/bili-spider 

# 数据分析和挖掘有哪些公开的数据来源？

 https://www.zhihu.com/question/19969760 

# kaggle-机器学习都会用的网站

 https://www.kaggle.com/ 
        
# google上直接搜索
google public data

# 亚马逊公开数据源
https://registry.opendata.aws/

7-2 股票市场分析实战之数据获取

雅虎上面获取股票数据

finance.yahoo.com/

使用工具去抓取股票的信息

pandas-datareader

安装pandas-datareader

# linux中切换到文件夹
/root/anaconda3/bin

# pip 安装pandas_datareader
pip install pandas_datareader

# pandas_datareader官网
https://pandas-datareader.readthedocs.io/en/latest/

阿里巴巴股票数据的获取

import pandas_datareader as pdr
# 获取阿里巴巴股票数据
alibaba = pdr.get_data_yahoo('BABA')  
alibaba.head()

alibaba.shape  # （行，列）的数量
alibaba.tail()  # 最后五条数据
alibaba.describe()  # 基本信息
alibaba.info  # 看基本信息

7-3 股票市场分析实战之历史趋势分析

# 基本信息
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

# 股票数据的读取
import pandas_datareader as pdr

# 可视化
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

# time

from datetime import datetime

从雅虎上获取阿里巴巴和亚马逊的股票数据

start = datetime(2015,9,20)
end = datetime(2017,11,30)
alibaba = pdr.get_data_yahoo('BABA',start=start,end=end)
amazon = pdr.get_data_yahoo('AMZN',start=start,end=end)

df直接画图

alibaba['Adj Close'].plot(legend=True)  # 股票价格走势图

alibaba['Volume'].plot(legend=True)  # 股票交易量走势

# 两个公司的股票价格放到一张图中，比较价格
alibaba['Adj Close'].plot()
amazon['Adj Close'].plot()

# 一段时间内股票价格的差值画图
alibaba['high-low'] = alibaba['High']-alibaba['Low']  # 添加一个column,反应当天股票的最高价-最低价

alibaba['high-low'].plot()

# daily return  每天的变化情况
# pct_change 就是当前元素与先前元素相差百分比
alibaba['daily-return'] = alibaba['Adj Close'].pct_change()  

alibaba['daily-return'].plot()  

# 以英寸为单位的元组(宽、高)
# linestyle改变线的风格
# marker:标记，o表示一个点,没个数据点显示一个加粗的点，取值比较明显
alibaba['daily-return'].plot(figsize=(10,4),linestyle='--',marker='o')  

alibaba['daily-return'].plot(kind='hist')  # 画一个直方图

seaborn来画图

# distplot画直方图和密度图
# dropna是忽略Series的NaN数据
# bins就是将所有的数据进行分段，然后画图
# color就是图所包含的颜色
sns.distplot(alibaba['daily-return'].dropna(),bins=100,color='purple')

7-4 股票市场分析实战之风险分析

# 基本信息
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

# 股票数据的读取
import pandas_datareader as pdr

# 可视化
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline

# time

from datetime import datetime

start = datetime(2018,1,1)
company=['AAPL','GOOG','MSFT','AMZN','FB']
# 获取这五家公司的Adj Close组成一个DataFrame
top_tech_df = pdr.get_data_yahoo(company,start=start)['Adj Close']

top_tech_dr = top_tech_df.pct_change()  # pct_change是当前元素与先前元素相差百分比

top_tech_df.plot()  # 五家公司价格走势图

top_tech_df[['AAPL','FB','MSFT']].plot()  # 苹果，facebook,微软三家公司股价的走势

sns.jointplot('AMZN','GOOG',top_tech_dr,kind='scatter')  # kind='scatter'散点图

sns.pairplot(top_tech_dr.dropna())  # 根据x坐标和y坐标画散点图

vips.pct_change().quantile(0.2)

写在后面：

机器学习和数据分析我们在工作和日常中都可以使用到的

在后面的学习过程中，我们可以去kaggle中找到相关案例，然后练习

www.kaggle.com/kernels