Numpy库速通教程典藏版 #一篇就够了系列

---

1.11 生成随机数组

---

①rand()方法

语法

np.random.rand(d0,d1,d2,d3,d4,…,dn)

randn()函数可以用于生成随机数或者随即数组。当不传入参数时，生成一个随机数。当传入参数时，则生成指定shape的随即数组。

• 数据的范围为[0, 1)

指定shape时不要求元组形式。参数个数不限制。这一点是区别于np.random.random()方法。

print(“生成一个随机数”)

n1 = np.random.rand()

print(n1)

print(type(n1))

print(“==============================”)

print(“生成一个一维随机数”)

n2 = np.random.rand(3)

print(n2)

print(type(n2))

print(“==============================”)

print(“生成一个二维随机数”)

n3 = np.random.rand(2, 3)

print(n3)

print(type(n3))

② random()方法

random()的用法及作用于rand相似，只是需要传入的参数是一个元组。

生成数据的范围也是[0, 1)

print(“生成一个随机数”)

print(np.random.random())

print(“==============================”)

print(“生成一个一维随机数”)

print(np.random.random(5))

print(“==============================”)

print(“生成一个二维随机数”)

print(np.random.random((3, 5)))

③randint()方法

randint()方法可以用于生成有一定范围的随机整数。

• 语法

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

• low 起始值 整数

• high 终止值 整数 应满足 low < high 否则会报错

• [low, high) 左闭右开，可取左，不可取右。

• size 整数或描述shape的元组。整数表示一维。

print(np.random.randint(0, 100, 5))

print(“==============================”)

print(np.random.randint(0, 100, (4, 4)))

④randn()方法

通过randn()方法可以得到满足标准正态分布的数组

X X X~ （ 0 , 1 ） （0, 1） （0,1）

语法

randn(d0,d1,d2,d3,…,dn)

参数形式同rand()，不是元组。表示shape。

print(“生成一个标准正态分布下的数字，这样没啥意义”)

print(np.random.randn())

print(“=====================================”)

print(“生成一个一维数组”)

print(np.random.randn(8))

print(“=====================================”)

print(“生成一个二维数组”)

print(np.random.randn(2, 3))

print(“=====================================”)

print(“生成一个三维数组”)

print(np.random.randn(2, 3, 4))

数组的数据越多，才越能体现其分布特点。

⑤normal()方法

normal()方法也可以用于生成正态分布数组，且不限于标准正态分布，可以自定义分布参数。

语法

np.random.normal(loc=0.0, scale=1.0, size=None)

• loc 均值

• scale 标准差

• size，即shape，或维度。要求是一个元组或一个数字。

默认生成数据满足标准正态分布。

print(“生成一个标准正态分布下的数字，这样没啥意义”)

print(np.random.normal())

print(“=====================================”)

print(“生成一个一维数组,均值为5标准差为10，元素个数为10”)

print(np.random.normal(5, 10, 10))

print(“=====================================”)

print(“生成一个二维数组，均值为4，标准差为5，shape为(4, 5)”)

print(np.random.normal(4, 5, (4, 5)))

print(“=====================================”)

print(“生成一个三维数组，均值为2，标准差为4，shape为(2, 3, 4)”)

print(np.random.normal(2, 4, (2, 3, 4)))

⑥随机数种子 seed()

有的情况下，为了保证得到一致的随机数，需要用到随机数种子

即给np.random.seed()传入一个大于等于0的整数

不管是在同一台电脑上多次允许，还是在不同的电脑上执行程序，只要随机数种子设置相同，则就可以保证得到相同的随机数。

写法示例：

np.random.seed(1)

print(np.random.randint(100, 200, (4, 4)))

⑦随机排序

• 对数组随机排序可以使用shuffle() 和 permutation() 两个方法。

• 区别在于shuffle()方法直接修改的是原数组，而permutation()不影响原数组。

• 两个方法均只有一个参数，为一个数组。

• 对数组对象中1数据随机排序

• 随机排序时，仅对数组最外层的维度排序，即axis=0。就是说，以shape为(5,6,7,8,9)的数组为例，随机排序打乱的是元素个数为“5”这个维度的5个对象。五个对象自身内部结构不会被改变。

• 此外，随机数种子固定的时候，随机排序的效果也是固定的。

代码示例 shuffle() ：

np.random.seed(1)

n = np.random.randint(100, 200, (4, 4))

print(n)

print(“==随机排序=”)

np.random.shuffle(n)

print(n)

---

代码示例 permutation() ：

np.random.seed(2)

n = np.random.randint(100, 200, (4, 4))

print(n)

print(“==随机排序=”)

print(np.random.permutation(n))

print(“原数组不改变”)

print(n)

⑧随机抽取 choice()方法

语法

numpy.random.choice(a, size=None, replace=True, p=None)

• a 一个列表 或者 一个数组，表示要从中抽样的对象。

也可以是一个正整数，是正整数的话则表示从[0, a)的整数中随机抽取 。

• size 即shape，元组。也可以是一个数字，表示一维数组。

• replace 是否有放回。默认为True是有放回的抽取。

• p 抽取到的概率。默认为None，表示所有元素抽取到的概率相等。也可以是一个数组，是数组的话，该数组的shape应与参数a数组的shape相同。该数组中的每个元素对应着数组a中相同位置的每个元素被抽取到的概率。

np.random.seed(3)

print(“从[0,100)中随机抽取一个整数”)

print(np.random.choice(100, 5))

data = [11, 22, 33, 44, 55, 66, 77, 88, 99, 100]

print(“从data中随机抽取一个数字”)

print(np.random.choice(data))

print(“=====================================”)

print(“随机抽取3个数字，构成三个元素的一维数组”)

print(np.random.choice(data, 3))

print(“=====================================”)

print(“随机抽取数组构成一个二维数组”)

print(np.random.choice(data, (2, 3)))

print(“随机抽取数组构成一个二维数组，无放回的抽取”)

print(np.random.choice(data, (2, 3), replace=False))

---

1.12从已有数组中创建数组

---

①asarray()方法

asarray()方法与array()函数类似，差别不大。这里了解即可。

asarray(a,dtype=None,order=None)

• a可以是数组，也可以是列表、元组等对象。而且是列表元组等时，可以支持一直套娃，套多少层，创建出来的维度就有多高。

a = np.asarray([1, 2, 3])

print(a)

print(“=================================”)

b = np.asarray([[1, 2, 3], [4, 5, 6]])

print(b)

print(“=================================”)

c = np.asarray(((1, 2), (3, 4)))

print©

print(“=================================”)

d = np.asarray((((1, 2), (3, 4)), ((5, 6), (7, 8))))

print(d)

print(“=================================”)

e = np.asarray(a)

print(e)

---

②formbuffer()方法

用formbuffer()方法创建数组，该方法的特点及优势在于，该方法接收字节流形式的参数。

语法

np.frombuffer(buffer, dtype=None, count=-1, offset=0)

• buffer指实现了__buffer__方法的对象。当buffer参数值为字符串时，因为python3默认字符串是Unicode类型，所以要转换成Byte string类型，需要在原字符串前加上b。

• dtype 即数据类型，默认为浮点型。

• count 读取数据的数量，默认值-1表示读取所有数据。

• offset 读取的起始位置，默认从0位置开始。

通过以下一系列示例，快速理解其用法。

n1 = np.frombuffer(b"12345678987654321", dtype=‘S1’)

print(n1)

print(“=================================”)

n2 = np.frombuffer(b"1234567887654321", dtype=‘S2’)

print(n2)

print(“=================================”)

n3 = np.frombuffer(b"1234567887654321", dtype=‘S4’)

print(n3)

print(“=================================”)

n4 = np.frombuffer(b"abcdefghijklmnop", dtype=‘S4’)

print(n4)

print(“=================================”)

n5 = np.frombuffer(b"abcdefghijklmnop") # 转浮点型了

print(n5)

print(n5.dtype)

---

③fromiter()方法

fromiter()方法可用于从可迭代对象(iterable) 中创建数组。

创建一个生成器

a1 = (x * 3 for x in range(6))

print(a1)

通过生成器这个可迭代对象创建数组

a2 = np.fromiter(a1, dtype=‘int’)

print(a2)

数据较多时这种方法比较高效。可以实现快速将生成器中的大量数据导入数组中。

a3 = np.fromiter((2, 5, 6, 8, 5, 2), dtype=‘int’)

print(a3)

a4 = np.fromiter([2, 5, 6, 8, 5, 2], dtype=‘int’)

print(a4)

• 需要注意的一点是，使用fromiter()方法时，传入的可迭代对象不能是 有嵌套其他可迭代对象 的可迭代对象。fromiter()方法不支持套娃。

---

④empty_like()方法

创建一个与给定数组相同shape的未初始化的数组

语法

empty_like(prototype, dtype=None, order=None, subok=None, shape=None)

n = np.arange(1, 7).reshape(2, 3)

print(n)

print(“===============================”)

a = np.empty_like(n)

print(a)

---

⑤zeros_like()方法

创建一个与给定数组相同shape的全零数组

语法

zeros_like(a, dtype=None, order=‘K’, subok=True, shape=None)

n = np.arange(1, 7).reshape(2, 3)

print(n)

print(“===============================”)

a = np.zeros_like(n)

print(a)

---

⑥ones_like()方法

创建一个与给定数组相同shape的 全一数组

语法

ones_like(a, dtype=None, order=‘K’, subok=True, shape=None)

n = np.arange(1, 7).reshape(2, 3)

print(n)

print(“===============================”)

a = np.ones_like(n)

print(a)

---

⑦fulls_like()方法

创建一个与给定数组相同shape的指定值填充的数组

语法

full_like(a, fill_value, dtype=None, order=‘K’, subok=True, shape=None)

n = np.arange(1, 7).reshape(2, 3)

print(n)

print(“===============================”)

a = np.full_like(n, 100)

print(a)

---

2. numpy数组 数据类型

======================================================================================

2.1 关于默认值（要求高时不建议使用）

---

通过上述方法创建数组时，上边的示例中并未指定数据类型。

通过上边的示例可以看到，不指定数据类型创建数组时，如果不是根据一个传入的 具体的有数组接口方法对象来创建，则创建出的数组的数值类型默认为浮点型。其中，除了使用arange()且各个数字刚好是整数时，是个例外，得到的数组的数据类型为整数型（回顾一下上文的arange即可理解，因为arange方法与array()里边放一个 list(range(n)) 是类似的。)

关于创建数组时数据类型默认具体是怎么样的（int32, int64, float32, float64…），我现在所了解的资源中说法有很多，有的说是跟个人的操作系统有关，有的认为是保存对象所需的最小类型。目前我不清楚哪一种是对的，不过可以确定的是，我们最好在创建数组的时候，我们通常不采用默认值，最好自己指定，这样就不会产生因为数据类型带来的问题了。（如有观点或其他答案欢迎在评论区补充。）

对类型的位数有需求时，不建议使用常规的时int,float,unit指定，而后边不跟数字，也不建议使用默认值。最好自己手动指定到位。

---

2.2 数组数据类型表

---

常用的基本数据类型如下表所示：

| 类型 | 类型代码/简写 | 描述 |

| — | — | — |

| int8,uint8 | i1,u1 | 有符号和无符号的8数位整数（-128_127）（0255） |

| int16,uint16 | i2,u2 | 有符号和无符号的16数位整数（-32768_32767）（065535） |

| int32,uint32 | i4,u4 | 有符号和无符号的32数位整数（-2147483648_{2147483647）（0}4294967295） |

| int64,uint64 | i8,u8 | 有符号和无符号的64数位整数（-9223372036854775808_{9223372036854775807）（0}18446744073709551615） |

| float16 | f2 | 半精度浮点数：1个符号位，5位指数，10位尾数 |

| float32 | f4 | 标准单精度浮点数：1个符号位，8位指数，23位尾数 |

| float64 | f8 | 标准双精度浮点数：1个符号位，11位指数，52位尾数 |

| bool | ------------ | 存储一个字节的布尔值，存储True或False。（也可写为bool_） |

| complex64 | ------------ | 复数，由两个32位浮点表示（实部和虚部） |

| complex128 | 简写：complex_ | 复数，由两个64位浮点表示（实部和虚部） |

| datatime64 | ------------ | 日期和事件类型 |

| timedelta | ------------ | 两个时间类型的间隔 |

| string_ | S | ASCII字符串类型（即字节类型），eg：‘S10’ |

| unicode_ | U | Unicode类型（python3的默认字符串是Unicode类型），eg：‘U10’ |

其中unit16表示16位无符号整数，unit32表示32位无符号整数。

其中，复数不能转化为其他数值类型。

几种变换，简单了解。

print(np.int32(12.56), type(np.int32(12.56)))

print(np.float64(13), type(np.float64(13)))

print(np.complex128(1+2j), type(np.complex(1+2j)))

print(np.unicode(‘20’), type(np.unicode(‘20’)))

---

2.3 指定数据类型详解

---

根据上表，创建数组时，指定数据类型，可以使用类型的全名，也可以使用类型代码。

使用array()，zeros()，ones()，empty()，arange()，linspace()，logspace()，eye()等方法创建数组时都可以通过dtype参数指定数据类型。dtype默认为None。

下边通过一些调用示例，来完成这个部分的学习。

2.3.1 整数与浮点数

---

a1 = np.array([1.23, 2.34, 3.45, 4.56], dtype=int)

print(a1)

print(a1.dtype)

---

a2 = np.arange(0, 10, 2, dtype=‘int’)

print(a2)

print(a2.dtype)

（不同：a1中传入的是关键字int，a2中传入的是字符串int。达到的效果一样。）

---

a3 = np.linspace(100, 200, 11, dtype=‘int64’)

print(a3)

print(a3.dtype)

---

a4 = np.logspace(0, 10, 11, base=2, dtype=‘int32’)

print(a4)

print(a4.dtype)

---

a5 = np.empty([2, 3], dtype=‘i8’)

print(a5)

print(a5.dtype)

---

a6 = np.ones(10, dtype=‘i4’)

print(a6)

print(a6.dtype)

---

a7 = np.zeros(10, dtype=‘f4’)

print(a7)

print(a7.dtype)


print(a8)

print(a8.dtype)

---

2.3.2 字节类型

a9 = np.full((3, 4), ‘99.0’, dtype=‘S’)

print(a9)

print(a9.dtype)

a10 = np.full((3, 4), ‘99.0’, dtype=‘S2’)

print(a10)

print(a10.dtype)

a11 = np.full((3, 4), ‘aaaaaaaaaaa’, dtype=‘|S5’)

print(a11)

print(a11.dtype)

如图，数据类型分别是，一个字节，二个字节，五个字节。

直接指定为"S"表示S1，也可以在S前加一个竖杠"|’ 符号，这个符号可有可无。

---

如果传入汉字，则无法转化为字节，则发生报错。

a11 = np.full((3, 4), ‘侯小啾’, dtype=‘S5’)

print(a11)

print(a11.dtype)

报错。

---

2.3.3 字符串类型

python3的默认字符串是Unicode类型。

a12 = np.full((3, 4), ‘99.0’)

print(a12)

print(a12.dtype)

a13 = np.full((3, 4), 99.0, dtype=‘U1’)

print(a13)

print(a13.dtype)

a14 = np.full((3, 4), 99.0, dtype=‘<U3’)

print(a14)

print(a14.dtype)

a15 = np.full((3, 4), 99.0, dtype=‘U9’)

print(a15)

print(a15.dtype)

不指定时，则为数据中心字符串的长度的字符串类型，这里为U4，也可以写为<U4。

---

字符长度长短不一时，数组的数据类型由数据中最长的字符串所决定。

a16 = np.array([[‘a’, ‘aa’, ‘aaa’], [‘aaaa’, ‘aaaaa’, ‘aaaaaa’]])

print(a16)

print(a16.dtype)

---

支持汉字，这里一个汉字记为一个长度。

a17 = np.array([‘侯小啾’, ‘支持小啾’, ‘关注他！’, ‘给他四连！’])

print(a17)

print(a17.dtype)

最长的字符是“给他四连！”，长度为5，所以数组的数据类型为"<U5"

---

3. 数组的属性 与 操作

====================================================================================

3.1 数组的属性

---

为了方便快速查看数组的属性，特定义以下函数，务必带走方便在学习及编程过程中随时调用。

def print_array(name, a):

print(name)

print(a)

print('rank = ', a.ndim) # 秩，即有几个轴，几维

print('shape = ', a.shape) # 形状

print('size = ', a.size) # 数据个数

print('data type = ', a.dtype) # 数据类型

print('element size = ', a.itemsize) # 每个元素占的字节数

print('data location = ', a.data) # 数据存储的位置

print()

n = np.array([[1, 2, 3], [4, 5, 6]])

print_array(“数组n：”, n)

---

3.2 数组的重塑

---

---

3.2.1 reshape()与resize()

对数据的结果进行重塑可以使用reshape() 或 resize()方法。

这两种方法的区别在于使用reshape()不修改原数组，而resize()是对原数组进行修改。

• 关于reshape

新建一个一维数组

a1 = np.arange(30)

print(a1)

print(“=====================”)

一维变二维

a2 = a1.reshape((5, 6))

print(a2)

print(“=====================”)

一维变三维

a3 = a1.reshape((2, 3, 5))

print(a3)

print(“=====================”)

三维变一维

a4 = a3.reshape((30,))

print(a4)

print(“=====================”)

三维变二维

a5 = a3.reshape((5, 6))

print(a5)

---

• 关于resize()

a1 = np.arange(30)

print(a1)

print(“=====================”)

一维变二维

a1.resize((5, 6))

print(a1)

如图，用法resize()用法与reshape()一致，只是resize()直接修改了原数组a1。具体根据实践过程合理选择使用。

---

• 修改shape时，shape的每个数字相乘必须等于数组元素的个数，否则会报错。

---

3.2.2flatten() 与 ravel()

使用flatten()和ravel()方法，可以直接将数组从多维变为一维。

a6 = a3.flatten()

print(a6)

---

a7 = a3.ravel()

print(a7)

fallen()与ravel()的区别在于，fallen()得到的新数组与原数组不共享存储，即为copy过来的，所以修改a3.fallen()时不会影响a3。而ravel()得到的新数组与原数组共享存储，修改a3.ravel()时，a3会被同步修改。

---

3.3 数组转置

---

n1 = np.arange(12).reshape(3, 4)

print(n1)

print(n1.shape)

print(“=====================”)

n2 = n1.T

print(n2)

print(n2.shape)

3.4 数组的索引与切片

---

3.4.1 索引

---

①一维数组为例

首先创建一个一维数组

a1 = np.arange(10)

print(a1)

取出该数组第一个数值 和 最后一个数值

print(a1[0])

print(a1[-1])

---

②二维数组为例

创建一个二维数组

a2 = np.arange(12).reshape(3, 4)

print(a2)

取出第一“行” 和 最后一“行”（这里说“行”只能用于二维数组，在更高维的数组是不准确的，不能说是行，而需要理解为是 在其所有维度中，序号为第一层的维度，或者说是最外层的维度 处的坐标。计数从0计起。）：

print(a2[0])

print(a2[-1])

• 取出指定位置处的元素

print(a2[1][2])

print(a2[1, 2])

③三维数组为例（高维）

（关于三维及其以上的高维数组，使用为描述趋于）

a3 = np.arange(30).reshape((2, 3, 5))

print(a3)

取出其最外层维度下的第一个对象：

print(a3[0])

再剥一层：

print(a3[0][1])

再剥一层：

print(a3[0][1][2])

一个括号的写法：

print(a3[0, 1, 2])

**重点，易混淆点！如果想要取出多个值（不用切片），则可以在括号内嵌套括号。

如下列代码，值得注意的是，这样取出的不是四个值，而是两个值。

不是在第二次取出1,2后，再分别在1,2两个行中取出2和3。而是取出的是(0,1,2)和(0,2,3)。**

print(a3[0, [1, 2], [2, 3]])

（这一点在学习了DataFrame的操作后后如果理解得不够透彻则容易弄混淆。）

---

3.4.2 切片

①一维数组为例

首先创建一个一维数组

a1 = np.arange(10)

print(a1)

print(a1[2:5])

• 还是一如既往的左闭右开。

---

②二维数组为例

创建一个二维数组

a2 = np.arange(30).reshape(5, 6)

print(a2)

print(a2[2:4, 1:3])

一种不太常用的用法可以了解一下，

start:stop 后边可以再接一个冒号和数值，该数值表示step，步长。

步长通常为正。

如果想要倒序取值，则需要满足start>stop，然后把步长设置为负值。（只把步长设为负值的话会得到一个空数组。）

a1 = np.arange(10)

print(a1[2:7])

print(a1[2:9:2])

print(a1[9:2:-1])

print(a1[9:2:-2])

③三维数组为例（高维）

a3 = np.arange(120).reshape(4, 5, 6)

print(a3)

print(a3[0:2, 1:3, 2:5])

---

3.4.3 布尔索引

n1 = np.arange(30).reshape(5, 6)

print(n1)

print(n1 > 10)

print(“======================================”)

print((n1 > 10) & (n1 < 20))

print(“======================================”)

print(n1[n1 > 10])

print(“======================================”)

print(n1[(n1 > 10) & (n1 < 20)])

print(“======================================”)

print(n1[(n1 < 10) | (n1 > 20)])

使用布尔索引，不管原数组是几维，取出的数据存放在一个一维数组中。

4. 数组运算

==============================================================================

准备两个数组的数据，两个数组的shape必须相同，才能进行加减乘除运算

n1 = np.arange(1, 7).reshape(2, 3)

n2 = np.arange(7, 13).reshape(2, 3)

n3 = np.arange(4, 7).reshape(1, 3)

n4 = np.arange(5, 7).reshape(2, 1)

print(n1)

print(“-------------------------------”)

print(n2)

print(“-------------------------------”)

print(n3)

print(“-------------------------------”)

print(n4)

4.1 加、减、乘、除 & 幂运算

---

数据具有广播机制

其规则为：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符或其中一方的长度为1，则认为他们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。

这里的后缘维度，即指的是二维数组中的行和列这两个维度，在更高维数组中则指0轴和1轴的两个维度。在进行加减乘除幂等运算时，广播机制将发挥作用，

这一点可以分为以下几种情况来理解：

• 两个shape相同的数组之间进行运算，

则广播机制不启用，数组中相同位置的数据一一对应进行运算。

• 两个shape不同的数组a、b之间运算，如果数组b的0轴或1轴的长度为1，且长度为1的轴经过一定的倍数扩展后可以满足两个数组的shape相同，则广播机制启用，该长度为1的维度扩展到与数组a 在该维度的长度相等再进行运算。

具体可以分为以下几种情况：

例如，

一个4行5列的数组，可以与与一个1行5列的数组运算，运算时将次1行复制为4行；

也可以与一个5行1列的数组进行运算，运算时将该1列复制为5列。

但是不可以与一个4行2列、2行5列的数组进行运算。

也不可以与一个3行1列的数组，或者一个1行6列的数组进行运算。

再例如，一个1行8列的数组，可以和一个7行1列的数组进行运算，因为1行可以广播为7行，1列也可以广播为8列，经过广播后两数组之间的运算就相当于两个7行8列的数组之间的运算。

• 一个数组与常数之间的运算，也是广播机制在起作用。该常数分别与该数组中的每个元素运算。

具体见下方示例演示：

---

• 加法

print(n1+n2)

---

读代码体会广播机制

print(n1+n3)

---

读代码体会广播机制

print(n1+n4)

---

读代码体会广播机制

行、列都不相同的两个数组，但是只要后缘轴存在长度为1的，就嫩运算：

print(n3+n4)

---

• 减法

print(n2-n1)

---

• 乘法

print(n1*n2)

• 除法

print(n2/n1)

---

• 幂运算

print(n2**n1)

---

4.2 比较运算

---

比较运算，即可以得到能够作为布尔索引的条件的数组。

print(n2 > n1)

print(“-------------------------------”)

print(n1 <= n2)

print(“-------------------------------”)

print(n1 != n2)

print(“-------------------------------”)

print(n1 == n2)

---

4.3 标量运算

---

print(n1 + 2)

print(“-------------------------------”)

print(n1 - 2)

print(“-------------------------------”)

print(n1 * 2)

print(“-------------------------------”)

print(n1 / 2)

print(“-------------------------------”)

print(n1 ** 2)

---

5. 数组增、删、改、查

===================================================================================

5.1 数组的增加（也称扩展、拼接）

---

5.1.1 hstack()方法 与 vstack()方法

对于二维数组，可以按照水平方向增加数据，也可以按照垂直方向增加。

水平方向上的二维数组合并可以使用hstack()方法

垂直方向上的二维数组合并可以使用vstack()方法

首先创建两个二维数组

n1 = np.arange(1, 7).reshape((2, 3))

n2 = np.arange(7, 13).reshape((2, 3))

---

• hstack()方法

print(n1)

print(“=================================”)

print(n2)

print(“=================================”)

print(np.hstack((n1, n2)))

---

• vstack()方法

print(n1)

print(“=================================”)

print(n2)

print(“=================================”)

print(np.vstack((n1, n2)))

• 需要注意的是，注意这里括号的数量。hstack()函数 和 vstack()函数 需要传入的参数都是一个由数组构成元组，而不是两个数组。

---

在二维数组中，也许hstack()函数 和 vstack()比较常用，但是对于更高维度的数组之间，hstack()方法 与 vstack()方法则显得有些能力有限。它又是怎么执行的呢？

下边先准备一组三维数组合并的示例，然后对其进行解读。

• hstack()

n1 = np.arange(1, 25).reshape((2, 3, 4))

n2 = np.arange(26, 50).reshape((2, 3, 4))

print(n1)

print(“=================================”)

print(n2)

print(“=================================”)

print(np.hstack((n1, n2)))

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

简历模板

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python爬虫全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：python）

3c7.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5L6v5bCP5ZW-,size_17,color_FFFFFF,t_70,g_se,x_16)

---

• vstack()方法

print(n1)

print(“=================================”)

print(n2)

print(“=================================”)

print(np.vstack((n1, n2)))

• 需要注意的是，注意这里括号的数量。hstack()函数 和 vstack()函数 需要传入的参数都是一个由数组构成元组，而不是两个数组。

---

在二维数组中，也许hstack()函数 和 vstack()比较常用，但是对于更高维度的数组之间，hstack()方法 与 vstack()方法则显得有些能力有限。它又是怎么执行的呢？

下边先准备一组三维数组合并的示例，然后对其进行解读。

• hstack()

n1 = np.arange(1, 25).reshape((2, 3, 4))

n2 = np.arange(26, 50).reshape((2, 3, 4))

print(n1)

print(“=================================”)

print(n2)

print(“=================================”)

print(np.hstack((n1, n2)))

一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照下面的知识点去找对应的学习资源，保证自己学得较为全面。

二、Python必备开发工具

工具都帮大家整理好了，安装就可直接上手！

三、最新Python学习笔记

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。

四、Python视频合集

观看全面零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

五、实战案例

纸上得来终觉浅，要学会跟着视频一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

六、面试宝典

简历模板

小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python爬虫全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频

如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注：python）
[外链图片转存中…(img-j2K9CpIJ-1710869436387)]