青少年编程与数学 02-019 Rust 编程基础 08课题、字面量、运算符和表达式

明月看潮生2025-05-13 15:13

青少年编程与数学 02-019 Rust 编程基础 08课题、字面量、运算符和表达式

课题摘要:

在 Rust 中，字面量、运算符和表达式是构建程序的基础组件，它们共同构成了 Rust 语言的核心语法。本文介绍Rust中的字面量、运算符和表达式。
关键词：字面量、运算符、表达式

一、字面量

在 Rust 中，字面量（Literals）是指直接在代码中表示的值，它们是程序中最基本的表达形式。字面量可以是数字、字符、字符串、布尔值等。以下是对 Rust 中字面量的详细解析：

1. 字面量的分类

Rust 中的字面量可以分为以下几类：

1.1 整数字面量

整数字面量可以表示整数类型（如 i32、u32、i64 等）。它们可以有以下几种形式：

  • 十进制：直接写数字，如 42。
  • 十六进制：以 0x 开头，如 0x2A（等同于十进制的 42）。
  • 八进制：以 0o 开头，如 0o52（等同于十进制的 42）。
  • 二进制：以 0b 开头，如 0b101010（等同于十进制的 42）。
  • 下划线分隔：可以在数字中使用下划线 _ 来分隔数字，提高可读性，如 1_000_000。

示例：

rust 复制代码 
let decimal = 42;
let hex = 0x2A;
let octal = 0o52;
let binary = 0b101010;
let large_number = 1_000_000;

1.2 浮点数字面量

浮点数字面量用于表示浮点数，可以是 f32 或 f64 类型。它们可以有以下几种形式：

  • 十进制表示：直接写数字和小数点，如 3.14。
  • 科学计数法：使用 e 或 E 表示指数部分，如 1.23e4（等同于 12300.0）。
  • 类型后缀：可以显式指定类型后缀，如 1.23f32 或 4.56f64。

示例：

rust 复制代码 
let float = 3.14;
let scientific = 1.23e4;
let f32_value = 4.56f32;
let f64_value = 7.89f64;

1.3 字符字面量

字符字面量用于表示单个字符，用单引号 ' 包裹。它可以表示：

  • 普通字符：如 'a'。
  • Unicode 字符：如 '中'。
  • 转义字符：如 '\n'（换行符）、'\t'（制表符）、'\\'（反斜杠）等。
  • Unicode 转义：使用 \u{} 表示 Unicode 码点，如 '\u{4E2D}'（等同于 '中'）。

示例：

rust 复制代码 
let letter = 'a';
let chinese_char = '中';
let newline = '\n';
let unicode_escape = '\u{4E2D}';

1.4 字符串字面量

字符串字面量用于表示字符串，用双引号 " 包裹。它可以包含：

  • 普通字符：如 "Hello, world!"。

  • 转义字符：如 "\n"（换行符）、"\t"（制表符）、"\\"（反斜杠）等。

  • 原始字符串：使用 r#""# 包裹，可以包含任意字符，包括换行符和双引号，而无需转义。例如：

    rust 复制代码 
    let raw_string = r#"C:\Users\Alice\Documents"#;

示例：

rust 复制代码 
let greeting = "Hello, world!";
let multiline_string = "This is a\nmultiline string.";
let raw_string = r#"C:\Users\Alice\Documents"#;

1.5 布尔字面量

布尔字面量只有两个值：true 和 false。

示例：

rust 复制代码 
let is_active = true;
let is_disabled = false;

1.6 字节数组字面量

字节数组字面量用于表示字节数组，用 b"" 包裹。它可以包含：

  • 普通字符：如 b"Hello"。
  • 转义字符：如 b"\n"（换行符）、b"\t"（制表符）、b"\\"（反斜杠）等。

示例：

rust 复制代码 
let bytes = b"Hello";

2. 字面量的类型推断

Rust 是一种强类型语言，但在某些情况下，字面量的类型可以由编译器推断。例如：

  • 如果上下文明确指定了类型，编译器会根据上下文推断字面量的类型。
  • 如果没有明确指定类型，编译器会使用默认类型：
    • 整数默认为 i32。
    • 浮点数默认为 f64。

示例：

rust 复制代码 
let x = 42; // 默认类型为 i32
let y = 3.14; // 默认类型为 f64

let z: i64 = 123; // 显式指定类型为 i64
let w: f32 = 4.56; // 显式指定类型为 f32

3. 字面量的用途

字面量在 Rust 中的用途非常广泛，主要用于以下场景：

  • 初始化变量：为变量赋初始值。
  • 函数参数：作为函数的参数传递。
  • 数组和元组的元素：作为数组或元组的元素。
  • 条件表达式：在 if、while 等条件表达式中使用。

4. 字面量的限制

  • 类型必须明确：虽然编译器可以推断某些字面量的类型，但在某些情况下，必须显式指定类型。
  • 转义字符的使用：在字符串和字符字面量中，特殊字符需要使用转义序列。
  • 原始字符串的限制：原始字符串不能使用转义字符，但可以通过 r#""# 包裹来包含任意字符。

字面量总结

字面量是 Rust 中最基本的数据表示形式，它用于直接在代码中表示值。Rust 支持多种类型的字面量，包括整数、浮点数、字符、字符串、布尔值和字节数组。通过合理使用字面量，可以简化代码的编写，并提高代码的可读性。

二、运算符

在 Rust 中，运算符用于执行各种操作，包括算术运算、逻辑运算、比较运算等。Rust 提供了丰富的运算符，涵盖了几乎所有常见的操作。以下是对 Rust 中运算符的详细解析：

1. 算术运算符

算术运算符用于执行基本的数学运算。

运算符 描述 示例 结果
+ 加法 let a = 1 + 2; a = 3
- 减法 let b = 5 - 3; b = 2
* 乘法 let c = 4 * 3; c = 12
/ 除法 let d = 10 / 2; d = 5
% 取模（余数） let e = 10 % 3; e = 1

2. 逻辑运算符

逻辑运算符用于执行布尔逻辑运算。

运算符 描述 示例 结果
&& 逻辑与 let a = true && false; a = false
` ` 逻辑或
! 逻辑非 let c = !true; c = false

3. 比较运算符

比较运算符用于比较两个值，并返回布尔值。

运算符 描述 示例 结果
== 等于 let a = 1 == 2; a = false
!= 不等于 let b = 1 != 2; b = true
> 大于 let c = 2 > 1; c = true
< 小于 let d = 1 < 2; d = true
>= 大于等于 let e = 2 >= 2; e = true
<= 小于等于 let f = 1 <= 2; f = true

4. 位运算符

位运算符用于对整数的二进制位进行操作。

运算符 描述 示例 结果
& 位与 let a = 5 & 3; a = 1
` ` 位或 `let b = 5
^ 位异或 let c = 5 ^ 3; c = 6
! 位非 let d = !5; d = -6
<< 左移 let e = 5 << 1; e = 10
>> 右移 let f = 5 >> 1; f = 2

5. 赋值运算符

赋值运算符用于将值赋给变量。

运算符 描述 示例 结果
= 简单赋值 let a = 5; a = 5
+= 加法赋值 let mut a = 5; a += 3; a = 8
-= 减法赋值 let mut b = 5; b -= 3; b = 2
*= 乘法赋值 let mut c = 5; c *= 3; c = 15
/= 除法赋值 let mut d = 10; d /= 2; d = 5
%= 取模赋值 let mut e = 10; e %= 3; e = 1
&= 位与赋值 let mut a = 5; a &= 3; a = 1
` =` 位或赋值 `let mut b = 5; b
^= 位异或赋值 let mut c = 5; c ^= 3; c = 6
<<= 左移赋值 let mut e = 5; e <<= 1; e = 10
>>= 右移赋值 let mut f = 5; f >>= 1; f = 2

6. 范围运算符

范围运算符用于创建范围。

运算符 描述 示例 结果
.. 范围（不包括上界） for i in 0..5 { ... } i = 0, 1, 2, 3, 4
..= 范围（包括上界） for i in 0..=5 { ... } i = 0, 1, 2, 3, 4, 5

7. 条件运算符

Rust 还提供了一个三元条件运算符，用于根据条件选择值。

运算符 描述 示例 结果
? 条件运算符 let a = if condition { x } else { y }; 根据条件返回 x 或 y

8. 运算符重载

Rust 允许通过实现特定的特质（traits）来重载运算符。例如，可以通过实现 std::ops::Add 特质来重载 + 运算符。

rust 复制代码 
use std::ops::Add;

struct Point {
    x: i32,
    y: i32,
}

impl Add for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let p3 = p1 + p2; // 使用重载的 + 运算符
    println!("p3: ({}, {})", p3.x, p3.y); // 输出：p3: (4, 6)
}

注意事项

  • 优先级：Rust 的运算符有优先级，例如乘法和除法的优先级高于加法和减法。可以通过括号改变优先级。
  • 短路逻辑：逻辑与（&&）和逻辑或（||）运算符具有短路行为，即如果第一个条件已经决定了结果，第二个条件不会被计算。
  • 溢出：整数运算可能会导致溢出。在调试模式下，Rust 会检查溢出并报错；在发布模式下，溢出行为是未定义的。

通过合理使用这些运算符，可以编写出高效且可读性强的 Rust 代码。

三、表达式

在 Rust 中，表达式（Expression）是程序中执行某些操作并产生值的语法构造。与语句（Statement）不同，表达式总是返回一个值，而语句则不返回值。理解表达式是掌握 Rust 编程的基础。以下是对 Rust 中表达式的详细解析。

1. 表达式的定义

表达式是 Rust 程序的基本构建块，它可以执行操作并产生一个值。表达式可以非常简单，如一个字面量或变量，也可以是复杂的，包含多个操作符和子表达式。

2. 表达式的类型

Rust 中的表达式可以分为以下几类：

字面量表达式

字面量是直接表示值的表达式，例如数字、字符串或布尔值。

rust 复制代码 
let x = 42; // 整数字面量
let y = "Hello"; // 字符串字面量
let z = true; // 布尔字面量
变量表达式

变量表达式是通过变量名引用变量的值。

rust 复制代码 
let a = 10;
let b = a; // 使用变量 a 的值
运算符表达式

运算符表达式是通过运算符对值进行操作的表达式。

rust 复制代码 
let sum = 1 + 2; // 加法运算符
let product = 3 * 4; // 乘法运算符
let is_equal = 5 == 5; // 比较运算符
函数调用表达式

函数调用表达式是通过函数名和参数列表调用函数的表达式。

rust 复制代码 
fn add(a: i32, b: i32) -> i32 {
    a + b
}

let result = add(3, 4); // 调用函数
方法调用表达式

方法调用表达式是通过对象调用其方法的表达式。

rust 复制代码 
let mut vec = Vec::new();
vec.push(1); // 调用 Vec 的 push 方法
条件表达式

条件表达式是根据条件选择不同值的表达式。Rust 中的 if 表达式是一个典型的条件表达式。

rust 复制代码 
let number = 5;
let is_positive = if number > 0 { true } else { false };
循环表达式

循环表达式是通过循环语句执行重复操作的表达式。Rust 中的 loop、while 和 for 都是循环表达式。

rust 复制代码 
let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;
    }
};
println!("Result: {}", result); // 输出：Result: 20
块表达式

块表达式是通过花括号 {} 包裹的一组语句和表达式。块表达式返回其最后一个表达式的值。

rust 复制代码 
let x = {
    let y = 3;
    y + 1
};
println!("x: {}", x); // 输出：x: 4

3. 表达式的值

每个表达式都有一个值，这个值可以被赋值给变量，也可以作为其他表达式的一部分。例如：

rust 复制代码 
let x = 5 + 3; // 表达式 5 + 3 的值是 8
let y = {
    let z = 10;
    z + 2 // 块表达式的值是 z + 2 的结果，即 12
};

4. 表达式的优先级

Rust 中的表达式遵循一定的优先级规则，这些规则决定了表达式中各个部分的计算顺序。例如，乘法和除法的优先级高于加法和减法。

rust 复制代码 
let result = 5 + 3 * 2; // 先计算 3 * 2，再计算 5 + 6

如果需要改变优先级，可以使用括号明确指定计算顺序：

rust 复制代码 
let result = (5 + 3) * 2; // 先计算 5 + 3，再计算 8 * 2

5. 表达式与语句的区别

在 Rust 中，表达式和语句是不同的概念：

  • 表达式：总是返回一个值。
  • 语句：不返回值，通常用于执行某些操作，如变量声明或函数调用。

例如，以下是一个语句：

rust 复制代码 
let x = 5; // 这是一个语句，它声明了一个变量 x

而以下是一个表达式：

rust 复制代码 
let y = { 5 }; // 这是一个块表达式，它的值是 5

6. 表达式的应用场景

表达式在 Rust 中的应用非常广泛，以下是一些常见的应用场景：

函数返回值

函数的返回值是一个表达式的结果。例如：

rust 复制代码 
fn add(a: i32, b: i32) -> i32 {
    a + b // 表达式
}
条件分支

if 和 match 表达式用于根据条件选择不同的值。例如：

rust 复制代码 
let number = 5;
let is_positive = if number > 0 { true } else { false };

let message = match number {
    0 => "zero",
    1 => "one",
    _ => "other",
};
循环控制

loop、while 和 for 表达式用于执行重复操作。例如：

rust 复制代码 
let mut counter = 0;
let result = loop {
    counter += 1;
    if counter == 10 {
        break counter * 2;
    }
};

7. 示例代码

以下是一个完整的示例代码，展示了 Rust 中表达式的多种用法：

rust 复制代码 
fn main() {
    // 字面量表达式
    let x = 42;

    // 变量表达式
    let y = x;

    // 运算符表达式
    let sum = x + y;

    // 函数调用表达式
    let product = multiply(x, y);

    // 条件表达式
    let is_positive = if sum > 0 { true } else { false };

    // 块表达式
    let z = {
        let temp = 10;
        temp + 2
    };

    // 循环表达式
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };

    println!("x: {}", x);
    println!("y: {}", y);
    println!("sum: {}", sum);
    println!("product: {}", product);
    println!("is_positive: {}", is_positive);
    println!("z: {}", z);
    println!("result: {}", result);
}

fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

表达式总结

Rust 中的表达式是程序的核心组成部分，它们用于执行操作并产生值。表达式可以非常简单，也可以非常复杂，涵盖了字面量、变量、运算符、函数调用、条件分支、循环控制等多种形式。通过合理使用表达式，可以编写出高效且可读性强的 Rust 代码。

四、综合示例

以下是一个综合示例代码，展示了 Rust 中字面量、运算符及表达式的用法：

rust 复制代码 
fn main() {
    // 字面量的使用
    // 整数字面量
    let decimal = 42;
    let hex = 0x2A;
    let octal = 0o52;
    let binary = 0b101010;
    let large_number = 1_000_000;

    // 浮点数字面量
    let float = 3.14;
    let scientific = 1.23e4;
    let f32_value = 4.56f32;
    let f64_value = 7.89f64;

    // 字符字面量
    let letter = 'a';
    let chinese_char = '中';
    let newline = '\n';
    let unicode_escape = '\u{4E2D}';

    // 字符串字面量
    let greeting = "Hello, world!";
    let multiline_string = "This is a\nmultiline string.";
    let raw_string = r#"C:\Users\Alice\Documents"#;

    // 布尔字面量
    let is_active = true;
    let is_disabled = false;

    // 字节数组字面量
    let bytes = b"Hello";

    // 输出字面量的值
    println!("整数字面量：decimal = {}, hex = {}, octal = {}, binary = {}, large_number = {}", decimal, hex, octal, binary, large_number);
    println!("浮点数字面量：float = {}, scientific = {}, f32_value = {}, f64_value = {}", float, scientific, f32_value, f64_value);
    println!("字符字面量：letter = {}, chinese_char = {}, newline = {:?}, unicode_escape = {}", letter, chinese_char, newline, unicode_escape);
    println!("字符串字面量：greeting = {}, multiline_string = {}", greeting, multiline_string);
    println!("原始字符串：raw_string = {}", raw_string);
    println!("布尔字面量：is_active = {}, is_disabled = {}", is_active, is_disabled);
    println!("字节数组字面量：bytes = {:?}", bytes);

    // 运算符的使用
    // 算术运算符
    let sum = 1 + 2;
    let difference = 5 - 3;
    let product = 4 * 3;
    let quotient = 10 / 2;
    let remainder = 10 % 3;

    // 逻辑运算符
    let and_result = true && false;
    let or_result = true || false;
    let not_result = !true;

    // 比较运算符
    let equal = 1 == 2;
    let not_equal = 1 != 2;
    let greater_than = 2 > 1;
    let less_than = 1 < 2;
    let greater_than_or_equal = 2 >= 2;
    let less_than_or_equal = 1 <= 2;

    // 位运算符
    let bitwise_and = 5 & 3;
    let bitwise_or = 5 | 3;
    let bitwise_xor = 5 ^ 3;
    let bitwise_not = !5;
    let left_shift = 5 << 1;
    let right_shift = 5 >> 1;

    // 赋值运算符
    let mut a = 5;
    a += 3;
    let mut b = 5;
    b -= 3;
    let mut c = 5;
    c *= 3;
    let mut d = 10;
    d /= 2;
    let mut e = 10;
    e %= 3;

    // 输出运算符的结果
    println!("算术运算符：sum = {}, difference = {}, product = {}, quotient = {}, remainder = {}", sum, difference, product, quotient, remainder);
    println!("逻辑运算符：and_result = {}, or_result = {}, not_result = {}", and_result, or_result, not_result);
    println!("比较运算符：equal = {}, not_equal = {}, greater_than = {}, less_than = {}, greater_than_or_equal = {}, less_than_or_equal = {}", equal, not_equal, greater_than, less_than, greater_than_or_equal, less_than_or_equal);
    println!("位运算符：bitwise_and = {}, bitwise_or = {}, bitwise_xor = {}, bitwise_not = {}, left_shift = {}, right_shift = {}", bitwise_and, bitwise_or, bitwise_xor, bitwise_not, left_shift, right_shift);
    println!("赋值运算符：a = {}, b = {}, c = {}, d = {}, e = {}", a, b, c, d, e);

    // 表达式的使用
    // 字面量表达式
    let x = 42;

    // 变量表达式
    let y = x;

    // 运算符表达式
    let sum = x + y;

    // 函数调用表达式
    let product = multiply(x, y);

    // 条件表达式
    let is_positive = if sum > 0 { true } else { false };

    // 块表达式
    let z = {
        let temp = 10;
        temp + 2
    };

    // 循环表达式
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };

    // 输出表达式的结果
    println!("字面量表达式：x = {}", x);
    println!("变量表达式：y = {}", y);
    println!("运算符表达式：sum = {}", sum);
    println!("函数调用表达式：product = {}", product);
    println!("条件表达式：is_positive = {}", is_positive);
    println!("块表达式：z = {}", z);
    println!("循环表达式：result = {}", result);
}

// 定义一个简单的函数
fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

运行结果

bash 复制代码 
整数字面量：decimal = 42, hex = 42, octal = 42, binary = 42, large_number = 1000000
浮点数字面量：float = 3.14, scientific = 12300, f32_value = 4.56, f64_value = 7.89
字符字面量：letter = a, chinese_char = 中, newline = '\n', unicode_escape = 中
字符串字面量：greeting = Hello, world!, multiline_string = This is a
multiline string.
原始字符串：raw_string = C:\Users\Alice\Documents
布尔字面量：is_active = true, is_disabled = false
字节数组字面量：bytes = [72, 101, 108, 108, 111]
算术运算符：sum = 3, difference = 2, product = 12, quotient = 5, remainder = 1
逻辑运算符：and_result = false, or_result = true, not_result = false
比较运算符：equal = false, not_equal = true, greater_than = true, less_than = true, greater_than_or_equal = true, less_than_or_equal = true
位运算符：bitwise_and = 1, bitwise_or = 7, bitwise_xor = 6, bitwise_not = -6, left_shift = 10, right_shift = 2
赋值运算符：a = 8, b = 2, c = 15, d = 5, e = 1
字面量表达式：x = 42
变量表达式：y = 42
运算符表达式：sum = 84
函数调用表达式：product = 1764
条件表达式：is_positive = true
块表达式：z = 12
循环表达式：result = 20

进程已结束，退出代码为 0

示例代码说明

  1. 字面量的使用：

    • 展示了各种类型的字面量（整数、浮点数、字符、字符串、布尔值、字节数组）的定义和输出。
    • 包括不同进制的整数字面量（十进制、十六进制、八进制、二进制）和字符串的转义字符。

  2. 运算符的使用：

    • 展示了算术运算符、逻辑运算符、比较运算符、位运算符和赋值运算符的用法。
    • 每个运算符的结果都被打印出来，便于观察。

  3. 表达式的使用：

    • 展示了字面量表达式、变量表达式、运算符表达式、函数调用表达式、条件表达式、块表达式和循环表达式的用法。
    • 每个表达式的结果都被打印出来，展示了表达式的多样性和灵活性。

通过这个示例代码，可以全面了解 Rust 中字面量、运算符和表达式的用法。

总结

在 Rust 中，字面量、运算符和表达式是构建程序的基础组件，它们共同构成了 Rust 语言的核心语法。

字面量（Literals）

字面量是直接表示值的语法构造，它们是表达式的最基本形式。Rust 支持多种类型的字面量，包括：

  • 整数字面量 ：如 42、0xFF（十六进制）、0b1010（二进制）。
  • 浮点数字面量 ：如 3.14、2.0f64（显式指定类型）。
  • 字符字面量 ：如 'a'、'中'（UTF-8 编码）。
  • 字符串字面量 ：如 "Hello"，存储为 UTF-8 编码的字符串。
  • 布尔字面量 ：true 和 false。
  • 数组和元组字面量 ：如 [1, 2, 3]（数组）、(1, "a")（元组）。

字面量是不可变的，它们的值在编译时就已经确定。

运算符（Operators）

运算符是用于对字面量或变量进行操作的符号。Rust 提供了多种运算符，包括：

  • 算术运算符 ：+、-、*、/、%。
  • 逻辑运算符 ：&&（逻辑与）、||（逻辑或）、!（逻辑非）。
  • 比较运算符 ：==、!=、>、<、>=、<=。
  • 位运算符 ：&、|、^、!、<<、>>。
  • 赋值运算符 ：=、+=、-=、*=、/=、%= 等。
  • 范围运算符 ：..（不包括上界）、..=（包括上界）。

运算符用于组合字面量和变量，形成更复杂的表达式。

表达式（Expressions）

表达式是由字面量、变量、运算符和函数调用等组成的语法构造，它们可以执行操作并返回一个值。表达式是 Rust 程序的基本构建块，例如：

  • 简单表达式 ：1 + 2、x * y。
  • 函数调用表达式 ：add(3, 4)。
  • 条件表达式 ：if x > 0 { 1 } else { -1 }。
  • 块表达式 ：{ let y = 3; y + 1 }。
  • 循环表达式 ：loop { break 42; }。

表达式可以嵌套，形成复杂的逻辑结构。Rust 的表达式遵循优先级规则，可以通过括号明确指定计算顺序。

总之，字面量是表达式的最基本形式，表示具体的值；运算符用于对字面量和变量进行操作；表达式则是由字面量、变量和运算符组合而成的语法构造，用于执行操作并产生值。它们共同构成了 Rust 程序的基础，是编写 Rust 代码的核心语法元素。

相关推荐
每天一个秃顶小技巧13 分钟前
02.Golang 切片（slice）源码分析（一、定义与基础操作实现）
开发语言·后端·python·golang
serve the people2 小时前
解决osx-arm64平台上conda默认源没有提供 python=3.7 的官方编译版本的问题
开发语言·python·conda
柒七爱吃麻辣烫2 小时前
在Linux中安装JDK并且搭建Java环境
java·linux·开发语言
极小狐2 小时前
如何构建容器镜像并将其推送到极狐GitLab容器镜像库？
开发语言·数据库·机器学习·gitlab·ruby
多多*3 小时前
Java反射 八股版
java·开发语言·hive·python·sql·log4j·mybatis
正在走向自律3 小时前
从0到1：Python机器学习实战全攻略（8/10）
开发语言·python·机器学习
FY_20183 小时前
键盘输出希腊字符方法
开发语言
西西弗Sisyphus3 小时前
Python 处理图像并生成 JSONL 元数据文件 - 灵活text版本
开发语言·python
q567315234 小时前
Go语言多线程爬虫与代理IP反爬
开发语言·爬虫·tcp/ip·golang
Chandler244 小时前
Go语言即时通讯系统 开发日志day1
开发语言·后端·golang
热门推荐
01【分布式】Hadoop完全分布式的搭建（零基础）02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03KGG转MP3工具|非KGM文件|解密音频04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06Coze扣子平台完整体验和实践（附国内和国际版对比）07DeepSeek各版本说明与优缺点分析08苍穹外卖面试总结09西电B测-计算机网络综合实验(含验收问题)10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）