元组tuple
定义
1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。
作用
1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖："姓名:%s, 年龄:%d" % ("tarena", 15)
基础操作
1. 创建空元组：
元组名 = ()
元组名 = tuple()
2. 创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)+
3. 获取元素：
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表
4. 遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
元组名[索引名]就是元素
元组tuple 详细基础操作：
# 1. 创建
tuple01 = ()
tuple01 = (4, 545, 5665, 7, 78)
list01 = [54, 5, 56, 67]
# 列表（预留空间） --> 元组（按需分配）
tuple02 = tuple(list01)
# 元组（按需分配） --> 列表（预留空间）
list02 = list(tuple01)
# 特殊
# -- 如果元组只有一个数据,必须在后面添加逗号
tuple03 = (4,)
# -- 小括号可以省略
tuple04 = 4, 5, 6
# -- 可以直接将容器赋值给多个变量
a, b, c = (8, 9, 10)
print(type(tuple04))
# 2. 查询
# -- 索引
print(tuple01[-1]) # 获取最后一个
print(tuple01[2]) # 获取第三个
# -- 切片
# 原理：创建新容器
print(tuple01[-3:]) # 最后三个
# -- 循环
for item in tuple01:
print(item)
for i in range(len(tuple01) - 1, -1, -1):
print(tuple01[i])
字典 dict
定义:
1. 由一系列键值对组成的可变散列容器。
2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
2. 键必须惟一且不可变(字符串/数字/元组)，值没有限制。
基础操作
1. 创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象)
2. 添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改值。
3. 获取元素：
变量 = 字典名[键] # 没有键则错误
4. 遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
5. 删除元素：
del 字典名[键]
字典 VS 列表
1. 都是可变容器。
2. 获取元素方式不同,列表用索引,字典用键。
3. 字典的插入,删除,修改的速度快于列表。
4. 列表的存储是有序的,字典的存储是无序的。
字典dict 详细基础操作：
# 1. 创建
dict01 = {}
dict01 = {101: "悟空", 102: "八戒", 103: "唐僧"}
# 列表(格式) --> 字典
# 格式：[(k,v),(k,v)]
dict02 = dict(["悟空", (102, "猪八戒"), [103, "唐僧"]])
# 字典 --> 列表(只保留key)
list01 = list(dict01)
# 2. 添加
# --通过键-值
dict01[104] = "沙僧"
print(dict01)
# 3. 修改（如果key存在,则为修改,不存在则为添加）
dict01[101] = "孙悟空"
# 4. 删除
# 如果key不存在则报错
if 108 in dict01:
del dict01[108]
# 5. 查询
# key/循环
# print(dict01[101])
# -- 获取所有key
for key in dict01:
print(key)
# --获取所有value
for value in dict01.values():
print(value)
# --获取所有key - value
# for item in dict01.items():
# print(item)# (k,v)
for key,value in dict01.items():
print(key)
print(value)
集合 set
定义:
1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。
基础操作
1. 创建空集合：
集合名 = set()
集合名 = set(可迭代对象)
2. 创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
3. 添加元素：
集合名.add(元素)
4. 删除元素：
集合名.discard(元素)
集合set 详细基础操作：
# 1. 创建
# set01 ={} # 创建字典,不是集合
set01 = {"悟空", "八戒", "唐僧"}
list01 = ["悟空", "八戒", "唐僧", "八戒"]
set02 = set(list01)
print(set02)
# 2. 添加
set01.add("沙僧")
# 3. 删除
set01.remove("悟空")
# 4. 修改(先删除后添加)
print(set01)
运算
1. 交集&：返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
2. 并集：返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
3. 补集-：返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^：返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
4. 子集<：判断一个集合的所有元素是否完全在另一个集合中
5. 超集>：判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True
# 数学运算
# 交集
# &
s01 = {1, 2, 3}
s02 = {2, 3, 4}
print(s01 & s02) # {2, 3}
# 并集
# |
print(s01 | s02) # {1, 2, 3, 4}
# 补集
# ^
print(s01 ^ s02) # {1, 4}
print(s01 - s02) # {1 }
print(s02 - s01) # {4 }
# 子集超集
s03 = {2, 3}
print(s03 < s01)
练习1：
"""
请使用容器的思想,改造下列代码：
统一管理
"""
year = int(input("请输入年份："))
month = int(input("请输入月份："))
# if month < 1 or month > 12:
# print("月份有误")
# elif month == 2:
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
# print("29天")
# else:
# print("28天")
# # elif month == 4 or month == 6 or month == 9 or month == 11:
# elif month in (4, 6, 9, 11):
# print("30天")
# else: # 1 3 5 7 8 10 12
# print("31天")
# 将每月天数,存入元组
day_of_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
days_of_month = (31, day_of_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
print(days_of_month[2]) # 三月
print(days_of_month[-1]) # 十二月
练习2:
"""
获取年、月、日
计算这是这一年的第几天
2019,5,18
算法：前几个月的总天数+当月天数
31,28,31,30+18
"""
year = int(input("获取年份:"))
month = int(input("获取月份:"))
day = int(input("获取天数"))
month_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
tuple01 = (31, month_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# total_day = 0
# for i in range(month - 1):
# total_day += tuple01[i]
total_day = sum(tuple01[:month - 1])
total_day += day
print("第%d年的%d月%d日是这一年的第%d天" % (year, month, day, total_day))
练习3:
"""
在终端中循环录入商品信息（名称，单价）
如果录入为空，停止录入。
-->打印所有终端信息 要求一行一个
格式：xxx的商品的价格是yyy
-->如果录入游戏机，单独打印其价格。
"""
dict01 = {}
while True:
name = input("输入商品名称:")
if name == "":
break
price = float(input("输入商品单价:"))
dict01[name] = price
for k, v in dict01.items():
print("%s的商品的价格是%.f" % (k, v))
if "游戏机" in dict01:
print(dict01["游戏机"])
练习4:
"""
dict01 = {}
while True:
name = input("输入学生信息:")
if name == "":
break
age = int(input("输入学生年龄:"))
sex = input("输入学生性别:")
result = float(input("输入学生成绩:"))
dict01[name] = [age, sex, result]
for k_name, v_infos in dict01.items():
print("%s的年龄是%d,性别是%s,成绩是%.f" % (k_name, v_infos[0], v_infos[1], v_infos[2]))
if "唐僧" in dict01:
print(dict01["唐僧"][2])
练习5:
"""
一家公司有如下员工
经理:"曹操","刘备","孙权"
技术员:"曹操","刘备","张飞","关羽"
选取数据结构，存储以上信息
1.选择数据结构，存储以上信息
2.是经理也是技术员的都有谁？
3.是经理不是技术员的都有谁？
4.不是经理也是技术员的都有谁？
5.公司有多少人？
6.张飞是经理吗？
"""
# 1.选择数据结构，存储以上信息
conductor = {"曹操", "刘备", "孙权"}
technician ={"曹操", "刘备", "张飞", "关羽"}
# 2.是经理也是技术员的都有谁？
print(conductor & technician)
# 3.是经理不是技术员的都有谁？
print(conductor - technician)
# 4.不是经理也是技术员的都有谁？
print(technician - conductor)
# 5.公司有多少人？
print(len(conductor | technician))
# 6.张飞是经理吗？
print("张飞" in conductor)
练习6:
"""
在终端中循环录入学生信息(名称,年龄,性别,成绩...)
如果名称为空,停止录入.
-- 打印所有学生信息(一行一个)
格式：xxx的年龄是xxx,性别是xxx,成绩是xxx.
-- 打印最后一个学生的信息
...
核心：数据结构 列表内嵌字典
[
{"name":"悟空", "age":26,"sex":"男","score":86},
{"name":"唐僧", "age":24,"sex":"男","score":90},
]
"""
list_persons = []
while True:
name = input("请输入学生姓名：")
if name == "":
break
age = int(input("请输入学生年龄："))
sex = input("请输入学生性别：")
score = float(input("请输入学生成绩："))
dict_person = {"name":name, "age":age,"sex":sex,"score":score}
list_persons.append( dict_person )
for person in list_persons:
print("%s的年龄是%d,性别是%s,成绩是%f." % (person["name"], person["age"],person["sex"],person["score"]))
# 最后一个学生信息
person = list_persons[-1]
print("%s的年龄是%d,性别是%s,成绩是%f." % (person["name"], person["age"], person["sex"], person["score"]))
总结：
列表：通过索引/切片获取数据,定位元素灵活. 【灵活】
字典：通过key查找值,代码可读性相对较高
(列表不适合存储多类信息，姓名/年龄/性别)
利用空间,换取时间,定义单个元素最快. 【快速】
扫一扫
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
