Rust 程序设计语言学习——基础语法

Rust 语言是一种高效、可靠的通用高级语言。其高效不仅限于开发效率,它的执行效率也是令人称赞的,是一种少有的兼顾开发效率和执行效率的语言。

Rust 语言由 Mozilla 开发,最早发布于 2014 年 9 月。Rust 的编译器是在 MIT License 和 Apache License 2.0 双重协议声明下的免费开源软件。

Rust 官方在线工具: https://play.rust-lang.org/。

一、Rust 语言的特点

  • 高性能:Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收,它能够胜任对性能要求特别高的服务,可以在嵌入式设备上运行,还能轻松和其他语言集成。

  • 可靠性:Rust 丰富的类型系统和所有权模型保证了内存安全和线程安全,在编译期就能够消除各种各样的错误。

  • 生产力:Rust 拥有出色的文档、友好的编译器和清晰的错误提示信息,还集成了一流的工具 —— 包管理器和构建工具, 智能地自动补全和类型检验的多编辑器支持,以及自动格式化代码等等。

二、基础语法

第一个 Rust 程序

Rust 语言代码文件后缀名为 .rs, 如 helloworld.rs。

fn main() {println!("Hello World!");
}

使用 rustc 命令编译 helloworld.rs 文件:

$ rustc helloworld.rs # 编译 helloworld.rs 文件

编译后会生成 helloworld 可执行文件:

$ ./helloworld # 执行 helloworld

Hello World!

2.1 简要介绍 println!() 和 print!()

println!( “Hello World”) 中的 println 后面还有一个 ! 符号,println 不是一个函数,而是一个宏规则。

Rust 输出文字的方式主要有两种:println!()print!()。这两个"函数"都是向命令行输出字符串的方法,区别仅在于前者会在输出的最后附加输出一个换行符。当用这两个"函数"输出信息的时候,第一个参数是格式字符串,后面是一串可变参数,对应着格式字符串中的"占位符",这一点与 C 语言中的 printf 函数很相似。但是,Rust 中格式字符串中的占位符不是 “% + 字母” 的形式,而是一对 {}

fn main() {let a = 12;let b = 12.5;println!("a is {}, b is {}", a, b);
}

运行结果:

a is 12, b is 12.5

如果想把 a 输出两遍,那岂不是要写成:

println!("a is {}, a again is {}", a, a);

其实有更好的写法:

println!("a is {0}, a again is {0}", a);

在 {} 之间可以放一个数字,它将把之后的可变参数当作一个数组来访问,下标从 0 开始。

如果要输出 { 或 } 怎么办呢?格式字符串中通过 {{ 和 }} 分别转义代表 { 和 }。但是其他常用转义字符与 C 语言里的转义字符一样,都是反斜杠开头的形式。

fn main() { println!("{{}}"); 
}

以上程序的输出结果是:

{}

2.2 变量

Rust 是强类型语言,但具有自动判断变量类型的能力。这很容易让人与弱类型语言产生混淆。如果要声明变量,需要使用 let 关键字。例如:let a = 123;,只学习过 JavaScript 的开发者对这句话很敏感,只学习过 C 语言的开发者对这句话很不理解。

在这句声明语句之后,以下三行代码都是被禁止的:

a = "abc";
a = 4.56; 
a = 456;

第一行的错误在于当声明 a 是 123 以后,a 就被确定为整型数字,不能把字符串类型的值赋给它。

第二行的错误在于自动转换数字精度有损失,Rust 语言不允许精度有损失的自动数据类型转换。

第三行的错误在于 a 不是个可变变量。

Rust 语言为了高并发安全而做的设计:在语言层面尽量少的让变量的值可以改变。所以 a 的值不可变。但这不意味着 a 不是"变量"(英文中的 variable),官方文档称 a 这种变量为不可变变量

如果我们编写的程序的一部分在假设值永远不会改变的情况下运行,而我们代码的另一部分在改变该值,那么代码的第一部分可能就不会按照设计的意图去运转。由于这种原因造成的错误很难在事后找到。这是 Rust 语言设计这种机制的原因。

当然,使变量变得"可变"(mutable)只需一个 mut 关键字。

fn main() {let mut a = 123;println!("a is {}", a);a = 456;println!("a is {}", a);
}

这个程序是正确的。

a is 123
a is 456

常量与不可变变量的区别

既然不可变变量是不可变的,那不就是常量吗?为什么叫变量?变量和常量还是有区别的。在 Rust 中,以下程序是合法的:

let a = 123;   // 可以编译,但可能有警告,因为该变量没有被使用
let a = 456;

但是如果 a 是常量就不合法:

const a: i32 = 123;
let a = 456;

报错如下:

   Compiling playground v0.0.1 (/playground)
error[E0005]: refutable pattern in local binding--> src/main.rs:3:9|
3 |     let a = 456;|         ^|         ||         patterns `i32::MIN..=122_i32` and `124_i32..=i32::MAX` not covered|         missing patterns are not covered because `a` is interpreted as a constant pattern, not a new variable|         help: introduce a variable instead: `a_var`|= note: `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant= note: for more information, visit https://doc.rust-lang.org/book/ch18-02-refutability.html= note: the matched value is of type `i32`

变量的值可以"重新绑定",但在"重新绑定"以前不能私自被改变,这样可以确保在每一次"绑定"之后的区域里编译器可以充分的推理程序逻辑。 虽然 Rust 有自动判断类型的功能,但有些情况下声明类型更加方便:

let a: u64 = 123;

这里声明了 a 为无符号 64 位整型变量,如果没有声明类型,a 将自动被判断为有符号 32 位整型变量,这对于 a 的取值范围有很大的影响。

2.3 重影(Shadowing)

重影的概念与其他面向对象语言里的"重写"(Override)或"重载"(Overload)是不一样的。重影就是所谓的重新绑定。

重影就是指变量的名称可以被重新使用的机制:

fn main() {let x = 5;let x = x + 1;let x = x * 2;println!("The value of x is: {}", x);
}

运行结果:

The value of x is: 12

再来看一个例子

fn main() {let x = 5; // warning: unused variable: `x`let x = 1.5;let x = x * 2.0;println!("The value of x is: {}", x);
}

运行结果:

The value of x is: 3

重影与可变变量的赋值不是一个概念,重影是指用同一个名字重新代表另一个变量实体,其类型、可变属性和值都可以变化。但可变变量赋值仅能发生值的变化。

let mut s = "123";
s = s.len();

这段程序会出错:不能给字符串变量赋整型值。

2.4 数据类型

Rust 语言中的基础数据类型有以下几种。

2.4.1 整型(Integer)

整数型简称整型,按照比特位长度和有无符号分为以下种类:

位长度有符号无符号
8-biti8u8
16-biti16u16
32-biti32u32
64-biti64u64
128-biti128u128
archisizeusize

isize 和 usize 两种整数类型是用来衡量数据大小的,它们的位长度取决于所运行的目标平台,如果是 32 位架构的处理器将使用 32 位位长度整型。

整数的表述方法有以下几种:

进制
十进制98_222
十六进制0xff
八进制0o77
二进制0b1111_0000
字节(只能表示 u8 型)b’A’

有的整数中间存在一个下划线,这种设计可以让人们在输入一个很大的数字时更容易判断数字的值大概是多少。

例如:

fn main() {let x = 598_000;println!("The value of x is: {}", x);
}

运行结果:

The value of x is: 598000
2.4.2 浮点数型(Floating-Point)

Rust 与其它语言一样支持 32 位浮点数(f32)和 64 位浮点数(f64)。默认情况下,64.0 将表示 64 位浮点数,因为现代计算机处理器对两种浮点数计算的速度几乎相同,但 64 位浮点数精度更高。

fn main() {let x = 2.0; // f64let y: f32 = 3.0; // f32
}

数学运算

用一段程序反映数学运算:

fn main() {let sum = 5 + 10; // 加let difference = 95.5 - 4.3; // 减let product = 4 * 30; // 乘let quotient = 56.7 / 32.2; // 除let remainder = 43 % 5; // 求余
}

许多运算符号之后加上 = 号是自运算的意思,例如:

sum += 1 等同于 sum = sum + 1

注意:Rust 不支持 ++ 和 --,因为这两个运算符出现在变量的前后会影响代码可读性,减弱了开发者对变量改变的意识能力。

2.4.3 布尔型

布尔型用 bool 表示,值只能为 true 或 false。

2.4.4 字符型

字符型用 char 表示。Rust 的 char 类型大小为 4 个字节,代表 Unicode 标量值,这意味着它可以支持中文、日文和韩文等非英文字符,甚至表情符号和零宽度空格在 Rust 中都是有效的 char 值。

Rust 使用 char 类型表示单个字符,但对字符串或文本流使用 UTF-8 编码。因此,String 将其文本表示为一个 UTF-8 字节的序列,而不是字符的数组。Rust 的 char 类型是语言中最原生的字母类型,例如:

fn main() {let c = 'z';let z = 'ℤ';let heart_eyed_cat = 'ᛀ';println!("The value is: {} {} {}", c, z, heart_eyed_cat);
}

运行结果:

The value is: z ℤ ᛀ

Rust 还是提供了字节字面量(byte literal),即用类字符字面量表示的 u8 值:b’X’ 表示 ASCII 编码的字符 X,它是一个 u8 值。比如,由于字符 A 的 ASCII 编码是 65,因此 b’A’ 等于 65u8。字节字面量中只能出现 ASCII 编码的字符。

注意:由于中文文字编码有两种(GBK 和 UTF-8),所以编程中使用中文字符串有可能导致乱码的出现,这是因为源程序与命令行的文字编码不一致,所以在 Rust 中字符串和字符都必须使用 UTF-8 编码,否则编译器会报错。

2.4.5 复合类型

元组是用一对 ( ) 包括的一组数据,可以包含不同种类的数据:

let tup: (i32, f64, u8) = (500, 6.4, 1);
// tup.0 等于 500
// tup.1 等于 6.4
// tup.2 等于 1
let (x, y, z) = tup;
// y 等于 6.4

程序首先创建了一个元组并绑定到 tup 变量上。接着使用了 let 和一个模式将 tup 分成了三个不同的变量 x、y 和 z。这叫做解构(destructuring),因为它将一个元组拆成了三个部分。

我们也可以使用点号(.)后跟值的索引来直接访问它们。例如:

fn main() {let x: (i32, f64, u8) = (500, 6.4, 1);let five_hundred = x.0;let six_point_four = x.1;let one = x.2;
}

这个程序创建了一个元组 x,然后使用其各自的索引访问元组中的每个元素。跟大多数编程语言一样,元组的第一个索引值是 0。

不带任何值的元组有个特殊的名称,叫做单元(unit) 元组。这种值以及对应的类型都写作 (),表示空值或空的返回类型。如果表达式不返回任何其他值,则会隐式返回单元值。

数组用一对 [ ] 包括的同类型数据。

let a = [1, 2, 3, 4, 5]; // a 是一个长度为 5 的整型数组
let b = ["January", "February", "March"]; // b 是一个长度为 3 的字符串数组
let c: [i32; 5] = [1, 2, 3, 4, 5]; // c 是一个长度为 5 的 i32 数组
let d = [3; 5]; // 等同于 let d = [3, 3, 3, 3, 3];let first = a[0]; // 数组访问
let second = a[1];a[0] = 123; // 错误:数组 a 不可变
let mut a = [1, 2, 3];
a[0] = 4; // 正确

2.5 注释

Rust 中的注释方式与其它语言(C、Java)一样,双斜杠的注释方式前面已经接触过,实际上支持三种注释方式:

// 这是第一种注释方式/* 这是第二种注释方式 *//** 多行注释* 多行注释* 多行注释*/

在 Rust 中使用 // 可以使其之后到第一个换行符的内容变成注释。

在这种规则下,三个正斜杠 /// 依然是合法的注释开始。所以 Rust 可以用 /// 作为说明文档注释的开头:

/// Adds one to the number given.
///
/// # Examples
///
/// ```
/// let x = add(1, 2);
///
/// ```fn add(a: i32, b: i32) -> i32 {return a + b;
}fn main() {println!("{}",add(2, 3));
}

IDE 中加载的效果如下:

在这里插入图片描述

2.6 函数

函数实际上前面已经有所了解,运行示例一直在使用 main 函数。Rust 函数的基本形式:

fn <函数名> ( <参数> ) -> <返回值类型> <函数体>

其中 Rust 函数名称的命名风格是小写字母以下划线分割:

fn main() {println!("Hello, world!");another_fn();
}fn another_fn() {println!("Hello, another_fn!");
}

2.6.1 函数参数

Rust 中定义函数如果需要具备参数必须声明参数名称和类型:

fn main() {another_fn(100, 6);
}fn another_fn(x: i32, y: i32) {println!("The value of x is {}. The value of y is {}", x, y);
}

运行结果:

The value of x is 100. The value of y is 6

2.6.2 函数体表达式

Rust 中可以在一个用 {} 包括的块里编写一个较为复杂的表达式:

fn main() {let x = 100;let y = {let x = 20;x + 1};println!("The value of x is {}. The value of y is {}", x, y);
}

运行结果:

The value of x is 100. The value of y is 21

很显然,这段程序中包含了一个表达式块:

let y = {let x = 20;x + 1
};

而且在块中可以使用函数语句,最后一个步骤是表达式,此表达式的结果值是整个表达式块所代表的值。这种表达式块叫做函数体表达式。

注意:x + 1 之后没有分号,否则它将变成一条语句!

这种表达式块是一个合法的函数体。而且在 Rust 中,函数定义可以嵌套:

fn main() {fn five() -> i32 {5}println!("The value of five() is {}.", five());
}

运行结果:

The value of five() is 5.

2.6.3 函数返回值

Rust 函数声明返回值类型的方式为在参数声明之后用 -> 来声明函数返回值的类型。在函数体中,随时都可以以 return 关键字结束函数运行并返回一个类型合适的值。这也是最接近大多数开发者经验的做法:

fn add(a: i32, b: i32) -> i32 {return a + b;
}

但是 Rust 不支持自动返回值类型判断!如果没有明确声明函数返回值的类型,函数将被认为是"纯过程",不允许产生返回值,return 后面不能有返回值表达式。

注意:函数体表达式并不能等同于函数体,它不能使用 return 关键字。

2.7 条件语句

在 Rust 语言中的条件语句是这种格式的:

fn main() {let number = 3;if number < 5 {println!("true");} else {println!("false");}
}

在上述程序中有条件 if 语句,这个语法在很多其它语言中很常见,但也有一些区别:首先,条件表达式 number < 5 不需要用小括号包括(注意,不需要不是不允许);但是 Rust 中的 if 不存在单语句不用加 {} 的规则,不允许使用一个语句代替一个块。尽管如此,Rust 还是支持传统 else-if 语法的:

fn main() {let x = 100;let y;if x > 0 {y = 1;}  else if (x < 0) { // warning: unnecessary parentheses around `if` conditiony = -1;}  else {y = 0;}println!("The value of y is {}", y);
}

以上第二个判断条件 else if (x < 0) 加了圆括号,编译运行的时候会有相关警告。

运行结果:

The value of y is 1

Rust 中的条件表达式必须是 bool 类型,例如下面的程序是错误的:

fn main() {let number = 100;if number {   // error[E0308]: mismatched types,expected `bool`, found integerprintln!("true");}
}

虽然 C/C++ 语言中的条件表达式用整数表示,非 0 即真,但这个规则在很多注重代码安全性的语言中是被禁止的。

在 Rust 中我们可以使用 if-else 结构实现类似于三元条件运算表达式 (A ? B : C) 的效果:

fn main() {let x = 100;let y = if x > 0 { 1 } else { -1 };println!("The value of y is {}", y);
}

运行结果:

The value of y is 1

注意:两个函数体表达式的类型必须一样,且必须有一个 else 及其后的表达式块。

2.8 循环

Rust 除了灵活的条件语句以外,循环结构的设计也十分成熟。

2.8.1 while 循环

while 循环是最典型的条件语句循环:

fn main() {let mut number = 0;while number != 5 {println!("{}", number);number += 1;}println!("EXIT");
}

运行结果:

0
1
2
3
4
EXIT

Rust 语言到目前还没有 do-while 的用法,但是 do 被规定为保留字,也许以后的版本中会用到。

fn main() {let mut number = 0;do {println!("{}", number);number += 1;} while number != 5;println!("EXIT");
}

以上代码编译会报错:error: expected expression, found reserved keyword do

在 C 语言中 for 循环使用三元语句控制循环:

int i;
for (i = 0; i < 10; i++) {// 循环体
}

但是 Rust 中没有这种用法,需要用 while 循环来代替:

let mut i = 0;
while i < 10 {// 循环体i += 1;
}

2.8.2 for 循环

for 循环是最常用的循环结构。比如 for 循环遍历数组:

fn main() {let a = [10, 20, 30, 40, 50];let mut index = 0;for value in a.iter() {println!("The value of a[{}] is {}", index, value);index += 1;}
}

运行结果:

The value of a[0] is 10
The value of a[1] is 20
The value of a[2] is 30
The value of a[3] is 40
The value of a[4] is 50

这个程序中的 for 循环完成了对数组 a 的遍历。a.iter() 代表 a 的迭代器(iterator),实际上,for 循环其实是可以通过下标来访问数组的:

fn main() {let a = [10, 20, 30, 40, 50];for index in 0..5 {println!("The value of a[{}] is {}", index, a[index]);}
}

运行结果和上面是一样的。注意此处 0…5 这个范围使用时包含了 0,却未包含 5。

2.8.3 loop 循环

Rust 语言有原生的无限循环结构 —— loop:

fn main() {let s = ['L', 'O', 'O', 'P', 'E', 'R'];let mut i = 0;loop {let ch = s[i];if ch == 'E' {break;}println!("The value of s[{}] is {}", i, ch);i += 1;}
}

运行结果:

The value of s[0] is L
The value of s[1] is O
The value of s[2] is O
The value of s[3] is P

loop 循环可以通过 break 关键字类似于 return 一样使整个循环退出并给予外部一个返回值。这是一个十分巧妙的设计,因为 loop 这样的循环常被用来当作查找工具使用,如果找到了某个东西当然要将这个结果交出去:

fn main() {let s = ['L', 'O', 'O', 'P', 'E', 'R'];let mut i = 0;let location = loop {let ch = s[i];if ch == 'E' {break i;}println!("The value of s[{}] is {}", i, ch);i += 1;};println!("The index of \'E\' is {}", location);
}

运行结果:

The value of s[0] is L
The value of s[1] is O
The value of s[2] is O
The value of s[3] is P
The index of 'E' is 4

2.8.4 循环标签

如果存在嵌套循环,breakcontinue 应用于此时最内层的循环。选择在一个循环上指定一个循环标签(loop label),然后将标签与 breakcontinue 一起使用,使这些关键字应用于已标记的循环而不是最内层的循环。

fn main() {let mut count = 0;'counting_up: loop {println!("count = {count}");let mut remaining = 10;loop {println!("remaining = {remaining}");if remaining == 9 {break;}if count == 2 {break 'counting_up;}remaining -= 1;}count += 1;}println!("End count = {count}");
}

外层循环有一个标签 counting_up,它将从 0 数到 2。没有标签的内部循环从 10 向下数到 9。第一个没有指定标签的 break 将只退出内层循环。break 'counting_up; 语句将退出外层循环。

运行结果:

count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

参考链接

  1. Rust 官方网站:https://www.rust-lang.org/zh-CN
  2. Rust 官方文档:https://doc.rust-lang.org/
  3. Rust Play:https://play.rust-lang.org/

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

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

相关文章

基于SpringBoot+vue的在线视频教育平台的设计与实现,附源码,数据库

博主介绍&#xff1a;✌程序员徐师兄、7年大厂程序员经历。全网粉丝30W、csdn博客专家、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精彩专栏推荐订阅&#x1f447;…

【文件处理】spring boot 文件处理

接收文件 PostMappingpublic result<String> add(MultipartFile file) throws IOException {// 得到目标文件夹File directory new File("file");//如果文件夹不存在就创建if(!directory.exists()){directory.mkdirs();}//文件名称String fileName file.getO…

性能进阶:使用JMeter进行websocket测试【建议收藏】

本次测试案例主要是分享如何使用JMeter进行websocket协议下的聊天接口性能测试。 包含websocket插件的下载安装、线程组及sampler的设置、csv参数化和组建分布式测试的方法、如何通过调整参数来获得发压机的最大并发数以及对测试过程的总结。 整篇文章只侧重介绍进行websocke…

Linux中的软件包管理器yum

目录 1.什么是软件包 2.关于 rzsz 3.查看软件包 4.如何安装软件 5.如何卸载软件 1.什么是软件包 ● 在Linux下安装软件, 一个通常的办法是下载到程序的源代码, 并进行编译, 得到可执行程序. ● 但是这样太麻烦了, 于是有些人把一些常用的软件提前编译好, 做成软件包(可以理…

阿里云优惠券领取入口、使用教程,2024优惠券更新

阿里云优惠代金券领取入口&#xff0c;阿里云服务器优惠代金券、域名代金券&#xff0c;在领券中心可以领取当前最新可用的满减代金券&#xff0c;阿里云百科aliyunbaike.com分享阿里云服务器代金券、领券中心、域名代金券领取、代金券查询及使用方法&#xff1a; 阿里云优惠券…

Linux下修改系统的运行级别

借助命令ll /etc/system/system/default.target可以查看当前的系统运行的级别&#xff1a;以下图为例运行级别就是3 但如果系统运行的级别默认为图形时&#xff0c;要将图形级别改为文本级别&#xff0c;可以按照下边两种方法运行&#xff1a; 1、重新设置链接文件 这个方法需…

03-常用编程概念

上一篇&#xff1a;02-编程猜谜游戏 本章介绍几乎所有编程语言中都会出现的概念&#xff0c;以及它们在 Rust 中的工作原理。许多编程语言的核心都有许多共同点。本章介绍的概念都不是 Rust 独有的&#xff0c;但我们会在 Rust 的上下文中讨论这些概念&#xff0c;并解释使用这…

Pymol-电子密度图展示方法-PDB数据库已发表结构和自己晶体解析得到的结构密度图

简单来说&#xff0c;想要用PyMol展示电子密度图可以归为以下两种&#xff1a; 一是展示PDB数据库中已发表数据的结构和Map的方式 以6sps.pdb为例&#xff0c;在pymol中导入该数据密度图时&#xff0c;可以无需下载对应的密度文件&#xff0c;直接用fetch即可&#xff1a; Py…

二维码地址门牌管理系统:预约安全、智能生活

文章目录 前言一、访客预约功能二、安全性保障三、智慧小区生活 前言 二维码地址门牌管理系统的出现不仅提升了小区的安全性&#xff0c;还为访客提供了更便捷的预约服务&#xff0c;让亲朋好友轻松进入小区。 一、访客预约功能 该系统提供了访客预约功能&#xff0c;业主可为…

【Docker】部署和运行青龙面板:一个支持python3、javaScript、shell、typescript 的定时任务管理面板

引言 青龙面板是一个支持python3、javaScript、shell、typescript 的定时任务管理面板。 步骤 拉取镜像 从 Docker Hub 上拉取最新的 “qinglong” 镜像。 docker pull whyour/qinglong:latest启动容器 使用刚刚拉取的镜像来启动一个新的 Docker 容器。 docker run -dit \-v…

pikachu验证码绕过第三关攻略

打开pikachu靶场第三关&#xff1a; 挂上代理&#xff0c;随便输入账户密码&#xff1a; 返回bp。进行放包发现显示token错误。 每一次登录的返回包会带有token相关数据用于下一次的登录认证&#xff1a; 进行替换token值&#xff1a; 替换完成开始进行检点的爆破&#xff1a;…

准备的一些爬虫面试题

最近准备试试外面的市场&#xff0c;找找看外面的岗位&#xff0c;给自己找点后路&#xff0c;防止到时候被裁被动。 我将面试题分为基于scrapy框架与普通爬虫【requests/aiohttp等开发的爬虫】 普通爬虫面试题 列举反爬虫机制 (1) UA 检测&#xff0c;请求头合法性 (2) Rob…

Python使用HTTP代理进行API请求的优化

在Python中&#xff0c;HTTP代理是一种常用的技术&#xff0c;用于控制和修改HTTP请求和响应。通过使用HTTP代理&#xff0c;我们可以更好地控制网络请求的行为&#xff0c;提高安全性、隐私性和效率。下面我们将详细介绍如何在Python中使用HTTP代理进行API请求的优化。 一、减…

10分钟快速上手LLM大模型Python前端开发(三)之显示模块(二)

【计划昵称全网统一&#xff0c;代码随想随记&#xff0c;知乎无法立即修改&#xff0c;&#xff0c;】 微信公众号&#xff1a;leetcode_algos_life&#xff0c;代码随想随记 小红书&#xff1a;412408155 CSDN&#xff1a;https://blog.csdn.net/woai8339?typeblog &#xf…

反序列化字符串逃逸(上篇)

首先&#xff0c;必须先明白&#xff0c;这个点并不难&#xff0c;我给大家梳理一遍就会明白。 反序列化字符串逃逸就是序列化过程中逃逸出来字符&#xff0c;是不是很简单&#xff0c;哈哈哈&#xff01; 好了&#xff0c;不闹了&#xff0c;其实&#xff1a; 这里你们只要懂…

Windows系统如何修改Nginx配置实现远程访问多个本地站点

文章目录 1. 下载windows版Nginx2. 配置Nginx3. 测试局域网访问4. cpolar内网穿透5. 测试公网访问6. 配置固定二级子域名7. 测试访问公网固定二级子域名 1. 下载windows版Nginx 进入官方网站(http://nginx.org/en/download.html)下载windows版的nginx 下载好后解压进入nginx目…

P4学习(六)实验三:a Control Plane using P4Runtime

目录 一. 实验目的二.阅读MyController.py文件1.导入P4Runtime的库2.main部分1. P4InfoHelper 实例化2. 创建交换机连接3. 设置主控制器4. 安装 P4 程序5. 写入隧道规则6. 读取表项和计数器&#xff08;注释掉的部分&#xff09;7. 定时打印隧道计数器8. 异常处理9. 关闭交换机…

TensorRT部署--Linux(Ubuntu)环境配置

系列文章目录 TensorRT环境配置–Linux(Ubuntu) 文章目录 系列文章目录前言一、环境配置二、CUDA下载安装三、cuDNN下载安装四、TensorRT下载安装五、模型创建总结 前言 TensorRT部署-Windows环境配置: https://blog.csdn.net/m0_70420861/article/details/135658922?csdn_s…

深入了解WPF控件:常用属性与用法(六)

掌握WPF控件&#xff1a;熟练常用属性&#xff08;六&#xff09; ListView 用于展示数据项集合的列表控件。它提供了丰富的功能和灵活的定制性&#xff0c;可以轻松地展示和编辑大量的数据。 常用属性描述ItemsSource用于设置ListView的数据源。可以是一个集合、数组或列表…

透明拼接屏代工:专业制造与质量保证

透明拼接屏代工是指专业的代工厂家根据客户的需求&#xff0c;为其生产透明拼接屏产品。随着透明拼接屏市场的不断扩大&#xff0c;越来越多的企业选择通过代工方式快速进入市场。尼伽小编将深入探讨透明拼接屏代工的优势、选择合适的代工厂家以及质量保证等方面的内容。 一、透…