|
|
相关文章推荐
|
刚失恋的回锅肉 · SQLSERVER 四舍五入 保留两位小数 ...· 1 年前 · |
|
|
鼻子大的酱牛肉 · 「牙刷存储多少天数据」相关问答|文档|产品| ...· 1 年前 · |
|
|
风流倜傥的核桃 · sqlserver查询超时已过期-掘金· 1 年前 · |
|
|
文质彬彬的咖啡豆 · 女子承包酒店留多人卖淫 ...· 1 年前 · |
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print
(
'
迭代后的数组：
'
)
for
element
in
a
.
flat
:
print
(
element
)
输出结果如下：
a = np. arange ( 16 ) . reshape ( 4 , 4 )
print ( '第一个数组：' )
print ( a )
print ( ' \n ' )
print ( '默认分割（0轴）：' )
b = np. split ( a , 2 )
print ( b )
print ( ' \n ' )
print ( '沿水平方向分割：' )
c = np. split ( a , 2 , 1 )
print ( c )
print ( ' \n ' )
print ( '沿水平方向分割：' )
d = np. hsplit ( a , 2 )
print ( d )
#0
#0
原始数组： [0 1 2] [3 4 5] [6 7 8] 迭代后的数组：numpy.ndarray.flatten
numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
ndarray.flatten(order='C')参数说明：
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。import numpy as np a = np.arange(8).reshape(2,4) print ('原数组：') print (a) print ('\n') # 默认按行 print ('展开的数组：') print (a.flatten()) print ('\n') print ('以 F 风格顺序展开的数组：') print (a.flatten(order = 'F'))输出结果如下：
[[0 1 2 3] [4 5 6 7]] 展开的数组： [0 1 2 3 4 5 6 7] 以 F 风格顺序展开的数组： [0 4 1 5 2 6 3 7]
numpy.ravel
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
该函数接收两个参数：
numpy.ravel(a, order='C')
参数说明：
order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'K' -- 元素在内存中的出现顺序。
import
numpy
as
np
a
=
np
.
arange
(
8
)
.
reshape
(
2
,
4
)
print
(
'
原数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
调用 ravel 函数之后：
'
)
print
(
a
.
ravel
(
)
)
print
(
'
\n
'
)
print
(
'
以 F 风格顺序调用 ravel 函数之后：
'
)
print
(
a
.
ravel
(
order
=
'
F
'
)
)
输出结果如下：
[[0 1 2 3] [4 5 6 7]] 调用 ravel 函数之后： [0 1 2 3 4 5 6 7] 以 F 风格顺序调用 ravel 函数之后： [0 4 1 5 2 6 3 7] # Python3.x 为 next(context) ，Python2.x 为 context.next() print ( next ( r ) , next ( c ) ) print ( next ( r ) , next ( c ) ) print ( ' \n ' ) # shape 属性返回广播对象的形状 print ( ' 广播对象的形状： ' ) print ( b . shape ) print ( ' \n ' ) # 手动使用 broadcast 将 x 与 y 相加 b = np . broadcast ( x , y ) c = np . empty ( b . shape ) print ( ' 手动使用 broadcast 将 x 与 y 相加： ' ) print ( c . shape ) print ( ' \n ' ) c . flat = [ u + v for ( u , v ) in b ] print ( ' 调用 flat 函数： ' ) print ( c ) print ( ' \n ' ) # 获得了和 NumPy 内建的广播支持相同的结果 print ( ' x 与 y 的和： ' ) print ( x + y )输出结果为：
对 y 广播 x： 广播对象的形状： (3, 3) 手动使用 broadcast 将 x 与 y 相加： (3, 3) 调用 flat 函数： [[5. 6. 7.] [6. 7. 8.] [7. 8. 9.]] x 与 y 的和： [[5 6 7] [6 7 8] [7 8 9]]
numpy.broadcast_to
numpy.broadcast_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。
numpy.broadcast_to(array, shape, subok)
import
numpy
as
np
a
=
np
.
arange
(
4
)
.
reshape
(
1
,
4
)
print
(
'
原数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
调用 broadcast_to 函数之后：
'
)
print
(
np
.
broadcast_to
(
a
,
(
4
,
4
)
)
)
输出结果为：
[[0 1 2 3]] 调用 broadcast_to 函数之后： [[0 1 2 3] [0 1 2 3] [0 1 2 3] [0 1 2 3]]numpy.expand_dims
numpy.expand_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:
numpy.expand_dims(arr, axis)
参数说明：
arr
：输入数组
axis
：新轴插入的位置
import
numpy
as
np
x
=
np
.
array
(
(
[
1
,
2
]
,
[
3
,
4
]
)
)
print
(
'
数组 x：
'
)
print
(
x
)
print
(
'
\n
'
)
y
=
np
.
expand_dims
(
x
,
axis
=
0
)
print
(
'
数组 y：
'
)
print
(
y
)
print
(
'
\n
'
)
print
(
'
数组 x 和 y 的形状：
'
)
print
(
x
.
shape
,
y
.
shape
)
print
(
'
\n
'
)
# 在位置 1 插入轴
y
=
np
.
expand_dims
(
x
,
axis
=
1
)
print
(
'
在位置 1 插入轴之后的数组 y：
'
)
print
(
y
)
print
(
'
\n
'
)
print
(
'
x.ndim 和 y.ndim：
'
)
print
(
x
.
ndim
,
y
.
ndim
)
print
(
'
\n
'
)
print
(
'
x.shape 和 y.shape：
'
)
print
(
x
.
shape
,
y
.
shape
)
输出结果为：
数组 x： [[1 2] [3 4]] 数组 y： [[[1 2] [3 4]]] 数组 x 和 y 的形状： (2, 2) (1, 2, 2) 在位置 1 插入轴之后的数组 y： [[[1 2]] [[3 4]]] x.ndim 和 y.ndim： x.shape 和 y.shape： (2, 2) (2, 1, 2)
numpy.squeeze
numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：
numpy.squeeze(arr, axis)
参数说明：
arr
：输入数组
axis
：整数或整数元组，用于选择形状中一维条目的子集
import
numpy
as
np
x
=
np
.
arange
(
9
)
.
reshape
(
1
,
3
,
3
)
print
(
'
数组 x：
'
)
print
(
x
)
print
(
'
\n
'
)
y
=
np
.
squeeze
(
x
)
print
(
'
数组 y：
'
)
print
(
y
)
print
(
'
\n
'
)
print
(
'
数组 x 和 y 的形状：
'
)
print
(
x
.
shape
,
y
.
shape
)
输出结果为：
数组 x： [[[0 1 2] [3 4 5] [6 7 8]]] 数组 y： [[0 1 2] [3 4 5] [6 7 8]] 数组 x 和 y 的形状： (1, 3, 3) (3, 3)
numpy.concatenate
numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：
numpy.concatenate((a1, a2, ...), axis)
参数说明：
a1, a2, ...
：相同类型的数组
axis
：沿着它连接数组的轴，默认为 0
import
numpy
as
np
a
=
np
.
array
(
[
[
1
,
2
]
,
[
3
,
4
]
]
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
b
=
np
.
array
(
[
[
5
,
6
]
,
[
7
,
8
]
]
)
print
(
'
第二个数组：
'
)
print
(
b
)
print
(
'
\n
'
)
# 两个数组的维度相同
print
(
'
沿轴 0 连接两个数组：
'
)
print
(
np
.
concatenate
(
(
a
,
b
)
)
)
print
(
'
\n
'
)
print
(
'
沿轴 1 连接两个数组：
'
)
print
(
np
.
concatenate
(
(
a
,
b
)
,
axis
=
1
)
)
输出结果为：
第一个数组： [[1 2] [3 4]] 第二个数组： [[5 6] [7 8]] 沿轴 0 连接两个数组： [[1 2] [3 4] [5 6] [7 8]] 沿轴 1 连接两个数组： [[1 2 5 6] [3 4 7 8]]
numpy.stack
numpy.stack 函数用于沿新轴连接数组序列，格式如下：
numpy.stack(arrays, axis)
参数说明：
arrays
相同形状的数组序列
axis
：返回数组中的轴，输入数组沿着它来堆叠
import
numpy
as
np
a
=
np
.
array
(
[
[
1
,
2
]
,
[
3
,
4
]
]
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
b
=
np
.
array
(
[
[
5
,
6
]
,
[
7
,
8
]
]
)
print
(
'
第二个数组：
'
)
print
(
b
)
print
(
'
\n
'
)
print
(
'
沿轴 0 堆叠两个数组：
'
)
print
(
np
.
stack
(
(
a
,
b
)
,
0
)
)
print
(
'
\n
'
)
print
(
'
沿轴 1 堆叠两个数组：
'
)
print
(
np
.
stack
(
(
a
,
b
)
,
1
)
)
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割：
import numpy as np
a = np. arange ( 16 ) . reshape ( 4 , 4 )
print ( '第一个数组：' )
print ( a )
print ( ' \n ' )
print ( '默认分割（0轴）：' )
b = np. split ( a , 2 )
print ( b )
print ( ' \n ' )
print ( '沿水平方向分割：' )
c = np. split ( a , 2 , 1 )
print ( c )
print ( ' \n ' )
print ( '沿水平方向分割：' )
d = np. hsplit ( a , 2 )
print ( d )
输出结果为：
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
默认分割（0轴）：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
沿水平方向分割：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
沿水平方向分割：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
numpy.hsplit
numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。
import
numpy
as
np
harr
=
np
.
floor
(
10
*
np
.
random
.
random
(
(
2
,
6
)
)
)
print
(
'
原array：
'
)
print
(
harr
)
print
(
'
拆分后：
'
)
print
(
np
.
hsplit
(
harr
,
3
)
)
输出结果为：
原array：
[[4. 7. 6. 3. 2. 6.]
[6. 3. 6. 7. 9. 7.]]
[array([[4., 7.],
[6., 3.]]), array([[6., 3.],
[6., 7.]]), array([[2., 6.],
[9., 7.]])]
numpy.vsplit
numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。
import
numpy
as
np
a
=
np
.
arange
(
16
)
.
reshape
(
4
,
4
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
竖直分割：
'
)
b
=
np
.
vsplit
(
a
,
2
)
print
(
b
)
输出结果为：
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
数组元素的添加与删除
元素及描述 [1 2 3]]numpy.append
numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。
append 函数返回的始终是一个一维数组。
numpy.append(arr, values, axis=None)
参数说明：
arr
：输入数组
values
：要向
arr
添加的值，需要和
arr
形状相同（除了要添加的轴）
axis
：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。
import
numpy
as
np
a
=
np
.
array
(
[
[
1
,
2
,
3
]
,
[
4
,
5
,
6
]
]
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
向数组添加元素：
'
)
print
(
np
.
append
(
a
,
[
7
,
8
,
9
]
)
)
print
(
'
\n
'
)
print
(
'
沿轴 0 添加元素：
'
)
print
(
np
.
append
(
a
,
[
[
7
,
8
,
9
]
]
,
axis
=
0
)
)
print
(
'
\n
'
)
print
(
'
沿轴 1 添加元素：
'
)
print
(
np
.
append
(
a
,
[
[
5
,
5
,
5
]
,
[
7
,
8
,
9
]
]
,
axis
=
1
)
)
输出结果为：
第一个数组： [[1 2 3] [4 5 6]] 向数组添加元素： [1 2 3 4 5 6 7 8 9] 沿轴 0 添加元素： [[1 2 3] [4 5 6] [7 8 9]] 沿轴 1 添加元素： [[1 2 3 5 5 5] [4 5 6 7 8 9]]
numpy.insert
numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。
如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。
numpy.insert(arr, obj, values, axis)
参数说明：
arr
：输入数组
obj
：在其之前插入值的索引
values
：要插入的值
axis
：沿着它插入的轴，如果未提供，则输入数组会被展开
import
numpy
as
np
a
=
np
.
array
(
[
[
1
,
2
]
,
[
3
,
4
]
,
[
5
,
6
]
]
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
未传递 Axis 参数。 在删除之前输入数组会被展开。
'
)
print
(
np
.
insert
(
a
,
3
,
[
11
,
12
]
)
)
print
(
'
\n
'
)
print
(
'
传递了 Axis 参数。 会广播值数组来配输入数组。
'
)
print
(
'
沿轴 0 广播：
'
)
print
(
np
.
insert
(
a
,
1
,
[
11
]
,
axis
=
0
)
)
print
(
'
\n
'
)
print
(
'
沿轴 1 广播：
'
)
print
(
np
.
insert
(
a
,
1
,
11
,
axis
=
1
)
)
输出结果如下：
第一个数组： [[1 2] [3 4] [5 6]] 未传递 Axis 参数。 在删除之前输入数组会被展开。 [ 1 2 3 11 12 4 5 6] 传递了 Axis 参数。 会广播值数组来配输入数组。 沿轴 0 广播： [[ 1 2] [11 11] [ 3 4] [ 5 6]] 沿轴 1 广播： [[ 1 11 2] [ 3 11 4] [ 5 11 6]]
numpy.delete
numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。
Numpy.delete(arr, obj, axis)
参数说明：
arr
：输入数组
obj
：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
axis
：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开
import
numpy
as
np
a
=
np
.
arange
(
12
)
.
reshape
(
3
,
4
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
未传递 Axis 参数。 在插入之前输入数组会被展开。
'
)
print
(
np
.
delete
(
a
,
5
)
)
print
(
'
\n
'
)
print
(
'
删除第二列：
'
)
print
(
np
.
delete
(
a
,
1
,
axis
=
1
)
)
print
(
'
\n
'
)
print
(
'
包含从数组中删除的替代值的切片：
'
)
a
=
np
.
array
(
[
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
]
)
print
(
np
.
delete
(
a
,
np
.
s_
[
::
2
]
)
)
输出结果为：
第一个数组： [[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] 未传递 Axis 参数。 在插入之前输入数组会被展开。 [ 0 1 2 3 4 6 7 8 9 10 11] 删除第二列： [[ 0 2 3] [ 4 6 7] [ 8 10 11]] 包含从数组中删除的替代值的切片： [ 2 4 6 8 10]
numpy.unique
numpy.unique 函数用于去除数组中的重复元素。
numpy.unique(arr, return_index, return_inverse, return_counts)
arr
：输入数组，如果不是一维数组则会展开
return_index
：如果为
true
，返回新列表元素在旧列表中的位置（下标），并以列表形式储
return_inverse
：如果为
true
，返回旧列表元素在新列表中的位置（下标），并以列表形式储
return_counts
：如果为
true
，返回去重数组中的元素在原数组中的出现次数
import
numpy
as
np
a
=
np
.
array
(
[
5
,
2
,
6
,
2
,
7
,
5
,
6
,
8
,
2
,
9
]
)
print
(
'
第一个数组：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
第一个数组的去重值：
'
)
u
=
np
.
unique
(
a
)
print
(
u
)
print
(
'
\n
'
)
print
(
'
去重数组的索引数组：
'
)
u
,
indices
=
np
.
unique
(
a
,
return_index
=
True
)
print
(
indices
)
print
(
'
\n
'
)
print
(
'
我们可以看到每个和原数组下标对应的数值：
'
)
print
(
a
)
print
(
'
\n
'
)
print
(
'
去重数组的下标：
'
)
u
,
indices
=
np
.
unique
(
a
,
return_inverse
=
True
)
print
(
u
)
print
(
'
\n
'
)
print
(
'
下标为：
'
)
print
(
indices
)
print
(
'
\n
'
)
print
(
'
使用下标重构原数组：
'
)
print
(
u
[
indices
]
)
print
(
'
\n
'
)
print
(
'
返回去重元素的重复数量：
'
)
u
,
indices
=
np
.
unique
(
a
,
return_counts
=
True
)
print
(
u
)
print
(
indices
)
(2, 3, 2)
(array([0]), array([0]), array([1]))
敛裳
2年前 (2021-05-24)
敛裳
262***3547@qq.com
L
193***9483@qq.om
闫伟超
yif***chaoran@163.com
推荐文章
|
|
风流倜傥的核桃 · sqlserver查询超时已过期-掘金 1 年前 |