Python常用库(六):科学计算库-Numpy[上篇]:创建、访问、赋值

1.Numpy

1.1 介绍

NumPyPython中非常流行且重要的科学计算库,提供了一个强大的多维数组对象(ndarray)和许多数学操作,包括矩阵运算、线性代数、微积分等等。

numpyPython中一个非常有用的工具,特别是在需要进行数值计算、线性代数计算、数据分析和机器学习等领域。

其他资料:

  • GitHub截止当前: 24.4k https://github.com/numpy/numpy

  • 中文文档: https://www.numpy.org.cn/

1.2 主要功能

以下是NumPy的主要功能:

  • 多维数组 (ndarray): NumPy的核心功能是多维数组对象 ndarray,它是一个固定大小的数组,在内存中连续存储数据。 ndarray可以保存任何类型的数据, 但通常用于存储数值类型的数据。 ndarray的维度可以从一维到多维,可以进行基本的数值操作 (加法、减法、乘法、除法等) 以及矩阵运算 (矩阵乘法、矩阵转置等)。
  • 数组操作: NumPy提供了一系列用于数组操作的函数和方法。可以对数组进行形状调整 ( reshape) 、切片( slicing) 、索引 ( indexing) 和切割 ( splitting) 等操作。 这些操作高效地对数组进行重排、选取和修改。
  • 数学函数: NumPy提供了大量的数学函数,如三角函数、指数函数、对数函数等。这些函数可以直接应用于数组,并进行元素级的操作。此外, NumPy还提供了统计学函数 (均值、方差、相关性等)、线性代数函数 (矩阵求逆、特征值分解等) 等。
  • 文件I/0: NumPy提供了用于读写数组数据的函数。可以将数组数据保存至文件 (如 CSV、HDF5等格式) 或从文件中加载数据。这对于在机器学习中保存和加载数据集非常有用。
  • 广播 (Broadcasting) : 广播是 NumPy中的强大功能之一。它允许在不同形状的数组间进行数值运算,而无需进行显式的形状匹配或复制数据。通过广播, 可以对形状不同的数组进行运算,使得代码更加简洁和高效。
  • 并行计算: NumPy支持并行计算和向量化操作。通过使用 NumPy的通用函数 ( ufunc) ,可以在数组上进行并行计算,提高计算效率。此外, NumPy还与其他库 (如 SciPy) 和工具(如 Numba) 集成,可进一步提升计算性能。

1.3 安装

通过Anaconda安装的Python环境,默认会安装Numpy

# 查看当前环境是否安装
(py3.11) ➜  python-learn pip list | grep num
numexpr                   2.8.4
numpy                     1.25.2
# 不存在则通过下面命令安装
(py3.11) ➜ pip install numpy 

2. 创建数组

2.1 序列转数组

numpy.array函数可以将Python列表或元组转换为NumPy数组。例如:

import numpy as np

if __name__ == '__main__':
    # 使用numpy.array创建多维数组
    print("------------创建一维数组--------------------")
    list_one = np.array([123])
    tuple_one = np.array((123))
    print("列表转一维:{} \n元组转一维:{}".format(list_one, tuple_one))

    print("------------创建二维数组--------------------")
    list_two = np.array([
        [123],
        [456],
        [789],
    ])
    tuple_two = np.array((
        (123),
        (456),
        (789),
    ))
    print("列表转二维:\n {} \n元组转二维:{}".format(list_two, tuple_two))

    print("------------创建三维数组--------------------")
    list_three = np.array([
        [
            [123],
        ],
        [
            [456],
        ],
        [
            [789]
        ]
    ])
    print("列表转三维:{} ".format(list_three))
    
# ********************** 输出 **********************
------------创建一维数组--------------------
列表转一维:[1 2 3
元组转一维:[1 2 3]
------------创建二维数组--------------------
列表转二维:
 [[1 2 3]
 [4 5 6]
 [7 8 9]] 
元组转二维:[[1 2 3]
 [4 5 6]
 [7 8 9]]
------------创建三维数组--------------------
列表转三维:[[[1 2 3]]

 [[4 5 6]]

 [[7 8 9]]] 

2.2 一维数组

numpy库中,我们可以通过numpy.arangenumpy.linspace来创建一维数组,它们的主要区别在于参数的定义方式和生成数组的规则。

1. numpy.arange
numpy.arange([start, ]stop, [step, ]dtype=None)
  • start:起始值(包含在数组中)。
  • stop:终止值(不包含在数组中)。
  • step:步长,可选参数,默认为1。
  • dtype:可选参数,指定数组的数据类型。

使用示例:

import numpy as np
if __name__ == '__main__':
    print("np.arange(10):", np.arange(10))
    print("np.arange(5, 10):", np.arange(510))
    print("np.arange(0, 10, 3):", np.arange(0103))
    
# -------------------------- 输出 --------------------------
np.arange(10): [0 1 2 3 4 5 6 7 8 9]
np.arange(510): [5 6 7 8 9]
np.arange(0103): [0 3 6 9]
2. numpy.linspace
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
  • start:起始值(包含)。
  • stop:终止值(默认包含,可根据参数 endpoint调整)。
  • num:可选参数,默认为 50,指定数组的长度(元素个数)。
  • endpoint:可选参数,默认为 True,如果为 True,终止值( stop)将包含在数组中;如果为 False,终止值不包含在数组中。
  • retstep:可选参数,默认为 False,如果为 True,将会返回数组的取值间隔。
  • dtype:可选参数,指定数组的数据类型。

使用示例:

import numpy as np
if __name__ == '__main__':
    print("在 [0,10]之间取5个元素:", np.linspace(0105))
    print("在 [0,10]之间取5个元素,并返回取值间隔:", np.linspace(0105, retstep=True))
    print("在 [0,10)之间取5个元素,不包含10:", np.linspace(0105, endpoint=False))
    
# --------------------- 输出 ---------------------
在 [0,10]之间取5个元素: [ 0.   2.5  5.   7.5 10. ]
在 [0,10]之间取5个元素,不包含10: [0. 2. 4. 6. 8.]
在 [0,10]之间取5个元素,并返回取值间隔: (array([ 0. ,  2.5,  5. ,  7.510. ]), 2.5)

@使用说明: 至于到底选择使用哪个函数,取决于您希望如何生成一维数组。

  • 依据 步长生成,用 numpy.arange
  • 依据 元素个数生成,用 numpy.linspace

2.3 特别数组

  • numpy.zeros: 该函数可以创建指定形状的数组,并将所有元素初始化为 0
  • numpy.ones: 该函数可以创建指定形状的数组,并将所有元素初始化为 1
import numpy as np

if __name__ == '__main__':
    print("---------------------------- 全是0 ------------------------------------")
    print("一维数组-> np.zeros(6):", np.zeros(6))
    print("二维数组(2,3)-> np.zeros((2,3)):", np.zeros((23)))
    print("三维数组(2,3,3)-> np.zeros((2,2,3)):", np.zeros((223)))
    print("---------------------------- 全是1 ------------------------------------")
    print("一维数组-> np.ones(6):", np.ones(6))
    print("二维数组(2,3)-> np.ones((2,3)):", np.ones((23)))
    print("三维数组(2,3,3)-> np.ones((2,2,3)):", np.ones((223)))
    
# ********************************* 输出 *********************************
---------------------------- 全是0 ------------------------------------
一维数组-> np.zeros(6): [0. 0. 0. 0. 0. 0.]
二维数组(2,3)-> np.zeros((2,3)): [[0. 0. 0.]
 [0. 0. 0.]]
三维数组(2,3,3)-> np.zeros((2,2,3)): [[[0. 0. 0.]
  [0. 0. 0.]]

 [[0. 0. 0.]
  [0. 0. 0.]]]
---------------------------- 全是1 ------------------------------------
一维数组-> np.ones(6): [1. 1. 1. 1. 1. 1.]
二维数组(2,3)-> np.ones((2,3)): [[1. 1. 1.]
 [1. 1. 1.]]
三维数组(2,3,3)-> np.ones((2,2,3)): [[[1. 1. 1.]
  [1. 1. 1.]]

 [[1. 1. 1.]
  [1. 1. 1.]]]

2.4 空数组

NumPy中的empty函数是用于创建一个指定形状和数据类型的空数组。它会分配内存空间来存储数组元素,但不会对这些元素进行初始化。因此,创建的数组将包含未初始化的随机值或者之前内存中遗留的值。

numpy.empty(shape, dtype=float, order='C')

1.参数说明:

  • shape:表示所需的数组形状,可以是一个整数或者一个整数元组。
  • dtype(可选):表示所需的数组元素的数据类型,默认为 float
  • order(可选):表示数组在内存中的存储顺序,可以是'C'(按行存储)或'F'(按列存储),默认为'C'。

2.使用示例:

import numpy as np
if __name__ == '__main__':
    print("二维数组:\n", np.empty((23)))
    print("三维数组:\n", np.empty((222)))
    
# --------------------- 输出 ---------------------
/Users/liuqh/opt/anaconda3/envs/py3.11/bin/python /Users/liuqh/ProjectItem/PythonItem/python-learn/main.py 
二维数组:
 [[0.   0.15 0.25]
 [0.5  0.75 1.  ]]
三维数组:
 [[[0.    0.03 ]
  [0.215 0.4  ]]

 [[0.586 0.77 ]
  [0.954 1.   ]]]

2.5 随机数组

NumPy有一个random子模块,可以用来创建随机数组,该模块下有三个常用的函数:

  • np.random.random: 用于生成 [0,1) 区间内的随机浮点型数组;

    def random(size=None):
    # size: 用于指定数组元素个数  
  • np.random.randint: 用于生成[low, high)区间内的随机整型数组

    def randint(low, high=None, size=None, dtype=None)
    low:
     区间最小值(包含)
    # high: 区间最大值(不包含)
    # size:是一个元组,用于指定数组形状
    # dtype: 用于指定数组类型
  • np.random.random: 用于生成以loc为均值、以scale为标准差的正态分布数组;

    def normal(loc=0.0, scale=1.0, size=None)
    loc:
    均值
    # size:是一个元组,用于指定数组形状

代码示例:

import numpy as np

if __name__ == '__main__':
    print("------------- np.random.random 演示 -------------")
    random_var = np.random.random(4)
    print("random_var:", random_var)
    print("random_var.shape:", random_var.shape)
    print("------------- np.random.randint 演示 -------------")
    rand_int = np.random.randint(110, size=(23))
    print("rand_int:", rand_int)
    print("rand_int.shape:", rand_int.shape)
    print("------------- np.random.randint 演示 -------------")
    rand_normal = np.random.normal(size=(33))
    print("rand_normal:", rand_normal)
    print("rand_normal.shape:", rand_normal.shape)

# ******************** 输出 *******************
------------- np.random.random 演示 -------------
random_var: [0.61308029 0.45486095 0.69006646 0.38384838]
random_var.shape: (4,)
------------- np.random.randint 演示 -------------
rand_int: [[9 4 9]
 [7 4 3]]
rand_int.shape: (23)
------------- np.random.randint 演示 -------------
rand_normal: [[ 1.93567259  1.21137246  0.128895  ]
 [-2.28372489  0.63390644  0.48948102]
 [ 0.34386644  0.3941035   0.60806804]]
rand_normal.shape: (33)

3. 数组属性

3.1 常用属性

属性说明
shape数组的形状
ndim数组的维度
dtype数组元素的数据类型
size数组元素的总数

3.2 元素类型

if __name__ == '__main__':
    # 所有数据类型
    print("所有数据类型:", np.sctypeDict.values())

    # 定义数组,dtype=np.int32
    arr = np.arange(08, dtype=np.int32)
    print("打印数组:", arr)
    print("数组类型.dtype:", arr.dtype)

    # 类型转换
    new_arr = arr.astype(np.int64)
    print("类型转换后.dtype:", new_arr.dtype)
    
# ----------------------输出---------------------
所有数据类型: dict_values([...]) # 类型太多,此处省略
打印数组: [0 1 2 3 4 5 6 7]
数组类型.dtype: int32
类型转换后.dtype: int64

@注意:NumPy的数值对象的运算速度比Python的内置类型的运算速度慢很多,如果程序中需要大量地对单个数值运算,应尽量使用Python的内置类型

3.3 使用示例

import numpy as np
if __name__ == '__main__':
    print("----------------------------------------------------------")
    # 定义一维数组
    one_arr = np.arange(4, dtype=np.int32)
    print("一维数组:\n", one_arr)
    # 定义二维数组
    two_arr = np.arange(6, dtype=float).reshape(23)
    print("二维数组:\n", two_arr)
    # 定义多维数组
    three_arr = np.arange(012, dtype=int).reshape((223))
    print("三维数组:\n", three_arr)
    print("---------------------- 数组的维度 --------------------------")
    print("one_arr.ndim:", one_arr.ndim)
    print("two_arr.ndim:", two_arr.ndim)
    print("three_arr.ndim:", three_arr.ndim)
    print("---------------------- 数组的形状 --------------------------")
    print("one_arr.shape:", one_arr.shape)
    print("two_arr.shape:", two_arr.shape)
    print("three_arr.shape:", three_arr.shape)
    print("---------------------- 数组元素的总数 -----------------------")
    print("one_arr.size:", one_arr.size)
    print("two_arr.size:", two_arr.size)
    print("three_arr.size:", three_arr.size)
    print("---------------------- 数组元素类型 -------------------------")
    print("one_arr.dtype:", one_arr.dtype)
    print("two_arr.dtype:", two_arr.dtype)
    print("three_arr.dtype:", three_arr.dtype)
    
# **************************** 输出 *****************************
----------------------------------------------------------
一维数组:
 [0 1 2 3]
二维数组:
 [[0. 1. 2.]
 [3. 4. 5.]]
三维数组:
 [[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]]
---------------------- 数组的维度 --------------------------
one_arr.ndim: 1
two_arr.ndim: 2
three_arr.ndim: 3
---------------------- 数组的形状 --------------------------
one_arr.shape: (4,)
two_arr.shape: (23)
three_arr.shape: (223)
---------------------- 数组元素的总数 -----------------------
one_arr.size: 4
two_arr.size: 6
three_arr.size: 12
---------------------- 数组元素类型 --------------------------
one_arr.dtype: int32
two_arr.dtype: float64
three_arr.dtype: int64

4. 数组访问

4.1 维度理解

可耻盗张图,侵权联系删
可耻盗张图,侵权联系删

当维度大于1时,axis=x含义如下:

  • axis=0: 代表对横轴操作,即第几行
  • axis=1: 代表对纵轴操作,即第几列
  • axis=2: 代表对层级操作,即第几层

@注:上述说明也许过于浅显,要是更好的多维理解文章,求推荐。

4.2 访问语法

一维数组的访问方式和列表一样,这里不在叙述;这里主要学习二维和三维数组的访问方式,访问语法如下:

# 当访问二维数组时
arr[x,y] 或 arr[x][y]
# 当访问三维数组时
arr[c,x,y] 或 arr[c][x][y]
  • x: 指第几行,从0开始,如: arr[0]代表访问第一行,
  • y: 指第几列,从0开始,如: arr[0,0] 代表访问第一行第一列
  • c: 指第几层,从0开始,如: arr[0,0,0]代表访问第一层第一行第一列

代码示例:

import numpy as np

if __name__ == '__main__':
    arr = np.arange(6).reshape((23))
    print("----------------------- 二维数组访问 -----------------------")
    print("二维数组:\n", arr)
    print("第2行第3列:", arr[12])
    print("@第2行第3列:", arr[1][2])
    three_arr = np.arange(12).reshape((232))
    print("----------------------- 三维数组访问 -----------------------")
    print("三维数组:\n", three_arr)
    print("第1层第2行第2列:", three_arr[011])
    print("@第1层第2行第2列:", three_arr[0][1][1])
    print("第2层第3行第1列:", three_arr[120])
    print("@第2层第3行第1列:", three_arr[1][2][0])
    
# *********************** 输出 ***********************
----------------------- 二维数组访问 -----------------------
二维数组:
 [[0 1 2]
 [3 4 5]]
2行第3列: 5
@第2行第3列: 5
----------------------- 三维数组访问 -----------------------
三维数组:
 [[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
1层第2行第2列: 3
@第1层第2行第2列: 3
2层第3行第1列: 10
@第2层第3行第1列: 10

@注: A[x,y]和A[x][y]两者是有区别的。A[x,y]只进行一次计算,直接获取数组中行为x、列为y的元素;而A[x][y]进行了两次计算:首先获取A[x]对应的数据集合(是第x行的数据集合),然后在获取的新数据集合中获取第y个元素。建议使用A[x,y]这种方式获取数组元素

4.3 切片索引

访问数组时,切片索引下标说明:

arr[x:y:z]
  • x: 指从哪儿开始,包括当前元素,默认0;

  • y: 指到哪儿结束, 不包括当前元素,默认到最后;

  • z: 指间隔多少取一次元素,默认1;

使用切片索引时,一定要注意索引中的逗号(,)

这里以**三维数组:arr[层,行,列]**为例,列举几个访问方式:

  • arr[0]: 访问三维数组中的第一层;
  • arr[0,:,0]: 这里 被写成** :**,指访问第1层所有行中的第1列;
  • arr[0,0,:]: 这里 被写成** :**,指访问第1层第1行中的所有列;
  • arr[0,0,0]: 指访问第1层第1行第1列对应的元素;
  • arr[1,0,0:2]: 指访问第2层第1行,第1、2列的元素, 0:2中的0可以省略即: arr[1,0,:2]
  • arr[1, 0, ::2]: 指在第2层第1行所有元素中,每间隔2个元素取一次
import numpy as np

if __name__ == '__main__':
    arr = np.arange(18).reshape((233))
    print("三维数组:\n", arr)

    print("第1层:\n", arr[0])
    print("第1层所有行中的第1列:", arr[0, :, 0])
    print("第1层第1行中的所有列:", arr[00, :])
    print("第1层第1行第1列元素:", arr[000])
    print("第2层第1行第1、2列元素:", arr[10, :2])
    print("在第2层第1行所有元素中,每间隔2个元素取一次:", arr[10, ::2])
    
# *************** 输出 ****************
三维数组:
 [[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]]

 [[ 9 10 11]
  [12 13 14]
  [15 16 17]]]
1层:
 [[0 1 2]
 [3 4 5]
 [6 7 8]]
1层所有行中的第1列: [0 3 6]
1层第1行中的所有列: [0 1 2]
1层第1行第1列元素: 0
2层第1行第12列元素: [ 9 10]
在第2层第1行所有元素中,每间隔2个元素取一次: [ 9 11]

@注意:使用切片得到的数组,底层依旧指向原来的数组,修改切片元素,也会影响到原始数组(引用变量), 如下示例:

import numpy as np
if __name__ == '__main__':
    arr = np.arange(5)
    print("arr:", arr)
    # 通过切片得到新数组
    slice_arr = arr[2:4]
    print("slice_arr:", slice_arr)
    # 修改切片数组
    slice_arr[0] = 100
    print("修改切片数组后 slice_arr:", slice_arr)
    print("修改切片数组后 arr:", arr)

# ---------------------- 输出 ----------------------
arr: [0 1 2 3 4]
slice_arr: [2 3]
修改切片数组后 slice_arr: [100   3]
修改切片数组后 arr: [  0   1 100   3   4]

4.4 布尔索引

NumPy中,布尔索引是一种非常强大和灵活的索引方式,它允许我们根据指定的条件来获取数组中满足该条件的元素,并且返回一个与原始数组形状相同的布尔数组,其中对应位置上的元素是TrueFalse

1.常用表达式:

表达式说明
==相等;如:arr == 3
!=不等;如:arr != 3
><大于和小于; 如: arr > 3
&并且(and),都为真则为True
``
~逻辑非,即相反的条件

2.使用示例:

if __name__ == '__main__':
    print("-------------------- 根据条件输出匹配结果 --------------------")
    arr = np.array(["Python""Go""C""PHP""Java"])
    # 匹配等于条件
    print("等于'Go'的元素变成True:\n{}\n{}".format(arr, arr == "Go"))
    # 匹配相反(~)条件 
    opposite_conda = ~(arr == "Go")
    print("不等于'Go'的元素变成True:\n{}\n{}".format(arr, opposite_conda))

    # 匹配大于条件: 大于2的元素
    num_arr = np.arange(6)
    print("大于2的元素变成True:\n{}\n{}".format(num_arr, num_arr > 2))
    # 匹配&(and)条件: 大于2且被2整除
    cond = (num_arr > 2) & (num_arr % 2 == 0)
    print("大于2且被2整除的元素变成True:\n{}\n{}".format(num_arr, cond))
    # 匹配|(or)条件: 大于4或被2整除
    or_cond = (num_arr > 4) | (num_arr % 2 == 0)
    print("大于4或被2整除的元素变成True:\n{}\n{}".format(num_arr, or_cond))

# ******************************* 输出 **************************
--------------------  根据条件输出匹配结果 -------------------- 
等于'Go'的元素变成True:
['Python' 'Go' 'C' 'PHP' 'Java']
[False  True False False False]
不等于'Go'的元素变成True:
['Python' 'Go' 'C' 'PHP' 'Java']
True False  True  True  True]
大于2的元素变成True:
[0 1 2 3 4 5]
[False False False  True  True  True]
大于2且被2整除的元素变成True:
[0 1 2 3 4 5]
[False False False False  True False]
大于4或被2整除的元素变成True:
[0 1 2 3 4 5]
True False  True False  True  True]   

4.5 数组索引

Numpy中除了使用整数索引、切片索引还可以使用数组索引,数组索引一般分为:一维数组和多维数组

  • arr[[1,3,5]]: 当索引是一维数组时,代表访问数组 arr索引( 或行)为 1、3、5的元素;
  • arr[ [0,1], [1,2] ]: 当索引是多维数组时,代表访问数组 arr, (0,1)、(1,2)对应的元素;
import numpy as np

if __name__ == '__main__':
    print("---------------- 一维索引数组演示 ----------------")
    one_arr = np.arange(1122)
    print("一维数组:\n", one_arr)
    # 代表访问 one_arr[1]、one_arr[3]、one_arr[5] 对应的元素
    print("当索引是一维数组时(访问一维):", one_arr[[135]])

    tmp_arr = np.arange(12).reshape(43)
    print("二维数组:\n", tmp_arr)
    # 代表访问 tmp_arr[1]、tmp_arr[3] 对应的行
    print("当索引是一维数组时(访问二维): \n", tmp_arr[[13]])

    print("---------------- 多维索引数组演示 ----------------")
    arr = np.arange(6).reshape(23)
    print("二维数组:\n", arr)
    # [0,1]: 第1行第2列元素
    # [1,2]: 第2行第3列元素
    a = arr[[01], [12]]
    print("当索引是二维数组时:", a)
    
# ******************** 输出 ********************
---------------- 一维索引数组演示 ----------------
一维数组:
 [ 1  3  5  7  9 11]
当索引是一维数组时(访问一维): [ 3  7 11]
二维数组:
 [[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
当索引是一维数组时(访问二维): 
 [[ 3  4  5]
 [ 9 10 11]]
---------------- 多维索引数组演示 ----------------
二维数组:
 [[0 1 2]
 [3 4 5]]
当索引是二维数组时: [1 5]

5.数组赋值

5.1 普通索引赋值

import numpy as np

if __name__ == '__main__':
    arr = np.arange(6).reshape(23)
    print("原始数组:\n", arr)
    # 使用普通索引赋值
    oldVal = arr[12]
    newVal = oldVal * oldVal
    arr[12] = newVal
    print("把arr[1,2]对应元素:{},改成:{}".format(oldVal, newVal))
    print("修改后的数组:\n", arr)
    
# ******************** 输出 ********************
原始数组:
 [[0 1 2]
 [3 4 5]]
把arr[1,2]对应元素:5,改成:25
修改后的数组:
 [[ 0  1  2]
 [ 3  4 25]]

5.2 切片索引赋值

import numpy as np

if __name__ == '__main__':
    arr = np.arange(12).reshape(43)
    print("原始数组:\n", arr)
    # 修改整行中所有的元素
    arr[0, :] = 99
    print("修改数组第1行所有元素后:\n", arr)
    # 修改所有行中第2列元素
    arr[:, 1] = 88
    print("修改所有行中第2列元素后:\n", arr)

# ******************** 输出 ********************
原始数组:
 [[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
修改数组第1行所有元素后:
 [[99 99 99]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
修改所有行中第2列元素后:
 [[99 88 99]
 [ 3 88  5]
 [ 6 88  8]
 [ 9 88 11]]

5.3 布尔索引赋值

import numpy as np

if __name__ == '__main__':
    arr = np.arange(6)
    print("原始数组:", arr)
    index = (arr % 2 == 0)
    print("布尔索引:", index)
    # 被2整除的元素,都乘以2
    arr[index] *= 2
    print("被2整除的元素,都乘以2:", arr)
    # 大于3的元素,都设置成0
    arr[arr > 3] = 0
    print("大于3的元素,都设成0: ", arr)

   
# ******************** 输出 ********************
原始数组: [0 1 2 3 4 5]
布尔索引: [ True False  True False  True False]
2整除的元素,都乘以2: [0 1 4 3 8 5]
大于3的元素,都设成0:  [0 1 0 3 0 0]

本文由 mdnice 多平台发布

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/137281.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

JS 原型和原型链

原型和原型链 1. 了解原型和原型链1.1 原型1.2 原型链 2. 原型2.1 prototype2.2 __proto__ 隐式原型 3. 原型链 1. 了解原型和原型链 1.1 原型 原型&#xff1a; prototype 又称显示原型 1、原型是一个普通对象 2、只有构造函数才具备该属性 3、公有属性可操作 1.2 原型链 原…

MySQL数据库详解 二:数据库的高级语言和操作

文章目录 1. 克隆表 ---- 将数据表的数据记录生成到新的表中1.1 方式一&#xff1a;先创建新表&#xff0c;再导入数据1.2方式二&#xff1a;创建的时候同时导入 2. 清空表 ---- 删除表内的所有数据2.1 delete删除2.2 truncate删除&#xff08;重新记录&#xff09;2.3 创建临时…

如何使用ArcGIS中的Arcmap进行矢量和栅格数据裁剪?

在地理信息系统(GIS)中&#xff0c;我们经常需要处理各种空间数据&#xff0c;而矢量和栅格数据是最常见的两种数据类型。有时候&#xff0c;我们需要对数据进行裁剪&#xff0c;以提取出我们需要的特定区域的数据。本文将介绍如何使用ArcGIS中的Arcmap软件对矢量和栅格数据进行…

2054. 两个最好的不重叠活动;1255. 得分最高的单词集合;858. 镜面反射

2054. 两个最好的不重叠活动 核心思想:枚举小堆。因为你最多可以参加两个时间不重叠活动&#xff0c;所以我们就枚举其中一个活动&#xff0c;用一个堆来维护右边界的最小值&#xff0c;因为我们的event是排序的&#xff0c;前面满足的max_r_v&#xff0c;后面的event也肯定满…

网络防御--防火墙

拓扑 Cloud 1 作为电脑与ENSP的桥梁 防火墙配置 登录防火墙 配置IP地址及安全区域 添加地址对象 配置策略 1、内网可以访问服务器 结果 2、内网可以访问公网 结果 配置NAT策略 结果

exec函数族

1.execl函数 #include <unistd.h> int execl(const char *path, const char *arg, ...); 参数&#xff1a; -path:需要指定的执行文件的路径或者名称 -*arg:是可执行文件所需要的参数列表 第一个参数一般没有什么作用&#xff0c;一般写的是执行的程序的名称 从第二个参…

单例模式(饿汉模式 懒汉模式)与一些特殊类设计

文章目录 一、不能被拷贝的类 二、只能在堆上创建类对象 三、只能在栈上创建类对象 四、不能被继承的类 五、单例模式 5、1 什么是单例模式 5、2 什么是设计模式 5、3 单例模式的实现 5、3、1 饿汉模式 5、3、1 懒汉模式 &#x1f64b;‍♂️ 作者&#xff1a;Ggggggtm &#x…

设计模式:简单工厂、工厂方法、抽象工厂

参考 Java设计模式之创建型&#xff1a;工厂模式详解&#xff08;简单工厂工厂方法抽象工厂&#xff09; - 知乎 工厂方法 以生产手机为例&#xff0c;具体的UML图如下&#xff1a; 这种方法的优点是对于用户来说&#xff0c;不再需要面对具体的生产逻辑&#xff0c;只需要将生…

采用小型封装、RGCL80TS60GC11、RGWS00TS65DGC13、RGW50TK65GVC11场终止沟槽型IGBT具有高速开关。

一、RGW 650V场终止沟槽型IGBT RGW 650V场终止沟槽型IGBT采用小型封装&#xff0c;具有低集电极-发射极饱和电压。RGW IGBT具有高速开关、低开关损耗和内置极快软恢复FRD。ROHM RGW 650V场终止沟槽型IGBT非常适合用于太阳能逆变器、UPS、焊接、IH和PFC应用。 1、RGW50TK65GVC1…

SpringBoot 统一登录鉴权、异常处理、数据格式

本篇将要学习 Spring Boot 统一功能处理模块&#xff0c;这也是 AOP 的实战环节 用户登录权限的校验实现接口 HandlerInterceptor WebMvcConfigurer 异常处理使用注解 RestControllerAdvice ExceptionHandler 数据格式返回使用注解 ControllerAdvice 并且实现接口 Response…

笔记-搭建和使用docker-registry私有镜像仓库

笔记-搭建和使用docker-registry私有镜像仓库 拉取/安装registry镜像 和 对应的ui镜像 如果有网络可以直接拉取镜像 docker pull registry docker pull hyper/docker-registry-web没有网络可以使用我导出好的离线镜像tar包, 下载地址https://wwzt.lanzoul.com/i3im1194z12d …

【AI视野·今日CV 计算机视觉论文速览 第249期】Tue, 19 Sep 202

AI视野今日CS.CV 计算机视觉论文速览 Tue, 19 Sep 2023 (showing first 100 of 152 entries) Totally 152 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computer Vision Papers GEDepth: Ground Embedding for Monocular Depth Estimation Authors Xiaodong Yang…

什么是集成测试?集成测试方法有哪些?

1、基本概念&#xff1a; 将软件集成起来后进行测试。集成测试又叫子系统测试、组装测试、部件测试等。集成测试主要是针对软件高层设计进行测试&#xff0c;一般来说是以模块和子系统为单位进行测试。 2、集成测试包含的层次&#xff1a; 1. 模块内的集成&#xff0c;主要是…

esxi下实现ikuai相同的两个网卡,单独路由配置

1.首先安装配置双网卡。 因为esxi主机只接入了一根外网的网线&#xff0c;那么我们这两个网卡都是一样的网卡&#xff0c;具体的到系统里面进行设置。 2.开机安装系统 进入配置界面&#xff0c;此处就不用多说了&#xff0c;可以看我之前的文档&#xff0c;或者网上其他人的安…

Spring Cloud Gateway快速入门(二)——断言工厂

文章目录 前言1. 什么是Gateway断言工厂2. 为什么要使用断言2.1. 调试和开发&#xff1a;2.2. 防御性编程&#xff1a;2.3. 文档和可读性&#xff1a;2.4. 测试&#xff1a; 3. 常用的Gateway断言工厂3.1 Path断言工厂3.2 Method断言工厂3.3 Header断言工厂3.4 时间断言工厂 4.…

[JAVAee]Spring项目的创建与基本使用

目录 Spring项目的创建 Spring中Bean对象的存储与获取 存储Bean对象 获取并使用Bean对象 getBean方法的重载 本文章介绍了Spring项目创建与使用的过程与一定的注意事项. Spring项目的创建 首先在IDEA中,新建一个Maven 第二步,在pom.xml中写入spring的依赖. pom.xml是mav…

Feign实战-Springboot集成OpenFeign Demo以及参数详解

最近整理一下微服务的文章&#xff0c;先拿一直用的OpenFeign开刀 思考&#xff1a;微服务之间如何方便优雅的实现服务间的远程调用 一、说说openFeign是什么吧&#xff1f; 说到这个&#xff0c;那不得不先说说RPC 1.什么是RPC RPC 全称是 Remote Procedure Call &#x…

【Java 基础篇】Java后台线程和守护线程详解

在Java多线程编程中&#xff0c;有两种特殊类型的线程&#xff1a;后台线程&#xff08;Daemon Thread&#xff09;和守护线程&#xff08;Daemon Thread&#xff09;。这两种线程在一些特定的场景下非常有用&#xff0c;但也需要谨慎使用。本文将详细介绍后台线程和守护线程的…

MyBatis之增删查改功能

文章目录 一、创建各种类二、MyBatis的各种功能 1、查询<select>2、增加<insert>3、修改<update>4、删除<delete>三、总结 前言 在MyBatis项目中编写代码实现对MySql数据库的增删查改 一、创建各种类 1、在Java包的mapper文件下创建一个接口 我创建…

知识库系统推荐,强大的全文检索与文档分类管理功能

在我们日常企业运营管理过程中&#xff0c;会积累大量的文档资料&#xff0c;对于我们全体成员来说&#xff0c;这些知识文档都是巨大的财富&#xff0c;所以整合并搭建一套知识库系统是非常有必要的。 知识库系统推荐 我们日常工作中产生大量的文档&#xff0c;随着存储技术的…