【python】数值分析——NumPy基础_ary = np.array([1, 2, 3, 4, 5, 6])

NumPy基础

中文教程：https://www.numpy.org.cn/

import numpy as np
1
'
运行
运行

NumPy优势

快、简洁

a = list(range(int(10e6)))
%time a2 = [i*2 for i in a]
#CPU times: total: 938 ms
#Wall time: 953 ms

na = np.array(range(int(10e6)))
%time na2 = na * 2
#CPU times: total: 15.6 ms
#Wall time: 13.7 ms
1
2
3
4
5
6
7
8
9

创建ndarray数组

1.np.array([])

a = np.array([1, 2, 3, 4, 5, 6])
print(a)	#[1 2 3 4 5 6]
print(type(a))	#<class 'numpy.ndarray'>
1
2
3

2.np.arange(起始值,终止值(不包括),步长)

a = np.arange(0, 5, 1)
print(a)	#[0 1 2 3 4]
1
2

3.np.zeros(数组元素个数, dtype=‘类型’)

a = np.zeros(10)
print(a)	#[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
1
2

4.np.ones(数组元素个数, dtype=‘类型’)

a = np.ones(10,dtype='int32')
print(a)	#[1 1 1 1 1 1 1 1 1 1]

b = np.ones((2,3)) == 1
print(b)
#[[ True  True  True]
# [ True  True  True]]
1
2
3
4
5
6
7

5.np.zeros_like(类数组)、np.ones_like(类数组)

a = np.arange(10).reshape(2, 5)
print(a)
b = np.ones_like(a)
print(b)
c = np.zeros_like(a)
print(c)
1
2
3
4
5
6

[[0 1 2 3 4]
 [5 6 7 8 9]]
[[1 1 1 1 1]
 [1 1 1 1 1]]
[[0 0 0 0 0]
 [0 0 0 0 0]]
1
2
3
4
5
6

6.随机数组

np.random.rand()：生成指定维度的随机浮点数数组

np.random.randint()：生成指定范围内整数的随机数组

rand_arr = np.random.rand(5)
print(rand_arr)
#[0.10091553 0.00264582 0.63294674 0.77381868 0.63492247]

rand_arr = np.random.rand(3, 2)		#生成一个形状为 (3, 2) 的二维随机浮点数数组
print(rand_arr)
"""
[[0.50965476 0.70277161]
 [0.88303003 0.796933  ]
 [0.85627475 0.07505982]]
 """

rand_num = np.random.randint(10)
print(rand_num)		# 输出: 5

rand_arr = np.random.randint(1, 10, size=5)
print(rand_arr)		# 输出: [6 2 9 6 5]

rand_arr = np.random.randint(1, 10, size=(3, 2))
print(rand_arr)
# 输出:
# [[8 1]
#  [2 7]
#  [4 1]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

ndarray数组属性

#一维数组
ary = np.array([1, 2, 3, 4, 5, 6])
print(type(ary))	#<class 'numpy.ndarray'>
print(ary.shape)	#(6,)
print(ary.ndim)		#1
print(ary.size)		#6
print(ary.dtype)	#int32
print(ary.itemsize)	#4
print(ary.data)		#<memory at 0x000001688890DA80>

#二维数组
ary1 = np.array([
    [1,2,3,4],
    [5,6,7,8]
])
print(type(ary1))	#<class 'numpy.ndarray'>
print(ary1.shape)	#(2, 4)
print(ary1.ndim)	#2
print(ary1.size)	#8
print(ary1.dtype)	#int32
print(ary1.itemsize)	#4
print(ary1.data)	#<memory at 0x0000020ABD071FF0>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

数组维度操作

reshape() 与 ravel()：视图变维（数据共享）

a = np.arange(1, 9)
print(a)	# [1 2 3 4 5 6 7 8]

b = a.reshape(2, 4)    #变为2行4列的二维数组
print(b)
#[[1 2 3 4]
# [5 6 7 8]]

c = b.reshape(2, 2, 2) #变为2页2行2列的三维数组
print(c)
"""[[[1 2]
  [3 4]]

 [[5 6]
  [7 8]]]"""

d = c.ravel()          #变为1维数组
print(d)	#[1 2 3 4 5 6 7 8]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

flatten()：复制变维（数据独立）

a = np.arange(1, 9)
print(a)        # [1 2 3 4 5 6 7 8]

b = a.flatten()
a += 10
print(a)	#[11 12 13 14 15 16 17 18]
print(b)	#[1 2 3 4 5 6 7 8]
1
2
3
4
5
6
7

shape()、resize()：直接变维（直接改变原数组的维度）

a = np.arange(1, 9)
print(a)        # [1 2 3 4 5 6 7 8]

a.reshape(2,4)
print(a)	# [1 2 3 4 5 6 7 8]

a.shape = (2, 4)
print(a)
"""[[1 2 3 4]
 [5 6 7 8]]"""

a.resize(4,2)
print(a)
"""[[1 2]
 [3 4]
 [5 6]
 [7 8]]"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

数组索引

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

print(a.shape)	#(2, 2, 2)
print(a[0])
"""[[1 2]
 [3 4]]"""
print(a[0][0])	#[1 2]
print(a[0][0][0])	#1
print(a[1, 1, 1])	#8	数组对象[页号, 行号, 列号]

#打印
for i in range(a.shape[0]):
    for j in range(a.shape[1]):
        for k in range(a.shape[2]):
            print(a[i, j, k])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

数组切片

数组对象[起始位置:终止位置:步长]

步长+：默认切从首到尾

步长-：默认切从尾到首

a = np.arange(1, 10)

print(a[:3])  #[1 2 3]
print(a[::-1])  #[9 8 7 6 5 4 3 2 1]
print(a[:-4:-1])  #[9 8 7]
1
2
3
4
5

多维数组切片

a = np.arange(1, 28)
a.resize(3,3,3)
print(a)
#切出1页
print(a[1, :, :])
#切出所有页的1行
print(a[:, 1, :])
#切出0页的所有行的0列
print(a[0, :, 0])
1
2
3
4
5
6
7
8
9

[[[ 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]]]
#切出1页 
[[10 11 12]
 [13 14 15]
 [16 17 18]]
#切出所有页的1行
[[ 4  5  6]
 [13 14 15]
 [22 23 24]]
#切出0页的所有行的0列
[1 4 7]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

数组运算

算术运算

a = np.arange(1, 10).reshape(3, 3)
"""
[[1 2 3]
 [4 5 6]
 [7 8 9]]
"""
b = np.ones(9,dtype=int).reshape(3, 3)*2
"""
[[2 2 2]
 [2 2 2]
 [2 2 2]]
 """

# 同等维度的数组内部对应位置的数据元素进行运算
print(a + b)  
"""
[[ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
"""
print(a * b)
"""
[[ 2  4  6]
 [ 8 10 12]
 [14 16 18]]
"""
print(a ** b)
"""
[[ 1  4  9]
 [16 25 36]
 [49 64 81]]
 """
print(a @ b)		#矩阵点乘
"""
[[12 12 12]
 [30 30 30]
 [48 48 48]]
"""
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

a@b：矩阵乘法，第一个矩阵的列数（column）和第二个矩阵的行数（row）相同

使用对象的 dot() 方法：result = A.dot(B)

使用 NumPy 的函数形式：result = np.dot(A, B)

a = np.array([[1, 2, 3],
              [4, 5, 6]])
b = np.array([[1, 2],
              [1, 2],
              [1, 2]])
print(a @ b)	#矩阵乘法
"""
[[ 6 12]
 [15 30]]
"""
1
2
3
4
5
6
7
8
9
10

数组筛选

a = np.array([1,2,3,4,5,6,7,8,9])
flag = [False,True,True,False,True,False,True,False,False]
print(a[flag])  # array([2,3,5,7])

print(a<5)	#[True True True True False False False False False]
print(a[a<5])	#[1 2 3 4]
print(a[a%3==0])	#[3 6 9]
1
2
3
4
5
6
7

np.where(condition, x, y)

参数解释：
condition：一个布尔型数组或条件表达式，用于指定选择元素的条件。
x：满足条件的元素将被选择的数组或值。
y：不满足条件的元素将被选择的数组或值。

arr = np.array([1, 2, 3, 4, 5])
condition = np.array([True, False, True, False, False])
new_arr = np.where(condition, arr, 0)
print(new_arr)
# 输出: [1 0 3 0 0]

arr = np.array([1, 2, 3, 4, 5])
new_arr = np.where(arr > 3, arr, -1)
print(new_arr)
# 输出: [-1 -1 -1 4 5]
1
2
3
4
5
6
7
8
9
10

数组交换

a = np.array([1, 2, 3, 4, 5])
indices = [1, 2, 3, 4, 0]
print(a[indices])
#[2 3 4 5 1]

a = np.array([[1, 2, 3, 4, 5],
             [6, 7, 8, 9, 10]])
b = list(range(5))
b[1],b[3] = b[3],b[1]
print(a[:,b])
"""
[[ 1  4  3  2  5]
 [ 6  9  8  7 10]]
 """
1
2
3
4
5
6
7
8
9
10
11
12
13
14

数组合并拆分

合并：np.hstack()、np.vstack()、np.concatenate()

a = np.ones(6,dtype=int).reshape(2, 3)
b = np.ones(6,dtype=int).reshape(2, 3)*2
# 列（水平）合并
c = np.hstack((a, b))
print(c)
"""
[[1 1 1 2 2 2]
 [1 1 1 2 2 2]]
 """

# 行（垂直）合并
c = np.vstack((a, b))
print(c)
"""
[[1 1 1]
 [1 1 1]
 [2 2 2]
 [2 2 2]]
 """

d = np.concatenate((a, b), axis=0)	# 行（垂直）合并
print(d)
"""
通过axis作为关键字参数指定组合的方向，取值如下：
二维数组：
	0: 垂直方向（行）
	1: 水平方向（列）
三维数组：
	0: 深度方向（页）
	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
29
30
31
32

拆分：np.vsplit()、np.hsplit()、np.split()

a = np.array([[ 1,  2,  3],
              [ 4,  5,  6],
              [ 7,  8,  9],
              [10, 11, 12]])
# 行拆分操作，生成两个数组
b, c = np.vsplit(a, 2)
print(b, c, sep='\n')
"""
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]
 """

# 列拆分操作，生成三个数组
x, y, z = np.hsplit(a, 3)
print(x, y, z, sep='\n')

# 通过给出的数组与要拆分的份数，按照某个方向进行拆分
d = np.split(a, 2, axis=0)		#行拆分
print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

数组重复

np.repeat()

np.repeat(arr, repeats, axis=None)
1

• arr：要重复的数组。
• repeats：重复次数。可以是一个整数，表示每个元素重复的次数；也可以是一个数组，表示每个元素按照指定的次数进行重复。
• axis：指定重复的轴。如果不指定，则将数组展平后重复。

arr = np.array([1, 2, 3])
repeated_arr = np.repeat(arr, 3)
print(repeated_arr)		# 输出: [1 1 1 2 2 2 3 3 3]

arr = np.array([[1, 2], [3, 4]])
repeated_arr = np.repeat(arr, 2)
print(repeated_arr)
# 输出:
# [[1 1 2 2]
#  [3 3 4 4]]

arr = np.array([[1, 2], [3, 4]])
repeated_arr = np.repeat(arr, 3, axis=1)
print(repeated_arr)
# 输出:
# [[1 1 1 2 2 2]
#  [3 3 3 4 4 4]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

np.tile()

np.tile(A, reps)
1

• A：要重复的数组。
• reps：重复次数的元组。元组的长度表示输出数组的维度，每个元素表示沿相应维度上的重复次数。

arr = np.array([1, 2, 3])
repeated_arr = np.tile(arr, 3)
print(repeated_arr)
# 输出: [1 2 3 1 2 3 1 2 3]

arr = np.array([[1, 2], [3, 4]])
repeated_arr = np.tile(arr, (2, 3))
print(repeated_arr)
# 输出:
# [[1 2 1 2 1 2]
#  [3 4 3 4 3 4]
#  [1 2 1 2 1 2]
#  [3 4 3 4 3 4]]
1
2
3
4
5
6
7
8
9
10
11
12
13

np.repeat() 和 np.tile()的区别

• np.repeat() 是在指定轴上重复数组或切片中的元素。
• np.tile() 是在多个维度上重复整个数组或某个维度上的切片。