numpy 数组索引和切片

import numpy as np


# [] 里面下标可以设置
# 1. 正负整数， 例如：np[0]、np[-1]、np[0][0]、np[-1][-1]
# 2. 列表表达式，例如：np[[1, 2, 3]]
# 3. 范围表达式，例如：np[1: 4], 从1位置开始到4之前结束，左闭右开
# 4. 逗号表达式，例如：np[0, 1]，逗号前为行、逗号后为列，适合多维数组
# 5. 布尔表达式，例如：np[[True, True, False, False]]

# 1. 正负整数下标 : 用于获得一维、多维数组中指定位置的元素
def test01():

    nd1 = np.arange(9)
    nd2 = np.arange(9).reshape((3, 3))
    print(nd1)
    print(nd2)
    print("-" * 10)

    print(nd1[0], nd1[-1], nd2[0][0], nd2[-1][-1])


# 2. 列表表达式 : 用于获得一维、多维数组中多个位置的元素
def test02():

    nd1 = np.arange(9)
    nd2 = np.arange(9).reshape((3, 3))

    # 获得下标为 1、3、5 位置的元素
    print(nd1[[1, 3, 5]])

    # 获得下标为 0、2 位置的一维数组
    print(nd2[[0, 2]])


# 3. 逗号表达式，例如：np[0, 1]，逗号前为行、逗号后为列，用于多维数组
def test03():

    # 3.1 一维数组：不能用
    # nd1 = np.arange(9)
    # print(nd1[0, 0])

    # 3.2 多维数组
    nd2 = np.arange(9).reshape((3, 3))
    print(nd2)
    print("-" * 10)

    # 获得第 2 行第 1 列数据
    print(nd2[2, 1])
    print("-" * 10)

    # 获得第 0 行第 1 列元素、2 行 2 列元素
    print(nd2[[0, 2], [1, 2]])
    print("-" * 10)
    print(nd2[[0, 2], [1, 2]])


# 4. 范围表达式，例如：np[1: 4], 从1位置开始到4之前结束，左闭右开
def test04():
    nd1 = np.arange(9)
    nd2 = np.arange(25).reshape((5, 5))

    # 4.1 一维数组
    # print(nd1)
    # print(nd1[: 3])  # 从开始到 3 下标之前
    # print(nd1[3:])  # 从 3 位置开始到结束
    # print(nd1[1: 4])  # 从 1 位置开始到 4 位置之前

    # 4.2 多维数组
    print(nd2)
    print("-" * 10)
    print(nd2[:3])  # 获得下标 3 之前的所有行
    print("-" * 10)
    print(nd2[3:])  # 获得下标 3 之后所有的行（包括3）
    print("-" * 10)
    print(nd2[1:4])  # 获得下标 1 开始到下标 4 之前所有的行
    print("-" * 10)

    # 4.3 范围表达式+逗号表达式
    """
        1. 先获得下标 1 开始到最后的所有行
        2. 再获得这些行的从开始到下标 2 之前所有的元素
    """
    print(nd2[1:, :2])
    print("-" * 10)
    """
        1. 先获得所有的行
        2. 再获得每一行的 1 下标开始，3下标之前的元素
    """
    print(nd2[:, 1:3])
    print("-" * 10)

    """
        1. 先获得 1、2、3 行
        2. 再获得这些行的下标为 1 到 3 之前的列
    """
    print(nd2[[1, 2, 3], 1: 3])
    print("-" * 10)

    """
        1. 先获得所有行
        2. 再获得这些行的 0、2、3 列
    """
    print(nd2[:, [0, 2, 3]])
    print("-" * 10)
    """
        1. nd2[[0, 2, 3]] 先获得 0、2、3 行
        2. [:, [0, 2, 3]] 再获得每一行的的 0、2、3 列
    """
    print(nd2[[0, 2, 3]][:, [0, 2, 3]])


# 5. 布尔表达式，例如：np[[True, True, False, False]]
def test05():
    line_data = np.arange(9).reshape(3, 3)

    print(line_data)
    print("-" * 10)

    # 获得第 1、2 行内容
    print(line_data[[True, True, False]])
    print("-" * 10)

    # 5.1 获得指定行
    line_name = np.array(["a", "b", "c"])

    # 获得名字为 a 的这一行
    print(line_data[line_name == "a"])
    print("-" * 10)

    # 获得名字为 a、c 的这两行
    print(line_data[(line_name == "a") | (line_name == "c")])
    print("-" * 10)

    # 获得大于 a <= cond < c 的这些行
    print(line_data[(line_name >= "a") & (line_name < "c")])
    print("-" * 10)

    # 获得行名字不为 a 的这些行
    print(line_data[line_name != "a"])
    print("-" * 10)

    # 获得行名字不为 a 的这些行
    print(line_data[~(line_name == "a")])
    print("-" * 10)

    # 5.2 获得指定列
    column_name = np.array(["c1", "c2", "c3"])  # 创建列名
    """
        获得列名为 c1、c3 的两列内容
    """
    print(line_data[:, (column_name == "c1") | (column_name == "c3")])


# 6. np.where
def test06():

    nd1 = np.arange(21, 30).reshape((3, 3))
    nd2 = np.arange(11, 20).reshape((3, 3))

    # 6.1 把所有 nd1 > 25 的元素替换成 0
    print(np.where(nd1 > 25, 0, nd2))
    print("-" * 10)

    # 6.2 将 nd1、nd2 中的最大值组成新的数组
    print(np.where(nd1 > nd2, nd1, nd2))


if __name__ == "__main__":
    test06()