变量

1、变量
变量的概念：
一个容器，计算机当中的存储空间，变量名只有在第一次出现的时候，
才是定义变量。当再次出现时，不是定义变量，而是直接使用之前定义的变量。

保存数据的格式:
变量名=变量值
注意事项:
首次使用变量会在内存中划分空间, 并初始化值
再次使用变量不再划分空间, 修改原空间中的值

2、标识符
变量的概念：
一个容器，计算机当中的存储空间，变量名只有在第一次出现的时候，
才是定义变量。当再次出现时，不是定义变量，而是直接使用之前定义的变量。

保存数据的格式:
变量名=变量值
注意事项:
首次使用变量会在内存中划分空间, 并初始化值
再次使用变量不再划分空间, 修改原空间中的值
命名规则：
下划线分割法: 变量名
多个单词组成的名称, 使用小写字母, 中间使用_分开。如：user_id, user_name, user_sex
大驼峰命名法:
多个单词组成的名称, 每个单词的首字母大写, 其余字母小写。如：UserId, UserName, UserSex
小驼峰命名法:
每一个单词小写字母开头，第二个单词首字母大写，如：userId，userName，userSex

3、数值类型

字符串类型

a = 10
b = 3.14
c = 2 + 3j
print(type(a)) # 输出 <class 'int'>
print(type(b)) # 输出 <class 'float'>
print(type(c)) # 输出 <class 'complex'>
print(a + b) # 输出 13.14
print(a * b) # 输出 31.400000000000002
print(c.real) # 输出 2.0，复数的实部
print(c.imag) # 输出 3.0，复数的虚部
print(abs(-10)) # 输出 10，绝对值
print(pow(2, 3)) # 输出 8，2 的 3 次方
print(divmod(10, 3)) # 输出 (3, 1)，商和余数
print(round(3.14159, 2)) # 输出 3.14，四舍五入保留两位小数
print(int(3.99)) # 输出 3，转换为整数
print(float(10)) # 输出 10.0，转换为浮点数
print(complex(2, 3)) # 输出 (2+3j)，创建复数
print(complex(5)) # 输出 (5+0j)，实数转换为复数
print(complex(0, 4)) # 输出 4j，纯虚数
print(isinstance(a, int)) # 输出 True，检查是否为整数
print(isinstance(b, float)) # 输出 True，检查是否为浮点数
print(isinstance(c, complex)) # 输出 True，检查是否为复数

4、字符串

字符串类型

str1 = "Hello, World!"
print(type(str1)) # 输出 <class 'str'>
print(len(str1)) # 输出 13，字符串长度
print(str1[0]) # 输出 'H'，访问字符串的第一个字符
print(str1[7:12]) # 输出 'World'，访问字符串的子串
print(str1.lower()) # 输出 'hello, world!'，转换为小写
print(str1.upper()) # 输出 'HELLO, WORLD!'，转换为大写
print(str1.replace("World", "Python")) # 输出 'Hello, Python!'，替换子串
print(str1.split(", ")) # 输出 ['Hello', 'World!']，分割字符串
print("Hello" in str1) # 输出 True，检查子串是否存在
print("Python" in str1) # 输出 False，检查子串是否存在
print(str1.startswith("Hello")) # 输出 True，检查是否以指定子串开头
print(str1.endswith("!")) # 输出 True，检查是否以指定子串结尾
print(str1.strip("!")) # 输出 'Hello, World'，去除指定字符
print(str1.find("World")) # 输出 7，查找子串的位置
print(str1.count("o")) # 输出 2，统计子串出现的次数
print("Formatted string: {}".format(str1)) # 使用 format 方法格式化字符串
print(f"Formatted string: {str1}") # 使用 f 字符串格式化

字符串运算符

• • in not in

下标/索引
Python中下标从0开始

Python可切片对象的索引方式包括:
正索引和负索引两部分，如下图所示，以list对象a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]为例：

语法：[起始:结束:步长]

5、列表类型

列表类型

list1 = [1, 2, 3, "a", "b", "c"]
print(type(list1)) # 输出 <class 'list'>
print(len(list1)) # 输出 6，列表长度
print(list1[0]) # 输出 1，访问列表的第一个元素
print(list1[3:6]) # 输出 ['a', 'b', 'c']，访问列表的子列表
print(list1 + [4, 5, 6]) # 输出 [1, 2, 3, 'a', 'b', 'c', 4, 5, 6]，列表拼接
print(list1 * 2) # 输出 [1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 'a', 'b', 'c']，列表重复
list1.append("d") # 在列表末尾添加元素
print(list1) # 输出 [1, 2, 3, 'a', 'b', 'c', 'd']
list1.insert(0, 0) # 在列表开头插入元素
print(list1) # 输出 [0, 1, 2, 3, 'a', 'b', 'c', 'd']
list1.remove("a") # 移除列表中的元素
print(list1) # 输出 [0, 1, 2, 3, 'b', 'c', 'd']
popped_element = list1.pop() # 移除并返回列表的最后一个元素
print(popped_element) # 输出 'd'
print(list1) # 输出 [0, 1, 2, 3, 'b', 'c']
list1.sort(key=str) # 对列表进行排序，按字符串顺序
print(list1) # 输出 [0, 1, 2, 3, 'b', 'c']
list1.reverse() # 反转列表中的元素顺序
print(list1) # 输出 ['c', 'b', 3, 2, 1, 0]
print(list1.index(2)) # 输出 3，表示元素 2 在列表中的索引位置
print(list1.count(2)) # 输出 1，表示元素 2 在列表中出现的次数
list1.clear() # 清空列表中的所有元素
print(list1) # 输出 []

6、元组类型

元组类型

tuple1 = (1, 2, 3, "a", "b", "c")
print(type(tuple1)) # 输出 <class 'tuple'>
print(len(tuple1)) # 输出 6，元组长度
print(tuple1[0]) # 输出 1，访问元组的第一个元素
print(tuple1[3:6]) # 输出 ('a', 'b', 'c')，访问元组的子元组
print(tuple1 + (4, 5, 6)) # 输出 (1, 2, 3, 'a', 'b', 'c', 4, 5, 6)，元组拼接
print(tuple1 * 2) # 输出 (1, 2, 3, 'a', 'b', 'c', 1, 2, 3, 'a', 'b', 'c')，元组重复
print(tuple1.index(2)) # 输出 1，表示元素 2 在元组中的索引位置
print(tuple1.count(2)) # 输出 1，表示元素 2 在元组中出现的次数

tuple1[0] = 0 # 尝试修改元组中的元素，会报错

print(tuple1) # 输出 (1, 2, 3, 'a', 'b', 'c')

empty_tuple = () # 创建一个空元组

print(type(empty_tuple)) # 输出 <class 'tuple'>
single_element_tuple = (1,) # 创建一个包含单个元素的元组
print(type(single_element_tuple)) # 输出 <class 'tuple'>
print(single_element_tuple) # 输出 (1,)
nested_tuple = (1, 2, (3, 4), [5, 6]) # 创建一个嵌套元组
print(type(nested_tuple)) # 输出 <class 'tuple'>
print(nested_tuple) # 输出 (1, 2, (3, 4), [5, 6])
print(nested_tuple[2]) # 输出 (3, 4)，访问嵌套元组
print(nested_tuple[3][0]) # 输出 5，访问嵌套列表中的元素

tuple1.clear() # 尝试清空元组，会报错

print(tuple1) # 输出 (1, 2, 3, 'a', 'b', 'c')

7、集合（set）类型

set 类型

set1 = {1, 2, 3, "a", "b", "c"}
print(type(set1)) # 输出 <class 'set'>
print(len(set1)) # 输出 6，集合长度
print(set1) # 输出 {1, 2, 3, 'a', 'b', 'c'}，集合内容（无序）
set1.add("d") # 在集合中添加元素
print(set1) # 输出 {1, 2, 3, 'a', 'b', 'c', 'd'}
set1.remove("a") # 移除集合中的元素
print(set1) # 输出 {1, 2, 3, 'b', 'c', 'd'}
set1.discard("e") # 移除集合中的元素，如果不存在不会报错
print(set1) # 输出 {1, 2, 3, 'b', 'c', 'd'}
popped_element = set1.pop() # 随机移除并返回一个元素
print(popped_element) # 输出被移除的元素
print(set1) # 输出集合内容（无序）
set1.clear() # 清空集合中的所有元素
print(set1) # 输出 set()
empty_set = set() # 创建一个空集合
print(type(empty_set)) # 输出 <class 'set'>
print(empty_set) # 输出 set()
set2 = {3, 4, 5, "c", "d", "e"}
set3 = {1, 2, 3, "a", "b", "c"}
set_union = set2 | set3 # 并集
print(set_union) # 输出 {1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e'}
set_intersection = set2 & set3 # 交集
print(set_intersection) # 输出 {3, 'c'}
set_difference = set3 - set2 # 差集
print(set_difference) # 输出 {1, 2, 'a', 'b'}
set_symmetric_difference = set2 ^ set3 # 对称差集
print(set_symmetric_difference) # 输出 {1, 2, 4, 5, 'a', 'b', 'd', 'e'}
print(set3 <= set2) # 子集 False
print(set3 >= set2) # 超集 False
print(set3 == set2) # 相等 False
print(set3 != set2) # 不相等 True
print(set3.isdisjoint(set2)) # 是否没有交集 False
set4 = frozenset([1, 2, 3, "a", "b", "c"]) # 创建一个不可变集合

print(type(set4)) # 输出 <class 'frozenset'>
print(set4) # 输出 frozenset({1, 2, 3, 'a', 'b', 'c'})

set4.add("d") # 尝试添加元素，会报错

print(set4) # 输出 frozenset({1, 2, 3, 'a', 'b', 'c'})

set4.remove("a") # 尝试移除元素，会报错

print(set4) # 输出 frozenset({1, 2, 3, 'a', 'b', 'c'})

print(2 in set3) # 输出 True，检查元素是否存在
print("d" in set3) # 输出 False，检查元素是否存在
print(2 not in set3) # 输出 False，检查元素是否不存在
print("d" not in set3) # 输出 True，检查元素是否不存在

8、字典类型

字典类型

dict1 = {"语文":125,"数学":99,"英语":88}
print(type(dict1)) # 输出 <class 'dict'>
print(len(dict1)) # 输出 3，字典长度
print(dict1) # 输出 {'语文': 125, '数学': 99, '英语': 88}，字典内容
print(dict1["数学"]) # 输出 99，访问字典中的值
dict1["物理"] = 95 # 添加新的键值对
print(dict1) # 输出 {'语文': 125, '数学': 99, '英语': 88, '物理': 95}
dict1["数学"] = 100 # 修改已有的键值对
print(dict1) # 输出 {'语文': 125, '数学': 100, '英语': 88, '物理': 95}
del dict1["英语"] # 删除键值对
print(dict1) # 输出 {'语文': 125, '数学': 100, '物理': 95}
print(dict1.get("数学")) # 输出 100，使用get方法访问值
print(dict1.get("化学", "不存在")) # 输出 '不存在'，使用get方法访问不存在的键，提供默认值
print(dict1.keys()) # 输出 dict_keys(['语文', '数学', '物理'])，获取所有的键
print(dict1.values()) # 输出 dict_values([125, 100, 95])，获取所有的值
print(dict1.items()) # 输出 dict_items([('语文', 125), ('数学', 100), ('物理', 95)])，获取所有的键值对
for key, value in dict1.items(): # 遍历字典
print(f"{key}: {value}")
print(len(dict1)) # 输出 3，获取字典的长度
dict1.clear() # 清空字典
print(dict1) # 输出 {}
dict2 = {} # 创建一个空字典
print(type(dict2)) # 输出 <class 'dict'>
print(dict2) # 输出 {}
dict3 = dict() # 创建一个空字典
print(type(dict3)) # 输出 <class 'dict'>
print(dict3) # 输出 {}
dict4 = {"语文":125,"数学":99,"英语":88} # 创建一个字典
print(type(dict4)) # 输出 <class 'dict'>
print(dict4) # 输出 {'语文': 125, '数学': 99, '英语': 88}
dict5 = dict(语文=125, 数学=99, 英语=88) # 使用dict函数创建字典
print(type(dict5)) # 输出 <class 'dict'>
print(dict5) # 输出 {'语文': 125, '数学': 99, '英语': 88}
dict6 = dict([("语文", 125), ("数学", 99), ("英语", 88)]) # 使用列表创建字典
print(type(dict6)) # 输出 <class 'dict'>
print(dict6) # 输出 {'语文': 125, '数学': 99, '英语': 88}
dict7 = dict(zip(["语文", "数学", "英语"], [125, 99, 88])) # 使用zip创建字典
print(type(dict7)) # 输出 <class 'dict'>
print(dict7) # 输出 {'语文': 125, '数学': 99, '英语': 88}
dict8 = dict.fromkeys(["语文", "数学", "英语"], 0) # 使用fromkeys创建字典
print(type(dict8)) # 输出 <class 'dict'>
print(dict8) # 输出 {'语文': 0, '数学': 0, '英语': 0}
dict9 = {"语文":125,"数学":99,"英语":88} # 创建一个字典
print(type(dict9)) # 输出 <class 'dict'>
print(dict9) # 输出 {'语文': 125, '数学': 99, '英语': 88}
dict9["物理"] = 95 # 添加新的键值对
print(dict9) # 输出 {'语文': 125, '数学': 99, '英语': 88, '物理': 95}
dict9.update({"化学": 90, "生物": 85}) # 使用update方法添加多个键值对
print(dict9) # 输出 {'语文': 125, '数学': 99, '英语': 88, '物理': 95, '化学': 90, '生物': 85}
dict9["数学"] = 100 # 修改已有的键值对
print(dict9) # 输出 {'语文': 125, '数学': 100, '英语': 88, '物理': 95, '化学': 90, '生物': 85}
dict9.update({"数学": 100, "英语": 90}) # 使用update方法修改多个键值对
print(dict9) # 输出 {'语文': 125, '数学': 100, '英语': 90, '物理': 95, '化学': 90, '生物': 85}
del dict9["英语"] # 删除键值对
print(dict9) # 输出 {'语文': 125, '数学': 100, '物理': 95, '化学': 90, '生物': 85}
dict9.pop("数学") # 使用pop方法删除键值对
print(dict9) # 输出 {'语文': 125, '物理': 95, '化学': 90, '生物': 85}
dict9.popitem() # 随机删除一个键值对
print(dict9) # 输出 {'语文': 125, '物理': 95, '化学': 90}
print(len(dict9)) # 输出 3，获取字典的长度
print(dict9["语文"]) # 输出 125，访问字典中的值
print(dict9.get("数学", "不存在")) # 输出 '不存在'，使用get方法访问不存在的键，提供默认值
print(dict9.keys()) # 输出 dict_keys(['语文', '物理', '化学'])，获取所有的键
print(dict9.values()) # 输出 dict_values([125, 95, 90])，获取所有的值
print(dict9.items()) # 输出 dict_items([('语文', 125), ('物理', 95), ('化学', 90)])，获取所有的键值对
for key, value in dict9.items(): # 遍历字典
print(f"{key}: {value}")
print(len(dict9)) # 输出 3，获取字典的长度
dict9.clear() # 清空字典
print(dict9) # 输出 {}
dict10 = {
"Alice": {"age": 20, "major": "Computer Science"},
"Bob": {"age": 22, "major": "Mathematics"},
"Charlie": {"age": 21, "major": "Physics"}
}
print(type(dict10)) # 输出 <class 'dict'>
print(dict10) # 输出嵌套字典内容
print(dict10["Alice"]["major"]) # 输出 'Computer Science'，访问嵌套字典中的值
dict10["David"] = {"age": 23, "major": "Chemistry"} # 添加新的嵌套字典
print(dict10) # 输出更新后的嵌套字典
dict10["Bob"]["age"] = 23 # 修改嵌套字典中的值
print(dict10) # 输出更新后的嵌套字典
del dict10["Charlie"] # 删除嵌套字典
print(dict10) # 输出更新后的嵌套字典
print(dict10.get("Eve", {"age": 0, "major": "Unknown"})) # 访问不存在的嵌套字典，提供默认值
print(len(dict10)) # 输出 3，获取嵌套字典的长度
print(dict10.keys()) # 输出 dict_keys(['Alice', 'Bob', 'David'])，获取嵌套字典的所有键
print(dict10.values()) # 输出嵌套字典的所有值
print(dict10.items()) # 输出嵌套字典的所有键值对
for name, info in dict10.items(): # 遍历嵌套字典
print(f"{name}: Age {info['age']}, Major {info['major']}")
more_students = {
"Eve": {"age": 20, "major": "Biology"},
"Frank": {"age": 22, "major": "History"}
}
dict10.update(more_students) # 合并两个嵌套字典
print(dict10) # 输出合并后的嵌套字典