Python numpy+pandas+matplotlib

本文是根据b站路飞学城Python数据分析全套教程的学习视频整理归纳的学习文档，主要目的是方便自己进行查阅，详细的还得去b站看原视频。另外有很多文字都是根据我自己的理解写的，比较小白，欢迎指正。

文章目录

Python numpy+pandas+matplotlib
- Numpy 使用ipython编译
- - array 创建
  - array索引和切片
  - array布尔型索引
  - array花式索引
  - array通用函数
  - 统计方法和随机数生成
- Pandas
- - pandas介绍
  - Series
  - - series-一维数据对象
    - series整数索引问题
    - series数据对齐
    - series缺失值处理
    - series小结
  - DataFrame
  - - DataFrame的创建
    - DataFrame常用属性
    - DataFrame索引和切片
    - DataFrame-数据对齐与缺失数据
  - pandas常用函数
  - 时间对象
  - - 时间对象处理
    - 时间对象生成
    - 时间序列
  - 文件处理
  - - 文件读取
    - 文件写入
- Matplotlib 使用jupyter编译
- - matplotlib介绍
  - plot函数周边
  - pandas与Matplotlib
  - matplotlib画布与子图
  - matplotlib柱状图和饼图
  - matplotlib K线图
  - Tushare-金融数据接包口
  - 股票分析作业
  - 双均线分析作业

Numpy 使用ipython编译

array 创建

array()	将列表转换为数组，可选择显示指定dtype
arange()	range的numpy版，支持浮点数
linspace()	类似arange()，第三个参数为数组长度
zeros()	根据指定形状和dtype创建全0数组
ones()	根据指定形状和dtype创建全1数组
empty()	根据指定形状和dtype创建空数组（随机值）
eye()	根据指定边长和dtype创建单位矩阵

import numpy as np
np.array([1,2,3])
>>>array([1,2,3])np.array([0]*10)
>>>array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])np.zeros(10)  # 此时该数组的dtype为float64 ，需转换为int才能正常输出0,后面的ones()同理
>>>array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.zeros(10, dtype='int')
>>>array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])np.ones(10, dtype='int')
>>>array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1])np.arange(起始数，数字个数，步长)np.linspace(起始数，最终数，数字个数)  # 最后得出的数组各数之间步长相同

array索引和切片

ndarray-批量运算
数组和标量之间的运算
a+1 a3 1//a a*0.5 a>5
同样大小数组之间的运算
a+b a/b a**b a%b a==b

import numpy as npa = np.arange(10)
a
>>>array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a+1
>>>array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
a*3
>>>array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27])b = np.arange(10,20)
>>>array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
a+b
>>> array([10, 12, 14, 16, 18, 20, 22, 24, 26, 28])
a>b
>>>array([False, False, False, False, False, False, False, False, False,False], dtype=bool)

ndarray-索引
一维数组的索引：a[5]
多维数组的索引：
列表式写法： a[2]【3】
新式写法：a[2,3]

# 一维数组检索
a = np.arange(10)
a[0]
>>>0
# 二维数组检索
np.arange(15)
>>>array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10a, 11, 12, 13, 14])
a = np.arange(15).reshape((3,5))  # 一维数组转二维数组
>>>array([[ 0,  1,  2,  3,  4],[ 5,  6,  7,  8,  9],[10, 11, 12, 13, 14]])
a[0][0]
>>>0
a[0,0]
>>>0  # 两种写法

ndarray-切片
一维数组的切片：a[5:8] a[4:] a[2:10] = 1
多维数组的切片：a[1:2, 3:4] a[:, 3:5] a[:,1]
数组切片与列表切片的不同：数组切片时并不会自动复制（而是创建一个视图），在切片数组上的修改会影响原数组。
copy()方法可以创建数组的深拷贝

In [17]: a
Out[17]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [18]: a[0:4]
Out[18]: array([0, 1, 2, 3])
In [19]: a[4:]
Out[19]: array([4, 5, 6, 7, 8, 9])
In [20]: a[:4]
Out[20]: array([0, 1, 2, 3])  # 一维数组的三种切片方式
In [21]: b = list(range(10))
In [22]: b
Out[22]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [23]: c=a[0:4]
In [24]: d = b[0:4]
In [25]: c[0] = 20
In [26]: d[0] = 20
In [27]: c
Out[27]: array([20,  1,  2,  3])
In [28]: d
Out[28]: [20, 1, 2, 3]
# 二维数组
a = np.arange(15).reshape((3,5))
a
>>>array([[ 0,  1,  2,  3,  4],[ 5,  6,  7,  8,  9],[10, 11, 12, 13, 14]])
a[0:2,0:2]
>>>array([[0, 1],[5, 6]])
a[1:,2:4]  # 前一个代表行，后一个代表列
>>>array([[ 7,  8],[12, 13]])

array布尔型索引

Q1：给一个数组，选出数组中所有大于5的数

A1：a[a>5]

Q2: 给一个数组，选出数组中所有大于5的偶数

A2: a[(a>5) & (a%2==0)]

Q3: 给一个数组，选出数组中所有大于5的数和偶数

A3: a[(a>5) | (a%2==0)]

a = [random.randint(0,10) for i in range(20)]
a
>>>[3, 8, 7, 7, 2, 3, 7, 8, 4, 2, 0, 0, 6, 3, 9, 0, 1, 7, 6, 7]
a = np.array(a)  # 将a转化为数组
list(filter(lambda x:x>5,a))
>>>[8, 7, 7, 7, 8, 6, 9, 7, 6, 7]  # 原方法
a[a>5]  # 选出数组中所有大于5的数
>>>array([8, 7, 7, 7, 8, 6, 9, 7, 6, 7])
a>5  # 判断数组的每一位是否大于5
>>>array([False,  True,  True,  True, False, False,  True,  True, False, False, False, False,  True, False,  True, False, False,  True,  True,  True])
a = np.arange(4)
a
>>>array([0,1,2,3])
a[[True , False, True, False]]
>>>array([0, 2])  # 对应位的数字不显示# Q1：给一个数组，选出数组中所有大于5的偶数
a = [random.randint(0,10) for i in range(20)]
a
>>>[10, 9, 0, 10, 6, 8, 0, 5, 7, 3, 10, 3, 10, 1, 9, 5, 9, 5, 8, 4]
a = np.array(a)  # 将a转化为数组
# 错误：a[a>5][a%2==0]
b =  a[a>5]
b
>>>array([10,  9, 10,  6,  8,  7, 10, 10,  9,  9,  8])
b = b[b%2==0]
b
>>>array([10, 10,  6,  8, 10, 10,  8])  # 第一种方法
a[(a>5) & (a%2==0)]
>>>array([10, 10,  6,  8, 10, 10,  8])  # 第二种方法# Q2:筛选出数组中大于5的数和偶数
a[(a>5) | (a%2==0)]
>>>array([10,  9,  0, 10,  6,  8,  0,  7, 10, 10,  9,  9,  8,  4])

array花式索引

Q1:对于一个数组，选出其第1，3，4，6，7个元素，组成新的二维数组。

A1:a[[1,3,4,6,7]]

Q2:对一个二维数组，选出其第一列和第三列，组成新的二维数组。

A2:a[:,[1,3]]

a = np.arange(20)
a
>>>array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
# Q1
a[[1,3,4,6,7]]
>>>array([1, 3, 4, 6, 7])
# Q2
a = np.arange(20).reshape(4,5)  # 转为二维数组
a
>>>array([[ 0,  1,  2,  3,  4],[ 5,  6,  7,  8,  9],[10, 11, 12, 13, 14],[15, 16, 17, 18, 19]])a[:,[1,3]]
>>>array([[ 1,  3],[ 6,  8],[11, 13],[16, 18]])
# 将6，8，16，18单独组成一个二维数组
a[[1,3],:][:,[1,3]]
>>>array([[ 6,  8],[16, 18]])

array通用函数

通用函数：能同时对数组中所有元素进行运算的函数
常见通用函数：
- 一元函数：abs,sqrt,exp,log,ceil,floor,rint,trunc,modf,isnan,isinf,cos,sin,tan
- 二元函数：add,substract,multiply,divide,power,mod,maximum,mininum

补充-浮点数特殊值

nan(Not a Number): 不等于任何浮点数(nan != nan)
nif(infinity): 比任何浮点数都大,趋于无限值
NumPy中创建特殊值： np.nan np.inf
在数据分析中，nan常被用作表示数据缺失值

a = np.arange(-5,5)
a
>>>array([-5, -4, -3, -2, -1,  0,  1,  2,  3,  4])
np.abs(a)   # 可以直接写abs(a)
>>>array([5, 4, 3, 2, 1, 0, 1, 2, 3, 4])
np.sqrt(a)
>>>array([nan, nan, nan, nan, nan, 0. , 1. , 1.41421356, 1.73205081, 2. ])
a = np.arange(-5.5,5.5)
a
>>> array([-5.5, -4.5, -3.5, -2.5, -1.5, -0.5,  0.5,  1.5,  2.5,  3.5,  4.5])
np.ceil(a)   # 向上取整，例1.2取2，-2.3取-3
>>>array([-5., -4., -3., -2., -1., -0.,  1.,  2.,  3.,  4.,  5.])
np.floor(a)  # 向下取整，例1.2取1，-2.3取-2
>>>    array([-6., -5., -4., -3., -2., -1.,  0.,  1.,  2.,  3.,  4.])
np.round(a)  # 四舍五入
>>>array([-6., -4., -4., -2., -2., -0.,  0.,  2.,  2.,  4.,  4.])
np.trunc(a)  # 向0取整，
>>>array([-5., -4., -3., -2., -1., -0.,  0.,  1.,  2.,  3.,  4.])
np.rint(a)  # 同round
np.modf(a)  # 将小数与整数部分分开
>>>(array([-0.5, -0.5, -0.5, -0.5, -0.5, -0.5,  0.5,  0.5,  0.5,  0.5,  0.5]),array([-5., -4., -3., -2., -1., -0.,  0.,  1.,  2.,  3.,  4.]))
a = np.arange(0,5)
>>> array([0, 1, 2, 3, 4])
b = a/a
b
>>>array([nan,  1.,  1.,  1.,  1.])
np.isnan(b)  # 判断数组内是否含有nan
>>>array([ True, False, False, False, False])
np.maximum(a,b)  # 取出每一位最大的数字
>>>array([nan,  1.,  2.,  3.,  4.])  # nan无法进行比较
np.minimum(a,b)  # 取出每一位最小的数字
>>>array([nan,  1.,  1.,  1.,  1.])

统计方法和随机数生成

统计方法		统计方法
sum	求和	min	求最小值
mean	求平均数	max	求最大值
std	求标准差	argmin	求最小值索引
var	求方差	argmax	求最大值索引

a = array([0, 1, 2, 3, 4])
a.sum()  # 求和
>>>10
a.mean()  # 求平均值
>>>2.0
a.var()  # 求方差，方差：每一位数减平均数后平方的和再除以数字的个数
>>>2.0
a.std()  # 求标准差，标准差及方差的开根
>>>1.4142135623730951
a.argmax()  # 求最大值索引，返回最大值的下标
>>>4

随机数生成

随机数函数在np.random子包内
- rand 给定形状产生随机数组（0到1之间的数）
- randint 给定形状产生随机整数
- choice 给定形状产生随机选择
- shuffle 与random.shuffle相同
- uniform 给定形状产生随机数组

np.random.randint(0,10,10)  # 随机生成10个0到10的整数,第三个参数为输出结果的shape，例如第三个参数为(3,5)将会生成三行五列的随机0到10的整数
>>>array([8, 6, 9, 7, 1, 1, 6, 3, 9, 0])
array([0, 1, 2, 3, 4])
np.random.shuffle(a)    # 打乱数组
a
>>>array([4, 0, 3, 2, 1])
np.random.rand(10)  # 随机生成0到1之间的数组，括号内为输出结果shape
>>>array([0.59299055, 0.62454554, 0.22663945, 0.19710862, 0.40294187, 0.69161135, 0.13875322, 0.62038921, 0.96111296, 0.32484364])
np.random.choice(a,(2,1))   # 在数组中随机选择输出，第二个参数为shape
>>>array([[3],[4]])
np.random.uniform(2.0,4.0,5)    # 生成范围内随机数组，第三个shape
>>>array([3.6005868 , 2.54784429, 2.62126056, 2.45776224, 2.68572162])

Pandas

pandas介绍

pandas是一个强大的Python数据分析的工具包，是基于Numpy构建的
pandas的主要功能：
- 具备对其功能的数据结构DataFrame、Series
- 集成时间序列功能
- 提供丰富的数学运算和操作
- 灵活处理缺失数据

Series

series-一维数据对象

series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。
创建方式：pd.Series([4,7,-5,3])

pd.Series([4,7,-5,3],index=[‘a’,‘b’,‘c’,‘d’])

pd.Series({‘a’:1,‘b’:2})

pd.Series(0,index=[‘a’,‘b’,‘c’,‘d’])
获取值数组和索引数组：values属性和index属性
Series比较像列表（数组）和字典的结合体

series-使用特性

series支持array的特性（下标）：	series支持字典的特性（标签）：
从ndarray创建Series:Series(arr)	从字典创建Series:Series(dic)
与标量运算：sr*2	in运算：‘a’ in sr
两个Series运算：sr1+sr2	键索引：sr[‘a’], sr[[‘a’, ‘b’, ‘d’]]
索引：sr[0], sr[[1,2,4]]
切片：sr[0:2]
通用函数：np.abs(sr)
布尔值过滤：sr[sr>0]

import pandas as pd
pd.Series([2,3,4,5])
>>>
0    2
1    3
2    4
3    5
dtype: int64
pd.Series([4,7,-5,3],index=['a','b','c','d'])  # 自定义索引
>>>
a    4
b    7
c   -5
d    3
dtype: int64
a = array([4, 0, 3, 2, 1])
pd.Series(a)    # 对数组
>>>
0    4
1    0
2    3
3    2
4    1
dtype: int32

series整数索引问题

整数索引的pandas对象往往会使新手抓狂

例：

sr = pd.Series(np.arange(4.))

sr[-1]

如果索引是整数类型，则根据整数进行下标获取值时总是面向标签。

解决方法：loc属性（将索引解释为标签）和iloc属性（将索引解释为下标）

sr = pd.Series(np.arange(20))
>>>
0      0
1      1
2      2
3      3
...
16    16
17    17
18    18
19    19
dtype: int32
sr2 = sr[10:].copy()
sr2
>>>
10    10
11    11
...
17    17
18    18
19    19
dtype: int32
sr2[10]     # 此时索引默认为标签，不推荐
>>>10
sr2.loc[10]     # 同sr2[10]，loc为属性，iloc相反
>>>10
sr2.iloc[9]     # 将索引解释为下标
>>>19

series数据对齐

例：
- sr1 = pd.Series([12,23,34],index=[‘c’, ‘a’, ‘d’])
- sr2 = pd.Series([11,20,10],index=[‘d’, ‘c’, ‘a’])
- sr1+sr2

会自动根据标签对齐，所以sr1+sr2 最终结果为

>>>
a    33
c    32
d    45
dtype: int64

如果数组sr2中有sr1中不存在的标签，则最后sr1+sr2的结果中该标签的值为NaN

(反之同理)

例：

sr1 = pd.Series([12,23,34],index=['c', 'a', 'd'])
sr2 = pd.Series([11,20,10,15],index=['d', 'c', 'a','b'])
sr1+sr2
>>>
a    33.0
b     NaN
c    32.0
d    45.0
dtype: float64

当sr1 = pd.Series([12,23,34],index=[‘c’, ‘a’, ‘d’])，

sr2 = pd.Series([11,20,10],index=[‘b’, ‘c’, ‘a’])时，sr1+sr2的结果中b标签和d标签的值分别为NaN，那如何使结果在索引’b’处的值为11，索引’d’处的值为34呢？

运用算术方法：add,sub,div,mul

sr1.add(sr2,fill_value=0)

series缺失值处理

例如 sr

sr
>>>
a    33.0
b     NaN
c    32.0
d     NaN
dtype: float64

在sr中索引’b’和’d’的值都是NaN，缺失状态。对这些缺失值的处理可以有以下几种方法。

1.删除

sr.isnull()  # 首先判断是否有缺失值
>>>a    False
b     True
c    False
d     True
dtype: bool
# sr.notnull()  返回结果与isnull()相反
sr[sr.notnull()]    # 可以删除缺失值
>>>
a    33.0
c    32.0
dtype: float64
sr.dropna()     # 可以删除缺失值

2.填充

sr.fillna(0) # 将缺失值填充为'0'
>>>
a    33.0
b     0.0
c    32.0
d     0.0
dtype: float64
sr.fillna(sr.mean())    # 将缺失值填充为平均值
>>>
a    33.0
b    32.5
c    32.0
d    32.5
dtype: float64

series小结

series 数组+字典的集合体
整数索引 loc和iloc
数据对齐 nan
缺失数据处理 dropna fillna

DataFrame

DataFrame的创建

DataFrame-二维数据对象

DataFrame是一个表格型的数据结构，含有一组有序的列。DataFrame可以被看做是由Series组成的字典，并且共用一个索引。

创建方式：

pd.DataFrame({‘one’:[1,2,3,4], ‘two’:[4,3,2,1]})

pd.DataFrame({‘one’:pd.Series([1,2,3],index=[‘a’, ‘b’, ‘c’]), ‘two’:pd.Series([1,2,3,4],index=[‘b’, ‘a’, ‘c’, ‘d’])})

…

csv文件读取与写入：

df.read_csv(‘filename.csv’)

df.to_csv()

pd.DataFrame({'one':[1,2,3,4], 'two':[4,3,2,1]})
>>>one  two
0    1    4
1    2    3
2    3    2
3    4    1
pd.DataFrame({'one':pd.Series([1,2,3],index=['a', 'b', 'c']), 'two':pd.Series([1,2,3,4],index=['b', 'a', 'c', 'd'])})
>>>one  two
a  1.0    2
b  2.0    1
c  3.0    3
d  NaN    4

DataFrame常用属性

DataFrame-常用属性
index	获取行索引
T	转置行列
columns	获取列索引
values	获取值数组（二维数组）
describe()	获取快速统计

df
>>>one  two
0    1    4
1    2    3
2    3    2
3    4    1
df.index
>>>RangeIndex(start=0, stop=4, step=1)
df.values
>>>
array([[1, 4],[2, 3],[3, 2],[4, 1]], dtype=int64)
df.T    # 行列交换
>>>0  1  2  3
one  1  2  3  4
two  4  3  2  1
df.describe()   # 对每一列进行统计
>>>one       two
count  4.000000  4.000000
mean   2.500000  2.500000
std    1.290994  1.290994
min    1.000000  1.000000
25%    1.750000  1.750000
50%    2.500000  2.500000
75%    3.250000  3.250000
max    4.000000  4.000000

DataFrame索引和切片

DataFrame是一个二维数据类型，所以由行索引和列索引。
DataFrame同样可以通过标签和位置两种方法进行索引和切片
loc属性和iloc属性
- 使用方法：逗号隔开，前面是行索引，后面是列索引
- 行/列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配

DataFrame-数据对齐与缺失数据

DataFrame对象在运算时，同样会进行数据对齐，其行索引和列索引分别对齐
DataFrame处理缺失数据的相关方法：
- dropna(axis=0,where=‘any’,…)
- fillna()
- isnull()
- notnull()

df
>>>one  two
a    1.0    2.0
b    2.0    1.0
c    3.0    NaN
d    NaN    Nan
df.dropna()     # 删除NaN
>>>one  two
a    1.0    2.0
b    2.0    1.0
df.dropna(how='all') # 删除都是NaN的行
>>>one  two
a    1.0    2.0
b    2.0    1.0
c    3.0    NaN
df.dropna(how='any') # 默认，删除所有含有NaN的行
>>>one  two
a    1.0    2.0
b    2.0    1.0
df.drop(axis=1)        # 默认axis=0按行为标准，写成1后按列为标准

pandas常用函数

pandas-其他常用方法
mean(axis=0,skipna=False)	对列（行）求平均值
sum(axis=1)	对列（行）求和
sort_index(axis,…,ascending)	对列（行）索引排序按标签排序
sort_values(by,axis,ascending)	按某一列（行）的值排序
Numpy的通用函数同样适用于pandas

df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b...: ','c']),'two':pd.Series([5,2,1,6],index=['a','b','c...: ','d'])})
>>>one  two
a  1.0    5
b  2.0    2
c  3.0    1
d  NaN    6
df.mean()       # 对列（行）求平均值 括号内axis值默认为0，若为1则对行求平均值
>>>
one    2.0
two    3.5
dtype: float64
df.sum()        # 求和 括号内参数与mean()相同
>>>
one     6.0
two    14.0
dtype: float64
df.sort_values(by='具体行',accending=False,axis=1或0)  # 其中accending表示升序，False则表示为降序，含有NaN的行不参与排序默认放到最后一行

时间对象

时间对象处理

时间序列类型：

时间戳：特定时刻

固定时间：如2017年7月

时间间隔：起始时间—结束时间

Python标准库处理时间对象：datetime

灵活处理时间对象：datautil

dateutil.parser.parse() # 无法处理中文格式但是可以处理JAN等缩写

成组处理时间对象：pandas

pd.to_datetime()

dateutil.parser.parse('20010130')  # 可以将任何格式的时间形式转换
>>>datetime.datetime(2001, 1, 30, 0, 0)
pd.to_datetime(['2001.1.30','20010813'])    # 可以批量处理时间对象 无论格式是否相同
>>> DatetimeIndex(['2001-01-30', '2001-08-13'], dtype='datetime64[ns]', freq=None)

时间对象生成

产生时间对象数组：date_range
- start 开始时间
- end 结束时间
- periods 时间长度
- freq 时间频率，默认为’D’，可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es),S(econd),A(year),…

pd.date_range('2001.1.30','2001.8.13',periods=10)   # periods表示输出的时间个数
>>>
DatetimeIndex(['2001-01-30 00:00:00', '2001-02-20 16:00:00','2001-03-14 08:00:00', '2001-04-05 00:00:00','2001-04-26 16:00:00', '2001-05-18 08:00:00','2001-06-09 00:00:00', '2001-06-30 16:00:00','2001-07-22 08:00:00', '2001-08-13 00:00:00'],dtype='datetime64[ns]', freq=None)

时间序列

时间序列就是以时间对象为索引的Series或DataFrame。
datetime对象作为索引时是存储在DatetimeIndex对象中的。
时间序列特殊功能：
- 传入“年”或“年月”作为切片方式
- 传入日期范围作为切片方式
- 丰富的函数支持：resample(),truncate(),…

sr = pd.Series(np.arange(100),index=pd.date_range('200...: 10130',periods=100)) # 首先生成以时间对象为索引的Series
>>>
2001-01-30     0
2001-01-31     1..
2001-05-09    99
Freq: D, Length: 100, dtype: int32
sr['2001-03','2001-04']     # 然后可以根据具体的日期进行索引，可以对一个时间段进行索引
>>>
2001-03-01    30
2001-03-02    31
...
2001-03-30    59
2001-03-31    60
Freq: D, dtype: int32

#    一些函数sr.resample('W').sum()    # resample()就是对括号内的单位时间进行重新采样，例如对将每一周的数据和统计出来就是上面这样，括号内的参数与时间对象创建的频率是一样的单位
>>>
2001-02-04     15
2001-02-11     63
2001-02-18    112
...
2001-05-13    294
Freq: W-SUN, dtype: int32
sr.truncate(before='2001-01-30') # 该函数就是输出你输入的时间后的所有记录，功能类似切片，实用性不高，括号内还有after

文件处理

数据文件格式：csv（以某间隔符分割数据）
pandas读取文件：从文件名、URL，文件对象中加载数据
- read_csv 默认分隔符为逗号
- read_table 默认分隔符为制表符

文件读取

read_csv,read_table函数主要参数：
- sep 指定分隔符
- header=None 指定文件无列名
- name 指定列名
- index_col 指定某列作为索引
- skip_row 指定跳过某些行（不常用）
- na_values 指定某些字符串表示缺失值
- parse_dates 指定某些列是否被解析为日期，类型为布尔值或列表

pd.read_csv('training.csv',index_col='Time')    # 可以更改索引，这里是将第0列作为索引，index_col的参数也可以是自定义的列名，例如这里的Time
>>>ID name  score
Time
2001/1/1   202001    A     98
2001/1/2   202002    B     95
...
2001/1/11  202011    K     68
2001/1/12  202012    L     65
# 但是这里的Time序列无法直接进行检索，输出只是index，所以需要将其转化为时间序列
pd.read_csv('training.csv',index_col='Time'，parse_dates=['Time'])    # 可以指定其中一列转化为时间序列，如果parse_dates=True会自动转化# 如果文件没有列名读取时会自动把第一行当作列名，为了避免这种情况会使用下面的方法
pd.read_csv('training.csv',header=None)
>>>0       1  2   3
0    2001/1/1  202001  A  98
...
11  2001/1/12  202012  L  65
pd.read_csv('training.csv',header=None,names=list('abcd'))    # 也可以指定输出列名
>>>a       b  c   d
0    2001/1/1  202001  A  98
1    2001/1/2  202002  B  95
...
11  2001/1/12  202012  L  65

文件写入

写入到csv文件：to_csv函数
写入文件函数的主要参数：
- sep 指定文件分隔符
- na_rep 指定缺失值转换的字符串，默认为空字符串
- header=False 不输出列名一行
- index=False 不输出行索引一列
- columns 指定输出的列，传入列表

df       # df[0,0]的位置值为NaN
>>>0       1  2   3
0         NaN  202001  A  98
1    2001/1/2  202002  B  95
...
11  2001/1/12  202012  L  65
df.to_csv('training.csv', header=False, index=False, na_rep='null', columns=[0,1,2,3])      # 此步骤可以将df存储的内容保存至training.csv中

pandas支持其他文件类型：json,XML,HTML,数据库,pickle,excel…

Matplotlib 使用jupyter编译

matplotlib介绍

数据可视化

Matplotlib是一个强大的Pytho绘图和数据可视化的工具包
安装方法：pip install matplotlib
引用方法：import matplotlib.pyplot as plt
绘图函数：plt.plot()
显示图像：plt.show()

plt.plot([1,2,3,4],[2,3,1,7])    # 折线图,第一个方括号里对应X轴的值，第二个方括号对应Y轴的值
plt.plot([1,2,3,4],[2,3,1,7],'o') # 后面有个o是只用点点出来，'o-'的话就是点和线组成

plot函数：绘制折线图
- 线性linestyle(-,-.,–,…)
- 点型marker(v,^,s,*,H,+,x,D,o,…)
- 颜色color(b,g,r,y,k,w,…)
plot函数绘制多条曲线
pandas包对plot的支持

plot函数周边

Matplotlib-图像标注
设置图像标题：plt.title()	设置y轴范围：plt.ylim()
设置x轴名称：plt.xlabel()	设置x轴刻度：plt.xticks()
设置y轴名称：plt.ylabel()	设置y轴刻度：plt.yticks()
设置x轴范围：plt.xlim()	设置曲线图例：plt.legend()

plt.xticks(np.arange(0,11,2),['a','b','c','d','e','f'])
# 该行语句其中括号里第一个参数设置了x轴的长度以及步长，第二个参数将x轴的每一个数字替换成英文字母
plt.legend()
# 这个如果直接打上去是不会有任何的改变的，首先必须每一条线有lable属性，对应图例名称，例如plt.plot([1,2,3,4],[2,3,1,7],label='line 1')，这样才可以在图像空白处显示曲线图例

pandas与Matplotlib

df = pd.read_csv('training.csv', parse_dates=['Date'], index_col='Date')[['Name','Score']]
# 这里就是读取了training.csv文件，将Date标签设置为索引，然后再设置了需要显示的变量

题目：Matplotlib实例——绘制数学函数图像

使用Matplotlib模块再一个窗口中绘制数学函数y=x,y=x²，y=3x³+5x²+2x+1的图像，使用不同颜色的线加以区别，并使用图例说明各个线代表什么函数。

x = np.linspace(-100,100,10000)
y1 = x.copy()
y2 = x ** 2
y3 = 3*x**3+5*x**2+2*x+1
plt.plot(x,y1,label='y=x',color='red')
plt.plot(x,y2,label='y=x^2',color='green')
plt.plot(x,y3,label='y=3x^3+5x^2+2x+1',color='blue')
plt.ylim(-1000,1000)
plt.legend()
plt.show()

matplotlib画布与子图

画布：figure
- fig = plt.figure
图：subplot
- ax1 = fig.add_subplot(2,2,1)
调节子图间距：
- subplots_adjust(left,bottom,right,top,wspace,hspace)

# 举例
fig = plt.figure()
ax1 = fig.add_subplot(2,2,1)
ax1.plot([1,2,3,4],[5,4,2,6])
ax2 = fig.add_subplot(2,2,2)
plt.show()

matplotlib柱状图和饼图

函数	说明
plt.plot(x,y,fmt,…)	坐标图
plt.boxplot(data,notch,position)	箱型图
plt.bar(left,height,width,bottom)	条形图
plt.barh(width,bottom,left,height)	横向条形图
plt.polar(theta,r)	极坐标图
plt.pie(data.explode)	饼图
plt.psd(x,NFFT=256,pad_to,Fs)	功率谱密度图
plt.specgram(x,NFFT=256,pad_to,F)	谱图
plt.cohere(x,y,NFFT=256,Fs)	X-Y相关性函数
plt.scatter(x,y)	散点图
plt.step(x,y,where)	步阶图
plt.hist(x,bins,normed)	直方图

# 柱状图
data = [21,22,41,100]  # 确定各值
labels = ['Jan','Feb','Mar','Apr'] # 确定各条的名字
plt.bar(np.arange(len(data)),data,color=['red','blue','yellow','green'])   # 确定属性，包括条形图的对应位置，值，以及各条的颜色
plt.xticks(np.arange(len(data)),labels) # 改变x轴
plt.show()

# 饼图
plt.pie([10,20,30,40],labels=['a','b','c','d'],autopct='%.2f%%',explode=[0.1,0,0,0])   # 这里面第一个参数是对应饼内各块的值，labels就是各块的标签，autopct可以设置值的显示形式，这里是百分号后显示两位小数，explode是可以让其中几块突出显示，括号内的数值指突出的距离
plt.axis('equal') # 刻度等长
plt.show

matplotlib K线图

现在已经没有matplotlib.finance子包了，已经单独分离出mplfinance包

mplfinanace包中有许多绘制金融相关图的函数接口。

绘制k线图：mpf.plot()函数

import mplfinance as mpf
mpf.plot(data)  # data里为传入的数据

修改plot绘图类型

通过参数type修改绘图类型，默认是ohlc，可改为type='candle’或者type=‘line’

mpf.plot(data,type='candle')

增加绘制均线

关键字参数mav=(2,5,10),多条均线使用元组，只绘制一条均线，可以mav=10

mpf.plot(data,type='candle',mav=(2,5,10))
mpf.plot(data,type='candle',mav=(10,))

绘制成交量

关键字参数volume=True

mpf.plot(data,type='candle',mav=(2,5,10),volume=True)

自动剔除非交易日空白

关键字参数show_nontrading，默认是False，设置为True，就可以看到停盘的时间段

mpf.plot(data,type='candle',mav=(2,5,10),volume=True,show_nontrading=True)
# 由于上述读取的数据没有停盘时间段，因此绘图没有什么不同。

Tushare-金融数据接包口

Tushare是一个免费、开源的python财经数据接口包,更多信息可以上官网查看

tushare.org

需要另外安装一个Tushare的包pip install Tushare

import tushare as ts
ts.get_k_data('601318')       # 可以显示近几年该代码股票的交易情况

股票分析作业

使用tushare包获取某股票的历史行情数据
输出该股票所有收盘比开盘上涨3%以上的日期
输出该股票所有开盘比前日收盘跌幅超过2%的日期
假如我从2010年1月1日开始，每月第一个交易日买入1手股票，每年最后一个交易日卖出所有股票，到今天为止，我的收益如何？

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import tushare as ts# 获取该股票的历史行情数据
df = ts.get_k_data('601318',start='1988-01-01')
df.to_csv('601318.csv')  # 存储成csv文件
# 以时间为索引
df = pd.read_csv('601318.csv',index_col='date',parse_dates=['date'])# 输出该股票所有收盘比开盘上涨3%以上的日期
df[(df['close']-df['open'])/df['open']>=0.03].index# 输出该股票所有开盘比前日收盘跌幅超过2%的日期
df[(df['open']-df['close'].shift(1))/df['close'].shift(1)<=-0.02]
#shift()的功能是将该列的数据全部往下移一行，括号内的数字代表向下移几行，不知道该函数也可以用循环做# 假如我从2010年1月1日开始，每月第一个交易日买入1手股票，每年最后一个交易日卖出所有股票，到今天为止，我的收益如何？
price_last = df['open'][-1]
df = df['2010-01':'2021-07']
df_monthly = df.resample('M').first()  # 重新取样，取每个月的第一天的数据并存储
df_yearly = df.resample('A').last()[:-1]  # 重新取样，取每年的最后一天的数据并存储
cost_money = 0
hold = 0
for year in range(2010,2022):cost_money = df_monthly[str(year)]['open'].sum()*100  # 买入所花费的钱hold += len(df_monthly[str(year)]['open'])*100  # 手中持有的股数if year !=2021:cost_money -= df_yearly[str(year)]['open'][0] * hold  # 卖出该年股票后花费的钱hold = 0print (cost_money)cost_money -= hold * price_last
print (-cost_money)

双均线分析作业

查找历史金叉死叉日期

均线：对于没一个交易日，都可以计算出前N天的移动平均值，然后把这些移动平均值连起来，成为一条线，就叫做N日移动平均线。移动平均线常用线有5天、10天、30天、60天、120天、240天的指标。
- 5天和10天的是短线操作的参照指标，称做日均线指标；
- 30天和60天的是中期均线指标，称做季均线指标；
- 120天和240天的是长期均线指标，称做年均线指标。
金叉：短期均线上穿长期均线，买入信号
死叉：短期均线下穿长期均线，卖出信号

题目：

使用tushare包获取某股票的历史行情数据
使用pandas包计算该股票历史数据的5日均线和60日均线
使用matplotlib包可视化历史数据的收盘价和两条均线
分析输出所有金叉日期和死叉日期
假如我从2010年1月1日开始，初始资金为100000元，金叉尽量买入，死叉全部卖出，则到今天为止，我的炒股收益率如何？

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import tushare as ts
# 获取该股票的历史行情数据
df = ts.get_k_data('600519',start='2001-01-01')
df.to_csv('600519.csv',index=False)  # 存储成csv文件
# 以时间为索引
df = pd.read_csv('600519.csv',index_col='date',parse_dates=['date'])[['open','close','low','high']]
# 循环方法
# df['ma5'] = np.nan
# df['ma30'] = np.nan# for i in range(4,len(df)):
#     df.loc[df.index[i],'ma5'] = df['close'][i-4:i+1].mean()# for i in range(29,len(df)):
#     df.loc[df.index[i],'ma30'] = df['close'][i-29:i+1].mean()
# rolling方法
df['ma5'] = df['close'].rolling(5).mean()
df['ma30'] = df['close'].rolling(30).mean()
# 画出三条线
df[['close','ma5','ma30']].plot()
plt.show()
# 方法1
# golden_cross = []
# death_cross = []
# for i in range(1,len(df)):
#     if df['ma5'][i] >= df['ma30'][i] and df['ma5'][i-1] < df['ma30'][i-1]:
#         golden_cross.append(df.index[i])
#     if df['ma5'][i] <= df['ma30'][i] and df['ma5'][i-1] > df['ma30'][i-1]:
#         death_cross.append(df.index[i])
# 方法2
sr1 = df['ma5'] < df['ma30']
sr2 = df['ma5'] >= df['ma30']death_cross = df[sr1 & sr2.shift(1)].index
golden_cross = df[~(sr1 | sr2.shift(1))].index
first_money = 100000
money = first_money
hold = 0  # 持有股数
sr1 = pd.Series(1,index=golden_cross)
sr2 = pd.Series(0,index=death_cross)
sr = sr1.append(sr2).sort_index()
for i in range(0,len(sr)):p = df['open'][sr.index[i]]if sr.iloc[i] == 1:# 金叉buy = (money // (100 * p))hold += buy*100money -= buy*100*pelse:# 死叉money += hold * phold = 0p = df['open'][-1]
now_money = hold * p + moneyprint(now_money - first_money)