NumPy 源码解析（四十二）
.\numpy\numpy\tests\test_reloading.py
# 导入系统相关模块
import sys
# 导入子进程管理模块
import subprocess
# 导入文本包装模块
import textwrap
# 导入模块重新加载函数
from importlib import reload
# 导入 pickle 序列化模块
import pickle
# 导入 pytest 测试框架
import pytest
# 导入 numpy 异常模块
import numpy.exceptions as ex
# 从 numpy 测试模块中导入多个断言函数
from numpy.testing import (
assert_raises,
assert_warns,
assert_,
assert_equal,
IS_WASM,
)
# 定义测试函数：测试 NumPy 的重新加载
def test_numpy_reloading():
# gh-7844. Also check that relevant globals retain their identity.
# 导入 NumPy 主模块和全局变量模块
import numpy as np
import numpy._globals
# 从 NumPy 模块中获取 _NoValue 对象
_NoValue = np._NoValue
# 导入 NumPy 异常模块中的警告类
VisibleDeprecationWarning = ex.VisibleDeprecationWarning
ModuleDeprecationWarning = ex.ModuleDeprecationWarning
# 使用 assert_warns 断言捕获 UserWarning 异常
with assert_warns(UserWarning):
# 重新加载 NumPy 模块
reload(np)
# 使用 assert_ 断言 _NoValue 对象保持一致
assert_(_NoValue is np._NoValue)
# 使用 assert_ 断言 ModuleDeprecationWarning 对象保持一致
assert_(ModuleDeprecationWarning is ex.ModuleDeprecationWarning)
# 使用 assert_ 断言 VisibleDeprecationWarning 对象保持一致
assert_(VisibleDeprecationWarning is ex.VisibleDeprecationWarning)
# 使用 assert_raises 断言捕获 RuntimeError 异常
assert_raises(RuntimeError, reload, numpy._globals)
# 再次使用 assert_warns 断言捕获 UserWarning 异常
with assert_warns(UserWarning):
# 再次重新加载 NumPy 模块
reload(np)
# 使用 assert_ 断言 _NoValue 对象保持一致
assert_(_NoValue is np._NoValue)
# 使用 assert_ 断言 ModuleDeprecationWarning 对象保持一致
assert_(ModuleDeprecationWarning is ex.ModuleDeprecationWarning)
# 使用 assert_ 断言 VisibleDeprecationWarning 对象保持一致
assert_(VisibleDeprecationWarning is ex.VisibleDeprecationWarning)
# 定义测试函数：测试 _NoValue 对象的序列化和反序列化
def test_novalue():
# 导入 NumPy 主模块
import numpy as np
# 遍历序列化协议的范围
for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
# 使用 assert_equal 断言 _NoValue 对象的字符串表示
assert_equal(repr(np._NoValue), '<no value>')
# 使用 assert_ 断言反序列化后的对象仍然是 _NoValue
assert_(pickle.loads(pickle.dumps(np._NoValue,
protocol=proto)) is np._NoValue)
# 使用 pytest 的装饰器标记此测试用例为条件跳过，若 IS_WASM 为真则跳过
@pytest.mark.skipif(IS_WASM, reason="can't start subprocess")
# 定义测试函数：全面重新导入 NumPy 测试
def test_full_reimport():
"""At the time of writing this, it is *not* truly supported, but
apparently enough users rely on it, for it to be an annoying change
when it started failing previously.
"""
# 在撰写时，此功能不完全受支持，但显然有足够的用户依赖它，
# 如果此前失败，这将是一个令人讨厌的变化。
# 在一个新进程中进行测试，以确保在测试运行期间不会影响全局状态
# （可能导致难以理解的测试失败）。这通常是不安全的，特别是因为我们还重新加载了 C 模块。
# 使用 textwrap.dedent 方法去除代码段的缩进
code = textwrap.dedent(r"""
import sys
from pytest import warns
import numpy as np
# 清理所有包含 "numpy" 的模块，以便重新导入
for k in list(sys.modules.keys()):
if "numpy" in k:
del sys.modules[k]
# 使用 warns 捕获 UserWarning 警告
with warns(UserWarning):
# 重新导入 NumPy 模块
import numpy as np
""")
# 使用 subprocess.run 在新进程中执行 Python 代码，捕获输出
p = subprocess.run([sys.executable, '-c', code], capture_output=True)
# 如果返回码不为零，抛出 AssertionError 异常，输出详细信息
if p.returncode:
raise AssertionError(
f"Non-zero return code: {p.returncode!r}\n\n{p.stderr.decode()}"
)
.\numpy\numpy\tests\test_scripts.py
""" Test scripts
Test that we can run executable scripts that have been installed with numpy.
"""
# 导入必要的模块
import sys # 系统相关操作
import os # 操作系统相关功能
import pytest # 测试框架
from os.path import join as pathjoin, isfile, dirname # 文件路径操作
import subprocess # 子进程管理
import numpy as np # 导入 numpy 库
from numpy.testing import assert_equal, IS_WASM # 导入断言函数和 WASM 标志
# 检查是否在 inplace 安装环境下
is_inplace = isfile(pathjoin(dirname(np.__file__), '..', 'setup.py'))
def find_f2py_commands():
# 根据操作系统选择不同的 f2py 脚本路径
if sys.platform == 'win32':
exe_dir = dirname(sys.executable)
if exe_dir.endswith('Scripts'): # 如果是 virtualenv 下
return [os.path.join(exe_dir, 'f2py')]
else:
return [os.path.join(exe_dir, "Scripts", 'f2py')]
else:
# Unix-like 系统中有三个可能的 f2py 脚本名
version = sys.version_info
major = str(version.major)
minor = str(version.minor)
return ['f2py', 'f2py' + major, 'f2py' + major + '.' + minor]
@pytest.mark.skipif(is_inplace, reason="Cannot test f2py command inplace")
@pytest.mark.xfail(reason="Test is unreliable")
@pytest.mark.parametrize('f2py_cmd', find_f2py_commands())
def test_f2py(f2py_cmd):
# 测试能否运行 f2py 脚本
stdout = subprocess.check_output([f2py_cmd, '-v'])
assert_equal(stdout.strip(), np.__version__.encode('ascii'))
@pytest.mark.skipif(IS_WASM, reason="Cannot start subprocess")
def test_pep338():
# 测试 PEP 338 兼容性
stdout = subprocess.check_output([sys.executable, '-mnumpy.f2py', '-v'])
assert_equal(stdout.strip(), np.__version__.encode('ascii'))
.\numpy\numpy\tests\test_warnings.py
"""
Tests which scan for certain occurrences in the code, they may not find
all of these occurrences but should catch almost all.
"""
# 导入 pytest 库，用于编写和运行测试用例
import pytest
# 导入 Path 类，用于处理文件路径
from pathlib import Path
# 导入 ast 模块，用于解析 Python 抽象语法树
import ast
# 导入 tokenize 模块，用于解析 Python 源代码的词法分析
import tokenize
# 导入 numpy 库，用于获取 numpy 模块的安装路径
import numpy
# 定义 ParseCall 类，继承自 ast.NodeVisitor，用于解析函数调用时的节点
class ParseCall(ast.NodeVisitor):
def __init__(self):
self.ls = [] # 初始化空列表，用于存储函数调用时的属性和名称
def visit_Attribute(self, node):
ast.NodeVisitor.generic_visit(self, node)
self.ls.append(node.attr) # 记录属性名称
def visit_Name(self, node):
self.ls.append(node.id) # 记录名称
# 定义 FindFuncs 类，继承自 ast.NodeVisitor，用于查找特定函数调用
class FindFuncs(ast.NodeVisitor):
def __init__(self, filename):
super().__init__()
self.__filename = filename # 存储当前文件名
def visit_Call(self, node):
p = ParseCall()
p.visit(node.func) # 解析函数调用
ast.NodeVisitor.generic_visit(self, node)
# 检查特定函数调用情况
if p.ls[-1] == 'simplefilter' or p.ls[-1] == 'filterwarnings':
if node.args[0].value == "ignore":
raise AssertionError(
"warnings should have an appropriate stacklevel; found in "
"{} on line {}".format(self.__filename, node.lineno))
if p.ls[-1] == 'warn' and (
len(p.ls) == 1 or p.ls[-2] == 'warnings'):
if "testing/tests/test_warnings.py" == self.__filename:
# 在特定测试文件中，忽略检查
return
# 检查是否存在 stacklevel 参数
if len(node.args) == 3:
return
args = {kw.arg for kw in node.keywords}
if "stacklevel" in args:
return
raise AssertionError(
"warnings should have an appropriate stacklevel; found in "
"{} on line {}".format(self.__filename, node.lineno))
@pytest.mark.slow
def test_warning_calls():
# combined "ignore" and stacklevel error
base = Path(numpy.__file__).parent # 获取 numpy 模块的安装路径
# 遍历指定目录下的 Python 文件
for path in base.rglob("*.py"):
if base / "testing" in path.parents:
continue
if path == base / "__init__.py":
continue
if path == base / "random" / "__init__.py":
continue
if path == base / "conftest.py":
continue
# 使用 tokenize.open 打开文件，自动检测编码
with tokenize.open(str(path)) as file:
tree = ast.parse(file.read()) # 解析文件内容为抽象语法树
FindFuncs(path).visit(tree) # 查找特定函数调用
.\numpy\numpy\tests\test__all__.py
# 导入collections模块和numpy模块
import collections
import numpy as np
# 定义一个测试函数，用于检查np.__all__中是否存在重复项
def test_no_duplicates_in_np__all__():
# 以下是一个回归测试，用于修复GitHub上编号为gh-10198的问题
# 使用collections.Counter统计np.__all__中各元素的出现次数，并找出出现次数大于1的项，表示重复项
dups = {k: v for k, v in collections.Counter(np.__all__).items() if v > 1}
# 断言没有重复项，即重复项的数量应该为0
assert len(dups) == 0
.\numpy\numpy\tests\__init__.py
# 定义一个函数，接受一个整数参数 n
def is_prime(n):
# 边界条件，如果 n 小于等于 1，则直接返回 False
if n <= 1:
return False
# 特殊情况，2 和 3 是质数，直接返回 True
if n <= 3:
return True
# 如果 n 能被 2 或 3 整除，则不是质数，返回 False
if n % 2 == 0 or n % 3 == 0:
return False
# 初始化 i 为 5，循环检查可能的质数直到 i*i 大于等于 n
i = 5
while i * i <= n:
# 如果 n 能被 i 或 i+2 整除，则不是质数，返回 False
if n % i == 0 or n % (i + 2) == 0:
return False
# 继续检查下一个可能的质数，加上 6
i += 6
# 如果上述条件都不满足，则 n 是质数，返回 True
return True
.\numpy\numpy\typing\mypy_plugin.py
"""A mypy_ plugin for managing a number of platform-specific annotations.
Its functionality can be split into three distinct parts:
* Assigning the (platform-dependent) precisions of certain `~numpy.number`
subclasses, including the likes of `~numpy.int_`, `~numpy.intp` and
`~numpy.longlong`. See the documentation on
:ref:`scalar types <arrays.scalars.built-in>` for a comprehensive overview
of the affected classes. Without the plugin the precision of all relevant
classes will be inferred as `~typing.Any`.
* Removing all extended-precision `~numpy.number` subclasses that are
unavailable for the platform in question. Most notably this includes the
likes of `~numpy.float128` and `~numpy.complex256`. Without the plugin *all*
extended-precision types will, as far as mypy is concerned, be available
to all platforms.
* Assigning the (platform-dependent) precision of `~numpy.ctypeslib.c_intp`.
Without the plugin the type will default to `ctypes.c_int64`.
.. versionadded:: 1.22
Examples
--------
To enable the plugin, one must add it to their mypy `configuration file`_:
.. code-block:: ini
[mypy]
plugins = numpy.typing.mypy_plugin
.. _mypy: https://mypy-lang.org/
.. _configuration file: https://mypy.readthedocs.io/en/stable/config_file.html
"""
from __future__ import annotations # 允许使用自身类型作为返回类型或者参数类型提示
from collections.abc import Iterable # 导入抽象基类 Iterable
from typing import Final, TYPE_CHECKING, Callable # 导入 Final 类型注解，TYPE_CHECKING 常量和 Callable 类型注解
import numpy as np # 导入 NumPy 库
try:
import mypy.types # 尝试导入 mypy.types 模块
from mypy.types import Type # 从 mypy.types 导入 Type 类型注解
from mypy.plugin import Plugin, AnalyzeTypeContext # 从 mypy.plugin 导入 Plugin 和 AnalyzeTypeContext 类
from mypy.nodes import MypyFile, ImportFrom, Statement # 从 mypy.nodes 导入 MypyFile, ImportFrom 和 Statement 类
from mypy.build import PRI_MED # 导入 PRI_MED 常量
_HookFunc = Callable[[AnalyzeTypeContext], Type] # 定义 _HookFunc 类型别名
MYPY_EX: None | ModuleNotFoundError = None # 初始化 MYPY_EX 变量为 None 或 ModuleNotFoundError 类型
except ModuleNotFoundError as ex:
MYPY_EX = ex # 捕获 ModuleNotFoundError 异常并赋值给 MYPY_EX 变量
__all__: list[str] = [] # 初始化 __all__ 变量为空列表，用于控制模块的公开接口
def _get_precision_dict() -> dict[str, str]:
# 定义一个列表 names，包含多个元组，每个元组包含名称和对应的 NumPy 类型
names = [
("_NBitByte", np.byte),
("_NBitShort", np.short),
("_NBitIntC", np.intc),
("_NBitIntP", np.intp),
("_NBitInt", np.int_),
("_NBitLong", np.long),
("_NBitLongLong", np.longlong),
("_NBitHalf", np.half),
("_NBitSingle", np.single),
("_NBitDouble", np.double),
("_NBitLongDouble", np.longdouble),
]
ret = {} # 初始化一个空字典 ret
for name, typ in names: # 遍历 names 列表
n: int = 8 * typ().dtype.itemsize # 计算每种类型的位数
ret[f'numpy._typing._nbit.{name}'] = f"numpy._{n}Bit" # 构建精度字典，键为名称，值为精度字符串
return ret # 返回精度字典
def _get_extended_precision_list() -> list[str]:
# 定义一个列表 extended_names，包含多个字符串，表示扩展精度的类型名称
extended_names = [
"uint128",
"uint256",
"int128",
"int256",
"float80",
"float96",
"float128",
"float256",
"complex160",
"complex192",
"complex256",
"complex512",
]
return [i for i in extended_names if hasattr(np, i)] # 返回列表中存在于 NumPy 中的类型名称列表
def _get_c_intp_name() -> str:
# 从 np.core._internal._getintp_ctype 改编而来
char = np.dtype('n').char # 获取字符 'n' 的数据类型对象
if char == 'i': # 如果字符为 'i'
return "c_int" # 返回字符串 "c_int"
elif char == 'l':
# 如果字符为 'l'，返回字符串 "c_long"
return "c_long"
elif char == 'q':
# 如果字符为 'q'，返回字符串 "c_longlong"
return "c_longlong"
else:
# 对于其他任何字符，返回字符串 "c_long"
return "c_long"
#: A dictionary mapping type-aliases in `numpy._typing._nbit` to
#: concrete `numpy.typing.NBitBase` subclasses.
_PRECISION_DICT: Final = _get_precision_dict()
#: A list with the names of all extended precision `np.number` subclasses.
_EXTENDED_PRECISION_LIST: Final = _get_extended_precision_list()
#: The name of the ctypes equivalent of `np.intp`
_C_INTP: Final = _get_c_intp_name()
# 定义一个函数 `_hook`，用于替换类型别名为具体的 `NBitBase` 子类。
def _hook(ctx: AnalyzeTypeContext) -> Type:
"""Replace a type-alias with a concrete ``NBitBase`` subclass."""
typ, _, api = ctx
name = typ.name.split(".")[-1]
name_new = _PRECISION_DICT[f"numpy._typing._nbit.{name}"]
return api.named_type(name_new)
# 当类型检查开启或者 MYPY_EX 为 None 时，定义函数 `_index`。
def _index(iterable: Iterable[Statement], id: str) -> int:
"""Identify the first ``ImportFrom`` instance the specified `id`."""
for i, value in enumerate(iterable):
if getattr(value, "id", None) == id:
return i
raise ValueError("Failed to identify a `ImportFrom` instance "
f"with the following id: {id!r}")
# 当类型检查开启或者 MYPY_EX 为 None 时，定义函数 `_override_imports`。
def _override_imports(
file: MypyFile,
module: str,
imports: list[tuple[str, None | str]],
) -> None:
"""Override the first `module`-based import with new `imports`."""
# 构造一个新的 `from module import y` 语句
import_obj = ImportFrom(module, 0, names=imports)
import_obj.is_top_level = True
# 替换第一个基于 `module` 的导入语句为 `import_obj`
for lst in [file.defs, file.imports]: # type: list[Statement]
i = _index(lst, module)
lst[i] = import_obj
class _NumpyPlugin(Plugin):
"""定义一个名为 _NumpyPlugin 的插件类，继承自 Plugin 类。"""
def get_type_analyze_hook(self, fullname: str) -> None | _HookFunc:
"""获取类型分析钩子函数。
如果 fullname 在 _PRECISION_DICT 中，返回 _hook 函数；否则返回 None。
"""
if fullname in _PRECISION_DICT:
return _hook
return None
def get_additional_deps(
self, file: MypyFile
) -> list[tuple[int, str, int]]:
"""获取额外的依赖项列表。
根据 file 的 fullname 添加适当的依赖项：
- 如果 fullname 是 "numpy"，则导入 numpy._typing._extended_precision 下的 _EXTENDED_PRECISION_LIST。
- 如果 fullname 是 "numpy.ctypeslib"，则导入 ctypes 下的 _C_INTP。
返回一个包含元组的列表，元组包含优先级 PRI_MED、file 的 fullname、和 -1。
"""
ret = [(PRI_MED, file.fullname, -1)]
if file.fullname == "numpy":
_override_imports(
file, "numpy._typing._extended_precision",
imports=[(v, v) for v in _EXTENDED_PRECISION_LIST],
)
elif file.fullname == "numpy.ctypeslib":
_override_imports(
file, "ctypes",
imports=[(_C_INTP, "_c_intp")],
)
return ret
def plugin(version: str) -> type[_NumpyPlugin]:
"""插件的入口点函数，返回 _NumpyPlugin 类型。"""
return _NumpyPlugin
else:
# 定义一个名为 plugin 的函数，接受一个参数 version，返回一个 _NumpyPlugin 类型
def plugin(version: str) -> type[_NumpyPlugin]:
"""An entry-point for mypy."""
# 抛出 MYPY_EX 异常
raise MYPY_EX
.\numpy\numpy\typing\tests\data\fail\arithmetic.pyi
from typing import Any
import numpy as np
import numpy.typing as npt
b_ = np.bool()
dt = np.datetime64(0, "D")
td = np.timedelta64(0, "D")
AR_b: npt.NDArray[np.bool] # 定义一个布尔类型的 NumPy 数组
AR_u: npt.NDArray[np.uint32] # 定义一个无符号 32 位整数类型的 NumPy 数组
AR_i: npt.NDArray[np.int64] # 定义一个 64 位整数类型的 NumPy 数组
AR_f: npt.NDArray[np.float64] # 定义一个双精度浮点数类型的 NumPy 数组
AR_c: npt.NDArray[np.complex128] # 定义一个复数类型的 NumPy 数组
AR_m: npt.NDArray[np.timedelta64] # 定义一个时间差类型的 NumPy 数组
AR_M: npt.NDArray[np.datetime64] # 定义一个日期时间类型的 NumPy 数组
ANY: Any # 任意类型的对象
AR_LIKE_b: list[bool] # 布尔类型的列表
AR_LIKE_u: list[np.uint32] # 无符号 32 位整数类型的列表
AR_LIKE_i: list[int] # 整数类型的列表
AR_LIKE_f: list[float] # 浮点数类型的列表
AR_LIKE_c: list[complex] # 复数类型的列表
AR_LIKE_m: list[np.timedelta64] # 时间差类型的列表
AR_LIKE_M: list[np.datetime64] # 日期时间类型的列表
# 数组减法操作
# 注意：mypys `NoReturn` 错误报告不是很好
_1 = AR_b - AR_LIKE_b # E: 需要类型注解
_2 = AR_LIKE_b - AR_b # E: 需要类型注解
AR_i - bytes() # E: 没有匹配的重载变量
AR_f - AR_LIKE_m # E: 不支持的操作数类型
AR_f - AR_LIKE_M # E: 不支持的操作数类型
AR_c - AR_LIKE_m # E: 不支持的操作数类型
AR_c - AR_LIKE_M # E: 不支持的操作数类型
AR_m - AR_LIKE_f # E: 不支持的操作数类型
AR_M - AR_LIKE_f # E: 不支持的操作数类型
AR_m - AR_LIKE_c # E: 不支持的操作数类型
AR_M - AR_LIKE_c # E: 不支持的操作数类型
AR_m - AR_LIKE_M # E: 不支持的操作数类型
AR_LIKE_m - AR_M # E: 不支持的操作数类型
# 数组整除操作
AR_M // AR_LIKE_b # E: 不支持的操作数类型
AR_M // AR_LIKE_u # E: 不支持的操作数类型
AR_M // AR_LIKE_i # E: 不支持的操作数类型
AR_M // AR_LIKE_f # E: 不支持的操作数类型
AR_M // AR_LIKE_c # E: 不支持的操作数类型
AR_M // AR_LIKE_m # E: 不支持的操作数类型
AR_M // AR_LIKE_M # E: 不支持的操作数类型
AR_b // AR_LIKE_M # E: 不支持的操作数类型
AR_u // AR_LIKE_M # E: 不支持的操作数类型
AR_i // AR_LIKE_M # E: 不支持的操作数类型
AR_f // AR_LIKE_M # E: 不支持的操作数类型
AR_c // AR_LIKE_M # E: 不支持的操作数类型
AR_m // AR_LIKE_M # E: 不支持的操作数类型
AR_M // AR_LIKE_M # E: 不支持的操作数类型
_3 = AR_m // AR_LIKE_b # E: 需要类型注解
AR_m // AR_LIKE_c # E: 不支持的操作数类型
AR_b // AR_LIKE_m # E: 不支持的操作数类型
AR_u // AR_LIKE_m # E: 不支持的操作数类型
AR_i // AR_LIKE_m # E: 不支持的操作数类型
AR_f // AR_LIKE_m # E: 不支持的操作数类型
AR_c // AR_LIKE_m # E: 不支持的操作数类型
# 数组乘法操作
AR_b *= AR_LIKE_u # E: 不兼容的类型
AR_b *= AR_LIKE_i # E: 不兼容的类型
AR_b *= AR_LIKE_f # E: 不兼容的类型
AR_b *= AR_LIKE_c # E: 不兼容的类型
AR_b *= AR_LIKE_m # E: 不兼容的类型
AR_u *= AR_LIKE_i # E: 不兼容的类型
AR_u *= AR_LIKE_f # E: 不兼容的类型
AR_u *= AR_LIKE_c # E: 不兼容的类型
AR_u *= AR_LIKE_m # E: 不兼容的类型
AR_i *= AR_LIKE_f # E: 不兼容的类型
AR_i *= AR_LIKE_c # E: 不兼容的类型
AR_i *= AR_LIKE_m # E: 不兼容的类型
AR_f *= AR_LIKE_c # E: 不兼容的类型
AR_f *= AR_LIKE_m # E: 不兼容的类型
# 数组幂操作
# 对 AR_b 进行自乘赋值操作，使用 AR_LIKE_b 作为指数。可能出现的错误是“Invalid self argument”。
AR_b **= AR_LIKE_b # E: Invalid self argument
# 对 AR_b 进行自乘赋值操作，使用 AR_LIKE_u 作为指数。可能出现的错误是“Invalid self argument”。
AR_b **= AR_LIKE_u # E: Invalid self argument
# 对 AR_b 进行自乘赋值操作，使用 AR_LIKE_i 作为指数。可能出现的错误是“Invalid self argument”。
AR_b **= AR_LIKE_i # E: Invalid self argument
# 对 AR_b 进行自乘赋值操作，使用 AR_LIKE_f 作为指数。可能出现的错误是“Invalid self argument”。
AR_b **= AR_LIKE_f # E: Invalid self argument
# 对 AR_b 进行自乘赋值操作，使用 AR_LIKE_c 作为指数。可能出现的错误是“Invalid self argument”。
AR_b **= AR_LIKE_c # E: Invalid self argument
# 对 AR_u 进行自乘赋值操作，使用 AR_LIKE_i 作为指数。可能出现的错误是“incompatible type”。
AR_u **= AR_LIKE_i # E: incompatible type
# 对 AR_u 进行自乘赋值操作，使用 AR_LIKE_f 作为指数。可能出现的错误是“incompatible type”。
AR_u **= AR_LIKE_f # E: incompatible type
# 对 AR_u 进行自乘赋值操作，使用 AR_LIKE_c 作为指数。可能出现的错误是“incompatible type”。
AR_u **= AR_LIKE_c # E: incompatible type
# 对 AR_i 进行自乘赋值操作，使用 AR_LIKE_f 作为指数。可能出现的错误是“incompatible type”。
AR_i **= AR_LIKE_f # E: incompatible type
# 对 AR_i 进行自乘赋值操作，使用 AR_LIKE_c 作为指数。可能出现的错误是“incompatible type”。
AR_i **= AR_LIKE_c # E: incompatible type
# 对 AR_f 进行自乘赋值操作，使用 AR_LIKE_c 作为指数。可能出现的错误是“incompatible type”。
AR_f **= AR_LIKE_c # E: incompatible type
# 对 b_ 进行减法，但没有给定操作数。可能出现的错误是“No overload variant”。
b_ - b_ # E: No overload variant
# 对 dt 变量进行加法，但加法操作不支持给定的操作数类型。可能出现的错误是“Unsupported operand types”。
dt + dt # E: Unsupported operand types
# 对 td 变量进行减法，但减法操作不支持给定的操作数类型。可能出现的错误是“Unsupported operand types”。
td - dt # E: Unsupported operand types
# 对 td 变量进行取模操作，但取模操作不支持给定的操作数类型（例如，1 是整数，td 可能是时间间隔类型）。可能出现的错误是“Unsupported operand types”。
td % 1 # E: Unsupported operand types
# 对 td 变量进行除法，但除法操作没有重载支持给定的操作数类型。可能出现的错误是“No overload”。
td / dt # E: No overload
# 对 td 变量进行取模操作，但取模操作不支持给定的操作数类型。可能出现的错误是“Unsupported operand types”。
td % dt # E: Unsupported operand types
# 对 b_ 变量进行一元负号操作，但操作的类型不支持给定的操作数类型。可能出现的错误是“Unsupported operand type”。
-b_ # E: Unsupported operand type
# 对 b_ 变量进行一元正号操作，但操作的类型不支持给定的操作数类型。可能出现的错误是“Unsupported operand type”。
+b_ # E: Unsupported operand type
.\numpy\numpy\typing\tests\data\fail\arrayprint.pyi
from collections.abc import Callable
from typing import Any
import numpy as np
import numpy.typing as npt
# 定义一个名为 AR 的 numpy 数组，其元素类型为 np.float64
AR: npt.NDArray[np.float64]
# 定义一个接受任意类型参数并返回字符串的函数签名
func1: Callable[[Any], str]
# 定义一个接受 numpy.integer 类型参数并返回字符串的函数签名
func2: Callable[[np.integer[Any]], str]
# 调用 np.array2string 函数，以下是各种参数传递方式的错误提示注释
# E: 意外的关键字参数 style
np.array2string(AR, style=None)
# E: 类型不兼容
np.array2string(AR, legacy="1.14")
# E: 类型不兼容
np.array2string(AR, sign="*")
# E: 类型不兼容
np.array2string(AR, floatmode="default")
# E: 类型不兼容
np.array2string(AR, formatter={"A": func1})
# E: 类型不兼容
np.array2string(AR, formatter={"float": func2})
.\numpy\numpy\typing\tests\data\fail\arrayterator.pyi
import numpy as np # 导入NumPy库
import numpy.typing as npt # 导入NumPy类型定义模块
AR_i8: npt.NDArray[np.int64] # 声明一个名为AR_i8的NumPy数组，其元素类型为np.int64
# 使用AR_i8创建一个Arrayterator对象，这是NumPy中的一个迭代器
ar_iter = np.lib.Arrayterator(AR_i8)
np.lib.Arrayterator(np.int64()) # E: 不兼容的类型
ar_iter.shape = (10, 5) # E: 只读属性无法更改形状
ar_iter[None] # E: 无效的索引类型
ar_iter[None, 1] # E: 无效的索引类型
ar_iter[np.intp()] # E: 无效的索引类型
ar_iter[np.intp(), ...] # E: 无效的索引类型
ar_iter[AR_i8] # E: 无效的索引类型
ar_iter[AR_i8, :] # E: 无效的索引类型
.\numpy\numpy\typing\tests\data\fail\array_constructors.pyi
import numpy as np # 导入 NumPy 库
import numpy.typing as npt # 导入 NumPy 的类型提示模块
a: npt.NDArray[np.float64] # 声明变量 a 是一个 NumPy 数组，包含浮点数
generator = (i for i in range(10)) # 创建一个生成器，产生范围在 0 到 9 的整数
np.require(a, requirements=1) # E: No overload variant
np.require(a, requirements="TEST") # E: incompatible type
np.zeros("test") # E: incompatible type
np.zeros() # E: require at least one argument
np.ones("test") # E: incompatible type
np.ones() # E: require at least one argument
np.array(0, float, True) # E: No overload variant
np.linspace(None, 'bob') # E: No overload variant
np.linspace(0, 2, num=10.0) # E: No overload variant
np.linspace(0, 2, endpoint='True') # E: No overload variant
np.linspace(0, 2, retstep=b'False') # E: No overload variant
np.linspace(0, 2, dtype=0) # E: No overload variant
np.linspace(0, 2, axis=None) # E: No overload variant
np.logspace(None, 'bob') # E: No overload variant
np.logspace(0, 2, base=None) # E: No overload variant
np.geomspace(None, 'bob') # E: No overload variant
np.stack(generator) # E: No overload variant
np.hstack({1, 2}) # E: No overload variant
np.vstack(1) # E: No overload variant
np.array([1], like=1) # E: No overload variant
.\numpy\numpy\typing\tests\data\fail\array_like.pyi
# 导入 NumPy 库
import numpy as np
# 导入 ArrayLike 类型提示
from numpy._typing import ArrayLike
# 定义空类 A
class A:
pass
# 创建生成器表达式，生成包含 0 到 9 的整数序列
x1: ArrayLike = (i for i in range(10)) # E: Incompatible types in assignment
# 尝试将类 A 的实例赋值给 x2，类型不匹配
x2: ArrayLike = A() # E: Incompatible types in assignment
# 尝试将字典赋值给 x3，类型不匹配
x3: ArrayLike = {1: "foo", 2: "bar"} # E: Incompatible types in assignment
# 创建 NumPy 的 int64 标量
scalar = np.int64(1)
# 调用标量的 __array__ 方法，尝试转换为 float64 类型的 NumPy 数组，但方法不存在对应的重载
scalar.__array__(dtype=np.float64) # E: No overload variant
# 创建 NumPy 的一维数组
array = np.array([1])
# 调用数组的 __array__ 方法，尝试转换为 float64 类型的 NumPy 数组，但方法不存在对应的重载
array.__array__(dtype=np.float64) # E: No overload variant
.\numpy\numpy\typing\tests\data\fail\array_pad.pyi
import numpy as np # 导入 NumPy 库，用于科学计算
import numpy.typing as npt # 导入 NumPy 的类型提示模块，用于类型注解
AR_i8: npt.NDArray[np.int64] # 声明一个变量 AR_i8，类型为 int64 的 NumPy 数组
np.pad(AR_i8, 2, mode="bob") # 对数组 AR_i8 进行填充操作，填充宽度为 2，使用非法填充模式 "bob"
# 此处会报错，因为 "bob" 不是合法的填充模式
.\numpy\numpy\typing\tests\data\fail\bitwise_ops.pyi
import numpy as np
# 创建一个64位整数的 numpy 对象 i8
i8 = np.int64()
# 创建一个32位整数的 numpy 对象 i4
i4 = np.int32()
# 创建一个64位无符号整数的 numpy 对象 u8
u8 = np.uint64()
# 创建一个布尔值的 numpy 对象 b_
b_ = np.bool()
# 创建一个普通的 Python 整数对象 i
i = int()
# 创建一个64位浮点数的 numpy 对象 f8
f8 = np.float64()
# 尝试使用位运算符 >>，但在布尔值 b_ 和浮点数 f8 之间无法进行位移操作
b_ >> f8 # E: No overload variant
# 尝试使用位运算符 <<，但在整数 i8 和浮点数 f8 之间无法进行位移操作
i8 << f8 # E: No overload variant
# 尝试使用位或运算符 |，但在整数 i 和浮点数 f8 之间无法进行位或操作
i | f8 # E: Unsupported operand types
# 尝试使用位异或运算符 ^，但在整数 i8 和浮点数 f8 之间无法进行位异或操作
i8 ^ f8 # E: No overload variant
# 尝试使用位与运算符 &，但在无符号整数 u8 和浮点数 f8 之间无法进行位与操作
u8 & f8 # E: No overload variant
# 尝试使用位取反运算符 ~，但浮点数 f8 不能进行位运算
~f8 # E: Unsupported operand type
# TODO: Certain mixes like i4 << u8 go to float and thus should fail
# mypys' error message for `NoReturn` is unfortunately pretty bad
# TODO: Re-enable this once we add support for numerical precision for `number`s
# a = u8 | 0 # E: Need type annotation
.\numpy\numpy\typing\tests\data\fail\char.pyi
import numpy as np # 导入 NumPy 库，通常用 np 作为别名
AR_U: npt.NDArray[np.str_] # 定义 AR_U 变量，类型为 NumPy 字符串数组
AR_S: npt.NDArray[np.bytes_] # 定义 AR_S 变量，类型为 NumPy 字节串数组
np.char.equal(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 和 AR_S 中的元素是否相等，返回布尔数组 # E: incompatible type
np.char.not_equal(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 和 AR_S 中的元素是否不相等，返回布尔数组 # E: incompatible type
np.char.greater_equal(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 是否大于等于 AR_S 中的元素，返回布尔数组 # E: incompatible type
np.char.less_equal(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 是否小于等于 AR_S 中的元素，返回布尔数组 # E: incompatible type
np.char.greater(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 是否大于 AR_S 中的元素，返回布尔数组 # E: incompatible type
np.char.less(AR_U, AR_S) # 使用 NumPy 字符串函数比较 AR_U 是否小于 AR_S 中的元素，返回布尔数组 # E: incompatible type
np.char.encode(AR_S) # 对 AR_S 中的每个元素进行编码为字节串的操作，返回一个新的数组 # E: incompatible type
np.char.decode(AR_U) # 对 AR_U 中的每个元素进行解码为字符串的操作，返回一个新的数组 # E: incompatible type
np.char.join(AR_U, b"_") # 使用指定的分隔符 b"_" 将 AR_U 中的每个字符串数组元素连接成一个单独的字符串 # E: incompatible type
np.char.join(AR_S, "_") # 使用指定的分隔符 "_" 将 AR_S 中的每个字节串数组元素连接成一个单独的字节串 # E: incompatible type
np.char.ljust(AR_U, 5, fillchar=b"a") # 对 AR_U 中的每个字符串进行左对齐操作，不足部分使用 fillchar=b"a" 填充到长度 5 # E: incompatible type
np.char.ljust(AR_S, 5, fillchar="a") # 对 AR_S 中的每个字节串进行左对齐操作，不足部分使用 fillchar="a" 填充到长度 5 # E: incompatible type
np.char.rjust(AR_U, 5, fillchar=b"a") # 对 AR_U 中的每个字符串进行右对齐操作，不足部分使用 fillchar=b"a" 填充到长度 5 # E: incompatible type
np.char.rjust(AR_S, 5, fillchar="a") # 对 AR_S 中的每个字节串进行右对齐操作，不足部分使用 fillchar="a" 填充到长度 5 # E: incompatible type
np.char.lstrip(AR_U, chars=b"a") # 对 AR_U 中的每个字符串进行左侧去除指定字符 b"a" 的操作 # E: incompatible type
np.char.lstrip(AR_S, chars="a") # 对 AR_S 中的每个字节串进行左侧去除指定字符 "a" 的操作 # E: incompatible type
np.char.strip(AR_U, chars=b"a") # 对 AR_U 中的每个字符串进行两侧去除指定字符 b"a" 的操作 # E: incompatible type
np.char.strip(AR_S, chars="a") # 对 AR_S 中的每个字节串进行两侧去除指定字符 "a" 的操作 # E: incompatible type
np.char.rstrip(AR_U, chars=b"a") # 对 AR_U 中的每个字符串进行右侧去除指定字符 b"a" 的操作 # E: incompatible type
np.char.rstrip(AR_S, chars="a") # 对 AR_S 中的每个字节串进行右侧去除指定字符 "a" 的操作 # E: incompatible type
np.char.partition(AR_U, b"a") # 使用分隔符 b"a" 对 AR_U 中的每个字符串进行分割，返回分割后的数组 # E: incompatible type
np.char.partition(AR_S, "a") # 使用分隔符 "a" 对 AR_S 中的每个字节串进行分割，返回分割后的数组 # E: incompatible type
np.char.rpartition(AR_U, b"a") # 使用分隔符 b"a" 对 AR_U 中的每个字符串进行从右侧开始分割，返回分割后的数组 # E: incompatible type
np.char.rpartition(AR_S, "a") # 使用分隔符 "a" 对 AR_S 中的每个字节串进行从右侧开始分割，返回分割后的数组 # E: incompatible type
np.char.replace(AR_U, b"_", b"-") # 将 AR_U 中的每个字符串中的 b"_" 替换为 b"-"，返回替换后的数组 # E: incompatible type
np.char.replace(AR_S, "_", "-") # 将 AR_S 中的每个字节串中的 "_" 替换为 "-"，返回替换后的数组 # E: incompatible type
np.char.split(AR_U, b"_") # 使用分隔符 b"_" 对 AR_U 中的每个字符串进行分割，返回分割后的数组 # E: incompatible type
np.char.split(AR_S, "_") # 使用分隔符 "_" 对 AR_S 中的每个字节串进行分割，返回分割后的数组 # E: incompatible type
np.char.rsplit(AR_U, b"_") # 使用分隔符 b"_" 对 AR_U 中的每个字符串进行从右侧开始分割，返回分割后的数组 # E: incompatible type
np.char.rsplit(AR_S, "_") # 使用分隔符 "_" 对 AR_S 中的每个字节串进行从右侧开始分割，返回分割后的数组 # E: incompatible type
np.char.count(AR_U, b"a", start=[1, 2, 3]) # 计算 AR_U 中的每个字符串中字符 b"a" 的出现次数，从指定位置 [1, 2, 3] 开始计数 # E: incompatible type
np.char.count(AR_S, "a", end=9) # 计算 AR_S 中的每个字节串中字符 "a" 的出现次数，直到指定位置 9 结束计数 # E: incompatible type
np.char.endswith(AR_U, b"a", start=[1, 2, 3]) # 检查 AR_U 中的每个字符串是否以字符 b"a" 结尾，从指定位置 [1, 2, 3] 开始检查 # E: incompatible type
np.char.endswith(AR_S, "a", end=9) # 检查 AR_S 中的每个字节串是否以字符 "a" 结尾，直到指定位置 9 结束检查 # E: incompatible type
np.char.startswith(AR_U, b"a", start=[1, 2, 3]) # 检查 AR_U 中的每个字符串是否以字符 b"a" 开头，从指定位置 [1, 2, 3] 开始检查 # E: incompatible type
np.char.startswith(AR_S, "a", end=9) # 检查 AR_S 中的每个字节串是否以字符 "a" 开头，直到指定位置 9 结束检查 # E: incompatible type
np.char.find(AR_U, b"a", start=[1, 2, 3]) # 在 AR_U 中的每个字符串中查找字符 b"a"，从指定位置 [1, 2, 3] 开始查找，返回找到的第一个位置索引 # E: incompatible type
np.char.find(AR_S, "a", end=9) # 在 AR_S 中的每个字节串中查找字符 "a"，直到指定位置 9 结束查找，
.\numpy\numpy\typing\tests\data\fail\chararray.pyi
import numpy as np
from typing import Any
# 定义一个类型为 np.char.chararray 的变量 AR_U，元素类型为 np.str_
AR_U: np.char.chararray[Any, np.dtype[np.str_]]
# 定义一个类型为 np.char.chararray 的变量 AR_S，元素类型为 np.bytes_
AR_S: np.char.chararray[Any, np.dtype[np.bytes_]]
# 对 AR_S 进行编码操作，但使用了无效的 self 参数
AR_S.encode() # E: Invalid self argument
# 对 AR_U 进行解码操作，但使用了无效的 self 参数
AR_U.decode() # E: Invalid self argument
# 尝试将 AR_U 中的每个元素用 b"_" 连接，但类型不兼容
AR_U.join(b"_") # E: incompatible type
# 尝试将 AR_S 中的每个元素用 "_" 连接，但类型不兼容
AR_S.join("_") # E: incompatible type
# 在 AR_U 中的每个元素右侧填充字符 b"a"，长度为 5，但类型不兼容
AR_U.ljust(5, fillchar=b"a") # E: incompatible type
# 在 AR_S 中的每个元素右侧填充字符 "a"，长度为 5，但类型不兼容
AR_S.ljust(5, fillchar="a") # E: incompatible type
# 在 AR_U 中的每个元素左侧填充字符 b"a"，长度为 5，但类型不兼容
AR_U.rjust(5, fillchar=b"a") # E: incompatible type
# 在 AR_S 中的每个元素左侧填充字符 "a"，长度为 5，但类型不兼容
AR_S.rjust(5, fillchar="a") # E: incompatible type
# 移除 AR_U 中的每个元素左侧的字符 b"a"，但类型不兼容
AR_U.lstrip(chars=b"a") # E: incompatible type
# 移除 AR_S 中的每个元素左侧的字符 "a"，但类型不兼容
AR_S.lstrip(chars="a") # E: incompatible type
# 移除 AR_U 中的每个元素两侧的字符 b"a"，但类型不兼容
AR_U.strip(chars=b"a") # E: incompatible type
# 移除 AR_S 中的每个元素两侧的字符 "a"，但类型不兼容
AR_S.strip(chars="a") # E: incompatible type
# 移除 AR_U 中的每个元素右侧的字符 b"a"，但类型不兼容
AR_U.rstrip(chars=b"a") # E: incompatible type
# 移除 AR_S 中的每个元素右侧的字符 "a"，但类型不兼容
AR_S.rstrip(chars="a") # E: incompatible type
# 在 AR_U 中的每个元素中寻找第一个出现的 b"a"，但类型不兼容
AR_U.partition(b"a") # E: incompatible type
# 在 AR_S 中的每个元素中寻找第一个出现的 "a"，但类型不兼容
AR_S.partition("a") # E: incompatible type
# 在 AR_U 中的每个元素中寻找最后一个出现的 b"a"，但类型不兼容
AR_U.rpartition(b"a") # E: incompatible type
# 在 AR_S 中的每个元素中寻找最后一个出现的 "a"，但类型不兼容
AR_S.rpartition("a") # E: incompatible type
# 将 AR_U 中的每个元素中的 b"_" 替换为 b"-"，但类型不兼容
AR_U.replace(b"_", b"-") # E: incompatible type
# 将 AR_S 中的每个元素中的 "_" 替换为 "-"，但类型不兼容
AR_S.replace("_", "-") # E: incompatible type
# 使用 b"_" 将 AR_U 中的每个元素分割，但类型不兼容
AR_U.split(b"_") # E: incompatible type
# 使用 "_" 将 AR_S 中的每个元素分割，但类型不兼容
AR_S.split("_") # E: incompatible type
# 尝试使用整数 1 将 AR_S 中的每个元素分割，但类型不兼容
AR_S.split(1) # E: incompatible type
# 使用 b"_" 将 AR_U 中的每个元素从右侧开始分割，但类型不兼容
AR_U.rsplit(b"_") # E: incompatible type
# 使用 "_" 将 AR_S 中的每个元素从右侧开始分割，但类型不兼容
AR_S.rsplit("_") # E: incompatible type
# 统计 AR_U 中每个元素中出现的 b"a" 的数量，但类型不兼容
AR_U.count(b"a", start=[1, 2, 3]) # E: incompatible type
# 统计 AR_S 中每个元素中出现的 "a" 的数量，但类型不兼容
AR_S.count("a", end=9) # E: incompatible type
# 检查 AR_U 中每个元素是否以 b"a" 结尾，但类型不兼容
AR_U.endswith(b"a", start=[1, 2, 3]) # E: incompatible type
# 检查 AR_S 中每个元素是否以 "a" 结尾，但类型不兼容
AR_S.endswith("a", end=9) # E: incompatible type
# 检查 AR_U 中每个元素是否以 b"a" 开头，但类型不兼容
AR_U.startswith(b"a", start=[1, 2, 3]) # E: incompatible type
# 检查 AR_S 中每个元素是否以 "a" 开头，但类型不兼容
AR_S.startswith("a", end=9) # E: incompatible type
# 查找 AR_U 中每个元素中第一次出现 b"a" 的位置，但类型不兼容
AR_U.find(b"a", start=[1, 2, 3]) # E: incompatible type
# 查找 AR_S 中每个元素中第一次出现 "a" 的位置，但类型不兼容
AR_S.find("a", end=9) # E: incompatible type
# 查找 AR_U 中每个元素中最后一次出现 b"a" 的位置，但类型不兼容
AR_U.rfind(b"a", start=[1, 2, 3]) # E: incompatible type
# 查找 AR_S 中每个元素中最后一次出现 "a" 的位置，但类型不兼容
AR_S.rfind("a", end=9) # E: incompatible type
# 查找 AR_U 是否等于 AR_S，但操作数类型不支持
AR_U == AR_S # E: Unsupported operand types
# 查找 AR_U 是否不等于 AR_S，但操作数类型不支持
AR_U != AR_S # E: Unsupported operand types
# 查找 AR_U 是否大于等于 AR_S，但操作数类型不支持
AR_U >= AR_S # E: Unsupported operand types
# 查找 AR_U 是否小于等于 AR_S，但操作数类型不支持
AR_U <= AR_S # E: Unsupported operand types
# 查找 AR_U 是否大于 AR_S，但操作数类型不支持
AR_U > AR_S # E: Unsupported operand types
# 查找 AR_U 是否小于 AR_S，但操作数类型不支持
AR_U < AR_S # E: Unsupported operand types
.\numpy\numpy\typing\tests\data\fail\comparisons.pyi
# 导入 NumPy 库，并引入 NumPy 类型注解模块
import numpy as np
import numpy.typing as npt
# 定义不同类型的 NumPy 数组变量，分别注解为特定的数据类型
AR_i: npt.NDArray[np.int64] # 整型数组，元素为 np.int64 类型
AR_f: npt.NDArray[np.float64] # 浮点型数组，元素为 np.float64 类型
AR_c: npt.NDArray[np.complex128] # 复数型数组，元素为 np.complex128 类型
AR_m: npt.NDArray[np.timedelta64] # 时间间隔数组，元素为 np.timedelta64 类型
AR_M: npt.NDArray[np.datetime64] # 日期时间数组，元素为 np.datetime64 类型
# 下面的表达式均会引发错误，因为这些 NumPy 数组类型之间的比较不受支持
AR_f > AR_m # E: Unsupported operand types
AR_c > AR_m # E: Unsupported operand types
AR_m > AR_f # E: Unsupported operand types
AR_m > AR_c # E: Unsupported operand types
AR_i > AR_M # E: Unsupported operand types
AR_f > AR_M # E: Unsupported operand types
AR_m > AR_M # E: Unsupported operand types
AR_M > AR_i # E: Unsupported operand types
AR_M > AR_f # E: Unsupported operand types
AR_M > AR_m # E: Unsupported operand types
# 下面的表达式均会引发错误，因为无法将整数或字节串与这些 NumPy 数组类型之一进行比较
AR_i > str() # E: No overload variant
AR_i > bytes() # E: No overload variant
str() > AR_M # E: Unsupported operand types
bytes() > AR_M # E: Unsupported operand types
.\numpy\numpy\typing\tests\data\fail\constants.pyi
# 导入 NumPy 库，用于科学计算和数组操作
import numpy as np
# 尝试修改 NumPy 的 little_endian 属性，但是 little_endian 是不可修改的，因此会引发错误
np.little_endian = np.little_endian # E: Cannot assign to final
.\numpy\numpy\typing\tests\data\fail\datasource.pyi
# 导入 Path 类从 pathlib 模块，导入 numpy 模块中的 np 对象
from pathlib import Path
import numpy as np
# 声明变量 path，类型为 Path
path: Path
# 声明变量 d1，类型为 numpy 中的 DataSource 类
d1: np.lib.npyio.DataSource
# 调用 d1 对象的 abspath 方法，传入 path 参数，返回类型不兼容的错误
d1.abspath(path) # E: incompatible type
# 再次调用 d1 对象的 abspath 方法，传入字节字符串参数，返回类型不兼容的错误
d1.abspath(b"...") # E: incompatible type
# 调用 d1 对象的 exists 方法，传入 path 参数，返回类型不兼容的错误
d1.exists(path) # E: incompatible type
# 再次调用 d1 对象的 exists 方法，传入字节字符串参数，返回类型不兼容的错误
d1.exists(b"...") # E: incompatible type
# 调用 d1 对象的 open 方法，传入 path 和 "r" 参数，返回类型不兼容的错误
d1.open(path, "r") # E: incompatible type
# 再次调用 d1 对象的 open 方法，传入字节字符串参数和 encoding 参数，返回类型不兼容的错误
d1.open(b"...", encoding="utf8") # E: incompatible type
# 再次调用 d1 对象的 open 方法，传入 None 和 newline 参数，返回类型不兼容的错误
d1.open(None, newline="/n") # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\dtype.pyi
import numpy as np # 导入 numpy 库
class Test1: # 定义类 Test1
not_dtype = np.dtype(float) # 定义类属性 not_dtype，其类型为 numpy 的 float 数据类型
class Test2: # 定义类 Test2
dtype = float # 定义类属性 dtype，其类型为 Python 的 float 类型
np.dtype(Test1()) # 创建 Test1 类的实例，并尝试将其传递给 np.dtype() 函数，此处报错 E: No overload variant of "dtype" matches
np.dtype(Test2()) # 创建 Test2 类的实例，并尝试将其传递给 np.dtype() 函数，此处报错 E: incompatible type
np.dtype( # 创建一个 numpy 数据类型对象，包含两个字段的描述
{
"field1": (float, 1), # 字段 "field1"，类型为 float，长度为 1
"field2": (int, 3), # 字段 "field2"，类型为 int，长度为 3
}
) # 此处报错 E: No overload variant of "dtype" matches
.\numpy\numpy\typing\tests\data\fail\einsumfunc.pyi
import numpy as np # 导入 NumPy 库，用于科学计算
import numpy.typing as npt # 导入 NumPy 类型注解模块，用于类型提示
AR_i: npt.NDArray[np.int64] # 定义 AR_i 为 np.int64 类型的 NumPy 数组
AR_f: npt.NDArray[np.float64] # 定义 AR_f 为 np.float64 类型的 NumPy 数组
AR_m: npt.NDArray[np.timedelta64] # 定义 AR_m 为 np.timedelta64 类型的 NumPy 数组
AR_U: npt.NDArray[np.str_] # 定义 AR_U 为 np.str_ 类型的 NumPy 数组
np.einsum("i,i->i", AR_i, AR_m) # E: 不兼容的类型。执行 Einstein 求和，但 AR_m 的类型不兼容。
np.einsum("i,i->i", AR_f, AR_f, dtype=np.int32) # E: 不兼容的类型。执行 Einstein 求和，但 AR_f 的类型不兼容。
np.einsum("i,i->i", AR_i, AR_i, out=AR_U) # E: "einsum" 函数的类型变量 "_ArrayType" 的值无法确定。
np.einsum("i,i->i", AR_i, AR_i, out=AR_U, casting="unsafe") # E: 没有匹配的重载变体。执行 Einstein 求和，并指定了不安全的类型转换。
.\numpy\numpy\typing\tests\data\fail\false_positives.pyi
`
# 导入 numpy 库并简化为 np，提供高效的数组操作功能
import numpy as np
# 导入 numpy.typing 模块中的 npt，用于在类型提示中使用 numpy 数组类型
import numpy.typing as npt
# 定义一个 numpy 数组类型的别名 AR_f8，元素类型为 np.float64
AR_f8: npt.NDArray[np.float64]
# NOTE: Mypy bug presumable due to the special-casing of heterogeneous tuples;
# xref numpy/numpy#20901
#
# NOTE: 由于 Mypy 的一个 bug 可能是由于对异构元组的特殊处理；
# xref numpy/numpy#20901
#
# 预期的输出应该与使用列表而不是元组时没有区别
# np.concatenate 用于连接数组，第一个参数是一个包含单个整数 1 的列表，第二个参数是 AR_f8 数组
np.concatenate(([1], AR_f8)) # E: Argument 1 to "concatenate" has incompatible type
.\numpy\numpy\typing\tests\data\fail\flatiter.pyi
from typing import Any
import numpy as np
import numpy._typing as npt
class Index:
def __index__(self) -> int:
...
# 定义一个类型为 flatiter 的变量 a，其元素类型为 float64 的 numpy 数组的迭代器类型
a: np.flatiter[npt.NDArray[np.float64]]
# 定义一个支持传递数组的类型变量 supports_array
supports_array: npt._SupportsArray[np.dtype[np.float64]]
# 尝试给属性赋值会引发错误，因为 flatiter 的属性 base、coords 和 index 是只读的
a.base = Any # E: Property "base" defined in "flatiter" is read-only
a.coords = Any # E: Property "coords" defined in "flatiter" is read-only
a.index = Any # E: Property "index" defined in "flatiter" is read-only
# 调用 flatiter 的 copy 方法，传递了一个不期望的关键字参数 'order'
a.copy(order='C') # E: Unexpected keyword argument
# 注意：与 `ndarray.__getitem__` 不同，`flatiter` 的对应方法不接受具有 `__array__` 或 `__index__` 协议的对象；
# 布尔索引是有问题的（gh-17175）
# 下面的三行尝试使用布尔索引、Index 类型的对象和 supports_array 进行索引，但都引发错误
a[np.bool()] # E: No overload variant of "__getitem__"
a[Index()] # E: No overload variant of "__getitem__"
a[supports_array] # E: No overload variant of "__getitem__"
.\numpy\numpy\typing\tests\data\fail\fromnumeric.pyi
"""Tests for :mod:`numpy._core.fromnumeric`."""
# 导入 numpy 库，并使用类型定义模块 numpy.typing
import numpy as np
import numpy.typing as npt
# 创建一个布尔类型的 2 维数组 A
A = np.array(True, ndmin=2, dtype=bool)
# 设置数组 A 为不可写
A.setflags(write=False)
# 定义一个类型为 np.str_ 的 numpy 数组 AR_U
AR_U: npt.NDArray[np.str_]
# 创建一个布尔类型的标量数组 a
a = np.bool(True)
# 调用 np.take 函数，尝试取出标量数组 a 的元素，但未指定索引位置，导致类型错误
np.take(a, None) # E: No overload variant
# 调用 np.take 函数，尝试在轴上使用浮点数索引，导致类型错误
np.take(a, axis=1.0) # E: No overload variant
# 调用 np.take 函数，尝试将结果输出到整数 1，导致类型错误
np.take(A, out=1) # E: No overload variant
# 调用 np.take 函数，尝试在模式中使用字符串 "bob"，导致类型错误
np.take(A, mode="bob") # E: No overload variant
# 调用 np.reshape 函数，尝试使用 None 作为新形状，导致类型错误
np.reshape(a, None) # E: No overload variant
# 调用 np.reshape 函数，尝试指定新形状为 1，并使用字符串 "bob" 作为排序顺序，导致类型错误
np.reshape(A, 1, order="bob") # E: No overload variant
# 调用 np.choose 函数，尝试使用 None 作为索引数组，导致类型错误
np.choose(a, None) # E: No overload variant
# 调用 np.choose 函数，尝试将结果输出到浮点数 1.0，导致类型错误
np.choose(a, out=1.0) # E: No overload variant
# 调用 np.choose 函数，尝试在模式中使用字符串 "bob"，导致类型错误
np.choose(A, mode="bob") # E: No overload variant
# 调用 np.repeat 函数，尝试使用 None 作为重复次数，导致类型错误
np.repeat(a, None) # E: No overload variant
# 调用 np.repeat 函数，尝试在轴上使用浮点数 1.0 作为重复次数，导致类型错误
np.repeat(A, 1, axis=1.0) # E: No overload variant
# 调用 np.swapaxes 函数，尝试使用 None 作为一个轴，导致类型错误
np.swapaxes(A, None, 1) # E: No overload variant
# 调用 np.swapaxes 函数，尝试在轴上使用整数 1 和列表 [0]，导致类型错误
np.swapaxes(A, 1, [0]) # E: No overload variant
# 调用 np.transpose 函数，尝试在轴参数中使用浮点数 1.0，导致类型错误
np.transpose(A, axes=1.0) # E: No overload variant
# 调用 np.partition 函数，尝试使用 None 作为分区索引，导致类型错误
np.partition(a, None) # E: No overload variant
# 调用 np.partition 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.partition(
a, 0, axis="bob"
)
# 调用 np.partition 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.partition(
A, 0, kind="bob"
)
# 调用 np.partition 函数，尝试在 order 参数中使用 range(5)，导致类型错误
np.partition(
A, 0, order=range(5) # E: Argument "order" to "partition" has incompatible type
)
# 调用 np.argpartition 函数，尝试使用 None 作为分区索引，导致类型错误
np.argpartition(
a, None # E: incompatible type
)
# 调用 np.argpartition 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.argpartition(
a, 0, axis="bob" # E: incompatible type
)
# 调用 np.argpartition 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.argpartition(
A, 0, kind="bob" # E: incompatible type
)
# 调用 np.argpartition 函数，尝试在 order 参数中使用 range(5)，导致类型错误
np.argpartition(
A, 0, order=range(5) # E: Argument "order" to "argpartition" has incompatible type
)
# 调用 np.sort 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.sort(A, axis="bob") # E: No overload variant
# 调用 np.sort 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.sort(A, kind="bob") # E: No overload variant
# 调用 np.sort 函数，尝试在 order 参数中使用 range(5)，导致类型错误
np.sort(A, order=range(5)) # E: Argument "order" to "sort" has incompatible type
# 调用 np.argsort 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.argsort(A, axis="bob") # E: Argument "axis" to "argsort" has incompatible type
# 调用 np.argsort 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.argsort(A, kind="bob") # E: Argument "kind" to "argsort" has incompatible type
# 调用 np.argsort 函数，尝试在 order 参数中使用 range(5)，导致类型错误
np.argsort(A, order=range(5)) # E: Argument "order" to "argsort" has incompatible type
# 调用 np.argmax 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.argmax(A, axis="bob") # E: No overload variant of "argmax" matches argument type
# 调用 np.argmax 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.argmax(A, kind="bob") # E: No overload variant of "argmax" matches argument type
# 调用 np.argmin 函数，尝试在轴参数中使用字符串 "bob"，导致类型错误
np.argmin(A, axis="bob") # E: No overload variant of "argmin" matches argument type
# 调用 np.argmin 函数，尝试在 kind 参数中使用字符串 "bob"，导致类型错误
np.argmin(A, kind="bob") # E: No overload variant of "argmin" matches argument type
# 调用 np.searchsorted 函数，尝试在 side 参数中使用字符串 "bob"，导致类型错误
np.searchsorted(
A[0], 0, side="bob"
)
# 调用 np.searchsorted 函数，尝试在 sorter 参数中使用浮点数 1.0，导致类型错误
np.searchsorted(
A[0], 0, sorter=1.0
)
# 调用 np.resize 函数，尝试在新形状参数中使用浮点数 1.0，导致类型错误
np.resize(A, 1.0) # E: No overload variant
# 调用 np.squeeze 函数，尝试在轴参数中使用浮点数 1.0，导致类型错误
np.squeeze(A, 1.0) # E: No overload variant of "squeeze" matches argument type
# 调用 np.diagonal 函数，尝试在 offset 参数中使用 None，导致类型错误
np.diagonal(A, offset=None) # E: No overload variant
# 调用 np.diagonal 函数，尝试在 axis1 参数中使用字符串 "bob"，导致类型错误
np.diagonal(A, axis
# 创建一个包含单个元素True的列表
[True],
# A 是一个变量或对象，用于某种计算或操作
A,
# axis 参数设置为 1.0，可能指定某些操作在特定轴上进行
axis=1.0
np.clip(a, 1, 2, out=1) # E: No overload variant of "clip" matches argument type
# 将数组 a 中的元素限制在 [1, 2] 的范围内，并将结果写入数组 out 中，但指定的输出参数类型不匹配
np.sum(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的元素和，但指定的轴参数类型不匹配
np.sum(a, keepdims=1.0) # E: No overload variant
# 计算数组 a 的元素和，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.sum(a, initial=[1]) # E: No overload variant
# 计算数组 a 的元素和，但指定的 initial 参数类型不匹配
np.all(a, axis=1.0) # E: No overload variant
# 检查数组 a 沿指定轴的所有元素是否都为 True，但指定的轴参数类型不匹配
np.all(a, keepdims=1.0) # E: No overload variant
# 检查数组 a 的所有元素是否都为 True，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.all(a, out=1.0) # E: No overload variant
# 检查数组 a 的所有元素是否都为 True，但指定的输出参数类型不匹配
np.any(a, axis=1.0) # E: No overload variant
# 检查数组 a 沿指定轴的任一元素是否为 True，但指定的轴参数类型不匹配
np.any(a, keepdims=1.0) # E: No overload variant
# 检查数组 a 的任一元素是否为 True，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.any(a, out=1.0) # E: No overload variant
# 检查数组 a 的任一元素是否为 True，但指定的输出参数类型不匹配
np.cumsum(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的累积和，但指定的轴参数类型不匹配
np.cumsum(a, dtype=1.0) # E: No overload variant
# 计算数组 a 的累积和，但指定的 dtype 参数类型不匹配
np.cumsum(a, out=1.0) # E: No overload variant
# 计算数组 a 的累积和，但指定的输出参数类型不匹配
np.ptp(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的最大值和最小值之差，但指定的轴参数类型不匹配
np.ptp(a, keepdims=1.0) # E: No overload variant
# 计算数组 a 的最大值和最小值之差，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.ptp(a, out=1.0) # E: No overload variant
# 计算数组 a 的最大值和最小值之差，但指定的输出参数类型不匹配
np.amax(a, axis=1.0) # E: No overload variant
# 返回数组 a 沿指定轴的最大值，但指定的轴参数类型不匹配
np.amax(a, keepdims=1.0) # E: No overload variant
# 返回数组 a 的最大值，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.amax(a, out=1.0) # E: No overload variant
# 返回数组 a 的最大值，但指定的输出参数类型不匹配
np.amax(a, initial=[1.0]) # E: No overload variant
# 返回数组 a 的最大值，但指定的 initial 参数类型不匹配
np.amax(a, where=[1.0]) # E: incompatible type
# 返回数组 a 的最大值，但指定的 where 参数类型不匹配
np.amin(a, axis=1.0) # E: No overload variant
# 返回数组 a 沿指定轴的最小值，但指定的轴参数类型不匹配
np.amin(a, keepdims=1.0) # E: No overload variant
# 返回数组 a 的最小值，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.amin(a, out=1.0) # E: No overload variant
# 返回数组 a 的最小值，但指定的输出参数类型不匹配
np.amin(a, initial=[1.0]) # E: No overload variant
# 返回数组 a 的最小值，但指定的 initial 参数类型不匹配
np.amin(a, where=[1.0]) # E: incompatible type
# 返回数组 a 的最小值，但指定的 where 参数类型不匹配
np.prod(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的元素乘积，但指定的轴参数类型不匹配
np.prod(a, out=False) # E: No overload variant
# 计算数组 a 的元素乘积，但指定的输出参数类型不匹配
np.prod(a, keepdims=1.0) # E: No overload variant
# 计算数组 a 的元素乘积，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.prod(a, initial=int) # E: No overload variant
# 计算数组 a 的元素乘积，但指定的 initial 参数类型不匹配
np.prod(a, where=1.0) # E: No overload variant
# 计算数组 a 的元素乘积，但指定的 where 参数类型不匹配
np.prod(AR_U) # E: incompatible type
# 计算数组 AR_U 的元素乘积，但输入的数组类型不匹配
np.cumprod(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的累积乘积，但指定的轴参数类型不匹配
np.cumprod(a, out=False) # E: No overload variant
# 计算数组 a 的累积乘积，但指定的输出参数类型不匹配
np.cumprod(AR_U) # E: incompatible type
# 计算数组 AR_U 的累积乘积，但输入的数组类型不匹配
np.size(a, axis=1.0) # E: Argument "axis" to "size" has incompatible type
# 返回数组 a 沿指定轴的元素个数，但指定的轴参数类型不匹配
np.around(a, decimals=1.0) # E: No overload variant
# 将数组 a 中的元素四舍五入到指定的小数位数，但指定的 decimals 参数类型不匹配
np.around(a, out=type) # E: No overload variant
# 将数组 a 中的元素四舍五入，但指定的输出参数类型不匹配
np.around(AR_U) # E: incompatible type
# 将数组 AR_U 中的元素四舍五入，但输入的数组类型不匹配
np.mean(a, axis=1.0) # E: No overload variant
# 计算数组 a 沿指定轴的均值，但指定的轴参数类型不匹配
np.mean(a, out=False) # E: No overload variant
# 计算数组 a 的均值，但指定的输出参数类型不匹配
np.mean(a, keepdims=1.0) # E: No overload variant
# 计算数组 a 的均值，并保持输入数组的维度，但指定的 keepdims 参数类型不匹配
np.mean(AR_U) # E: incompatible type
# 计算数组 AR_U 的均值，但输入的数组类型
.\numpy\numpy\typing\tests\data\fail\histograms.pyi
import numpy as np # 导入NumPy库，通常用np作为别名
import numpy.typing as npt # 导入NumPy类型定义模块，用于类型提示
AR_i8: npt.NDArray[np.int64] # 声明AR_i8为一个NumPy数组，其中元素类型为np.int64
AR_f8: npt.NDArray[np.float64] # 声明AR_f8为一个NumPy数组，其中元素类型为np.float64
np.histogram_bin_edges(AR_i8, range=(0, 1, 2)) # 计算AR_i8的直方图边缘值，但类型不兼容
np.histogram(AR_i8, range=(0, 1, 2)) # 计算AR_i8的直方图，但类型不兼容
np.histogramdd(AR_i8, range=(0, 1)) # 计算AR_i8的多维直方图，但类型不兼容
np.histogramdd(AR_i8, range=[(0, 1, 2)]) # 计算AR_i8的多维直方图，但类型不兼容
.\numpy\numpy\typing\tests\data\fail\index_tricks.pyi
import numpy as np # 导入 NumPy 库，用于科学计算
AR_LIKE_i: list[int] # 定义 AR_LIKE_i 为整数类型的列表
AR_LIKE_f: list[float] # 定义 AR_LIKE_f 为浮点数类型的列表
np.ndindex([1, 2, 3]) # E: No overload variant
# 使用 np.ndindex() 函数创建一个迭代器，遍历给定维度下的所有索引组合
np.unravel_index(AR_LIKE_f, (1, 2, 3)) # E: incompatible type
# 使用 np.unravel_index() 函数将平坦索引或数组转换为多维索引，但 AR_LIKE_f 类型不兼容
np.ravel_multi_index(AR_LIKE_i, (1, 2, 3), mode="bob") # E: No overload variant
# 使用 np.ravel_multi_index() 函数将多维索引转换为平坦索引，但参数或模式不匹配
np.mgrid[1] # E: Invalid index type
# 使用 np.mgrid[] 生成一个多维网格，但索引类型无效
np.mgrid[...] # E: Invalid index type
# 使用 np.mgrid[] 生成一个多维网格，但索引类型无效
np.ogrid[1] # E: Invalid index type
# 使用 np.ogrid[] 生成一个单轴网格，但索引类型无效
np.ogrid[...] # E: Invalid index type
# 使用 np.ogrid[] 生成一个单轴网格，但索引类型无效
np.fill_diagonal(AR_LIKE_f, 2) # E: incompatible type
# 使用 np.fill_diagonal() 函数将对角线元素填充为指定值，但 AR_LIKE_f 类型不兼容
np.diag_indices(1.0) # E: incompatible type
# 使用 np.diag_indices() 函数返回指定形状数组的对角线索引，但参数类型不兼容
.\numpy\numpy\typing\tests\data\fail\lib_function_base.pyi
from typing import Any
import numpy as np
import numpy.typing as npt
# 声明不同数据类型的数组变量
AR_f8: npt.NDArray[np.float64]
AR_c16: npt.NDArray[np.complex128]
AR_m: npt.NDArray[np.timedelta64]
AR_M: npt.NDArray[np.datetime64]
AR_O: npt.NDArray[np.object_]
# 定义一个空函数 func，参数为整数，无返回值
def func(a: int) -> None: ...
# 计算 AR_m 数组的平均值，但存在类型不兼容的错误
np.average(AR_m) # E: incompatible type
# 在 AR_f8 数组中选择元素，但存在类型不兼容的错误
np.select(1, [AR_f8]) # E: incompatible type
# 计算 AR_m 数组的角度，但存在类型不兼容的错误
np.angle(AR_m) # E: incompatible type
# 对 AR_m 数组进行解包，但存在类型不兼容的错误
np.unwrap(AR_m) # E: incompatible type
# 对 AR_c16 数组进行解包，但存在类型不兼容的错误
np.unwrap(AR_c16) # E: incompatible type
# 对整数值进行去零处理，但存在类型不兼容的错误
np.trim_zeros(1) # E: incompatible type
# 在整数值中应用条件替换，但存在类型不兼容的错误
np.place(1, [True], 1.5) # E: incompatible type
# 创建一个对整数进行向量化的函数，但存在类型不兼容的错误
np.vectorize(1) # E: incompatible type
# 在 AR_f8 数组的切片位置插入值 5，但存在类型不兼容的错误
np.place(AR_f8, slice(None), 5) # E: incompatible type
# 使用插值计算 AR_f8 和 AR_c16 数组之间的插值，但存在类型不兼容的错误
np.interp(AR_f8, AR_c16, AR_f8) # E: incompatible type
# 使用插值计算 AR_c16 和 AR_f8 数组之间的插值，但存在类型不兼容的错误
np.interp(AR_c16, AR_f8, AR_f8) # E: incompatible type
# 使用插值计算 AR_f8 和 AR_O 数组之间的插值，但存在类型不兼容的错误
np.interp(AR_f8, AR_f8, AR_O) # E: incompatible type
# 计算 AR_m 数组的协方差，但存在类型不兼容的错误
np.cov(AR_m) # E: incompatible type
# 计算 AR_O 数组的协方差，但存在类型不兼容的错误
np.cov(AR_O) # E: incompatible type
# 计算 AR_m 数组的相关系数，但存在类型不兼容的错误
np.corrcoef(AR_m) # E: incompatible type
# 计算 AR_O 数组的相关系数，但存在类型不兼容的错误
np.corrcoef(AR_O) # E: incompatible type
# 计算 AR_f8 数组相关系数时，指定了不支持的参数，不存在匹配的重载变体
np.corrcoef(AR_f8, bias=True) # E: No overload variant
# 计算 AR_f8 数组相关系数时，指定了不支持的参数，不存在匹配的重载变体
np.corrcoef(AR_f8, ddof=2) # E: No overload variant
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.blackman(1j) # E: incompatible type
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.bartlett(1j) # E: incompatible type
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.hanning(1j) # E: incompatible type
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.hamming(1j) # E: incompatible type
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.hamming(AR_c16) # E: incompatible type
# 创建复数数列时使用了不兼容的参数，存在类型不兼容的错误
np.kaiser(1j, 1) # E: incompatible type
# 在 AR_O 数组上应用 sinc 函数，但存在类型不兼容的错误
np.sinc(AR_O) # E: incompatible type
# 计算 AR_M 数组的中位数，但存在类型不兼容的错误
np.median(AR_M) # E: incompatible type
# 计算 AR_f8 数组百分位数时，使用了不兼容的参数，不存在匹配的重载变体
np.percentile(AR_f8, 50j) # E: No overload variant
# 计算 AR_f8 数组百分位数时，使用了不兼容的参数，不存在匹配的重载变体
np.percentile(AR_f8, 50, interpolation="bob") # E: No overload variant
# 计算 AR_f8 数组分位数时，使用了不兼容的参数，不存在匹配的重载变体
np.quantile(AR_f8, 0.5j) # E: No overload variant
# 计算 AR_f8 数组分位数时，使用了不兼容的参数，不存在匹配的重载变体
np.quantile(AR_f8, 0.5, interpolation="bob") # E: No overload variant
# 创建网格时使用了不兼容的参数，存在类型不兼容的错误
np.meshgrid(AR_f8, AR_f8, indexing="bob") # E: incompatible type
# 在 AR_f8 数组中删除 AR_f8 数组的元素，但存在类型不兼容的错误
np.delete(AR_f8, AR_f8) # E: incompatible type
# 在 AR_f8 数组中插入元素 AR_f8，但存在类型不兼容的错误
np.insert(AR_f8, AR_f8, 1.5) # E: incompatible type
# 在 AR_f8 数组中执行数位化操作时使用了不兼容的参数，不存在匹配的重载变体
np.digitize(AR_f8, 1j) # E: No overload variant
.\numpy\numpy\typing\tests\data\fail\lib_polynomial.pyi
import numpy as np # 导入NumPy库，用于科学计算
import numpy.typing as npt # 导入NumPy的类型标注模块，用于类型注解
AR_f8: npt.NDArray[np.float64] # AR_f8是一个NumPy数组，包含np.float64类型的元素
AR_c16: npt.NDArray[np.complex128] # AR_c16是一个NumPy数组，包含np.complex128类型的元素
AR_O: npt.NDArray[np.object_] # AR_O是一个NumPy数组，包含np.object_类型的元素
AR_U: npt.NDArray[np.str_] # AR_U是一个NumPy数组，包含np.str_类型的元素
poly_obj: np.poly1d # poly_obj是一个NumPy多项式对象
np.polymul(AR_f8, AR_U) # E: 不兼容的类型错误，尝试对AR_f8和AR_U进行多项式乘法
np.polydiv(AR_f8, AR_U) # E: 不兼容的类型错误，尝试对AR_f8和AR_U进行多项式除法
5**poly_obj # E: 没有匹配的重载变体，尝试对5和poly_obj进行乘方运算
np.polyint(AR_U) # E: 不兼容的类型错误，尝试对AR_U进行多项式积分
np.polyint(AR_f8, m=1j) # E: 没有匹配的重载变体，尝试对AR_f8进行多项式积分，使用复数1j作为参数
np.polyder(AR_U) # E: 不兼容的类型错误，尝试对AR_U进行多项式求导
np.polyder(AR_f8, m=1j) # E: 没有匹配的重载变体，尝试对AR_f8进行多项式求导，使用复数1j作为参数
np.polyfit(AR_O, AR_f8, 1) # E: 不兼容的类型错误，尝试使用AR_O和AR_f8进行多项式拟合
np.polyfit(AR_f8, AR_f8, 1, rcond=1j) # E: 没有匹配的重载变体，尝试使用AR_f8和AR_f8进行多项式拟合，使用复数rcond=1j作为参数
np.polyfit(AR_f8, AR_f8, 1, w=AR_c16) # E: 不兼容的类型错误，尝试使用AR_f8和AR_f8进行多项式拟合，使用AR_c16作为权重参数
np.polyfit(AR_f8, AR_f8, 1, cov="bob") # E: 没有匹配的重载变体，尝试使用AR_f8和AR_f8进行多项式拟合，使用字符串"bob"作为cov参数
np.polyval(AR_f8, AR_U) # E: 不兼容的类型错误，尝试对AR_f8和AR_U进行多项式求值
np.polyadd(AR_f8, AR_U) # E: 不兼容的类型错误，尝试对AR_f8和AR_U进行多项式加法
np.polysub(AR_f8, AR_U) # E: 不兼容的类型错误，尝试对AR_f8和AR_U进行多项式减法
.\numpy\numpy\typing\tests\data\fail\lib_utils.pyi
# 导入 numpy 库中的 array_utils 模块，用于处理数组相关的实用工具
import numpy.lib.array_utils as array_utils
# 调用 array_utils 模块中的 byte_bounds 函数，传入参数 1，返回其字节边界
array_utils.byte_bounds(1) # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\lib_version.pyi
# 从 numpy.lib 模块中导入 NumpyVersion 类
from numpy.lib import NumpyVersion
# 声明一个变量 version，类型为 NumpyVersion
version: NumpyVersion
# 创建一个 NumpyVersion 对象，传入字节字符串 b"1.8.0"，表示 numpy 的版本号为 1.8.0
NumpyVersion(b"1.8.0") # E: incompatible type
# 检查 version 对象是否大于或等于字节字符串 b"1.8.0"，由于版本号与字节字符串比较，导致不支持的操作类型错误
version >= b"1.8.0" # E: Unsupported operand types
.\numpy\numpy\typing\tests\data\fail\linalg.pyi
import numpy as np # 导入 NumPy 库
AR_f8: npt.NDArray[np.float64] # 定义 AR_f8 变量，类型为 NumPy 的 float64 类型数组
AR_O: npt.NDArray[np.object_] # 定义 AR_O 变量，类型为 NumPy 的 object 类型数组
AR_M: npt.NDArray[np.datetime64] # 定义 AR_M 变量，类型为 NumPy 的 datetime64 类型数组
np.linalg.tensorsolve(AR_O, AR_O) # 调用 NumPy 的 tensorsolve 函数，求解张量方程，但类型不兼容
np.linalg.solve(AR_O, AR_O) # 调用 NumPy 的 solve 函数，求解线性方程组，但类型不兼容
np.linalg.tensorinv(AR_O) # 调用 NumPy 的 tensorinv 函数，计算张量的逆，但类型不兼容
np.linalg.inv(AR_O) # 调用 NumPy 的 inv 函数，计算方阵的逆，但类型不兼容
np.linalg.matrix_power(AR_M, 5) # 调用 NumPy 的 matrix_power 函数，计算矩阵的整数次幂，但类型不兼容
np.linalg.cholesky(AR_O) # 调用 NumPy 的 cholesky 函数，计算正定矩阵的 Cholesky 分解，但类型不兼容
np.linalg.qr(AR_O) # 调用 NumPy 的 qr 函数，计算矩阵的 QR 分解，但类型不兼容
np.linalg.qr(AR_f8, mode="bob") # 调用 NumPy 的 qr 函数，但没有符合的重载变体
np.linalg.eigvals(AR_O) # 调用 NumPy 的 eigvals 函数，计算方阵的特征值，但类型不兼容
np.linalg.eigvalsh(AR_O) # 调用 NumPy 的 eigvalsh 函数，计算实对称或复共轭对称矩阵的特征值，但类型不兼容
np.linalg.eigvalsh(AR_O, UPLO="bob") # 调用 NumPy 的 eigvalsh 函数，但没有符合的重载变体
np.linalg.eig(AR_O) # 调用 NumPy 的 eig 函数，计算方阵的特征值和特征向量，但类型不兼容
np.linalg.eigh(AR_O) # 调用 NumPy 的 eigh 函数，计算实对称或复共轭对称矩阵的特征值和特征向量，但类型不兼容
np.linalg.eigh(AR_O, UPLO="bob") # 调用 NumPy 的 eigh 函数，但没有符合的重载变体
np.linalg.svd(AR_O) # 调用 NumPy 的 svd 函数，计算矩阵的奇异值分解，但类型不兼容
np.linalg.cond(AR_O) # 调用 NumPy 的 cond 函数，计算矩阵的条件数，但类型不兼容
np.linalg.cond(AR_f8, p="bob") # 调用 NumPy 的 cond 函数，但没有符合的重载变体
np.linalg.matrix_rank(AR_O) # 调用 NumPy 的 matrix_rank 函数，计算矩阵的秩，但类型不兼容
np.linalg.pinv(AR_O) # 调用 NumPy 的 pinv 函数，计算矩阵的伪逆，但类型不兼容
np.linalg.slogdet(AR_O) # 调用 NumPy 的 slogdet 函数，计算矩阵的符号和对数行列式的值，但类型不兼容
np.linalg.det(AR_O) # 调用 NumPy 的 det 函数，计算矩阵的行列式，但类型不兼容
np.linalg.norm(AR_f8, ord="bob") # 调用 NumPy 的 norm 函数，但没有符合的重载变体
np.linalg.multi_dot([AR_M]) # 调用 NumPy 的 multi_dot 函数，计算多个数组的点积，但类型不兼容
.\numpy\numpy\typing\tests\data\fail\memmap.pyi
import numpy as np # 导入 NumPy 库，用于科学计算和数组操作
with open("file.txt", "r") as f:
np.memmap(f) # 尝试使用 NumPy 创建一个内存映射，但是参数不足，缺少必要的内存映射对象大小或者 dtype
np.memmap("test.txt", shape=[10, 5]) # 尝试创建一个新的内存映射对象，映射到文件 "test.txt"，但是缺少必要的 dtype 参数，因此报错 "No overload variant"
.\numpy\numpy\typing\tests\data\fail\modules.pyi
import numpy as np # 导入 NumPy 库，使用 np 作为别名
np.testing.bob # E: Module has no attribute，尝试访问 np.testing 模块中的 bob 属性，但该属性不存在
np.bob # E: Module has no attribute，尝试访问 np 模块中的 bob 属性，但该属性不存在
# Stdlib modules in the namespace by accident
np.warnings # E: Module has no attribute，尝试访问 np 模块中的 warnings 模块，但该模块不存在
np.sys # E: Module has no attribute，尝试访问 np 模块中的 sys 模块，但该模块不存在
np.os # E: Module "numpy" does not explicitly export，尝试访问 np 模块中的 os 模块，NumPy 不显式导出该模块
np.math # E: Module has no attribute，尝试访问 np 模块中的 math 模块，但该模块不存在
# Public sub-modules that are not imported to their parent module by default;
# e.g. one must first execute `import numpy.lib.recfunctions`
np.lib.recfunctions # E: Module has no attribute，尝试访问 np.lib 模块中的 recfunctions 模块，但该模块不存在
np.__NUMPY_SETUP__ # E: Module has no attribute，尝试访问 np 模块中的 __NUMPY_SETUP__ 属性，但该属性不存在
np.__deprecated_attrs__ # E: Module has no attribute，尝试访问 np 模块中的 __deprecated_attrs__ 属性，但该属性不存在
np.__expired_functions__ # E: Module has no attribute，尝试访问 np 模块中的 __expired_functions__ 属性，但该属性不存在
.\numpy\numpy\typing\tests\data\fail\multiarray.pyi
import numpy as np # 导入 NumPy 库
i8: np.int64 # 定义别名 i8 为 np.int64
AR_b: npt.NDArray[np.bool] # 定义 AR_b 为布尔类型的 NumPy 数组
AR_u1: npt.NDArray[np.uint8] # 定义 AR_u1 为无符号 8 位整数类型的 NumPy 数组
AR_i8: npt.NDArray[np.int64] # 定义 AR_i8 为有符号 64 位整数类型的 NumPy 数组
AR_f8: npt.NDArray[np.float64] # 定义 AR_f8 为双精度浮点数类型的 NumPy 数组
AR_M: npt.NDArray[np.datetime64] # 定义 AR_M 为日期时间类型的 NumPy 数组
M: np.datetime64 # 定义 M 为日期时间类型的 NumPy 对象
AR_LIKE_f: list[float] # 定义 AR_LIKE_f 为浮点数列表
def func(a: int) -> None: ... # 定义一个函数 func，接收一个整数参数 a，无返回值
np.where(AR_b, 1) # 使用 np.where 函数，根据条件 AR_b 返回 1 的索引位置
np.can_cast(AR_f8, 1) # 检查是否可以将 AR_f8 类型转换为整数 1
np.vdot(AR_M, AR_M) # 计算 AR_M 和 AR_M 的向量点积
np.copyto(AR_LIKE_f, AR_f8) # 将 AR_f8 的值复制到 AR_LIKE_f，要求类型兼容
np.putmask(AR_LIKE_f, [True, True, False], 1.5) # 根据掩码修改 AR_LIKE_f 中的值
np.packbits(AR_f8) # 将 AR_f8 中的数据打包为位字段
np.packbits(AR_u1, bitorder=">") # 将 AR_u1 中的数据按大端顺序打包为位字段
np.unpackbits(AR_i8) # 解包 AR_i8 中的位字段为数组
np.unpackbits(AR_u1, bitorder=">") # 按大端顺序解包 AR_u1 中的位字段为数组
np.shares_memory(1, 1, max_work=i8) # 检查两个对象是否共享内存，设置最大工作大小为 i8
np.may_share_memory(1, 1, max_work=i8) # 检查两个对象是否可能共享内存，设置最大工作大小为 i8
np.arange(M) # 创建从 0 开始到 M-1 的整数数组
np.arange(stop=10) # 创建一个从 0 到 9 的整数数组
np.datetime_data(int) # 获取整数类型的日期时间数据
np.busday_offset("2012", 10) # 计算从 "2012" 开始的第 10 个工作日的日期
np.datetime_as_string("2012") # 将日期时间 "2012" 转换为字符串表示形式
np.char.compare_chararrays("a", b"a", "==", False) # 比较两个字符数组是否相等，不考虑大小写
np.nested_iters([AR_i8, AR_i8]) # 创建嵌套迭代器，传入数组列表，但缺少位置参数
np.nested_iters([AR_i8, AR_i8], 0) # 创建嵌套迭代器，但类型不兼容
np.nested_iters([AR_i8, AR_i8], [0]) # 创建嵌套迭代器，但类型不兼容
np.nested_iters([AR_i8, AR_i8], [[0], [1]], flags=["test"]) # 创建嵌套迭代器，但类型不兼容
np.nested_iters([AR_i8, AR_i8], [[0], [1]], op_flags=[["test"]]) # 创建嵌套迭代器，但类型不兼容
np.nested_iters([AR_i8, AR_i8], [[0], [1]], buffersize=1.0) # 创建嵌套迭代器，但类型不兼容
.\numpy\numpy\typing\tests\data\fail\ndarray.pyi
# 导入 NumPy 库
import numpy as np
# 禁止设置 dtype，因为直接在原地改变数组的类型会使得 ndarray 无法泛化到不同的 dtype。
# 通常情况下，用户应该在这种情况下使用 `ndarray.view`。详细信息请参见：
#
# https://github.com/numpy/numpy-stubs/issues/7
#
# 获取一个包含单个浮点数的 NumPy 数组
float_array = np.array([1.0])
# 尝试设置数组的 dtype 为布尔型，但是因为 ndarray 的 dtype 是只读属性，所以会引发错误。
float_array.dtype = np.bool # E: Property "dtype" defined in "ndarray" is read-only
.\numpy\numpy\typing\tests\data\fail\ndarray_misc.pyi
"""
Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
More extensive tests are performed for the methods'
function-based counterpart in `../from_numeric.py`.
"""
import numpy as np # 导入 NumPy 库
import numpy.typing as npt # 导入 NumPy 的类型注解模块
f8: np.float64 # 声明一个类型为 np.float64 的变量 f8
AR_f8: npt.NDArray[np.float64] # 声明一个 np.float64 类型的 NumPy 数组 AR_f8
AR_M: npt.NDArray[np.datetime64] # 声明一个 np.datetime64 类型的 NumPy 数组 AR_M
AR_b: npt.NDArray[np.bool] # 声明一个 np.bool 类型的 NumPy 数组 AR_b
ctypes_obj = AR_f8.ctypes # 获取 AR_f8 数组的 ctypes 对象
reveal_type(ctypes_obj.get_data()) # E: has no attribute
reveal_type(ctypes_obj.get_shape()) # E: has no attribute
reveal_type(ctypes_obj.get_strides()) # E: has no attribute
reveal_type(ctypes_obj.get_as_parameter()) # E: has no attribute
f8.argpartition(0) # E: has no attribute
f8.diagonal() # E: has no attribute
f8.dot(1) # E: has no attribute
f8.nonzero() # E: has no attribute
f8.partition(0) # E: has no attribute
f8.put(0, 2) # E: has no attribute
f8.setfield(2, np.float64) # E: has no attribute
f8.sort() # E: has no attribute
f8.trace() # E: has no attribute
AR_M.__int__() # E: Invalid self argument
AR_M.__float__() # E: Invalid self argument
AR_M.__complex__() # E: Invalid self argument
AR_b.__index__() # E: Invalid self argument
AR_f8[1.5] # E: No overload variant
AR_f8["field_a"] # E: No overload variant
AR_f8[["field_a", "field_b"]] # E: Invalid index type
AR_f8.__array_finalize__(object()) # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\nditer.pyi
import numpy as np # 导入 NumPy 库
class Test(np.nditer): ... # E: 无法继承自 final 类
np.nditer([0, 1], flags=["test"]) # E: 类型不兼容，flags 应为整数或者空列表
np.nditer([0, 1], op_flags=[["test"]]) # E: 类型不兼容，op_flags 应为整数
np.nditer([0, 1], itershape=(1.0,)) # E: 类型不兼容，itershape 应为整数元组
np.nditer([0, 1], buffersize=1.0) # E: 类型不兼容，buffersize 应为整数
.\numpy\numpy\typing\tests\data\fail\nested_sequence.pyi
# 导入Sequence抽象基类，用于声明序列类型变量
from collections.abc import Sequence
# 导入_NestedSequence类型变量，这是一个内部类型，用于声明嵌套序列
from numpy._typing import _NestedSequence
# 声明变量a为Sequence类型，元素为float类型的序列
a: Sequence[float]
# 声明变量b为列表类型，元素为complex复数类型的列表
b: list[complex]
# 声明变量c为元组类型，包含不可变的str类型元素
c: tuple[str, ...]
# 声明变量d为整数类型
d: int
# 声明变量e为字符串类型
e: str
# 定义函数func，接受_NestedSequence类型的整数序列参数，返回空值
def func(a: _NestedSequence[int]) -> None:
...
# 使用reveal_type函数分别输出func函数对各变量类型的推断，预期会显示类型不兼容的错误信息
reveal_type(func(a)) # E: incompatible type
reveal_type(func(b)) # E: incompatible type
reveal_type(func(c)) # E: incompatible type
reveal_type(func(d)) # E: incompatible type
reveal_type(func(e)) # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\npyio.pyi
import pathlib # 导入pathlib模块，用于处理路径
from typing import IO # 导入IO类型，用于类型注解
import numpy.typing as npt # 导入numpy的类型注解模块
import numpy as np # 导入numpy库，用于科学计算
str_path: str # 声明str_path为字符串类型
bytes_path: bytes # 声明bytes_path为字节类型
pathlib_path: pathlib.Path # 声明pathlib_path为pathlib.Path类型
str_file: IO[str] # 声明str_file为文本IO对象，内容为字符串类型
AR_i8: npt.NDArray[np.int64] # 声明AR_i8为numpy的int64类型的数组
np.load(str_file) # E: incompatible type # 载入文件到numpy数组，但str_file的类型不兼容
np.save(bytes_path, AR_i8) # E: incompatible type # 将数组AR_i8保存到字节路径bytes_path，但类型不兼容
np.savez(bytes_path, AR_i8) # E: incompatible type # 将数组AR_i8保存为未压缩的字节格式文件，但类型不兼容
np.savez_compressed(bytes_path, AR_i8) # E: incompatible type # 将数组AR_i8保存为压缩的字节格式文件，但类型不兼容
np.loadtxt(bytes_path) # E: incompatible type # 从字节路径bytes_path加载数据到numpy数组，但类型不兼容
np.fromregex(bytes_path, ".", np.int64) # E: No overload variant # 使用正则表达式从字节路径bytes_path中加载数据到int64类型的numpy数组，但没有匹配的重载版本
.\numpy\numpy\typing\tests\data\fail\numerictypes.pyi
# 导入 numpy 库，并将其重命名为 np
import numpy as np
# 使用 numpy 库中的函数 np.isdtype() 检查参数是否是指定数据类型 np.int64
np.isdtype(1, np.int64) # E: incompatible type
# 使用 numpy 库中的函数 np.issubdtype() 检查参数是否是指定数据类型 np.int64 的子类型
np.issubdtype(1, np.int64) # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\random.pyi
import numpy as np # 导入 NumPy 库
SEED_FLOAT: float = 457.3 # 浮点型种子值
SEED_ARR_FLOAT: npt.NDArray[np.float64] = np.array([1.0, 2, 3, 4]) # 浮点型 NumPy 数组种子值
SEED_ARRLIKE_FLOAT: list[float] = [1.0, 2.0, 3.0, 4.0] # 类似数组的浮点型列表种子值
SEED_SEED_SEQ: np.random.SeedSequence = np.random.SeedSequence(0) # NumPy 随机数种子序列对象
SEED_STR: str = "String seeding not allowed" # 字符串类型的种子值，不被允许
# 默认的随机数生成器
np.random.default_rng(SEED_FLOAT) # E: 不兼容的类型
np.random.default_rng(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.default_rng(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.default_rng(SEED_STR) # E: 不兼容的类型
# 种子序列对象
np.random.SeedSequence(SEED_FLOAT) # E: 不兼容的类型
np.random.SeedSequence(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.SeedSequence(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.SeedSequence(SEED_SEED_SEQ) # E: 不兼容的类型
np.random.SeedSequence(SEED_STR) # E: 不兼容的类型
seed_seq: np.random.bit_generator.SeedSequence = np.random.SeedSequence() # BitGenerator 类型的种子序列对象
seed_seq.spawn(11.5) # E: 不兼容的类型
seed_seq.generate_state(3.14) # E: 不兼容的类型
seed_seq.generate_state(3, np.uint8) # E: 不兼容的类型
seed_seq.generate_state(3, "uint8") # E: 不兼容的类型
seed_seq.generate_state(3, "u1") # E: 不兼容的类型
seed_seq.generate_state(3, np.uint16) # E: 不兼容的类型
seed_seq.generate_state(3, "uint16") # E: 不兼容的类型
seed_seq.generate_state(3, "u2") # E: 不兼容的类型
seed_seq.generate_state(3, np.int32) # E: 不兼容的类型
seed_seq.generate_state(3, "int32") # E: 不兼容的类型
seed_seq.generate_state(3, "i4") # E: 不兼容的类型
# 比特生成器
np.random.MT19937(SEED_FLOAT) # E: 不兼容的类型
np.random.MT19937(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.MT19937(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.MT19937(SEED_STR) # E: 不兼容的类型
np.random.PCG64(SEED_FLOAT) # E: 不兼容的类型
np.random.PCG64(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.PCG64(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.PCG64(SEED_STR) # E: 不兼容的类型
np.random.Philox(SEED_FLOAT) # E: 不兼容的类型
np.random.Philox(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.Philox(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.Philox(SEED_STR) # E: 不兼容的类型
np.random.SFC64(SEED_FLOAT) # E: 不兼容的类型
np.random.SFC64(SEED_ARR_FLOAT) # E: 不兼容的类型
np.random.SFC64(SEED_ARRLIKE_FLOAT) # E: 不兼容的类型
np.random.SFC64(SEED_STR) # E: 不兼容的类型
# 生成器
np.random.Generator(None) # E: 不兼容的类型
np.random.Generator(12333283902830213) # E: 不兼容的类型
np.random.Generator("OxFEEDF00D") # E: 不兼容的类型
np.random.Generator([123, 234]) # E: 不兼容的类型
np.random.Generator(np.array([123, 234], dtype="u4")) # E: 不兼容的类型
.\numpy\numpy\typing\tests\data\fail\rec.pyi
import numpy as np # 导入 NumPy 库
AR_i8: npt.NDArray[np.int64] # 声明一个类型为 int64 的 NumPy 数组类型标注
np.rec.fromarrays(1) # E: No overload variant
np.rec.fromarrays([1, 2, 3], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
# 使用 np.rec.fromarrays() 函数尝试创建结构化数组，但提供的参数没有合适的重载变体
np.rec.fromrecords(AR_i8) # E: incompatible type
np.rec.fromrecords([(1.5,)], dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
# 使用 np.rec.fromrecords() 函数尝试创建结构化数组，但提供的参数类型不兼容或没有合适的重载变体
np.rec.fromstring("string", dtype=[("f8", "f8")]) # E: No overload variant
np.rec.fromstring(b"bytes") # E: No overload variant
np.rec.fromstring(b"(1.5,)", dtype=[("f8", "f8")], formats=["f8", "f8"]) # E: No overload variant
# 使用 np.rec.fromstring() 函数尝试从字符串或字节串创建结构化数组，但提供的参数没有合适的重载变体
with open("test", "r") as f:
np.rec.fromfile(f, dtype=[("f8", "f8")]) # E: No overload variant
# 使用 np.rec.fromfile() 函数尝试从文件中读取数据创建结构化数组，但提供的参数没有合适的重载变体
.\numpy\numpy\typing\tests\data\fail\scalars.pyi
import sys # 导入sys模块，用于系统相关的操作
import numpy as np # 导入numpy库，并使用np作为别名
f2: np.float16 # 声明f2为numpy的float16类型
f8: np.float64 # 声明f8为numpy的float64类型
c8: np.complex64 # 声明c8为numpy的complex64类型
# Construction
np.float32(3j) # E: incompatible type # 创建一个复数常量3j，但无法转换为np.float32类型
# Technically the following examples are valid NumPy code. But they
# are not considered a best practice, and people who wish to use the
# stubs should instead do
#
# np.array([1.0, 0.0, 0.0], dtype=np.float32)
# np.array([], dtype=np.complex64)
#
# See e.g. the discussion on the mailing list
#
# https://mail.python.org/pipermail/numpy-discussion/2020-April/080566.html
#
# and the issue
#
# https://github.com/numpy/numpy-stubs/issues/41
#
# for more context.
np.float32([1.0, 0.0, 0.0]) # E: incompatible type # 创建一个包含浮点数的numpy数组，但无法转换为np.float32类型
np.complex64([]) # E: incompatible type # 创建一个空的numpy复数数组，但无法转换为np.complex64类型
np.complex64(1, 2) # E: Too many arguments # 创建一个复数，但传递了太多的参数
# TODO: protocols (can't check for non-existent protocols w/ __getattr__)
np.datetime64(0) # E: No overload variant # 尝试创建一个datetime64类型的对象，但没有匹配的重载变体
class A:
def __float__(self):
return 1.0
np.int8(A()) # E: incompatible type # 将A类实例转换为np.int8类型，但类型不兼容
np.int16(A()) # E: incompatible type # 将A类实例转换为np.int16类型，但类型不兼容
np.int32(A()) # E: incompatible type # 将A类实例转换为np.int32类型，但类型不兼容
np.int64(A()) # E: incompatible type # 将A类实例转换为np.int64类型，但类型不兼容
np.uint8(A()) # E: incompatible type # 将A类实例转换为np.uint8类型，但类型不兼容
np.uint16(A()) # E: incompatible type # 将A类实例转换为np.uint16类型，但类型不兼容
np.uint32(A()) # E: incompatible type # 将A类实例转换为np.uint32类型，但类型不兼容
np.uint64(A()) # E: incompatible type # 将A类实例转换为np.uint64类型，但类型不兼容
np.void("test") # E: No overload variant # 创建一个void类型对象，但没有匹配的重载变体
np.void("test", dtype=None) # E: No overload variant # 创建一个void类型对象，但没有匹配的重载变体
np.generic(1) # E: Cannot instantiate abstract class # 尝试实例化抽象类generic，但无法实现
np.number(1) # E: Cannot instantiate abstract class # 尝试实例化抽象类number，但无法实现
np.integer(1) # E: Cannot instantiate abstract class # 尝试实例化抽象类integer，但无法实现
np.inexact(1) # E: Cannot instantiate abstract class # 尝试实例化抽象类inexact，但无法实现
np.character("test") # E: Cannot instantiate abstract class # 尝试实例化抽象类character，但无法实现
np.flexible(b"test") # E: Cannot instantiate abstract class # 尝试实例化抽象类flexible，但无法实现
np.float64(value=0.0) # E: Unexpected keyword argument # 创建一个float64类型对象，但提供了意外的关键字参数
np.int64(value=0) # E: Unexpected keyword argument # 创建一个int64类型对象，但提供了意外的关键字参数
np.uint64(value=0) # E: Unexpected keyword argument # 创建一个uint64类型对象，但提供了意外的关键字参数
np.complex128(value=0.0j) # E: Unexpected keyword argument # 创建一个complex128类型对象，但提供了意外的关键字参数
np.str_(value='bob') # E: No overload variant # 创建一个str_类型对象，但没有匹配的重载变体
np.bytes_(value=b'test') # E: No overload variant # 创建一个bytes_类型对象，但没有匹配的重载变体
np.void(value=b'test') # E: No overload variant # 创建一个void类型对象，但没有匹配的重载变体
np.bool(value=True) # E: Unexpected keyword argument # 创建一个bool类型对象，但提供了意外的关键字参数
np.datetime64(value="2019") # E: No overload variant # 创建一个datetime64类型对象，但没有匹配的重载变体
np.timedelta64(value=0) # E: Unexpected keyword argument # 创建一个timedelta64类型对象，但提供了意外的关键字参数
np.bytes_(b"hello", encoding='utf-8') # E: No overload variant # 创建一个指定编码的bytes_类型对象，但没有匹配的重载变体
np.str_("hello", encoding='utf-8') # E: No overload variant # 创建一个指定编码的str_类型对象，但没有匹配的重载变体
f8.item(1) # E: incompatible type # 获取f8对象的第1个元素，但类型不兼容
f8.item((0, 1)) # E: incompatible type # 获取f8对象指定位置的元素，但类型不兼容
f8.squeeze(axis=1) # E: incompatible type # 对f8对象进行压缩操作，但轴的类型不兼容
f8.squeeze(axis=(0, 1)) # E: incompatible type # 对f8对象进行压缩操作，但轴的类型不兼容
f8.transpose(1) # E: incompatible type # 对f8对象进行转置操作，但参数的类型不兼容
def func(a: np.float32) -> None: ... # 定义一个函数func，接受一个np.float32类型参数，并返回None
func(f2) # E: incompatible type # 调用func函数，传递f2作为参数，但类型不兼容
func(f8) # E: incompatible type # 调用func函数，传递f8作为参数，但类型不兼容
round(c8) # E: No overload variant # 对c8对象进行四舍五入操作，但没有匹配的重载变体
c8.__getnewargs__() # E: Invalid self argument # 调用c8对象的__getnewargs__方法，但self参数无效
f2.__getnewargs__() # E: Invalid self argument # 调用f2对象的__getnewargs__方法，但self参数无效
f2.hex() # E: Invalid self argument # 调用f2对象的hex方法，但self参数无效
np.float16.fromhex("0x0.0p+0") # E: Invalid self argument # 调用np.float16的fromhex静态方法，但self参数无效
f2.__trunc__() # E: Invalid self argument # 调用f2对象的__trunc__方法，但self参数无效
f2.__getformat__("float") # E: Invalid self argument # 调用f2对象的__getformat__方法，但self参数无效
.\numpy\numpy\typing\tests\data\fail\shape_base.pyi
import numpy as np # 导入 numpy 库
class DTypeLike: # 定义类 DTypeLike
dtype: np.dtype[np.int_] # 类属性 dtype，指定为 np.int_ 类型的 numpy 数据类型
dtype_like: DTypeLike # 定义变量 dtype_like，类型为 DTypeLike 类的实例
np.expand_dims(dtype_like, (5, 10)) # 使用 numpy 函数 expand_dims 对变量 dtype_like 进行维度扩展，传入参数 (5, 10)，出现错误 "E: No overload variant"
.\numpy\numpy\typing\tests\data\fail\stride_tricks.pyi
import numpy as np
import numpy.typing as npt
# 导入 numpy 库以及 numpy.typing 模块，npt.NDArray 表示 numpy 数组的类型提示
AR_f8: npt.NDArray[np.float64]
# 定义一个类型为 np.float64 的 numpy 数组 AR_f8
np.lib.stride_tricks.as_strided(AR_f8, shape=8)
# 使用 numpy 的 stride_tricks 模块中的 as_strided 函数，尝试使用 shape 参数，但未找到匹配的重载变体
np.lib.stride_tricks.as_strided(AR_f8, strides=8)
# 使用 numpy 的 stride_tricks 模块中的 as_strided 函数，尝试使用 strides 参数，但未找到匹配的重载变体
np.lib.stride_tricks.sliding_window_view(AR_f8, axis=(1,))
# 使用 numpy 的 stride_tricks 模块中的 sliding_window_view 函数，尝试使用 axis 参数，但未找到匹配的重载变体
.\numpy\numpy\typing\tests\data\fail\strings.pyi
import numpy as np # 导入 NumPy 库，通常用 np 作为别名
AR_U: npt.NDArray[np.str_] # 定义一个类型为字符串的 NumPy 数组 AR_U
AR_S: npt.NDArray[np.bytes_] # 定义一个类型为字节字符串的 NumPy 数组 AR_S
np.strings.equal(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 和 AR_S 是否相等，返回布尔值，可能引发类型不匹配错误
np.strings.not_equal(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 和 AR_S 是否不相等，返回布尔值，可能引发类型不匹配错误
np.strings.greater_equal(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 是否大于等于 AR_S，返回布尔值，可能引发类型不匹配错误
np.strings.less_equal(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 是否小于等于 AR_S，返回布尔值，可能引发类型不匹配错误
np.strings.greater(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 是否大于 AR_S，返回布尔值，可能引发类型不匹配错误
np.strings.less(AR_U, AR_S) # 调用 NumPy 中的字符串比较函数，比较 AR_U 是否小于 AR_S，返回布尔值，可能引发类型不匹配错误
np.strings.encode(AR_S) # 调用 NumPy 中的字符串编码函数，尝试将 AR_S 中的元素编码为字节串，可能引发类型不匹配错误
np.strings.decode(AR_U) # 调用 NumPy 中的字符串解码函数，尝试将 AR_U 中的元素解码为字符串，可能引发类型不匹配错误
np.strings.join(AR_U, b"_") # 调用 NumPy 中的字符串连接函数，使用 b"_" 将 AR_U 中的元素连接起来，可能引发类型不匹配错误
np.strings.join(AR_S, "_") # 调用 NumPy 中的字符串连接函数，使用 "_" 将 AR_S 中的元素连接起来，可能引发类型不匹配错误
np.strings.ljust(AR_U, 5, fillchar=b"a") # 调用 NumPy 中的字符串左对齐函数，使用 b"a" 将 AR_U 中的元素左对齐填充至长度 5，可能引发类型不匹配错误
np.strings.ljust(AR_S, 5, fillchar="a") # 调用 NumPy 中的字符串左对齐函数，使用 "a" 将 AR_S 中的元素左对齐填充至长度 5，可能引发类型不匹配错误
np.strings.rjust(AR_U, 5, fillchar=b"a") # 调用 NumPy 中的字符串右对齐函数，使用 b"a" 将 AR_U 中的元素右对齐填充至长度 5，可能引发类型不匹配错误
np.strings.rjust(AR_S, 5, fillchar="a") # 调用 NumPy 中的字符串右对齐函数，使用 "a" 将 AR_S 中的元素右对齐填充至长度 5，可能引发类型不匹配错误
np.strings.lstrip(AR_U, b"a") # 调用 NumPy 中的字符串左移除函数，移除 AR_U 中开头的 b"a"，可能引发类型不匹配错误
np.strings.lstrip(AR_S, "a") # 调用 NumPy 中的字符串左移除函数，移除 AR_S 中开头的 "a"，可能引发类型不匹配错误
np.strings.strip(AR_U, b"a") # 调用 NumPy 中的字符串移除函数，移除 AR_U 中首尾的 b"a"，可能引发类型不匹配错误
np.strings.strip(AR_S, "a") # 调用 NumPy 中的字符串移除函数，移除 AR_S 中首尾的 "a"，可能引发类型不匹配错误
np.strings.rstrip(AR_U, b"a") # 调用 NumPy 中的字符串右移除函数，移除 AR_U 中结尾的 b"a"，可能引发类型不匹配错误
np.strings.rstrip(AR_S, "a") # 调用 NumPy 中的字符串右移除函数，移除 AR_S 中结尾的 "a"，可能引发类型不匹配错误
np.strings.partition(AR_U, b"a") # 调用 NumPy 中的字符串分割函数，使用 b"a" 分割 AR_U，可能引发类型不匹配错误
np.strings.partition(AR_S, "a") # 调用 NumPy 中的字符串分割函数，使用 "a" 分割 AR_S，可能引发类型不匹配错误
np.strings.rpartition(AR_U, b"a") # 调用 NumPy 中的字符串反向分割函数，使用 b"a" 反向分割 AR_U，可能引发类型不匹配错误
np.strings.rpartition(AR_S, "a") # 调用 NumPy 中的字符串反向分割函数，使用 "a" 反向分割 AR_S，可能引发类型不匹配错误
np.strings.split(AR_U, b"_") # 调用 NumPy 中的字符串分割函数，使用 b"_" 分割 AR_U，可能引发类型不匹配错误
np.strings.split(AR_S, "_") # 调用 NumPy 中的字符串分割函数，使用 "_" 分割 AR_S，可能引发类型不匹配错误
np.strings.rsplit(AR_U, b"_") # 调用 NumPy 中的字符串反向分割函数，使用 b"_" 反向分割 AR_U，可能引发类型不匹配错误
np.strings.rsplit(AR_S, "_") # 调用 NumPy 中的字符串反向分割函数，使用 "_" 反向分割 AR_S，可能引发类型不匹配错误
np.strings.count(AR_U, b"a", [1, 2, 3], [1, 2, 3]) # 调用 NumPy 中的字符串计数函数，计算 AR_U 中包含 b"a" 的个数，可能引发类型不匹配错误
np.strings.count(AR_S, "a", 0, 9) # 调用 NumPy 中的字符串计数函数，计算 AR_S 中包含 "a" 的个数，可能引发类型不匹配错误
np.strings.endswith(AR_U, b"a", [1, 2, 3], [1, 2, 3]) # 调用 NumPy 中的字符串结束匹配函数，判断 AR_U 是否以 b"a" 结束，可能引发类型不匹配错误
np.strings.endswith(AR_S, "a", 0, 9) # 调用 NumPy 中的字符串结束匹配函数，判断 AR_S 是否以 "a" 结束，可能引发类型不匹配错误
np.strings.startswith(AR_U, b"a", [1, 2, 3], [1, 2, 3]) # 调用 NumPy 中的字符串开始匹配函数，判断 AR_U 是否以 b"a" 开始，可能引发类型不匹配错误
np.strings.startswith(AR_S, "a", 0, 9) # 调用 NumPy 中的字符串开始匹配函数，判断 AR_S 是否以 "a" 开始，可能引发类型不匹配错误
np.strings.find(AR_U, b"a", [1, 2, 3], [1, 2, 3]) # 调用 NumPy 中的字符串查找函数，查找 AR_U 中 b"a" 的位置，可能引发类型不匹配错误
np.strings.find(AR_S, "a", 0, 9) # 调用 NumPy 中的字符串查找函数，查找 AR_S 中 "a" 的位置，可能引发类型不匹配错误
np.strings.rfind(AR_U, b
.\numpy\numpy\typing\tests\data\fail\testing.pyi
# 导入 NumPy 库，并引入 NumPy 类型注解
import numpy as np
import numpy.typing as npt
# 声明 AR_U 变量，类型为 NumPy 字符串数组
AR_U: npt.NDArray[np.str_]
# 声明一个空函数 func，返回类型为布尔值
def func() -> bool: ...
# 使用 NumPy.testing.assert_ 进行断言，预期为 True，但给出错误信息 1
np.testing.assert_(True, msg=1) # E: incompatible type
# 使用 NumPy.testing.build_err_msg 构建错误消息，给出错误代码 1 和消息 "test"
np.testing.build_err_msg(1, "test") # E: incompatible type
# 使用 NumPy.testing.assert_almost_equal 进行近似相等断言，比较 AR_U 与 AR_U
np.testing.assert_almost_equal(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_approx_equal 进行近似相等断言，比较两个列表 [1, 2, 3] 与 [1, 2, 3]
np.testing.assert_approx_equal([1, 2, 3], [1, 2, 3]) # E: incompatible type
# 使用 NumPy.testing.assert_array_almost_equal 进行数组近似相等断言，比较 AR_U 与 AR_U
np.testing.assert_array_almost_equal(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_array_less 进行数组大小比较断言，比较 AR_U 与 AR_U
np.testing.assert_array_less(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_string_equal 进行字符串相等断言，比较字节串 b"a" 与 b"a"
np.testing.assert_string_equal(b"a", b"a") # E: incompatible type
# 使用 NumPy.testing.assert_raises 断言函数 func 调用会引发 TypeError 异常
np.testing.assert_raises(expected_exception=TypeError, callable=func) # E: No overload variant
# 使用 NumPy.testing.assert_raises_regex 断言函数 func 调用会引发 TypeError 异常，且异常消息匹配 "T"
np.testing.assert_raises_regex(expected_exception=TypeError, expected_regex="T", callable=func) # E: No overload variant
# 使用 NumPy.testing.assert_allclose 进行全部近似相等断言，比较 AR_U 与 AR_U
np.testing.assert_allclose(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_array_almost_equal_nulp 进行数组近似相等断言，比较 AR_U 与 AR_U
np.testing.assert_array_almost_equal_nulp(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_array_max_ulp 进行数组最大误差比较断言，比较 AR_U 与 AR_U
np.testing.assert_array_max_ulp(AR_U, AR_U) # E: incompatible type
# 使用 NumPy.testing.assert_warns 断言函数 func 调用会产生 RuntimeWarning 警告
np.testing.assert_warns(warning_class=RuntimeWarning, func=func) # E: No overload variant
# 使用 NumPy.testing.assert_no_warnings 断言函数 func 调用不会产生任何警告
np.testing.assert_no_warnings(func=func) # E: No overload variant
# 使用 NumPy.testing.assert_no_warnings 断言函数 func 调用不会产生任何警告，但给出了多余的参数 None
np.testing.assert_no_warnings(func, None) # E: Too many arguments
# 使用 NumPy.testing.assert_no_warnings 断言函数 func 调用不会产生任何警告，但提供了未预期的关键字参数 test=None
np.testing.assert_no_warnings(func, test=None) # E: Unexpected keyword argument
# 使用 NumPy.testing.assert_no_gc_cycles 断言函数 func 调用期间没有垃圾回收循环
np.testing.assert_no_gc_cycles(func=func) # E: No overload variant
.\numpy\numpy\typing\tests\data\fail\twodim_base.pyi
# 导入必要的类型和函数
from typing import Any, TypeVar
import numpy as np
import numpy.typing as npt
# 定义一个接受任意类型数组和整数的函数，返回一个字符串类型数组
def func1(ar: npt.NDArray[Any], a: int) -> npt.NDArray[np.str_]:
pass
# 定义一个接受任意类型数组和浮点数的函数，返回一个浮点数
def func2(ar: npt.NDArray[Any], a: float) -> float:
pass
# 定义一个布尔类型的NumPy数组
AR_b: npt.NDArray[np.bool]
# 定义一个时间间隔类型的NumPy数组
AR_m: npt.NDArray[np.timedelta64]
# 定义一个布尔类型的列表
AR_LIKE_b: list[bool]
# 创建一个10x20的单位矩阵，返回错误：没有匹配的函数重载
np.eye(10, M=20.0) # E: No overload variant
# 创建一个10x10的单位矩阵，偏移为2.5，数据类型为整数，返回错误：没有匹配的函数重载
np.eye(10, k=2.5, dtype=int) # E: No overload variant
# 从AR_b创建对角矩阵，偏移为0.5，返回错误：没有匹配的函数重载
np.diag(AR_b, k=0.5) # E: No overload variant
# 从AR_b创建扁平对角矩阵，偏移为0.5，返回错误：没有匹配的函数重载
np.diagflat(AR_b, k=0.5) # E: No overload variant
# 创建一个10x20的下三角矩阵，返回错误：没有匹配的函数重载
np.tri(10, M=20.0) # E: No overload variant
# 创建一个10x10的下三角矩阵，偏移为2.5，数据类型为整数，返回错误：没有匹配的函数重载
np.tri(10, k=2.5, dtype=int) # E: No overload variant
# 从AR_b创建一个下三角矩阵，偏移为0.5，返回错误：没有匹配的函数重载
np.tril(AR_b, k=0.5) # E: No overload variant
# 从AR_b创建一个上三角矩阵，偏移为0.5，返回错误：没有匹配的函数重载
np.triu(AR_b, k=0.5) # E: No overload variant
# 从AR_m创建一个Vandermonde矩阵，返回错误：不兼容的类型
np.vander(AR_m) # E: incompatible type
# 计算AR_m的二维直方图，返回错误：没有匹配的函数重载
np.histogram2d(AR_m) # E: No overload variant
# 使用函数func1计算长度为10的遮罩索引数组，返回错误：不兼容的类型
np.mask_indices(10, func1) # E: incompatible type
# 使用函数func2和参数10.5计算长度为10的遮罩索引数组，返回错误：不兼容的类型
np.mask_indices(10, func2, 10.5) # E: incompatible type
.\numpy\numpy\typing\tests\data\fail\type_check.pyi
import numpy as np # 导入 NumPy 库，使用 np 作为别名
DTYPE_i8: np.dtype[np.int64] # 定义一个类型别名 DTYPE_i8，表示 np.int64 类型
np.mintypecode(DTYPE_i8) # 调用 NumPy 函数 mintypecode，传入 DTYPE_i8，返回类型码，但类型不兼容错误
np.iscomplexobj(DTYPE_i8) # 调用 NumPy 函数 iscomplexobj，传入 DTYPE_i8，检查其是否为复数对象，但类型不兼容错误
np.isrealobj(DTYPE_i8) # 调用 NumPy 函数 isrealobj，传入 DTYPE_i8，检查其是否为实数对象，但类型不兼容错误
np.typename(DTYPE_i8) # 调用 NumPy 函数 typename，传入 DTYPE_i8，返回其类型名称，但未找到匹配的重载变体错误
np.typename("invalid") # 调用 NumPy 函数 typename，传入字符串 "invalid"，但未找到匹配的重载变体错误
np.common_type(np.timedelta64()) # 调用 NumPy 函数 common_type，传入 np.timedelta64 类型，但类型不兼容错误
.\numpy\numpy\typing\tests\data\fail\ufunclike.pyi
import numpy as np # 导入 NumPy 库，约定别名为 np
import numpy.typing as npt # 导入 NumPy 的类型定义模块，约定别名为 npt
AR_c: npt.NDArray[np.complex128] # 定义 AR_c 变量为复数类型的 NumPy 数组
AR_m: npt.NDArray[np.timedelta64] # 定义 AR_m 变量为时间差类型的 NumPy 数组
AR_M: npt.NDArray[np.datetime64] # 定义 AR_M 变量为日期时间类型的 NumPy 数组
AR_O: npt.NDArray[np.object_] # 定义 AR_O 变量为对象类型的 NumPy 数组
np.fix(AR_c) # 调用 NumPy 的 fix 函数，尝试对 AR_c 进行修正，可能会出现类型不兼容的错误
np.fix(AR_m) # 调用 NumPy 的 fix 函数，尝试对 AR_m 进行修正，可能会出现类型不兼容的错误
np.fix(AR_M) # 调用 NumPy 的 fix 函数，尝试对 AR_M 进行修正，可能会出现类型不兼容的错误
np.isposinf(AR_c) # 调用 NumPy 的 isposinf 函数，判断 AR_c 是否为正无穷，可能会出现类型不兼容的错误
np.isposinf(AR_m) # 调用 NumPy 的 isposinf 函数，判断 AR_m 是否为正无穷，可能会出现类型不兼容的错误
np.isposinf(AR_M) # 调用 NumPy 的 isposinf 函数，判断 AR_M 是否为正无穷，可能会出现类型不兼容的错误
np.isposinf(AR_O) # 调用 NumPy 的 isposinf 函数，判断 AR_O 是否为正无穷，可能会出现类型不兼容的错误
np.isneginf(AR_c) # 调用 NumPy 的 isneginf 函数，判断 AR_c 是否为负无穷，可能会出现类型不兼容的错误
np.isneginf(AR_m) # 调用 NumPy 的 isneginf 函数，判断 AR_m 是否为负无穷，可能会出现类型不兼容的错误
np.isneginf(AR_M) # 调用 NumPy 的 isneginf 函数，判断 AR_M 是否为负无穷，可能会出现类型不兼容的错误
np.isneginf(AR_O) # 调用 NumPy 的 isneginf 函数，判断 AR_O 是否为负无穷，可能会出现类型不兼容的错误
.\numpy\numpy\typing\tests\data\fail\ufuncs.pyi
import numpy as np # 导入 NumPy 库
import numpy.typing as npt # 导入 NumPy 的类型注解
AR_f8: npt.NDArray[np.float64] # 定义一个浮点64位类型的 NumPy 数组
np.sin.nin + "foo" # E: Unsupported operand types # 错误：不支持的操作类型，np.sin.nin 不是有效的属性
np.sin(1, foo="bar") # E: No overload variant # 错误：没有匹配的重载变体，np.sin 函数不接受名为 'foo' 的参数
np.abs(None) # E: No overload variant # 错误：没有匹配的重载变体，np.abs 函数不接受 None 作为参数
np.add(1, 1, 1) # E: No overload variant # 错误：没有匹配的重载变体，np.add 函数不接受三个参数的调用方式
np.add(1, 1, axis=0) # E: No overload variant # 错误：没有匹配的重载变体，np.add 函数不接受名为 'axis' 的关键字参数
np.matmul(AR_f8, AR_f8, where=True) # E: No overload variant # 错误：没有匹配的重载变体，np.matmul 函数不接受名为 'where' 的关键字参数
np.frexp(AR_f8, out=None) # E: No overload variant # 错误：没有匹配的重载变体，np.frexp 函数不接受名为 'out' 的关键字参数
np.frexp(AR_f8, out=AR_f8) # E: No overload variant # 错误：没有匹配的重载变体，np.frexp 函数不接受两个参数的调用方式
np.absolute.outer() # E: "None" not callable # 错误："None" 不可调用，np.absolute.outer 不是可调用对象
np.frexp.outer() # E: "None" not callable # 错误："None" 不可调用，np.frexp.outer 不是可调用对象
np.divmod.outer() # E: "None" not callable # 错误："None" 不可调用，np.divmod.outer 不是可调用对象
np.matmul.outer() # E: "None" not callable # 错误："None" 不可调用，np.matmul.outer 不是可调用对象
np.absolute.reduceat() # E: "None" not callable # 错误："None" 不可调用，np.absolute.reduceat 不是可调用对象
np.frexp.reduceat() # E: "None" not callable # 错误："None" 不可调用，np.frexp.reduceat 不是可调用对象
np.divmod.reduceat() # E: "None" not callable # 错误："None" 不可调用，np.divmod.reduceat 不是可调用对象
np.matmul.reduceat() # E: "None" not callable # 错误："None" 不可调用，np.matmul.reduceat 不是可调用对象
np.absolute.reduce() # E: "None" not callable # 错误："None" 不可调用，np.absolute.reduce 不是可调用对象
np.frexp.reduce() # E: "None" not callable # 错误："None" 不可调用，np.frexp.reduce 不是可调用对象
np.divmod.reduce() # E: "None" not callable # 错误："None" 不可调用，np.divmod.reduce 不是可调用对象
np.matmul.reduce() # E: "None" not callable # 错误："None" 不可调用，np.matmul.reduce 不是可调用对象
np.absolute.accumulate() # E: "None" not callable # 错误："None" 不可调用，np.absolute.accumulate 不是可调用对象
np.frexp.accumulate() # E: "None" not callable # 错误："None" 不可调用，np.frexp.accumulate 不是可调用对象
np.divmod.accumulate() # E: "None" not callable # 错误："None" 不可调用，np.divmod.accumulate 不是可调用对象
np.matmul.accumulate() # E: "None" not callable # 错误："None" 不可调用，np.matmul.accumulate 不是可调用对象
np.frexp.at() # E: "None" not callable # 错误："None" 不可调用，np.frexp.at 不是可调用对象
np.divmod.at() # E: "None" not callable # 错误："None" 不可调用，np.divmod.at 不是可调用对象
np.matmul.at() # E: "None" not callable # 错误："None" 不可调用，np.matmul.at 不是可调用对象
.\numpy\numpy\typing\tests\data\fail\ufunc_config.pyi
"""
Typing tests for `numpy._core._ufunc_config`.
"""
# 导入 NumPy 库
import numpy as np
# 定义一个函数 func1，接受一个字符串 a，一个整数 b，一个浮点数 c，返回空值
def func1(a: str, b: int, c: float) -> None: ...
# 定义一个函数 func2，接受一个字符串 a 和一个命名参数 b（必须通过关键字传递），返回空值
def func2(a: str, *, b: int) -> None: ...
# 定义一个类 Write1
class Write1:
# 类 Write1 中的方法 write1，接受一个字符串 a，返回空值
def write1(self, a: str) -> None: ...
# 定义一个类 Write2
class Write2:
# 类 Write2 中的方法 write，接受两个字符串参数 a 和 b，返回空值
def write(self, a: str, b: str) -> None: ...
# 定义一个类 Write3
class Write3:
# 类 Write3 中的方法 write，接受一个命名参数 a（必须通过关键字传递），返回空值
def write(self, *, a: str) -> None: ...
# 调用 NumPy 库中的 seterrcall 函数，传入 func1 函数作为参数，用于处理错误回调
np.seterrcall(func1) # E: Argument 1 to "seterrcall" has incompatible type
# 调用 NumPy 库中的 seterrcall 函数，传入 func2 函数作为参数，用于处理错误回调
np.seterrcall(func2) # E: Argument 1 to "seterrcall" has incompatible type
# 调用 NumPy 库中的 seterrcall 函数，传入 Write1 类的实例作为参数，用于处理错误回调
np.seterrcall(Write1()) # E: Argument 1 to "seterrcall" has incompatible type
# 调用 NumPy 库中的 seterrcall 函数，传入 Write2 类的实例作为参数，用于处理错误回调
np.seterrcall(Write2()) # E: Argument 1 to "seterrcall" has incompatible type
# 调用 NumPy 库中的 seterrcall 函数，传入 Write3 类的实例作为参数，用于处理错误回调
np.seterrcall(Write3()) # E: Argument 1 to "seterrcall" has incompatible type
.\numpy\numpy\typing\tests\data\fail\warnings_and_errors.pyi
import numpy.exceptions as ex
创建一个别名为 ex 的模块，用于导入 numpy 库中的异常类
ex.AxisError(1.0) # 创建一个 AxisError 异常的实例，传递参数 1.0 给构造函数
ex.AxisError(1, ndim=2.0) # 创建一个 AxisError 异常的实例，传递参数 1 给构造函数，并且指定 ndim 参数为 2.0
ex.AxisError(2, msg_prefix=404) # 创建一个 AxisError 异常的实例，传递参数 2 给构造函数，并且指定 msg_prefix 参数为 404
.\numpy\numpy\typing\tests\data\misc\extended_precision.pyi
import sys
# 导入系统模块
import numpy as np
# 导入 NumPy 库，并将其命名为 np
from numpy._typing import _80Bit, _96Bit, _128Bit, _256Bit
# 从 NumPy 的 _typing 模块导入特定的位数类型定义
if sys.version_info >= (3, 11):
# 如果 Python 版本大于等于 3.11，使用标准库中的 assert_type
from typing import assert_type
else:
# 否则使用 typing_extensions 中的 assert_type
from typing_extensions import assert_type
assert_type(np.uint128(), np.unsignedinteger[_128Bit])
# 断言 np.uint128() 的类型为 np.unsignedinteger[_128Bit]
assert_type(np.uint256(), np.unsignedinteger[_256Bit])
# 断言 np.uint256() 的类型为 np.unsignedinteger[_256Bit]
assert_type(np.int128(), np.signedinteger[_128Bit])
# 断言 np.int128() 的类型为 np.signedinteger[_128Bit]
assert_type(np.int256(), np.signedinteger[_256Bit])
# 断言 np.int256() 的类型为 np.signedinteger[_256Bit]
assert_type(np.float80(), np.floating[_80Bit])
# 断言 np.float80() 的类型为 np.floating[_80Bit]
assert_type(np.float96(), np.floating[_96Bit])
# 断言 np.float96() 的类型为 np.floating[_96Bit]
assert_type(np.float128(), np.floating[_128Bit])
# 断言 np.float128() 的类型为 np.floating[_128Bit]
assert_type(np.float256(), np.floating[_256Bit])
# 断言 np.float256() 的类型为 np.floating[_256Bit]
assert_type(np.complex160(), np.complexfloating[_80Bit, _80Bit])
# 断言 np.complex160() 的类型为 np.complexfloating[_80Bit, _80Bit]
assert_type(np.complex192(), np.complexfloating[_96Bit, _96Bit])
# 断言 np.complex192() 的类型为 np.complexfloating[_96Bit, _96Bit]
assert_type(np.complex256(), np.complexfloating[_128Bit, _128Bit])
# 断言 np.complex256() 的类型为 np.complexfloating[_128Bit, _128Bit]
assert_type(np.complex512(), np.complexfloating[_256Bit, _256Bit])
# 断言 np.complex512() 的类型为 np.complexfloating[_256Bit, _256Bit]
.\numpy\numpy\typing\tests\data\pass\arithmetic.py
from __future__ import annotations
# 引入未来的语法特性，确保代码在较老版本的 Python 中也能运行
from typing import Any, Optional
# 导入类型提示相关的模块
import numpy as np
# 导入 NumPy 库并使用别名 np
import pytest
# 导入 pytest 模块用于单元测试
c16 = np.complex128(1)
# 创建一个复数类型的 NumPy 变量 c16，精度为 128 位复数
f8 = np.float64(1)
# 创建一个浮点数类型的 NumPy 变量 f8，精度为 64 位浮点数
i8 = np.int64(1)
# 创建一个整数类型的 NumPy 变量 i8，精度为 64 位整数
u8 = np.uint64(1)
# 创建一个无符号整数类型的 NumPy 变量 u8，精度为 64 位无符号整数
c8 = np.complex64(1)
# 创建一个复数类型的 NumPy 变量 c8，精度为 64 位复数
f4 = np.float32(1)
# 创建一个浮点数类型的 NumPy 变量 f4，精度为 32 位浮点数
i4 = np.int32(1)
# 创建一个整数类型的 NumPy 变量 i4，精度为 32 位整数
u4 = np.uint32(1)
# 创建一个无符号整数类型的 NumPy 变量 u4，精度为 32 位无符号整数
dt = np.datetime64(1, "D")
# 创建一个表示日期的 NumPy 变量 dt，精度为一天
td = np.timedelta64(1, "D")
# 创建一个表示时间间隔的 NumPy 变量 td，精度为一天
b_ = np.bool(1)
# 创建一个布尔类型的 NumPy 变量 b_，值为 True
b = bool(1)
# 创建一个标准布尔类型的 Python 变量 b，值为 True
c = complex(1)
# 创建一个标准复数类型的 Python 变量 c，值为 1+0j
f = float(1)
# 创建一个标准浮点数类型的 Python 变量 f，值为 1.0
i = int(1)
# 创建一个标准整数类型的 Python 变量 i，值为 1
class Object:
# 定义一个名为 Object 的类
def __array__(self, dtype: Optional[np.typing.DTypeLike] = None,
copy: Optional[bool] = None) -> np.ndarray[Any, np.dtype[np.object_]]:
# 定义 __array__ 方法，使对象可以被转换为 NumPy 数组
ret = np.empty((), dtype=object)
ret[()] = self
return ret
def __sub__(self, value: Any) -> Object:
# 定义 __sub__ 方法，支持对象的减法操作
return self
def __rsub__(self, value: Any) -> Object:
# 定义 __rsub__ 方法，支持减法操作的右侧反向运算
return self
def __floordiv__(self, value: Any) -> Object:
# 定义 __floordiv__ 方法，支持对象的整数除法操作
return self
def __rfloordiv__(self, value: Any) -> Object:
# 定义 __rfloordiv__ 方法，支持整数除法操作的右侧反向运算
return self
def __mul__(self, value: Any) -> Object:
# 定义 __mul__ 方法，支持对象的乘法操作
return self
def __rmul__(self, value: Any) -> Object:
# 定义 __rmul__ 方法，支持乘法操作的右侧反向运算
return self
def __pow__(self, value: Any) -> Object:
# 定义 __pow__ 方法，支持对象的乘方操作
return self
def __rpow__(self, value: Any) -> Object:
# 定义 __rpow__ 方法，支持乘方操作的右侧反向运算
return self
AR_b: np.ndarray[Any, np.dtype[np.bool]] = np.array([True])
# 创建一个 NumPy 布尔类型的数组 AR_b，包含一个值为 True 的元素
AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32)
# 创建一个 NumPy 无符号整数类型的数组 AR_u，包含一个值为 1 的元素
AR_i: np.ndarray[Any, np.dtype[np.int64]] = np.array([1])
# 创建一个 NumPy 整数类型的数组 AR_i，包含一个值为 1 的元素
AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0])
# 创建一个 NumPy 浮点数类型的数组 AR_f，包含一个值为 1.0 的元素
AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1j])
# 创建一个 NumPy 复数类型的数组 AR_c，包含一个值为 1j 的元素
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64(1, "D")])
# 创建一个 NumPy 时间间隔类型的数组 AR_m，包含一个时间间隔为一天的元素
AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64(1, "D")])
# 创建一个 NumPy 日期时间类型的数组 AR_M，包含一个日期为一天的元素
AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([Object()])
# 创建一个 NumPy 对象类型的数组 AR_O，包含一个 Object 类的实例对象
AR_LIKE_b = [True]
# 创建一个 Python 布尔类型的列表 AR_LIKE_b，包含一个值为 True 的元素
AR_LIKE_u = [np.uint32(1)]
# 创建一个 Python 无符号整数类型的列表 AR_LIKE_u，包含一个值为 1 的元素
AR_LIKE_i = [1]
# 创建一个 Python 整数类型的列表 AR_LIKE_i，包含一个值为 1 的元素
AR_LIKE_f = [1.0]
# 创建一个 Python 浮点数类型的列表 AR_LIKE_f，包含一个值为 1.0 的元素
AR_LIKE_c = [1j]
# 创建一个 Python 复数类型的列表 AR_LIKE_c，包含一个值为 1j 的元素
AR_LIKE_m = [np.timedelta64(1, "D")]
# 创建一个 Python 时间间隔类型的列表 AR_LIKE_m，包含一个时间间隔为一天的元素
AR_LIKE_M = [np.datetime64(1, "D")]
# 创建一个 Python 日期时间类型的列表 AR_LIKE_M，包含一个日期为一天的元素
AR_LIKE_O = [Object()]
# 创建一个 Python 对象类型的列表 AR_LIKE_O，包含一个 Object 类的实例对象
# Array subtractions
AR_b - AR_LIKE_u
# 对 AR_b 和 AR_LIKE_u 执行数组减法操作
AR_b - AR_LIKE_i
# 对 AR_b 和 AR_LIKE_i 执行数组减法操作
AR_b - AR_LIKE_f
# 对 AR_b 和 AR_LIKE_f 执行数组减法操作
AR_b - AR_LIKE_c
# 对 AR_b 和 AR_LIKE_c 执行数组减法操作
AR_b - AR_LIKE_m
# 对 AR_b 和 AR_LIKE_m 执行数组减法操作
AR_b - AR_LIKE_O
# 对 AR_b 和 AR_LIKE_O 执行数组减法操作
AR_LIKE_u - AR_b
# 对 AR_LIKE_u 和 AR_b 执行数组减法操作
AR_LIKE_i - AR_b
# 对 AR_LIKE_i 和 AR_b 执行数组减法操作
AR_LIKE_f - AR_b
# 对 AR_LIKE_f 和 AR_b 执行数组减法操作
AR_LIKE_c - AR_b
# 对 AR_LIKE_c 和 AR_b 执行数组减法操作
AR_LIKE_m - AR_b
# 对 AR_LIKE_m 和 AR_b 执行数组减法操作
AR_LIKE_M - AR_b
# 对 AR_LIKE_M 和 AR_b 执行数组减法操作
AR_LIKE_O - AR_b
# 对 AR_LIKE
# Subtract AR_c from AR_LIKE_b
AR_LIKE_b - AR_c
# Subtract AR_c from AR_LIKE_u
AR_LIKE_u - AR_c
# Subtract AR_c from AR_LIKE_i
AR_LIKE_i - AR_c
# Subtract AR_c from AR_LIKE_f
AR_LIKE_f - AR_c
# Subtract AR_c from AR_LIKE_c
AR_LIKE_c - AR_c
# Subtract AR_c from AR_LIKE_O
AR_LIKE_O - AR_c
# Subtract AR_LIKE_b from AR_m
AR_m - AR_LIKE_b
# Subtract AR_LIKE_u from AR_m
AR_m - AR_LIKE_u
# Subtract AR_LIKE_i from AR_m
AR_m - AR_LIKE_i
# Subtract AR_LIKE_m from AR_m
AR_m - AR_LIKE_m
# Subtract AR_m from AR_LIKE_b
AR_LIKE_b - AR_m
# Subtract AR_m from AR_LIKE_u
AR_LIKE_u - AR_m
# Subtract AR_m from AR_LIKE_i
AR_LIKE_i - AR_m
# Subtract AR_m from AR_LIKE_m
AR_LIKE_m - AR_m
# Subtract AR_m from AR_LIKE_M
AR_LIKE_M - AR_m
# Subtract AR_LIKE_b from AR_M
AR_M - AR_LIKE_b
# Subtract AR_LIKE_u from AR_M
AR_M - AR_LIKE_u
# Subtract AR_LIKE_i from AR_M
AR_M - AR_LIKE_i
# Subtract AR_LIKE_m from AR_M
AR_M - AR_LIKE_m
# Subtract AR_LIKE_M from AR_M
AR_M - AR_LIKE_M
# Subtract AR_M from AR_LIKE_b
AR_LIKE_b - AR_M
# Subtract AR_M from AR_LIKE_u
AR_LIKE_u - AR_M
# Subtract AR_M from AR_LIKE_i
AR_LIKE_i - AR_M
# Subtract AR_M from AR_LIKE_m
AR_LIKE_m - AR_M
# Subtract AR_M from AR_LIKE_M
AR_LIKE_M - AR_M
# Subtract AR_M from AR_LIKE_M
AR_LIKE_M - AR_M
# Subtract AR_LIKE_b from AR_O
AR_O - AR_LIKE_b
# Subtract AR_LIKE_u from AR_O
AR_O - AR_LIKE_u
# Subtract AR_LIKE_i from AR_O
AR_O - AR_LIKE_i
# Subtract AR_LIKE_f from AR_O
AR_O - AR_LIKE_f
# Subtract AR_LIKE_c from AR_O
AR_O - AR_LIKE_c
# Subtract AR_LIKE_O from AR_O
AR_O - AR_LIKE_O
# Subtract AR_O from AR_LIKE_b
AR_LIKE_b - AR_O
# Subtract AR_O from AR_LIKE_u
AR_LIKE_u - AR_O
# Subtract AR_O from AR_LIKE_i
AR_LIKE_i - AR_O
# Subtract AR_O from AR_LIKE_f
AR_LIKE_f - AR_O
# Subtract AR_O from AR_LIKE_c
AR_LIKE_c - AR_O
# Subtract AR_O from AR_LIKE_O
AR_LIKE_O - AR_O
# Increment AR_u by AR_b
AR_u += AR_b
# Increment AR_u by AR_u
AR_u += AR_u
# Increment AR_u by 1 (allowed during runtime as long as AR_u is 0D and >= 0)
# Perform floor division of AR_b by AR_LIKE_b
AR_b // AR_LIKE_b
# Perform floor division of AR_b by AR_LIKE_u
AR_b // AR_LIKE_u
# Perform floor division of AR_b by AR_LIKE_i
AR_b // AR_LIKE_i
# Perform floor division of AR_b by AR_LIKE_f
AR_b // AR_LIKE_f
# Perform floor division of AR_b by AR_LIKE_O
AR_b // AR_LIKE_O
# Perform floor division of AR_LIKE_b by AR_b
AR_LIKE_b // AR_b
# Perform floor division of AR_LIKE_u by AR_b
AR_LIKE_u // AR_b
# Perform floor division of AR_LIKE_i by AR_b
AR_LIKE_i // AR_b
# Perform floor division of AR_LIKE_f by AR_b
AR_LIKE_f // AR_b
# Perform floor division of AR_LIKE_O by AR_b
AR_LIKE_O // AR_b
# Perform floor division of AR_u by AR_LIKE_b
AR_u // AR_LIKE_b
# Perform floor division of AR_u by AR_LIKE_u
AR_u // AR_LIKE_u
# Perform floor division of AR_u by AR_LIKE_i
AR_u // AR_LIKE_i
# Perform floor division of AR_u by AR_LIKE_f
AR_u // AR_LIKE_f
# Perform floor division of AR_u by AR_LIKE_O
AR_u // AR_LIKE_O
# Perform floor division of AR_LIKE_b by AR_u
AR_LIKE_b // AR_u
# Perform floor division of AR_LIKE_u by AR_u
AR_LIKE_u // AR_u
# Perform floor division of AR_LIKE_i by AR_u
AR_LIKE_i // AR_u
# Perform floor division of AR_LIKE_f by AR_u
AR_LIKE_f // AR_u
# Perform floor division of AR_LIKE_m by AR_u
AR_LIKE_m // AR_u
# Perform floor division of AR_LIKE_O by AR_u
AR_LIKE_O // AR_u
# Perform floor division of AR_i by AR_LIKE_b
AR_i // AR_LIKE_b
# Perform floor division of AR_i by AR_LIKE_u
AR_i // AR_LIKE_u
# Perform floor division of AR_i by AR_LIKE_i
AR_i // AR_LIKE_i
# Perform floor division of AR_i by AR_LIKE_f
AR_i // AR_LIKE_f
# Perform floor division of AR_i by AR_LIKE_O
AR_i // AR_LIKE_O
# Perform floor division of AR_LIKE_b by AR_i
AR_LIKE_b // AR_i
# Perform floor division of AR_LIKE_u by AR_i
AR_LIKE_u // AR_i
# Perform floor division of AR_LIKE_i by AR_i
AR_LIKE_i // AR_i
# Perform floor division of AR_LIKE_f by AR_i
AR_LIKE_f // AR_i
# Perform floor division of AR_LIKE_m by AR_i
AR_LIKE_m // AR_i
# Perform floor division of AR_LIKE_O by AR_i
AR_LIKE_O // AR_i
# Perform floor division of AR_f by AR_LIKE_b
AR_f // AR_LIKE_b
# Perform floor division of AR_f by AR_LIKE_u
AR_f // AR_LIKE_u
# Perform floor division of AR_f by AR_LIKE_i
AR_f // AR_LIKE_i
# Perform floor division of AR_f by AR_LIKE_f
AR_f // AR_LIKE_f
# Perform floor division of AR_f by AR_LIKE_O
AR_f // AR_LIKE_O
# Perform floor division of AR_LIKE_b by AR_f
AR_LIKE_b // AR_f
# Perform floor division of AR_LIKE_u by AR_f
AR_LIKE_u // AR_f
# Perform floor division of AR_LIKE_i by AR_f
AR_LIKE_i // AR_f
# Perform floor division of AR_LIKE_f by AR_f
AR_LIKE_f // AR_f
# Perform floor division of AR_LIKE_m by AR_f
AR_LIKE_m // AR_f
# Perform floor division of AR_LIKE_O by AR_f
AR_LIKE_O // AR_f
# Perform floor division of AR_m by AR_LIKE_u
AR_m // AR_LIKE_u
# Perform floor division of AR_m by AR_LIKE_i
AR_m // AR_LIKE_i
# Perform floor division of AR_m by AR_LIKE_f
AR_m // AR_LIKE_f
# Perform floor division of AR_m by AR_LIKE_m
AR_m // AR_LIKE_m
# Perform floor division of AR_LIKE_m by AR_m
AR_LIKE_m // AR_m
# Perform floor division of AR_O by AR_LIKE_b
AR_O // AR_LIKE_b
# Perform floor division of AR_O by AR_LIKE_u
AR_O // AR_LIKE_u
# Perform floor division of AR_O by AR_LIKE_i
AR_O // AR_LIKE_i
# Perform floor division of AR_O by AR_LIKE_f
AR_O // AR_LIKE_f
# Perform floor division of AR_O by AR_LIKE_O
AR_O // AR_LIKE_O
# Perform floor division of AR_LIKE_b by AR_O
AR_LIKE_b // AR_O
# Perform floor division of AR_LIKE_u by AR_O
AR_LIKE_u // AR_O
# Perform floor division of AR_LIKE_i by AR_O
AR_LIKE_i // AR_O
# Perform floor division of AR_LIKE_f by AR_O
AR_LIKE_f // AR_O
# Perform floor division of AR_LIKE_O by AR_O
AR_LIKE_O // AR_O
# Inplace multiplication of AR_LIKE_b by AR_b
AR_b *= AR_LIKE_b
# Inplace multiplication of AR_LIKE_b by AR_u
AR_u *= AR_LIKE_b
# Inplace multiplication of AR_LIKE_u by AR_u
AR_u *= AR_LIKE_u
# Inplace multiplication of AR_LIKE_b by AR_i
AR_i *= AR_LIKE_b
# Inplace multiplication of
# boolean
# 布尔类型之间的除法操作，结果为浮点数
b_ / b
b_ / b_
b_ / i
b_ / i8
b_ / i4
b_ / u8
b_ / u4
b_ / f
b_ / f8
b_ / f4
b_ / c
b_ / c16
b_ / c8
# 整数除以布尔类型，结果为整数
b / b_
b_ / b_
i / b_
i8 / b_
i4 / b_
u8 / b_
u4 / b_
f / b_
f8 / b_
f4 / b_
c / b_
c16 / b_
c8 / b_
# Complex
# 复数类型 c16 与各种类型的加法操作
c16 + c16
c16 + f8
c16 + i8
c16 + c8
c16 + f4
c16 + i4
c16 + b_
c16 + b
c16 + c
c16 + f
c16 + i
c16 + AR_f
# 各种类型与复数类型 c16 的加法操作
c16 + c16
f8 + c16
i8 + c16
c8 + c16
f4 + c16
i4 + c16
b_ + c16
b + c16
c + c16
f + c16
i + c16
AR_f + c16
c8 + c16
c8 + f8
c8 + i8
c8 + c8
c8 + f4
c8 + i4
c8 + b_
c8 + b
c8 + c
c8 + f
c8 + i
c8 + AR_f
c16 + c8
f8 + c8
i8 + c8
c8 + c8
f4 + c8
i4 + c8
b_ + c8
b + c8
c + c8
f + c8
i + c8
AR_f + c8
# Float
# 浮点类型 f8 与各种类型的加法操作
f8 + f8
f8 + i8
f8 + f4
f8 + i4
f8 + b_
f8 + b
f8 + c
f8 + f
f8 + i
f8 + AR_f
# 各种类型与浮点类型 f8 的加法操作
f8 + f8
i8 + f8
f4 + f8
i4 + f8
b_ + f8
b + f8
c + f8
f + f8
i + f8
AR_f + f8
f4 + f8
f4 + i8
f4 + f4
f4 + i4
f4 + b_
f4 + b
f4 + c
f4 + f
f4 + i
f4 + AR_f
f8 + f4
i8 + f4
f4 + f4
i4 + f4
b_ + f4
b + f4
c + f4
f + f4
i + f4
AR_f + f4
# Int
# 整数类型 i8 与各种类型的加法操作
i8 + i8
i8 + u8
i8 + i4
i8 + u4
i8 + b_
i8 + b
i8 + c
i8 + f
i8 + i
i8 + AR_f
u8 + u8
u8 + i4
u8 + u4
u8 + b_
u8 + b
u8 + c
u8 + f
u8 + i
u8 + AR_f
i8 + i8
u8 + i8
i4 + i8
u4 + i8
b_ + i8
b + i8
c + i8
f + i8
i + i8
AR_f + i8
u8 + u8
i4 + u8
u4 + u8
b_ + u8
b + u8
c + u8
f + u8
i + u8
AR_f + u8
i4 + i8
i4 + i4
i4 + i
i4 + b_
i4 + b
i4 + AR_f
u4 + i8
u4 + i4
u4 + u8
u4 + u4
u4 + i
u4 + b_
u4 + b
u4 + AR_f
i8 + i4
i4 + i4
i + i4
b_ + i4
b + i4
AR_f + i4
i8 + u4
i4 + u4
u8 + u4
u4 + u4
b_ + u4
b + u4
i + u4
AR_f + u4
.\numpy\numpy\typing\tests\data\pass\arrayprint.py
# 导入NumPy库，简称为np
import numpy as np
# 创建一个包含0到9的一维数组
AR = np.arange(10)
# 设置数组为只读模式，即不允许修改数组的值
AR.setflags(write=False)
# 使用默认的打印选项打印NumPy数组
with np.printoptions():
# 设置打印选项，包括小数点后的精度为1，阈值为2，显示前后各3个元素，每行打印4个字符
np.set_printoptions(
precision=1,
threshold=2,
edgeitems=3,
linewidth=4,
suppress=False,
nanstr="Bob",
infstr="Bill",
formatter={},
sign="+",
floatmode="unique",
)
# 获取当前的打印选项
np.get_printoptions()
# 将NumPy数组AR转换为字符串形式
str(AR)
# 将NumPy数组AR转换为指定格式的字符串
np.array2string(
AR,
max_line_width=5, # 每行最大宽度为5个字符
precision=2, # 小数点后精度为2
suppress_small=True, # 抑制小的浮点数形式
separator=";", # 数组元素的分隔符为分号
prefix="test", # 输出字符串的前缀为'test'
threshold=5, # 打印数组的阈值为5
floatmode="fixed", # 使用固定小数点模式
suffix="?", # 输出字符串的后缀为'?'
legacy="1.13", # 遗留模式为1.13版本
)
# 格式化一个浮点数为科学计数法字符串
np.format_float_scientific(1, precision=5)
# 格式化一个浮点数为定点形式的字符串
np.format_float_positional(1, trim="k")
# 返回NumPy数组AR的表达式形式的字符串
np.array_repr(AR)
# 返回NumPy数组AR的字符串形式
np.array_str(AR)
.\numpy\numpy\typing\tests\data\pass\arrayterator.py
# 导入将来版本的特性模块，支持类型注解
from __future__ import annotations
# 导入类型相关模块
from typing import Any
# 导入 NumPy 库，通常用于处理数值计算
import numpy as np
# 创建一个包含整数的 NumPy 数组，从 0 到 9
AR_i8: np.ndarray[Any, np.dtype[np.int_]] = np.arange(10)
# 创建一个数组迭代器对象，用于迭代处理 AR_i8 数组
ar_iter = np.lib.Arrayterator(AR_i8)
# 访问数组迭代器对象的实例变量 var
ar_iter.var
# 访问数组迭代器对象的实例变量 buf_size
ar_iter.buf_size
# 访问数组迭代器对象的实例变量 start
ar_iter.start
# 访问数组迭代器对象的实例变量 stop
ar_iter.stop
# 访问数组迭代器对象的实例变量 step
ar_iter.step
# 访问数组迭代器对象的实例变量 shape
ar_iter.shape
# 访问数组迭代器对象的实例变量 flat
# 调用数组迭代器对象的 __array__() 方法，返回数组迭代器的视图或副本
# 使用 for 循环遍历数组迭代器对象 ar_iter 中的所有元素
for i in ar_iter:
pass
# 访问数组迭代器对象的索引位置为 0 的元素
ar_iter[0]
# 访问数组迭代器对象的所有维度
ar_iter[...]
# 访问数组迭代器对象的所有元素
ar_iter[:]
# 访问数组迭代器对象多维索引为 (0, 0, 0) 的元素
ar_iter[0, 0, 0]
# 访问数组迭代器对象多维索引为 (...，0，:) 的元素，其中 ... 表示省略的维度
.\numpy\numpy\typing\tests\data\pass\array_constructors.py
from typing import Any # 导入必要的类型提示模块
import numpy as np # 导入 NumPy 库
import numpy.typing as npt # 导入 NumPy 的类型提示模块
class Index:
def __index__(self) -> int:
return 0 # Index 类的方法返回整数 0
class SubClass(npt.NDArray[np.float64]):
pass # 定义一个 SubClass 类，继承自 NumPy 的 NDArray 类型，元素类型为 np.float64
def func(i: int, j: int, **kwargs: Any) -> SubClass:
return B # 函数 func 接收两个整数参数并返回变量 B
i8 = np.int64(1) # 创建一个 np.int64 类型的变量 i8，值为 1
A = np.array([1]) # 创建一个包含单个元素 1 的 NumPy 数组 A
B = A.view(SubClass).copy() # 创建一个 B 变量，通过 A 的视图转换为 SubClass 类型并复制
B_stack = np.array([[1], [1]]).view(SubClass) # 创建一个 B_stack 变量，通过 NumPy 数组的视图转换为 SubClass 类型
C = [1] # 创建一个包含单个元素 1 的普通 Python 列表
np.ndarray(Index()) # 创建一个 NumPy 数组，其元素为 Index() 返回的整数 0
np.ndarray([Index()]) # 创建一个 NumPy 数组，其元素为包含 Index() 返回的整数 0 的列表
np.array(1, dtype=float) # 创建一个包含单个元素 1.0 的 NumPy 数组，数据类型为 float
np.array(1, copy=None) # 创建一个包含单个元素 1 的 NumPy 数组，未指定 copy 参数
np.array(1, order='F') # 创建一个包含单个元素 1 的 NumPy 数组，内存布局顺序为列优先 (Fortran 风格)
np.array(1, order=None) # 创建一个包含单个元素 1 的 NumPy 数组，未指定内存布局顺序
np.array(1, subok=True) # 创建一个包含单个元素 1 的 NumPy 数组，允许子类化
np.array(1, ndmin=3) # 创建一个至少包含三个维度的 NumPy 数组，元素为单个元素 1
np.array(1, str, copy=True, order='C', subok=False, ndmin=2) # 创建一个字符串类型的 NumPy 数组，指定多个参数
np.asarray(A) # 将 A 转换为 NumPy 数组
np.asarray(B) # 将 B 转换为 NumPy 数组
np.asarray(C) # 将 C 转换为 NumPy 数组
np.asanyarray(A) # 将 A 转换为 NumPy 数组（若已是 NumPy 数组则不变）
np.asanyarray(B) # 将 B 转换为 NumPy 数组（若已是 NumPy 数组则不变）
np.asanyarray(B, dtype=int) # 将 B 转换为指定数据类型的 NumPy 数组
np.asanyarray(C) # 将 C 转换为 NumPy 数组（若已是 NumPy 数组则不变）
np.ascontiguousarray(A) # 将 A 转换为内存连续的 NumPy 数组
np.ascontiguousarray(B) # 将 B 转换为内存连续的 NumPy 数组
np.ascontiguousarray(C) # 将 C 转换为内存连续的 NumPy 数组
np.asfortranarray(A) # 将 A 转换为 Fortran 风格的 NumPy 数组
np.asfortranarray(B) # 将 B 转换为 Fortran 风格的 NumPy 数组
np.asfortranarray(C) # 将 C 转换为 Fortran 风格的 NumPy 数组
np.require(A) # 返回 A 的一个新的要求数组
np.require(B) # 返回 B 的一个新的要求数组
np.require(B, dtype=int) # 返回 B 的一个新的要求数组，指定数据类型
np.require(B, requirements=None) # 返回 B 的一个新的要求数组，未指定要求
np.require(B, requirements="E") # 返回 B 的一个新的要求数组，指定要求为 "E"
np.require(B, requirements=["ENSUREARRAY"]) # 返回 B 的一个新的要求数组，指定多个要求
np.require(B, requirements={"F", "E"}) # 返回 B 的一个新的要求数组，指定多个要求为集合
np.require(B, requirements=["C", "OWNDATA"]) # 返回 B 的一个新的要求数组，指定多个要求
np.require(B, requirements="W") # 返回 B 的一个新的要求数组，指定要求为 "W"
np.require(B, requirements="A") # 返回 B 的一个新的要求数组，指定要求为 "A"
np.require(C) # 返回 C 的一个新的要求数组
np.linspace(0, 2) # 返回一个在 [0, 2] 区间内均匀间隔的 NumPy 数组，默认包含 50 个元素
np.linspace(0.5, [0, 1, 2]) # 返回一个在 [0.5, [0, 1, 2]] 区间内均匀间隔的 NumPy 数组
np.linspace([0, 1, 2], 3) # 返回一个在 [[0, 1, 2], 3] 区间内均匀间隔的 NumPy 数组
np.linspace(0j, 2) # 返回一个在 [0j, 2] 区间内均匀间隔的复数 NumPy 数组
np.linspace(0, 2, num=10) # 返回一个在 [0, 2] 区间内均匀间隔的 NumPy 数组，包含 10 个元素
np.linspace(0, 2, endpoint=True) # 返回一个在 [0, 2] 区间内均匀间隔的 NumPy 数组，包含终点值 2
np.linspace(0, 2, retstep=True) # 返回一个在 [0, 2] 区间内均匀间隔的 NumPy 数组以及步长
np.linspace(0j, 2j, retstep=True) # 返回一个在 [0j, 2j] 区间内均匀间隔的复数 NumPy 数组以及步长
np.linspace(0, 2, dtype=bool) # 返回一个在 [0, 2] 区间内均匀间隔的 NumPy 数组，数据类型为 bool
np.linspace([0, 1], [2, 3], axis=Index()) # 返回一个在 [[0, 1], [2, 3]] 区间内均匀间隔的 NumPy 数组，指定轴
np.logspace(0, 2, base=2) # 返回一个在 [2^0, 2^2] 区间内以 2 为底数均匀间隔的 NumPy 数组
np.logspace(0, 2, base=2) # 返回一个在 [2^0, 2^2] 区间内以 2 为底数均匀间隔的 NumPy 数组
np.logspace(0, 2, base=[1j, 2j], num=2) # 返回一个在 [1j^0, 2j^2] 区间内以复数为底数均匀间隔的 NumPy 数组，包含 2 个元素
np.geomspace(1, 2) # 返回一个在 [1, 2] 区间内以几何级数间隔的 NumPy 数组
np.zeros_like(A) # 返回一个与 A 形状和数据类型相同的全零 NumPy 数组
np.zeros_like(C) # 返回一个与 C 形状和数据类型相同的全零 NumPy 数组
np.zeros_like(B) # 返回一个与 B 形状和
.\numpy\numpy\typing\tests\data\pass\array_like.py
# 导入未来的语法特性，用于支持类型注解中的 annotations
from __future__ import annotations
# 导入类型相关模块
from typing import Any
# 导入 NumPy 库
import numpy as np
# 导入 NumPy 中的类型定义
from numpy._typing import NDArray, ArrayLike, _SupportsArray
# 下面定义了多个变量，并注明它们的类型为 ArrayLike
# x1 是一个布尔类型的数组或类数组对象，初始值为 True
x1: ArrayLike = True
# x2 是一个整数类型的数组或类数组对象，初始值为 5
x2: ArrayLike = 5
# x3 是一个浮点数类型的数组或类数组对象，初始值为 1.0
x3: ArrayLike = 1.0
# x4 是一个复数类型的数组或类数组对象，初始值为 1 + 1j
x4: ArrayLike = 1 + 1j
# x5 是一个 int8 类型的数组或类数组对象，初始值为 1
x5: ArrayLike = np.int8(1)
# x6 是一个 float64 类型的数组或类数组对象，初始值为 1.0
x6: ArrayLike = np.float64(1)
# x7 是一个 complex128 类型的数组或类数组对象，初始值为 1
x7: ArrayLike = np.complex128(1)
# x8 是一个包含整数数组 [1, 2, 3] 的数组或类数组对象
x8: ArrayLike = np.array([1, 2, 3])
# x9 是一个包含整数列表 [1, 2, 3] 的数组或类数组对象
x9: ArrayLike = [1, 2, 3]
# x10 是一个包含整数元组 (1, 2, 3) 的数组或类数组对象
x10: ArrayLike = (1, 2, 3)
# x11 是一个字符串类型的数组或类数组对象，初始值为 "foo"
x11: ArrayLike = "foo"
# x12 是一个内存视图类型的数组或类数组对象，初始值为 b'foo'
x12: ArrayLike = memoryview(b'foo')
# 定义类 A
class A:
# 类 A 定义了 __array__ 方法，返回一个包含浮点数数组的 NDArray
def __array__(
self, dtype: None | np.dtype[Any] = None
) -> NDArray[np.float64]:
return np.array([1.0, 2.0, 3.0])
# x13 是类 A 的一个实例，它也被声明为数组或类数组对象
x13: ArrayLike = A()
# scalar 是一个支持数组的标量对象，其类型为 np.int64 的支持数组
scalar: _SupportsArray[np.dtype[np.int64]] = np.int64(1)
# 调用 scalar 对象的 __array__ 方法
scalar.__array__()
# array 是一个支持数组的对象，其类型为 np.int_ 的支持数组
array: _SupportsArray[np.dtype[np.int_]] = np.array(1)
# 调用 array 对象的 __array__ 方法
array.__array__()
# a 是类 A 的一个实例，其类型为 np.float64 的支持数组
a: _SupportsArray[np.dtype[np.float64]] = A()
# 连续两次调用 a 对象的 __array__ 方法
a.__array__()
a.__array__()
# 对于创建对象数组的转义，用于表示像对象数组一样的东西
# object_array_scalar 是一个生成器表达式，用于生成 0 到 9 的整数序列
object_array_scalar: object = (i for i in range(10))
# 使用 np.array 将 object_array_scalar 转换为数组对象
np.array(object_array_scalar)
.\numpy\numpy\typing\tests\data\pass\bitwise_ops.py
# 导入NumPy库，通常用np作为别名
import numpy as np
# 创建一个64位有符号整数
i8 = np.int64(1)
# 创建一个64位无符号整数
u8 = np.uint64(1)
# 创建一个32位有符号整数
i4 = np.int32(1)
# 创建一个32位无符号整数
u4 = np.uint32(1)
# 创建一个布尔值数组，值为True
b_ = np.bool(1)
# 创建一个Python内置的布尔值，值为True
b = bool(1)
# 创建一个Python内置的整数，值为1
i = int(1)
# 创建一个一维整型数组，数据为[0, 1, 2]，数据类型为32位有符号整数
AR = np.array([0, 1, 2], dtype=np.int32)
# 设置数组AR为只读模式，禁止修改数据
# 64位有符号整数的左移运算
i8 << i8
# 64位有符号整数的右移运算
i8 >> i8
# 64位有符号整数的按位或运算
i8 | i8
# 64位有符号整数的按位异或运算
i8 ^ i8
# 64位有符号整数的按位与运算
i8 & i8
# Python内置整数的左移运算，应用于数组AR的每个元素
i << AR
# Python内置整数的右移运算，应用于数组AR的每个元素
i >> AR
# Python内置整数的按位或运算，应用于数组AR的每个元素
i | AR
# Python内置整数的按位异或运算，应用于数组AR的每个元素
i ^ AR
# Python内置整数的按位与运算，应用于数组AR的每个元素
i & AR
# 64位有符号整数的左移运算，应用于数组AR的每个元素
i8 << AR
# 64位有符号整数的右移运算，应用于数组AR的每个元素
i8 >> AR
# 64位有符号整数的按位或运算，应用于数组AR的每个元素
i8 | AR
# 64位有符号整数的按位异或运算，应用于数组AR的每个元素
i8 ^ AR
# 64位有符号整数的按位与运算，应用于数组AR的每个元素
i8 & AR
# 32位有符号整数的左移运算
i4 << i4
# 32位有符号整数的右移运算
i4 >> i4
# 32位有符号整数的按位或运算
i4 | i4
# 32位有符号整数的按位异或运算
i4 ^ i4
# 32位有符号整数的按位与运算
i4 & i4
# 64位有符号整数和32位有符号整数的左移运算
i8 << i4
# 64位有符号整数和32位有符号整数的右移运算
i8 >> i4
# 64位有符号整数和32位有符号整数的按位或运算
i8 | i4
# 64位有符号整数和32位有符号整数的按位异或运算
i8 ^ i4
# 64位有符号整数和32位有符号整数的按位与运算
i8 & i4
# 64位有符号整数和Python内置整数的左移运算
i8 << i
# 64位有符号整数和Python内置整数的右移运算
i8 >> i
# 64位有符号整数和Python内置整数的按位或运算
i8 | i
# 64位有符号整数和Python内置整数的按位异或运算
i8 ^ i
# 64位有符号整数和Python内置整数的按位与运算
i8 & i
# 64位有符号整数和布尔值数组的左移运算
i8 << b_
# 64位有符号整数和布尔值数组的右移运算
i8 >> b_
# 64位有符号整数和布尔值数组的按位或运算
i8 | b_
# 64位有符号整数和布尔值数组的按位异或运算
i8 ^ b_
# 64位有符号整数和布尔值数组的按位与运算
i8 & b_
# 64位有符号整数和Python内置布尔值的左移运算
i8 << b
# 64位有符号整数和Python内置布尔值的右移运算
i8 >> b
# 64位有符号整数和Python内置布尔值的按位或运算
i8 | b
# 64位有符号整数和Python内置布尔值的按位异或运算
i8 ^ b
# 64位有符号整数和Python内置布尔值的按位与运算
i8 & b
# 64位无符号整数的左移运算
u8 << u8
# 64位无符号整数的右移运算
u8 >> u8
# 64位无符号整数的按位或运算
u8 | u8
# 64位无符号整数的按位异或运算
u8 ^ u8
# 64位无符号整数的按位与运算
u8 & u8
# 32位无符号整数的左移运算
u4 << u4
# 32位无符号整数的右移运算
u4 >> u4
# 32位无符号整数的按位或运算
u4 | u4
# 32位无符号整数的按位异或运算
u4 ^ u4
# 32位无符号整数的按位与运算
u4 & u4
# 32位无符号整数和32位有符号整数的左移运算
u4 << i4
# 32位无符号整数和32位有符号整数的右移运算
u4 >> i4
# 32位无符号整数和32位有符号整数的按位或运算
u4 | i4
# 32位无符号整数和32位有符号整数的按位异或运算
u4 ^ i4
# 32位无符号整数和32位有符号整数的按位与运算
u4 & i4
# 32位无符号整数和Python内置整数的左移运算
u4 << i
# 32位无符号整数和Python内置整数的右移运算
u4 >> i
# 32位无符号整数和Python内置整数的按位或运算
u4 | i
# 32位无符号整数和Python内置整数的按位异或运算
u4 ^ i
# 32位无符号整数和Python内置整数的按位与运算
u4 & i
# 64位无符号整数和布尔值数组的左移运算
u8 << b_
# 64位无符号整数和布尔值数组的右移运算
u8 >> b_
# 64位无符号整数和布尔值数组的按位或运算
u8 | b_
# 64位无符号整数和布尔值数组的按位异或运算
u8 ^ b_
# 64位无符号整数和布尔值数组的按位与运算
u8 & b_
# 64位无符号整数和Python内置布尔值的左移运算
u8 << b
# 64位无符号整数和Python内置布尔值的右移运算
u8 >> b
# 64位无符号整数和Python内置布尔值的按位或运算
u8 | b
# 64位无符号整数和Python内置布尔值的按位异或运算
u8 ^ b
# 64位无符
.\numpy\numpy\typing\tests\data\pass\comparisons.py
from __future__ import annotations # 导入 future 模块中的 annotations 特性，用于支持注解的类型提示
from typing import Any # 导入 Any 类型，表示可以是任意类型
import numpy as np # 导入 NumPy 库并重命名为 np
c16 = np.complex128() # 创建一个复数类型的变量 c16，精度为 complex128
f8 = np.float64() # 创建一个浮点数类型的变量 f8，精度为 float64
i8 = np.int64() # 创建一个整数类型的变量 i8，精度为 int64
u8 = np.uint64() # 创建一个无符号整数类型的变量 u8，精度为 uint64
c8 = np.complex64() # 创建一个复数类型的变量 c8，精度为 complex64
f4 = np.float32() # 创建一个浮点数类型的变量 f4，精度为 float32
i4 = np.int32() # 创建一个整数类型的变量 i4，精度为 int32
u4 = np.uint32() # 创建一个无符号整数类型的变量 u4，精度为 uint32
dt = np.datetime64(0, "D") # 创建一个日期时间类型的变量 dt，初始化为 0 天
td = np.timedelta64(0, "D") # 创建一个时间差类型的变量 td，初始化为 0 天
b_ = np.bool() # 创建一个布尔类型的变量 b_，默认初始化为 False
b = bool() # 创建一个布尔类型的变量 b，Python 内置类型，默认初始化为 False
c = complex() # 创建一个复数类型的变量 c，Python 内置类型，默认初始化为 0+0j
f = float() # 创建一个浮点数类型的变量 f，Python 内置类型，默认初始化为 0.0
i = int() # 创建一个整数类型的变量 i，Python 内置类型，默认初始化为 0
SEQ = (0, 1, 2, 3, 4) # 创建一个元组 SEQ，包含整数 0 到 4
AR_b: np.ndarray[Any, np.dtype[np.bool]] = np.array([True]) # 创建一个 NumPy 布尔数组 AR_b，包含一个 True 值
AR_u: np.ndarray[Any, np.dtype[np.uint32]] = np.array([1], dtype=np.uint32) # 创建一个 NumPy 无符号整数数组 AR_u，包含一个值为 1 的 uint32
AR_i: np.ndarray[Any, np.dtype[np.int_]] = np.array([1]) # 创建一个 NumPy 整数数组 AR_i，包含一个值为 1 的 int_
AR_f: np.ndarray[Any, np.dtype[np.float64]] = np.array([1.0]) # 创建一个 NumPy 浮点数数组 AR_f，包含一个值为 1.0 的 float64
AR_c: np.ndarray[Any, np.dtype[np.complex128]] = np.array([1.0j]) # 创建一个 NumPy 复数数组 AR_c，包含一个值为 1.0j 的 complex128
AR_m: np.ndarray[Any, np.dtype[np.timedelta64]] = np.array([np.timedelta64("1")]) # 创建一个 NumPy 时间差数组 AR_m，包含一个值为 1 的 timedelta64
AR_M: np.ndarray[Any, np.dtype[np.datetime64]] = np.array([np.datetime64("1")]) # 创建一个 NumPy 日期时间数组 AR_M，包含一个值为 1 的 datetime64
AR_O: np.ndarray[Any, np.dtype[np.object_]] = np.array([1], dtype=object) # 创建一个 NumPy 对象数组 AR_O，包含一个值为 1 的 object
# Arrays
AR_b > AR_b # 比较两个布尔数组 AR_b 的元素是否逐个大于
AR_b > AR_u # 比较布尔数组 AR_b 和无符号整数数组 AR_u 的元素是否逐个大于
AR_b > AR_i # 比较布尔数组 AR_b 和整数数组 AR_i 的元素是否逐个大于
AR_b > AR_f # 比较布尔数组 AR_b 和浮点数数组 AR_f 的元素是否逐个大于
AR_b > AR_c # 比较布尔数组 AR_b 和复数数组 AR_c 的元素是否逐个大于
AR_u > AR_b # 比较无符号整数数组 AR_u 和布尔数组 AR_b 的元素是否逐个大于
AR_u > AR_u # 比较两个无符号整数数组 AR_u 的元素是否逐个大于
AR_u > AR_i # 比较无符号整数数组 AR_u 和整数数组 AR_i 的元素是否逐个大于
AR_u > AR_f # 比较无符号整数数组 AR_u 和浮点数数组 AR_f 的元素是否逐个大于
AR_u > AR_c # 比较无符号整数数组 AR_u 和复数数组 AR_c 的元素是否逐个大于
AR_i > AR_b # 比较整数数组 AR_i 和布尔数组 AR_b 的元素是否逐个大于
AR_i > AR_u # 比较整数数组 AR_i 和无符号整数数组 AR_u 的元素是否逐个大于
AR_i > AR_i # 比较两个整数数组 AR_i 的元素是否逐个大于
AR_i > AR_f # 比较整数数组 AR_i 和浮点数数组 AR_f 的元素是否逐个大于
AR_i > AR_c # 比较整数数组 AR_i 和复数数组 AR_c 的元素是否逐个大于
AR_f > AR_b # 比较浮点数数组 AR_f 和布尔数组 AR_b 的元素是否逐个大于
AR_f > AR_u # 比较浮点数数组 AR_f 和无符号整数数组 AR_u 的元素是否逐个大于
AR_f > AR_i # 比较浮点数数组 AR_f 和整数数组 AR_i 的元素是否逐个大于
AR_f > AR_f # 比较两个浮点数数组 AR_f 的元素是否逐个大于
AR_f > AR_c # 比较浮点数数组 AR_f 和复数数组 AR_c 的元素是否逐个大于
AR_c > AR_b # 比较复数数组 AR_c 和布尔数组 AR_b 的元素是否逐个大于
AR_c > AR_u # 比较复数数组 AR_c 和无符号整数数组 AR_u 的元素是否逐个大于
AR_c > AR_i # 比较复数数组 AR_c 和整数数组 AR_i 的元素是否逐个大于
AR_c > AR_f # 比较复数数组 AR_c 和浮点数数组 AR_f 的元素是否逐个大于
AR_c > AR_c # 比较两个复数数组 AR_c 的元素是否逐个大于
AR_m > AR_b # 比较时间差数组 AR_m 和布尔数组 AR_b 的元素是否逐个大于
AR_m > AR_u # 比较时间差数组 AR_m 和无符号整数数组 AR_u 的元素是否逐个大于
AR_m > AR_i # 比较时间差数组 AR_m 和整数数组 AR_i 的元素是否逐个大于
AR_b > AR_m # 比较布尔数组 AR_b 和时间差数组 AR_m 的元素是否逐个大于
AR_u > AR_m # 比较无符号整数数组 AR_u 和时间差数组 AR_m 的元素是否逐个大于
AR_i > AR_m # 比较整数数组 AR_i 和时间差数组 AR_m 的元素是否逐个大于
AR_M > AR_M # 比较两个日期时间数组 AR_M 的元素是否逐个大于
AR_O > AR_O # 比较两个对象数组 AR_O 的元素是否逐个大于
1 > AR_O # 比较整数 1 和
.\numpy\numpy\typing\tests\data\pass\dtype.py
import numpy as np # 导入 NumPy 库
dtype_obj = np.dtype(np.str_) # 创建一个数据类型对象，表示字符串
void_dtype_obj = np.dtype([("f0", np.float64), ("f1", np.float32)]) # 创建一个复合数据类型对象，包含两个字段 f0 和 f1
np.dtype(dtype=np.int64) # 创建一个整数类型的数据类型对象，指定为 int64
np.dtype(int) # 创建一个整数类型的数据类型对象，没有指定精度，默认为 int64
np.dtype("int") # 创建一个整数类型的数据类型对象，同样默认为 int64
np.dtype(None) # 创建一个空的数据类型对象，未指定类型信息，默认为 void
np.dtype((int, 2)) # 创建一个包含两个整数的数据类型对象，表示一个长度为 2 的数组
np.dtype((int, (1,))) # 创建一个包含一个整数的数据类型对象，表示一个长度为 1 的数组
np.dtype({"names": ["a", "b"], "formats": [int, float]}) # 创建一个结构化数据类型对象，包含两个字段 a 和 b，分别为 int 和 float 类型
np.dtype({"names": ["a"], "formats": [int], "titles": [object]}) # 创建一个结构化数据类型对象，包含一个字段 a，类型为 int，具有一个标题对象
np.dtype({"names": ["a"], "formats": [int], "titles": [object()]}) # 创建一个结构化数据类型对象，包含一个字段 a，类型为 int，具有一个标题对象
np.dtype([("name", np.str_, 16), ("grades", np.float64, (2,)), ("age", "int32")]) # 创建一个结构化数据类型对象，包含三个字段：name 为固定长度字符串，grades 为长度为 2 的浮点数数组，age 为 int32
np.dtype(
{
"names": ["a", "b"],
"formats": [int, float],
"itemsize": 9,
"aligned": False,
"titles": ["x", "y"],
"offsets": [0, 1],
}
) # 创建一个自定义的结构化数据类型对象，包含两个字段 a 和 b，分别为 int 和 float，设定字节大小为 9，不进行对齐，具有自定义标题和偏移量信息
np.dtype((np.float64, float)) # 创建一个复合数据类型对象，包含两种浮点数类型
class Test:
dtype = np.dtype(float)
np.dtype(Test()) # 使用类 Test 的数据类型属性创建一个数据类型对象
# Methods and attributes
dtype_obj.base # 获取数据类型对象的基类
dtype_obj.subdtype # 获取数据类型对象的子数据类型信息
dtype_obj.newbyteorder() # 创建一个具有新字节顺序的数据类型对象
dtype_obj.type # 获取数据类型对象的类型
dtype_obj.name # 获取数据类型对象的名称
dtype_obj.names # 获取结构化数据类型对象的字段名称
dtype_obj * 0 # 将数据类型对象与整数相乘
dtype_obj * 2 # 将数据类型对象与整数相乘
0 * dtype_obj # 将整数与数据类型对象相乘
2 * dtype_obj # 将整数与数据类型对象相乘
void_dtype_obj["f0"] # 访问复合数据类型对象的字段 f0
void_dtype_obj[0] # 通过索引访问复合数据类型对象的第一个字段
void_dtype_obj[["f0", "f1"]] # 通过列表访问复合数据类型对象的多个字段
void_dtype_obj[["f0"]] # 通过列表访问复合数据类型对象的单个字段
.\numpy\numpy\typing\tests\data\pass\einsumfunc.py
from __future__ import annotations
from typing import Any
import numpy as np
# 声明一些类似数组的对象
AR_LIKE_b = [True, True, True] # 布尔类型的数组样式对象
AR_LIKE_u = [np.uint32(1), np.uint32(2), np.uint32(3)] # 无符号整数类型的数组样式对象
AR_LIKE_i = [1, 2, 3] # 整数类型的数组样式对象
AR_LIKE_f = [1.0, 2.0, 3.0] # 浮点数类型的数组样式对象
AR_LIKE_c = [1j, 2j, 3j] # 复数类型的数组样式对象
AR_LIKE_U = ["1", "2", "3"] # Unicode 字符串类型的数组样式对象
# 创建一个形状为 (3,)、数据类型为 np.float64 的空数组对象
OUT_f: np.ndarray[Any, np.dtype[np.float64]] = np.empty(3, dtype=np.float64)
# 创建一个形状为 (3,)、数据类型为 np.complex128 的空数组对象
OUT_c: np.ndarray[Any, np.dtype[np.complex128]] = np.empty(3, dtype=np.complex128)
# 使用 einsum 函数进行张量运算，以下是一系列示例
np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_b) # 对布尔类型数组样式对象进行元素对应乘法
np.einsum("i,i->i", AR_LIKE_u, AR_LIKE_u) # 对无符号整数类型数组样式对象进行元素对应乘法
np.einsum("i,i->i", AR_LIKE_i, AR_LIKE_i) # 对整数类型数组样式对象进行元素对应乘法
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f) # 对浮点数类型数组样式对象进行元素对应乘法
np.einsum("i,i->i", AR_LIKE_c, AR_LIKE_c) # 对复数类型数组样式对象进行元素对应乘法
np.einsum("i,i->i", AR_LIKE_b, AR_LIKE_i) # 对布尔类型和整数类型数组样式对象进行元素对应乘法
np.einsum("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c) # 复杂的 einsum 操作
# 使用 einsum 函数指定输出的数据类型或者输出数组对象
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, dtype="c16") # 指定输出的数据类型为复数类型
np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=bool, casting="unsafe") # 指定输出的数据类型为布尔类型，不进行安全检查
np.einsum("i,i->i", AR_LIKE_f, AR_LIKE_f, out=OUT_c) # 将结果存储到预先分配的复数类型数组对象中
np.einsum("i,i->i", AR_LIKE_U, AR_LIKE_U, dtype=int, casting="unsafe", out=OUT_f) # 将结果存储到预先分配的浮点数类型数组对象中
# 返回与指定的 einsum 操作相关的优化路径
np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_b) # 返回布尔类型数组样式对象的优化路径
np.einsum_path("i,i->i", AR_LIKE_u, AR_LIKE_u) # 返回无符号整数类型数组样式对象的优化路径
np.einsum_path("i,i->i", AR_LIKE_i, AR_LIKE_i) # 返回整数类型数组样式对象的优化路径
np.einsum_path("i,i->i", AR_LIKE_f, AR_LIKE_f) # 返回浮点数类型数组样式对象的优化路径
np.einsum_path("i,i->i", AR_LIKE_c, AR_LIKE_c) # 返回复数类型数组样式对象的优化路径
np.einsum_path("i,i->i", AR_LIKE_b, AR_LIKE_i) # 返回布尔类型和整数类型数组样式对象的优化路径
np.einsum_path("i,i,i,i->i", AR_LIKE_b, AR_LIKE_u, AR_LIKE_i, AR_LIKE_c) # 返回复杂 einsum 操作的优化路径
.\numpy\numpy\typing\tests\data\pass\flatiter.py
# 导入 NumPy 库，简写为 np
import numpy as np
# 创建一个形状为 (2, 2) 的空数组，并获取其扁平化的迭代器对象
a = np.empty((2, 2)).flat
# 返回数组的基础对象（如果有的话，否则返回 None）
a.base
# 返回数组的一个副本
a.copy()
# 返回一个迭代器，用于扁平化数组的坐标
a.coords
# 返回当前迭代位置的索引
a.index
# 返回数组的迭代器对象
iter(a)
# 返回迭代器的下一个元素
next(a)
# 获取扁平化数组中索引为 0 的元素
a[0]
# 获取扁平化数组中索引为 0, 1, 2 的元素（索引超出范围的部分将抛出 IndexError）
a[[0, 1, 2]]
# 获取整个扁平化数组的切片（类似于获取所有元素）
a[...]
# 获取整个扁平化数组的切片（类似于获取所有元素）
a[:]
# 返回一个数组的视图（如果需要的话），或者返回一个具有指定数据类型的新数组
a.__array__()
# 返回一个数组的视图，并指定返回数组的数据类型为 np.float64
a.__array__(np.dtype(np.float64))
.\numpy\numpy\typing\tests\data\pass\fromnumeric.py
"""Tests for :mod:`numpy._core.fromnumeric`."""
# 导入 numpy 库
import numpy as np
# 创建布尔类型的二维数组 A，初始化为 True
A = np.array(True, ndmin=2, dtype=bool)
# 创建单精度浮点数类型的二维数组 B，初始化为 1.0
B = np.array(1.0, ndmin=2, dtype=np.float32)
# 设置数组 A 的写保护标志，禁止写入操作
A.setflags(write=False)
# 设置数组 B 的写保护标志，禁止写入操作
B.setflags(write=False)
# 创建布尔类型标量 a，初始化为 True
a = np.bool(True)
# 创建单精度浮点数标量 b，初始化为 1.0
b = np.float32(1.0)
# 创建标量 c，初始化为 1.0
c = 1.0
# 创建单精度浮点数类型的数组 d，初始化为 1.0，可写入
d = np.array(1.0, dtype=np.float32) # writeable
# 取出数组 a 中索引为 0 的元素
np.take(a, 0)
# 取出数组 b 中索引为 0 的元素
np.take(b, 0)
# 取出标量 c 的索引为 0 的元素，不支持
np.take(c, 0)
# 取出数组 A 中索引为 0 的元素
np.take(A, 0)
# 取出数组 B 中索引为 0 的元素
np.take(B, 0)
# 取出数组 A 中索引为 0 的元素组成的数组
np.take(A, [0])
# 取出数组 B 中索引为 0 的元素组成的数组
np.take(B, [0])
# 将标量 a 重塑为形状为 (1,) 的数组
np.reshape(a, 1)
# 将标量 b 重塑为形状为 (1,) 的数组
np.reshape(b, 1)
# 将标量 c 重塑为形状为 (1,) 的数组
np.reshape(c, 1)
# 将数组 A 重塑为形状为 (1,) 的数组
np.reshape(A, 1)
# 将数组 B 重塑为形状为 (1,) 的数组
np.reshape(B, 1)
# 从布尔类型标量 a 和给定选择数组中选择元素
np.choose(a, [True, True])
# 从数组 A 和给定选择数组中选择元素
np.choose(A, [1.0, 1.0])
# 对标量 a 重复 1 次
np.repeat(a, 1)
# 对标量 b 重复 1 次
np.repeat(b, 1)
# 对标量 c 重复 1 次
np.repeat(c, 1)
# 对数组 A 重复 1 次
np.repeat(A, 1)
# 对数组 B 重复 1 次
np.repeat(B, 1)
# 交换数组 A 的轴 0 和轴 0
np.swapaxes(A, 0, 0)
# 交换数组 B 的轴 0 和轴 0
np.swapaxes(B, 0, 0)
# 转置布尔类型标量 a
np.transpose(a)
# 转置单精度浮点数标量 b
np.transpose(b)
# 转置标量 c
np.transpose(c)
# 转置数组 A
np.transpose(A)
# 转置数组 B
np.transpose(B)
# 对布尔类型标量 a 进行轴向为 None 的分区排序
np.partition(a, 0, axis=None)
# 对单精度浮点数标量 b 进行轴向为 None 的分区排序
np.partition(b, 0, axis=None)
# 对标量 c 进行轴向为 None 的分区排序
np.partition(c, 0, axis=None)
# 对数组 A 进行以索引 0 为分割点的分区排序
np.partition(A, 0)
# 对数组 B 进行以索引 0 为分割点的分区排序
np.partition(B, 0)
# 返回数组 a 在轴 0 上的分区排序索引
np.argpartition(a, 0)
# 返回数组 b 在轴 0 上的分区排序索引
np.argpartition(b, 0)
# 返回标量 c 在轴 0 上的分区排序索引，不支持
np.argpartition(c, 0)
# 返回数组 A 在轴 0 上的分区排序索引
np.argpartition(A, 0)
# 返回数组 B 在轴 0 上的分区排序索引
np.argpartition(B, 0)
# 返回数组 A 沿轴 0 排序后的结果
np.sort(A, 0)
# 返回数组 B 沿轴 0 排序后的结果
np.sort(B, 0)
# 返回数组 A 沿轴 0 排序后的索引
np.argsort(A, 0)
# 返回数组 B 沿轴 0 排序后的索引
np.argsort(B, 0)
# 返回数组 A 中最大值的索引
np.argmax(A)
# 返回数组 B 中最大值的索引
np.argmax(B)
# 返回数组 A 在轴 0 上最大值的索引
np.argmax(A, axis=0)
# 返回数组 B 在轴 0 上最大值的索引
np.argmax(B, axis=0)
# 返回数组 A 中最小值的索引
np.argmin(A)
# 返回数组 B 中最小值的索引
np.argmin(B)
# 返回数组 A 在轴 0 上最小值的索引
np.argmin(A, axis=0)
# 返回数组 B 在轴 0 上最小值的索引
np.argmin(B, axis=0)
# 在数组 A[0] 中搜索值为 0 的插入点索引
np.searchsorted(A[0], 0)
# 在数组 B[0] 中搜索值为 0 的插入点索引
np.searchsorted(B[0], 0)
# 在数组 A[0] 中搜索值为 [0] 的插入点索引
np.searchsorted(A[0], [0])
# 在数组 B[0] 中搜索值为 [0] 的插入点索引
np.searchsorted(B[0], [0])
# 将标量 a 重塑为形状 (5, 5) 的数组
np.resize(a, (5, 5))
# 将标量 b 重塑为形状 (5, 5) 的数组
np.resize(b, (5, 5))
# 将标量 c 重塑为形状 (5, 5) 的数组
np.resize(c, (5, 5))
# 将数组 A 重塑为形状 (5, 5) 的数组
np.resize(A, (5, 5))
# 将数组 B 重塑为形状 (5, 5) 的数组
np.resize(B, (5, 5))
# 去除数组 a 的单维度条目
np.squeeze(a)
# 去除数组 b 的单维度条目
np.squeeze(b)
# 去除数组 c 的单维度条目
np.squeeze(c)
# 去除数组 A 的单维度条目
np.squeeze(A)
# 去除数组 B 的单维度条目
np.squeeze(B)
# 返回数组 A 的主对角线元素
np.diagonal(A)
# 返回数组 B 的主对角线元素
np.diagonal(B)
# 返回数组 A 的迹
np.trace(A)
# 返回数组 B 的迹
np.trace(B)
# 返回数组 a 的扁平化视图
np.ravel(a)
# 返回数组 b 的扁平化视图
np.ravel(b)
# 返回标量 c 的扁平化视图
np.ravel(c)
# 返回数组 A 的扁平化视图
np.ravel(A)
# 返回数组 B 的扁平化视图
np.ravel(B)
# 返回数组 A 中非零元素的索引
np.nonzero(A)
# 返回数组 B 中非零元素的索引
np.nonzero(B)
# 返回数组 a 的形状
np.shape(a)
# 返回数组 b 的形状
np.shape(b)
# 返回标量 c 的形状，不支持
np.shape(c)
# 返回数组 A 的形状
np.shape(A)
# 返回数组 B 的
# 计算数组 c 的累积乘积
np.cumprod(c)
# 计算数组 A 的累积乘积
np.cumprod(A)
# 计算数组 B 的累积乘积
np.cumprod(B)
# 返回数组 a 的维度数
np.ndim(a)
# 返回数组 b 的维度数
np.ndim(b)
# 返回数组 c 的维度数
np.ndim(c)
# 返回数组 A 的维度数
np.ndim(A)
# 返回数组 B 的维度数
np.ndim(B)
# 返回数组 a 中元素的总数
np.size(a)
# 返回数组 b 中元素的总数
np.size(b)
# 返回数组 c 中元素的总数
np.size(c)
# 返回数组 A 中元素的总数
np.size(A)
# 返回数组 B 中元素的总数
np.size(B)
# 返回数组 a 中每个元素四舍五入到整数
np.around(a)
# 返回数组 b 中每个元素四舍五入到整数
np.around(b)
# 返回数组 c 中每个元素四舍五入到整数
np.around(c)
# 返回数组 A 中每个元素四舍五入到整数
np.around(A)
# 返回数组 B 中每个元素四舍五入到整数
np.around(B)
# 返回数组 a 的平均值
np.mean(a)
# 返回数组 b 的平均值
np.mean(b)
# 返回数组 c 的平均值
np.mean(c)
# 返回数组 A 的所有元素的平均值
np.mean(A)
# 返回数组 B 的所有元素的平均值
np.mean(B)
# 返回数组 A 按行计算的平均值，axis=0 表示沿着第一个轴（行）计算
np.mean(A, axis=0)
# 返回数组 B 按行计算的平均值，axis=0 表示沿着第一个轴（行）计算
np.mean(B, axis=0)
# 返回数组 A 的平均值，并保持原有维度
np.mean(A, keepdims=True)
# 返回数组 B 的平均值，并保持原有维度
np.mean(B, keepdims=True)
# 返回数组 b 的平均值，将结果存储在数组 d 中
np.mean(b, out=d)
# 返回数组 B 的平均值，将结果存储在数组 d 中
np.mean(B, out=d)
# 返回数组 a 的标准差
np.std(a)
# 返回数组 b 的标准差
np.std(b)
# 返回数组 c 的标准差
np.std(c)
# 返回数组 A 的所有元素的标准差
np.std(A)
# 返回数组 B 的所有元素的标准差
np.std(B)
# 返回数组 A 按行计算的标准差，axis=0 表示沿着第一个轴（行）计算
np.std(A, axis=0)
# 返回数组 B 按行计算的标准差，axis=0 表示沿着第一个轴（行）计算
np.std(B, axis=0)
# 返回数组 A 的标准差，并保持原有维度
np.std(A, keepdims=True)
# 返回数组 B 的标准差，并保持原有维度
np.std(B, keepdims=True)
# 返回数组 b 的标准差，将结果存储在数组 d 中
np.std(b, out=d)
# 返回数组 B 的标准差，将结果存储在数组 d 中
np.std(B, out=d)
# 返回数组 a 的方差
np.var(a)
# 返回数组 b 的方差
np.var(b)
# 返回数组 c 的方差
np.var(c)
# 返回数组 A 的所有元素的方差
np.var(A)
# 返回数组 B 的所有元素的方差
np.var(B)
# 返回数组 A 按行计算的方差，axis=0 表示沿着第一个轴（行）计算
np.var(A, axis=0)
# 返回数组 B 按行计算的方差，axis=0 表示沿着第一个轴（行）计算
np.var(B, axis=0)
# 返回数组 A 的方差，并保持原有维度
np.var(A, keepdims=True)
# 返回数组 B 的方差，并保持原有维度
np.var(B, keepdims=True)
# 返回数组 b 的方差，将结果存储在数组 d 中
np.var(b, out=d)
# 返回数组 B 的方差，将结果存储在数组 d 中
np.var(B, out=d)
.\numpy\numpy\typing\tests\data\pass\index_tricks.py
# 导入未来的注释，允许使用类型注释的特性
from __future__ import annotations
# 导入 Any 类型，表示可以是任何类型
from typing import Any
# 导入 NumPy 库，并简写为 np
import numpy as np
# 定义一个布尔类型的二维列表
AR_LIKE_b = [[True, True], [True, True]]
# 定义一个整数类型的二维列表
AR_LIKE_i = [[1, 2], [3, 4]]
# 定义一个浮点数类型的二维列表
AR_LIKE_f = [[1.0, 2.0], [3.0, 4.0]]
# 定义一个字符串类型的二维列表
AR_LIKE_U = [["1", "2"], ["3", "4"]]
# 创建一个整数类型的 NumPy 数组 AR_i8，使用 AR_LIKE_i 作为数据源，指定数据类型为 np.int64
AR_i8: np.ndarray[Any, np.dtype[np.int64]] = np.array(AR_LIKE_i, dtype=np.int64)
# 调用 np.ndenumerate 函数，返回 AR_i8 的枚举对象
np.ndenumerate(AR_i8)
# 调用 np.ndenumerate 函数，返回 AR_LIKE_f 的枚举对象
np.ndenumerate(AR_LIKE_f)
# 调用 np.ndenumerate 函数，返回 AR_LIKE_U 的枚举对象
np.ndenumerate(AR_LIKE_U)
# 获取 AR_i8 的枚举对象并访问其 iter 属性
np.ndenumerate(AR_i8).iter
# 获取 AR_LIKE_f 的枚举对象并访问其 iter 属性
np.ndenumerate(AR_LIKE_f).iter
# 获取 AR_LIKE_U 的枚举对象并访问其 iter 属性
np.ndenumerate(AR_LIKE_U).iter
# 调用 next 函数获取 AR_i8 的枚举对象的下一个元素
next(np.ndenumerate(AR_i8))
# 调用 next 函数获取 AR_LIKE_f 的枚举对象的下一个元素
next(np.ndenumerate(AR_LIKE_f))
# 调用 next 函数获取 AR_LIKE_U 的枚举对象的下一个元素
next(np.ndenumerate(AR_LIKE_U))
# 调用 iter 函数获取 np.ndenumerate(AR_i8) 的可迭代对象
iter(np.ndenumerate(AR_i8))
# 调用 iter 函数获取 np.ndenumerate(AR_LIKE_f) 的可迭代对象
iter(np.ndenumerate(AR_LIKE_f))
# 调用 iter 函数获取 np.ndenumerate(AR_LIKE_U) 的可迭代对象
iter(np.ndenumerate(AR_LIKE_U))
# 调用 iter 函数生成一个 np.ndindex 对象，表示多维数组的索引
iter(np.ndindex(1, 2, 3))
# 调用 next 函数获取 np.ndindex(1, 2, 3) 的下一个元素
next(np.ndindex(1, 2, 3))
# 使用 np.unravel_index 函数根据索引值和形状获取多维数组的坐标
np.unravel_index([22, 41, 37], (7, 6))
# 使用 np.unravel_index 函数根据索引值和形状以及指定的顺序获取多维数组的坐标
np.unravel_index([31, 41, 13], (7, 6), order='F')
# 使用 np.unravel_index 函数根据线性索引和形状获取多维数组的坐标
np.unravel_index(1621, (6, 7, 8, 9))
# 使用 np.ravel_multi_index 函数根据多维数组的坐标和形状获取线性索引
np.ravel_multi_index(AR_LIKE_i, (7, 6))
# 使用 np.ravel_multi_index 函数根据多维数组的坐标、形状和指定的顺序获取线性索引
np.ravel_multi_index(AR_LIKE_i, (7, 6), order='F')
# 使用 np.ravel_multi_index 函数根据多维数组的坐标、形状和指定的模式获取线性索引
np.ravel_multi_index(AR_LIKE_i, (4, 6), mode='clip')
# 使用 np.ravel_multi_index 函数根据多维数组的坐标、形状和指定的模式获取线性索引
np.ravel_multi_index(AR_LIKE_i, (4, 4), mode=('clip', 'wrap'))
# 使用 np.ravel_multi_index 函数根据指定的坐标和形状获取线性索引
np.ravel_multi_index((3, 1, 4, 1), (6, 7, 8, 9))
# 使用 np.mgrid 函数创建多维网格
np.mgrid[1:1:2]
np.mgrid[1:1:2, None:10]
# 使用 np.ogrid 函数创建多维开放网格
np.ogrid[1:1:2]
np.ogrid[1:1:2, None:10]
# 使用 np.index_exp 函数创建扩展的索引
np.index_exp[0:1]
np.index_exp[0:1, None:3]
np.index_exp[0, 0:1, ..., [0, 1, 3]]
# 使用 np.s_ 函数创建扩展的切片对象
np.s_[0:1]
np.s_[0:1, None:3]
np.s_[0, 0:1, ..., [0, 1, 3]]
# 使用 np.ix_ 函数根据指定的数组创建广播后的索引器
np.ix_(AR_LIKE_b[0])
np.ix_(AR_LIKE_i[0], AR_LIKE_f[0])
np.ix_(AR_i8[0])
# 使用 np.fill_diagonal 函数将数组的对角线填充为指定的值
np.fill_diagonal(AR_i8, 5)
# 使用 np.diag_indices 函数获取指定大小的对角线索引
np.diag_indices(4)
# 使用 np.diag_indices 函数获取指定大小和偏移的对角线索引
np.diag_indices(2, 3)
# 使用 np.diag_indices_from 函数根据指定的数组获取对角线索引
np.diag_indices_from(AR_i8)
.\numpy\numpy\typing\tests\data\pass\lib_utils.py
# 引入未来版本的注解支持
from __future__ import annotations
# 从 io 模块中引入 StringIO 类
from io import StringIO
# 引入 numpy 库，并将其命名为 np
import numpy as np
# 引入 numpy 库中的 array_utils 模块
import numpy.lib.array_utils as array_utils
# 创建一个字符串缓冲区对象 FILE
FILE = StringIO()
# 创建一个包含 0 到 9 的浮点数数组 AR，数据类型为 np.float64
AR = np.arange(10, dtype=np.float64)
# 定义一个函数 func，参数 a 是整数类型，返回值是布尔类型
def func(a: int) -> bool:
return True
# 调用 array_utils 模块的 byte_bounds 函数，传入 AR 数组作为参数
array_utils.byte_bounds(AR)
# 调用 array_utils 模块的 byte_bounds 函数，传入 np.float64() 对象作为参数
array_utils.byte_bounds(np.float64())
# 调用 numpy 的 info 函数，打印关于数字 1 的信息，输出重定向到 FILE 对象
np.info(1, output=FILE)
.\numpy\numpy\typing\tests\data\pass\lib_version.py
# 从 numpy 库中导入 NumpyVersion 类
from numpy.lib import NumpyVersion
# 创建一个 NumpyVersion 对象，表示版本号为 "1.8.0"
version = NumpyVersion("1.8.0")
# 获取版本号的字符串表示形式
version.vstring
# 获取版本号的完整列表形式
version.version
# 获取版本号的主要版本号部分
version.major
# 获取版本号的次要版本号部分
version.minor
# 获取版本号的修订版本号部分
version.bugfix
# 获取版本号的预发布版本信息，如果有的话
version.pre_release
# 检查版本号是否为开发版本
version.is_devversion
# 检查两个版本号对象是否相等
version == version
# 检查两个版本号对象是否不相等
version != version
# 检查版本号对象是否小于给定的版本号字符串 "1.8.0"
version < "1.8.0"
# 检查版本号对象是否小于等于另一个版本号对象
version <= version
# 检查版本号对象是否大于另一个版本号对象
version > version
# 检查版本号对象是否大于等于给定的版本号字符串 "1.8.0"
version >= "1.8.0"
.\numpy\numpy\typing\tests\data\pass\literal.py
# 导入未来的注释支持，以便在类型提示中使用类型的字符串表示
from __future__ import annotations
# 导入必要的类型提示
from typing import Any
from functools import partial
from collections.abc import Callable
# 导入 pytest 和 numpy 库
import pytest
import numpy as np
# 创建一个不可变的 NumPy 数组 AR，标记为不可写
AR = np.array(0)
AR.setflags(write=False)
# 定义几个不可变的集合，用于限制函数的可选参数
KACF = frozenset({None, "K", "A", "C", "F"})
ACF = frozenset({None, "A", "C", "F"})
CF = frozenset({None, "C", "F"})
# order_list 列表包含了多个元组，每个元组包含一个集合和一个可调用对象的部分应用
order_list: list[tuple[frozenset[str | None], Callable[..., Any]]] = [
(KACF, partial(np.ndarray, 1)), # 使用 np.ndarray 创建一个一维数组的部分应用
(KACF, AR.tobytes), # 将数组 AR 转换为字节串的方法
(KACF, partial(AR.astype, int)), # 将数组 AR 转换为整数类型的部分应用
(KACF, AR.copy), # 复制数组 AR 的方法
(ACF, partial(AR.reshape, 1)), # 将数组 AR 重塑为一维数组的部分应用
(KACF, AR.flatten), # 将数组 AR 展平为一维数组的方法
(KACF, AR.ravel), # 将数组 AR 拉直为一维数组的方法
(KACF, partial(np.array, 1)), # 使用 np.array 创建一个一维数组的部分应用
(CF, partial(np.zeros, 1)), # 使用 np.zeros 创建一个全零数组的部分应用
(CF, partial(np.ones, 1)), # 使用 np.ones 创建一个全一数组的部分应用
(CF, partial(np.empty, 1)), # 使用 np.empty 创建一个空数组的部分应用
(CF, partial(np.full, 1, 1)), # 使用 np.full 创建一个填充值为 1 的数组的部分应用
(KACF, partial(np.zeros_like, AR)), # 使用 np.zeros_like 根据 AR 创建全零数组的部分应用
(KACF, partial(np.ones_like, AR)), # 使用 np.ones_like 根据 AR 创建全一数组的部分应用
(KACF, partial(np.empty_like, AR)), # 使用 np.empty_like 根据 AR 创建空数组的部分应用
(KACF, partial(np.full_like, AR, 1)), # 使用 np.full_like 根据 AR 创建填充值为 1 的数组的部分应用
(KACF, partial(np.add, 1, 1)), # 使用 np.add 创建加法函数的部分应用，即 np.ufunc.__call__
(ACF, partial(np.reshape, AR, 1)), # 使用 np.reshape 根据 AR 创建一维数组的部分应用
(KACF, partial(np.ravel, AR)), # 使用 np.ravel 将 AR 拉直为一维数组的部分应用
(KACF, partial(np.asarray, 1)), # 使用 np.asarray 创建一个数组的部分应用
(KACF, partial(np.asanyarray, 1)), # 使用 np.asanyarray 创建一个可作为数组的对象的部分应用
]
# 遍历 order_list 中的每个元组
for order_set, func in order_list:
# 对于 order_set 中的每个 order，调用 func 函数
for order in order_set:
func(order=order)
# 对于不在 order_set 中的每个 order，验证调用 func 会引发 ValueError 异常
invalid_orders = KACF - order_set
for order in invalid_orders:
with pytest.raises(ValueError):
func(order=order)
.\numpy\numpy\typing\tests\data\pass\ma.py
# 导入必要的模块和类型
from typing import Any
# 导入 NumPy 库及其子模块，用于科学计算和数组处理
import numpy as np
import numpy.ma
# 创建一个带有掩码的 NumPy 掩码数组
# 数据数组为 [1.5, 2, 3]，掩码数组为 [True, False, True]
m : np.ma.MaskedArray[Any, np.dtype[np.float64]] = np.ma.masked_array([1.5, 2, 3], mask=[True, False, True])
.\numpy\numpy\typing\tests\data\pass\mod.py
import numpy as np # 导入 NumPy 库，通常用于科学计算
f8 = np.float64(1) # 创建一个 64 位浮点数对象 f8，赋值为 1
i8 = np.int64(1) # 创建一个 64 位有符号整数对象 i8，赋值为 1
u8 = np.uint64(1) # 创建一个 64 位无符号整数对象 u8，赋值为 1
f4 = np.float32(1) # 创建一个 32 位浮点数对象 f4，赋值为 1
i4 = np.int32(1) # 创建一个 32 位有符号整数对象 i4，赋值为 1
u4 = np.uint32(1) # 创建一个 32 位无符号整数对象 u4，赋值为 1
td = np.timedelta64(1, "D") # 创建一个表示一天时间间隔的 timedelta64 对象 td，赋值为 1 天
b_ = np.bool(1) # 创建一个布尔值对象 b_，赋值为 True
b = bool(1) # 创建一个布尔值对象 b，赋值为 True
f = float(1) # 创建一个浮点数对象 f，赋值为 1.0
i = int(1) # 创建一个整数对象 i，赋值为 1
AR = np.array([1], dtype=np.bool) # 创建一个 NumPy 数组 AR，包含一个布尔值元素
AR.setflags(write=False) # 设置数组 AR 为只读模式，不可写入
AR2 = np.array([1], dtype=np.timedelta64) # 创建一个 NumPy 数组 AR2，包含一个时间间隔元素
AR2.setflags(write=False) # 设置数组 AR2 为只读模式，不可写入
# Time structures
td % td # 计算时间间隔 td 对自身的取模运算
td % AR2 # 计算时间间隔 td 对数组 AR2 的取模运算
AR2 % td # 计算数组 AR2 的时间间隔元素对 td 的取模运算
divmod(td, td) # 计算时间间隔 td 与自身的商和余数
divmod(td, AR2) # 计算时间间隔 td 与数组 AR2 的每个元素的商和余数
divmod(AR2, td) # 计算数组 AR2 的每个元素与时间间隔 td 的商和余数
# Bool
b_ % b # 计算布尔值对象 b_ 对布尔值对象 b 的取模运算
b_ % i # 计算布尔值对象 b_ 对整数对象 i 的取模运算
b_ % f # 计算布尔值对象 b_ 对浮点数对象 f 的取模运算
b_ % b_ # 计算布尔值对象 b_ 对自身的取模运算
b_ % i8 # 计算布尔值对象 b_ 对整数对象 i8 的取模运算
b_ % u8 # 计算布尔值对象 b_ 对无符号整数对象 u8 的取模运算
b_ % f8 # 计算布尔值对象 b_ 对浮点数对象 f8 的取模运算
b_ % AR # 计算布尔值对象 b_ 对数组 AR 的取模运算
divmod(b_, b) # 计算布尔值对象 b_ 与布尔值对象 b 的商和余数
divmod(b_, i) # 计算布尔值对象 b_ 与整数对象 i 的商和余数
divmod(b_, f) # 计算布尔值对象 b_ 与浮点数对象 f 的商和余数
divmod(b_, b_) # 计算布尔值对象 b_ 与自身的商和余数
divmod(b_, i8) # 计算布尔值对象 b_ 与整数对象 i8 的商和余数
divmod(b_, u8) # 计算布尔值对象 b_ 与无符号整数对象 u8 的商和余数
divmod(b_, f8) # 计算布尔值对象 b_ 与浮点数对象 f8 的商和余数
divmod(b_, AR) # 计算布尔值对象 b_ 与数组 AR 的商和余数
b % b_ # 计算布尔值对象 b 对布尔值对象 b_ 的取模运算
i % b_ # 计算整数对象 i 对布尔值对象 b_ 的取模运算
f % b_ # 计算浮点数对象 f 对布尔值对象 b_ 的取模运算
b_ % b_ # 计算布尔值对象 b_ 对自身的取模运算
i8 % b_ # 计算整数对象 i8 对布尔值对象 b_ 的取模运算
u8 % b_ # 计算无符号整数对象 u8 对布尔值对象 b_ 的取模运算
f8 % b_ # 计算浮点数对象 f8 对布尔值对象 b_ 的取模运算
AR % b_ # 计算数组 AR 对布尔值对象 b_ 的取模运算
divmod(b, b_) # 计算布尔值对象 b 与布尔值对象 b_ 的商和余数
divmod(i, b_) # 计算整数对象 i 与布尔值对象 b_ 的商和余数
divmod(f, b_) # 计算浮点数对象 f 与布尔值对象 b_ 的商和余数
divmod(b_, b_) # 计算布尔值对象 b_ 与自身的商和余数
divmod(i8, b_) # 计算整数对象 i8 与布尔值对象 b_ 的商和余数
divmod(u8, b_) # 计算无符号整数对象 u8 与布尔值对象 b_ 的商和余数
divmod(f8, b_) # 计算浮点数对象 f8 与布尔值对象 b_ 的商和余数
divmod(AR, b_) # 计算数组 AR 与布尔值对象 b_ 的商和余数
# int
i8 % b # 计算整数对象 i8 对布尔值对象 b 的取模运算
i8 % i # 计算整数对象 i8 对整数对象 i 的取模运算
i8 % f # 计算整数对象 i8 对浮点数对象 f 的取模运算
i8 % i8 # 计算整数对象 i8 对自身的取模运算
i8 % f8 # 计算整数对象 i8 对浮点数对象 f8 的取模运算
i4 % i8 # 计算整数对象 i4 对整数对象 i8 的取模运算
i4 % f8 # 计算整数对象 i4 对浮点数对象 f8 的取模运算
i4 % i4 # 计算整数对象 i4 对自身的取模运算
i4 % f4 # 计算整数对象 i4 对浮点数对象 f4 的取模运算
i8 % AR # 计算整数对象 i8 对数组 AR 的取模运算
divmod(i8, b) # 计算整数对象 i8 与布尔值对象 b 的商和余数
divmod(i8, i) # 计算整数对象 i8 与整数对象 i 的商和余数
divmod(i8, f) # 计算整数对象 i8 与浮点数对象 f 的商和余数
divmod(i8, i8) # 计算整数对象 i8 对自身的商和余数
divmod(i8, f8) # 计算整数对象 i8 与浮点数对象 f8 的商和余数
divmod(i8, i4) # 计算整数对象 i8 与整数对象 i4 的商和余数
divmod(i8, f4) # 计算整数对象 i8 与浮点数对象 f4 的商和余数
divmod(i4,
.\numpy\numpy\typing\tests\data\pass\modules.py
# 导入 numpy 库，使用 np 作为别名
import numpy as np
# 从 numpy 中导入 f2py 模块
from numpy import f2py
# numpy 模块中的子模块和包
# 字符串操作相关的子模块
np.char
# ctypes 相关的子模块
np.ctypeslib
# 扩展数学函数相关的子模块
np.emath
# 快速傅里叶变换相关的子模块
np.fft
# 通用函数和数组操作相关的子模块
np.lib
# 线性代数操作相关的子模块
np.linalg
# 掩码数组相关的子模块
np.ma
# 矩阵操作相关的子模块
np.matrixlib
# 多项式操作相关的子模块
np.polynomial
# 随机数生成相关的子模块
np.random
# 记录数组相关的子模块
np.rec
# 字符串相关的子模块
np.strings
# 测试相关的子模块
np.testing
# numpy 版本信息相关的子模块
np.version
# numpy.lib 中的子模块
np.lib.format
np.lib.mixins
np.lib.scimath
np.lib.stride_tricks
np.lib.array_utils
# 掩码数组 (masked arrays) 的额外函数
np.ma.extras
# Chebyshev 多项式相关的子模块
np.polynomial.chebyshev
# Hermite 多项式相关的子模块
np.polynomial.hermite
# Hermite_e 多项式相关的子模块
np.polynomial.hermite_e
# Laguerre 多项式相关的子模块
np.polynomial.laguerre
# Legendre 多项式相关的子模块
np.polynomial.legendre
# 多项式操作的基类
np.polynomial.polynomial
# numpy 主命名空间的路径
np.__path__
# numpy 的版本号
np.__version__
# numpy 主命名空间中的 __all__ 变量
np.__all__
# numpy.char 中的 __all__ 变量
np.char.__all__
# numpy.ctypeslib 中的 __all__ 变量
np.ctypeslib.__all__
# numpy.emath 中的 __all__ 变量
np.emath.__all__
# numpy.lib 中的 __all__ 变量
np.lib.__all__
# numpy.ma 中的 __all__ 变量
np.ma.__all__
# numpy.random 中的 __all__ 变量
np.random.__all__
# numpy.rec 中的 __all__ 变量
np.rec.__all__
# numpy.strings 中的 __all__ 变量
np.strings.__all__
# numpy.testing 中的 __all__ 变量
np.testing.__all__
# numpy.f2py 中的 __all__ 变量
f2py.__all__
.\numpy\numpy\typing\tests\data\pass\multiarray.py
# 导入 numpy 库并为变量指定类型
import numpy as np
import numpy.typing as npt
# 声明一个包含单个浮点数的一维数组 AR_f8
AR_f8: npt.NDArray[np.float64] = np.array([1.0])
# 声明一个包含单个整数的一维数组 AR_i4，并指定数据类型为 int32
AR_i4 = np.array([1], dtype=np.int32)
# 声明一个包含单个无符号整数的一维数组 AR_u1，并指定数据类型为 uint8
AR_u1 = np.array([1], dtype=np.uint8)
# 使用 AR_f8 创建一个广播对象 b_f8
b_f8 = np.broadcast(AR_f8)
# 调用广播对象 b_f8 的方法 next()，获取下一个元素
next(b_f8)
# 重置广播对象 b_f8 的迭代状态
b_f8.reset()
# 返回广播对象 b_f8 的当前索引
b_f8.index
# 返回广播对象 b_f8 的迭代器元组
b_f8.iters
# 返回广播对象 b_f8 的维度
b_f8.nd
# 返回广播对象 b_f8 的维度数
b_f8.ndim
# 返回广播对象 b_f8 的迭代器数量
b_f8.numiter
# 返回广播对象 b_f8 的形状
b_f8.shape
# 返回广播对象 b_f8 的大小
b_f8.size
# 使用 AR_i4, AR_f8, AR_f8 创建一个多元广播对象 b_i4_f8_f8
next(b_i4_f8_f8)
# 重置多元广播对象 b_i4_f8_f8 的迭代状态
b_i4_f8_f8.reset()
# 返回多元广播对象 b_i4_f8_f8 的维度
b_i4_f8_f8.ndim
# 返回多元广播对象 b_i4_f8_f8 的当前索引
b_i4_f8_f8.index
# 返回多元广播对象 b_i4_f8_f8 的迭代器元组
b_i4_f8_f8.iters
# 返回多元广播对象 b_i4_f8_f8 的维度
b_i4_f8_f8.nd
# 返回多元广播对象 b_i4_f8_f8 的迭代器数量
b_i4_f8_f8.numiter
# 返回多元广播对象 b_i4_f8_f8 的形状
b_i4_f8_f8.shape
# 返回多元广播对象 b_i4_f8_f8 的大小
b_i4_f8_f8.size
# 计算 AR_f8 和 AR_i4 的内积
np.inner(AR_f8, AR_i4)
# 返回数组中满足条件的索引
np.where([True, True, False])
# 根据条件返回数组中的值
np.where([True, True, False], 1, 0)
# 使用给定的键排序多维数组
np.lexsort([0, 1, 2])
# 检查是否可以将指定类型转换为另一类型
np.can_cast(np.dtype("i8"), int)
# 检查是否可以将 AR_f8 转换为指定类型 "f8"
np.can_cast(AR_f8, "f8")
# 检查是否可以将 AR_f8 转换为复数类型 np.complex128，使用不安全转换
np.can_cast(AR_f8, np.complex128, casting="unsafe")
# 返回数组中能够精确表示所有值的最小标量类型
np.min_scalar_type([1])
# 返回 AR_f8 中能够精确表示所有值的最小标量类型
np.min_scalar_type(AR_f8)
# 返回数组的结果类型
np.result_type(int, AR_i4)
# 返回 AR_f8 和 AR_u1 的结果类型
np.result_type(AR_f8, AR_u1)
# 返回 AR_f8 和 np.complex128 的结果类型
np.result_type(AR_f8, np.complex128)
# 计算向量的点积
np.dot(AR_LIKE_f, AR_i4)
# 计算标量与数组的乘积
np.dot(AR_u1, 1)
# 计算复数与标量的乘积
np.dot(1.5j, 1)
# 计算标量与数组的乘积，并将结果存储到 AR_f8
np.dot(AR_u1, 1, out=AR_f8)
# 计算向量的内积
np.vdot(AR_LIKE_f, AR_i4)
# 计算标量与数组的内积
np.vdot(AR_u1, 1)
# 计算复数与标量的内积
np.vdot(1.5j, 1)
# 计算数组中每个元素的出现次数
np.bincount(AR_i4)
# 将源数组的内容复制到目标数组
np.copyto(AR_f8, [1.6])
# 根据条件将值放入目标数组
np.putmask(AR_f8, [True], 1.5)
# 将整数数组打包为二进制位数组
np.packbits(AR_i4)
# 将无符号整数数组打包为二进制位数组
np.packbits(AR_u1)
# 将二进制位数组解包为整数数组
np.unpackbits(AR_u1)
# 检查两个对象是否共享内存
np.shares_memory(1, 2)
# 检查多个对象是否共享内存，设置最大工作数为 1
np.shares_memory(AR_f8, AR_f8, max_work=1)
# 检查两个对象是否可能共享内存
np.may_share_memory(1, 2)
# 检查多个对象是否可能共享内存，设置最大工作数为 1
np.may_share_memory(AR_f8, AR_f8, max_work=1)
.\numpy\numpy\typing\tests\data\pass\ndarray_conversion.py
# 导入标准库 os 和临时文件模块 tempfile
import os
import tempfile
# 导入第三方库 numpy 并使用 np 别名
import numpy as np
# 创建一个二维 numpy 数组
nd = np.array([[1, 2], [3, 4]])
# 创建一个包含单个元素的 numpy 数组
scalar_array = np.array(1)
# 使用 item 方法获取单个元素值
scalar_array.item()
# 使用 item 方法获取指定位置的元素值
nd.item(1)
# 使用 item 方法获取指定行列的元素值
nd.item(0, 1)
# 使用 item 方法获取指定元素位置的值
nd.item((0, 1))
# 将数组以字节流形式表示
nd.tobytes()
# 将数组以 C 顺序的字节流形式表示
nd.tobytes("C")
# 将数组以默认顺序的字节流形式表示
nd.tobytes(None)
# 在非 Windows 系统下，使用临时文件将数组写入文件
if os.name != "nt":
with tempfile.NamedTemporaryFile(suffix=".txt") as tmp:
nd.tofile(tmp.name) # 默认以二进制格式写入文件
nd.tofile(tmp.name, "") # 空字符串作为分隔符
nd.tofile(tmp.name, sep="") # 空字符串作为分隔符
nd.tofile(tmp.name, "", "%s") # 空字符串作为分隔符，格式为 %s
nd.tofile(tmp.name, format="%s") # 格式为 %s
nd.tofile(tmp) # 将数组写入临时文件对象
# dump 方法非常简单，没有添加注释
# dumps 方法非常简单，没有添加注释
# 将数组转换为指定类型的副本
nd.astype("float")
nd.astype(float)
# 将数组转换为指定类型和顺序的副本
nd.astype(float, "K")
nd.astype(float, order="K")
# 将数组转换为指定类型和顺序，选择不安全的转换方式
nd.astype(float, "K", "unsafe")
nd.astype(float, casting="unsafe")
# 将数组转换为指定类型和顺序，选择不安全的转换方式和复制行为
nd.astype(float, "K", "unsafe", True)
nd.astype(float, subok=True)
# 将数组转换为指定类型和顺序，选择不安全的转换方式和复制行为和对齐方式
nd.astype(float, "K", "unsafe", True, True)
nd.astype(float, copy=True)
# 在原地交换数组元素的字节顺序
nd.byteswap()
nd.byteswap(True)
# 创建数组的副本
nd.copy()
nd.copy("C")
# 返回数组的视图
nd.view()
nd.view(np.int64)
nd.view(dtype=np.int64)
nd.view(np.int64, np.matrix)
nd.view(type=np.matrix)
# 从复数数组中获取指定域的数据
complex_array = np.array([[1 + 1j, 0], [0, 1 - 1j]], dtype=np.complex128)
complex_array.getfield("float")
complex_array.getfield(float)
# 从复数数组中获取指定偏移量和域的数据
complex_array.getfield("float", 8)
complex_array.getfield(float, offset=8)
# 设置数组的标志位
nd.setflags()
# 设置数组的标志位，启用写入模式
nd.setflags(True)
nd.setflags(write=True)
# 设置数组的标志位，启用写入模式和对齐
nd.setflags(True, True)
nd.setflags(write=True, align=True)
# 设置数组的标志位，启用写入模式和对齐，禁用用户自定义标志位
nd.setflags(True, True, False)
nd.setflags(write=True, align=True, uic=False)
# fill 方法非常简单，没有添加注释
.\numpy\numpy\typing\tests\data\pass\ndarray_misc.py
"""
Tests for miscellaneous (non-magic) ``np.ndarray``/``np.generic`` methods.
More extensive tests are performed for the methods'
function-based counterpart in `../from_numeric.py`.
"""
# 导入必要的模块和类型声明
from __future__ import annotations # 使用未来版本的类型注解支持
import operator # 导入运算符模块
from typing import cast, Any # 导入类型提示相关模块
import numpy as np # 导入 NumPy 库
import numpy.typing as npt # 导入 NumPy 的类型提示模块
class SubClass(npt.NDArray[np.float64]): ... # 定义一个继承自 np.float64 的子类 SubClass
i4 = np.int32(1) # 创建一个 np.int32 类型的标量 i4
A: np.ndarray[Any, np.dtype[np.int32]] = np.array([[1]], dtype=np.int32) # 创建一个形状为 (1, 1) 的 np.ndarray A，元素类型为 np.int32
B0 = np.empty((), dtype=np.int32).view(SubClass) # 创建一个空数组 B0，将其视图转换为 SubClass 类型
B1 = np.empty((1,), dtype=np.int32).view(SubClass) # 创建一个形状为 (1,) 的空数组 B1，将其视图转换为 SubClass 类型
B2 = np.empty((1, 1), dtype=np.int32).view(SubClass) # 创建一个形状为 (1, 1) 的空数组 B2，将其视图转换为 SubClass 类型
C: np.ndarray[Any, np.dtype[np.int32]] = np.array([0, 1, 2], dtype=np.int32) # 创建一个形状为 (3,) 的 np.ndarray C，元素类型为 np.int32
D = np.ones(3).view(SubClass) # 创建一个包含三个元素的全为 1 的数组 D，并将其视图转换为 SubClass 类型
i4.all() # 调用 i4 的 all 方法，返回所有元素是否为 True 的布尔值
A.all() # 调用 A 的 all 方法，返回所有元素是否为 True 的布尔值
A.all(axis=0) # 调用 A 的 all 方法，按列计算所有元素是否为 True 的布尔值
A.all(keepdims=True) # 调用 A 的 all 方法，保持维度，返回所有元素是否为 True 的布尔值
A.all(out=B0) # 调用 A 的 all 方法，将结果存入数组 B0 中
i4.any() # 调用 i4 的 any 方法，返回是否存在任意元素为 True 的布尔值
A.any() # 调用 A 的 any 方法，返回是否存在任意元素为 True 的布尔值
A.any(axis=0) # 调用 A 的 any 方法，按列计算是否存在任意元素为 True 的布尔值
A.any(keepdims=True) # 调用 A 的 any 方法，保持维度，返回是否存在任意元素为 True 的布尔值
A.any(out=B0) # 调用 A 的 any 方法，将结果存入数组 B0 中
i4.argmax() # 返回 i4 中最大元素的索引
A.argmax() # 返回 A 中最大元素的索引
A.argmax(axis=0) # 返回 A 中每列最大元素的索引
A.argmax(out=B0) # 返回 A 中最大元素的索引，并将结果存入数组 B0 中
i4.argmin() # 返回 i4 中最小元素的索引
A.argmin() # 返回 A 中最小元素的索引
A.argmin(axis=0) # 返回 A 中每列最小元素的索引
A.argmin(out=B0) # 返回 A 中最小元素的索引，并将结果存入数组 B0 中
i4.argsort() # 返回 i4 的元素排序后的索引
A.argsort() # 返回 A 的元素排序后的索引
i4.choose([()]) # 根据索引数组选择 i4 中的元素
_choices = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=np.int32) # 创建一个选择数组 _choices
C.choose(_choices) # 根据选择数组 _choices 选择 C 中的元素
C.choose(_choices, out=D) # 根据选择数组 _choices 选择 C 中的元素，并将结果存入数组 D 中
i4.clip(1) # 将 i4 的元素限制在指定范围内，小于 1 的变为 1
A.clip(1) # 将 A 的元素限制在指定范围内，小于 1 的变为 1
A.clip(None, 1) # 将 A 的元素限制在指定范围内，大于 1 的变为 1
A.clip(1, out=B2) # 将 A 的元素限制在指定范围内，并将结果存入数组 B2 中
A.clip(None, 1, out=B2) # 将 A 的元素限制在指定范围内，大于 1 的变为 1，并将结果存入数组 B2 中
i4.compress([1]) # 返回根据条件压缩后的 i4 的数组
A.compress([1]) # 返回根据条件压缩后的 A 的数组
A.compress([1], out=B1) # 返回根据条件压缩后的 A 的数组，并将结果存入数组 B1 中
i4.conj() # 返回 i4 的共轭复数
A.conj() # 返回 A 的每个元素的共轭复数
B0.conj() # 返回 B0 的每个元素的共轭复数
i4.conjugate() # 返回 i4 的共轭复数
A.conjugate() # 返回 A 的每个元素的共轭复数
B0.conjugate() # 返回 B0 的每个元素的共轭复数
i4.cumprod() # 返回 i4 的累积乘积
A.cumprod() # 返回 A 的每个元素的累积乘积
A.cumprod(out=B1) # 返回 A 的每个元素的累积乘积，并将结果存入数组 B1 中
i4.cumsum() # 返回 i4 的累积和
A.cumsum() # 返回 A 的每个元素的累积和
A.cumsum(out=B1) # 返回 A 的每个元素的累积和，并将结果存入数组 B1 中
i4.max() # 返回 i4 的最大值
A.max() # 返回 A 的最大值
A.max(axis=0) # 返回 A 中每列的最大值
A.max(keepdims=True) # 返回 A 的最大值，并保持维度
A.max(out=B0) # 返回 A 的最大值，并将结果存入数组 B0 中
i4.mean() # 返回 i4 的平均值
A.mean() # 返回 A 的平均值
A.mean(axis=0) # 返回 A 中每列的平均值
A.mean(keepdims=True) # 返回 A 的平均值，并保持维度
A.mean(out=B0) # 返回 A 的平均值，并将结果存入数组 B0 中
i4.min() # 返回 i4 的最小值
A.min() # 返回 A 的最小值
A.min(axis=0) # 返回 A 中每列的最小值
A.min(keepdims=True) # 返回 A 的最小值，并保持维度
A.min(out=B0) # 返回 A 的最小值，并将结果存入数组 B0 中
i4.prod() # 返回 i4 的所有元素的乘积
A.prod() # 返回 A 的所有元素的乘积
A.prod(axis=0) # 返回 A 中每列元素的乘积
A.prod(keepdims=True) # 返回 A 的所有元素的乘积，并保持维度
A.prod(out=B0) # 返回 A 的所有元素的乘积，并将结果存入数组 B0 中
i4.round() # 返回 i4
