个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
24
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章关于Numpy之repeat、tile的用法总结由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
numpy.repeat(a, repeats, axis=none)：若axis=none，对于多维数组而言，可以将多维数组变化为一维数组，然后再根据repeats参数扩充数组元素；若axis=m，表示数组在轴m上扩充数组元素.
|
1
2
3
4
5
6
7
8
|
in
[
1
]:
import
numpy as np
in
[
2
]: arr
=
np.arange(
12
).reshape(
1
,
4
,
3
)
in
[
3
]: arr
out[
3
]:
array([[[
0
,
1
,
2
],
[
3
,
4
,
5
],
[
6
,
7
,
8
],
[
9
,
10
,
11
]]])
|
①repeats为整数n，axis=none：数组arr首先被扁平化，然后将数组arr中的各个元素 依次重复n次 。
|
1
2
3
4
|
in
[
4
]: arr.repeat(
2
)
out[
4
]:
array([
0
,
0
,
1
,
1
,
2
,
2
,
3
,
3
,
4
,
4
,
5
,
5
,
6
,
6
,
7
,
7
,
8
,
8
,
9
,
9
,
10
,
10
,
11
,
11
])
|
②repeats为整数数组rp_arr，axis=none：数组arr首先被扁平化，然后再将数组arr中元素依次重复对应rp_arr数组中元素对应次数。若rp_arr为一个值的一维数组，则数组arr中各个元素重复相同次数，否则rp_arr数组长度必须和数组arr的长度相等，否则报错 。
a：rp_arr为单值一维数组，进行广播 。
|
1
2
3
4
|
in
[
5
]: arr.repeat([
2
])
out[
5
]:
array([
0
,
0
,
1
,
1
,
2
,
2
,
3
,
3
,
4
,
4
,
5
,
5
,
6
,
6
,
7
,
7
,
8
,
8
,
9
,
9
,
10
,
10
,
11
,
11
])
|
b：rp_arr长度小于数组arr长度，无法进行广播，报错 。
in [6]: arr.repeat([2,3,4]) --------------------------------------------------------------------------- valueerror traceback (most recent call last) <ipython-input-6-d3b52907284c> in <module>() ----> 1 arr.repeat([2,3,4]) valueerror: operands could not be broadcast together with shape (12,) (3,) 。
c：rp_arr长度和数组arr长度相等 。
|
1
2
3
4
5
6
|
in
[
7
]: arr.repeat(np.arange(
12
))
out[
7
]:
array([
1
,
2
,
2
,
3
,
3
,
3
,
4
,
4
,
4
,
4
,
5
,
5
,
5
,
5
,
5
,
6
,
6
,
6
,
6
,
6
,
6
,
7
,
7
,
7
,
7
,
7
,
7
,
7
,
8
,
8
,
8
,
8
,
8
,
8
,
8
,
8
,
9
,
9
,
9
,
9
,
9
,
9
,
9
,
9
,
9
,
10
,
10
,
10
,
10
,
10
,
10
,
10
,
10
,
10
,
10
,
11
,
11
,
11
,
11
,
11
,
11
,
11
,
11
,
11
,
11
,
11
])
|
d：rp_arr长度大于数组arr长度，也无法广播，报错 。
in [8]: arr.repeat(np.arange(13)) --------------------------------------------------------------------------- valueerror traceback (most recent call last) <ipython-input-8-ec8454224d1b> in <module>() ----> 1 arr.repeat(np.arange(13)) valueerror: operands could not be broadcast together with shape (12,) (13,) 。
结论：两个数组满足广播的条件是两个数组的后缘维度(即从末尾开始算起的维度)的轴长度相等或其中一方的长度为1 。
③repeats为整数n，axis=m：数组arr的轴m上的每个元素重复n次，m=-1代表最后一条轴 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
in
[
9
]: arr.repeat(
2
,axis
=
0
)
out[
9
]:
array([[[
0
,
1
,
2
],
[
3
,
4
,
5
],
[
6
,
7
,
8
],
[
9
,
10
,
11
]],
[[
0
,
1
,
2
],
[
3
,
4
,
5
],
[
6
,
7
,
8
],
[
9
,
10
,
11
]]])
in
[
12
]: arr.repeat(
2
,axis
=
-
1
)
#arr.repeat(2,axis=-1)等同于arr.repeat(2,axis=2)
out[
12
]:
array([[[
0
,
0
,
1
,
1
,
2
,
2
],
[
3
,
3
,
4
,
4
,
5
,
5
],
[
6
,
6
,
7
,
7
,
8
,
8
],
[
9
,
9
,
10
,
10
,
11
,
11
]]])
|
④repeats为整数数组rp_arr，axis=m：把数组arr1轴m上的元素依次重复对应rp_arr数组中元素对应次数。若rp_arr为一个值的一维数组，则数组arr1轴m上的各个元素重复相同次数，否则rp_arr数组长度必须和数组arr1轴m的长度相等，否则报错 。
a：rp_arr长度和数组arr1轴m上长度相等 。
在轴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
|
in
[
13
]: arr1
=
np.arange(
24
).reshape(
4
,
2
,
3
)
in
[
14
]: arr1
out[
14
]:
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
]]])
in
[
15
]: arr1.repeat((
1
,
2
,
3
,
4
),axis
=
0
)
out[
15
]:
array([[[
0
,
1
,
2
],
[
3
,
4
,
5
]],
[[
6
,
7
,
8
],
[
9
,
10
,
11
]],
[[
6
,
7
,
8
],
[
9
,
10
,
11
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]]])
|
在轴1上扩充数组元素 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
in
[
19
]: arr1.repeat([
1
,
2
],axis
=
1
)
out[
19
]:
array([[[
0
,
1
,
2
],
[
3
,
4
,
5
],
[
3
,
4
,
5
]],
[[
6
,
7
,
8
],
[
9
,
10
,
11
],
[
9
,
10
,
11
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
],
[
15
,
16
,
17
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
],
[
21
,
22
,
23
]]])
|
b：rp_arr为单值数组时，进行广播 。
|
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
|
in
[
20
]: arr1.repeat([
2
],axis
=
0
)
out[
20
]:
array([[[
0
,
1
,
2
],
[
3
,
4
,
5
]],
[[
0
,
1
,
2
],
[
3
,
4
,
5
]],
[[
6
,
7
,
8
],
[
9
,
10
,
11
]],
[[
6
,
7
,
8
],
[
9
,
10
,
11
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
]],
[[
12
,
13
,
14
],
[
15
,
16
,
17
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]],
[[
18
,
19
,
20
],
[
21
,
22
,
23
]]])
|
c：rp_arr和数组arr1某轴不满足广播条件，则报错 。
in [21]: arr1.repeat((1,2,3),axis=0) --------------------------------------------------------------------------- valueerror traceback (most recent call last) <ipython-input-21-8ae4dc97e410> in <module>() ----> 1 arr1.repeat((1,2,3),axis=0) valueerror: operands could not be broadcast together with shape (4,) (3,) 。
numpy.tile(a, reps):根据reps中元素扩充数组a中对应轴上的元素 。
①reps为整数n：可以把整数n理解成含一个元素n的序列reps,若数组.ndim大于reps序列的长度，则需在reps序列的索引为0的位置开始添加元素1，直到reps的长度和数组的维度数相等，然后数组各轴上的元素依次重复reps序列中元素对应的次数 。
对于一维数组而言：是整体数组重复n次，从数组的最后一位置开始重复，注意与repeat函数的区别 。
|
1
2
3
4
5
|
in
[
26
]: arr3
=
np.arange(
4
)
in
[
27
]: arr3
out[
27
]: array([
0
,
1
,
2
,
3
])
in
[
28
]: np.tile(arr3,
2
)
out[
28
]: array([
0
,
1
,
2
,
3
,
0
,
1
,
2
,
3
])
|
对多维数组而言：arr2.ndim=3,，reps=[2,]，可以看出数组的长度大于序列reps的长度，因此需要向reps中添加元素，变成reps=[1,1,2]，然后arr2数组再根据reps中的元素重复其对应轴上的元素，reps=[1,1,2]代表数组arr2在轴0上各个元素重复1次，在轴1上的各个元素重复1次，在轴1上的各个元素重复2次 。
|
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
|
in
[
29
]: arr2
=
np.arange(
24
).reshape(
4
,
2
,
3
)
in
[
30
]: arr2
out[
30
]:
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
]]])
in
[
31
]: np.tile(arr2,
2
)
out[
31
]:
array([[[
0
,
1
,
2
,
0
,
1
,
2
],
[
3
,
4
,
5
,
3
,
4
,
5
]],
[[
6
,
7
,
8
,
6
,
7
,
8
],
[
9
,
10
,
11
,
9
,
10
,
11
]],
[[
12
,
13
,
14
,
12
,
13
,
14
],
[
15
,
16
,
17
,
15
,
16
,
17
]],
[[
18
,
19
,
20
,
18
,
19
,
20
],
[
21
,
22
,
23
,
21
,
22
,
23
]]])
|
②reps为整数序列rp_arr：若数组.ndim大于rp_arr长度，方法同①相同，若数组ndim小于rp_arr长度，则需在数组的首缘维添加新轴，直到数组的维度数和rp_arr长度相等，然后数组各轴上的元素依次重复reps序列中元素对应的次数 。
a：数组维度大于rp_arr长度：需rp_arr提升为(1,2,3) 。
|
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
|
in
[
33
]: arr2
=
np.arange(
24
).reshape(
4
,
2
,
3
)
in
[
34
]: arr2
out[
34
]:
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
]]])
in
[
35
]: np.tile(arr2,(
2
,
3
))
out[
35
]:
array([[[
0
,
1
,
2
,
0
,
1
,
2
,
0
,
1
,
2
],
[
3
,
4
,
5
,
3
,
4
,
5
,
3
,
4
,
5
],
[
0
,
1
,
2
,
0
,
1
,
2
,
0
,
1
,
2
],
[
3
,
4
,
5
,
3
,
4
,
5
,
3
,
4
,
5
]],
[[
6
,
7
,
8
,
6
,
7
,
8
,
6
,
7
,
8
],
[
9
,
10
,
11
,
9
,
10
,
11
,
9
,
10
,
11
],
[
6
,
7
,
8
,
6
,
7
,
8
,
6
,
7
,
8
],
[
9
,
10
,
11
,
9
,
10
,
11
,
9
,
10
,
11
]],
[[
12
,
13
,
14
,
12
,
13
,
14
,
12
,
13
,
14
],
[
15
,
16
,
17
,
15
,
16
,
17
,
15
,
16
,
17
],
[
12
,
13
,
14
,
12
,
13
,
14
,
12
,
13
,
14
],
[
15
,
16
,
17
,
15
,
16
,
17
,
15
,
16
,
17
]],
[[
18
,
19
,
20
,
18
,
19
,
20
,
18
,
19
,
20
],
[
21
,
22
,
23
,
21
,
22
,
23
,
21
,
22
,
23
],
[
18
,
19
,
20
,
18
,
19
,
20
,
18
,
19
,
20
],
[
21
,
22
,
23
,
21
,
22
,
23
,
21
,
22
,
23
]]])
|
b：数组的维度小于rp_arr的长度：需在数组的首缘维度新增加一条轴，使其shape变为(1,4,2,3) 。
|
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
|
in
[
36
]: np.tile(arr2,(
2
,
1
,
1
,
3
))
out[
36
]:
array([[[[
0
,
1
,
2
,
0
,
1
,
2
,
0
,
1
,
2
],
[
3
,
4
,
5
,
3
,
4
,
5
,
3
,
4
,
5
]],
[[
6
,
7
,
8
,
6
,
7
,
8
,
6
,
7
,
8
],
[
9
,
10
,
11
,
9
,
10
,
11
,
9
,
10
,
11
]],
[[
12
,
13
,
14
,
12
,
13
,
14
,
12
,
13
,
14
],
[
15
,
16
,
17
,
15
,
16
,
17
,
15
,
16
,
17
]],
[[
18
,
19
,
20
,
18
,
19
,
20
,
18
,
19
,
20
],
[
21
,
22
,
23
,
21
,
22
,
23
,
21
,
22
,
23
]]],
[[[
0
,
1
,
2
,
0
,
1
,
2
,
0
,
1
,
2
],
[
3
,
4
,
5
,
3
,
4
,
5
,
3
,
4
,
5
]],
[[
6
,
7
,
8
,
6
,
7
,
8
,
6
,
7
,
8
],
[
9
,
10
,
11
,
9
,
10
,
11
,
9
,
10
,
11
]],
[[
12
,
13
,
14
,
12
,
13
,
14
,
12
,
13
,
14
],
[
15
,
16
,
17
,
15
,
16
,
17
,
15
,
16
,
17
]],
[[
18
,
19
,
20
,
18
,
19
,
20
,
18
,
19
,
20
],
[
21
,
22
,
23
,
21
,
22
,
23
,
21
,
22
,
23
]]]])
|
repeat和tile都可以用来复制数组的，但是有一些区别 。
关键区别在于repeat是对于元素的复制，tile是以整个数组为单位的 ，repeat复制时元素依次复制，注意不要用错，区别类似于[1,1,2,2]和[1,2,1,2] 。
用法 。
|
1
|
np.repeat(a, repeats, axis
=
none)
|
重复复制数组a的元素，元素的定义与axis有关，axis不指定时，数组会被展开进行复制，每个元素就是一个值，指定axis时，就是aixis指定维度上的一个元素 。
|
1
2
|
a
=
np.array([[
1
,
2
],
[
3
,
4
]])
|
不指定axis，默认none，这时候数组会被展开成1维，再进行复制 。
|
1
|
np.repeat(a,
2
)
# 所有元素依次复制相同的次数
|
参数是列表 。
|
1
|
np.repeat(a, [
1
,
2
,
1
,
2
])
# 如果第二个参数是列表，列表长度必须和a的复制可选元素数目相等，这里都是4
|
指定时，就是指定了复制元素沿的维度,这时候就不会把数组展平，会维持原来的维度数 。
|
1
|
np.repeat(a,
2
, axi
=
0
)
# 所有沿着0维的元素依次复制相同的次数
|
|
1
|
np.repeat(a, [
1
,
2
], axis
=
1
)
# 第二个参数是列表，列表长度必须和a的复制可选元素数目相等，这里是2
|
结果如下，复制元素从第1维度算，可以看到第一列被复制了一次，第二列被复制了两次 。
用法 。
|
1
|
np.tile(a, repeats)
|
复制数组，repeats可以是整数或者元组、数组 。
示例如下，它会将数组复制两份，并且在最后一维将两个元素叠加在一起，数组的维数不变，最后一维根据复制次数加倍 。
如果列表长度是1，和整数时相同.
列表长度不为1时，列表从后向前看，最后一项是2，所以复制两个数组，在最后一维进行叠加，倒数第二项是3，将前步的结果进行复制，并在倒数第二维，结果如下 。
当列表的长度超过数组的维数时，和前面类似，从后向前复制，复制结果会增加维度与列表的维数匹配，结果如下，在上面的基础上，增加了一维 。
复制结果的shape 。
但是对于 简单的单个数组重复，个人更喜欢使用stack和concatenate将同一个数组堆叠起来 。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我.
原文链接：https://blog.csdn.net/kancy110/article/details/70980127 。
最后此篇关于关于Numpy之repeat、tile的用法总结的文章就讲到这里了,如果你想了解更多关于关于Numpy之repeat、tile的用法总结的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
24
4
0
1、定义 设 \(u\) 和 \(v\) 为一张图上的任意两个节点。令 \(c(u, v)\) 为它们之间的边的容量， \(f(u, v)\) 为它们之间的流量，则需要满足以
1、前言 工作中涉及到文件系统，有时候需要判断文件和目录是否存在。我结合apue第四章文件和目录，总结一下如何正确判断文件和目录是否存在，方便以后查询。 2、stat系列函数 stat函数用来
并查集(Union-Find Set)： 一种用于管理分组的数据结构。它具备两个操作：(1)查询元素a和元素b是否为同一组 (2) 将元素a和b合并为同一组。 注意：并查集不能将在同一组的元素拆
当下，注解非常流行，以前很长篇的代码，现在基本上一个注解就能搞定。 那，在Mybatis中又有哪些注解呢？ Mybatis中的注解基本上都在org.apache.ibatis.annotat
指针操作数组，方法一是p+index，方法二是p[index]，第二种方法跟数组访问方法是一样的。 数组引用返回的是数组的第一个元素的指针地址。 可以将指针指向数组的任意元素，然后从那里开始访问
通常部署完php环境后会进行一些安全设置，除了熟悉各种php漏洞外，还可以通过配置php.ini来加固PHP的运行环境，PHP官方也曾经多次修改php.ini的默认设置。 下面对php.ini中一
在JavaScript中，使用typeof可以检测基本数据类型，使用instanceof可以检测引用数据类型。在PHP中，也有检测数据类型的方法，具体如下： 1、输出变量的数据类型（gettype
把图片缓存到本地，在很多场景都会用到，如果只是存储文件信息，那建一个plist文件，或者数据库就能很方便的解决问题，但是如果存储图片到沙盒就没那么方便了。这里简单介绍两种保存图片到沙盒的方法。
（1）需要安装docker容器，在docker容器内安装jenkins，gogs，tomcat。 新建maven项目，添加findbugs plugin。 使用docker
今天主题是实现并发服务器，实现方法有多种版本，先从简单的单进程代码实现到多进程，多线程的实现，最终引入一些高级模块来实现并发TCP服务器。 说到TCP，想起吐槽大会有个段子提到三次握手，也只有程序
如下所示： Ctrl+1或F2快速修复 Ctrl+D快捷删除行 Shift+Enter 快速切换到下一行，在本行的任何位置都可 Ctrl+F11快速运行代码 Alt+上下键 快速移动行（可
JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。 JSP编译后是”类servlet”。 Servlet和JSP最主要的不同点在于，Servlet的应用逻辑
Java中的Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor在这里对这些关键
读取Java文件到byte数组的三种方法(总结) ? 1
用java实现的数组创建二叉树以及递归先序遍历，递归中序遍历，递归后序遍历，非递归前序遍历，非递归中序遍历，非递归后序遍历，深度优先遍历，广度优先遍历8种遍历方式：
1、简明总结 ASCII(char) 返回字符的ASCII码值 BIT_LENGTH(str) 返回字符串的比特长度 CONCAT(s1,s2…,sn)
java应用服务器(web server)，是指运行java程序的web应用服务器软件，不包括nginx、Apache等通用web服务器软件。 一、Tomcat Tomcat是Apache 软件基
事务作为抽象层，允许应用忽略DB 内部一些复杂并发问题和某些硬件、软件故障，简化应用层的处理逻辑：事务中止（transaction abort），而应用仅需重试。对复杂访问模式，事务可大大减少需要考虑
我们在本教程学习了如何描述 XML 文档的结构 我们学习到了如何使用 DTD 来定义一个 XML 文档的合法元素，以及如何在我们的 XML 内部或者作为一个外部引用来声明 DTD 我们学习了如何为
在这个XPath 基础教程中我们讲解了如何在 XML 文档中查找信息 我们可以使用 XPath 的元素和属性在 XML 文档中进行导航 我们也学习了如何使用 XPath 中内建的某些标准函数 如
我是一名优秀的程序员,十分优秀！