Numpy基础

1.如何生成一个ndarray

# encoding=utf-8

# 学习numpy

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """怎样去构建一个 nd_array"""

    """构建一个一维的 nd_array"""
    a_list = [1, 2, 3]
    nd_array = np.array(a_list)
    print(type(nd_array), nd_array)  # <class 'numpy.ndarray'> [1 2 3]
    # 修改 nd_array，支持索引取值
    nd_array[0] = 5
    print(type(nd_array), nd_array)  # <class 'numpy.ndarray'> [5 2 3]
    print(nd_array.shape)  # (3,) 表示 nd_array 是一个长度为3的一维数组

    """构建一个二维的 nd_array"""
    b_list = [[1, 2, 3], [2, 3, 4]]
    nd_array = np.array(b_list)
    print(type(nd_array), nd_array)  # <class 'numpy.ndarray'> [[1 2 3] [2 3 4]]
    # 二维数组的取值
    nd_array[0, 1] = 5
    print(type(nd_array), nd_array)  # <class 'numpy.ndarray'> [[1 5 3] [2 3 4]]
    # 获取 nd_array 的维度
    print(nd_array.shape)  # (2, 3) 表示 nd_array 是两行三列的数组

    """有一些内置的创建数组的函数"""
    a_array = np.zeros((2, 3))  # shape, dtype, order 接收三个参数
    print(type(a_array), a_array)  # <class 'numpy.ndarray'> [[0. 0. 0.] [0. 0. 0.]]
    b_array = np.ones((3, 3))
    print(type(b_array), b_array)  # <class 'numpy.ndarray'> [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]
    # 来个厉害点的，有点像clone
    l_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
    clone_array = np.empty_like(l_array)  # random
    print("=" * 50, clone_array)  # 返回一个与给定数组具有相同形状和类型的新数组

    """自定制数组"""
    c_array = np.full((2, 2), 9.0)  # shape, full_value, dtype, order 接收4个参数
    print(type(c_array), c_array)  # <class 'numpy.ndarray'> [[9. 9.] [9. 9.]]

    """创建一个对角线矩阵"""
    d_array = np.eye(3)
    print(type(d_array), d_array)  # <class 'numpy.ndarray'> [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

    """创建随机的nd_array"""
    e_array = np.random.random((2, 3))
    print(type(e_array), e_array)  # <class 'numpy.ndarray'> [[0.539274   0.52694839 0.30455279]
                                                            # [0.46885707 0.26451937 0.64076338]]

    """生成指定范围内的array"""
    f_array = np.arange(0, 10, 2)  # start, end(顾前不顾后), set(步长)
    print(type(f_array), f_array)  # <class 'numpy.ndarray'> [0 2 4 6 8]

    """array 有不同的数据类型：int32(默认整数类型), int64(支持的整数范围更大), float64(默认小数类型)"""
    # 将int类型的array转换成float类型的array
    # str_array 不能转成 int_array 或 float_array
    int_array = np.arange(0, 10, 3)  # [0 3 6 9]
    float_array = np.array([1.2, 1.3, 1.4])  # [1.2 1.3 1.4]
    int_array = int_array.astype(dtype=float_array.dtype)  # 这里会生成一个新的array
    # int_array.dtype = float_array.dtype  # 这样直接赋值是错误的！
    print(int_array.dtype, int_array)  # float64 [0. 3. 6. 9.]


if __name__ == '__main__':
    main()

2.array_indexing_数组取值与赋值

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """
    学习 numpy_array 的取值与赋值
    Numpy 提供了很多种取值的方式
    """

    # 初始化一个元数据
    a_array = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
    print(a_array, a_array.shape)  # [[ 1  2  3  4] [ 5  6  7  8] [ 9 10 11 12]] (3, 4)

    # 可以像list一样做切片(多维数组可以从多个维度同时切片)
    b_array = a_array[:2, 1:]
    print(b_array, b_array.shape)  # [[2 3 4] [6 7 8]] (2, 3)
    c_array = a_array[1:2, :]
    print(c_array, c_array.shape)  # [[5 6 7 8]] (1, 4)

    # 赋值的效果
    d_array = a_array[1:2, :]  # [[5 6 7 8]]
    d_array[0, 0] = 100
    # 此时，两个array都发生了变化，这跟list的属性是一样的，切片是浅拷贝，只拷贝了最外面一层
    print(d_array, d_array.shape)  # [[100   6   7   8]] (1, 4)
    print(a_array)  # [[ 1  2  3  4] [ 100  6  7  8] [ 9 10 11 12]]
    # 用copy()来避免这种现象
    e_array = a_array[1:2, :].copy()
    e_array[0, 0] = 200
    print(e_array)  # [[ 200   6   7   8]]
    print(a_array)  # [[ 1   2   3   4] [ 100   6   7   8] [  9  10  11  12]]

    # 另外一种现象，输入索引不加冒号的情况，得到的就是一个一维数组
    f_array = a_array[1, :]  # [100   6   7   8]
    print(f_array, f_array.shape)  # [100   6   7   8] (4,)
    # 这样取值，就相当于a_array[1:2, :]
    g_array = a_array[[1], :]  # [100   6   7   8]]
    print(g_array, g_array.shape)  # [[100   6   7   8]] (1, 4)

    # 尝试在第二维度上切片, 可增加步长
    h_array = a_array[:, 1::2]  # [[ 2  4] [ 6  8] [10 12]]
    print(h_array, h_array.shape)  # [[ 2  4] [ 6  8] [10 12]] (3, 2)
    # 另外一种现象，输入索引不加冒号的情况
    i_array = a_array[:, 1]  # [ 2  6 10]
    j_array = a_array[:, 1:2]  # [[ 2] [ 6] [10]]
    k_array = a_array[:, [1]]  # [[ 2] [ 6] [10]]
    print(i_array, i_array.shape)  # [ 2  6 10] (3,)
    print(j_array, j_array.shape)  # [[ 2] [ 6] [10]] (3, 1)
    print(k_array, k_array.shape)  # [[ 2] [ 6] [10]] (3, 1)

    """高级取值用法(advanced)"""
    ad_array = np.array([[1, 2], [3, 4], [5, 6]])
    # 坐标点取值
    a_ad_array = ad_array[[0, 1, 2], [0, 1, 0]]  # [1 4 5]
    print(a_ad_array, a_ad_array.shape)  # [1 4 5] (3,)
    # 等同于 ad_array[[0, 1, 2], [0, 1, 0]]
    b_ad_array = np.array([ad_array[0, 0], ad_array[1, 1], ad_array[2, 0]])
    print(b_ad_array, b_ad_array.shape)  # [1 4 5] (3,)
    # 再举个例子
    c_ad_array = ad_array[[0, 1], [1, 1]]
    d_ad_array = np.array([ad_array[0, 1], ad_array[1, 1]])
    print(c_ad_array, c_ad_array.shape)  # [2 4] (2,)
    print(d_ad_array, d_ad_array.shape)  # [2 4] (2,)

    # 举一个高级的例子(用下标生成一个向量)
    ad_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
    print(ad_array, ad_array.shape)  # [[ 1  2  3] [ 4  5  6] [ 7  8  9] [10 11 12]] (4, 3)
    y = np.array([0, 1, 2, 1])
    print(ad_array[np.arange(4), y])  # [1 5 9 11]
    # 做一个赋值运算
    ad_array[np.arange(4), y] += 10
    print(ad_array, ad_array.shape)  # [[11  2  3] [ 4 15  6] [ 7  8 19] [10 21 12]] (4, 3)

    # 举一个比较fashion的用法
    fa_array = np.array([[1, 2], [3, 4], [5, 6]])
    bool_index = (fa_array > 2)
    print(bool_index, bool_index.shape)  # [[False False] [ True  True] [ True  True]] (3, 2)
    # 用刚才的布尔型数组作为下标就可以去除符合条件的元素了
    print(fa_array[bool_index])  # [3 4 5 6]  把符合条件的过滤出来了
    # 其实用一行代码就能实现
    print(fa_array[fa_array > 2])  # [3 4 5 6]


if __name__ == '__main__':
    main()

3.numpy的基础运算

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """
    学习 numpy_array 的基础运算
    下面这些运算才是你在科学运算中经常会用到的
    """

    x = np.array([[1, 2], [3, 4]], dtype=np.float64)
    y = np.array([[7, 8], [9, 10]], dtype=np.float64)
    # 逐个元素求和有下面2种方式
    print(x + y)  # [[ 8. 10.] [12. 14.]]
    print(np.add(x, y))  # [[ 8. 10.] [12. 14.]]
    # 逐个元素作差
    print(x - y)  # [[-6. -6.] [-6. -6.]]
    print(np.subtract(x, y))  # [[-6. -6.] [-6. -6.]]
    # 逐个元素相乘
    print(x * y)  # [[ 7. 16.] [27. 40.]]
    print(np.multiply(x, y))  # [[ 7. 16.] [27. 40.]]
    # 逐个元素相除
    print(x / y)  # [[0.14285714 0.25] [0.33333333 0.4]]
    print(np.divide(x, y))  # [[0.14285714 0.25] [0.33333333 0.4]]
    # 求单个 array 的平方根
    print(np.sqrt(x))  # [[1. 1.41421356] [1.73205081 2.]]

    """做矩阵的乘法运算，使用 matrix multiplication"""
    v = np.array([9, 10])
    w = np.array([10, 11])
    # 求向量内积，下面两种写法完全相同
    z1 = v.dot(w)  # 200  9*10 + 10*11
    print(v)
    z2 = np.dot(v, w)  # # 200  9*10 + 10*11
    print(z1, z2)
    # 再举一个二维数据的例子
    a = np.array([[1, 2], [3, 4]], dtype=np.int32)
    b = np.array([[5, 6], [7, 8]], dtype=np.int32)
    print(np.dot(a, v))  # [29 67] 1*9+2*10 3*9+4*10
    print(np.dot(a, b))  # [[19 22] [43 50]] 1*5+2*7 1*6+2*8 3*5+4*7 3*6+4*8

    """转置，和数学公式一样，简单粗暴"""
    print(a, a.T)  # [[1 2] [3 4]] [[1 3] [2 4]]
    # 一维数组的转置还是本身
    print(v, v.T)  # [ 9 10] [ 9 10]
    # 二维数组就不一样了
    w = np.array([[1, 2, 3]])
    print(w, w.T)  # [[1 2 3]] [[1] [2] [3]]

    """常用的矩阵运算，求和、求平均值"""
    s_array = np.array([[1, 2], [3, 4]])
    print(np.sum(s_array))  # 10
    print(s_array.sum())  # 10  这样也行
    # 对某行某列进行求和
    print(np.sum(s_array, axis=0))  # [4 6]
    print(np.sum(s_array, axis=1))  # [3 7]
    # 对某行某列求平均值
    print(np.mean(s_array, axis=0))  # [2. 3.]
    print(np.mean(s_array, axis=1))  # [1.5 3.5]
    # 求cumsum(元素累积和)
    print(np.cumsum(s_array, axis=0))  # [[1 2] [4 6]]
    print(np.cumsum(s_array, axis=1))  # [[1 3] [3 7]]
    # 求cumprod(元素累计积)
    print(np.cumprod(s_array, axis=0))  # [[1 2] [3 8]]
    print(np.cumprod(s_array, axis=1))  # [[1 2] [3 12]]


if __name__ == '__main__':
    main()

4.numpy数组排序

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """
    学习 numpy_array 的排序
    """

    r_array = np.random.randint(low=0, high=10, size=10, dtype=np.int32)
    print(r_array, r_array.shape)
    # sort排序
    r_array.sort()
    print(r_array)  # [0 1 1 3 6 8 9 9 9 9]  默认升序排列
    # 二维数组也可以在某些维度上排序
    t_array = np.random.randn(2, 3) * 10
    print(t_array)  # [[-13.23464858  -3.81143413  10.45328329] [ 12.66804747  -7.3430627    7.01360172]] (2, 3)
    # 在第一维度上进行排序
    t_array.sort(1)
    print(t_array)  # [[ -9.22978586  -1.74940518  14.06818126] [-19.23860172   1.73005451  20.56067731]]
    # 做一个小案例，找到排序后位置在5%的数字
    s_array = np.random.randn(1000) * 10
    s_array.sort()
    # print(s_array[0.05 * len(s_array)])  # 0.05 * len(s_array) 是个50.0的小数
    print(s_array[int(0.05 * len(s_array))])  # -17.82508819373788


if __name__ == '__main__':
    main()

5.numpy_broadcasting(重点)

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """
    学习 numpy_broadcasting
    作用是什么呢？我们设想一个场景，如果要用小的矩阵去和大的矩阵做一些操作，
    但是希望小矩阵能循环和大矩阵的那些块做一样的操作，那极其需要broadcasting
    """

    """
    我们要做一件事情，给 x 矩阵的每一行都逐元素加上一个向量，然后生成 y 矩阵
    比较粗暴的方式是，用for循环逐个相加，这种方法当然可以了，问题是不高效，
    如果 x 矩阵行数非常多，那就很慢的
    """

    x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
    v = np.array([1, 0, 1])

    y = np.empty_like(x)  # 返回一个与给定数组具有相同形状和类型的新数组
    print(y)  # [[1869490011  740779374  740763424] [1852788256  171597157  538976288] [ 538976288 1850679331 1881176428] [1953393010 1998610720 1768845921]]
    # 比较粗暴的方式：用for循环逐个相加
    for i in range(4):
        y[i, :] = x[i, :] + v
    print(y)  # [[ 2  2  4] [ 5  5  7] [ 8  8 10] [11 11 13]]
    # 因为broadcasting的存在，上面的操作可以简单的写成一个求和操作，且效率很高
    # 当操作两个array时，numpy会逐个比较它们的shape， 在相等 or 其中一个为1的情况下可以进行操作
    y = x + v  # [[ 2  2  4] [ 5  5  7] [ 8  8 10] [11 11 13]]
    print(x.shape, v.shape)  # (4, 3) (3,)
    print(y)

    # 举个栗子
    v = np.array([1, 2, 3])  # [1 2 3]
    w = np.array([4, 5])  # [4 5]
    print(v.shape, w.shape)  # (3,) (2,)
    # 改变v的shape
    v = v.reshape(3, 1)  # [[1] [2] [3]]
    print(v + w)  # [[5 6] [6 7] [7 8]]

    # 再举个栗子
    x = np.array([[1, 2, 3], [4, 5, 6]])
    w = np.array([1, 2, 3])
    print(x + w)  # [[2 4 6] [5 7 9]]

    # 再举个栗子
    x = np.array([[1, 2, 3], [4, 5, 6]])
    w = np.array([4, 5])
    # 可以先把 x 转置一下得到二维数组
    print(x.T)  # [[1 4] [2 5] [3 6]]
    print(x.T + w)  # [[5 9] [6 10] [7 11]]
    # 也可以修改 w 的shape
    print(w.reshape(2, 1))  # [[4] [5]]
    print(x + w.reshape(2, 1))  # [[5 6 7] [9 10 11]]


if __name__ == '__main__':
    main()

6.numpy的逻辑运算

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


def main():
    """
    学习 numpy 的逻辑运算

    """
    x_array = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
    y_array = np.array([2.1, 2.2, 2.3, 2.4, 2.5])

    cond = np.array([True, False, True, True, False])
    print(np.where(cond, x_array, y_array))  # [1.1 2.2 1.3 1.4 2.5]
    # 举个栗子
    z_array = np.random.randn(2, 2)
    print(z_array > 0)  # [[False False] [ True  True]]
    print(np.where(z_array > 0, 1, -1))  # [[-1  -1] [1 1]]

    """一些高级的 nd_array 的处理"""
    # 使用reshape来改变tensor(指多维数组)的形状，前面的例子中也有用到
    a_array = np.arange(8)
    print(a_array, a_array.shape)  # [0 1 2 3 4 5 6 7] (8,)
    print(a_array.reshape(8, 1))  # [[0] [1] [2] [3] [4] [5] [6] [7]]
    print(a_array.reshape(2, 4))  # [[0 1 2 3] [4 5 6 7]]
    print(a_array.reshape(2, 2, 2))  # [[[0 1] [2 3]]  [[4 5] [6 7]]]
    # 还可以从其他的ndarray中获取shape信息(就是先拿到一个tuple参数)，然后reshape
    other_array = np.ones((2, 4), dtype=np.int32)
    print(other_array, other_array.shape)  # [[1 1 1 1] [1 1 1 1]] (2, 4)
    b_array = np.arange(8)  # [0 1 2 3 4 5 6 7] (8,)
    c_array = b_array.reshape(other_array.shape)
    print(c_array)  # [[0 1 2 3] [4 5 6 7]]
    # 使用ravel()把多维数组拉平
    d_array = c_array.ravel()
    print(d_array, d_array.shape)  # [0 1 2 3 4 5 6 7] (8,)

    # 连接两个二维数组
    arr1 = np.array([[1, 2, 3], [4, 5, 6]])
    arr2 = np.array([[7, 8, 9], [10, 11, 12]])
    print(np.concatenate((arr1, arr2), axis=0))  # [[ 1  2  3] [ 4  5  6] [ 7  8  9] [10 11 12]]
    print(np.concatenate((arr1, arr2), axis=1))  # [[ 1  2  3  7  8  9] [ 4  5  6 10 11 12]]
    # vertical: vstack(垂直堆叠), horizontal：hstack(水平堆叠)
    print(np.vstack((arr1, arr2)))  # [[ 1  2  3] [ 4  5  6] [ 7  8  9] [10 11 12]]
    print(np.hstack((arr1, arr2)))  # [[ 1  2  3  7  8  9] [ 4  5  6 10 11 12]]

    # 拆分数组
    arr = np.arange(0, 15).reshape(5, 3)  # [[ 0  1  2] [ 3  4  5] [ 6  7  8] [ 9 10 11] [12 13 14]]
    first, second, third = np.split(arr, [1, 3], axis=0)
    print(first, "\n\n", second, "\n\n", third)  # [[0 1 2]]  [[3 4 5] [6 7 8]]  [[ 9 10 11] [12 13 14]]
    first, second, third = np.split(arr, [1, 3], axis=1)
    print(first, "\n\n", second, "\n\n", third)  # [[0] [3] [6] [9] [12]]  [[1  2] [4  5] [7  8] [13 14]]  []


if __name__ == '__main__':
    main()

7.numpy的文件输入输出

# encoding=utf-8

# Numpy 简介：
"""
是python语言的一个library
只支持矩阵操作和运算
由C语言写成，非常高效

pandas也是基于Numpy构建的一个library
现在流行的机器学习框架 Tensorflow/PyTorch 等等，语法都与Numpy比较接近
"""

import numpy as np


# 读取csv文件作为数组
arr = np.loadtxt("array_name.txt", delimiter=",")
print(arr)

# 存储nd_array
arr = np.arange(0, 10).reshape(2, 5)
print(arr)  # [[0 1 2 3 4] [5 6 7 8 9]]
np.save("some_array", arr)  # 在当前目录下会生成一个.npy文件