【Rust 精进之路之第4篇-数据基石·上】标量类型：整数、浮点数、布尔与字符的精妙之处

系列： Rust 精进之路：构建可靠、高效软件的底层逻辑
作者： 码觉客
发布日期： 2025-04-20

引言：构成万物的“原子”——标量类型

在上一篇文章【变量观】中，我们深入探讨了 Rust 如何通过 let、mut、const、static 和 Shadowing 来管理变量绑定，并理解了其背后对安全性和清晰性的重视。我们知道了如何为数据命名和设定规则，现在，是时候看看这些变量“盒子”里具体能装些什么了。

任何复杂的程序，归根结底都是由最基础的数据单元构成的。在 Rust 中，这些最基础的、不可再分的数据类型被称为标量类型 (Scalar Types)。它们是构成更复杂数据结构（如数组、结构体）的“原子”。Rust 的标量类型主要有四种：整数 (Integers)、浮点数 (Floating-Point Numbers)、布尔值 (Booleans) 和字符 (Characters)。

你可能觉得这些类型在其他语言里也司空见惯，但在 Rust 中，即使是这些基础类型，也蕴含着其独特的设计考量，特别是在类型安全、内存表示和行为定义（如整数溢出处理）方面。理解这些细节，对于编写精确、高效且健壮的 Rust 代码至关重要。本文将带你逐一解剖这四大标量类型，探索它们在 Rust 世界中的精妙之处。

一、整数类型 (Integer Types)：精确的大小与溢出处理

整数是没有小数部分的数字。Rust 提供了一系列内置的整数类型，它们的主要区别在于位宽 (bit width) 和是否有符号 (signedness)。

  • 有符号整数 (Signed Integers): 类型名称以 i 开头 (代表 integer)，可以表示正数、负数和零。它们使用二进制补码 (Two’s Complement) 表示法。
    • i8, i16, i32, i64, i128: 分别占用 8, 16, 32, 64, 128 位内存空间。
    • isize: 其大小取决于目标计算机的架构（32位系统上是 32 位，64位系统上是 64 位）。主要用于指针偏移量和集合索引。
  • 无符号整数 (Unsigned Integers): 类型名称以 u 开头 (代表 unsigned)，只能表示非负数（零和正数）。
    • u8, u16, u32, u64, u128: 同样分别占用 8, 16, 32, 64, 128 位内存空间。
    • usize: 大小同样取决于目标架构，与 isize 对应。所有集合类型（如数组、Vec、切片）的索引都必须是 usize 类型。这是因为索引代表内存偏移量，其最大值不能超过地址空间的大小。

表示范围：
一个 n 位的有符号整数可以表示从 -(2^(n-1)) 到 2^(n-1) - 1 的数。
一个 n 位的无符号整数可以表示从 0 到 2^n - 1 的数。
例如，i8 的范围是 -128 到 127，而 u8 的范围是 0 到 255。

整数的字面量表示 (Integer Literals):
Rust 支持多种格式的整数常量写法：

fn main() {let decimal = 98_222;       // 十进制 (Decimal) - 下划线可作为视觉分隔符，不影响值let hex = 0xff;           // 十六进制 (Hex) - 以 0x 开头let octal = 0o77;         // 八进制 (Octal) - 以 0o 开头let binary = 0b1111_0000; // 二进制 (Binary) - 以 0b 开头let byte = b'A';          // 字节 (Byte) - 仅适用于 u8，表示 ASCII 字符的字节值println!("Decimal: {}", decimal); // 输出: 98222println!("Hex: {}", hex);       // 输出: 255println!("Octal: {}", octal);     // 输出: 63println!("Binary: {}", binary);   // 输出: 240println!("Byte (u8): {}", byte);   // 输出: 65 (A 的 ASCII 值)// 整数类型后缀let big_number = 3_000_000_000u64; // 显式指定为 u64println!("Big number: {}", big_number);// usize 示例let array = [1, 2, 3];let index: usize = 1; // 索引必须是 usize 类型println!("数组第二个元素: {}", array[index]); // 输出: 2
}

整数的默认类型：
如果在没有足够上下文让编译器推断类型的情况下使用整数常量，Rust 会默认将其视为 i32。这是因为 i32 在大多数现代处理器上性能良好，并且其大小适中，适用于很多常见场景。

关键点：整数溢出 (Integer Overflow)

当一个整数运算的结果超出了该类型所能表示的范围时，就会发生溢出。例如，一个 u8 类型的变量最大能存 255，如果你给它加 1，结果会是什么？

Rust 对待整数溢出的方式取决于构建模式：

  1. 调试模式 (Debug Build - cargo build 或 cargo run)：

    • 如果发生整数溢出，程序会立即 panic (崩溃)。
    • 目的： 在开发阶段尽早发现这类潜在错误。Rust 把溢出视为一种逻辑错误，默认行为是安全优先。

  2. 发布模式 (Release Build - cargo build --release)：

    • 如果发生整数溢出，Rust 不会 panic，而是执行二进制补码环绕 (Two’s Complement Wrapping)。
    • 例如： 对于 u8 类型，255 + 1 会变成 0，255 + 2 会变成 1，就像一个循环计数器。对于有符号整数也是类似的环绕行为。
    • 目的： 性能优先。检查每次整数运算是否溢出是有运行时开销的。发布模式假设开发者已经处理了或接受了溢出的可能性，并选择了性能更高的行为。

显式处理溢出：
Rust 强烈不建议依赖隐式的环绕行为，因为它可能隐藏逻辑错误。相反，标准库提供了一系列方法让你显式地控制溢出行为：

  • wrapping_* 方法： 执行环绕（与 release 模式行为一致），如 wrapping_add()。
  • checked_* 方法： 如果发生溢出，返回 None；否则返回包含结果的 Some。这允许你检查并处理溢出情况。如 checked_add()。
  • overflowing_* 方法： 返回一个包含结果和表示是否发生溢出的布尔值的元组。如 overflowing_add()。
  • saturating_* 方法： 如果发生溢出，结果会停留在该类型的最大值或最小值（饱和）。如 saturating_add()。
fn main() {let a: u8 = 250;let b: u8 = 10;// 1. Wrapping (环绕)let wrapped_sum = a.wrapping_add(b); // 250 + 10 = 260 -> 260 % 256 = 4println!("Wrapping add: {}", wrapped_sum); // 输出: 4// 2. Checked (检查)let checked_sum = a.checked_add(b);match checked_sum {Some(sum) => println!("Checked add: {}", sum),None => println!("Checked add: Overflow occurred!"), // 输出: Overflow occurred!}let checked_sum_safe = (100u8).checked_add(20u8);if let Some(sum) = checked_sum_safe {println!("Safe checked add: {}", sum); // 输出: 120}// 3. Overflowing (溢出指示)let (overflowing_sum, did_overflow) = a.overflowing_add(b);println!("Overflowing add: result={}, overflow={}", overflowing_sum, did_overflow); // 输出: result=4, overflow=true// 4. Saturating (饱和)let saturated_sum = a.saturating_add(b); // 结果停留在 u8 的最大值 255println!("Saturating add: {}", saturated_sum); // 输出: 255
}

设计哲学思考： Rust 对整数溢出的处理方式体现了其在安全与性能之间的权衡，以及对开发者意图明确性的要求。默认在 debug 模式 panic 保证了开发时的安全发现，而在 release 模式提供性能选项（环绕），同时通过 checked_* 等方法赋予开发者完全的、显式的控制权。

二、浮点数类型 (Floating-Point Types)：近似的艺术

浮点数用于表示带有小数部分的数字。Rust 提供了两种基础的浮点数类型，它们都遵循 IEEE 754 标准：

  • f32： 单精度浮点数，占用 32 位。
  • f64： 双精度浮点数，占用 64 位。

默认类型：
Rust 的浮点数默认类型是 f64。这是因为在现代 CPU 上，f64 的运算速度通常与 f32 相当，甚至有时更快，并且 f64 提供了更高的精度。除非你有特定的理由（例如需要节省内存，或者与只支持 f32 的硬件/库交互），否则推荐使用 f64。

fn main() {let x = 2.0; // 默认推断为 f64let y: f32 = 3.0; // 显式指定为 f32println!("x (f64): {}", x);println!("y (f32): {}", y);// 浮点数运算let sum = x + 1.5; // f64 + f64println!("Sum: {}", sum);// 注意：不同浮点数类型之间不能直接运算，需要显式转换// let mixed_sum = x + y; // 编译错误！类型不匹配 (expected f64, found f32)let converted_y = y as f64; // 使用 as 进行类型转换let mixed_sum_correct = x + converted_y;println!("Correct mixed sum: {}", mixed_sum_correct);
}

浮点数的“陷阱”：精度问题

由于浮点数在计算机内部使用二进制表示，很多十进制小数无法被精确表示，只能是一个近似值。这会导致一些看似奇怪的行为：

fn main() {let a = 0.1; // f64let b = 0.2; // f64let sum = a + b;println!("0.1 + 0.2 = {}", sum); // 可能输出类似 0.30000000000000004// 因此，直接比较浮点数是否相等通常是不可靠的// assert_eq!(sum, 0.3); // 这行代码很可能会 panic!// 正确的做法是比较差值是否在一个很小的容差 (epsilon) 内let difference = (sum - 0.3).abs();let epsilon = 1e-10; // 定义一个很小的容差值if difference < epsilon {println!("浮点数比较：认为 0.1 + 0.2 等于 0.3 (在容差范围内)");} else {println!("浮点数比较：认为 0.1 + 0.2 不等于 0.3");}// 特殊值：NaN (Not a Number)let result = (-42.0_f64).sqrt(); // 对负数开平方根得到 NaNprintln!("sqrt(-42.0) = {}", result); // 输出: NaN// 注意：NaN 不等于任何值，包括它自己！(result == result) 会是 falseassert!(result.is_nan()); // 应该使用 is_nan() 方法来检查
}

核心建议： 在进行浮点数计算时，要时刻意识到精度限制。避免直接进行相等性比较。对于需要精确计算的场景（如金融计算），考虑使用专门的定点数库或十进制算术库（如 rust_decimal crate）。

三、布尔类型 (Boolean Type)：真与假的裁判

布尔类型 bool 是最简单的类型之一，它只有两个可能的值：true 和 false。

fn main() {let is_rust_fun: bool = true;let is_learning_easy = false; // 类型推断为 boolprintln!("Rust 有趣吗? {}", is_rust_fun); // 输出: trueprintln!("学习轻松吗? {}", is_learning_easy); // 输出: false// 布尔值主要用于条件控制流if is_rust_fun {println!("太棒了，继续学习！");} else {println!("再坚持一下，你会发现它的魅力！");}// 强调：Rust 是强类型语言，布尔值不能隐式转换成整数（反之亦然）// let number = is_rust_fun as i32; // 可以显式转换，true 变为 1, false 变为 0// if 1 { ... } // 编译错误！if 条件必须是 bool 类型
}

布尔类型在内存中通常占用 1 个字节。它的简单性背后是逻辑判断的基础，是构建复杂程序流程控制的关键。Rust 的强类型系统确保了条件表达式必须明确地产生 bool 值，避免了 C/C++ 中将整数误用作布尔值可能引发的错误。

四、字符类型 (Character Type)：Unicode 的世界

Rust 的 char 类型代表一个单一的 Unicode 标量值 (Unicode Scalar Value)。这意味着一个 char 可以表示远超 ASCII 范围的字符，包括各种语言的字母、符号、甚至是表情符号 (Emoji)。

关键特性：

  • 大小固定： Rust 的 char 类型占用 4 个字节 (32 位) 的内存空间。这足以表示所有的 Unicode 标量值。
  • 字面量： 使用单引号 (') 包裹。
  • 与字符串的区别： char 表示单个字符，而 Rust 的字符串 (String, &str) 是 UTF-8 编码的字节序列，一个字符在 UTF-8 中可能占用 1 到 4 个字节。
fn main() {let c = 'z';let z = 'ℤ'; // 一个数学符号let heart_eyed_cat = '😻'; // 一个表情符号let pi = 'π'; // 希腊字母 Piprintln!("字符 c: {}", c);println!("字符 z: {}", z);println!("字符 cat: {}", heart_eyed_cat);println!("字符 pi: {}", pi);// char 的大小总是 4 字节println!("Size of char: {} bytes", std::mem::size_of::<char>()); // 输出: 4// 对比字符串中字符的 UTF-8 字节长度let s = "😻"; // 这是一个 &str (字符串切片)println!("字符串 \"😻\" 的字节长度 (UTF-8): {}", s.len()); // 输出: 4 (因为它在 UTF-8 中需要 4 个字节)// 但它只包含一个 charprintln!("字符串 \"😻\" 包含的 char 数量: {}", s.chars().count()); // 输出: 1// 可以对 char 进行一些操作assert!(pi.is_alphabetic()); // 检查是否是字母类字符assert!(heart_eyed_cat.is_emoji()); // 需要引入 `unicode-segmentation` 等库来做更复杂的判断，标准库能力有限println!("'A' 的小写形式: {}", 'A'.to_lowercase().next().unwrap()); // 输出: a
}

Rust 对 char 的定义（基于 Unicode 标量值并固定为 4 字节）体现了其面向全球化和现代文本处理的设计思想。它避免了许多其他语言中处理非 ASCII 字符时可能遇到的编码问题和歧义。

五、类型注解与推断再探

虽然 Rust 的类型推断很强大，可以推断出大部分标量类型，但在某些情况下，显式类型注解 (Type Annotation) 是必需的或推荐的：

  1. 消除歧义： 当一个字面量可以被解释为多种类型时，例如 parse 方法需要知道目标类型。
    let guess: u32 = "42".parse().expect("Not a number!"); // 必须告诉 parse 我们想要 u32
  2. 常量和静态变量： const 和 static 声明必须显式标注类型。
  3. 函数签名： 函数的参数和返回值类型必须明确标注。
  4. 复杂类型或提高可读性： 对于复杂的复合类型，或者为了让代码意图更清晰，有时即使编译器能推断，也建议加上类型注解。

对于标量类型，通常只有在默认类型（如 i32, f64）不适用或存在歧义时，才需要显式注解。

总结：坚实的基础，精确的表达

今天我们深入了解了 Rust 的四大标量类型：

  • 整数： 提供了多种位宽和有/无符号选项，强调 usize 用于索引，并对整数溢出有明确、安全的处理机制（debug panic, release wrap, explicit methods）。
  • 浮点数： 基于 IEEE 754 标准的 f32 和 f64（默认），需注意精度问题和比较陷阱。
  • 布尔值： 简单的 bool 类型 (true/false)，强类型系统防止与整数混用。
  • 字符： char 代表 4 字节的 Unicode 标量值，支持全球字符集。

Rust 对这些基础类型的精确定义和严格的类型检查，是其可靠性的重要来源。它鼓励开发者思考数据的具体表示、范围和潜在问题（如溢出、精度），并通过编译器提供强有力的保障。这些看似基础的知识，构成了我们未来构建更复杂、更健壮程序所依赖的坚实地基。

FAQ：关于标量类型的常见疑问

  • Q1: 如何选择合适的整数类型？ i32 够用吗？
    • A: 如果不确定，i32 是个不错的起点，性能好且范围适中。但最好根据数据的实际范围选择最小的能容纳的类型，可以节省内存。如果明确知道不需要负数，使用无符号类型 (u8, u16 等)。对于集合索引和内存大小相关的值，必须使用 usize。
  • Q2: 为什么 f64 是默认浮点类型，而不是更省内存的 f32？
    • A: 现代 64 位 CPU 处理 f64 的速度通常不亚于 f32，而 f64 的精度更高，能减少累积误差。因此，Rust 选择了精度优先作为默认行为。
  • Q3: Rust 的 char 和 C/C++ 的 char 有什么不同？
    • A: C/C++ 的 char 通常是 1 字节，主要表示 ASCII 字符或字节值。Rust 的 char 是 4 字节，设计用来表示任意 Unicode 标量值，更能适应现代多语言文本处理的需求。Rust 中的 u8 类型更接近 C/C++ char 表示字节的概念。
  • Q4: usize 和 u64 在 64 位系统上大小一样，可以混用吗？
    • A: 虽然它们在 64 位系统上大小相同，但语义不同。usize 的语义是“足够大以容纳内存中任何对象的指针或索引”，其大小随架构变化。u64 则始终是 64 位无符号整数。代码中应根据语义选择：用于索引、长度、大小的，用 usize；用于表示明确需要 64 位存储的数字（与架构无关）时，用 u64。不能直接混用，需要显式转换 (as)。

下一篇预告：组合的力量——复合类型初探

掌握了构成数据的“原子”（标量类型），下一步我们将学习如何将它们组合起来，构建更复杂的数据结构。

下一篇：【数据基石·下】复合类型：元组 (Tuple) 与数组 (Array) 的定长世界。 我们将探索如何将不同或相同类型的值组合成固定的集合。敬请期待！

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

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

相关文章

消息中间件RabbitMQ：简要介绍及其Windows安装流程

消息中间件RabbitMQ：简要介绍及其Windows安装流程

一、简要介绍 定义&#xff1a;RabbitMQ 是一个开源消息中间件&#xff0c;用于实现消息队列和异步通信。 场景&#xff1a;适用于分布式系统、异步任务处理、消息解耦、负载均衡等场景。 比喻&#xff1a;RabbitMQ 就像是快递公司&#xff0c;负责在不同系统间安全快速地传递…
阅读更多...
Docker概念详解

Docker概念详解

文章目录 一、Docker&#xff1a;容器化应用的基石1.1 环境1.2 Docker 是什么1.3 Docker镜像1.3.1 基础镜像(Base Image)1.3.2 Dockerfile1.3.3 容器镜像&#xff08;Container Image&#xff09; 1.4 Registry1.5 容器1.6 Docker VS 虚拟机 二、Docker 的架构原理2.1 C/S软件架…
阅读更多...
linux查看及修改用户过期时间

linux查看及修改用户过期时间

修改用户有效期 密码到期时间 sudo chage -E 2025-12-31 username sudo chage -M 180 username sudo chage -d $(date %F) username 查询用户密码到期时间 for user in $(cat /etc/passwd |cut -d: -f1); do echo $user; chage -l $user | grep "Password expires"; …
阅读更多...
CGAL 计算直线之间的距离（3D）

CGAL 计算直线之间的距离（3D）

文章目录 一、简介二、实现代码三、实现效果一、简介 这里的计算思路很简单： 1、首先将两个三维直线均平移至过原点处，这里两条直线可以构成一个平面normal。 2、如果两个直线平行，那么两条直线之间的距离就转换为直线上一点到另一直线的距离。 3、如果两个直线不平行，则可…
阅读更多...
＜项目代码＞YOLO小船识别＜目标检测＞

＜项目代码＞YOLO小船识别＜目标检测＞

项目代码下载链接 YOLOv8是一种单阶段&#xff08;one-stage&#xff09;检测算法&#xff0c;它将目标检测问题转化为一个回归问题&#xff0c;能够在一次前向传播过程中同时完成目标的分类和定位任务。相较于两阶段检测算法&#xff08;如Faster R-CNN&#xff09;&#xff0…
阅读更多...
基于RK3588+FPGA+AI YOLO全国产化的无人船目标检测系统（二）平台设计

基于RK3588+FPGA+AI YOLO全国产化的无人船目标检测系统（二）平台设计

基于项目需求确定国产 AI 平台的总体架构设计&#xff0c;完成硬件单元的选择和搭建以及开发工具链的配置工作。 4.1 国产 AI 平台总体架构 本文设计了一套灵活高效的国产 AI 平台总体架构&#xff0c;设计方法是在嵌入式平 台上使用串行总线&#xff08; Peripheral Co…
阅读更多...
Typescript中的泛型约束extends keyof

Typescript中的泛型约束extends keyof

概要 本文主要分享Typescript中泛型约束的使用方法。在开发过程中&#xff0c;通过使用该方法&#xff0c;可以在编译阶段&#xff0c;帮助我们查找到一些潜在的空值引用错误。 代码和实现 我们预先定义了IUser接口&#xff0c;接口包括了id&#xff0c;姓名&#xff0c;性别…
阅读更多...
C++ 2025 展望：现代编程需求与新兴技术驱动下的变革

C++ 2025 展望：现代编程需求与新兴技术驱动下的变革

C 作为一门成熟的语言&#xff0c;在多个领域&#xff08;嵌入式系统、高性能计算、图形渲染、游戏开发等&#xff09;依旧占据重要地位。在 2024 年&#xff0c;C 开发继续在许多传统领域保持强劲的势头&#xff0c;同时也面临着新的挑战与发展方向。展望 2025 年&#xff0c;…
阅读更多...
包管理工具有哪些？主流软件分享

包管理工具有哪些？主流软件分享

常见的包管理工具主要有&#xff1a;npm、Yarn、pnpm、Composer、Maven、pip、Conda 等&#xff0c;其中 npm 是目前全球使用最广泛的JavaScript包管理工具&#xff0c;以丰富的生态、便捷的使用体验以及强大的社区支持闻名。npm具备依赖管理、版本控制、脚本执行等强大功能&am…
阅读更多...
2025年世界职业院校技能大赛实施方案（意见稿）

2025年世界职业院校技能大赛实施方案（意见稿）

为贯彻落实《教育强国建设规划纲要&#xff08;2024—2035年&#xff09;》&#xff0c;进一步提升世界职业院校技能大赛&#xff08;以下简称“大赛”&#xff09;内涵质量&#xff0c;发挥大赛引领作用&#xff0c;提升高技能人才培养质量&#xff0c;服务现代职业教育体系建…
阅读更多...
Redis 慢查询分析与优化

Redis 慢查询分析与优化

Redis 慢查询分析与优化 参考书籍 &#xff1a; https://weread.qq.com/web/reader/d5432be0813ab98b6g0133f5kd8232f00235d82c8d161fb2 以下从配置参数、耗时细分、分析工具、优化策略四个维度深入解析 Redis 慢查询问题&#xff0c;结合实战调优建议&#xff0c;帮助开发者…
阅读更多...
AI之pdf解析：Tesseract、PaddleOCR、RapidPaddle（可能为 RapidOCR）和 plumberpdf 的对比分析及使用建议

AI之pdf解析：Tesseract、PaddleOCR、RapidPaddle（可能为 RapidOCR）和 plumberpdf 的对比分析及使用建议

目录标题 Tesseract、PaddleOCR、RapidPaddle&#xff08;可能为 RapidOCR&#xff09;和 plumberpdf 的对比分析1. Tesseract类型: 开源 OCR 引擎特点:缺点:适用场景: 2. PaddleOCR (推荐)类型:特点:缺点:适用场景: 复杂版式文档、多语言混合文本、需要高精度识别的场景&#…
阅读更多...
算法 | 成长优化算法（Growth Optimizer，GO）原理，公式，应用，算法改进研究综述，matlab代码

算法 | 成长优化算法（Growth Optimizer，GO）原理，公式，应用，算法改进研究综述，matlab代码

===================================================== github：https://github.com/MichaelBeechan CSDN：https://blog.csdn.net/u011344545 ===================================================== 成长优化算法 一、算法原理二、核心公式三、应用领域四、算法改进研究五…
阅读更多...
网络原理（TCP协议—协议格式，性质（上），状态）

网络原理（TCP协议—协议格式，性质（上），状态）

目录 1.TCP协议段格式。 2.TCP协议传输时候的性质。 2.1确认应答。 2.2超时重传。 2.3连接管理。 2.3.1 三次握手。 2.3.2四次挥手。 3.TCP常见的状态。 1.TCP协议段格式。 TCP协议段是由首部和数据两部分构成的。首部包含了TCP通信所需要的各种控制信息&#xff0c;而…
阅读更多...
XAML 标记扩展

XAML 标记扩展

# XAML 标记扩展详解 标记扩展(Markup Extensions)是XAML中一种特殊的语法结构&#xff0c;允许在XAML属性中嵌入动态值或引用&#xff0c;而不是简单的静态值。它们使用花括号{}作为标识&#xff0c;是XAML强大功能的核心组成部分。 ## 基本语法结构 所有标记扩展都遵循以下…
阅读更多...
DeepSeek+Cursor+Devbox+Sealos项目实战

DeepSeek+Cursor+Devbox+Sealos项目实战

黑马程序员DeepSeekCursorDevboxSealos带你零代码搞定实战项目开发部署视频教程&#xff0c;基于AI完成项目的设计、开发、测试、联调、部署全流程 原视频地址视频选的项目非常基础&#xff0c;基本就是过了个web开发流程&#xff0c;但我在实际跟着操作时&#xff0c;ai依然会…
阅读更多...
Ethan独立开发产品日报 | 2025-04-20

Ethan独立开发产品日报 | 2025-04-20

1. Checklist GG 基于人工智能的清单管理工具 checklist.gg是一个基于人工智能的清单管理工具&#xff0c;旨在帮助组织确保每次都能正确完成任务。 关键词&#xff1a;AI驱动, 检查清单, 管理工具, 任务管理, 效率提升, 组织管理, 工作流程, 自动化工具, 清单管理, 协作工具…
阅读更多...
第十四届蓝桥杯 2023 C/C++组 冶炼金属

第十四届蓝桥杯 2023 C/C++组 冶炼金属

目录 题目&#xff1a; 题目描述&#xff1a; 题目链接&#xff1a; 思路&#xff1a; 核心思路&#xff1a; 思路详解&#xff1a; 代码&#xff1a; 代码详解&#xff1a; 题目&#xff1a; 题目描述&#xff1a; 题目链接&#xff1a; 蓝桥云课 冶炼金属 洛谷 P92…
阅读更多...
【数字图像处理】彩色图像处理（1）

【数字图像处理】彩色图像处理（1）

研究彩色图像处理的原因 1&#xff1a;利用颜色信息&#xff0c;可以简化目标物的区分&#xff0c;以及从场景中提取出目标物 2&#xff1a;人眼对颜色非常敏感&#xff0c;可以分辨出来几千种颜色色调和亮度&#xff0c;却只能分别出几十种灰度 彩色图像分类 伪彩色图像处理&…
阅读更多...
pytest自动化中关于使用fixture是否影响用例的独立性

pytest自动化中关于使用fixture是否影响用例的独立性

第一个问题&#xff1a;难道使用fixture 会影响用例独立吗&#xff1f; ✅ 简单回答&#xff1a; 使用 fixture ≠ 不独立。 只要你的 fixture 是每次测试都能自己运行、自己产生数据的&#xff0c;那么测试用例依然是“逻辑独立”的。 ✅ 怎么判断 fixture 是否影响独立性&a…
阅读更多...
最新文章

Copyright @ 2022~2023