① 注释
# 这是单行注释,单行注释的快捷键为ctrl+/
print(1)
# 这是多行注释，一般对类和方法进行注释，多行注释的快捷键为按住shift,然后连按三次引号
"""
print("1212")
print("hello,world")
"""
② 变量
"""
变量
"""
# 定义一个变量money
money = 50
print("余额还有：", money, "元")
money = money - 10
print("余额还有：", money, "元")
余额还有： 50 元
余额还有： 40 元
③ 查看数据类型
"""
查看数据类型
"""
# 查看数据的类型
str_type = type("haha");
print(str_type)
print("当前数据的类型为：", type("字符串"))
print("当前数据的类型为：", type(666))
print("当前数据的类型为：", type(111))
# 查看变量存储的数据的类型，在Python中，变量是没有类型的，但是变量存储的数据是有类型的
print("当前数据的类型为：", type(money))
当前数据的类型为：
当前数据的类型为：
当前数据的类型为：
当前数据的类型为：
④ 数据类型转换
"""
数据类型转换
int(x):将x转换为一个整数
float(x)：将x转换为一个浮点型数
str(x)：将x转为一个字符串
"""
int_str = str(11)
print(type(int_str), int_str)
float_str = str(13.14)
print(type(float_str), float_str)
str_int = str("11")
print(type(str_int), str_int)
11
13.14
11
⑤ 运算符
"""
算术运算符： + - * / //（取整） %（取余） **（指数）
赋值运算符：=，+=，-=，*=，/= //= %=
"""
print(11 // 2)
print(11 % 2)
num = 1
num += 1
print(num)
5
1
2
⑥ 字符串定义
"""
字符串定义
"""
# 单引号定义：
name_1 = 'zhangsan'
print(name_1)
# 双引号定义
name_2 = 'lisi'
print(name_2)
# 三引号定义：
name_3 = """wangwu"""
print(name_3)
# 字符串包含单
name_4 = "'zholiu'"
print(name_4)
name_5 = '"wangba"'
print(name_5)
zhangsan
lisi
wangwu
‘zholiu’
“wangba”
⑦ 字符串拼接
"""
字符串拼接
"""
name_6 = "我是"
print(name_6 + "hh")
我是hh
⑧ 字符串格式化
"""
字符串格式化：
%s: 字符串占位
%:占位
s:将变量变成字符串放入占位的地方
%d：整数占位
%f: 浮点数占位
"""
name_7 = "hh"
age = 18
time = 19.99
message = "我是%s，今年%d，时间%f" % (name_7, age, time)
print(message)
我是hh
我是hh，今年18，时间19.990000
"""
比较运算符：== ！= > < >= <=
"""
bool_1 = True
# 字符串前面加f代表字符串的格式化：{}里面填入变量
print(f"bool_1变量的内容为：{bool_1}，类型为：{type(bool_1)}")
bool_2 = False
print(f"bool_1变量的内容为：{bool_2}，类型为：{type(bool_2)}")
"""
if语句：缩进的是要执行的语句，类似于{}里面的
if 条件：
条件成立时，要做的事情
"""
age = 80
if age > 30:
print("我已经成年了")
print("非同级")
"""
if-else语句：
if 条件：
条件成立时，要做的事情
else:
条件不成立时，要做的事情
"""
age_1 = 50
if age_1 > 70:
print(f"我今年{age_1}岁了")
else:
print("我还没到70岁")
"""
if-elif-else语句：
if 条件1：
条件成立时，要做的事情
elif 条件2：
条件成立时，要做的事情
elif 条件3：
条件成立时，要做的事情
else:
所有条件都不成立时要做的事情
"""
age_2 = 50
if age_2 < 30:
print("年龄小于30")
elif age_2 < 40:
print("年龄小于40")
elif age_2 < 50:
print("年龄小于50")
else:
print("年龄大于50")
"""
判断语句的嵌套：
if 条件1：
满足条件1做的事情
if 条件2：
满足条件2做的事情
"""
age_4 = 50
if age_4 > 40:
print("年龄大于40")
if age_4 > 45:
print("年龄大于45")
else:
print("年龄小于45")
else:
print("年龄大于40")
bool_1变量的内容为：True，类型为：
bool_1变量的内容为：False，类型为：
我已经成年了
非同级
我还没到70岁
年龄大于50
年龄大于40
年龄大于45
"""
while语句
while 条件：
条件满足时，做的事情1
条件满足时，做的事情2
"""
i = 0
while i < 5:
print("小美，我喜欢你")
i += 1
"""
while语句
while 条件1：
满足条件1，要做的事情
while 条件2：
满足条件2，要做的事情
"""
j = 0
while j < 5:
print(f"今天是第{j}天")
k = 1
while k < 10:
print(f"送给小妹{k}朵玫瑰花")
k += 1
print("小美，我喜欢你")
j += 1
"""
for循环
for 临时变量 in 待处理的变量:
循环满足条件是执行的代码
"""
name = "zhangsan"
for x in name:
# 将name变量的值，挨个取出赋值给x
print(x)
"""
range语句
range(num):获取一个从0开始，到nun结束的数字序列（不包含num本身）
range(num1,num2,strp):获取一个从num1开始到num2结束的数字序列，不包含num2; step为数字之间的步长，默认为1
"""
range(10)
range(1, 7, 2)
for x in range(3):
print(x)
for x in range(1, 3):
print(x)
for x in range(1, 6, 2):
print(x)
"""
for 循环的嵌套应用
for 临时变量 in 待处理数据集：
循环条件满足要做的事情
for 临时变量 in 待处理的数据集：
循环条件满足要做的事情
"""
for i in range(1, 10):
print(f"今天是向小妹表白的第{i}天")
for j in range(1, 5):
print(f"给小妹送的第{j}朵玫瑰")
print("小妹，我喜欢你")
"""
continue关键字：中断本次循环，直接进入下一次循环
"""
for i in range(1, 10):
if i == 5:
continue
print(i)
for i in range(1, 5):
print("语句1")
continue
print("语句2")
for i in range(1, 6):
print("语句1")
for j in range(1, 6):
print("语句2")
continue
print("语句3")
print("语句4")
"""
break关键字：直接结束循环
"""
for i in range(1, 10):
print("语句1-------------")
break
print("语句2-------------")
for i in range(1, 6):
print("语句1------------")
for j in range(1, 6):
print("语句2-----------")
break
print("语句3-----------")
print("语句4------------")
str_1 = "zhangsan"
str_2 = "lisi"
str_3 = "wangwu"
"""
函数的基本定义语法：
def 函数名(传入参数)：
函数体
return 返回值
"""
# 定义函数
def my_len(data):
count = 0
for i in data:
count = count + 1
print(f"{data} 字符串的长度为：{count}")
# 调用函数
my_len(str_1)
my_len(str_2)
my_len(str_3)
# 定义函数
def say_hi():
print("我是一个程序员")
# 调用函数
say_hi()
# 定义函数
def check():
print("请出示健康码")
# 调用函数
check()
"""
定义函数并传入参数
"""
# 定义函数并传入参数
def add(num1, num2):
result = num1 + num2
print(f"{num1}+{num2}的值为：{result}")
# 调用函数
add(1, 2)
# 定义函数并传入参数
def check(num):
print(f"你的体温为：{num} 度")
# 调用函数
check(37)
"""
函数的返回值
def 函数(参数...):
函数体
return 返回值
变量 = 函数(参数)
"""
# 定义函数并传入参数
def sub(num1, num2):
res = num1 - num2
print(f"{num1}-{num2}的值为：{res}")
return res
# 调用函数
result = sub(2, 1)
print(result)
"""
函数如果没有使用return语句，则返回None
"""
# 定义函数
def say_hi():
print("say hi")
# 调用函数
result = say_hi()
print(f"函数返回值的类型为：{type(result)}")
# 定义函数
def say_hi_1():
print("say hi")
return None
# 调用函数
result = say_hi_1()
print(f"函数返回值的类型为：{type(result)}")
# 定义函数
def check(age):
if (age > 10):
return age
else:
return None
# 调用函数
result = check(9)
if not result:
# result为None值，也就是False
print("未成年不可以进入")
"""
函数文档说明
"""
# 定义函数
def add(x, y, z):
"""
add函数接收3个参数，实现3个数相加的功能
:param x: 一个数字
:param y: 一个数字
:param z: 一个数字
:return: 结果
"""
return x + y + z
# 调用函数
add(1, 2, 3)
"""
函数的嵌套作用
"""
# 定义函数
def func_a():
print("----------1---------")
def func_b():
func_a()
print("---------2----------")
def func_c():
func_a()
func_b()
print("---------3-----------")
# 调用函数
func_c()
"""
变量在函数中的作用域
"""
# 定义函数
def test_a():
# 局部变量，作用域在方法体内
num = 100
print(num)
# 调用函数
test_a()
# 定义函数
num = 200
def test_b():
# 函数内部的修改只在函数内部生效，因为变成局部变量了
num = 300
print(num)
# 调用函数
test_b()
# 结果仍然是200
print(num)
# 定义函数
age = 10
def test_c():
# global关键字将局部变量age声明为全局变量
global age
age = 20
print(age)
# 调用函数
test_c()
# 结果是20
print(age)
"""
一个容器可以容纳多份数据的数据类型，容纳的每一份数据称为一个元素
可以是任意类型的数据：字符串，数字，布尔
列表、元祖、字符串、集合、字典
"""
"""
定义列表：变量名称 = [元素1，元素2，元素3，........]
"""
list_1 = ["zhangsan", "lisi", "wangwu"]
print(f"list_1的元素为：{list_1}")
print(f"list_1的类型为：{type(list_1)}")
list_1 = ["ab", 11, True]
print(f"list_1的元素为：{list_1}")
print(f"list_1的类型为：{type(list_1)}")
list_2 = [list_1, True, 11]
print(f"list_2的元素为：{list_2}")
print(f"list_2的类型为：{type(list_2)}")
"""
列表的下标索引：列表[下标索引]
"""
# 第1个元素
print(list_1[0])
# 第2个元素
print(list_1[1])
# 倒数第1个元素
print(list_1[-1])
# 倒数第2个元素
print(list_1[-2])
# 取出嵌套列表的元素：第1个元素里面的第2个元素
print(list_2[0][1])
"""
# 如果将函数定义为class的成员，那么函数称之为方法
class Student:
def add(self, x, y):
return x + y
# 方法和传入参数一样，有传入参数，有返回值，只是方法的使用格式不同
函数的使用：num = add(1,2)
方法的使用：student=Student()
num = student.add(1,2)
"""
# 查找某元素的下标：列表.index(元素),如果不存在，程序报错
list_1 = ['grape', 'apple', 'banana', 'orange', 'pear']
print(f"list_1的元素为：{list_1}")
value_1 = list_1.index('grape')
print(f"value_1的值为:{value_1}")
# 修改特定索引的元素值：列表[index] = 值
list_1 = ['grape', 'apple', 'banana', 'orange', 'pear']
print(f"list_1的元素为：{list_1}")
# 修改第二个元素
list_1[1] = 'mango'
print(f"list_1的元素为：{list_1}")
"""
在列表中添加元素：
append(value) —— 在列表末尾添加元素。
insert(index,value) —— 在列表指定的位置添加元素。
"""
list_1 = ['grape', 'apple', 'banana', 'orange', 'pear']
print(f"list_1的元素为：{list_1}")
list_1.append('mango')
print(f"list_1的元素为：{list_1}")
list_1.insert(2, 'watermelon')
print(f"list_1的元素为：{list_1}")
"""
从列表中删除元素:
del 列表[index] —— 从列表中删除一个元素，且不再使用。 如果要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；
pop(index) —— 从列表中删除一个元素，后续还会再使用。 如果要在删除元素后还能继续使用它，就使用方法pop()；
remove(‘element name’) —— 不知道要从列表中删除的值所处的位置，但知道要删除元素的值。如果只知道要删除的元素的值，就使用方法remove()，方法remove()只删除第一个指定的值，如果要删除的值可能在列表中出现多次，就需要使用循环来判断是否删除了所有这样的值
"""
list_ = ['grape', 'apple', 'watermelon', 'banana', 'orange', 'apple', 'pear', 'mango']
print(f"list_1的元素为：{list_1}")
# 删除列表的第三个元素
del list_1[2]
print(f"list_1的元素为：{list_1}")
# 删除列表的最后一个元素
value_1 = list_1.pop(-1)
print(f"value_1的值为:{value_1}")
list_1_remove = 'apple'
# 删除列表中名为fruit_remove的第一个元素
value_1 = list_1.remove(list_1_remove)
print(f"list_1的元素为：{list_1}")
print(f"value_1的值为:{value_1}")
# 获取列表中元素的个数
print(len(list_1))
# 获取列表中某个元素的数量
print(list_1.count('apple'))
"""
while循环
"""
# 定义函数
def list_while(list_data):
"""
列表的遍历--while循环
:param list_data: 列表
:return: None
"""
index = 0
while index < len(list_data):
data = list_data[index]
print(data)
index = index + 1
# 使用函数
list_3 = ["张三", "李四", "王五"]
list_while(list_3)
# 定义函数
def list_for(list_data):
for data in list_data:
print(data)
# 使用函数
list_for(list_3)
list_1的元素为：[‘zhangsan’, ‘lisi’, ‘wangwu’]
list_1的类型为：
list_1的元素为：[‘ab’, 11, True]
list_1的类型为：
list_2的元素为：[[‘ab’, 11, True], True, 11]
list_2的类型为：
ab
11
True
11
11
list_1的元素为：[‘grape’, ‘apple’, ‘banana’, ‘orange’, ‘pear’]
value_1的值为:0
list_1的元素为：[‘grape’, ‘apple’, ‘banana’, ‘orange’, ‘pear’]
list_1的元素为：[‘grape’, ‘mango’, ‘banana’, ‘orange’, ‘pear’]
list_1的元素为：[‘grape’, ‘apple’, ‘banana’, ‘orange’, ‘pear’]
list_1的元素为：[‘grape’, ‘apple’, ‘banana’, ‘orange’, ‘pear’, ‘mango’]
list_1的元素为：[‘grape’, ‘apple’, ‘watermelon’, ‘banana’, ‘orange’, ‘pear’, ‘mango’]
list_1的元素为：[‘grape’, ‘apple’, ‘watermelon’, ‘banana’, ‘orange’, ‘pear’, ‘mango’]
list_1的元素为：[‘grape’, ‘apple’, ‘banana’, ‘orange’, ‘pear’, ‘mango’]
value_1的值为:mango
list_1的元素为：[‘grape’, ‘banana’, ‘orange’, ‘pear’]
value_1的值为:None
4
0
张三
李四
王五
张三
李四
王五
"""
元祖和列表一样，都可存储多个元素，且数据类型不同，但是和列表不同的是，元祖中的数据是只读的，不可以被修改
元素使用（）来定义，使用逗号隔开元素
"""
# 定义元祖
t1 = (1, "zhangsan", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t1的类型是：{type(t2)}, 内容是：{t2}")
print(f"t1的类型是：{type(t3)}, 内容是：{t3}")
# 元組的嵌套
t4 = ((1, 2, 3), (4, 5, 6))
print(f"t4的类型为{type(t4)},内容为{t4}")
# 查找
num = t4[1][2]
print(f"从元组中取出6：{num}")
# 统计某个元素在元祖中出现的次数
t1 = (1, "zhangsan", True)
t4 = ((1, 2, 3), (4, 5, 6))
count = t4.count((1, 2, 3))
count_1 = t1.count("zhangsan")
print(f"(1, 2, 3)在元祖t4中出现的次数：{count}")
print(f"zhangsan在元祖t1中出现的次数：{count_1}")
# 統計元祖内元素的个数
t1 = (1, "zhangsan", True)
t4 = ((1, 2, 3), (4, 5, 6))
len_1 = len(t1)
len_2 = len(t4)
print(f"t1的元素个数：{len_1}")
print(f"t2的元素个数：{len_2}")
# while - 元組的遍历
def get_while():
t5 = ["a", "b", "c", "d", "e"]
index = 0
while index < len(t5):
print(t5[index])
index = index + 1
get_while()
# for - 元組的遍历
def get_for():
t5 = ["a", "b", "c", "d", "e"]
for element in t5:
print(element)
get_for()
t1的类型是：
, 内容是：(1, ‘zhangsan’, True)
t1的类型是：, 内容是：()
t1的类型是：, 内容是：()
t4的类型为,内容为((1, 2, 3), (4, 5, 6))
从元组中取出6：6
(1, 2, 3)在元祖t4中出现的次数：1
zhangsan在元祖t1中出现的次数：1
t1的元素个数：3
t2的元素个数：2
a
b
c
d
e
a
b
c
d
e
str_1 = "my name is chahua"
# 通过下标索引取值
value_1 = str_1[0]
value_2 = str_1[1]
print(f"下标为0的元素：{value_1}")
print(f"下标为1的元素：{value_2}")
# index方法：在字符串中查找字符串1的起始下标
value_3 = str_1.index("is")
print(f"在字符串中查找is,其起始下标为：{value_3}")
# replace方法：字符串.replace(字符串1，字符串2)
value_4 = str_1.replace("chahua","nini")
print(f"將字符串chahua替换为字符串nini，得到的新字符串为{value_4},旧字符串为：{str_1}")
# split方法: 字符串.split(分隔字符串)
# 按照指定的分隔字符串，将字符串分为多个字符串，并存入列表对象中
value_5 = str_1.split(" ")
print(f"將字符串按照空格切分：{value_5}")
# 统计字符串中某个字符串出现的次数
value_6 = str_1.count("chahua")
print(f"字符串chahua在字符串str_1中出現的次數：{value_6}")
# 统计字符串的长度
value_7 = len(str_1)
print(f"字符串的长度：{value_7}")
下标为0的元素：m
下标为1的元素：y
在字符串中查找is,其起始下标为：8
將字符串chahua替换为字符串nini，得到的新字符串为my name is nini,旧字符串为：my name is chahua
將字符串按照空格切分：[‘my’, ‘name’, ‘is’, ‘chahua’]
字符串chahua在字符串str_1中出現的次數：1
字符串的长度：17
"""
序列：内容连续，有序，可使用下标索引的一类数据容器 ，列表，元祖，字符串，均可以视为序列，序列支持切片，即列表，元祖，字符串均支持切片
切片：从一个序列中取出一个子序列
语法：序列[其实下标：结束下标：步长]，表示从序列中，从指定位置开始到指定位置结束，得到一个新的序列
起始下标：从哪里开始，如果为空表示从头开始
结束下标：到哪里结束，如果为空标识到末尾结束
步长：依次取元素的间隔，默認為1，可以省略不寫
"""
# 对list进行切片，从1开始，到4结束（不包含4），步长为1
list_1 = [0, 1, 2, 3, 4, 5, 6, 7]
value_1 = list_1[1:4:1]
value_2 = list_1[1:4]
print(f"value_1:{value_1}")
print(f"value_2:{value_2}")
# 对tuple进行切片，从头开始，到最后结束，步长为1
tuple_1 = (0, 1, 2, 3, 4, 5, 6, 7)
value_3 = tuple_1[0:8:1]
value_4 = tuple_1[:]
print(f"value_3:{value_3}")
print(f"value_4:{value_4}")
# 对str进行切片，从头开始到最后结束，步长为2
str_1 = ["a", "b", "c", "d", "e"]
value_5 = str_1[0:5:2]
value_6 = str_1[::2]
print(f"value_5:{value_5}")
print(f"value_6:{value_6}")
# 对str进行切片，从头开始到最后结束，步长为-1
str_2 = ["a", "b", "c", "d", "e"]
value_7 = str_2[::-1]
print(f"value_8:{value_7}")
# 对list进行切片，从3开始，到1结束（不包含1），步长为-1
list_2 = [0, 1, 2, 3, 4, 5, 6, 7]
value_8 = list_1[3:1:-1]
print(f"value_8:{value_8}")
value_1:[1, 2, 3]
value_2:[1, 2, 3]
value_3:(0, 1, 2, 3, 4, 5, 6, 7)
value_4:(0, 1, 2, 3, 4, 5, 6, 7)
value_5:[‘a’, ‘c’, ‘e’]
value_6:[‘a’, ‘c’, ‘e’]
value_8:[‘e’, ‘d’, ‘c’, ‘b’, ‘a’]
value_8:[3, 2]
"""
列表：支持重复元素且有序
元祖：支持重复元素且有序
字符串：支持重复元素且有序
集合：不支持重复元素且无序，集合是无序的，因此不支持下标索引访问
集合定义语法：{元素1，元素2，元素3}
定义空集合：set_1 = set()
"""
# 定义集合
set_1 = {"a", "b", "c", "d", "e", "f", "g"}
set_2 = set()
print(f"set_1集合元素为：{set_1}")
print(f"set_2集合元素为：{set_2}")
# 添加新元素
set_1.add("h")
print(f"set_1集合元素为：{set_1}")
set_1.add("g")
print(f"set_1集合元素为：{set_1}")
# 移除元素
set_1.remove("h")
print(f"set_1集合元素为：{set_1}")
# 随机取出元素
value_1 = set_1.pop()
print(f"value_1元素为：{value_1}")
# 清空集合
set_1.clear()
print(f"set_1集合元素为：{set_1}")
# 取两个集合的差集
set_1 = {1, 2, 3}
set_2 = {1, 5, 6}
value_2 = set_1.difference(set_2)
print(f"value_2的元素为：{value_2}")
print(f"set_1集合元素为：{set_1}")
print(f"set_2集合元素为：{set_2}")
# 删除两个集合的差集
set_1 = {1, 2, 3}
set_2 = {1, 5, 6}
set_1.difference_update(set_2)
print(f"set_1集合元素为：{set_1}")
print(f"set_2集合元素为：{set_2}")
# 取两个集合的并集
set_1 = {1, 2, 3}
set_2 = {1, 5, 6}
value_3 = set_1.union(set_2)
print(f"value_3的元素为：{value_3}")
print(f"set_1集合元素为：{set_1}")
print(f"set_2集合元素为：{set_2}")
# 统计集合元素数量
value_4 = len(set_1)
print(f"value_4的元素为：{value_4}")
# 集合的遍历，不支持下标索引，不可以使用while循环遍历
set_1 = {1, 2, 3}
def set_for():
for ele in set_1:
print(ele)
set_for()
set_1集合元素为：{‘f’, ‘d’, ‘e’, ‘g’, ‘b’, ‘a’, ‘c’}
set_2集合元素为：set()
set_1集合元素为：{‘f’, ‘d’, ‘e’, ‘g’, ‘b’, ‘h’, ‘a’, ‘c’}
set_1集合元素为：{‘f’, ‘d’, ‘e’, ‘g’, ‘b’, ‘h’, ‘a’, ‘c’}
set_1集合元素为：{‘f’, ‘d’, ‘e’, ‘g’, ‘b’, ‘a’, ‘c’}
value_1元素为：f
set_1集合元素为：set()
value_2的元素为：{2, 3}
set_1集合元素为：{1, 2, 3}
set_2集合元素为：{1, 5, 6}
set_1集合元素为：{2, 3}
set_2集合元素为：{1, 5, 6}
value_3的元素为：{1, 2, 3, 5, 6}
set_1集合元素为：{1, 2, 3}
set_2集合元素为：{1, 5, 6}
value_4的元素为：3
1
2
3
"""
字典定义：同样使用{}，不过存储的元素时一个个的键值对
字典语法：{key:value，key:value，key:value}
"""
# 定义字典
map_1 = {"name": "nini", "age": 13}
map_2 = dict()
map_3 = {}
print(f"map_1的元素为：{map_1}")
print(f"map_2的元素为：{map_2}")
print(f"map_3的元素为：{map_3}")
# 定义key重复的字典
map_1 = {"name": "nini", "name": "chahua", "age": 13}
print(f"map_1的元素为：{map_1}")
# 通过key获取value
map_1 = {"name": "nini", "age": 13}
value_1 = map_1["name"]
value_2 = map_1["age"]
print(f"value_1的值为：{value_1}")
print(f"value_2的值为：{value_2}")
# 字典的嵌套；字典的key和value可以是任意数据类型，但是key不可以为字典
map_1 = {
"张三": {
"语文": 99,
"数学": 90,
"英语": 89
},
"李四": {
"语文": 90,
"数学": 66,
"英语": 78
},
"王五": {
"语文": 100,
"数学": 90,
"英语": 57
}
}
print(f"map_1的元素为：{map_1}")
value_1 = map_1["张三"]
value_2 = value_1["语文"]
value_3 = map_1["李四"]["英语"]
print(f"value_1的值为：{value_1}")
print(f"value_2的值为：{value_2}")
print(f"value_3的值为：{value_3}")
# 添加元素:key不存在是添加，key存在是更新
map_1 = {"a": 99, "b": 90, "c": 80}
print(f"map_1的元素为：{map_1}")
map_1["d"] = 78
print(f"map_1的元素为：{map_1}")
map_1["a"] = 60
print(f"map_1的元素为：{map_1}")
# 删除元素
map_1 = {"a": 99, "b": 90, "c": 80, "d": 78}
map_1.pop("d")
print(f"map_1的元素为：{map_1}")
# 清空元素
map_1 = {"a": 99, "b": 90, "c": 80}
map_1.clear()
print(f"map_1的元素为：{map_1}")
# 获取字典中全部的key
map_1 = {"a": 99, "b": 90, "c": 80}
value_1 = map_1.keys()
print(f"value_1的值为：{value_1}")
# 遍历字典
for key in value_1:
print(map_1[key])
for key in map_1:
print(map_1[key])
# 统计字典内元素的个数
value_1 = len(map_1)
print(f"value_1的值为：{value_1}")
map_1的元素为：{‘name’: ‘nini’, ‘age’: 13}
map_2的元素为：{}
map_3的元素为：{}
map_1的元素为：{‘name’: ‘chahua’, ‘age’: 13}
value_1的值为：nini
value_2的值为：13
map_1的元素为：{‘张三’: {‘语文’: 99, ‘数学’: 90, ‘英语’: 89}, ‘李四’: {‘语文’: 90, ‘数学’: 66, ‘英语’: 78}, ‘王五’: {‘语文’: 100, ‘数学’: 90, ‘英语’: 57}}
value_1的值为：{‘语文’: 99, ‘数学’: 90, ‘英语’: 89}
value_2的值为：99
value_3的值为：78
map_1的元素为：{‘a’: 99, ‘b’: 90, ‘c’: 80}
map_1的元素为：{‘a’: 99, ‘b’: 90, ‘c’: 80, ‘d’: 78}
map_1的元素为：{‘a’: 60, ‘b’: 90, ‘c’: 80, ‘d’: 78}
map_1的元素为：{‘a’: 99, ‘b’: 90, ‘c’: 80}
map_1的元素为：{}
value_1的值为：dict_keys([‘a’, ‘b’, ‘c’])
99
90
80
99
90
80
value_1的值为：3
str_1 = "abc"
list_1 = ["a", "b", "c"]
tuple_1 = (1, 2, 3)
set_1 = {1, 2, 3, 4}
map_1 = {"name": "nini", "age": 19}
print("----------------------len------------------------")
# len元素个数统计
print(len(str_1))
print(len(list_1))
print(len(tuple_1))
print(len(set_1))
print(len(map_1))
print("----------------------max------------------------")
# max最大元素
print(max(str_1))
print(max(list_1))
print(max(tuple_1))
print(max(set_1))
print(max(map_1))
print("----------------------min------------------------")
# max最大元素
print(min(str_1))
print(min(list_1))
print(min(tuple_1))
print(min(set_1))
print(min(map_1))
print("----------------------容器转列表------------------------")
# 容器转列表
print(list(str_1))
print(list(list_1))
print(list(tuple_1))
print(list(set_1))
print(list(map_1))
print("----------------------容器转元祖------------------------")
# 容器转元祖
print(tuple(str_1))
print(tuple(list_1))
print(tuple(tuple_1))
print(tuple(set_1))
print(tuple(map_1))
print("----------------------容器转字符串------------------------")
# 容器转字符串
print(str(str_1))
print(str(list_1))
print(str(tuple_1))
print(str(set_1))
print(str(map_1))
print("----------------------容器转集合-----------------------")
# 容器转集合
print(set(str_1))
print(set(list_1))
print(set(tuple_1))
print(set(set_1))
print(set(map_1))
print("----------------------容器排序-----------------------")
# 容器排序,排序后会变成列表
print(sorted(str_1))
print(sorted(list_1))
print(sorted(tuple_1))
print(sorted(set_1))
print(sorted(map_1))
# 容器逆序排序,排序后会变成列表
print(sorted(str_1, reverse=True))
print(sorted(list_1, reverse=True))
print(sorted(tuple_1, reverse=True))
print(sorted(set_1, reverse=True))
print(sorted(map_1, reverse=True))
----------------------len------------------------
3
3
3
4
2
----------------------max------------------------
c
c
3
4
name
----------------------min------------------------
a
a
1
1
age
----------------------容器转列表------------------------
[‘a’, ‘b’, ‘c’]
[‘a’, ‘b’, ‘c’]
[1, 2, 3]
[1, 2, 3, 4]
[‘name’, ‘age’]
----------------------容器转元祖------------------------
(‘a’, ‘b’, ‘c’)
(‘a’, ‘b’, ‘c’)
(1, 2, 3)
(1, 2, 3, 4)
(‘name’, ‘age’)
----------------------容器转字符串------------------------
abc
[‘a’, ‘b’, ‘c’]
(1, 2, 3)
{1, 2, 3, 4}
{‘name’: ‘nini’, ‘age’: 19}
----------------------容器转集合-----------------------
{‘c’, ‘b’, ‘a’}
{‘c’, ‘b’, ‘a’}
{1, 2, 3}
{1, 2, 3, 4}
{‘age’, ‘name’}
----------------------容器排序-----------------------
[‘a’, ‘b’, ‘c’]
[‘a’, ‘b’, ‘c’]
[1, 2, 3]
[1, 2, 3, 4]
[‘age’, ‘name’]