目录
一、运算符介绍
1.1 算术运算符
1.2 比较运算符
1.3 赋值运算符
1.4 位运算符
1.5 逻辑运算符
1.6 成员运算符
1.7 身份运算符
二、python运算符优先级
三、三大流程结构
四、列表
五、元组
六、字典
一、运算符介绍
1.1 算术运算符
1.2 比较运算符
1.3 赋值运算符
1.4 位运算符
下表中变量 a 为 60,b 为 13,二进制格式如下:
a = 0011 1100b = 0000 1101-----------------a&b = 0000 1100a|b = 0011 1101a^b = 0011 0001~a = 1100 0011
1.5 逻辑运算符
1.6 成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
1.7 身份运算符
身份运算符用于比较两个对象的存储单元
二、python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
三、三大流程结构
在Python编程中,三大流程结构是控制程序执行流程的基本方式。它们分别是:
1. **顺序结构**:
- 顺序结构是程序中最基本的执行流程,按照代码书写的顺序依次执行。
- 例如:
x = 10y = 20z = x + yprint(z) # 输出 30
2. **选择结构(条件结构)**:
- 选择结构用于根据条件判断来决定执行哪一段代码。
- 主要通过 `if`、`elif` 和 `else` 语句实现。
- 例如:
age = 18if age >= 18:print("成年人")else:print("未成年人")
if语句运行过程如下动图:
3. **循环结构**:
- 循环结构用于重复执行某段代码,直到满足某个条件为止。
- 主要通过 `while` 和 `for` 语句实现。
- 例如:
# while 循环count = 0while 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:breakprint(i) # 输出 0 到 4
2). **`continue` 语句**:
- `continue` 语句用于跳过当前循环的剩余语句,并继续下一次循环。
- 常用于在满足某个条件时跳过当前迭代。
- 例如:
for i in range(10):if i % 2 == 0:continueprint(i) # 输出 1, 3, 5, 7, 9
3). **`pass` 语句**:
- `pass` 语句是一个空操作语句,用于在语法上需要语句但实际不需要执行任何代码的地方。
- 常用于占位,表示稍后会添加代码。
- 例如:
for i in range(10):if i % 2 == 0:passelse:print(i) # 输出 1, 3, 5, 7, 9
4). **`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) # 输出: 3print(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 = 30city = "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) # 输出: Alicevalue = 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
方法避免。 -
键的限制:字典的键必须是不可变的类型,如数字、字符串、元组,不能是列表或其他可变类型。