目录
一、运算符介绍
1.1 算术运算符
1.2 比较运算符
1.3 赋值运算符
1.4 位运算符
下表中变量 a 为 60，b 为 13，二进制格式如下：
a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
1.5 逻辑运算符
1.6 成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
1.7 身份运算符
身份运算符用于比较两个对象的存储单元
二、python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
三、三大流程结构
在Python编程中，三大流程结构是控制程序执行流程的基本方式。它们分别是：
1. **顺序结构**：
- 顺序结构是程序中最基本的执行流程，按照代码书写的顺序依次执行。
- 例如：
x = 10
y = 20
z = x + y
print(z) # 输出 302. **选择结构（条件结构）**：
- 选择结构用于根据条件判断来决定执行哪一段代码。
- 主要通过 `if`、`elif` 和 `else` 语句实现。
- 例如：
age = 18
if age >= 18:
print("成年人")
else:
print("未成年人")if语句运行过程如下动图：
3. **循环结构**：
- 循环结构用于重复执行某段代码，直到满足某个条件为止。
- 主要通过 `while` 和 `for` 语句实现。
- 例如：
# while 循环
count = 0
while count < 5:
print(count)
count += 1
# for 循环
for i in range(5):
print(i)while循环过程图示：
4. 循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
在Python中，循环控制语句用于控制循环的执行流程。主要有以下几种：
1）. **`break` 语句**：
- `break` 语句用于立即终止当前循环，跳出循环体。
- 常用于在满足某个条件时提前结束循环。
- 例如：
for i in range(10):
if i == 5:
break
print(i) # 输出 0 到 42）. **`continue` 语句**：
- `continue` 语句用于跳过当前循环的剩余语句，并继续下一次循环。
- 常用于在满足某个条件时跳过当前迭代。
- 例如：
for i in range(10):
if i % 2 == 0:
continue
print(i) # 输出 1, 3, 5, 7, 93）. **`pass` 语句**：
- `pass` 语句是一个空操作语句，用于在语法上需要语句但实际不需要执行任何代码的地方。
- 常用于占位，表示稍后会添加代码。
- 例如：
for i in range(10):
if i % 2 == 0:
pass
else:
print(i) # 输出 1, 3, 5, 7, 94）. **`else` 子句**：
- `else` 子句可以与 `for` 和 `while` 循环一起使用，当循环正常结束（即没有遇到 `break` 语句）时执行。
- 常用于在循环结束后执行某些操作。
- 例如：
for i in range(5):
print(i)
else:
print("循环正常结束") # 输出 0, 1, 2, 3, 4 和 "循环正常结束"四、列表
在Python中，列表（List）是一种非常灵活且强大的数据结构，用于存储一组有序的元素。列表可以包含不同类型的数据，如整数、字符串、浮点数，甚至是其他列表。以下是一些关于列表的基本操作和特性：
### 创建列表
你可以使用方括号 `[]` 来创建一个列表，并用逗号分隔其中的元素：
my_list = [1, 2, 3, 4, 5]
print(my_list) # 输出: [1, 2, 3, 4, 5]### 访问元素
你可以通过索引来访问列表中的元素，索引从0开始：
print(my_list[0]) # 输出: 1
print(my_list[3]) # 输出: 4### 修改元素
你可以通过索引来修改列表中的元素：
my_list[1] = 10
print(my_list) # 输出: [1, 10, 3, 4, 5]### 列表切片
你可以使用切片操作来获取列表的子集：
print(my_list[1:4]) # 输出: [10, 3, 4]
print(my_list[:3]) # 输出: [1, 10, 3]
print(my_list[2:]) # 输出: [3, 4, 5]### 列表方法
Python提供了许多内置方法来操作列表：
- `append(item)`：在列表末尾添加一个元素。
my_list.append(6)
print(my_list) # 输出: [1, 10, 3, 4, 5, 6]- `insert(index, item)`：在指定位置插入一个元素。
my_list.insert(2, 20)
print(my_list) # 输出: [1, 10, 20, 3, 4, 5, 6]- `remove(item)`：移除列表中第一个匹配的元素。
my_list.remove(10)
print(my_list) # 输出: [1, 20, 3, 4, 5, 6]- `pop(index)`：移除并返回指定位置的元素，如果不指定索引，则移除并返回最后一个元素。
popped_item = my_list.pop(2)
print(popped_item) # 输出: 3
print(my_list) # 输出: [1, 20, 4, 5, 6]- `index(item)`：返回第一个匹配元素的索引。
index = my_list.index(4)
print(index) # 输出: 2- `count(item)`：返回元素在列表中出现的次数。
count = my_list.count(5)
print(count) # 输出: 1- `sort()`：对列表进行排序。
my_list.sort()
print(my_list) # 输出: [1, 4, 5, 6, 20]- `reverse()`：反转列表中的元素。
my_list.reverse()
print(my_list) # 输出: [20, 6, 5, 4, 1]### 列表推导式
列表推导式是一种简洁的创建列表的方式：
squares = [x**2 for x in range(5)]
print(squares) # 输出: [0, 1, 4, 9, 16]五、元组
在Python中，元组（Tuple）是一种有序且不可变的数据类型，用于存储一组元素。元组与列表类似，但元组一旦创建，其内容就不能被修改。以下是一些关于元组的基本操作和特性：
### 创建元组
你可以使用圆括号 `()` 来创建一个元组，并用逗号分隔其中的元素：
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple) # 输出: (1, 2, 3, 4, 5)### 访问元素
你可以通过索引来访问元组中的元素，索引从0开始：
print(my_tuple[0]) # 输出: 1
print(my_tuple[3]) # 输出: 4### 元组切片
你可以使用切片操作来获取元组的子集：
print(my_tuple[1:4]) # 输出: (2, 3, 4)
print(my_tuple[:3]) # 输出: (1, 2, 3)
print(my_tuple[2:]) # 输出: (3, 4, 5)### 元组的不可变性
元组一旦创建，其内容就不能被修改。这意味着你不能添加、删除或修改元组中的元素：
# 尝试修改元组中的元素会引发 TypeError
# my_tuple[1] = 10 # 这行代码会引发 TypeError### 元组方法
虽然元组是不可变的，但Python提供了一些内置方法来操作元组：
- `count(item)`：返回元素在元组中出现的次数。
count = my_tuple.count(3)
print(count) # 输出: 1- `index(item)`：返回第一个匹配元素的索引。
index = my_tuple.index(4)
print(index) # 输出: 3### 元组的优点
- **不可变性**：元组的不可变性使得它们在某些情况下比列表更安全，特别是在需要确保数据不被意外修改的场景中。
- **性能**：由于元组是不可变的，它们的访问速度通常比列表更快，占用的内存也更少。
### 元组的使用场景
- 当你需要一个不可变的数据集合时，可以使用元组。
- 元组常用于函数返回多个值的场景。
### 示例
def get_user_info():
name = "Alice"
age = 30
city = "New York"
return name, age, city # 返回一个元组
user_info = get_user_info()
print(user_info) # 输出: ('Alice', 30, 'New York')六、字典
在Python中，字典（Dictionary）是一种无序、可变且可嵌套的数据类型，用于存储键值对（key-value pairs）。字典中的每个键（key）必须是唯一的，而值（value）可以是任意类型的数据。以下是一些关于字典的基本操作和特性：
### 创建字典
你可以使用花括号 `{}` 来创建一个字典，并用冒号 `:` 分隔键和值，用逗号分隔键值对：
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
print(my_dict) # 输出: {'name': 'Alice', 'age': 30, 'city': 'New York'}### 访问元素
你可以通过键来访问字典中的值：
print(my_dict["name"]) # 输出: Alice
print(my_dict["age"]) # 输出: 30### 修改元素
你可以通过键来修改字典中的值：
my_dict["age"] = 31
print(my_dict) # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York'}### 添加元素
你可以通过新的键来添加新的键值对：
my_dict["country"] = "USA"
print(my_dict) # 输出: {'name': 'Alice', 'age': 31, 'city': 'New York', 'country': 'USA'}### 删除元素
你可以使用 `del` 语句或 `pop` 方法来删除字典中的键值对：
del my_dict["city"]
print(my_dict) # 输出: {'name': 'Alice', 'age': 31, 'country': 'USA'}
popped_value = my_dict.pop("age")
print(popped_value) # 输出: 31
print(my_dict) # 输出: {'name': 'Alice', 'country': 'USA'}### 字典方法
Python提供了许多内置方法来操作字典：
- `keys()`：返回字典中所有键的视图对象。
keys = my_dict.keys()
print(keys) # 输出: dict_keys(['name', 'country'])- `values()`：返回字典中所有值的视图对象。
values = my_dict.values()
print(values) # 输出: dict_values(['Alice', 'USA'])- `items()`：返回字典中所有键值对的视图对象。
items = my_dict.items()
print(items) # 输出: dict_items([('name', 'Alice'), ('country', 'USA')])- `get(key, default)`：返回指定键的值，如果键不存在，则返回默认值。
value = my_dict.get("name", "Unknown")
print(value) # 输出: Alice
value = my_dict.get("age", "Unknown")
print(value) # 输出: Unknown- `update(other_dict)`：将另一个字典的键值对更新到当前字典中。
other_dict = {"age": 31, "city": "New York"}
my_dict.update(other_dict)
print(my_dict) # 输出: {'name': 'Alice', 'country': 'USA', 'age': 31, 'city': 'New York'}### 字典推导式
字典推导式是一种简洁的创建字典的方式：
squares = {x: x**2 for x in range(5)}
print(squares) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}字典的特性：
-
键的唯一性：字典中的键是唯一的，重复的键会覆盖之前的值。
-
访问不存在的键：访问不存在的键会引发
KeyError，可以使用get方法避免。 -
键的限制：字典的键必须是不可变的类型，如数字、字符串、元组，不能是列表或其他可变类型。