603 lines
21 KiB
Markdown
603 lines
21 KiB
Markdown
# 注释
|
||
单行注释：
|
||
```python
|
||
# 这是一条注释信息
|
||
```
|
||
|
||
多行注释：
|
||
```python
|
||
'''
|
||
这是多行注释
|
||
'''
|
||
|
||
"""
|
||
这是多行注释
|
||
"""
|
||
```
|
||
|
||
# 变量
|
||
变量就是把某些值或者运行的结果临时保存在内存中，以便后续调用。
|
||
|
||
## 强类型与弱类型
|
||
|
||
### 强类型
|
||
- **定义**：在强类型语言中，类型检查在编译时或运行时都很严格，变量的类型在定义时明确，且不允许隐式转换。
|
||
- **特征**：
|
||
- 不同类型之间的操作会导致错误。
|
||
- 类型安全，高度限制了类型不兼容的操作。
|
||
- **示例语言**：Java、C++、Python、Rust
|
||
|
||
**示例：python**
|
||
```python
|
||
a = 10
|
||
b = "10"
|
||
print(a+b)
|
||
print(a == b)
|
||
|
||
# Output:
|
||
TypeError: unsupported operand type(s) for +: 'int' and 'str'
|
||
......
|
||
```
|
||
|
||
### 弱类型
|
||
- **定义**：在弱类型语言中，变量的数据类型可以在运行时发生变化，允许隐式转换。
|
||
- **特征**：
|
||
- 不同类型之间的操作可能会被自动转换。
|
||
- 灵活性高，但可能导致运行时错误或意外结果。
|
||
- **示例语言**：JavaScript、PHP、Ruby
|
||
|
||
**示例：JavaScript**
|
||
|
||
```python
|
||
let a = "5";
|
||
let b = 10;
|
||
let result = a + b; // result 为 "510"（字符串拼接）
|
||
```
|
||
|
||
### 对比
|
||
|
||
| 特性 | 强类型 | 弱类型 |
|
||
| :----------- | :----------------------- | :----------------------- |
|
||
| 类型检查 | 严格 | 灵活 |
|
||
| 隐式转换 | 不允许 | 允许 |
|
||
| 错误检测 | 通常在编译时或运行时 | 可能在运行时发现错误 |
|
||
| 类型安全 | 高 | 低 |
|
||
| 代码可维护性 | 高，类型明确易于理解 | 低，需要额外的类型检查 |
|
||
| 性能特征 | 通常性能较好，优化空间大 | 可能有性能开销，需要类型推断 |
|
||
|
||
## 动态类型与静态类型
|
||
|
||
### 动态类型
|
||
- **定义**：动态类型语言在运行时确定变量的类型，变量可以在程序执行过程中改变其类型。
|
||
- **特征**：
|
||
- 变量不需要在声明时指定类型。
|
||
- 类型检查在运行时进行。
|
||
- 允许在同一变量中存储不同类型的数据。
|
||
- 示例语言：JavaScript、Python、Ruby、PHP。
|
||
|
||
**示例：python**
|
||
|
||
```python
|
||
a = 10 # 整数类型
|
||
print(a) # 输出: 10
|
||
|
||
a = "Hello" # 现在是字符串类型
|
||
print(a) # 输出: Hello
|
||
```
|
||
|
||
### 静态类型
|
||
- **定义**：静态类型语言在编译时确定变量的类型，变量的类型在声明时明确且在整个生命周期内保持不变。
|
||
- 特征：
|
||
- 变量必须在声明时指定类型。
|
||
- 类型检查在编译时进行。
|
||
- 不允许在同一变量中存储不同类型的数据。
|
||
- 示例语言：Java、C、C++、Go、Rust。
|
||
|
||
**示例：C**
|
||
|
||
```c
|
||
#include <stdio.h>
|
||
|
||
int main() {
|
||
int a = 10; // 整数类型
|
||
float b = 5.5; // 浮点类型
|
||
char c = 'A'; // 字符类型
|
||
|
||
printf("a = %d\n", a);
|
||
printf("b = %.2f\n", b);
|
||
printf("c = %c\n", c);
|
||
|
||
return 0;
|
||
}
|
||
```
|
||
|
||
### 对比
|
||
|
||
| 特性 | 动态类型 | 静态类型 |
|
||
| :----------- | :----------------------- | :----------------------- |
|
||
| 类型检查时机 | 运行时 | 编译时 |
|
||
| 类型声明 | 不需要显式声明 | 需要显式声明 |
|
||
| 类型灵活性 | 高，可以随时改变变量类型 | 低，类型在声明后固定 |
|
||
| 内存使用 | 可能较高，需要存储类型信息 | 通常较低，编译时确定 |
|
||
| 开发效率 | 较高，代码编写更灵活 | 前期较低，需要类型声明 |
|
||
| 调试难度 | 可能较高，运行时才发现错误 | 较低，编译时即可发现问题 |
|
||
| 性能特征 | 运行时开销较大 | 运行时性能通常更好 |
|
||
|
||
|
||
## 声明变量
|
||
```python
|
||
a = "Hello World!"
|
||
print(a)
|
||
```
|
||
|
||
## 变量命名约定
|
||
|
||
### Python 变量命名规则
|
||
- 只能由字母、数字和下划线组成
|
||
- 只能以字母或下划线开头，不能以数字开头
|
||
- 不区分大小写，但为了提高可读性，推荐使用小写字母命名，并用下划线分隔多个单词
|
||
- 应该具有描述性，以便能够清晰地表达变量的含义
|
||
- 不能使用 Python 的关键字，如下：
|
||
```python
|
||
'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
|
||
'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not',
|
||
'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield'
|
||
```
|
||
|
||
|
||
### 常见的命名方式
|
||
|
||
- 大驼峰命名法：将多个单词连接在一起，每个单词首字母大写，常用于类、函数和对象的命名。
|
||
```python
|
||
FirstName = '英格科技'
|
||
LastName = 'EaglesLab'
|
||
|
||
print("你的名字是:", FirstName + LastName)
|
||
```
|
||
|
||
- 下划线命名法：将多个单词连接在一起，使用下划线 `_` 分隔每个单词，所有字母小写，常用于变量和模块名的命名。
|
||
```python
|
||
first_str = 'Hello'
|
||
second_str = 'Python'
|
||
|
||
print(first_str + " " + second_str)
|
||
```
|
||
|
||
- 全大写命名法：将多个单词连接在一起，每个单词所有字母大写，可以加上适当的分隔符如 `_`，常用于常量或全局变量的命名。
|
||
|
||
```python
|
||
FIRST_STR = 'Hello'
|
||
SECOND_STR = 'Python'
|
||
|
||
print( FIRST_STR+ " " + SECOND_STR)
|
||
```
|
||
|
||
## 变量的赋值
|
||
将某个数据赋值给某个变量存储
|
||
|
||
```python
|
||
a = "变量1"
|
||
b = "变量2"
|
||
print(id(a), id(b))
|
||
```
|
||
|
||
|
||
|
||
```python
|
||
a = "变量1"
|
||
b = a
|
||
print(id(a), id(b))
|
||
```
|
||
|
||
|
||
|
||
## 常量
|
||
|
||
常量是指在程序运行过程中其值不应被改变的变量。
|
||
|
||
Python 没有内置的常量机制，但通过命名约定和模块结构，可以有效地使用常量来提高代码的可读性和可维护性。在设计大型程序时，合理使用常量是一个良好的编程习惯。
|
||
|
||
常量通常是通过使用大写字母命名的变量来表示：
|
||
|
||
```python
|
||
PI = 3.14159
|
||
MAX_CONNECTIONS = 100
|
||
```
|
||
|
||
# 用户交互
|
||
|
||
## 输入
|
||
|
||
解释器在执行该代码的时候，如果遇到 `input()` 就会出现阻塞，程序暂停，等待用户输入。当用户回车以后，程序才会继续向下执行
|
||
|
||
```python
|
||
name = input('请输出你的姓名:')
|
||
print(name)
|
||
|
||
# 注意：通过input函数输入进来的内容一律会被当成字符串处理
|
||
a = input('请输入一个数字:')
|
||
# a = int(input('请输入一个数字:')) # 类型转化
|
||
print(type(a))
|
||
print(a > 0)
|
||
```
|
||
|
||
## 输出
|
||
|
||
**基本用法**：
|
||
|
||
```python
|
||
a = "Hello world"
|
||
print(a)
|
||
```
|
||
|
||
### 格式化输出
|
||
|
||
```python
|
||
name = input("姓名：")
|
||
age = input("年龄：")
|
||
job = input("工作：")
|
||
info = '''
|
||
----------- info of %s -----------
|
||
姓名：%s
|
||
年龄：%s
|
||
工作：%s
|
||
''' % (name,name,age,job)
|
||
print(info)
|
||
```
|
||
|
||
### 字符串格式化标志(占位符)
|
||
|
||
以下是 Python 中字符串格式化的常见格式化标志及其说明：
|
||
|
||
| 标志 | 说明 |
|
||
| :--- | :--- |
|
||
| `s` | 获取传入对象的 `__str__` 方法的返回值 |
|
||
| `r` | 获取传入对象的 `__repr__` 方法的返回值 |
|
||
| `c` | 将整数转换为Unicode字符或直接添加字符 |
|
||
| `o` | 将整数转换为八进制表示 |
|
||
| `x` | 将整数转换为十六进制表示 |
|
||
| `d` | 将整数、浮点数转换为十进制表示 |
|
||
| `e` | 将数值转换为科学计数法（小写e） |
|
||
| `E` | 将数值转换为科学计数法（大写E） |
|
||
| `f` | 将数值转换为浮点表示（默认6位小数） |
|
||
| `F` | 同 `f`，但使用大写表示特殊值 |
|
||
| `g` | 自动选择 `e` 或 `f`（小写） |
|
||
| `G` | 自动选择 `E` 或 `F`（大写） |
|
||
| `%` | 输出百分号 |
|
||
|
||
**示例**：
|
||
|
||
```python
|
||
# s：获取对象的 __str__ 方法返回值
|
||
print("Hello, %s!" % "EaglesLab") # 输出: Hello, EaglesLab!
|
||
|
||
# r：获取对象的 __repr__ 方法返回值
|
||
print("Name: %r" % name) # 输出: Name: 'EaglesLab'
|
||
|
||
# c：整数转换为其 Unicode 字符（0-1114111）
|
||
print("Unicode character: %c" % 65) # 输出: Unicode character: A
|
||
|
||
# o：将整数转换为八进制表示
|
||
print("Octal: %o" % 10) # 输出: Octal: 12
|
||
|
||
# x：将整数转换为十六进制表示
|
||
print("Hexadecimal: %x" % 255) # 输出: Hexadecimal: ff
|
||
|
||
# d：将整数或浮点数转换为十进制表示
|
||
print("Decimal: %d" % 42) # 输出: Decimal: 42
|
||
|
||
# e：将整数或浮点数转换为科学计数法（小写 e）
|
||
print("Scientific: %e" % 123456789) # 输出: Scientific: 1.234568e+08
|
||
|
||
# E：将整数或浮点数转换为科学计数法（大写 E）
|
||
print("Scientific: %E" % 123456789) # 输出: Scientific: 1.234568E+08
|
||
|
||
# f/F：将整数或浮点数转换为浮点数表示，默认保留小数点后 6 位
|
||
print("Float: %f" % 3.14159) # 输出: Float: 3.141590
|
||
print("Float: %F" % 3.14159) # 输出: Float: 3.141590
|
||
|
||
# g/G：自动调整为浮点型或科学计数法，超出 6 位数使用科学计数法
|
||
print("Auto: %g" % 1234567.89) # 输出: Auto: 1234567.89
|
||
print("Auto: %G" % 1234567.89) # 输出: Auto: 1234567.89
|
||
|
||
# %：表示一个百分号
|
||
print("Percentage: %.2f%%" % (0.75 * 100)) # 输出: Percentage: 75.00%
|
||
```
|
||
|
||
# 数据类型
|
||
|
||
## 整数（int）
|
||
|
||
- **描述**：表示没有小数部分的数字，可以是正数、负数或零。
|
||
- **特性**：
|
||
- Python 3 中的 `int` 类型是无限大小的。这意味着你可以创建非常大的整数，而不必担心溢出（overflow）的问题。
|
||
- Python 会根据整数的大小自动调整内存使用，因此可以存储任意大小的整数，只要计算机的内存允许。
|
||
- 支持基本的算术运算，如加、减、乘、除等。
|
||
|
||
**示例**：
|
||
|
||
```python
|
||
a = 10
|
||
b = -5
|
||
c = 0
|
||
print(a + b)
|
||
# Output: 5
|
||
print(type(a)) # 可以使用 type() 内置函数来查看某个变量或值的数据类型
|
||
# Output:
|
||
<class 'int'>
|
||
```
|
||
|
||
## 字符串（str）
|
||
|
||
- **描述**：字符串是字符的序列，可以通过单引号或双引号定义。
|
||
- **特性**：
|
||
- 字符串是不可变的（immutable），不能更改其内容。
|
||
- 支持切片、连接、重复等操作。
|
||
- 可以使用转义字符处理特殊字符。
|
||
- 在 Python 中, 加了引号的字符都被认为是字符串！
|
||
|
||
**示例**：
|
||
|
||
```python
|
||
Greeting = "Welcome to 英格科技"
|
||
Name = "同学们"
|
||
print(Greeting + " " + Name) # 字符串可以通过 + 号进行拼接
|
||
|
||
# Output:
|
||
Welcome to 英格科技 牛老师
|
||
```
|
||
|
||
### 字符串的索引与切片
|
||
|
||
**字符串的索引**：
|
||
|
||
索引：每个字符在字符串中都有一个唯一的索引，索引从 `0` 开始。
|
||
|
||
负索引：可以使用负数索引从字符串的末尾开始访问字符，`-1` 表示最后一个字符，`-2` 表示倒数第二个字符，以此类推。
|
||
|
||
**示例**：
|
||
|
||
```bash
|
||
s = "Hello, World!"
|
||
|
||
# 正索引
|
||
print(s[0]) # 输出: H
|
||
print(s[7]) # 输出: W
|
||
|
||
# 负索引
|
||
print(s[-1]) # 输出: !
|
||
print(s[-5]) # 输出: o
|
||
```
|
||
|
||
**字符串的切片**：
|
||
|
||
切片：可以通过指定起始索引和结束索引来提取字符串的子串。切片的语法为 `s[start:end]`，包含起始索引的字符，但不包含结束索引的字符。
|
||
|
||
步长：可以指定步长来控制切片的间隔，语法为 `s[start:end:step]`。如果不指定步长，默认为 `1`。
|
||
|
||
**示例**：
|
||
|
||
```python
|
||
s = "Hello, World!"
|
||
|
||
# 基本切片
|
||
print(s[0:5]) # 输出: Hello
|
||
print(s[7:12]) # 输出: World
|
||
|
||
# 省略起始或结束索引
|
||
print(s[:5]) # 输出: Hello (从开始到索引 4)
|
||
print(s[7:]) # 输出: World! (从索引 7 到结束)
|
||
|
||
# 使用负索引切片
|
||
print(s[-6:-1]) # 输出: World
|
||
|
||
# 步长切片
|
||
print(s[::2]) # 输出: Hlo ol! (每隔一个字符)
|
||
print(s[::-1]) # 输出: !dlroW ,olleH (反转字符串)
|
||
```
|
||
|
||
### 字符串常用方法
|
||
|
||
```bash
|
||
# 字符串操作示例
|
||
|
||
words = "beautiful is better than ugly."
|
||
|
||
# 字符串的基本操作
|
||
print(words.capitalize()) # 首字母大写
|
||
print(words.swapcase()) # 大小写翻转
|
||
print(words.title()) # 每个单词的首字母大写
|
||
|
||
# 内容居中，总长度，空白处填充
|
||
a = "test"
|
||
ret = a.center(20, "*")
|
||
print(ret)
|
||
|
||
# 统计字符串中的元素出现的个数
|
||
ret = words.count("e", 0, 30)
|
||
print(ret)
|
||
|
||
# startswith 和 endswith 判断
|
||
print(a.startswith("a")) # 判断是否以 'a' 开头
|
||
print(a.endswith("j")) # 判断是否以 'j' 结尾
|
||
print(a.startswith('sdj', 2, 5)) # 判断子串是否在指定范围内
|
||
print(a.endswith('ado', 7, 10)) # 判断子串是否在指定范围内
|
||
|
||
# 寻找字符串中的元素是否存在
|
||
print(a.find('sdj', 1, 10)) # 返回索引，找不到返回 -1
|
||
print(a.index('sdj', 1, 10)) # 返回索引，找不到抛出异常
|
||
|
||
# split 以指定字符分割，形成列表
|
||
ret = words.split(' ')
|
||
print(ret)
|
||
ret = words.rsplit(' ', 2) # 指定分割次数
|
||
print(ret)
|
||
|
||
# format 的三种用法
|
||
print('{} {} {}'.format('aaron', 18, 'teacher'))
|
||
print('{1} {0} {1}'.format('aaron', 18, 'teacher'))
|
||
print('{name} {age} {job}'.format(job='teacher', name='aaron', age=18))
|
||
|
||
# strip 操作
|
||
a = '****asdasdasd********'
|
||
print(a.strip('*')) # 去除两端指定字符
|
||
print(a.lstrip('*')) # 去除左侧指定字符
|
||
print(a.rstrip('*')) # 去除右侧指定字符
|
||
|
||
# replace 操作
|
||
print(words.replace('e', 'a', 2)) # 替换 'e' 为 'a'，替换两次
|
||
|
||
# 字符串类型检查
|
||
print(words.isalnum()) # 判断字符串是否只由字母或数字组成
|
||
print(words.isalpha()) # 判断字符串是否只由字母组成
|
||
print(words.isdigit()) # 判断字符串是否只由数字组成
|
||
```
|
||
|
||
## 布尔类型（bool）
|
||
|
||
- **描述**：布尔类型只有两个值：`True` 和 `False`。
|
||
- **特性**：
|
||
- 通常用于条件判断和逻辑运算。
|
||
- 布尔值在逻辑表达式中可以进行运算。
|
||
|
||
布尔类型很简单，就两个值 ，一个 True(真)，一个 False(假), 主要用记逻辑判断
|
||
|
||
```python
|
||
a = 3
|
||
b = 5
|
||
print(a < b, a > b , a != b)
|
||
|
||
# Output:
|
||
True False True
|
||
```
|
||
|
||
# 基本运算符
|
||
|
||
## 算数运算符
|
||
|
||
用于执行基本的数学运算
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :----- | :------------------------------------------------- | :-------------- |
|
||
| `+` | 加法，返回两个数的和 | `3 + 5` → `8` |
|
||
| `-` | 减法，返回第一个数减去第二个数的结果 | `10 - 4` → `6` |
|
||
| `*` | 乘法，返回两个数的乘积 | `2 * 3` → `6` |
|
||
| `/` | 除法，返回第一个数除以第二个数的结果，结果为浮点数 | `7 / 2` → `3.5` |
|
||
| `//` | 地板除法，返回两个数相除的整数部分 | `7 // 2` → `3` |
|
||
| `%` | 取模，返回第一个数除以第二个数的余数 | `7 % 2` → `1` |
|
||
| `**` | 幂运算，返回第一个数的第二个数次幂 | `2 ** 3` → `8` |
|
||
|
||
## 关系运算符
|
||
|
||
用于比较两个值的关系
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :----- | :--------------------------------------- | :---------------- |
|
||
| `==` | 等于，判断两个值是否相等 | `5 == 5` → `True` |
|
||
| `!=` | 不等于，判断两个值是否不相等 | `5 != 3` → `True` |
|
||
| `>` | 大于，判断左侧值是否大于右侧值 | `5 > 3` → `True` |
|
||
| `<` | 小于，判断左侧值是否小于右侧值 | `5 < 3` → `False` |
|
||
| `>=` | 大于等于，判断左侧值是否大于或等于右侧值 | `5 >= 5` → `True` |
|
||
| `<=` | 小于等于，判断左侧值是否小于或等于右侧值 | `3 <= 5` → `True` |
|
||
|
||
## 逻辑运算符
|
||
|
||
用于进行布尔逻辑运算
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :----- | :---------------------------------------------- | :------------------------- |
|
||
| `and` | 逻辑与，当且仅当两个表达式都为 True 时返回 True | `True and False` → `False` |
|
||
| `or` | 逻辑或，只要有一个表达式为 True 即返回 True | `True or False` → `True` |
|
||
| `not` | 逻辑非，返回布尔值的反转 | `not True` → `False` |
|
||
|
||
## 赋值运算符
|
||
|
||
用于给变量赋值
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :----- | :-------------------------------- | :-------- |
|
||
| `=` | 赋值，将右侧的值赋给左侧的变量 | `x = 5` |
|
||
| `+=` | 加法赋值，等同于 `x = x + 5` | `x += 3` |
|
||
| `-=` | 减法赋值，等同于 `x = x - 5` | `x -= 2` |
|
||
| `*=` | 乘法赋值，等同于 `x = x * 5` | `x *= 4` |
|
||
| `/=` | 除法赋值，等同于 `x = x / 5` | `x /= 2` |
|
||
| `//=` | 地板除法赋值，等同于 `x = x // 5` | `x //= 3` |
|
||
| `%=` | 取模赋值，等同于 `x = x % 5` | `x %= 2` |
|
||
| `**=` | 幂赋值，等同于 `x = x ** 5` | `x **= 3` |
|
||
|
||
## 位运算符
|
||
|
||
用于对整数的二进制位进行操作
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :----- | :---------------------------------- | :------------------------------------ |
|
||
| `&` | 按位与，两个比特位都为 1 时结果为 1 | `5 & 3` → `1` |
|
||
| `\|` | 按位或，只要有一个比特位为 1 结果为 1 | `5 \| 3` → `7` |
|
||
| `^` | 按位异或，当比特位不同结果为 1 | `5 ^ 3` → `6` |
|
||
| `~` | 按位取反，反转所有比特位 | `~5` → `-6` |
|
||
| `<<` | 左移运算，向左移动指定的比特位数 | `5 << 1` → `10` |
|
||
| `>>` | 右移运算，向右移动指定的比特位数 | `5 >> 1` → `2` |
|
||
|
||
## 身份运算符
|
||
|
||
用于比较两个对象的内存地址
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :------- | :--------------------------- | :----------- |
|
||
| `is` | 判断两个对象是否为同一对象 | `x is y` |
|
||
| `is not` | 判断两个对象是否不是同一对象 | `x is not y` |
|
||
|
||
## 成员运算符
|
||
|
||
用于检查值是否在序列中
|
||
|
||
| 运算符 | 描述 | 示例 |
|
||
| :------- | :--------------------- | :---------------------------- |
|
||
| `in` | 判断元素是否在序列中 | `3 in [1, 2, 3]` → `True` |
|
||
| `not in` | 判断元素是否不在序列中 | `4 not in [1, 2, 3]` → `True` |
|
||
|
||
## 运算符优先级
|
||
|
||
以下表格列出了从最高到最低优先级的所有运算符：
|
||
|
||
| 优先级 | 运算符 | 描述 |
|
||
| :----- | :----------------------------------------- | :------------------------- |
|
||
| 1 | `()` | 括号，改变运算顺序 |
|
||
| 2 | `**` | 幂运算 |
|
||
| 3 | `+`, `-` | 正负号（正负运算） |
|
||
| 4 | `*`, `/`, `//`, `%` | 乘法、除法、地板除法、取模 |
|
||
| 5 | `+`, `-` | 加法、减法 |
|
||
| 6 | `<<`, `>>` | 位移运算 |
|
||
| 7 | `&` | 按位与 |
|
||
| 8 | `^` | 按位异或 |
|
||
| 9 | ` | ` |
|
||
| 10 | `==`, `!=`, `>`, `<`, `>=`, `<=` | 比较运算 |
|
||
| 11 | `is`, `is not`, `in`, `not in` | 身份和成员运算 |
|
||
| 12 | `not` | 逻辑非 |
|
||
| 13 | `and` | 逻辑与 |
|
||
| 14 | `or` | 逻辑或 |
|
||
| 15 | `=` | 赋值 |
|
||
| 16 | `+=`, `-=`, `*=`, `/=`, `//=`, `%=`, `**=` | 赋值运算 |
|
||
|
||
### 注意事项
|
||
|
||
1. **括号优先**：使用括号可以改变运算顺序，任何在括号内的运算会优先计算。
|
||
2. **运算符结合性**：
|
||
- 大多数运算符是从左到右结合的，例如加法和减法。
|
||
- 幂运算 `**` 是从右到左结合，即 `2 ** 3 ** 2` 等于 `2 ** (3 ** 2)`。
|
||
3. **比较运算符**：比较运算符的优先级在逻辑运算符之前。
|
||
4. **赋值运算符**：赋值运算符的优先级最低。
|
||
|
||
```python
|
||
# 示例 1
|
||
result = 2 + 3 * 4 # 结果为 14，因为乘法优先于加法
|
||
|
||
# 示例 2
|
||
result = (2 + 3) * 4 # 结果为 20，因为括号改变了优先顺序
|
||
|
||
# 示例 3
|
||
result = 2 ** 3 ** 2 # 结果为 512，因为幂运算是右结合的
|
||
```
|
||
|
||
了解运算符优先级有助于在编写和阅读代码时清晰地理解表达式的计算顺序。
|