educoder-Numpy基础及取值操作

一、第1关：ndarray对象

什么是ndarray对象
NumPy的核心数据结构是：ndarray
ndarray的全称是N-Dimension Arrary，一个ndarray对象就是一个N维数组，ndarray是同质的。同质的意思就是说 N维数组里的所有元素必须是属于同一种数据类型的 。 (PS: python中的list是异质的)
ndarray一些基本的属性：shape，ndim，size，dtype。

shape:ndarray对象的形状，由一个tuple表示；

ndim:ndarray对象的维度；

size:ndarray对象中元素的数量；

dtype:ndarray对象中元素的数据类型，例如int64，float32等。

设现在有一个3行5列的矩阵（ndarray）如下：

    array([[ 0,  1,  2,  3,  4],  
           [ 5,  6,  7,  8,  9],  
           [10, 11, 12, 13, 14]])  

那么该ndarray的shape是(3, 5)(代表3行5列)；

ndim是2(因为矩阵有行和列两个维度)；

size是15(因为矩阵总共有15个元素)；

dtype是int32(因为矩阵中元素都是整数，并且用32位整型足够表示矩阵中的元素)。

示例：

    # 导入numpy并取别名为np  
    import numpy as np
    # 构造ndarray  
    a = np.arange(15).reshape(3, 5)
    # 打印a的shape，ndim，size，dtype  
    print(a.shape)  
    print(a.ndim)  
    print(a.size)  
    print(a.dtype)  

实例化ndarray对象
实例化ndarray对象常用的函数是array，zeros，ones以及empty：

• 使用array函数实例化ndarray对象
  array函数将list中的值作为初始值，来实例化一个ndarray对象

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

• 使用zeros，ones，empty函数实例化ndarray对象
• zeros()：元素全为0

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

• ones()：元素全为1

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

• empty()：元素为随机数

    import numpy as np
    # 实例化ndarray对象a，a是一个2行3列的矩阵，矩阵中元素全为随机值  
    a = np.empty((2, 3)) 
    # 打印ndarray对象a  
    print(a)  

答案：

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 *********#

二、第2关：形状操作

改变ndarray对象的形状
把a变成4行3列的二维数组，
法一：直接修改shape属性

    import numpy as np
    a = np.zeros((3, 4))
    # 直接修改shape属性  
    a.shape = [4, 3]

法二：使用改变ndarray对象的shape的函数：reshape()

    import numpy as np
    a = np.zeros((3, 4))
    # 调用a的成员函数reshape将3行4列改成4行3列  
    a = a.reshape((4, 3))

    import numpy as np
    a = np.zeros((3, 4))
    # 调用reshape函数将a变形成4行3列  
    a = np.reshape(a, (4, 3))

PS:不管是哪种方式的reshape，都不会改变原ndarray的形状，而是将源ndarray进行深拷贝并进行变形操作，最后再将变形后的数组返回出去。也就是说如果代码是np.reshape(a, (4, 3))那么a的形状不会被修改！

直接改变源ndarray的形状使用resize():

    import numpy as np
    a = np.zeros((3, 4))
    # 将a从3行4列的二维数组变成一个有12个元素的一维数组  
    a.resize(12)

小技巧

有的时候懒得去算每个维度上的长度是多少，比如现在有一个6行8列的ndarray，然后想把它变形成有2列的ndarray()，此时我们可以在行的维度上传个-1即可，代码如下：

    import numpy as np
    a = np.zeros((6, 8))
    # 行的维度上填-1，会让numpy自己去推算出行的数量，很明显，行的数量应该是24  
    a = a.reshape((-1, 2))

答案：

import numpy as np


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

    #********* Begin *********#
    after_reshape = np.array(input_data).reshape(-1)
    print(after_reshape)
    #********* End *********#

三、第3关：基础操作

• 算术运算

    import numpy as np
    a = np.array([0, 1, 2, 3])
    # a中的所有元素都加2，结果为[2, 3, 4, 5]  
    b = a + 2
    # a中的所有元素都减2，结果为[-2, -1, 0, 1]  
    c = a - 2
    # a中的所有元素都乘以2，结果为[0, 2, 4, 6]  
    d = a * 2
    # a中的所有元素都平方，结果为[0, 1, 4, 9]  
    e = a ** 2
    # a中的所有元素都除以2，结果为[0, 0.5, 1, 1.5]  
    f = a / 2
    # a中的所有元素都与2比，结果为[True, True, False, False]  
    g = a < 2

• 矩阵运算

    import numpy as np
    a = np.array([[0, 1], [2, 3]])  
    b = np.array([[1, 1], [3, 2]])
    # a与b逐个元素相加，结果为[[1, 2], [5, 5]]  
    c = a + b
    # a与b逐个元素相减，结果为[[-1, 0], [-1, 1]]  
    d = a - b
    # a与b逐个元素相乘，结果为[[0, 1], [6, 6]]  
    e = a * b
    # a的逐个元素除以b的逐个元素，结果为[[0., 1.], [0.66666667, 1.5]]  
    f = a / b
    # a与b逐个元素做幂运算，结果为[[0, 1], [8, 9]]  
    g = a ** b
    # a与b逐个元素相比较，结果为[[True, False], [True, False]]  
    h = a < b

• @和dot函数来实现矩阵乘法

    import numpy as np
    A = np.array([[1, 1], [0, 1]])  
    B = np.array([[2, 0], [3, 4]])
    # @表示矩阵乘法，矩阵A乘以矩阵B，结果为[[5, 4], [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))  

• 简单统计
  sum，min，max，argmin，argmax等函数来实现简单的统计功能

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

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

PS:当没有修改axis时，axis的值默认为None。意思是在统计时会把ndarray对象中所有的元素都考虑在内。

答案：

import numpy as np


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

    #********* Begin *********#

    a=np.array(input_data).argmax(axis=1)
    print(a)
    #********* End *********#

四、第4关：随机数生成

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

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

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

    import numpy as np
    '''  
    掷骰子时可能出现的点数为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))  

randint
randint的功能和choice差不多，只不过randint只能生成整数，而choice生成的数与a有关，如果a中有浮点数，那么choice会有概率挑选到浮点数。

randint的参数有3个，分别为low，high和size。其中low表示随机数生成时能够生成的最小值，high表示随机数生成时能够生成的最大值减1。也就是说randint生成的随机数的区间为[low, high)。假如模拟5次掷骰子，代码如下：

    import numpy as np
    '''  
    掷骰子时可能出现的点数为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)  

根据高斯分布（正态分布）来产生随机值，可以使用normal函数

mport 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)  

其中normal函数除了size参数外，还有两个比较重要的参数就是loc和scale，它们分别代表高斯分布的均值和方差。loc影响的分布中概率最高的点的位置，假设loc=2，那么分布中概率最高的点的位置就是2。下图体现了loc对分布的影响，其中蓝色分布的loc=0，红色分布的loc=5。
scale影响的是分布图形的胖瘦，scale越小，分布就越又高又瘦，scale越大，分布就越又矮又胖。下图体现了scale对分布的影响，其中蓝色分布的scale=0.5，红色分布的scale=1.0。
均值为1，方差为10的高斯分布来生成5个随机值：

    import numpy as np
    print(np.random.normal(loc=1, scale=10, size=5)  

随机种子
前面说了这么多随机数生成的方法，那么随机数是怎样生成的呢？其实计算机产生的随机数是由随机种子根据一定的计算方法计算出来的数值。所以只要计算方法固定，随机种子固定，那么产生的随机数就不会变！
如果想要让每次生成的随机数不变，那么就需要设置随机种子（随机种子其实就是一个0到2^32−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))  

答案：

import numpy as np


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

    # 保存打乱的结果
    result = []
    #********* Begin *********#
  
    num=np.random.choice(input_data,len(input_data),replace=False)
    for i in num:
        result.append(i)
    #********* End *********#
    return result