当前位置： 首页 > news >正文

小杰python高级（one day）——numpy库

news 2025/8/10 7:38:21

1.numpy库的安装

numpy库版本：1.23.5

（1）通过界面搜索的方式

1.搜索三方库进行安装。

此方式依赖于网络环境，如果出现安装失败的情况，可以尝试更换个人热点、更换源，同时检查选择的python解释器路径是否正确

2.修改国内源方式

阿里云 
Simple IndexVerifying - USTC MirrorsSimple Index
中国科技大学 
https://pypi.mirrors.ustc.edu.cn/simple/
豆瓣(douban) 
http://pypi.douban.com/simple/
清华大学 
https://pypi.tuna.tsinghua.edu.cn/simple/
中国科学技术大学 
http://pypi.mirrors.ustc.edu.cn/simple/

（2）.通过命令的方式

在pycharm软件的terminal上执行命令

pip install matplotlib==3.7.2 -i 源的链接：可以通过命令进行换源

（3）.numpy库的功能

NumPy(Numerical Python)是一个开源的Python科学计算库，它提供了多维数组对象（‌ndarray）以及大量的数学函数库

  • 支持多维数组操作：NumPy提供了强大的n维数组对象ndarray，可进行高效的数据处理
  • 丰富的函数：NumPy内置了大量数学、统计和线性代数函数。
  • 高性能：NumPy底层采用C语言编写，相比于python来说运算速度快，性能优越
  • 具有广播功能：可以允许不同形状的数组进行算术运算

2.ndarray 数组

  • NumPy数组在内存中连续存储，并且每个元素的大小、类型相同。其在访问和修改元素时具有极高的效率。
  • NumPy数组可以是多维的，具有明确的形状（shape）。
  • NumPy提供了丰富的数学、统计、线性代数等函数库，可以进行相应的运算。
  • NumPy数组的内部实现是基于C语言的
  • NumPy的广播机制允许不同形状的数组在进行运算时自动扩展它们的形状，从而能够进行元素级的运算

（1）数组的创建

numpy.array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)

参数：

        object:可以是列表、元组、ndarray数组等可迭代对象，表示要转换为数组的数据。

        dtype:数组元素的数据类型，可选，如果未指定，则根据输入数据自动推断。

        copy:对象是否需要复制（针对数组），特殊情况（当新数组的dtype改变时，会复制空间）默认为True

                True，则复制输入数据；

                False，当传入参数的数据类型和dtype指定的不一致时才复制

        order:指定数组在内存中的存储顺序，可以是‘C’（C语言风格,行优先）、‘F’（Fortran风格,列优先）或‘K’（尽可能与输入数据的顺序一致）。默认为‘K’。

        subok:默认返回一个与基类类型一致的数组

        ndmin:指定数组的最小维度。如果输入数据的维度小于ndmin，则 NumPy 会自动在前面添加维度，以使数组的维度至少为ndmin。

numpy.asarray(a, dtype = None, order = None)

功能：创建numpy数组，于array类似，array比较常用

例
import numpy as np
a = [1.6, 2.7, 3, 4]
b = (3, 4, 5, 6)
arr = np.array(a, dtype=int)
print(arr)
brr = np.array(arr)
brr[2] = 5.4
print(arr)
print(brr)
crr = np.array(arr, dtype= float, copy=False)
crr[1] = 9.77
print(arr)
print(crr)
drr = np.array(crr,ndmin=3)
print(drr)输出：
[1 2 3 4]
[1 2 3 4]
[1 2 5 4]
[1 2 3 4]
[1.   9.77 3.   4.  ]
[[[1.   9.77 3.   4.  ]]]

（2）数组的访问

        索引访问：

索引从 0 开始，可以使用负数索引从数组末尾（-1）开始访问元素。

        切片访问：

切片访问与Python列表的切片方式类似，使用冒号:进行切片，格式为start:stop:step，其中start、stop值为数组的索引，遵循左闭右开原则，三个值可根据情况省略

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 索引访问
print(arr[0])
print(arr[1][1])
print(arr[1, 1])# 切片与索引结合访问
print(arr[0:2])
print(arr[0:2, 1:2]) # 取0：2切片行并且1：2的切片列的值
print(arr[:,0:2])
print(arr[:,1:2])  # 取所有行中1：2的切片列
print(arr[:,[0,2]])  # 取所有行中下标0与2的值
print(arr[[1,2]])  # 取下标为1与2的行
print(arr[[1,2], [0,2]])  # 相当于取arr[1][0]与arr[2][2]的值
print(arr[[1], [0,2]])  # 对1进行了广播
print(arr[[1,2],[2]])    # 对2进行了广播输出：
[1 2 3]
5
5
[[1 2 3][4 5 6]]
[[2][5]]
[[1 2][4 5][7 8]]
[[2][5][8]]
[[1 3][4 6][7 9]]
[[4 5 6][7 8 9]]
[4 9]
[4 6]
[6 9]

（3）创建特殊数组

empty

创建一个指定形状（shape）、数据类型（dtype）且初值为随机值的数组。

numpy.empty(shape, dtype = float, order = 'C')
参数：
    shape：数组的形状，用[]或()表示
    dtype：数组元素的类型
    order：数据在计算机内存中的存储元素的顺序，C或F​​​​​​​

zeros

numpy.zeros(shape, dtype = float, order = 'C')
功能：创建指定大小的数组
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
参数：a：可以是列表、元组、numpy数组
功能：创建一个和给定的数组具有相同形状的数组

import numpy as np
arr = np.empty([2,3], dtype=int)  # 随机值
print('arr', arr)
arr.fill(4)  # 传值4
print(arr)
brr = np.zeros([3,4])  # 默认0
print('brr', brr)
crr = np.zeros_like([[1,2,3],[4,5,6]])  # 和传入数据类型相同并将其置为0
print('crr', crr)输出：
arr [[0 0 0][0 0 0]]
[[4 4 4][4 4 4]]
brr [[0. 0. 0. 0.][0. 0. 0. 0.][0. 0. 0. 0.]]
crr [[0 0 0][0 0 0]]

ones

numpy.ones(shape, dtype = None, order = 'C')

功能：创建指定形状的数组

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

功能：创建一个和给定的数组具有相同形状的数组

full

numpy.full(shape, fill_value, dtype=None, order='C')

功能：创建一个指定形状，并设置指定值的数组

参数：shape：形状

fill_value：填充的值

full_like:  创建单行数组

import numpy as nparr = np.ones([3,4])  # 默认输出为1
print(arr)
brr = np.ones_like(arr)
print(brr)
crr = np.full([2,3], 5)
print(crr)
drr = np.full_like([2,3], 5)
print(drr)# 输出：
[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]
[[1. 1. 1. 1.][1. 1. 1. 1.][1. 1. 1. 1.]]
[[5 5 5][5 5 5]]
[5 5]

3.numpy的数据类型

（1）基本数据类型

名称

描述

np.int8

字节（-128 to 127）

np.int16

整数（-32768 to 32767）

np.int32

整数（-2147483648 to 2147483647）

np.int64

整数（-9223372036854775808 to 9223372036854775807）

np.uint8

无符号整数（0 to 255）

np.uint16

无符号整数（0 to 65535）

np.uint32

无符号整数（0 to 4294967295）

np.uint64

无符号整数（0 to 18446744073709551615）

np.float16

半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位

np.float32

单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位

np.float64

双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位

np.complex64

复数，共64位， 32 位浮点数的实数部分和32位浮点数虚数部分

np.complex128

复数，共128位， 64 位浮点数的实数部分和64位浮点数虚数部分

np.bool_

布尔型数据类型（True 或者 False）

np.int_

默认的整数类型（根据系统来定是int32还是int64）

np.intc

与 C 的 int 类型一样，一般是 int32 或 int 64

np.intp

用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）

np.float_

float64 类型的简写

np.complex_

complex128 类型的简写，即 128 位复数

整数类型：

'b': 有符号字符（相当于 int8）

'u': 无符号字符（相当于 uint8）

'i1', 'i2', 'i4', 'i8': 分别表示有符号的8位、16位、32位、64位整数

'u1', 'u2', 'u4', 'u8': 分别表示无符号的8位、16位、32位、64位整数

浮点类型：

'f2', 'f4', 'f8': 分别表示16位、32位、64位浮点数（相当于 float16, float32, float64）

复数类型：

'c8', 'c16', 'c32': 分别表示由两个16位、32位、64位浮点数组成的复数（相当于 complex64, complex128, complex256）

布尔类型：

'?' 或 'bool': 布尔类型（相当于 bool_）

字节类型：

'S<n>': 固定长度的字节字符串，<n> 表示长度。例如，'S10' 表示长度为10的字节字符串。

unicode类型：

'U<n>': 固定长度的Unicode字符串，<n> 表示长度（以字符为单位）。例如，'U10' 表示长度为10的Unicode字符串（Unicode编码标准来表示的字符串）。

补充：S10和U10区别：

S：是采用ASCII编码的字符串，ASCII 是一种基于英文字符的编码标准

U：是采用Unicode编码的字符串，Unicode 是一种国际标准的字符编码

两者编码方式不一样。

​​​​​​​（2）结构化数据类型

        (与C语言中结构体类似)

格式：

        [('键名1'， '类型1')， （'键名2'， '类型2'）...]

例：
import numpy as np
type = [('x', 'i4'), ('y', 'f4')]
a = [(1, 1.3), (2, 2.7), (3, 3.9)]
arr = np.array(a, dtype=type)
print(arr)
print(arr[0])
print(arr['x'])
print(arr['x'][1])# 输出：
[(1, 1.3) (2, 2.7) (3, 3.9)]
(1, 1.3)
[1 2 3]
2
例：

        定义一个结构化数据类型，每个元素包含3个字段，分别是name、age、height

import numpy as np
type1 = [('name', 'U20'), ('age', 'i4'), ('height', 'f4')]
a = [("zhangsan", 32, 175.1), ("lisi", 45, 180.1), ("wangwu", 16, 165.1)]
arr = np.array(a, dtype=type1)
print(type(arr['name'][0]))
print(arr)
print(arr[0])
print(arr['name'])
print()
type2 = [('name', 'S20'), ('age', 'i4'), ('height', 'f4')]
brr = np.array(a, dtype=type2)
print(type(brr['name'][0]))
print(brr['name'])输出：
<class 'numpy.str_'>
[('zhangsan', 32, 175.1) ('lisi', 45, 180.1) ('wangwu', 16, 165.1)]
('zhangsan', 32, 175.1)
['zhangsan' 'lisi' 'wangwu']<class 'numpy.bytes_'>
[b'zhangsan' b'lisi' b'wangwu']

（3）ndarray 属性

ndarray.ndim

秩(zhi)，即轴的数量或维度的数量

ndarray.shape

数组的维度，对于矩阵，n 行 m 列

ndarray.size

数组元素的总个数，相当于 .shape 中 n*m 的值

ndarray.dtype

ndarray 对象的元素类型

import numpy as np
arr = np.array([[1,2,3], [4,5,6]])
# 数组的维度
print(arr.ndim)
# 数组的形状
print(arr.shape)
# 数组的大小
print(arr.size)
# 数组的元素类型
print(arr.dtype)
# 数组的类型
print(type(arr))输出：
2
(2, 3)
6
int32
<class 'numpy.ndarray'>

（4）修改属性

       

astype

(不修改原数据类型，得赋给新变量)

numpy.ndarray.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)

参数：

dtype：表示新数据类型的对象。这可以是 NumPy 的 dtype 对象，也可以是 Python 的数据类型，例如 `int` 或 `float`。

casting：控制数据类型转换的安全性。

'no'：表示根本不应该进行转换数据类型。

'equiv'：允许数值上等价的类型转换，即转换前后数据的位表示相同。这意味着转换不会导致数据丢失。

'safe'：允许安全的类型转换，即转换过程中不会丢失信息。

'same_kind'：允许相同数据类型类别内的转换。例如，允许整型和整型之间、浮点型和浮点型之间的转换，但是不允许整型和浮点型之间的转换。

'unsafe'：允许任何类型的转换，不考虑是否会导致数据丢失或改变。这是最不安全的选项，因为它可能会静默地丢弃数据。

import numpy as nparr = np.array([[1,2,3], [4,5,6]])
print(arr.dtype)
brr = arr.astype(dtype=float)
print(brr)
print(brr.dtype)输出：
int32
[[1. 2. 3.][4. 5. 6.]]
float64

​​​​​​​reshape

（按顺序存储）

改变数组的形状，reshape方法用于给数组一个新的形状而不改变其数据，它返回一个新的数组，前提是修改的新数组元素个数与原始数组元素个数要一致，会抛出异常

numpy.ndarray.reshape(newshape, order='C')
参数：
    newshape：整数或整数元组，新的形状应该与原始数组中的元素数量相匹配。  当值为-1时，会根据元素总个数除以固定的值，自动计算出来

import numpy as nparr = np.array([[1,2,3], [4,5,6]])
brr = arr.reshape([6,1])
print(brr)
crr = arr.reshape([-1,2])
print(crr)输出：
[[1][2][3][4][5][6]]
[[1 2][3 4][5 6]]

​​​​​​​resize

resize 方法用于改变数组的大小，它会直接修改调用它的原始数组。如果新形状大于原始形状，则会在数组的末尾添加新的元素，这些元素的值未定义；如果新形状小于原始形状，则会截断数组。

numpy.ndarray.resize(newshape)
import numpy as nparr = np.array([[1,2,3], [4,5,6]])
arr.resize([2,2])  # 对原数组进行修改
print(arr)
arr.resize([3,5])  # 比原数据大，会进行随机值补充
print(arr)输出：
[[1 2][3 4]]
[[1 2 3 4 0][0 0 0 0 0][0 0 0 0 0]]

​​​​​​​flatten

flatten方法返回一个一维数组，它是原始数组的拷贝，修改新数组不会影响原数组，它默认按行顺序展平数组，但可以通过参数 `order` 来指定展平顺序。

numpy.ndarray.flatten(order='C')
参数：
    order：指定的顺序，‘C’ 表示按行，‘F’ 表示按列，‘A’ 或 ‘K’ 表示与原数组相同的顺序

import numpy as nparr = np.array([[1,2,3], [4,5,6]])
brr = arr.flatten(order='F')
print(brr)  # 将代码进行平铺输出：
[1 4 2 5 3 6]

​​​​​​​T

Ndarray 对象的 T 属性是一个特殊的属性，它返回转置后的数组（transpose）。

转置是一个操作，它将数组的维度进行交换。对于二维数组，这意味着行变为列，列变为行。对于更高维度的数组，转置操作涉及到交换数组的轴。

import numpy as nparr = np.array([[1,2,3], [4,5,6]])
brr = arr.T
print(brr) # 数组转置输出：
[[1 4][2 5][3 6]]
汇总：
import numpy as nparr = np.array([[1,2,3], [4,5,6]])
# print(arr.dtype)
# 1.修改数组的类型
# brr = arr.astype(np.float32)
# print(brr)
# print(brr.dtype)
# 2.修改数组的形状，保证和原数组元素个数一致，当指定一个为-1时，会根据固定值自动推导
# brr = arr.reshape([6,1])
# print(brr)
# 3.修改数组的大小
# arr.resize([2,2])
# print(arr)
# 4.将数组平铺
# brr = arr.flatten(order='F')
# print(brr)
# 5.数组的转置
brr = arr.T
print(brr)

（5）创建数组的其他函数

arange

(与range类似，左闭右开，默认0开始，步长为1)

numpy 使用 arange 函数创建数值范围并返回 ndarray 对象

numpy.arange(start, stop, step, dtype)
参数：
    start：起始值，默认为0
    stop：终止值（不包含）
    step：步长，默认为1
    dtype：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

代码：

import numpy as np
# 创建指定范围内一维数组
arr = np.arange(7, 34, 4)
print(arr)输出：
[ 7 11 15 19 23 27 31]

​​​​​​​linspace

（创建一个一维数组，数组是一个等差数列构成的）

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
参数：start：序列的起始值
    stop：序列的终止值
    num：要生成的等步长的样本数量，默认为`50`
    endpoint：该值为 True时，数列中包含`stop`值，反之不包含，默认是True。
    retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。
    dtype：`ndarray` 的数据类型

代码：

import numpy as np# 创建一个等差数列
brr = np.linspace(22, 30, 5, endpoint= True, retstep=True, dtype=int)
print(brr)输出：
(array([22, 24, 26, 28, 30]), 2.0)

​​​​​​​random

Ndarray数组还可以创建具有随机元素的数组。随机元素的值可以根据是否设置随机数种子每次产生相同或不同的随机值。

随机数种子：是一个用于初始化随机数生成器的值，随机数种子的值可以是任意的，如果不显式设置种子，通常会使用当前时间作为种子，这样每次程序运行时都会产生不同的随机数序列。如果设置相同的随机数种子，每次程序运行时生成的随机数序列都是相同的。

np.random.seed(num)
功能：设置随机数种子，种子值可以是任何整数，通常是正整数。
rand

numpy.random.rand(d0, d1, ..., dn)

功能：返回一个或一组[0.0, 1.0) 区间均匀分布的随机浮点类型样本

参数：d0, d1, ..., dn：这些参数定义了输出数组的形状

import numpy as np# 当设置随机数种子为固定值时，每次运行的随机值都想同，
# 当不设置种子值时会以当前时间作为种子值，每次运行随机值都不同
np.random.seed(10)  # 随机数种子，产生固定的随机值
arr = np.random.rand(3, 2)  # 无随机数种子时，根据当前时间，产生随机值
print(arr)输出：[[0.77132064 0.02075195][0.63364823 0.74880388][0.49850701 0.22479665]]
http://www.dtcms.com/a/318587.html

相关文章：

  • 应急响应-windows篇
  • Spring选择哪种方式代理？
  • 12、Docker Compose 安装 Redis
  • CGAL Kernel 和 Traits 类深度解析：从官方教程到实践应用
  • 疯狂星期四文案网第30天运营日记
  • 从Token到序列：阿里GSPO算法如何让大模型训练更稳、更强？
  • CubeFS存储（一）
  • 16-DS18B20-±0.5℃精度-12bitADC--55°C ~ +125°C
  • ubuntu server 工业环境部署手册[2025-08-06]
  • ⭐CVPR 文本到 3D 场景生成新突破：Prometheus 框架解析
  • http请求结构体解析
  • 【C++】二叉树进阶
  • 人工智能大数据模型驱动企业创新
  • 商用密码应用安全性评估法律法规的重要性及演变过程
  • 力扣-15.三数之和
  • 五、Istio管理网格外部服务
  • 快速准确的千兆像素病理图像分类，采用分层蒸馏多实例学习（每日一文）
  • ssm复习
  • 【RabbitMQ】高级特性—死信队列详解
  • 560. 和为 K 的子数组 - 前缀和思想
  • MATLAB下载教程MATLAB R2025a 保姆级安装步骤（附安装包）
  • 数据结构——双向链表及makefile
  • c++ 中 原子锁、互斥锁、自旋锁的区别和详细用法
  • 大模型 + 垂直场景：搜索 / 推荐 / 营销 / 客服领域开发
  • 【Redis】Linux部署redis 7集群部署三主三从、ACL新建用户及密码（图文教程）
  • ​ubuntu22.04系统入门 （四）linux入门命令 权限管理、ACL权限、管道与重定向
  • 集合数据类型Map和Set
  • pcl手动直通滤波
  • LeetCode每日一题，8-6
  • 基于Simulink/MWORKS的文字与开关量混合传输系统设计