Numpy使用入门

Jupyter

启动

jupyter notebook

magic methed

运行外部python文件	%run /home/nanfengpo/Desktop/bb.py
运行计时	%time statement 计算代码块的运行时间
	%timeit statement 计算代码运行的平均时间
	%%timeit statement1 statement2 计算多行代码的平均运行速度
查看当前会话中的所有变量和函数	%who 查看当前会话的所有变量和函数名称
	%whos 查看当前会话的所有变量和函数名称的详细信息
	%who_is 返回一个字符串列表,里面元素是当前会话的所有变量与函数名称
执行linux指令	在指令前 加 ! 例如 !ls
更多魔法指令	lsmagic 列出所有魔法指令

jupyter notebook 快捷键

enter	进入编辑模式
shift+enter	运行本单元,选中下一单元
Y	单元转入代码状态
M	单元转入Markdown状态
A	在上方插入新单元
B	在下方插入新单元
Double-D	删除一行
ctrl+enter	运行本单元
alt+enter	运行本单元,在下面插入一个单元

Numpy

Numpy是python的一种开源的数值计算扩展

• 强大的N维数组对象Array
• 丰富的函数库
• 用户整合C/C++和Fortran代码的工具包
• 使用的线性代数,傅里叶变换和随机数生成函数
• numpy和系数矩阵运算包scipy配合使用更加强大

使用方法

创建数组对象

• 使用np.array() 创建

创建一维array对象
import numpy as np
test = np.array([1,2,3,4,5])
test
输出 array([1, 2, 3, 4, 5])

创建多维array对象
test = np.array([[1,2,3],[4,5,6]])
test
输出 array([[1, 2, 3],
       [4, 5, 6]])

使用np的常规函数创建

数组对象内部参数固定为1

np.ones(shape, dtype=None, order='C')

参数shape是array数组的样式 dtype是数组里参数的类型 order='C'

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

np.ones([3,3],dtype=int)
输出结果：
array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

自定义数组对象内部参数

np.full(shape, fill_value, dtype=None, order='C')

fill_value 是数组对象填充的参数

np.full([3,3],3.14)
输出结果：
array([[ 3.14,  3.14,  3.14],
       [ 3.14,  3.14,  3.14],
       [ 3.14,  3.14,  3.14]])

对角线生成多维数组对象

np.eye(N, M=None, k=0, dtype=float) k参数为便宜

np.eye(4,4)
输出结果：
array([[ 1.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.]])
np.eye(4，4，1)
输出结果：
array([[ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.],
       [ 0.,  0.,  0.,  1.],
       [ 0.,  0.,  0.,  0.]])
np.eye(4，4，-1)
输出结果：
array([[ 0.,  0.,  0.,  0.],
       [ 1.,  0.,  0.,  0.],
       [ 0.,  1.,  0.,  0.],
       [ 0.,  0.,  1.,  0.]])

生成等差数列

(1)指定起始值,结束值,以及需要生成的个数 生成等差数列一维数组

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start 起始值 stop 结束值 参数num 分成的份数

retstep 为True时 显示步长 endpoint为True时 最后一个值是stop值

等差数列
np.linspace(0,10,5)
输出结果：
array([  0. ,   2.5,   5. ,   7.5,  10. ])

(2)指定起始值,结束值,以及步长 生成等差数列 一维数组

np.arange([start, ]stop, [step, ]dtype=None)

等差数列
np.arange(0,10,2)
输出结果：
array([0, 2, 4, 6, 8])

生成随机数

(1)随机整数一维数组

np.random.randint(low, high=None, size=None, dtype='l')

size是生成的数量

np.random.randint(0,10,5)
输出结果：
array([0, 7, 2, 3, 7])

(2)随机数一维/多维数组

np.random.randn(d0, d1, ..., dn)

#例子
np.random.randn(4,3,2)
输出   从最后一个参数开始  2个数一组   3个组一列   最后 生成4个列 
array([[[-0.75635231,  0.81645401],
        [ 0.75044476, -0.45594693],
        [ 1.18962227, -1.69061683]],

       [[-1.35639905, -1.23243451],
        [-0.54443916, -0.66817174],
        [ 0.00731456, -0.61293874]],

       [[ 1.29974807, -1.73309562],
        [-0.9833101 ,  0.35750775],
        [-1.6135785 ,  1.47071387]],

       [[-1.1880176 , -0.54974619],
        [-0.94004616, -0.82793236],
        [ 0.10886347,  0.50780959]]])

np.random.randn(10)
# 每次每次都不一样
输出结果：
array([-1.74976547,  0.3426804 ,  1.1530358 , -0.25243604,  0.98132079,
        0.51421884,  0.22117967, -1.07004333, -0.18949583,  0.25500144])

np.random.seed(100)#随机的种子，有了种子，每次都一样
np.random.randn(10)

输出结果：
array([ 0.37332715, -0.2887605 ,  0.04985088, -0.93815832, -0.4087037 ,
        1.13352254,  0.52713526, -0.76014192, -0.97292788,  0.16290446])

(3)随机数一维数组

np.random.random(size=None)

np.random.random(3)
array([0.73130075, 0.34038522, 0.0920556 ])

数组的属性

• ndim 维度
• shape 各个维度的长度
• size 总长度
• dtype 元素类型

数组的操作

索引

np.random.seed(2)
# 随机整数 5个一列 4列一组  生成3组
x = np.random.randint(10,size=[3,4,5])
# 取第3组第1列第1个
print(x[2,0,0])
print(x)
输出
6
[[[8 8 6 2 8]
  [7 2 1 5 4]
  [4 5 7 3 6]
  [4 3 7 6 1]]

 [[3 5 8 4 6]
  [3 9 2 0 4]
  [2 4 1 7 8]
  [2 9 8 7 1]]

 [[6 8 5 9 9]
  [9 3 0 0 2]
  [8 8 2 9 6]
  [5 6 6 6 3]]]

切片

一维与列表完全一致 多维时同理
np.random.seed(0)
x = np.random.randint(100,size = (10,4))
x
输出结果：
array([[44, 47, 64, 67],
       [67,  9, 83, 21],
       [36, 87, 70, 88],
       [88, 12, 58, 65],
       [39, 87, 46, 88],
       [81, 37, 25, 77],
       [72,  9, 20, 80],
       [69, 79, 47, 64],
       [82, 99, 88, 49],
       [29, 19, 19, 14]])

切片：
x[7:10]
切片结果：
array([[69, 79, 47, 64],
       [82, 99, 88, 49],
       [29, 19, 19, 14]])

变形

使用reshape函数，注意参数是一个tuple！
x = np.arange(0,16).reshape(4,4)
x

执行结果：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

类型是：
type(x.shape)

tuple

级联

np.concatenate([x,x],axis = 0)

np.concatenate() 级联需要注意的点：
级联的参数是列表：一定要加中括号
维度必须相同
形状相符
【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向np.concatenate() 级联需要注意的点：
级联的参数是列表：一定要加中括号
维度必须相同
形状相符
【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
可通过axis参数改变级联的方向

x = np.array([1,2,3])
y = np.array([1,5,6,7,3,20])
x
输出 array([1, 2, 3])
输出 array([ 1,  5,  6,  7,  3, 20])

z = np.concatenate([x,y])
z
输出 array([ 1,  2,  3,  1,  5,  6,  7,  3, 20])
z.shape
输出 (9,)

/
#二维
x = np.array([[1,2,3],[4,5,6]])
x

array([[1, 2, 3],
       [4, 5, 6]])

x.shape
(2,3)

p = np.concatenate([x,x]).shape
p
(4, 3)

如果增加 axis 参数

个人理解:

加入有两个 shape为 (4,3,2) 的数组级联操作

axis 为0 时 是 最外层的相加 也就4 这个级别

axis为1 时 是第二层的相加 也就是3这一层

axis为2时 是第三层的相加 就是2这一层

下面这个是例子 是 两个 shape为 (2,3,3)的数组的级联操作

import numpy as np
x = np.array([[[1,2,3],[2,2,3],[3,3,3]],[[4,4,4],[5,5,5],[6,6,6]]])
print(x)
print(x.shape)
输出：
[[[1 2 3]
  [2 2 3]
  [3 3 3]]

 [[4 4 4]
  [5 5 5]
  [6 6 6]]]
(2, 3, 3)

w = np.concatenate([x,x],axis = 0)
print(w.shape)
print(w)
输出：
(4, 3, 3)
[[[1 2 3]
  [2 2 3]
  [3 3 3]]

 [[4 4 4]
  [5 5 5]
  [6 6 6]]

 [[1 2 3]
  [2 2 3]
  [3 3 3]]
 
 [[4 4 4]
  [5 5 5]
  [6 6 6]]]

w = np.concatenate([x,x],axis = 1)
print(w.shape)
print(w)
输出：
(2, 6, 3)
[[[1 2 3]
  [2 2 3]
  [3 3 3]
  [1 2 3]
  [2 2 3]
  [3 3 3]]

 [[4 4 4]
  [5 5 5]
  [6 6 6]
  [4 4 4]
  [5 5 5]
  [6 6 6]]]
/
w = np.concatenate([x,x],axis = 2)
print(w.shape)
print(w)

输出：
(2, 3, 6)
[[[1 2 3 1 2 3]
  [2 2 3 2 2 3]
  [3 3 3 3 3 3]]

 [[4 4 4 4 4 4]
  [5 5 5 5 5 5]
  [6 6 6 6 6 6]]]

水平级联和垂直级联

np.hstack 水平级联

np.vstack 垂直级联

x = np.array([[1,1],[2,2],[3,3]])
y = np.array([1,2,3])
print(np.hstack(x))
print(np.vstack(y))

输出：
[1 1 2 2 3 3]
[[1]
 [2]
 [3]]

切分

(1)np.split()

np.split(ary, indices_or_sections, axis=0)

x = np.arange(1,10)
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
x1,x2,x3 = np.split(x,[3,5])  #[3,5] 是索引位置
print(x1,x2,x3)
输出：
[1 2 3] [4 5] [6 7 8 9]
___________________________
x1,x2,x3,x4 = np.split(x,[1,4,6])
print(x1,x2,x3,x4)
输出:
[1] [2 3 4] [5 6] [7 8 9]
____________________________
x = np.arange(3,10)
x
输出: array([3, 4, 5, 6, 7, 8, 9])
x1,x2,x3,x4 = np.split(x,[1,3,5])
print(x1,x2,x3,x4)
输出:[3] [4 5] [6 7] [8 9]

(2)np.hsplit()

垂直切分

x = np.arange(16).reshape(4,4)
x
输出：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

print(np.hsplit(x,[2,3])) 
# [2,3] 是切的位置  2 为 0,1 |4,5| 8,9 | 12,13
# 3为 2 6 10 14
输出：
[array([[ 0,  1],[ 4,  5], [ 8,  9], [12, 13]]),
         array([[ 2],  [ 6],  [10], [14]]), 
         array([[ 3],  [ 7],  [11],  [15]])]

(3)np.vsplit()

横切

x = np.arange(16).reshape(4,4)
x
输出：
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
# 横切  把 1,2 两行 切到一组   第3行切为一组  剩余的为一组
print(np.vsplit(x,[2,3]))
输出：
[array([[0, 1, 2, 3],
        [4, 5, 6, 7]]), array([[ 8,  9, 10, 11]]), array([[12, 13, 14, 15]])]

副本

所有赋值运算不会为ndarray的任何元素创建副本。对赋值后的对象的操作也对原来的对象生效

a = np.array([1,2,3])
b=a
print(a,b)
输出：
[1 2 3] [1 2 3]

b[0]=2
a
输出：
array([2, 2, 3])

可使用copy()函数创建副本

a = np.array([1,2,3])
b = a.copy()
b
输出：
[1,2,3]

b[0]=3
print(a,b)
输出：
[1 2 3] [3 2 3]

聚合操作

• 求和np.sum()

x = np.arange(4)
np.sum(x)
输出 6

• 最大最小值：np.max/ np.min
• 求平均值 np.mean(heights)
• 计算标准差 heights.std()

矩阵操作

• 基本操作 加减乘除

a = np.array([[1,2,3],
[4,5,6]])
a
输出：
array([[1, 2, 3],
       [4, 5, 6]])
a+1
输出：
array([[2, 3, 4],
       [5, 6, 7]])
a*2
输出：
array([[ 2,  4,  6],
       [ 8, 10, 12]])

a+[[1,4,9],[3,3,3]]
输出：
array([[ 2,  6, 12],
       [ 7,  8,  9]])

a*2-2
输出：
array([[ 0,  2,  4],
       [ 6,  8, 10]])

• 矩阵积

  A*B

  A的横排去乘B的竖排 按顺序去乘即可

• 广播机制

【重要】ndarray广播机制的两条规则
规则一：为缺失的维度补1
规则二：假定缺失元素用已有值填充

例子

a = np.ones((4,1))
a 
输出: 
    array([[1.],
       [1.],
       [1.],
       [1.]])
b = np.arange(4)
b
输出:
    array([0, 1, 2, 3])

a + b    
a 实际上变成了 
    array([[1.,1,1,1],
       [1.,1,1,1],
       [1.,1,1,1],
       [1.,1,1,1]])
这个就是规则1 给缺失的维度补1
而b变成了
        array([[0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3],
       [0, 1, 2, 3]])
这个就是规则2 假定缺失元素用已有值填充

因此 a+b的值 输出为

array([[1., 2., 3., 4.],
       [1., 2., 3., 4.],
       [1., 2., 3., 4.],
       [1., 2., 3., 4.]])

排序

• 快速排序

np.sort()与ndarray.sort()都可以，但有区别：
np.sort()不改变输入
ndarray.sort()本地处理，不占用空间，但改变输入

• 部分排序

np.partition(a,k) #参数1是数组 参数2是要的个数

当k为正数时 要最小的k个 数 这几个数在数组前k个

当k为负数时 要最大的k个 数 这几个数在数组后k个

有的时候我们不是对全部数据感兴趣，我们可能只对最小或最大的一部分感兴趣。
当k为正时，我们想要得到最小的k个数
当k为负时，我们想要得到最大的k个数