数据分析---- Numpy

Numpy

​ Numpy是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组类型(ndarray)。numpy支持向量处理ndarray对象，提高程序运算速度。

ndarray:n-dimensional array object,任意维数的数组对象

Numpy的官方文档： http://www.numpy.org/

使用方式

安装numpy库

pip install numpy 

pip install numpy 

使用numpy库

import numpy as np

查看版本

print(np.__verson__)

数组创建

Numpy提供很多函数创建数组，常用函数如下:

• array
• arange
• ones/ones_like
• zeros/zeros_like
• empty/empty_like
• full/full_like
• eye/identity
• linspace
• logspace

array

# 使用array方法创建一维数组，传入参数为列表
n = np.array([1,2,3])
# display() 函数python解释器不支持，ipython解释器才支持
display(n)
# print(n)

# 使用array创建多维数组，传入参数是嵌套列表
n= np.array([[1,2],[3,4]])
display(n)

arange

# arange方法类似python中range方法，传入参数也包含起始值，结束值和步长
numpy.arange(start,stop,step,dtype=None)
# 栗子
n = np.arange(10)
n = np.arange(1,10)
n = np.arange(1,10,2)

# 步长可以是浮点型，以及负数
n = np.arange(3,1,-0.5) # array([3. , 2.5, 2. , 1.5])

ones/ones_like

# ones创建全为1的数组
numpy.ones(shape, dtype=None, order='C')
# shape  整型或者元祖
# dtype  数据类型 默认numpy.float64
# 栗子
n1 = np.ones(3)
display(n1)

n2 = np.ones((3,4))
display(n2)

np.ones((3,2))

# ones_like:根据传入的数组形状创建全为1的数组
n3 = np.ones_like(n2)
display(n3)

输出结果：
array([1., 1., 1.])
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])

zeros/zeros_like

# zeros方法创建全为0的数组
n1 = np.zeros(3)
display(n1)

n2 = np.zeros((3,4))
display(n2)

# zeros_like:根据传入的数组形状创建全为0的数组
n3 = np.zeros_like(n2)
display(n3)

empty/empty_like

# empty创建全为空数组：注意，数据并不是设置为0，而是值未初始化，需要我们自己来初始化

n1 = np.empty(3)
display(n1)

# empty_like 根据传入的数组形状创建全为空的数组
n2 = np.empty_like(n1)
display(n2)

full/full_like

# full(shape,fill_value) 创建全为某个指定数据的数组
#  shape 数组维度或者形状
# fill_value 指定数据
n1 = np.full((2,2),3)
display(n1)

# full_like:根据传入数组形状创建数组，同时指定全为某个数
n2 = np.full_like(n1,4)
display(n2)

eye/identity

# eye和identity创建单位矩阵
numpy.eye（N，M =无，k = 0，dtype = <class’flove’>，order =‘C’）
# 对角线的索引：0（默认值）指的是主对角线，正值指的是上对角线，负值指的是下对角线
n1 = np.eye(3)
display(n1)

n1 = np.eye(3,k=1)
display(n1)
# 输出结果
array([[0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])

n2 = np.identity(3)
display(n2)

linspace

# linspace根据一定间隔创建等差数组
# 1,2,3,4,5
# endpoint=True  间隔 end-start/(num-1)
#endpoint - 是否包含stop数值，默认为True，包含stop值；若为False，则不包含stop值

n1 = np.linspace(1,5,num=5)
display(n1)
# 1,2,3...50
n2 = np.linspace(1,50)
display(n2)

# endpoint=False  间隔 end-start/num
# 5-1/5   4/5  0.8
# 1 1.8 2.6 3.4 4.2
n3 = np.linspace(1,5,num=5,endpoint=False)
display(n3)

logspace

# logspace根据指数函数创建等比数组
numpy.logspace(start, stop, num, endpoint, base, dtype)
# 在logspace中，起始位和终止位代表的是10的幂（默认基数为10），0代表10的0次方，9代表10的9次方
# 1 2 4 8 
n1 = np.logspace(0,3,num=4,base=2)
display(n1)
# 1 10 100 1000
n2 = np.logspace(0,3,num=4)
display(n2)

数组ndarray和列表(List)比较

优势

• 数组可与标量进行计算，数组之间可进行向量化计算
• 数组在运算时，具有广播能力。
• 数组底层使用c语言编写，运行速度快
• 数组底层使用c数组的存储方式，节省内存空间

# 班上同学的python成绩，统一加1分
# 列表操作
scores = [90,91,92]
# 循环遍历列表
for i in range(len(scores)):
    scores[i]+=1
display(scores)

# 数组操作
scores_ndarray = np.array([90,91,92])
# 整体操作，不再需要循环遍历
scores_ndarray+=1
display(scores_ndarray)
# 数组具有广播能力，shape 不够时自动补全复制 
a = np.array([1,2,3]) # 复制成 array([[1,2,3],[1,2,3]])
b = np.array([[1,1,1],[2,2,2]])

display(a+b)

魔法命令(time/timeit,memit/mprun)

魔法命令是ipython提供特殊命令，能实现一些特殊功能，比如统计时间(time/timeit)和占用内存(memit/mprun)等功能。
魔法命令两种形式:

• % :行模式
• %% :单元格模式

time

time 统计语句执行时间，被统计语句只执行一次

timeit

timeit可以循环多次执行被统计语句，得到平均执行时间，支持行模式和单元格模式。
timeit命令参数，–n 指定每轮测试次数，-r 指定测试轮数(默认为7)
单元格模式

• 第一行语句(与timeit同一行语句)为初始化语句，作用为后续代码中变量提供初始化功能。
• 初始化语句每轮测试只执行一次，且不参与计时。第二行至整个单元格末尾语句会执行相应次数，并参与计时。

# time用来统计语句执行时间，被统计语句只执行一次
%time time.sleep(0.5)

# -n 每轮循环的次数
# -r 执行轮数 默认是7轮
%timeit -n 1000 -r 2 a=1

单元格模式

%%time 
time.sleep(0.5)
time.sleep(0.6)

%%timeit -n 2 -r 3 print('初始化语句')
print('hello world')
# 单元格模式下，我们可以在timeit后面（同一行）使用初始化语句
# 初始化语句作用为后续被统计的执行代码提供变量的初始化
# 初始化语句执行次数由轮数来决定

writefile

​ 将单元格内容写入到文件中。如果文件不存在则创建，如果文件存在，则覆盖文件。如果指定 –a 参数，则追加内容,不覆盖。

%%writefile -a  test.py
print('update222222....')

run

​ 运行外部python文件，运行结束后，外部文件中定义的变量得到保留。
格式： %run 文件路径

%run test.py

memit

分析语句内存使用情况。memit支持行模式与单元格模式。单元格模式下，初始化语句不会参与计算内存。第二行至整个单元格末尾会参与计算内存。 

说明：

• memit不是Ipython内置，需要安装memory_profiler模块(pip install memory_profiler)
• 安装后，需要通过%load_ext memory_profiler载入，才能使用

%load_ext memory_profiler

def m1():
    print('hello world')

%memit m1()

mprun

逐行分析语句内存使用情况，分析结果列如下：

• Line 行号
• Mem usage 内存使用大小
• increment内存增量
• Line content 代码内容

说明：

• mprun不是Ipython内置，需要安装memory_profiler模块
• 安装后，需要通过%load_ext memory_profiler载入，才能使用
• mprun测试的函数必须定义在独立模块中，不能定义在交互式Ipython环境中
• 如果需要重新加载模块，可以调用importlib模块提供reload函数实现

%%writefile test2.py
def m():
    li1 = [i for i in range(20000)]
    li2 = [i for i in range(400000)]
    
# import test2

# 修改代码后，想要再次导入代码所在的模块成功，需要使用importlib模块的relaod方法
import importlib
importlib.reload(test2)

# %mprun -f 分析函数 执行语句
%mprun -f test2.m test2.m()

数组属性

数组对象具有如下常用属性:

• ndim:n-dimension,维度
• shape:形状，每个维度上相应长度
• dtype:数据类型
• size:数组元素个数
• itemsize:一个数组元素占用内存空间，字节为单位

x = np.array([1,2,3])
display(x.ndim)

y = np.array([[1,2,3],[2,3,4]])
display(y.ndim)

# 返回数组对象形状，每个维度上长度,元祖
display(y.shape)   #(2, 3)
# 返回数据类型
display(y.dtype)    #dtype('int32')
# 返回元素个数
display(y.size)
# 返回一个元素占用内存空间，字节为单位
display(y.itemsize)

数据类型及转换（astype）

• 创建数组时候，可使用dtype指定数组中元素类型
• 如果没有指定，根据元素类型进行推断
• 如果类型不同，会选择兼容类型
• 使用astype函数转换数据类型

# 使用dtype指定数组中元素类型
x = np.array([1,2,3],dtype=np.float32)
display(x.dtype)

# 如果没有指定，根据元素类型进行推断
y = np.array([1.1,2.1,3.1])
display(y.dtype)

# 如果类型不同，会选择兼容类型（向上）
z = np.array([1.1,2,3,4])
display(z.dtype)

# 使用astype函数转换数据类型
w = np.array([1.1,2.2,3.3,-4.4])
display(w.dtype)

m = w.astype(np.int64)
display(m)

改变数组形状(reshape)

我们可以通过数组对象的reshape方法(或者np的reshape函数)改变数组形状。
说明：

• nump中很多方法，既可以使用np来访问，也可以通过数组对象来访问

# 一维数组改为多维数组
x = np.arange(6)
display(x)

# 数组对象，reshape的参数可以是元祖，也可以将元祖中内容分开传入
# y=x.reshape(3,2)
# np的reshape方法，只能使用元祖传入,不能将元祖中内容分开传入
y=np.reshape(x,3,2)
display(y)
# 多维数组改为1维数组
# x = np.array([[1,2,3],[3,4,5]])
# display(x)
# # y = x.reshape((-1))
# y = np.reshape(x,(-1))
# display(y)

索引与切片

在python中，序列类型支持索引与切片。ndarray数组也支持类似操作。不过两者之间既有相同点，也有不同点。

• 相似点：数组对象也支持索引与切片，语法python中索引与切片类似
• 不同点：数组切片返回的原数组数据视图。如果需要复制底层数组元素，可使用数组对象copy方法
  注意：视图共享底层数组元素。

索引访问

# 索引访问
import numpy as np
x = np.arange(9).reshape(3,3)
display(x)
# 从低维获取数据
# x是2维数组，包含低维和高维，低维对应向下坐标轴，表示为0方向；高维对应向右 坐标轴，表示1方向。
# x[1]从低维度，也就是从0方向上获取数据，即访问的第一行的数据
display(x[0])
display(x[1][1])
#######输出结果######
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])
array([0, 1, 2])
4

切片访问

# 切片访问
    # 0 1 2
    # 3 4 5
    # 6 7 8
x = np.arange(9).reshape(3,3)
display(x)

# 得到
# 3 4 5
# 6 7 8
# y = x[1:3]
# display(y)

# 得到
# 3 4
# 6 7
# y = x[1:3,0:2]
# display(y)

# 得到
# 1 2
# 4 5
# 7 8
# y = x[:,1:3]
# display(y)

    # 得到
    # 1 2
    # 4 5
# y = x[0:2,1:3]
# display(y)

# 得到 修改步长
# 0 1 2
# 6 7 8
y = x[0:3:2,:]
display(y)

注意： 切片得到新的数组,和原有的数组共享底层内存中数据，修改其中一方都会去影响对方的数据，通过数组对象的copy方法得到新的数组，新的数组和原有数组之间不共享数据。

x = np.array([1,2,3])
# y = x[:]

# # y[0]=100
# x[0]=200
# display(x)
# display(y)

w = x.copy()
w[0]=30
display(x)
display(w)

整数数组进行索引

​ 当选取元素不连续时候，可以提供一个索引数组选择(或修改)对应索引位置元素。 说明

• 通过整数数组索引，返回的是原数组拷贝
• 可以提供多个一维数组索引，此时会将每个数组中内容对应作为索引，返回对应的元素

x = np.arange(20).reshape(5,4)
display(x)
# 获取第0 2 3,不连续数据
# y = x[[0,2,3]]
# display(y)

# y[0][0]=100
# display(y)

# display(x)

# 返回0 （0,0） 2  （0,2） 8 （2,0）10 （2,2）
# [0,0,2,2]  [0,2,0,2]
y= x[[0,0,2,2],[0,2,0,2]]
display(y)

布尔数组进行索引

我们可通过布尔数组对数组进行索引，获取对应的元素。获取数据原则，为True，获取对应位置，为False，不获取。
说明：

• 索引布尔数组通过对现有数组计算得到
• 逻辑运算符和python不同:and->&， or->|，not->~,条件组合时候，条件需用小括号

x = np.arange(12).reshape(4,3)
display(x)
# 使用布尔数组获取第0行 1行数据
y=x[[True,True,False,False]]
display(y)

# 大于5
# x[x>5]

# 大于1小于5数据返回
x[(x>1) & (x<5)]
############返回结果##########
array([[0, 1, 2],
       [3, 4, 5]])
array([2, 3, 4])

数组扁平化

我们可以通过调用ravel或flatten方法，对数组对象进行扁平化处理,使多维的数组转变成一行数组

• np.ravel/ravel
• flatten
  两者区别在于，ravel返回数组原数组共享数据，而flatten返回原数组拷贝

x = np.arange(12).reshape(3,2,2)
display(x)

# y = np.ravel(x)
# 返回的数组和原数组共享数据，修改返回数组影响原有数组
y=x.ravel()
y[0]=200

# 返回的原数组拷贝，修改返回数组不影响原有数组
# y = x.flatten()
# y[0] = 100

display(x)
display(y)
###########输出结果############
array([[[ 0,  1],
        [ 2,  3]],

       [[ 4,  5],
        [ 6,  7]],

       [[ 8,  9],
        [10, 11]]])
array([100,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11])

数组存储顺序

在创建数组时，我们可以通过order参数指定数组元素存储顺序。存储顺序分为2种：

• C: 按照行存储
• F: 按照列存储
  说明：order参数作用于两个步骤：一是数据抽取（扁平化处理）顺序;二是数据构建(数组填充)顺序

x = np.array([1,2,3,4]).reshape((2,2),order='C')
y = np.array([1,2,3,4]).reshape((2,2),order='F')

display(x)
display(y)
###############输出结果################
array([[1, 2],
       [3, 4]])
array([[1, 3],
       [2, 4]])

通用函数ufunc(universal function)

Numpy提供很多通用函数，它们可看做对应Python计算向量化版本

• abs/fabs 绝对值/浮点的绝对值
• cell/floor 上入整数/下舍整数
• exp
• log/log2/log10
• modf 取小数部分
• sin/sinh/cos/cosh
• sqrt

x = np.array([-1.2,10,1.5])

# np.abs(x)
np.modf(x)
###########输出结果##############
(array([-0.2,  0. ,  0.5]), array([ -1.,  10.,   1.]))

统计函数

Numpy具有如下常用统计函数

• mean/sum 平均值/总和
• max/min 最大值/最小值
• argmax/argmin 最大值索引/最小值索引
• std/var 标准差/方差
• cumsum/cumprod 累加和/累加乘

# 统计函数如果只传入数组对象的话，它会对数组首先做一个扁平化处理，再对扁平化后的一维数组的所有的数据进行统计
x = np.arange(1,5).reshape(2,2)
display(x)

# display(np.mean(x),np.sum(x))
# display(np.max(x),np.min(x))
# argmax 得到最大值对应索引值，argmin最小值对应索引值
# display(np.argmax(x),np.argmin(x))
# std标准差  var方差
# display(np.std(x),np.var(x))
# cumsum 累加和 cumprod 累乘
display(np.cumsum(x),np.cumprod(x))

轴(axis)

可以指定axis参数改变统计的轴。在二维数组中，0表示竖直方向操作，1表示沿着水平方向操作。
超过二维的多维数组，轴相对复杂，可认为沿着轴所指定坐标变化方向，其他轴坐标不变。进行操作。
比如轴是 axis = 0，则根据第一维的坐标变化方向，其他维的坐标不变。

    语文   数学
zs  90     92
ls  85     100

scores = np.array([[90,92],[85,100]])
# axis=0，从竖直方向统计数据，获得语文的最高分，以及数学的最高分
display(np.max(scores,axis=0))

# 如果我们指定轴为0，第一个维度的坐标变化的，第二个维度的坐标不变
x = np.arange(12).reshape((3,2,2))
display(x)
display(x.sum(axis=0))
##############输出结果#########
array([[[ 0,  1],
        [ 2,  3]],

       [[ 4,  5],
        [ 6,  7]],

       [[ 8,  9],
        [10, 11]]])
array([[12, 15],
       [18, 21]])

连接和拆分函数

• np.concatenate对多个数组按指定轴方向进行连接
• np.vstack/np.hstack
• np.split/np.hsplit/np.vsplit

101班成绩 数学 语文 [[95,100], [96,98]]

102班成绩 数学 语文 [[97,98], [96,99], [95,94]]

# 对101班和102班成绩进行垂直连接，列数一致
x = np.array([[95,100],[96,98]])
y = np.array([[97,98],[96,99],[95,94]])
# display(x,y)

# w = np.concatenate((x,y),axis=0)
w = np.vstack((x,y))
display(w)
'''
array([[ 95, 100],
       [ 96,  98],
       [ 97,  98],
       [ 96,  99],
       [ 95,  94]])
'''
# 对w进行横向切分，将数据切分2部分
z = np.split(w,2,axis=1)
display(z)
'''
[array([[95],
        [96],
        [97],
        [96],
        [95]]), array([[100],
        [ 98],
        [ 98],
        [ 99],
        [ 94]])]

'''
# 对w进行纵向切方，得到3部分数据 第0，1行，第2，3行  第4行
z = np.split(w,[2,4],axis=0)
display(z)
'''
[array([[ 95, 100],
        [ 96,  98]]), array([[97, 98],
        [96, 99]]), array([[95, 94]])]
'''

其他函数

• any/all
• transpose
• dot
• np.sort
• np.argsort

any和all

# any和all运算时，数组元素为0 False 空返回False，其他返回True
# any有一个数组元素返回True，any返回True
x = np.array([0,0,False])
display(x.any(),x.all())

transpose 转置

# transpose对数组数据进行转置
x = np.arange(1,5).reshape(2,2)
display(x)

# display(x.transpose())
display(x.T)

# 数组转置本质上轴的颠倒，对于二维数组a[i][j]-->a[j][ip]  a[0][1]-->a[1][0]
# 传入参数，指定轴的颠倒顺序
y = np.arange(1,13).reshape(3,2,2)
# display(y)
# # 如果tanspose方法不传入参数，默认前后颠倒  a[i][j][k]-->a[k][j][i]
# # transpose(0,2,1)    a[i][j][k]-->a[i][k][j]
# # 
# display(y.transpose(0,2,1))

dot 点积，矩阵的乘法

x = np.array([[1,2],[3,4]])
y = np.array([[2,3],[1,2]])
display(x,y)
# 不是矩阵乘法运算
# display(x*y)
# 使用dot实现矩阵乘法（点积）运算
# display(x.dot(y))
display(x.dot(3))

sort 排序

# sort 排序
x = np.array([3,-1,2])
# display(np.sort(x))
y=np.array([[3,2],[1,2]])
display(y)
# sort对数组内容进行排序，默认按照最后一个轴的方向排序，如果是二维，按照水平方向排序，从小到大
# display(np.sort(y,axis=1))
# argsort 对数组内容对应的下标进行排序，
display(np.argsort(y))

归一化矩阵

将矩阵值转化为0到1区间

• 归一化公式：x-min/max-min
  max为每列最大值，min为每列最小值

90 1
80 2
70 2
min 70 1
max 90 2

90-70/90-70=20/20=1
80-70/90-70=10/20=0.5

x = np.array([[90,1],[80,2],[70,2]])
# 得到0方向最大值
max = x.max(0)
# 得到0方向最小值
min = x.min(0)
# 得到max-min的范围值
range = max-min

# 矩阵减去min在0方向的复制，除以范围在0方向上复制
shape = x.shape
y = x - np.tile(min,(shape[0],1))
y = y/np.tile(range,(shape[0],1))
y

### 输出结果 ###
array([[ 1. ,  0. ],
       [ 0.5,  1. ],
       [ 0. ,  1. ]])

title 复制函数

a = np.tile([1,2],(1,2)) #后面传的是元祖，1，在0 方向上不变，在1的方向上复制总2份
a

######输出结果######

array([[1, 2, 1, 2]])