python numpy和pandas库的区别_Python模块 - Numpy与Pandas

Numpy简介

Numpy是高性能科学计算和数据分析的基础包。它是pandas等其他各种工具的基础。

Numpy的主要功能：

ndarray，一个多维数组结构，高效且节省空间

无需循环对数组数据进行快速运算的数学函数

线性代数、随机数生成和博立叶变换功能

创建ndarray：np.array(array_list)

数组与列表的区别：

- 数组对象内的元素类型必须相同

- 数组大小不可修改

常用属性

T 数组的转置

size 数组元素的个数

ndim 数组的维数

shape 数组的维度大小（元祖形式）

dtype 数组元素的数据类型

创建array

np.zeros(10)# 10个 0.的数组

np.ones(10)# 10个的1.的数组

a = np.empty(100)# 内存中存的值

np.arange(100)# 快速创建100的数组

np.arange(15).reshape(3, 5)# 创建二维数组

np.arange(2, 10, 0.3)

np.linspace(0, 50, 100)# 0 ~ 50 平分成100份

np.eye(10)# 线性代数

ndarray 批量运算

数组和标量之间的运算

a+1 1*3 1//aa**0.5 a>5

同样大小数组之间的运算

a+b a/b a**b a%b a==b

索引

一位数组索引 a[5]

多维数组索引

列表式写法 a[2][1]

新式写法 a[2, 1]

切片

一位数组：a[5:8] a[4:] a[2:10]

多维数组：a[1:2, 3:4] a[:, 3:5] a[:,1]

np数组的切片与列表切片的不同：数组切片时并不会自动复制（而是创建一个视图），在切片数组上的修改会影响原数组

copy()方法可以创建数组的深拷贝

ndarray布尔型索引

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

答案：a[a>5]

原理

数组与标量的运算：a>5会对a中的每一个元素进行判断，返回一个布尔数组

布尔型索引：将同样大小的布尔数组传进索引，会返回一个由所有True对应位置的元素的数组

例子：

# 1,给一个数组，选出数组中所有大于5的数

a = np.array([random.randint(1, 10) for _ in range(20)])

a[a>5]# array([8, 6, 6, 7, 7, 6, 6])

# 2,给一个数组，选出数组中所有大于5的偶数

a = np.array([random.randint(1, 10) for _ in range(20)])

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

# 3,给一个数组，选出数组中所有大于5的数和偶数

a = np.array([random.randint(1, 10) for _ in range(20)])

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

ndarray花式索引

根据索引位置给出值

a = np.arange(20)

a[[1,4,5,6]]# array([1, 4, 5, 6])

a = np.arange(20).reshape(4,5)# array([[ 0, 1, 2, 3, 4],

# [ 5, 6, 7, 8, 9],

# [10, 11, 12, 13, 14],

# [15, 16, 17, 18, 19]])

a[0, 2:5]# array([7, 8, 9])

a[0, a[0]>2]

a[[1, 3], [1, 3]]# 注意2个花式索引的取法，解析有点不一样，获取到的值是：array([ 6, 18])

# 如果就是想取6 8 16 18 可以使用下满的方法

a[[1, 3],:][:,[1,3]]# : 表示全切

Numpy 通用函数

通用函数：能同时对数组中所有元素进行运算的函数

补充知识：

int # 向零取整

round # 向零外取整,round到两边距离相等时取偶数值

math.floor # 向小取整（向左取整）（地板）

math.ceil# 向大取整（向右取整）（天花）

常见通用函数：

一元函数: 对一维数组处理

np.abs(a) # 绝对值

np.sqrt(a)# 开方

np.exp(a)

np.log(a)

np.ceil(a) # 向大取整（向右取整）（天花）

np.floor(a) # 向小取整（向左取整）（地板）

np.rint(a) # 等价于 round

np.round(a)# 向零外取整,round到两边距离相等时取偶数值

np.trunc(a) # 向零取整

np.modf(a)# 将小数和整数拆开

np.isnan(a) # 过滤nan

np.isinf(a)# 过滤inf

np.cos(a)

np.sin(a)

np.tan(a)

例子

a = np.arange(-5.5,5)

np.abs(a)

x, y = np.modf(a)# 将小数和整数拆开，x是小数，y是整数

# numpy过滤nan

a = np.arange(0,5)

b = a/a# array([nan, 1., 1., 1., 1.])

b[~np.isnan(b)]# ~ 是取反

# numpy过滤inf

a=np.array([3,4,5,6])

b=np.array([2,0,3,0])

c = a/b

c[c!=np.inf]# 过滤inf

c[~np.isinf(c)]# 过滤inf

二元函数: 对二维数组处理

np.add(a,b)# a数组 + b数组

np.subtract(a,b)# a-b 一般不用调函数，直接对数组相加就好

np.multiply(a,b)

np.divide(a,b)

np.power(a,b)

np.mod(a,b)

np.maximum(a,b)# 两个数组中的最大

np.minimum(a,b)# 两个数组中的最小

Numpy 数学和统计方法

sum # 求和

mean# 求平均值

std# 求标准差

var# 求方差

min# 求最小值

max# 求最大值

argmin# 求最小值索引

argmax# 求最大值索引

# 求方差

1 2 3 4 5

mean:3

((1-3)**2+(2-3)**2+(3-3)**2+(4-3)**2+(5-3)**2)/5

# 方差表示你这组数据的离散程度

标准差 = sqrt(方差)

# 差不多60%的数据分布在这区间

a.mean()+a.std()

a.mean()-a.std()

# 差不多80%的数据分布在这区间

a.mean()+2*a.std()

a.mean()-2*a.std()

Numpy 随机数生成

随机数函数在np.random子包内

np.random.rand给定形状产生随机数组(0 ~ 1之间)

np.random.randint给定**长度**产生随机整数

np.random.choice给定形状产生随机选择

np.random.shuffle与random.shuffle相同

np.random.uniform给定形状产生随机数组

例子

np.random.randint(0, 10, 10)# 生成一个长度10的随机数组

np.random.rand(5)

np.random.choice([1,2,3,4,5], (2,3))

np.random.uniform(2,5, (3,4))

补充 - 浮点数特殊值

nan (Not a Number): 不等于任何浮点数（nan != nan）

inf(infinity)：比任何浮点数都大

Numpy中创建特殊值：np.nan np.inf

在数据分析中，nan常被用作表示数据缺失值

Pandas 数据分析

pandas简介

pandas是一个强大的Python数据分析的工具包，是基于NumPy构建的。

pandas的主要功能：

具备对其功能的数据结构DataFrame、Series

集成时间序列功能

提供丰富的数学运算和操作

灵活处理缺失数据

安装方法：pip install pandas

引用方法：import pandas as pd

Series 一维数组对象

Series是一种类似于一维数组的对象，由一组数据和一组与之相关相关的数据标签（索引）组成。

创建方式：

pd.Series([4, 5, -5, 3])

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

pd.Series({'a': 1, 'b': 2, 'c': 3})

pd.Series(0, index=['a', 'b', 'c'])

合并两个Series

sr = sr1.append(sr2).sort_index() # 方式二 （0，死叉） （1，金叉）

获取值数组和索引数组：values属性和index属性

Series比较像列表（数组）和字典的结合体

Series 使用特性

Series支持array的（下标）特性：

从ndarray创建Series: Series(arr)

与标量运算：sr * 2

两个Series运算：sr1+sr2

索引：sr[0] [sr[[1,2,4]]]

切片：sr[0:2]

通用函数:np.abs(sr)

布尔值过滤：sr[sr>0]

Series支持字典的特性（标签）

从字典创建Series：Series(dic)

in运算：'a' in sr

键索引：sr['a'] sr[['a', 'b', 'd']]

sr.index

sr.values

sr.index[0]

sr[[1, 3]]

sr[['a', 'd']]

sr['a': 's']# 通过标签切片，前包后也包

Series 整数索引

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

例如：

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

sr[-1]# 会报错

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

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

sr2.loc[10]# 根据标签索引

sr2.iloc[10]# 根据下标索引

sr2.iloc[-1]

sr2.iloc[3:6]

sr2.iloc[[2, 3, 7]]

Series 数据对齐

两个series数组对象，将会根据索引对齐后再相加

sr1 = pd.Series([11,23,34], index=['c','a','d'])

sr2 = pd.Series([11,20,10], index=['d','c','a'])

sr1+sr2# 将会按照index对齐之后进行相加

sr1 = pd.Series([11,23,34], index=['c','a','d'])

sr2 = pd.Series([11,20,10,21], index=['d','c','a','b'])

sr1+sr2# 出现缺省值，b 将会用 NaN 代替

sr1 = pd.Series([11,23,34], index=['b','a','d'])

sr2 = pd.Series([11,20,10], index=['d','c','a'])

sr1+sr2# b NaNc NaN

sr1 = pd.Series([11,23,34], index=['b','a','d'])

sr2 = pd.Series([11,20,10], index=['d','c','a'])

# 如何使结果在索引`b`处的值为11，在索引`c`处的值为20

# 灵活的算术方法：add sub div mul

sr1.add(sr2, fill_value=0)# sr1 + sr2 , 有NaN就用0代替

Series 缺失值的处理

sr.isnull()# NaN 返回 True

sr.notnull()# not NaN 返回 True

# 丢掉

sr = sr[sr.notnull()]

sr = sr.dropna()

# 填充成其他值

sr = sr.fillna(0)# 使用0填充

sr = sr.fillna(sr.mean())# 使用平均值填充

DataFrame的创建方式

dataframe的列得是同一个类型

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

创建方式

# 方式一

pd.DataFrame({'one': [1,2,3], 'two': [4,5,6]})

pd.DataFrame({'one': [1,2,3], 'two': [4,5,6]}, index=['a','b','c'])

# 方式二

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.to_csv('test2.csv')

pd.read_csv('test2.csv')

DataFrame 常用属性

index行索引

T转置

columns获取列索引

values获取值数组 (二维数组)

describe()获取快速统计

DataFrame 索引和切片

DataFrame是一个二维数据类型，所以有行索引和列索引。

DataFrame同样可以铜鼓标签和位置两种方法进行索引和切片

loc属性和iloc属性

使用方法：逗号隔开，前面是行索引，后面是列索引

行/列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配

loc会将行解释为索引标签，iloc会将行解释为其索引下标

df['one']['a']# one是列索引，a是行索引

df.loc['a', 'one']# 推荐这种，a 是 行索引，one是列索引

df.loc['a',:]# 切片 a 这一行数据

df.loc[['a','c'],:]

df.loc[['a','c'],'two']# 任意搭配

DataFrame 数据对齐与缺省数据

DataFrame对象在运算时，同样会进行数据对齐，其行索引和列索引分别对齐。

DataFrame处理缺省数据的相关方法：

dropna(axis=0,how='any',...)# axis=0按行删；axis=1按列删。how='any' 出现一个就删，how='all'都出现才删。

fillna()# 填充

isnull()

notnull()

df.dropna(how='all')# 都出现才删除默认是 any

df2.dropna(axis=1)# 按列删默认是0

Pandas 其他常用方法

mean(axis=0, skipna=False)对列（行）求平均值

sum(axis=1)对列（行）求平均值

sort_index(axio,...,ascending)对列（行）索引排序

sort_values(by, axis, ascending) 按某一列（行）的值排序，注意：有nan的不参与排序 放到最后显示

# Numpy的通用函数同样适用于pandas

例子

f.sort_values(by='two')# 按two列排序

df.sort_values(by='two', ascending=False)# 按two降序排序

df.sort_values(by=1, ascending=False, axis=1)# 按1这一行降序排序

df.sort_index()# 按行索引排序

df.sort_index(ascending=False)# 按行索引降序排序

df.sort_index(ascending=False, axis=1)# 按列索引降序排序

Pandas 时间对象

时间序列类型：

时间戳：特定时刻

固定日期：如2017年7月

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

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

灵活处理时间对象： dateutil dateutil.parser.parse()

成组处理事件对象：pandas pd.to_datetime()

datetime.datetime.strptime('2010-08-21', '%Y-%m-%d')

import dateutil

dateutil.parser.parse('2001-01-01')

dateutil.parser.parse('200101/01')

dateutil.parser.parse('2001/01/01')

dateutil.parser.parse('01/01/2020')

pd.to_datetime(['2019-01-01','2010/Feb/02'])

Pandas 时间对象处理

产生时间对象数组 date_range

start 开始时间

end结束时间

period时间长度

freq时间频率，默认为'D'， 可选H(our), W(eek), B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year), ...

pd.date_range('2010-01-01','2010-5-1')

pd.date_range('2010-01-01',periods=60)

pd.date_range?

pd.date_range('2010-01-01',periods=60,freq='H')

pd.date_range('2010-01-01',periods=60,freq='W')

pd.date_range('2010-01-01',periods=60,freq='W-MON')

pf = pd.date_range('2010-01-01',periods=60,freq='B')

pd.date_range('2010-01-01',periods=60,freq='1h20min')

df[0].to_pydatetime()# 转换成Python的datetime类型

将索引转换为时间列

df['date'] = pd.to_datetime(df['date'])

df.set_index("date", inplace=True)

# df.set_index('date',drop=True)

Pandas 时间序列

时间序列就是以时间对象为索引的Series或DataFrame

datetime对象作为索引时是存储在DatetimeIndex对象中的

时间序列特殊功能：

传入“年”或“年月”作为切片方式

传入日期范围作为切片方式

丰富的函数支持：resample(), truncate() ....

sr = pd.Series(np.arange(1000), index=pd.date_range('2017-1-1', periods=1000))

sr['2017-3']

sr['2017-4']

sr['2017']

sr['2017':'2018-3']

sr['2017-12-24':'2018-2-1']

sr.resample('W').sum()# 按周求和

sr.resample('m').sum()

sr.resample('m').mean()

sr.resample('M').first()# 每个月第一天数据

sr.truncate(before='2018-2-3')# 切掉掉前面的,因为有时间切片了，所以不推荐这个方法

sr.truncate(after='2018-2-3')

Pandas 文件处理

数据文件常用格式：csv（以某间隔符分割字符）

pandas读取文件：从文件名、URL、文件对象中加载数据

read_csv 默认分隔符为逗号

read_table 默认分隔符为制表符

read_csv read_table 函数主要参数

sep指定分隔符，可用正则表达式，如'\s+'， 不指定则默认是 `,`

header=None指定文件无列名

names指定列名

index_col指定某列作为索引

skip_row指定跳过某些行

na_values指定某些字符串表示缺失值（将某些奇怪字符串解析成NaN）

parse_dates指定某些列是否被解析为日期，类型为布尔型或列表

例子

# 常用

df = pd.read_csv('zn2006SHFE2020.csv', index_col='datetime', parse_dates=['datetime'])[['open','high','low','close']]

pd.read_csv('zn2006.csv')

pd.read_csv('zn2006.csv', index_col=0)# 指定第0列为索引

pd.read_csv('zn2006.csv', index_col='datetime')# 指定`datetime`列为索引

pd.read_csv('zn2006.csv', index_col='datetime', parse_dates=True)

pd.read_csv('zn2006.csv', index_col='datetime', parse_dates=['datetime'])

pd.read_csv('zn2006.csv', header=None)

pd.read_csv('zn2006.csv', header=None, names=list('qwertyuiopasdfg'))

pd.read_csv('zn2006.csv', header=None, skiprows=[2,3,4])

pd.read_csv('zn2006.csv', na_values=['None'])# 将None替换为NaN

写入到CSV文件：to_csv函数

写入文件函数的主要参数：

sep指定文件分隔符

na_rep指定缺失值转换的字符串，默认为空字符串

header=False不输出列名一行

index=False不输出行索引一行

cols指定输出的列，传入列表

df.to_csv('test.csv', header=False, index=False, na_rep='null')

df.to_csv('test.csv', header=False, index=False, na_rep='null',columns=['open','high','low','close'])

df.to_html('test.html')

pd.read_excel('test.xlsx')

pandas支持的其他文件类型

json

xml

html

数据库

pickle

excel

补充

rolling函数

可以取前10的窗口

df['pre_high'] = df['high'].rolling(10).max()

shift平移函数

通过shift函数里面的值来控制向前还是向后偏移, 缺少的值会填充NaN，groupby函数里的参数控制基于什么字段进行shift.

注意：-1 是向前前移

df16['pre_close'] = df16['close'].shift(1)# 向后偏移

temp['value_shift'] = temp.groupby('id')['value'].shift(1);temp

Out[180]:

id value value_shift

0 1 1 NaN

1 1 2 1.0

2 1 3 2.0

3 2 4 NaN

4 2 5 4.0

5 3 6 NaN

temp['value_shift_1'] = temp.groupby('id')['value'].shift(-1);temp

Out[181]:

id value value_shift value_shift_1

0 1 1 NaN 2.0

1 1 2 1.0 3.0

2 1 3 2.0 NaN

3 2 4 NaN 5.0

4 2 5 4.0 NaN

5 3 6 NaN NaN

通过shift函数里面的值来控制向前还是向后偏移, 缺少的值会填充NaN.

groupby函数里的参数控制基于什么字段进行shift.

补充函数

series.describe()# 总结数据分布情况

np.sign()# sign()是Python的Numpy中的取数字符号（数字前的正负号）的函数。(大于0，返回1) ;(等于0，返回0);(小于0，返回-1)

Series.value_counts()# 统计值的出现次数

series.cumsum()# 累加之前的数据

series.cumprod()# 累乘之前的数据

series.pct_change()# 表示当前元素与先前元素的相差百分比，当然指定periods=n,表示当前元素与先前第n 个元素的相差百分比。可以用来算当天较上一天的return（收益）