Numpy：数组（Ndarray）操作之数组连接

最新推荐文章于 2024-04-11 22:40:14 发布
最新推荐文章于 2024-04-11 22:40:14 发布
阅读量5.2k 收藏 13
点赞数 6
分类专栏： Numpy 文章标签： python 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shield911/article/details/124421666
版权

文章目录

连接数组

Numpy中数组连接的方法很多，但是各有特点，本文将对各种方法做详细的解释和示例演示。

方法列表

方法说明
numpy.concatenate()沿现有轴连接一系列数组。
numpy.stack()沿新轴加入一系列数组。
numpy.vstack()垂直（按行）按顺序堆叠数组。
numpy.hstack()水平顺序堆叠数组（按列）。
numpy.dstack()按顺序深度（沿第三轴）堆叠数组。
numpy.column_stack()将一维数组作为列堆叠到二维数组中。
numpy.row_stack()垂直（按行）按顺序堆叠数组。

方法详解

numpy.concatenate()

沿现有轴连接一系列数组。

numpy.concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting="same_kind")

参数说明：

  • a1, a2, …：具有相同形状的数组构成的序列，维度默认为第一个数组的维度，其他数组的维度需要与默认相应。
  • axis：接收整数，默认为0（行）。如果axis为None，数组会被延展。
  • out：ndarray，如果提供，合并后的数组将会替换目标数组，目标数组的形状必须与合并后的数组形状相同。
  • dtype：接收字符串或者dtype，设置结果数组的数据类型。
  • casting：可选{no, equiv, safe, same_kind, unsafe}，控制可能发生的数据类型转换。

返回值：

  • ndarray：合并后的数组。

示例：

>>> import numpy as np

>>> arr01 = np.arange(1, 25).reshape(4,6)
>>> arr02 = np.ones(shape=(4,6))
>>> arr03 = np.zeros(shape=(8,6))
# 横向连接arr01,arr02, axis=0,列数必须相同，将结果替换arr03
# arr03的形状必须和合并后的数组形状一样，才能使用out参数
>>> np.concatenate((arr01, arr02), axis=0, out=arr03)
>>> arr03
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.],
       [ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.]])

# 纵向连接arr01, arr02, axis=1,行数必须相同
>>> np.concatenate((arr01, arr02), axis=1) 
array([[ 1.,  2.,  3.,  4.,  5.,  6.,  1.,  1.,  1.,  1.,  1.,  1.],
       [ 7.,  8.,  9., 10., 11., 12.,  1.,  1.,  1.,  1.,  1.,  1.],
       [13., 14., 15., 16., 17., 18.,  1.,  1.,  1.,  1.,  1.,  1.],
       [19., 20., 21., 22., 23., 24.,  1.,  1.,  1.,  1.,  1.,  1.]])

numpy.stack()

沿新轴加入一系列数组，数组堆叠，堆叠后产生的数组比原数组高一个维度。

numpy.stack(arrays, axis=0, out=None)

参数说明：

  • array：具有相同形状的数组构成的序列。
  • axis：接收int，轴向，沿该轴堆叠，默认为0。
  • out：ndarray，如果提供，合并后的数组将会替换目标数组，目标数组的形状必须与合并后的数组形状相同。

返回值：

  • ndarray：堆叠后的数组比原数组高一个维度。

示例：

>>> import numpy as np

>>> arr01 = np.arange(1, 25).reshape(4,6)
>>> arr01
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]])
>>> arr02 = np.ones(shape=(4,6))
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])

axis=0

>>>  np.stack((arr01, arr02), axis=0)
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.]],

       [[ 1.,  1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.,  1.,  1.]]])

axis=1

>>>  np.stack((arr01, arr02), axis=1)
array([[[ 1.,  2.,  3.,  4.,  5.,  6.],
        [ 1.,  1.,  1.,  1.,  1.,  1.]],

       [[ 7.,  8.,  9., 10., 11., 12.],
        [ 1.,  1.,  1.,  1.,  1.,  1.]],

       [[13., 14., 15., 16., 17., 18.],
        [ 1.,  1.,  1.,  1.,  1.,  1.]],

       [[19., 20., 21., 22., 23., 24.],
        [ 1.,  1.,  1.,  1.,  1.,  1.]]])

axis=2

>>>  np.stack((arr01, arr02), axis=2)
array([[[ 1.,  1.],
        [ 2.,  1.],
        [ 3.,  1.],
        [ 4.,  1.],
        [ 5.,  1.],
        [ 6.,  1.]],

       [[ 7.,  1.],
        [ 8.,  1.],
        [ 9.,  1.],
        [10.,  1.],
        [11.,  1.],
        [12.,  1.]],

       [[13.,  1.],
        [14.,  1.],
        [15.,  1.],
        [16.,  1.],
        [17.,  1.],
        [18.,  1.]],

       [[19.,  1.],
        [20.,  1.],
        [21.,  1.],
        [22.,  1.],
        [23.,  1.],
        [24.,  1.]]])

numpy.vstack()

按行（垂直）堆叠数组。

numpy.vstack(tup)

参数说明：

  • tup：数组组成的序列，数组必须在列方向具有相同的形状。一维数组必须具有相同的长度。

返回值：

  • ndarray：堆叠的数组。

示例：

>>> arr01 = np.arange(1, 25).reshape(4,6)
>>> arr01
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]])
       
>>> arr04 = np.ones(shape=(2, 6)) 
>>> arr04
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])

# 按行（垂直）堆叠数组, 堆叠后的数组维度不会增加
>>> np.vstack((arr01, arr04))
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.],
       [ 1.,  1.,  1.,  1.,  1.,  1.],
       [ 1.,  1.,  1.,  1.,  1.,  1.]])

numpy.hstack()

按列（水平）顺序堆叠数组。

numpy.hstack(tup)

参数说明：

  • tup：数组组成的序列。数组必须在行方向具有相同的形状。

返回值：

  • ndarray：堆叠的后的数组。

示例：

>>> arr01 = np.arange(1, 25).reshape(4,6)
>>> arr01
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]])
>>> arr05 = np.zeros(shape=(4,2))
array([[0., 0.],
       [0., 0.],
       [0., 0.],
       [0., 0.]])
       
# 按列（水平）顺序堆叠数组, 行数必须相同
>>> np.hstack((arr01, arr03))   
array([[ 1.,  2.,  3.,  4.,  5.,  6.,  0.,  0.],
       [ 7.,  8.,  9., 10., 11., 12.,  0.,  0.],
       [13., 14., 15., 16., 17., 18.,  0.,  0.],
       [19., 20., 21., 22., 23., 24.,  0.,  0.]])

numpy.dstack()

按深度堆叠数组。

numpy.dstack(tup)

参数说明：

  • tup：数组组成的序列。

返回值：

  • ndarray，堆叠的数组。

示例：

>>> arr01 = np.arange(1, 25).reshape(4,6)
>>> arr01
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]])
>>> arr02 = np.ones(shape=(4,6))
array([[1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1., 1.]])
>>> np.dstack((arr01, arr02))
array([[[ 1.,  1.],
        [ 2.,  1.],
        [ 3.,  1.],
        [ 4.,  1.],
        [ 5.,  1.],
        [ 6.,  1.]],

       [[ 7.,  1.],
        [ 8.,  1.],
        [ 9.,  1.],
        [10.,  1.],
        [11.,  1.],
        [12.,  1.]],

       [[13.,  1.],
        [14.,  1.],
        [15.,  1.],
        [16.,  1.],
        [17.,  1.],
        [18.,  1.]],

       [[19.,  1.],
        [20.,  1.],
        [21.,  1.],
        [22.,  1.],
        [23.,  1.],py
        [24.,  1.]]])

numpy.column_stack()

将一维数组作为列堆叠到二维数组中。

numpy.column_stack(tup)

参数说明：

  • tup：一维数组或二维数组构成的序列。

返回值：

  • ndarray：堆叠后的二维数组。

示例：

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],
       [2, 3],
       [3, 4]])

numpy.row_stack()

按行（垂直）堆叠数组

numpy.row_stack(tup)

参数说明：

  • tup：数组构成的序列。

返回值：

  • ndarray：堆叠后的数组，至少是二维。

示例：

>>> a = np.array([1,2,3,4,5,6]).reshape(3,2)
>>> a
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> b = np.array([7,8,9,10,11,12]).reshape(3,2)
>>> b
array([[ 7,  8],
       [ 9, 10],
       [11, 12]])
>>> np.vstack((a,b))
array([[ 1,  2],
       [ 3,  4],
       [ 5,  6],
       [ 7,  8],
       [ 9, 10],
       [11, 12]])
Mr李小四
关注
  • 6
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 数组的连接
03-20
将两个数组连接在一起，很简单的一个例子。
Python NumPy 连接数组
weixin_64338372的博客
01-14 3132
NumPy（Numerical Python的缩写）是一个开源的Python科学计算库。使用NumPy，就可以很自然地使用数组和矩阵。NumPy包含很多实用的数学函数，涵盖线性代数运算、傅里叶变换和随机数生成等功能。本文主要介绍Python NumPy 连接数组(array)
numpy学习笔记（3），数组连接
最新发布
车前猛跑
04-11 974
1. 连接数组，2. 分割数组， 3.算术运算， 4.广播
【Numpy】连接数组
Graduate2015的博客
06-22 1542
文章目录前言1. concatenate2. stack3. block4. vstack5. hstack6. dstack7. column_stack8. row_stackReference 前言 本篇总结、介绍Numpy数组（ndarray）的基本操作之一——连接数组 [1]。 1. concatenate numpy.concatenate((a1, a2, …), axis=0, out=None, dtype=None, casting=“same_kind”)：沿现有的轴连接一系列数组
数组连接
weixin_30511039的博客
11-21 171
1.一个数组里的元素连接起来 作为新手，我只会最简单的，慢慢积累吧。 方法一：定义新数组，循环读出。 1 <!doctype html> 2 <html> 3 <head> 4 <meta http-equiv="Content-Type" content="text/html charset=utf-8" ...
numpy-连接数组
qq_14815199的博客
10-22 503
函数 描述 concatenate 连接沿现有轴的数组序列 stack 沿着新的轴加入一系列数组。 hstack 水平堆叠序列中的数组（列方向） vstack 竖直堆叠序列中的数组（行方向） 1.使用concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下： numpy.concatenate((a1, a2, ...), axis) 参数说明： a1, a2, ...：相同类型的数组 axis：沿着它连接数组的轴，默认为 0
numpy数组连接方法
黄佳俊的博客
06-03 2217
1、np.concatenate() np.concatenate()用于相同维度数组的合并 2、np.vstack() np.vstack()在处理混合维度的数组时效果比较好。（行连接） 3、np.hstack() np.hstack()在处理混合维度的数组时效果比较好。（列连接） ...
NumPy基础：多维数组
02-24
NumPy（NumericalPython的基础）是高性能科学计算和数据分析的...它接受一切序列型的对象（包括其他数组），然后产生一个新的含有传入数据的NumPy数组。列表的转换：嵌套序列（比如由一组等长列表组成的列表）将会被
numpy中实现ndarray数组返回符合特定条件的索引方法
09-20
下面小编就为大家分享一篇numpy中实现ndarray数组返回符合特定条件的索引方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python Numpy 数组的初始化和基本操作
12-23
Python 是一种高级的，动态的，多泛型的编程语言。Python代码很多时候看起来...ndarray.dtype：数组中元素的类型（numpy.int32, numpy.int16, and numpy.float64等） ndarray.itemsize：每个元素占几个字节 例子： >
Python numpy多维数组实现原理详解
12-20
NumPy它本身其实没有提供很高级别的数据分析功能，NumPy之于数值计算特别重要的原因之一，就是因为它能够高效的处理大数组的数据。这是因为： 1.NumPy是在一个连续的内存块中存储数据，独立于其他的
Python之Numpy数组拼接--组合--连接--切分--变形(stack,hstack,vstack,dstack,vsplit,concatenate等)
家有代码初写成 的博客
12-08 2318
Python之Numpy数组拼接，组合，连接 转自：https://www.douban.com/note/518335786/?type=like stack()，hstack()，vstack() dstack()  vsplit()、concatenate()参考（推荐）： https://blog.csdn.net/csdn15698845876/article/details/73...
numpy数组拼接方法介绍
热门推荐
zyl1042635242的专栏
01-26 29万+
数组拼接方法一 思路：首先将数组转成列表，然后利用列表的拼接函数append()、extend()等进行拼接处理，最后将列表转成数组。 示例1： >>> import numpy as np >>> a=np.array([1,2,5]) >>> b=np.array([10,12,15]) >>> a_list=list(a) >>> b_list=list(b) >>> a_l
【Python语言基础】——Python NumPy 数组连接
玄链教育
02-19 1218
我们传递了一系列要与轴一起连接到 concatenate() 函数的数组。我们传递了一系列要与轴一起连接到 concatenate() 方法的数组。我们可以沿着第二个轴连接两个一维数组，这将导致它们彼此重叠，即，堆叠（stacking）。NumPy 提供了一个辅助函数：dstack() 沿高度堆叠，该高度与深度相同。在 SQL 中，我们基于键来连接表，而在 NumPy 中，我们按轴连接数组。NumPy 提供了一个辅助函数：hstack() 沿行堆叠。连接意味着将两个或多个数组的内容放在单个数组中。
C# 数组增加元素_JavaScript中数组的简单使用
weixin_39796878的博客
11-20 280
JavaScript数组这种数据类型可以在一个变量里保存多个值，每个值都有一个数值的索引，而且能够保存任何数据类型，比如布尔值、数值、字符串、对象，甚至是其它数组也可以。创建新数组创建数组的语法并不新奇，在C#里面是 ：int[] array = new int[20];而JavaScript是：var myArray = new Array();当然，创建数组还可以使用另外一种方便的形式：var...
数组的两种连接方式
王会长的博客
05-11 7820
数组的两种连接方式#include&lt;cstdio&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; class Node { public: int **data; int hang; int lie; Node() { data=NULL; } Node(int h,int l) { hang=h; lie...
numpy实现全连接
weixin_38730719的博客
08-05 240
全连接层可以看作是矩阵乘法。 class Liner(): def __init__(self,in_features,out_features,bias=0): self.in_features =in_features self.out_features = out_features self.weight = np.zeros((in_features,out_features)) self.bias = np.zeros
链接数组的四种方法（把两个数组链接成一个数组）
gplihf的博客
08-18 1万+
首先定义两个数组，这边以int数组为例 int[] arrayList={9,5,3,2,0,4}; int[] arrayList2={1,6,8,7}; 方法一、ArrayUtils.addAll()方法，引入包：org.apache.commons.lang3.ArrayUtils; int[] tempArrayList = ArrayUtils.addAll(arrayList,
Numpy数组结合/合并/连接操作
wllzhk的博客
10-14 4427
常用数组结合/合并/连接函数： numpy.concatenate numpy.stack numpy.append 搭配函数： numpy.resize 注意各个函数对输入的尺寸约束，常常需要先用resize调整数组结构，再使用合适的函数连接数组 numpy.concatenate numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组 实例 import numpy as np a = np.array([[1,2],[3,4]]) print ('第一个数组：
掌握NumPy数组对象ndarray
04-05
NumPy（Numerical Python）是一个Python包，它是由一个多维数组对象和用于处理数组的函数组成的。NumPy数组对象ndarray是NumPy的核心。 ndarray是一个n维数组对象，它具有以下特点： 1. 所有元素必须是相同类型的，通常是数值类型（整数、浮点数、复数等）。 2. 维度（即轴的个数）称为数组的秩（rank）。 3. 数组的形状（shape）是一个表示各个轴上元素个数的元组。 4. 数组的大小（size）是指数组中所有元素的总数。 5. 数组的数据类型（dtype）描述了数组中元素的类型。 ndarray可以通过多种方式创建： 1. 从Python列表或元组创建。 2. 使用NumPy的内置函数（如arange和linspace）创建。 3. 从文件中读取数据。 4. 从其他数据类型（如Pandas DataFrame）转换而来。 ndarray提供了许多方法和属性，可以对数组进行各种操作，如索引、切片、重塑、转置、排序、聚合等。 以下是一个简单的例子，展示如何创建一个ndarray并对其进行操作： ```python import numpy as np # 从列表创建ndarray my_list = [1, 2, 3, 4, 5] my_array = np.array(my_list) # 输出数组的形状和大小 print(my_array.shape) print(my_array.size) # 对数组进行切片操作 print(my_array[1:3]) # 对数组进行重塑操作 my_reshaped_array = my_array.reshape((5, 1)) print(my_reshaped_array) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值