python学习基础第一阶段day06

元组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查找值,代码可读性相对较高
         		 (列表不适合存储多类信息，姓名/年龄/性别)
         		利用空间,换取时间,定义单个元素最快.      【快速】