NumPy基础及取值操作_ndarray取值

一.ndarray对象

1.安装Numpy：命令行输入 pip install numpy
2.ndarray对象——围绕Numpy的一个核心数据结构
ndarray对象就是一个N维数组。但要注意的是，ndarray是同质的。同质的意思就是说：N维数组里的所有元素必须是属于同一种数据类型的。 (PS: python中的list是异质的) 。
ndarray对象实例化好了之后，包含了一些基本的属性。

• shape:ndarray对象的形状，由一个tuple表示；
• ndim:ndarray对象的维度；
• size:ndarray对象中元素的数量；
• dtype:ndarray对象中元素的数据类型，例如int64，float32等

# 导入numpy并取别名为np
import numpy as np
# 构造ndarray
a = np.arange(15).reshape(3,5)
#   ndarray的shape是(3, 5)(代表3行5列)；
#   ndim是2(因为矩阵有行和列两个维度)；
#   size是15(因为矩阵总共有15个元素)；
#   dtype是int32(因为矩阵中元素都是整数，并且用32位整型足够表示矩阵中的元素)
print(a.shape)
print(a.ndim)
print(a.size)
print(a.dtype)
1
2
3
4
5
6
7
8
9
10
11
12

3.实例化ndarray对象

import numpy as np
# 使用列表作为初始值，实例化ndarray对象a
a = np.array([2,3,4])
print("a=",a)

# 实例化ndarray对象b，b是一个3行4列的矩阵，矩阵中元素全为0
b = np.zeros((3, 4))
print("b=",b)

# 实例化ndarray对象c，c是一个3行4列的矩阵，矩阵中元素全为1
c = np.ones((3, 4))
print("c=",c)

# 实例化ndarray对象d，d是一个2行3列的矩阵，矩阵中元素全为随机值
d = np.empty((2, 3))
print("d=",d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

第一关

import numpy as np


def print_ndarray(input_data):
    '''
    实例化ndarray对象并打印
    :param input_data: 测试用例，类型为字典类型
    :return: None
    '''

    #********* Begin *********#
    a = np.array(input_data['data'])
    print(a)
    #********* End *********#
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二. 形状操作

改变ndarray对象的形状：

import numpy as np
a = np.zeros((3, 4))

# 直接修改shape属性(太粗暴，不符合良好的编程规范）
a.shape = [4, 3]
print(a)


# 调用a的成员函数reshape将3行4列改成4行3列
a = a.reshape((4, 3))   #偏向面向对象
print(a)
# 调用reshape函数将a变形成4行3列
a = np.reshape(a, (4, 3))   #偏向面向过程
print(a)
#   PS:不管是哪种方式的reshape，都不会改变原ndarray的形状，而是将源ndarray进行深拷贝并进行变形操作，最后再将变形后的数组返回出去。
#   也就是说如果代码是np.reshape(a, (4, 3))那么a的形状不会被修改！



# 将a从3行4列的二维数组变成一个有12个元素的一维数组
a.resize(12)    #直接改变源ndarray的形状
print(a)



#在变形操作时，如果某个维度上的值为-1，那么该维度上的值会根据其他维度上的值自动推算。
# 行的维度上填-1，会让numpy自己去推算出行的数量，很明显，行的数量应该是24
a = a.reshape((-1, 2))
print(a)
#如果代码改成a = a.reshape((-1, -1))，NumPy会抛出异常ValueError: can only specify one unknown dimension。

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

第二关

import numpy as np


def reshape_ndarray(input_data):
    '''
    将ipnut_data转换成ndarray后将其变形成一位数组并打印
    :param input_data: 测试用例，类型为list
    :return: None
    '''

    #********* Begin *********#
    a = np.array(input_data)
    a = a.reshape((1,-1))
    print(a[0,])
    #********* End *********#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三.基础操作

算术运算：
如果想要对ndarray对象中的元素做elementwise(逐个元素地)的算术运算非常简单，加减乘除即可。

import numpy as np

a = np.array([0, 1, 2, 3])

b = a + 2    # a中的所有元素都加2，结果为[2, 3, 4, 5]

c = a - 2    # a中的所有元素都减2，结果为[-2, -1, 0, 1]

d = a * 2    # a中的所有元素都乘以2，结果为[0, 2, 4, 6]

e = a ** 2    # a中的所有元素都平方，结果为[0, 1, 4, 9]

f = a / 2    # a中的所有元素都除以2，结果为[0, 0.5, 1, 1.5]

g = a < 2    # a中的所有元素都与2比，结果为[True, True, False, False]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

矩阵运算：
相同shape的矩阵A与矩阵B之间想要做elementwise运算也很简单，加减乘除即可。

import numpy as np
a = np.array([[0, 1], [2, 3]])
b = np.array([[1, 1], [3, 2]])

c = a + b   # a与b逐个元素相加，结果为[[1, 2], [5, 5]]

d = a - b    # a与b逐个元素相减，结果为[[-1, 0], [-1, 1]]

e = a * b    # a与b逐个元素相乘，结果为[[0, 1], [6, 6]]

f = a / b    # a的逐个元素除以b的逐个元素，结果为[[0., 1.], [0.66666667, 1.5]]

g = a ** b    # a与b逐个元素做幂运算，结果为[[0, 1], [8, 9]]

h = a < b    # a与b逐个元素相比较，结果为[[True, False], [True, False]]

#   *只能做elementwise运算，如果想做真正的矩阵乘法运算显然不能用*。
#   NumPy提供了@和dot函数来实现矩阵乘法。
A = np.array([[1, 1], [0, 1]])
B = np.array([[2, 0], [3, 4]])

print(A @ B)    # @表示矩阵乘法，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]

print(A.dot(B)) # 面向对象风格，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]

print(np.dot(A, B)) # 面向过程风格，矩阵A乘以矩阵B，结果为[[5, 4], [3, 4]]
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

简单统计：

import numpy as np
a = np.array([[-1, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 13]])
print(a.sum())   # 计算a中所有元素的和，结果为67
   
print(a.max())    # 找出a中最大的元素，结果为13
    
print(a.min())    # 找出a中最小的元素，结果为-1
    
print(a.argmax())    # 找出a中最大元素在a中的位置，由于a中有12个元素，位置从0开始计，所以结果为11
    
print(a.argmin())    # 找出a中最小元素在a中位置，结果为0
1
2
3
4
5
6
7
8
9
10
11

维度为2，就是说有两个轴：0号轴与1号轴（轴的编号从0开始算）。
0号轴为纵轴，1号轴为横轴。想要实现沿着哪个轴来统计，只需要修改axis即可
当没有修改axis时，axis的值默认为None。意思是在统计时会把ndarray对象中所有的元素都考虑在内。

    import numpy as np
    info = np.array([[3000, 4000, 20000], [2700, 5500, 25000], [2800, 3000, 15000]])
   	
   	print(info.min(axis=0)) 	# 沿着0号轴统计，结果为[2700, 3000, 15000]
    
    print(info.max(axis=0)) 	# 沿着0号轴统计，结果为[3000, 5500, 25000]
1
2
3
4
5
6

第三关

import numpy as np


def get_answer(input_data):
    '''
    将input_data转换成ndarray后统计每一行中最大值的位置并打印
    :param input_data: 测试用例，类型为list
    :return: None
    '''

    #********* Begin *********#
    a = np.array(input_data)
    print(a.argmax(axis=1))
    #********* End *********#
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四.随机数生成

简单随机数生成
random_sample：random_sample用于生成区间为[0, 1]的随机数，需要填写的参数size表示生成的随机数的形状，比如size=[2, 3]那么则会生成一个2行3列的ndarray，并用随机值填充。

choice：随机值是离散值，而且知道范围的可以使用choice实现。
choice的主要参数是a、size和replace。a是个一维数组，代表你想从a中随机挑选；size是随机数生成后的形状。假如模拟5次掷骰子，replace用来设置是否可以取相同元素，True表示可以取相同数字；False表示不可以取相同数字，默认是True。

randint：randint的功能和choice差不多，只不过randint只能生成整数，而choice生成的数与a有关，如果a中有浮点数，那么choice会有概率挑选到浮点数。
randint的参数有3个，分别为low，high和size。其中low表示随机数生成时能够生成的最小值，high表示随机数生成时能够生成的最大值减1。也就是说randint生成的随机数的区间为[low, high)。

import numpy as np

'''
结果可能为[[0.32343809, 0.38736262, 0.42413616]
          [0.86190206, 0.27183736, 0.12824812]]
'''
print(np.random.random_sample(size=[2, 3]))



'''
掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6，所以a=[1,2,3,4,5,6]
模拟5此掷骰子所以size=5
结果可能为 [1 4 2 3 6]
'''
print(np.random.choice(a=[1, 2, 3, 4, 5, 6], size=5,replace=False))


  
'''
掷骰子时可能出现的点数为1, 2, 3, 4, 5, 6，所以low=1,high=7
模拟5此掷骰子所以size=5
结果可能为 [6, 4, 3, 1, 3]
'''
print(np.random.randint(low=1, high=7, size=5))

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

概率分布随机数生成
高斯分布又称为正态分布，中间高，两边低。横轴为随机变量的值（可以看成是产生的随机值），纵轴表示随机变量对应的概率（可以看成是随机值被挑选到的概率）。
normal：normal函数除了size参数外，还有两个比较重要的参数就是loc和scale，它们分别代表高斯分布的均值和方差。loc影响的分布中概率最高的点的位置，假设loc=2，那么分布中概率最高的点的位置就是2。scale影响的是分布图形的胖瘦，scale越小，分布就越又高又瘦，scale越大，分布就越又矮又胖。

import numpy as np
'''
根据高斯分布生成5个随机数
结果可能为：[1.2315868, 0.45479902, 0.24923969, 0.42976352, -0.68786445]
从结果可以看出0.4左右得值出现的次数比较高，1和-0.7左右的值出现的次数比较低。
'''
print(np.random.normal(size=5))


#根据均值为1，方差为10的高斯分布来生成5个随机值
print(np.random.normal(loc=1, scale=10, size=5))

1
2
3
4
5
6
7
8
9
10
11
12

随机种子
计算机产生的随机数是由随机种子根据一定的计算方法计算出来的数值。所以只要计算方法固定，随机种子固定，那么产生的随机数就不会变！
如果想要让每次生成的随机数不变，那么就需要设置随机种子（随机种子其实就是一个0到232−1的整数）。设置随机种子很长简单，调用seed函数并设置随机种子即可。

    import numpy as np
    # 设置随机种子为233
    np.random.seed(seed=233)
    data = [1, 2, 3, 4]
    # 随机从data中挑选数字，结果为4
    print(np.random.choice(data))
    # 随机从data中挑选数字，结果为4
    print(np.random.choice(data))
1
2
3
4
5
6
7
8

第四关

import numpy as np


def shuffle(input_data):
    '''
    打乱input_data并返回打乱结果
    :param input_data: 测试用例输入，类型为list
    :return: result，类型为list
    '''

    # 保存打乱的结果
    result = []
    #********* Begin *********#
    result = list(np.random.choice(a=input_data,size=len(input_data),replace=False))
    #********* End *********#
    return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

五.索引与切片

索引：
ndarray的索引其实和python的list的索引极为相似。元素的索引从0开始。

    import numpy as np
    # a中有4个元素，那么这些元素的索引分别为0，1，2，3
    a = np.array([2, 15, 3, 7])
    # 打印第2个元素，索引1表示的是a中的第2个元，结果为15
    print(a[1])
    # b是个2行3列的二维数组
    b = np.array([[1, 2, 3], [4, 5, 6]])
    # 打印b中的第1行， 总共就2行，所以行的索引分别为0，1， 结果为[1, 2, 3]
    print(b[0])
    # 打印b中的第2行第2列的元素，结果为5
    print(b[1][1])
1
2
3
4
5
6
7
8
9
10
11

遍历：
ndarray的遍历方式与python的list的遍历方式也极为相似

    import numpy as np
    a = np.array([2, 15, 3, 7])
    # 使用for循环将a中的元素取出来后打印
    for element in a:
        print(element)
    # 根据索引遍历a中的元素并打印
    for idx in range(len(a)):
        print(a[idx])
    # b是个2行3列的二维数组
    b = np.array([[1, 2, 3], [4, 5, 6]])
    # 将b展成一维数组后遍历并打印
    for element in b.flat:
        print(element)
    # 根据索引遍历b中的元素并打印
    for i in range(len(b)):
        for j in range(len(b[0])):
            print(b[i][j])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

切片：
ndarray的切片方式与python的list的遍历方式也极为相似。
切片时，索引范围是左闭右开。

import numpy as np
# a中有4个元素，那么这些元素的索引分别为0，1，2，3
a = np.array([2, 15, 3, 7])

'''
将索引从1开始到最后的所有元素切片出来并打印
结果为[15  3  7]
'''
print(a[1:])


'''
将从倒数第2个开始到最后的所有元素切片出来并打印
结果为[3  7]
'''
print(a[-2:])


'''
将所有元素倒序切片并打印
结果为[ 7  3 15  2]
'''
print(a[::-1])


# b是个2行3列的二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])

'''
将第2行的第2列到第3列的所有元素切片并打印
结果为[[5 6]]
'''
print(b[1:, 1:3])


'''
将第2列到第3列的所有元素切片并打印
结果为[[2 3]
    [5 6]]
'''
print(b[:, 1: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
37
38
39
40
41

第五关

import numpy as np

def get_roi(data, x, y, w, h):
    '''
    提取data中左上角顶点坐标为(x, y)宽为w高为h的ROI
    :param data: 二维数组，类型为ndarray
    :param x: ROI左上角顶点的行索引，类型为int
    :param y: ROI左上角顶点的列索引，类型为int
    :param w: ROI的宽，类型为int
    :param h: ROI的高，类型为int
    :return: ROI，类型为ndarray
    '''

    #********* Begin *********#
    a = data[x:x+h+1,y:y+w+1]
    return a
    #********* End *********#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17