Python：Numpy的使用

最新推荐文章于 2022-05-31 13:30:27 发布

尔玉先生

最新推荐文章于 2022-05-31 13:30:27 发布

阅读量601

点赞数

分类专栏： Python 文章标签： python numpy 数据分析数据挖掘

本文链接：https://blog.csdn.net/weixin_44330955/article/details/107800736

版权

Python 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nH5Mjfnf-1596548636123)(F:\JianShu_material\Python\Numpy的使用\000.png)]$

1. Numpy的优势

1.1 Numpy的介绍

Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。

Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。

Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。

1.2 ndarray介绍

Numpy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。

import numpy as np

score = np.array([[80,89,86,67,79],
                  [78,97,89,67,81],
                  [90,94,78,67,74],
                  [91,91,90,67,69],
                  [76,87,75,67,86],
                  [70,79,84,67,84],
                  [94,92,93,67,64],
                  [86,85,83,67,80]])

print(score)

[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]

1.3 ndarray与Python原生list运算效率对比

ndarray计算的速度很快，效率高。

Numpy专门针对ndarray的操作和运算进行了设计，所以数组的存储效率和输入输出性能远优于Python中的嵌套列表，数组越大，Numpy的优势就越明显。

1.4 ndarray的优势

ndarray为什么这么快：

存储风格

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cTD4j9B0-1596548636129)(F:\JianShu_material\Python\Numpy的使用\001.png)]$

从图中我们可以看出ndarray在存储数据的时候，数据与数据的地址都是连续的，这样就给使得批量操作数组元素时速度更快。

这是因为ndarray中的所有元素的类型都是相同的，而Python列表中的元素类型是任意的，所以ndarray在存储元素时内存可以连续，而python原生lis就t只能通过寻址方式找到下一个元素。
并行化运算

Numpy支持并行化运算（向量化运算）。
底层语言

Numpy底层使用C语言编写，内部解除了GIL（全局解释器锁），其对数组的操作速度不受Python解释器的限制，效率远高于纯Python代码。

2. 认识n维数组-ndarray属性

2.1 ndarray的属性

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JSdBaobN-1596548636130)(F:\JianShu_material\Python\Numpy的使用\002.png)]$

其中最重要的是ndarray.shape和ndarray.dtype，下面来具体看看每一种方法：

import numpy as np

score = np.array([[80,89,86,67,79],
                  [78,97,89,67,81],
                  [90,94,78,67,74],
                  [91,91,90,67,69],
                  [76,87,75,67,86],
                  [70,79,84,67,84],
                  [94,92,93,67,64],
                  [86,85,83,67,80]])

# 数组的形状，使用一个元组表示：(行数, 列数)
a = score.shape
print('数组的形状:' + str(a))

# 数组的维度
b = score.ndim
print('数组的维度:' + str(b))

# 数组的元素个数
c = score.size
print('数组的元素个数:' + str(c))

# 数组的类型
d = score.dtype
print('数组的类型:' + str(d))

# 数组一个元素字节长度
e = score.itemsize
print('数组一个元素字节长度:' + str(e))

数组的形状:(8, 5)
数组的维度:2
数组的元素个数:40
数组的类型:int32
数组一个元素字节长度:4

2.2 ndarray的形状

ndarray的形状有一维数组、二维数组、三维数组…

根据嵌套情况来判断，或者使用.shape，元组中有几个数就是几维

2.3 ndarray的类型

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQZBgHGG-1596548636132)(F:\JianShu_material\Python\Numpy的使用\003.png)]$

创建adarray时可以指定数据类型

import numpy as np

score = np.array([[80,89,86,67,79],
                  [78,97,89,67,81],
                  [90,94,78,67,74],
                  [91,91,90,67,69],
                  [76,87,75,67,86],
                  [70,79,84,67,84],
                  [94,92,93,67,64],
                  [86,85,83,67,80]],
                 dtype = 'float32')

# 数组的类型
d = score.dtype
print('数组的类型:' + str(d))

# 数组一个元素字节长度
e = score.itemsize
print('数组一个元素字节长度:' + str(e))

数组的类型:float32
数组一个元素字节长度:4

3. 基本操作

3.1 生成数组的方法

生成0和1的数组

np.zeros()、np.ones()下面来具体看看：

import numpy as np

# 括号内是列表
a1 = np.zeros([2, 3])
# 括号内是元组
b1 = np.zeros((2, 3))
# 设置数组类型方法一
c1 = np.zeros(shape = [2, 3], dtype = 'int32')
# 设置数组类型方法二
d1 = np.zeros(shape = [2, 3], dtype = np.int32)

# 括号内是列表
a2 = np.ones([2, 3])
# 括号内是元组
b2 = np.ones((2, 3))
# 设置数组类型方法一
c2 = np.ones(shape = [2, 3], dtype = 'int32')
# 设置数组类型方法二
d2 = np.ones(shape = [2, 3], dtype = np.int32)

从现有数组中生成

有np.array()、方法np.asarray()、np.copy()有三种方法，下面来比较下：

import numpy as np

score = np.array([[80,89,86,67,79],
                  [78,97,89,67,81],
                  [90,94,78,67,74],
                  [91,91,90,67,69],
                  [76,87,75,67,86],
                  [70,79,84,67,84],
                  [94,92,93,67,64],
                  [86,85,83,67,80]])

# 使用方法np.array()
data1 = np.array(score)
print('修改前array：' + str(data1))

# 使用方法np.asarray()
data2 = np.asarray(score)
print('修改前asarray：' + str(data2))

# 使用方法np.copy()
data3 = np.copy(score)
print('修改前copy：' + str(data3))

score[2, 1] = 1000

print('修改后array：' + str(data1))
print('修改后asarray：' + str(data2))
print('修改后copy：' + str(data3))

修改前array：[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]
修改前asarray：[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]
修改前copy：[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]
修改后array：[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]
修改后asarray：[[  80   89   86   67   79]
 [  78   97   89   67   81]
 [  90 1000   78   67   74]
 [  91   91   90   67   69]
 [  76   87   75   67   86]
 [  70   79   84   67   84]
 [  94   92   93   67   64]
 [  86   85   83   67   80]]
修改后copy：[[80 89 86 67 79]
 [78 97 89 67 81]
 [90 94 78 67 74]
 [91 91 90 67 69]
 [76 87 75 67 86]
 [70 79 84 67 84]
 [94 92 93 67 64]
 [86 85 83 67 80]]

说明asarray是深拷贝，array和copy是浅拷贝。

生成固定范围的数组

有np.linspace(a,b,c)、np.arange(a,b,c)两种方法，下面来具体看看：

import numpy as np

# np.linspace(a,b,c)
# 代表从[a,b]等距离生成c个数
data1 = np.linspace(0, 100, 9)
print(data1)

# np.arange(a,b,c)
# 代表从[a,b)生成的数与数的距离为c
data2 = np.arange(0, 10, 2)
print(data2)

[  0.   12.5  25.   37.5  50.   62.5  75.   87.5 100. ]
[0 2 4 6 8]

生成随机数组

生成均匀分布数组

import numpy as np
import matplotlib.pyplot as plt

# 1.准备数据
# 代表均匀生成10000个从1到10之间的数
data1 = np.random.uniform(1, 10, 10000)

# 2.创建画布
plt.figure(figsize = (20, 8), dpi = 80)

# 3.绘制图像
# data代表要统计的数据
# 1000代表将将要统计的数据分为5组
plt.hist(data1, 1000)

# 4.显示图像
plt.show()

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zkbrUW3u-1596548636138)(F:\JianShu_material\Python\Numpy的使用\004.png)]$

生成正态分布数组

import numpy as np
import matplotlib.pyplot as plt

# 1.准备数据
# 代表生成均值为0，方差为1，有1000000个这样数据的列表
data1 = np.random.normal(0, 1, 1000000)

# 2.创建画布
plt.figure(figsize = (20, 8), dpi = 80)

# 3.绘制图像
# data代表要统计的数据
# 10000代表将将要统计的数据分为10000组
plt.hist(data1, 10000)

# 4.显示图像
plt.show()

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fDmFgCB3-1596548636140)(F:\JianShu_material\Python\Numpy的使用\005.png)]$

3.2 数组的索引、切片

数组进行索引和切片操作i：

一维数组

import numpy as np

# 创建一个一维数组
a = np.array([1, 2, 3, 4, 5, 6])

# 进行索引操作
print(a[0])

# 进行切片操作
# 左闭右开
print(a[0:5])

1
[1 2 3 4 5]

二维数组

import numpy as np

# 创建一个二维数组
b = np.array([[80,89,86,67,79],
             [78,100,89,67,81],
             [90,94,78,67,74],
             [94,92,93,67,64],
             [86,85,83,67,80]])

# 进行索引操作
print(b[1, 1])

# 进行切片操作
# '1'代表第二行，'0:3'代表第二行的前三个数
print(b[1, 0:3])

100
[ 78 100  89]

三维数组

import numpy as np

# 创建一个三维数组
c = np.array([[[80,89,86,67,79],
             [78,100,89,67,81],
             [90,94,78,67,74],
             [94,92,93,67,64],
             [86,85,83,67,80]]])


# 进行索引操作
print(c[0,1,1])

# 进行切片操作
print(c[0, 1, 0:3])

100
[ 78 100  89]

3.3 形状修改

有三种方法进行形状的修改：

方法一：newndarray = ndarray.reshape()
方法二：ndarry.resize()
方法三：ndarry.T

下面来进行比较：

import numpy as np

# 创建一个二维数组
a = np.array([[80,89,86,67,79],
             [78,100,89,67,81],
             [86,85,83,67,80]])

# 使用方法newndarray = ndarray.reshape()
# 有返回值，不对原有数据进行转置
new_a = a.reshape(5, 3)
print('使用reshape():' +'\n' + str(new_a))

# 使用方法ndarry.resize()
# 无返回值，对原有数据进行转置
a.resize(5,3)
print('使用resize():' +'\n' + str(a))

# 使用方法ndarry.T
# 无返回值，不对原有数据进行转置，只有在使用.T时才转置
print('使用T:' +'\n' + str(a.T))

使用reshape():
[[ 80  89  86]
 [ 67  79  78]
 [100  89  67]
 [ 81  86  85]
 [ 83  67  80]]
使用resize():
[[ 80  89  86]
 [ 67  79  78]
 [100  89  67]
 [ 81  86  85]
 [ 83  67  80]]
使用T:
[[ 80  67 100  81  83]
 [ 89  79  89  86  67]
 [ 86  78  67  85  80]]

3.4 类型修改

有两种方法进行类型的修改：

使用ndarray.astype()进行类型的修改。
使用ndarray.tostring()进行序列化，保存到本地。

下面来具体比较下：

import numpy as np

# 创建一个二维数组
a = np.array([[80,89,86,67,79],
             [78,100,89,67,81],
             [86,85,83,67,80]])

# 使用ndarray.astype()进行类型的修改
# 可以有返回值类型，不对原始数据进行修改
print(a.astype('float32'))

# 使用ndarray.tostring()进行序列化，保存到本地
print(a.tostring())

[[ 80.  89.  86.  67.  79.]
 [ 78. 100.  89.  67.  81.]
 [ 86.  85.  83.  67.  80.]]
b'P\x00\x00\x00Y\x00\x00\x00V\x00\x00\x00C\x00\x00\x00O\x00\x00\x00N\x00\x00\x00d\x00\x00\x00Y\x00\x00\x00C\x00\x00\x00Q\x00\x00\x00V\x00\x00\x00U\x00\x00\x00S\x00\x00\x00C\x00\x00\x00P\x00\x00\x00'

3.5 数组的去重

使用np.unique()方法进行数组的去重

import numpy as np

# 创建一个二维数组
a = np.array([[80,89,86,67,79],
             [78,100,89,67,81],
             [86,85,83,67,80]])

# 使用np.unique()方法进行数组的去重
# 有返回值，不对原有数据进行修改
print(np.unique(a))

[ 67  78  79  80  81  83  85  86  89 100]

4. ndarray运算

4.1 逻辑运算

主要是np.all()、np.any()、np.wherer()三个方法的使用

import numpy as np

# 生成一个8行10列的标准正态分布的二维数组
# 代表8支股票10天的涨幅情况
data = np.random.normal(loc =0, scale = 1, size = (8,10))
print('原始数据' + '\n' + str(data))

# 需求1：8支股票10天如果涨跌幅大于0.5就标记为True，否则为False
print('需求1' + '\n' + str(data > 0.5))

# 需求2：前3支股票前5天如果涨跌幅大于0.5就标记为True，否则为False
print('需求2' + '\n' + str(data[0:3, 0:5] > 0.5))

# 需求3：股票如果涨跌幅大于0.5，则标记为1，否则为0
# data[]中传递的是布尔值，不能是其他数据
data[data > 0.5] = 1
print('需求3' + '\n' + str(data))

原始数据
[[ 0.83886781  0.6069855   0.80865936 -1.16895959 -2.09760814  0.62323489
  -0.34492482 -1.60124892 -0.55024986 -0.95986343]
 [-1.54374376  0.52759955  0.87870201  2.67280895  1.067674   -1.15614495
   0.50872886  2.51069133 -0.99770796 -0.02567882]
 [ 1.09679682 -0.41084766  0.50589611 -0.92443376 -0.84711761  0.4000614
   1.2457309  -0.68819461 -0.64765538 -0.24950491]
 [ 0.13768991  0.33223589  0.19751889 -0.85598566  0.03029228  0.30495726
   1.1824456   0.82183664  1.89418781 -0.10182856]
 [-2.15338839  1.99478745  0.46251004 -0.23795407  0.19862356 -0.68163819
  -0.19186438  1.27409356  0.301477   -0.43326793]
 [-1.56409593 -0.06941236 -2.47672878 -0.59172057 -1.03028201 -0.21272101
   2.88081077  0.53148962 -0.33871506  0.68933348]
 [-2.3376821  -1.27299444 -0.16487271  1.36572759  1.24535189  0.20982072
   0.93941999  1.11054398 -2.19532362  0.5933207 ]
 [ 1.0011553  -1.35618182  0.96510902 -0.76907634  0.10349159  0.228885
  -1.65697367 -1.82298863 -0.11080476  0.38423467]]
需求1
[[ True  True  True False False  True False False False False]
 [False  True  True  True  True False  True  True False False]
 [ True False  True False False False  True False False False]
 [False False False False False False  True  True  True False]
 [False  True False False False False False  True False False]
 [False False False False False False  True  True False  True]
 [False False False  True  True False  True  True False  True]
 [ True False  True False False False False False False False]]
需求2
[[ True  True  True False False]
 [False  True  True  True  True]
 [ True False  True False False]]
需求3
[[ 1.          1.          1.         -1.16895959 -2.09760814  1.
  -0.34492482 -1.60124892 -0.55024986 -0.95986343]
 [-1.54374376  1.          1.          1.          1.         -1.15614495
   1.          1.         -0.99770796 -0.02567882]
 [ 1.         -0.41084766  1.         -0.92443376 -0.84711761  0.4000614
   1.         -0.68819461 -0.64765538 -0.24950491]
 [ 0.13768991  0.33223589  0.19751889 -0.85598566  0.03029228  0.30495726
   1.          1.          1.         -0.10182856]
 [-2.15338839  1.          0.46251004 -0.23795407  0.19862356 -0.68163819
  -0.19186438  1.          0.301477   -0.43326793]
 [-1.56409593 -0.06941236 -2.47672878 -0.59172057 -1.03028201 -0.21272101
   1.          1.         -0.33871506  1.        ]
 [-2.3376821  -1.27299444 -0.16487271  1.          1.          0.20982072
   1.          1.         -2.19532362  1.        ]
 [ 1.         -1.35618182  1.         -0.76907634  0.10349159  0.228885
  -1.65697367 -1.82298863 -0.11080476  0.38423467]]

import numpy as np

# 生成一个8行10列的标准正态分布的二维数组
# 代表8支股票10天的涨幅情况
data = np.random.normal(loc =0, scale = 1, size = (8,10))

# 需求4：判断data[0:3, 0:4]的股票是否全部大于0
# 使用函数np.all()
# 必须全部数据符合条件才返回True，否则为False
temp1 = data[0:3, 0:4]
print('需求4' + '\n' + str(np.all(temp1)))

# 需求5：判断data[0:3, 0:4]的股票是否有大于0的
# 使用函数np.any()
# 有一个数据符合条件就返回True，全部不符合则为False
temp2 = data[0:3, 0:4]
print('需求5' + '\n' + str(np.all(temp2)))

需求4
True
需求5
True

import numpy as np

# 生成一个8行10列的标准正态分布的二维数组
# 代表8支股票10天的涨幅情况
data = np.random.normal(loc =0, scale = 1, size = (8,10))

# 需求6：判断前四个股票前四天的涨跌幅大于0的置为1，否则为0
# 使用函数np.where()
temp = data[0:4, 0:4]
# where()中传递三个参数
# 第一个为判读条件
# 第二个为符合条件所进行的操作
# 第三个为不符合条件进行的操作
print('需求6' + '\n' + str(np.where(temp > 0, 1, 0)))

# 复合逻辑需结合np.logical_and和np.logical_or使用
# 需求7：判断前四个股票前四天的涨跌幅，大于0.5并且小于1的置为1，否则为0
print('需求7' + '\n' + str(np.where(np.logical_and(temp>0.5,temp<1),1,0)))

# 需求8：判断前四个股票前四天的涨跌幅，大于0.5并且小于-0.5的置为1，否则为0
print('需求8' + '\n' + str(np.where(np.logical_or(temp>0.5,temp<-0.5),1,0)))

需求6
[[0 0 0 0]
 [1 0 1 0]
 [0 0 1 0]
 [0 1 0 1]]
需求7
[[0 0 0 0]
 [0 0 1 0]
 [0 0 0 0]
 [0 0 0 1]]
需求8
[[1 0 0 1]
 [1 0 1 0]
 [0 0 1 0]
 [0 0 0 1]]

4.2 统计运算

import numpy as np

# 创建一个5行5列的标准正态分布的二维数组
# 代表5支股票5天的涨幅情况
data = np.array([[80,89,86,67,79],
                [78,100,89,67,81],
                [90,94,78,67,74],
                [94,92,93,67,64],
                [86,85,83,67,80]])

# 需求1：统计每支股票10天内的最大值
# 第一个参数为数据，第二个参数表示按照行还是列进行计算，1为行，2为列
print('最大值' + str(np.max(data, axis = 1)))

# 需求2：统计每支股票5天内的最小值
print('最小值' + str(np.min(data, axis = 1)))

# 需求3：统计每支股票5天内的平均值
print('平均值' + str(np.mean(data, axis = 1)))

# 需求4：统计每支股票5天内的中位数
print('中位数' + str(np.median(data, axis = 1)))

# 需求5：统计每支股票5天内的方差
print('方差' + str(np.var(data, axis = 1)))

# 需求6：统计每支股票5天内的标注差
print('标准差' + str(np.std(data, axis = 1)))

# 需求7：统计每支股票5天内的最大值所在的下标
print('最大值' + str(np.argmax(data, axis = 1)))
    
# 需求8：统计每支股票5天内的最小值所在的下标
print('最大值' + str(np.argmin(data, axis = 1)))

最大值[ 89 100  94  94  86]
最小值[67 67 67 64 67]
平均值[80.2 83.  80.6 82.  80.2]
中位数[80. 81. 78. 92. 83.]
方差[ 57.36 122.   100.64 182.8   47.76]
标准差[ 7.57363849 11.04536102 10.03194896 13.52035502  6.91086102]
最大值[1 1 1 0 0]
最大值[3 3 3 4 3]

4.3 数组间运算

import numpy as np

data = np.array([[1,2,3,4,5],
                 [6,7,8,9,10]])

# 使用np创建的数组可直接对其进行加减乘除
print('使用加法：' + '\n' + str(data + 1))
print('使用减法：' + '\n' + str(data - 2))
print('使用乘法：' + '\n' + str(data * 3))
print('使用除法：' + '\n' + str(data / 4))

使用加法：
[[ 2  3  4  5  6]
 [ 7  8  9 10 11]]
使用减法：
[[-1  0  1  2  3]
 [ 4  5  6  7  8]]
使用乘法：
[[ 3  6  9 12 15]
 [18 21 24 27 30]]
使用除法：
[[0.25 0.5  0.75 1.   1.25]
 [1.5  1.75 2.   2.25 2.5 ]]

数组与数组间的运算需要进行条件判断，必须满足以下其中一个条件：

总维度相同
同一维度下有1出现

如果可以进行运算，则运算后的维度为每个维度对应的最大值。

下面是可以进行运算的例子：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3CvhcvWa-1596548636142)(F:\JianShu_material\Python\Numpy的使用\006.png)]$

下面是不可以进行运算的例子：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GIIHvi6X-1596548636144)(F:\JianShu_material\Python\Numpy的使用\007.png)]$

4.4 矩阵间的运算

矩阵必须是二维的。

矩阵一定是二维数组，二维数组不一定是矩阵。

矩阵间的乘法必须满足：（m, n）*（n, l）= (m, l)，即第一个矩阵的列数与第二个矩阵的行数相等。

import numpy as np

# 数据
data = np.array([[1,2],
                 [6,7],
                 [3,6],
                 [1,1],
                 [7,8]])
# 权重
weight = np.array([[1,2],
                   [5,6]])


# 使用np.array()创建的矩阵可使用两种方法进行矩阵的乘法
# 方法一：np.matmul
print('方法一：' + '\n' + str(np.matmul(data,weight)))
# 方法二：np.dot
print('方法二：' + '\n' + str(np.dot(data,weight)))

方法一：
[[11 14]
 [41 54]
 [33 42]
 [ 6  8]
 [47 62]]
方法二：
[[11 14]
 [41 54]
 [33 42]
 [ 6  8]
 [47 62]]

5. 合并、分割

5.1 合并

import numpy as np

a = np.array([1,2,3])
b = np.array([2,3,4])
c = np.array([[1],
              [2],
              [3]])
d = np.array([[2],
              [3],
              [4]])
# 进行水平合并
print('水平合并：')
print(np.hstack((a, b)))
print(np.hstack((c, d)))

# 进行竖直合并
print('竖直合并：')
print(np.vstack((a, b)))
print(np.vstack((c, d)))

水平合并：
[1 2 3 2 3 4]
[[1 2]
 [2 3]
 [3 4]]
竖直合并：
[[1 2 3]
 [2 3 4]]
[[1]
 [2]
 [3]
 [2]
 [3]
 [4]]

import numpy as np

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

# 进行水平合并
print('水平合并：')
# 需要传递两个参数，一个为数据，一个为轴
print(np.concatenate((a, b.T), axis = 1))

print('竖直合并：')
print(np.concatenate((a, b), axis = 0))

水平合并：
[[1 2 5]
 [3 4 6]]
竖直合并：
[[1 2]
 [3 4]
 [5 6]]

##5.2 分割

分割并不常用

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O5pDMNaQ-1596548636146)(F:\JianShu_material\Python\Numpy的使用\008.png)]$

尔玉先生

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python：Numpy的使用

1. Numpy的优势1.1 Numpy的介绍Numpy（Numerical Python）是一个开源的Python科学计算库，用于快速处理任意维度的数组。Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。Numpy使用ndarray对象来处理多维数组，该对象是一个快速而灵活的大数据容器。1.2 ndarray介绍Numpy提供了一个N维数组类型ndarray，它描述了相同类型的“items”的集合。import numpy as n.
复制链接

扫一扫