numpy科学计算库的基础用法，完美抽象多维数组(原创)

# 起别名避免重名
import numpy as np

# 小技巧：print从外往内看==shape从左往右看
if __name__ == "__main__":
    print('numpy版本号  {}'.format(np.version.version))

    n_1 = np.array([1, 2, 3])
    print('\n{} \n{} 维数组 \n{} 形状包含元素个数'.format(n_1, n_1.ndim, n_1.shape))

    n_2 = np.array([[1, 2, 3], [4, 5, 6]])
    print('\n{} \n{} 维数组 \n{} 形状包含行数、列数'.format(n_2, n_2.ndim, n_2.shape))

    n_3 = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
    print('\n{} \n{} 维数组 \n{} 形状包含2维数组个数、行数、列数'.format(n_3, n_3.ndim, n_3.shape))

    print("\n使用size()方法来打印多维数组的元素个数")
    print(np.size(n_1))
    print(np.size(n_2))
    print(np.size(n_3))

    print("\n <class 'list'>对比数据类型<class 'numpy.ndarray'>")
    print(type([1, 2, 3]))
    print(type(n_1))

    print("\n 内置dtype属性来打印多维度数组的元素类型")
    print(type(123))
    print(n_1.dtype)

    print("\n itemsize属性，来打印多维数组中的数据所占字节大小")
    print(n_1.itemsize, n_2.itemsize, n_3.itemsize)

    print("\n data属性，用来打印数据缓冲区--buffer---/也就是内存地址/")
    print(n_1.data, n_2.data, n_3.data)

    # 使用reshape()方法，根据形状反向生成多维数组
    n_3 = np.array(range(24)).reshape((3, 2, 4))  # 3个二维数组,每个2行,4列
    print('\n', n_3)

    # 使用浮点--元素类型
    n_float = np.array([1.0, 2.0, 3.0])
    print('\n', n_float.dtype)  # float64

    # 使用字符串-元素类型
    n_str = np.array(['1', '2', '3'])
    print(n_str.dtype)  # <U1

    # 使用整形--元素类型
    n_int = np.array(range(20))
    print(n_int.dtype)  # int32

    # 正向
    n_4 = np.array([[[list(range(5)), list(range(5, 10)), list(range(10, 15))]]])
    print(n_4)
    print('* ' * 50)

    # 反向
    n_4 = np.array(range(20)).reshape((2, 1, 2, 5))
    print(n_4)
    print('* ' * 50)

    n_3 = np.array(range(20)).reshape((2, 2, 5))
    print(n_3)
    print('* ' * 50)

    # 随机数
    n0 = np.random.randint(0, 100)
    print("\n{}的类型是{}".format(n0, type(n0)))
    n1 = np.random.rand()
    print("{}的类型是{}".format(n1, type(n1)))
    n2 = np.random.randn()
    print("{}的类型是{}".format(n2, type(n2)))
    n3 = np.random.random_sample(10)
    print("{}的类型是{}".format(n3, type(n3)))

    # 元素为1的多维数组
    nlist_ones = np.ones((4, 4))
    print(nlist_ones)
    print(nlist_ones.dtype)  # 元素float64

    # 元素为0的多维数组
    nlist_zeros = np.zeros((4, 4))
    print(nlist_zeros)

    # 使用empty方法来生成随机多维数组，使用第二个参数指定元素类型
    nlist_empty = np.empty((5, 5), dtype=np.int)
    print(nlist_empty)
    print(nlist_empty.dtype)  # int32

    # asarray把普通list转换为数组
    x = [1, 2, 3]
    print(type(x))
    nlist = np.asarray(x)
    print(type(nlist))
    print(nlist)

    # frombuffer把字符串（buffer内存地址）字节切片来生成多维数组
    # b强转byte字节
    my_str = b'Hello World'
    nlist_str = np.frombuffer(my_str, dtype='S1')
    print(nlist_str)

    # 数组运算
    # axis属性指定行或列，keepdims保持之前维度
    x = np.array([[1, 2], [3, 4]])
    print(x)
    sum0 = np.sum(x, axis=0, keepdims=True)  # axis = 0/行级/
    print(sum0)
    sum1 = np.sum(x, axis=1, keepdims=True)  # axis = 1/列级/
    print(sum1)

    # 多维数组赋值
    x = np.array([1, 2])
    x[1] = 3
    print(x)
    y = x.copy()
    y[0] = 3
    print(x)

    # 维度级的运算
    a = np.array([[1, 2], [3, 4], [5, 6]])
    b = np.array([[11, 22], [33, 44], [55, 66]])
    # vstack()方法---维度一样--- vertical垂直合并
    suma = np.vstack((a, b))
    print(suma)
    # hstack()方法---维度一样--- 横向连纵
    sumb = np.hstack((a, b))
    print(sumb)

    # 多维数组调用
    nl = np.array([[1, 2], [3, 4], [5, 6]])
    # 取子数据
    print(nl[[2]])
    # 取元素
    print(nl[0][0])
    print(nl[0, 0])
    # 元素赋值
    nl[1, 1] = 44
    print(nl)
    # 调换子数据位置
    print(nl[[2, 1, 0]])

    # 删除方法 delete
    # 删除nlist第二行
    print(np.delete(nl, 1, axis=0))
    print(np.delete(nl, 0, axis=1))

    # 范围区间差 = 形状数的乘积
    a = np.arange(1, 5).reshape((2, 2))
    b = np.arange(3, 7).reshape((2, 2))
    print(a)
    print(b)

    # 1、创建一个长度为10的一维全为0的多维数组，然后让第5个元素等于1
    ll = np.zeros((10,))
    print(ll)
    print(ll.ndim)
    print(ll.size)
    ll[4] = 1
    print(ll)

    q1 = np.zeros(shape=10)
    print(q1)
    q1[4] = 1
    print(q1)

    # 2、创建一个每一行都是从0到4的5*5矩阵
    list_5 = np.array([[range(5)] * 5])
    print(list_5)
    l_2 = np.array([range(5)] * 5).reshape(5, 5)
    print(l_2)

    # 3、假如给定一个3*3的二维数组，如何交换其中两行的元素？
    vv0 = np.random.randint(0, 100, size=(2, 2))
    print(vv0)
    print(vv0[[1, 0]])

    # 4、假如给定一个3*3的二维数组，如何交换其中两行的元素？
    vv = np.random.randint(0, 100, size=(3, 3))
    print(vv)
    print(vv[[1, 0, 2]])
    print(vv[[2, 0, 1]])
    print(vv[[0, 2, 1]])

    # 5、原数组为一维数组，内容为从 0 到 100，抽取出所有偶数。
    mm = np.arange(0, 101).reshape(101, )

    print(mm[::2])

    mm = filter(lambda x: x % 2 == 0, mm)
    print(np.array(list(mm)))

    # 用数组运算
    mm = np.array(range(101))
    print(mm)
    mm = mm[mm % 2 == 0]
    print(mm)