目录
第五章 函数
定义
三要素
（1）是组织好的
（2）可重复使用的
（3）实现特定功能的代码段
定义格式
def 函数名(传入参数)：
函数体
return 返回值注意：
（1）参数不需要，可以省略
（2）返回值不需要，可以省略
函数的注释说明
def add(x, y):
"""
add函数可以接收2个参数，进行2数相加的功能
:param x:形参x表示相加的其中一个数字
:param y:形参y表示相加的另一个数字
:return:返回值是2数相加的结果
"""
result = x + y
print(f"{x} + {y} 的和为{result}")
return result
add(2, 3)
函数的嵌套调用
def func_b():
print("---2---")
def func_a():
print("---1---")
func_b()
print("---3---")
func_a()
---1---
---2---
---3---
相关函数
长度函数
内置的
name = "itheima"
length = len(name)
print("%s的长度是%d" % (name, length))
自己定义
def my_length(data):
count = 0
for i in data:
count += 1
print("%s的长度是%d" % (data, count))
str1 = "itheima"
my_length(str1)itheima的长度是7两数之和函数
def add(x, y):
result = x + y
print(f"{x} + {y}的和为{result}")
return None
add(3, 4)3 + 4的和为7
案例：自动查核酸
def check_temperature(num):
print("欢迎来到黑马程序员!请出示您的健康码以及72小时核酸证明，并配合测量体温!")
if num <= 37.5:
print(f"体温测量中，您的体温是:{num}度，体温正常请进!")
else:
print(f"体温测量中，您的体温是:{num}度，需要隔离!")
check_temperature(37.3)None函数
定义
None是类型'Nonetype'的字面量，用于表示：空的、无意义的
用法
（1）函数返回值
（2）if判断
（3）变量定义
案例：能不能进网吧
def check_age(x):
if x >= 18:
return "SUCCESS"
else:
return None
result = check_age(16)
if not result:
print("未成年，不可进入")未成年，不可进入综合案例：黑马ATM
# 全局变量
money = 5000000
name = None
# 输入姓名
name = input("请输入您的姓名：")
# 定义函数
def balance(condition):
"""
查询余额函数
"""
if condition:
print("-------------------查询余额-------------------")
print(f"{name}，您好，你的余额剩余：{money}元")
def store(store_money):
"""
存款函数
"""
global money
print("-------------------存款-------------------")
print(f"{name}，您好，你存款{store_money}元成功")
money += store_money
balance(False)
def take_out(take_out_money):
"""
取款函数
"""
global money
print("-------------------取款-------------------")
print(f"{name}，您好，你取款{take_out_money}元成功")
money -= take_out_money
balance(False)
def main_menu():
print("-------------------主菜单-------------------")
print(f"{name}，您好，欢迎来到黑马银行ATM，请选择操作：")
print("查询余额\t【输入1】")
print("存款\t【输入2】")
print("取款\t【输入3】")
print("退出\t【输入4】")
return input()
while True:
keyboard_input = int(main_menu())
if keyboard_input == 1:
balance(True)
continue
elif keyboard_input == 2:
num = int(input("您想要存入多少钱？"))
store(num)
continue
elif(keyboard_input == 3):
num = int(input("您想要取出多少钱？"))
take_out(num)
continue
else:
print("程序已退出")
break
D:\softWare\pythonLearning\pythonProject\.venv\Scripts\python.exe D:\softWare\pythonLearning\pythonProject\test.py
请输入您的姓名：彭于晏
-------------------主菜单-------------------
彭于晏，您好，欢迎来到黑马银行ATM，请选择操作：
查询余额 【输入1】
存款 【输入2】
取款 【输入3】
退出 【输入4】
1
-------------------查询余额-------------------
彭于晏，您好，你的余额剩余：5000000元
-------------------主菜单-------------------
彭于晏，您好，欢迎来到黑马银行ATM，请选择操作：
查询余额 【输入1】
存款 【输入2】
取款 【输入3】
退出 【输入4】
2
您想要存入多少钱？500
-------------------存款-------------------
彭于晏，您好，你存款500元成功
彭于晏，您好，你的余额剩余：5000500元
-------------------主菜单-------------------
彭于晏，您好，欢迎来到黑马银行ATM，请选择操作：
查询余额 【输入1】
存款 【输入2】
取款 【输入3】
退出 【输入4】
3
您想要取出多少钱？500
-------------------取款-------------------
彭于晏，您好，你取款500元成功
彭于晏，您好，你的余额剩余：5000000元
-------------------主菜单-------------------
彭于晏，您好，欢迎来到黑马银行ATM，请选择操作：
查询余额 【输入1】
存款 【输入2】
取款 【输入3】
退出 【输入4】
4
程序已退出
进程已结束，退出代码为 0
第六章 数据容器
五大数据容器
定义
一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。
类型：
1.列表（list） 2.元组（tuple ） （3）字符串（str） 4.集合（set） 5.字典（dict）
分类
特点
通用操作
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
# max最大元素
print(f"列表最大的元素是：{max(my_list)}")
print(f"元组最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合最大的元素是：{max(my_set)}")
print(f"字典最大的元素是：{max(my_dict)}")
print()
# min最大元素
print(f"列表最小的元素是：{min(my_list)}")
print(f"元组最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合最小的元素是：{min(my_set)}")
print(f"字典最小的元素是：{min(my_dict)}")
print()
# 容器转字符串
print(f"列表转字符串后的结果是：{str(my_list)}")
print(f"元组转字符串后的结果是：{str(my_tuple)}")
print(f"字符串转字符串后的结果是：{str(my_str)}")
print(f"集合转字符串后的结果是：{str(my_set)}")
print(f"字典转字符串后的结果是：{str(my_dict)}")
列表最大的元素是：5
元组最大的元素是：5
字符串最大的元素是：g
集合最大的元素是：5
字典最大的元素是：key5
列表最小的元素是：1
元组最小的元素是：1
字符串最小的元素是：a
集合最小的元素是：1
字典最小的元素是：key1
列表转字符串后的结果是：[1, 2, 3, 4, 5]
元组转字符串后的结果是：(1, 2, 3, 4, 5)
字符串转字符串后的结果是：abcdefg
集合转字符串后的结果是：{1, 2, 3, 4, 5}
字典转字符串后的结果是：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}# 进行容器的排序
my_list = [3, 2, 1, 5, 4]
my_tuple = (3, 2, 1, 5, 4)
my_str = "deabfcg"
my_set = {3, 2, 1, 5, 4}
my_dict = {"key3":3, "key1":1, "key4":4, "key2":2, "key5":5}
# 升序
print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")
print()
my_list = [3, 2, 1, 5, 4]
my_tuple = (3, 2, 1, 5, 4)
my_str = "deabfcg"
my_set = {3, 2, 1, 5, 4}
my_dict = {"key3":3, "key1":1, "key4":4, "key2":2, "key5":5}
# 降序
print(f"列表对象的排序结果：{sorted(my_list, reverse = True)}")
print(f"元组对象的排序结果：{sorted(my_tuple, reverse = True)}")
print(f"字符串对象的排序结果：{sorted(my_str, reverse = True)}")
print(f"集合对象的排序结果：{sorted(my_set, reverse = True)}")
print(f"字典对象的排序结果：{sorted(my_dict, reverse = True)}")列表对象的排序结果：[1, 2, 3, 4, 5]
元组对象的排序结果：[1, 2, 3, 4, 5]
字符串对象的排序结果：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合对象的排序结果：[1, 2, 3, 4, 5]
字典对象的排序结果：['key1', 'key2', 'key3', 'key4', 'key5']
列表对象的排序结果：[5, 4, 3, 2, 1]
元组对象的排序结果：[5, 4, 3, 2, 1]
字符串对象的排序结果：['g', 'f', 'e', 'd', 'c', 'b', 'a']
集合对象的排序结果：[5, 4, 3, 2, 1]
字典对象的排序结果：['key5', 'key4', 'key3', 'key2', 'key1']注：
列表
定义
列表是可以修改的。
# 定义一个列表list
my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))
# 定义一个嵌套的列表
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))['itheima', 666, True]
<class 'list'>
[[1, 2, 3], [4, 5, 6]]
<class 'list'>取值
# 顺序取出
my_list = ["itheima", "Lily", "Rose"]
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 倒序取出
my_list = ["itheima", "Lily", "Rose"]
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
# 取出嵌套列表中的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[0][1])
print(my_list[1][1])itheima
Lily
Rose
Rose
Lily
itheima
2
5操作
追加元素
1.append（追加元素在列表末端，时：O(1),否则为O(n)）
my_list = ["itheima", "Lily", "Rose"]
my_list.append("hey")
print(f"通过append方法在列表尾部追加元素后，结果是{my_list}")
2.extend
my_list1 = ["itheima", "Lily", "Rose"]
my_list2 = [1, 2, 3]
my_list1.extend(my_list2)
print(f"列表扩展后，结果是{my_list1}")
3.insert
my_list = ["itheima", "Lily", "Rose"]
my_list.insert(1, "hello")
print(f"列表中插入元素后，结果是{my_list}")
4.“+”
my_list1 = ["itheima", "Lily", "Rose"]
my_list2 = [1, 2, 3]
my_list3 = my_list1 + my_list2
print(f"列表合并后，结果是{my_list3}")列表合并后，结果是['itheima', 'Lily', 'Rose', 1, 2, 3]删除元素
1.del（删除指定下标的元素）
my_list = ["itheima", "Lily", "Rose"]
del my_list[0]
print(f"删除列表元素后，结果是{my_list}")
2.pop（删除指定下标的元素）
- my_list.pop() 时：O(1)
- my_list.pop(1) 时：O(n)
my_list = ["itheima", "Lily", "Rose"]
element = my_list.pop(2)
print(f"通过pop方法取出元素后列表内容：{my_list}，取出的元素是：{element}")
3.remove（删除指定元素，时：O(n)）
my_list = ["itheima", "itheima", "Lily", "Rose"]
my_list.remove("itheima")
print(f"通过remove方法删除元素后列表内容：{my_list}")
4.clear
my_list = ["itheima", "itheima", "Lily", "Rose"]
my_list.clear()
print(f"通过clear方法删除元素后列表内容：{my_list}")
计数
1.count
my_list = ["itheima", "itheima", "Lily", "Rose"]
count = my_list.count("itheima")
print(f"通过count方法统计出itheima的出现次数为：{count}")
2.len
my_list = ["itheima", "itheima", "Lily", "Rose"]
count = len(my_list)
print(f"通过len方法统计出列表的长度为：{count}")
找下标
index
my_list = ["itheima", "Lily", "Rose"]
index = my_list.index("Lily")
print(f"Lily在列表中的下标索引值是：{index}")
列表的sort（时：O(NlogN)）
使用方式
my_list = [["a", 33], ["b", 55], ["c", 11]]
# 定义排序方法
def choose_sort_key(element):
return element[1] # 返回第二个元素，表示根据列表中的嵌套列表第二个元素进行排序
my_list.sort(key=choose_sort_key, reverse=True)
print(my_list)[['b', 55], ['a', 33], ['c', 11]]my_list = [["a", 33], ["b", 55], ["c", 11]]
my_list.sort(key = lambda element : element[1], reverse=True)
print(my_list)[['b', 55], ['a', 33], ['c', 11]]特点
练习案例
my_list1 = [21, 25, 21, 23, 22, 20]
my_list1.append(31)
print(f"追加后，列表是{my_list1}")
my_list2 = [29, 33, 30]
my_list1.extend(my_list2)
print(f"追加后，列表是{my_list1}")
element = my_list1.pop(0)
print(f"取出后列表是{my_list1}，取出的元素是：{element}")
element = my_list1.pop(-1)
print(f"取出后列表是{my_list1}，取出的元素是：{element}")
index = my_list1.index(31)
print(f"31在列表中的下标位置是：{index}")
my_list列表中的元素有：itheima
my_list列表中的元素有：itheima
my_list列表中的元素有：Lily
my_list列表中的元素有：Rose遍历（每次从列表中取出的元素是字符串）
while
my_list = ["itheima", "itheima", "Lily", "Rose"]
index = 0
while index < len(my_list):
element = my_list[index]
print("my_list列表中的元素有：%s" % (element))
index += 1
my_list列表中的元素有：itheima
my_list列表中的元素有：itheima
my_list列表中的元素有：Lily
my_list列表中的元素有：Rosefor
方式一
my_list = ["itheima", "itheima", "Lily", "Rose"]
for element in my_list:
print("my_list列表中的元素有：%s" % (element))my_list列表中的元素有：itheima
my_list列表中的元素有：itheima
my_list列表中的元素有：Lily
my_list列表中的元素有：Rose方式二
enumerate()
my_list = ["itheima", "itheima", "Lily", "Rose"]
lenth = len(my_list)
for temp in enumerate(my_list, 1):
print(temp)
(1, 'itheima')
(2, 'itheima')
(3, 'Lily')
(4, 'Rose')
<type 'tuple'>方式三
my_list = ["itheima", "itheima", "Lily", "Rose"]
for i in range(0, len(my_list)):
print("i:", i, "element:", my_list[i])('i:', 0, 'element:', 'itheima')
('i:', 1, 'element:', 'itheima')
('i:', 2, 'element:', 'Lily')
('i:', 3, 'element:', 'Rose')对比
案例：取出列表内的偶数
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list2 = []
for element in my_list:
if element % 2 == 0:
my_list2.append(element)
print(f"my_list列表中的偶数有：{my_list2}")
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_list2 = []
index = 0
while index < len(my_list):
if my_list[index] % 2 == 0:
my_list2.append(my_list[index])
index += 1
print(f"my_list列表中的偶数有：{my_list2}")
my_list列表中的偶数有：[2, 4, 6, 8, 10]元组
定义
元组一旦定义完成，就不可修改
定义元组
# 定义元组
t1 = (1, "hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是{t1}")
print(f"t2的类型是：{type(t2)},内容是{t2}")
print(f"t3的类型是：{type(t3)},内容是{t3}")t1的类型是：<class 'tuple'>,内容是(1, 'hello', True)
t2的类型是：<class 'tuple'>,内容是()
t3的类型是：<class 'tuple'>,内容是()定义单个元素
t4 = ("hello",)
print(f"t4的类型是：{type(t4)},内容是{t4}")t4的类型是：<class 'tuple'>,内容是('hello',)若没有这个：, 则
t4 = ("hello")
print(f"t4的类型是：{type(t4)},内容是{t4}")t4的类型是：<class 'str'>,内容是hello元组的嵌套和取值
# 元组的嵌套
t5 = ((1, 2, 3),(4, 5, 6))
print(f"t5的类型是：{type(t5)},内容是{t5}")
num = t5[1][2]
print(f"从嵌套元组中取出的数据是{num}")t5的类型是：<class 'tuple'>,内容是((1, 2, 3), (4, 5, 6))
从嵌套元组中取出的数据是6操作
t1 = (1, "hello", True, 2, "hello")
# 取值
num = t1[3]
print(f"从嵌套元组中取出的数据是{num}")
# 索引
print(f"hello的下标是：{t1.index("hello")}")
# 计数
print(f"hello出现的次数是：{t1.count("hello")}")
# 求长度
print(f"t1的长度是：{len(t1)}")从嵌套元组中取出的数据是2
hello的下标是：1
hello出现的次数是：2
t1的长度是：5
遍历
while
t1 = (1, "hello", True, 2, "hello")
index = 0
while index < len(t1):
element = t1[index]
print(f"t1元组中的元素有{element}")
index += 1t1元组中的元素有1
t1元组中的元素有hello
t1元组中的元素有True
t1元组中的元素有2
t1元组中的元素有hellofor
t1 = (1, "hello", True, 2, "hello")
for element in t1:
print(f"t1元组中的元素有{element}")t1元组中的元素有1
t1元组中的元素有hello
t1元组中的元素有True
t1元组中的元素有2
t1元组中的元素有hello字符串
操作
my_str = "hello,1111,4444"
# 取值
num = my_str[3]
print(f"从字符串中取出的数据是：{num}")
# 索引
print(f"1的下标是：{my_str.index("1")}")
# 新替换
my_str2 = my_str.replace("1", "2")
print(f"新替换后：my_str的内容是：{my_str},my_str2的内容是：{my_str2}")从字符串中取出的数据是：l
1的下标是：6
新替换后：my_str的内容是：hello,1111,4444,my_str2的内容是：hello,2222,4444# 分割
my_str = "hello,1111,4444"
my_str_list = my_str.split(",")
print(f"将my_str字符串分割后，得到的新列表的内容是：{my_str_list}")
# 规整
my_str = " hello,1111,4444 "
new_my_str = my_str.strip()
print(f"规整后:my_str的内容是：{my_str},new_my_str的内容是：{new_my_str}")
my_str1 = "hh黑马程序员,黑马程序员hh"
new_my_str1 = my_str1.strip("hh")
print(f"规整后:my_str1的内容是：{my_str1},new_my_str1的内容是：{new_my_str1}")将my_str字符串分割后，得到的新列表的内容是：['hello', '1111', '4444']
规整后:my_str的内容是： hello,1111,4444 ,new_my_str的内容是：hello,1111,4444
规整后:my_str1的内容是：hh黑马程序员,黑马程序员hh,new_my_str1的内容是：黑马程序员,黑马程序员# 计数
my_str = "hello"
print(f"l出现的次数是：{my_str.count("l")}")
# 求串长
print(f"字符串my_str的长度是：{len(my_str)}")l出现的次数是：2
字符串my_str的长度是：5遍历
while
my_str = ("黑马程序员")
index = 0
while index < len(my_str):
print(f"my_str字符串中的元素有：{my_str[index]}")
index += 1my_str字符串中的元素有：黑
my_str字符串中的元素有：马
my_str字符串中的元素有：程
my_str字符串中的元素有：序
my_str字符串中的元素有：员for
my_str = "黑马程序员"
for element in my_str:
print(f"my_str字符串中的元素有：{element}")my_str字符串中的元素有：黑
my_str字符串中的元素有：马
my_str字符串中的元素有：程
my_str字符串中的元素有：序
my_str字符串中的元素有：员特点
案例：分割字符串(字符串独有的split)
my_str = "itheiima itcast boxuegu"
print(f"字符串{my_str}中有：{my_str.count("it")}个字符")
my_str2 = my_str.replace(" ","|")
print(f"字符串{my_str}，被替换空格后，结果：{my_str2}")
my_str_list = my_str2.split("|")
print(f"字符串{my_str2}，按照|分割后，得到：{my_str_list}")字符串itheiima itcast boxuegu中有：2个字符
字符串itheiima itcast boxuegu，被替换空格后，结果：itheiima|itcast|boxuegu
字符串itheiima|itcast|boxuegu，按照|分割后，得到：['itheiima', 'itcast', 'boxuegu']序列sequence（列表元组字符串有的）
定义
（1）内容连续、有序
（2）可使用下标索引的一类数据容器
（3）列表、元组、字符串可视为序列
操作
切片
即从一个序列中，取出一个子序列，取出的数据类型和原数据类型一致
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4] #步长默认是1，所以可以不写
print(f"result1的内容是{result1}")
# 对list进行切片，从3开始，1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result2 = my_list[3:1:-1]
print(f"result2的内容是{result2}")
# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result3 = my_tuple[:] #起始和结束不写表示从头到尾，步长默认是1，可以不写
print(f"result3的内容是{result3}")
# 对tuple进行切片，从末尾开始，到头结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result4 = my_tuple[::-2]
print(f"result4的内容是{result4}")
# 对str进行切片，从头开始，到最后结束，步长2
my_str = "0, 1, 2, 3, 4, 5, 6"
result5 = my_str[::2] #起始和结束不写表示从头到尾，步长是2
print(f"result5的内容是{result5}")
# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "0,1,2,3,4,5,6"
result6 = my_str[::-1]
print(f"result6的内容是{result6}")
# 对str进行切片，从末尾开始，到-2结束，步长-1，注意逗号也占一个位置
my_str = "0,1,2,3,4,5,6"
result7 = my_str[-1:-4:-1]
print(f"result7的内容是{result7}")
result1的内容是[1, 2, 3]
result2的内容是[3, 2]
result3的内容是(0, 1, 2, 3, 4, 5, 6)
result4的内容是(6, 4, 2, 0)
result5的内容是0 ,2 ,4 ,6
result6的内容是6,5,4,3,2,1,0
result7的内容是6,5案例
my_str = "万过薪月,员序程马黑来,nohtyp学"
result1 = my_str[::-1]
print(f"{result1}")
last_result = result1[result1.index("黑"):result1.index("黑") + 5]
print(f"{last_result}")学python,来黑马程序员,月薪过万
黑马程序员集合
定义
（1）是无序的
（2）不支持重复元素
特点
特别注意：定义空集合不能使用 my_set = {}的方式，因为这是定义空字典的方式
操作
单集合操作
# 定义集合变量
my_set = {"hello", "world"}
# 添加新元素
my_set.add("itheima")
print("添加新元素后my_set的内容是")
print(my_set)
print("")
# 移除元素
my_set = {"hello", "world"}
my_set.remove("hello")
print("移除元素后my_set的内容是")
print(my_set)
print("")
# 从集合中随机取出元素
my_set = {"hello", "world"}
element = my_set.pop()
print("随机取出元素后my_set的内容是")
print(my_set)
print("element的内容是")
print(element)
print("")
# 清空集合
my_set = {"hello", "world"}
my_set.clear()
print("清空集合后my_set的内容是")
print(my_set)
print("")
# 统计集合元素数量
my_set = {"hello", "world"}
num = len(my_set)
print(num)添加新元素后my_set的内容是
set(['world', 'hello', 'itheima'])
移除元素后my_set的内容是
set(['world'])
随机取出元素后my_set的内容是
set(['hello'])
element的内容是
world
清空集合后my_set的内容是
set([])
set1的内容是
set([1, 2, 3])
set2的内容是
set([1, 5, 6])
set3的内容是
set([2, 3])
2两个集合的操作
# 取两个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是{set3}")
print(f"取差集后,原有set1的内容{set1}")
print(f"取差集后,原有set2的内容{set2}")
print()
# 消除两个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后,集合1的内容{set1}")
print()
# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2个集合合并后的结果是{set3}")
print(f"合并后,原有set1的内容{set1}")
print(f"合并后,原有set2的内容{set2}")
print()取出差集后的结果是{2, 3}
取差集后,原有set1的内容{1, 2, 3}
取差集后,原有set2的内容{1, 5, 6}
消除差集后,集合1的内容{2, 3}
2个集合合并后的结果是{1, 2, 3, 5, 6}
合并后,原有set1的内容{1, 2, 3}
合并后,原有set2的内容{1, 5, 6}遍历
my_set = {'world', 'hello', 'itheima'}
for element in my_set:
print(element)world
hello
itheima案例
my_list = ["黑马程序员", "传智播客", "黑马程序员", "传智播客", "itheima", "itcast", "itheima", "itcast", "best"]
my_set = set()
for element in my_list:
my_set.add(element)
print(my_set)
{'best', 'itheima', 'itcast', '黑马程序员', '传智播客'}字典
定义
# 定义字典
my_dict = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = dict()
my_dict3 = {}
print(f"my_dict的内容是：{my_dict}，类型是：{type(my_dict)}")
print(f"my_dict2的内容是：{my_dict2}，类型是：{type(my_dict2)}")
print(f"my_dict3的内容是：{my_dict3}，类型是：{type(my_dict3)}")
# 定义重复key的字典
my_dict4 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是{my_dict4}")my_dict的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77}，类型是：<class 'dict'>
my_dict2的内容是：{}，类型是：<class 'dict'>
my_dict3的内容是：{}，类型是：<class 'dict'>
重复key的字典的内容是{'王力鸿': 88, '林俊节': 77}嵌套字典
# 定义嵌套字典
stu_score_dict = {
"王力鸿": {
"语文": 77,
"数学": 66,
"英语": 33,
}, "周杰轮": {
"语文": 88,
"数学": 86,
"英语": 55,
}, "林俊节": {
"语文": 99,
"数学": 96,
"英语": 66,
}
}
print(f"学生的考试成绩信息是：{stu_score_dict}")
# 从嵌套字典中获取数据
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")
学生的考试成绩信息是：{'王力鸿': {'语文': 77, '数学': 66, '英语': 33}, '周杰轮': {'语文': 88, '数学': 86, '英语': 55}, '林俊节': {'语文': 99, '数学': 96, '英语': 66}}
周杰轮的语文分数是：88操作
新增和更新
my_dict = {
"王力鸿": 99,
"周杰轮": 88,
"林俊节": 77
}
# 新增元素
my_dict["张学友"] = 66
print(f"新增后，my_dict的内容是：{my_dict}")
# 更新元素
my_dict["王力鸿"] = 100
print(f"更新后，my_dict的内容是：{my_dict}")新增后，my_dict的内容是：{'王力鸿': 99, '周杰轮': 88, '林俊节': 77, '张学友': 66}
更新后，my_dict的内容是：{'王力鸿': 100, '周杰轮': 88, '林俊节': 77, '张学友': 66}删除和清空
my_dict = {
"王力鸿": 99,
"周杰轮": 88,
"林俊节": 77
}
# 删除元素
score = my_dict.pop("周杰轮")
print(f"删除元素后，my_dict的内容是：{my_dict}，周杰轮的成绩是：{score}")
# 清空元素
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")删除元素后，my_dict的内容是：{'王力鸿': 99, '林俊节': 77}，周杰轮的成绩是：88
字典被清空了，内容是：{}获取全部的key和values
my_dict = {
"王力鸿": 99,
"周杰轮": 88,
"林俊节": 77
}
keys = my_dict.keys()
print(f"字典的全部key是{keys},该类型是{type(keys)}")
values = my_dict.values()
print(f"字典的全部value是{values},该类型是{type(values)}")
for name in keys:
print(name)
for score in values:
print(score)
字典的全部key是dict_keys(['王力鸿', '周杰轮', '林俊节']),该类型是<class 'dict_keys'>
字典的全部value是dict_values([99, 88, 77]),该类型是<class 'dict_values'>
王力鸿
周杰轮
林俊节
99
88
77统计字典内的元素数量
my_dict = {
"王力鸿": 99,
"周杰轮": 88,
"林俊节": 77
}
print(f"字典内的元素数量是：{len(my_dict)}")字典内的元素数量是：3遍历
特注：
- 在Python 3.5（含）以前，字典是不能保证顺序的。
- 从python3.6开始，dict变得紧凑以及关键字变得有序。
# 遍历字典两种方式
my_dict = {
"王力鸿": 99,
"周杰轮": 88,
"林俊节": 77
}
# 方式1：通过Keys遍历字典
keys = my_dict.keys()
for key in keys:
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict[key]}")
# 方式2：直接遍历字典
for key in my_dict:
print(f"字典的key是：{key}")
print(f"字典的value是：{my_dict[key]}")字典的key是：王力鸿
字典的value是：99
字典的key是：周杰轮
字典的value是：88
字典的key是：林俊节
字典的value是：77
字典的key是：王力鸿
字典的value是：99
字典的key是：周杰轮
字典的value是：88
字典的key是：林俊节
字典的value是：77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
