小白眼中的AI之~Numpy基础

1.数组定义、常见属性

引入一下 Numpy模块, Numpy的数组使用可以查看一下帮助文档, Numpyarray数组类型必须是一致的(后面会讲)

# 导入Numpy模块
import numpy as np
help(np.array) #或者用 np.array? 查看

1.1.通过List创建数组

np.array(list)

注意

print(np.array([1,2,3,4,5]))np.array([1,2,3,4,5])

在交互摸索下显示是稍微有点区别的,千万别以为是不一样的东西

# 构造一个list1
list1 = list(range(10))
print(list1)

# 通过List创建一个一维数组
array1 = np.array(list1)

print(array1)
type(array1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0 1 2 3 4 5 6 7 8 9]





numpy.ndarray
# 你直接写也一样
test_array = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

print(test_array)
type(test_array)
[0 1 2 3 4 5 6 7 8 9]





numpy.ndarray
# 创建一个嵌套列表
list2 = [list1,list1]
print(list2)

# 通过嵌套列表创建二维数组
array2 = np.array(list2)
print(array2)
[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]
# 创建3维数组
array3 = np.array([
    [[1,2,3],[4,5,6],[7,8,9]],
    [[1,2,3],[4,5,6],[7,8,9]]
])

print(array3)
type(array3)
[[[1 2 3]
  [4 5 6]
  [7 8 9]]

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





numpy.ndarray
################### 扩展部分 ########################

# 其实你通过元组创建也一样,只是官方演示文档里面用的是list

# 逆天推荐使用列表(和官方文档一致嘛)
# 一维数组
np.array((1,2,3,4,5))
array([1, 2, 3, 4, 5])
# 都是一个数组,你print和直接输入名字是稍微有点区别的
# 千万别以为是不一样东西

print(np.array((1,2,3,4,5)))
[1 2 3 4 5]
# 二维数组
np.array(((1,2,3),(4,5,6)))
array([[1, 2, 3],
       [4, 5, 6]])
# 二维数组,这种方式也一样
np.array(([1,2,3],[4,5,6]))
array([[1, 2, 3],
       [4, 5, 6]])

1.2.常用属性

ndim 查看数组维度

shape 查看数组形状

size 查看数组含有多少元素(行*列)

dtype 查看元素的数据类型

help(array2)
# 查看维度
print(array1.ndim)
print(array2.ndim)
print(array3.ndim)
1
2
3
# 数组的形状,Tuple类型
print(array1.shape)
print(array2.shape) # 2行10列
print(array3.shape)
(10,)
(2, 10)
(2, 3, 3)
# 查看总共多少元素(行*列)
array2.size
20
# 查看元素的数据类型
array2.dtype
dtype('int64')
################### 扩展部分 ########################
# Array元素类型都一致,如果不一致会以最大兼容来初始化

np.array([[1,2,3],[4,5,6.0]]) # 都变成Float类型了
array([[1., 2., 3.],
       [4., 5., 6.]])
# 指定类型
np.array([[1,2,3],[4,5,6]],dtype=float)
array([[1., 2., 3.],
       [4., 5., 6.]])
# 行元素的个数不一致的测试

test_list = [[1],[1,2]]
print(test_list)

test_array = np.array(test_list)

print(test_array)

print(test_array.dtype) # 全部变成了object
[[1], [1, 2]]
[list([1]) list([1, 2])]
object

1.3.通过arange和reshape创建数组

range()返回的是 range对象,而 np.arange()返回的是 numpy.ndarray()

两者都可以进行迭代,而 np.nrange还是一个序列,可被当做向量使用

range()不支持步长为小数, np.arange()支持步长为小数

如果这些基础类型还不是很清楚,可以看我之前写的文章:

Python3 与 C# 基础语法对比(新排版)


多维数组创建:(reshape的 行x列 != 元素个数 就会报错)

创建3行5列的数组: np.arange(15).reshape((3,5))

告诉它多少列,自动求行: np.arange(20).reshape((-1,5))

告诉它多少行,自动求列: np.arange(20).reshape((4,-1))

help(np.arange)
list(range(5))
[0, 1, 2, 3, 4]
np.arange(5)
array([0, 1, 2, 3, 4])
type(range(1,10))
range
# 用法和range差不多
array1 = np.arange(1,10) # [1,10)

print(array1)

type(array1)
[1 2 3 4 5 6 7 8 9]





numpy.ndarray
# 可以直接迭代
for i in array1:
    print(i,end=' ')
1 2 3 4 5 6 7 8 9
# Python里面的range不支持步长为小数
range(1,10,0.5)
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-27-546bf1d2fbc2> in <module>()
      1 # Python里面的range不支持步长为小数
----> 2 range(1,10,0.5)


TypeError: 'float' object cannot be interpreted as an integer
# 支持步长为小数
np.arange(1,10,0.5) # step为0.5
array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,
       7.5, 8. , 8.5, 9. , 9.5])
################### 开始变化 ########################
help(array1.reshape)
# 创建2维数组,参数传元组比较合适(官方案例也是元组)
np.arange(1,10,0.5).reshape((2,9))
array([[1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ],
       [5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5]])
# 3行5列
np.arange(15).reshape((3,5))
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
# 告诉它多少列,自动求行
np.arange(20).reshape((-1,5))
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
# 告诉它多少行,自动求列
np.arange(20).reshape((4,-1))
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14],
       [15, 16, 17, 18, 19]])
# reshape的 **行x列 != 元素个数** 就会报错
np.arange(20).reshape(3,7)
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-35-7050b8704de5> in <module>()
      1 # reshape的 **行x列 != 元素个数** 就会报错
----> 2 np.arange(20).reshape(3,7)


ValueError: cannot reshape array of size 20 into shape (3,7)

1.4.创建随机数组

np.random.randint 生成给定范围内均匀分布的整数

np.random.rand 生成 [0,1)之间均匀分布的随机数

np.random.ranf 生成均匀分布的浮点数字 [0.0,1.0)

np.random.randn 生成符合正态分布的随机数

np.random.normal 从正态分布中返回符合你输入的均值与方差以及shape的值

扩展: np.random.seed 设置随机种子,一般不太用,特殊场景需要

# 生成一个给定范围内均匀分布的整数[0,10)
np.random.randint(10)
0
# 生成20个在[0,10)的整数
np.random.randint(10,size=20)
array([4, 4, 7, 8, 1, 7, 5, 7, 4, 4, 3, 7, 2, 6, 9, 2, 7, 0, 4, 5])
# 生成2*4的数组,取值范围在[0,5)
np.random.randint(5, size=(2, 4))
array([[1, 1, 0, 1],
       [3, 0, 1, 4]])
# 更多可以查看
help(np.random.randint)
# 均匀分布的随机数[0,1)
np.random.rand(10)
array([0.08996296, 0.82827789, 0.74820873, 0.09045909, 0.26352475,
       0.66150275, 0.0038369 , 0.47934078, 0.43417883, 0.05288273])
# 更多可以查看
help(np.random.rand)
# 均匀分布的浮点数字[0.0, 1.0)
np.random.ranf(10)
array([0.95702794, 0.59910303, 0.73824443, 0.6832429 , 0.64869682,
       0.0955835 , 0.99294838, 0.55386257, 0.25567338, 0.95512264])
# 更多可以查看
help(np.random.ranf)
# 创建10个符合正态分布的随机数
np.random.randn(10)
array([ 1.05768826e+00, -3.95641972e-01,  2.37315110e+00, -6.94658823e-01,
        7.70828099e-01,  1.91420905e+00, -1.77742033e+00,  1.87125778e+00,
        3.81989892e-01,  1.85276444e-03])
# 更多可以查看
help(np.random.randn)
# 符合均值为0,方差为1的正态分布的浮点数
np.random.normal()
-0.9892652426992485
# 符合均值为10,方差为100的正态分布的浮点数
np.random.normal(10,100)
-39.99076455480153
# 符合均值为10,方差为100,3*2的正态分布矩阵
np.random.normal(10,100,(3,2))
array([[106.69681561, -81.35604536],
       [-22.26387387, 141.78449018],
       [ 28.3122283 , -96.87127422]])
# 更多可以查看
help(np.random.normal)

1.5.linspace创建等差数组

np.linspace 生成等差数列的数组

和arange不一样的是end值可以取到

help(np.linspace)
# 创建一个从0~10,差值为1的等差数组
# 0~10总共11个数(和arange不一样的是end值可以取到)
np.linspace(0,10,11)
array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])
# 0~20(总共22个数)差值为2的等差数组
np.linspace(0,20,11)
array([ 0.,  2.,  4.,  6.,  8., 10., 12., 14., 16., 18., 20.])
# 也可以让end_index取不到
np.linspace(0,20,10,endpoint=False)
array([ 0.,  2.,  4.,  6.,  8., 10., 12., 14., 16., 18.])

2.数组常用方法

2.1.数组元素的获取

基础用法之前讲过,可以回顾一下:https://www.cnblogs.com/dotnetcrazy/p/9114691.html#2.1.Python

简写: array_name[行,列] (行列都是从0开始)

其他写法: array_name[行][列]Numpy不建议这么写,多维数组用切片的时候语义容易偏差,eg: xx[:2][:2])

# 先用熟悉的一维数组
array1 = np.arange(10)

print(array1)
[0 1 2 3 4 5 6 7 8 9]
# 取第一个元素
array1[0]
0
# 取最后一个元素
array1[-1]
9
# 取第二个元素
array1[1]
1
# 取倒数第二个元素
array1[-2]
8
################### 二维数组 ########################
test_array = np.array([[1,2,3],[4,5,6]])

print(test_array)
[[1 2 3]
 [4 5 6]]
# 获取元素4(行列都是从0开始)
test_array[1][0] # Numpy不建议这么写
4
# 获取元素4 简写
test_array[1,0]
4
# 获取第一行最后一个
test_array[0,-1]
3
# 获取最后一行倒数第二个元素
test_array[-1,-2]
5

2.2.多维数组的切片用法

array_name[行切片,列切片] eg: test_array[1:3,1:3]==> 取索引为1,2的行;取索引为1,2的列

基础用法之前讲过,可以回顾一下:https://www.cnblogs.com/dotnetcrazy/p/9155310.html#1.7.列表切片

# 先用熟悉的一维数组
array1 = np.arange(100)

print(array1)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
 96 97 98 99]
# 全部取出来
array1[::]
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
       51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
       68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
       85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
# 从索引为1~最后
array1[1::]
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
       35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
       52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
       69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
       86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
################### 切片开始 ########################
# 从第二个元素取到最后,step为10
array1[1::10]
array([ 1, 11, 21, 31, 41, 51, 61, 71, 81, 91])
# [1,5) 从下标1取到下标4,下标为5的取不到
array1[1:5]
array([1, 2, 3, 4])
# 取下标为1~倒数第二个元素(end_index取不到)
array1[1:-1]
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
       18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
       35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
       52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
       69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
       86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98])
# 取前10个
array1[:10]
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 取最后10个,可以理解为从索引-5的元素到最后
array1[-10:]
array([90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
# 前11~20(eg:第二页)
array1[10:20]
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])
# 取80~90(eg:倒数第二页)
array1[-20:-10]
array([80, 81, 82, 83, 84, 85, 86, 87, 88, 89])
# 前20个数,每两个取一个(eg:隔行换样式)
array1[:20:2]
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
# 所有数每10个取一个(eg:test的时候十里挑一)
array1[::10]
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
################### 二维数组 ########################
# 生成一个多维数组
test_array = np.arange(15).reshape(3,5)

print(test_array)
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
# [行切片,列切片]
# 行:取第2行到最后,列:取第3列到最后
test_array[1:,2:]
array([[ 7,  8,  9],
       [12, 13, 14]])
# 所有行,最后一列
test_array[:,-1:]
array([[ 4],
       [ 9],
       [14]])
# 所有行,索引[0,2)列
test_array[:,:2]
array([[ 0,  1],
       [ 5,  6],
       [10, 11]])
# 索引1的行,索引1的列
test_array[1:2,1:2]
array([[6]])
# 上面的等同于test_array[1][1]
print(test_array[1,1])
6
# 取索引为1,2的行;取索引为1,2的列
test_array[1:3,1:3]
array([[ 6,  7],
       [11, 12]])

2.3.unique、max、min、sum

np.unique 找出其中不重复的元素

np.max 找出其中最大的值

np.min 找出其中最小值

np.sum 求和系列

a = np.random.randint(5,size=(4,5))

print(a)
[[3 4 4 2 0]
 [3 3 2 1 4]
 [2 4 1 3 4]
 [2 0 3 3 0]]
# 找出其中不重复的元素
np.unique(a)
array([0, 1, 2, 3, 4])
# 找出其中最大的值
np.max(a) # 或者:a.max()
4
# 找出第1行最大值
np.max(a[0]) # 或者:max(a[0])
4
# 找出第3列最大值
np.max(a[:,2]) # 或者:max(a[:,2])
4
print(a)
[[3 4 4 2 0]
 [3 3 2 1 4]
 [2 4 1 3 4]
 [2 0 3 3 0]]
# 找出其中最小值
np.min(a) # a.min()
0
# 找出第1行最小值
np.min(a[0]) # min(a[0])
0
# 找出第3列最小值
np.min(a[:,2]) # min(a[:,2])
1
print(a)
[[3 4 4 2 0]
 [3 3 2 1 4]
 [2 4 1 3 4]
 [2 0 3 3 0]]
np.sum(a)
48
# 注意:这个是每一列分别求和
sum(a)
array([10, 11, 10,  9,  8])
# 求第1行和
np.sum(a[0]) # sum(a[0])
13
# 求第3列和
np.sum(a[:,2]) # sum(a[:,2])
10

2.4.load导入、save导出

以前我们可能使用 pickle来实现,现在直接可以用自带的方法实现,eg:

import pickle

f = open('x.dat','wb') # 写二进制文件
pickle.dump(array2,f) # 把对象array2写入f中
f.close()

f = open('x.dat','rb') # 读二进制文件
temp = pickle.load(f)
print(temp)

现在直接调用Numpy里面的方法即可

np.save('file_name',obj)
np.load('file_name.npy')

多个文件:推荐用这种指定key的方式 默认以npz结尾:

np.savez('file_name',obj1=obj1,obj2=obj2)
temp = np.load('file_name.npz')
temp[obj1]
temp.close()

也可以用扩展里面的方法

help(np.save)
!ls # 查看下当前目录

print(array2)
NumpyBase.ipynb  矩阵系列.ipynb
[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]
# 把array2对象保存成本地二进制文件(自动以.npy结尾)
np.save('bak',array2)
!ls
bak.npy  NumpyBase.ipynb  矩阵系列.ipynb
# 读取
np.load('bak.npy')
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
################### 多个对象保存 ########################
help(np.savez)
print(array1)
print(array2)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
 96 97 98 99]
[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]
# 推荐用这种指定key的方式 默认以npz结尾
np.savez('good',array1=array1,array2=array2)
!ls
bak.npy  good.npz  NumpyBase.ipynb  矩阵系列.ipynb
temp = np.load('good.npz')
temp['array1']
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
       51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
       68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
       85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
temp['array2']
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
################### 扩展系列 ########################
# 默认以npz结尾
np.savez('some',array1,array2)
!ls
bak.npy  good.npz  NumpyBase.ipynb  some.npz  矩阵系列.ipynb
temp = np.load('some.npz')

type(temp)
numpy.lib.npyio.NpzFile
# 知道有那些文件名,也就是对应的key了
keys = temp.files

print(keys)
['arr_0', 'arr_1']
# 通过这种方式获取
temp[keys[0]]
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
       51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
       68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
       85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])
temp[keys[1]]
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

看个图就知道它多文件是啥意思了

2.5.合并系列(concatenate、hstack、vstack)

2.5.1. concatenate

np.concatenate(tuple,axis=0) 默认是x轴拼接(上下、按照列顺序), axis=1 => y轴拼接(左右、按照行顺序)

help(np.concatenate)
A = np.random.randint(10,size=(2,3))print(A)
[[8 9 1] [8 9 0]]
# 默认是上下(x轴)拼接,第一个参数是元组np.concatenate((A,A))
array([[8, 9, 1],       [8, 9, 0],       [8, 9, 1],       [8, 9, 0]])
# 左右(沿y轴)拼接np.concatenate((A,A),axis=1)
array([[8, 9, 1, 8, 9, 1],       [8, 9, 0, 8, 9, 0]])

2.5.2.hstack and vstack

注意一点:concatenate只能处理一个维度的,如果维度不同可以使用容错性更强的 vstack(垂直拼接)和 hstack(水平拼接)

print(A)print(new_test_array)np.concatenate((A,new_test_array)) # 只能处理一个维度的
[[8 9 1] [8 9 0]]---------------------------------------------------------------------------NameError                                 Traceback (most recent call last)<ipython-input-124-1d57e04ff24b> in <module>()      1 print(A)----> 2 print(new_test_array)      3       4 np.concatenate((A,new_test_array)) # 只能处理一个维度的NameError: name 'new_test_array' is not defined
help(np.hstack
print(A)

np.hstack((A,A))
[[8 9 1]
 [8 9 0]]





array([[8, 9, 1, 8, 9, 1],
       [8, 9, 0, 8, 9, 0]])
np.vstack((A,A))
array([[8, 9, 1],
       [8, 9, 0],
       [8, 9, 1],
       [8, 9, 0]])
print(new_test_array)

np.hstack((A,new_test_array))
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-128-2b6aab3c90b4> in <module>()
----> 1 print(new_test_array)
      2 
      3 np.hstack((A,new_test_array))


NameError: name 'new_test_array' is not defined
# 元素不够也是一样报错的
np.vstack((A,new_test_array))
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-129-97df5d70dcf5> in <module>()
      1 # 元素不够也是一样报错的
----> 2 np.vstack((A,new_test_array))


NameError: name 'new_test_array' is not defined
help(np.vstack)

2.6.切割系列(split、hsplit、vsplit)

按行切割 np.split(test_array,[index]) 简化: np.vsplit(test_array,[index])

按列切割 np.split(test_array,[index],axis=1) 简化: np.hsplit(test_array,[index])

A = np.random.randint(10,size=10) # np.arange(10)

print(A)
[2 9 3 9 1 5 7 4 0 0]
a,b = np.split(A,[2])

print(a)
print(b)
[2 9]
[3 9 1 5 7 4 0 0]
# 索引2、4分割
a,b,c = np.split(A,[2,4])

print(a)
print(b)
print(c)
[2 9]
[3 9]
[1 5 7 4 0 0]
################### 多维系列 ########################
test_array = np.random.randint(10,size=(4,5))

print(test_array)
[[4 6 2 2 2]
 [0 7 7 9 1]
 [5 1 1 3 6]
 [9 0 5 0 1]]
# 按行切割
a,b = np.split(test_array,[1])

print(a)
print(b)
[[4 6 2 2 2]]
[[0 7 7 9 1]
 [5 1 1 3 6]
 [9 0 5 0 1]]
# 简化写法
a,b = np.vsplit(test_array,[1])

print(a)
print(b)
[[4 6 2 2 2]]
[[0 7 7 9 1]
 [5 1 1 3 6]
 [9 0 5 0 1]]
# 按列切割
a,b = np.split(test_array,[1],axis=1)

print(a)
print(b)
[[4]
 [0]
 [5]
 [9]]
[[6 2 2 2]
 [7 7 9 1]
 [1 1 3 6]
 [0 5 0 1]]
# 简化写法
a,b = np.hsplit(test_array,[1])

print(a)
print(b)
[[4]
 [0]
 [5]
 [9]]
[[6 2 2 2]
 [7 7 9 1]
 [1 1 3 6]
 [0 5 0 1]]
help(np.split)

2.7.扩展系列

2.7.1. np.copy

我们先来看看为什么要用copy

test_list = list(range(10))
print(test_list)

# 在Python中切片是不改变原列表的
new_test_list = test_list[:5]
print(test_list)
print(new_test_list)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4]
# 修改切片出来的列表不影响原列表
new_test_list[0] = 22
print(test_list)
print(new_test_list)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[22, 1, 2, 3, 4]
# 再看看Numpy的数组
test_array = np.random.randint(10,size=(3,5))
print(test_array)

new_test_array = test_array[:2,:2]
print(new_test_array)
print(test_array)
[[5 5 2 6 6]
 [1 2 2 4 8]
 [8 4 2 5 8]]
[[5 5]
 [1 2]]
[[5 5 2 6 6]
 [1 2 2 4 8]
 [8 4 2 5 8]]
# Numpy只要效率,所以不是真的给你切出新数组
new_test_array[0,0]=22

print(new_test_array)
print(test_array)
[[22  5]
 [ 1  2]]
[[22  5  2  6  6]
 [ 1  2  2  4  8]
 [ 8  4  2  5  8]]
################### Copy登场 ########################
print(test_array)

temp = test_array.copy()
new_test_array = temp[:2,:2]

print(new_test_array)
[[22  5  2  6  6]
 [ 1  2  2  4  8]
 [ 8  4  2  5  8]]
[[22  5]
 [ 1  2]]
# 验证一下是不是真的copy,的确是真copy
new_test_array[0,0] = 6

print(new_test_array)
print(test_array)
[[6 5]
 [1 2]]
[[22  5  2  6  6]
 [ 1  2  2  4  8]
 [ 8  4  2  5  8]]

原文发布于微信公众号 - 我为Net狂(dotNetCrazy)

原文发表时间:2018-07-14

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏mathor

LeetCode342. 4的幂

 这是上一道题2的幂的进阶,首先我们看和2的幂有什么不同。2的幂有1,2,4,8......,而4的幂有1,4,16,64,也就是说少了2,8,32......

9620
来自专栏和蔼的张星的图像处理专栏

28. 搜索二维矩阵二分法

写出一个高效的算法来搜索 m × n矩阵中的值。 这个矩阵具有以下特性: 每行中的整数从左到右是排序的。 每行的第一个数大于上一行的最后一个整数。 样例...

16020
来自专栏nummy

Uninformed search Python实现【译】

图的搜索可以分为uninformed搜索和informed搜索,两者的区别是前者是的搜索是盲目的,它不知道目标节点在哪,而后者是启发式的搜索。

12120
来自专栏数据结构与算法

17:文字排版

17:文字排版 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB描述 给一段英文短文,单词之间以空格分隔(每个单词包括其前后紧邻...

32070
来自专栏hanlp学习笔记

hanlp中的N最短路径分词

N-最短路径 是中科院分词工具NLPIR进行分词用到的一个重要算法,张华平、刘群老师在论文《基于N-最短路径方法的中文词语粗分模型》中做了比较详细的介绍。该算法...

16500
来自专栏人工智能LeadAI

Python 中argparse模块的使用

如果脚本很简单或临时使用,没有多个复杂的参数选项,可以直接利用sys.argv将脚本后的参数依次读取(读进来的默认是字符串格式)。

10240
来自专栏机器学习算法与Python学习

Numpy

Numpy Numpy是Python中用于科学计算的核心库。它提供了高性能的多维数组对象,以及相关工具。(本文文末的原文链接为numpy的官方文档) NumPy...

35070
来自专栏决胜机器学习

PHP数据结构(十一) ——图的连通性问题与最小生成树算法(2)

PHP数据结构(十一)——图的连通性问题与最小生成树算法(2) (原创内容,转载请注明来源,谢谢) 再次遇到微信公众号限制字数3000字的问题。因此将...

454100
来自专栏算法channel

Tensorflow|通过Variable及assign()感悟一点设计之道

01 Variable a = tf.Variable(2, name="scalar") # create variable a with scalar v...

2.1K70
来自专栏数据结构与算法

P1008 三连击

题目背景 本题为提交答案题,您可以写程序或手算在本机上算出答案后,直接提交答案文本,也可提交答案生成程序。 题目描述 将1,2,…,9共9个数分成三组,分别组成...

42990

扫码关注云+社区

领取腾讯云代金券