【Python 基础】Python全栈体系（三）

Python 基础

三、元组

1. 定义

1. 由一系列变量组成的不可变序列容器。
2. 不可变是指一但创建，不可以再添加/删除/修改元素。

2. 基础操作

2.1 创建空元组

• 元组名 = ()
• 元组名 = tuple()

2.2 创建非空元组

• 元组名 = (20,)
• 元组名 = (1, 2, 3)
• 元组名 = 100,200,300
• 元组名 = tuple(可迭代对象)

2.3 获取元素

• 变量 = 元组名[索引]
• 变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表

2.4 遍历元组

• 正向：
  • for 变量名 in 列表名:
    • 变量名就是元素
• 反向：
  • for 索引名 in range(len(列表名)-1,-1,-1):
    • 元组名[索引名]就是元素

"""
    元组tuple
"""
# 1. 创建
tuple01 = ()
tuple02 = tuple()

tuple01 = (12, 33, 4)
list01 = ["a", "b", "c"]
tuple02 = tuple(list01)
print(tuple02)
list03 = list(tuple01)

tuple02 = (1,)  # 元组中只有一个元素
tuple02 = 1, 2, 3  #
print(tuple02)

# 2. 查询
tuple03 = ("a", "b", "c")
a, b, c = tuple03

# 索引
print(tuple02[-1])

# 切片
print(tuple02[:2])

# 循环
for item in tuple02:
    print(item)

"""
在控制台中录入日期(月日)，计算是这一年的第几天。
例如：
       3月15日 --> 31 + 28 + 15
       5月20日 --> 31 + 28 + 31 + 30 + 20
"""
month = int(input("请输入月份："))
day = int(input("请输入天数："))
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# total_day = 0
# for item in day_of_month[:month - 1]:
#     total_day += item
total_day = sum(day_of_month[:month - 1])
total_day += day
print(total_day)

3. 作用

1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
3. 应用：
   变量交换的本质就是创建元组：x, y = （y, x ）
   格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)

4. 小结

• 字符串：存储字符编码，不可变序列
• 列表：存储变量，可变序列
• 元组：存储变量，不可变序列
• 不可变：按需分配
• 可变：预留空间

四、字典 dict

1. 定义

1. 由一系列键值对组成的可变散列容器。
2. 散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3. 键必须唯一且不可变(字符串/数字/元组)，值没有限制。

2. 基础操作

2.1 创建字典

• 字典名 = {键1：值1，键2：值2}
• 字典名 = dict (可迭代对象)

2.2 添加/修改元素

• 语法:
  • 字典名[键] = 数据
• 说明:
  • 键不存在，创建记录。
  • 键存在，修改值。

2.3 获取元素

• 变量 = 字典名[键] # 没有键则错误

2.4 遍历字典

• for 键名 in 字典名:
  • 字典名[键名]
• for 键名,值名 in 字典名.items():
  • 语句

2.5 删除元素

• del 字典名[键]

"""
    字典dict
"""
# 1. 创建
dict01 = {}
dict02 = dict()

dict01 = {101: "a", 102: "b", 103: "c"}
dict02 = dict([(101,"a"),(102,"b")])

# 2. 添加
dict01[104] = "d"

# 3. 修改
dict01[104] = "e"

# 4. 查找
# key
print(dict01[102])
if 106 in dict01:
    print(dict01[106])

# 循环
for key in dict01:
    print(key)

for value in dict01.values():
    print(value)

for item in dict01.items():
    print(item)

for k,v in dict01.items():
    print(k)
    print(v)

# 在控制台中录入商品信息(名称与单价)，
# 如果名称录入为空，则停止录入。
# 最后打印所有商品信息(一行一个)。
# 如果录入了游戏机，则打印其价格。

dict_commodity = {}
while True:
    name = input("请输入商品名称：")
    if name == "":
        break
    price = int(input("请输入单价："))
    dict_commodity[name] = price

for k, v in dict_commodity.items():
    print("%s商品的价格是%d" % (k, v))

if "游戏机" in dict_commodity:
    print(dict_commodity["游戏机"])

3. 小结

• 字符串：存储字符编码，不可变序列
• 列表：存储变量，可变序列
• 元组：存储变量，不可变序列
• 字典：存储键值对，可变散列

"""
    计算字符串中每个字符出现次数。
    输入：abcbdeacb
    输出：
        字符a,2次
        字符b,3次
        字符c,2次
        字符d,1次
        字符e,1次
"""
str_target = "abcbdeacb"
dict_result = {}

for item in str_target:
    if item not in dict_result:
        dict_result[item] = 1
    else:
        dict_result[item] += 1

for k, v in dict_result.items():
    print("字符%s,%d次" % (k, v))

"""
    在控制台中循环录入学生信息(名称、性别、年龄、成绩)，如果名称录入为空，则停止录入。
    最后打印所有学生信息(一行一个)。
    数据结构：
    [
      {"name":"悟空","sex":"男","age":23,"score":100}
    ]
"""
list_persons = []
while True:
    name = input("请输入学生姓名：")
    if name == "":
        break
    sex = input("请输入学生性别：")
    age = int(input("请输入学生年龄："))
    score = int(input("请输入学生成绩："))
    dict_person = {"name":name,"sex":sex,"age":age,"score":score}
    list_persons.append(dict_person)

for item in list_persons:
    print("我叫%s性别是%s今年%d岁啦考了%d分"%(item["name"],item["sex"],item["age"],item["score"]))

"""
    在控制台中循环录入多个人的多个喜好，如果名称录入为空，则停止录入。
    最后打印所有信息。
    数据结构：
    {
       "于谦":["抽烟","喝酒","烫头"]
    }
"""
dict_persons ={}
while True:
    name = input("请输入姓名：")
    if name == "":
        break
    dict_persons[name] = []
    while True:
        hobby = input("请输入喜好：")
        if hobby == "":
            break
        dict_persons[name].append(hobby)

for k,v_list_hobby in dict_persons.items():
    print(k+"喜欢：")
    for item in v_list_hobby:
        print(item)

4. 字典推导式

1. 定义：
   使用简易方法，将可迭代对象转换为字典。
2. 语法:
   {键:值 for 变量 in 可迭代对象}
   {键:值 for 变量 in 可迭代对象 if 条件}

"""
    字典推导式
"""

# 1 2 3 .. 9  -->  数字:数字的平方
# dict_result = {}
# for item in range(1,10):
#     dict_result[item] = item ** 2
# print(dict_result)

dict_result = {item: item ** 2 for item in range(1, 10)}

dict_result = {item: item ** 2 for item in range(1, 10) if item % 2 ==0}
print(dict_result)

"""
    将两个列表合并为一个字典。
    输入：["张无忌","赵敏","周芷若"] [101,102,103]
    输出：{"张无忌":101,"赵敏":102,"周芷若":103}
"""
list_names = ["张无忌", "赵敏", "周芷若"]
list_rooms = [101, 102, 103]

# dict_result = {}
# for i in range(len(list_names)):
#     dict_result[list_names[i]] = list_rooms[i]

dict_result = {list_names[i]: list_rooms[i] for i in range(len(list_names))}
print(dict_result)

5. 字典 VS 列表

1. 都是可变容器。
2. 获取元素方式不同,列表用索引,字典用键。
3. 字典的插入,删除,修改的速度快于列表。
4. 列表的存储是有序的,字典的存储是无序的。

五、集合 set

1. 定义

1. 由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2. 相当于只有键没有值的字典(键则是集合的数据)。

2. 基础操作

2.1 创建空集合：

• 集合名 = set()
• 集合名 = set(可迭代对象)

2.2 创建具有默认值集合

• 集合名 = {1, 2, 3}
• 集合名 = set(可迭代对象)

2.3 添加元素

• 集合名.add(元素)

2.4 删除元素

• 集合名.discard(元素)

3. 运算

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

6.	相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
 	s1 = {1, 2, 3}
  	s2 = {3, 2, 1}
  	s1 == s2  # True
  	s1 != s2  # False
	子集或相同,超集或相同 <=  >= 

"""
    集合set
        价值：去重复
             数学运算
"""
# 1. 创建
set01 = set()

set02 = {"唐僧", "悟空", "八戒"}

list01 = ["A", "b", "c", "A"]
set03 = set(list01)
print(set03)

print(set("abcacdb"))

# 2. 添加
set01.add("A")
set01.add("A")
print(set01)

# 3. 删除
set02.remove("唐僧")
if "唐三藏" in set02: set02.remove("唐三藏")
print(set02)

# 4. 循环
for item in set02:
    print(item)

# 5. 数学计算
set04 = {1, 2, 3}
set05 = {2, 3, 4}
# -- 交集
print(set04 & set05)# {2, 3}
# -- 并集
print(set04 | set05)# {1, 2, 3, 4}
# -- 补集
print(set04 ^ set05)# {1, 4}
print(set04 - set05)# {1}
print(set05 - set04)# {4}
# -- 子集
set06 = {2,3}
print(set06 < set04)	# True
# -- 超集
print(set04 > set06)	# True

"""
    在控制台中循环录入内容，如果为空则停止。
    打印所有不重复的内容。
"""
set_result = set()
while True:
    str_input = input("请输入：")
    if str_input == "":
        break
    set_result.add(str_input)

for item in set_result:
    print(item)

"""
    公司有以下员工：
	经理-曹操,刘备,孙权
	技术-曹操,刘备,张飞,关羽
    请计算：
        是经理也是技术的有谁？
        是经理，不是技术的有谁？
        是技术，不是经理的有谁？
        身兼一职的有谁？
        经理和技术总工有多少人？
"""
dict_persons = {
    "经理":{"曹操","刘备","孙权"},
    "技术":{"曹操","刘备","张飞","关羽"}
}
print(dict_persons["经理"]  &  dict_persons["技术"])
print(dict_persons["经理"]  -  dict_persons["技术"])
print(dict_persons["技术"]  -  dict_persons["经理"])
print(dict_persons["技术"]  ^  dict_persons["经理"])
print(len(dict_persons["技术"]  |  dict_persons["经理"]))

4. 集合推导式

1. 定义：
   使用简易方法，将可迭代对象转换为集合。
2. 语法:
   {表达式 for 变量 in 可迭代对象}
   {表达式 for 变量 in 可迭代对象 if 条件}

六、for for 嵌套

"""
    for for 嵌套
"""
# 外层循环控制行
for r in range(3):#012
    # 内层循环控制列
    for c in range(5):  # 01234
        print("*", end=" ")
    print()

"""
    使用for循环绘制下列图形：
    *****
    #####
    *****
    #####
"""
for r in range(4):#0  1  2  3
    for c in range(5):
        if r % 2 ==0:
            print("*",end= " ")
        else:
            print("#",end= " ")
    print()

"""
    自定义排序算法，对列表进行升序排列。
    思路：
        依次取出元素，与后面进行比较。
        发现更小的，则交换。
    输入：[2,8,6,1]
    输出：[1,2,6,8]
"""
list01 = [2, 8, 6, 1]
for r in range(len(list01) - 1):
    for c in range(r + 1, len(list01)):
        if list01[r] > list01[c]:
            list01[r], list01[c] = list01[c], list01[r]
print(list01)
"""
# list01[0] -->  list01[1]   list01[2]   list01[3]
for c in range(1,4):
    # list01[0]   list01[c]
    pass

# list01[1] -->  list01[2]   list01[3]
for c in range(2,4):
    # list01[1]   list01[c]
    pass

# list01[2] -->  list01[3]
for c in range(3,4):
    # list01[2]   list01[c]
    pass
"""

"""
    打印二维列表第四行第三列元素。
    从左到右打印二维列表第二行所有元素。
    从上到下打印二维列表第一列所有元素。
    将二维列表按照表格状输出到终端。
"""
list01 = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
    [13, 14, 15, 16],
]
print(list01[3][2])
for item in list01[1]:
    print(item)

# list01[0][0]
# list01[1][0]
# list01[2][0]
# list01[3][0]
for r in range(4):
    print(list01[r][0])

for line in list01:
    for item in line:
        print(item,end = "\t")
    print()

"""
    方阵转置
"""
list01 = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12],
    [13,14,15,16],
]
"""
for r in range(1,4):
    # list01[r][0]   list01[0][r]
    pass
# list01[1][0]    list01[0][1]
# list01[2][0]    list01[0][2]
# list01[3][0]    list01[0][3]

for r in range(2,4):
    # list01[r][1]    list01[1][r]
    pass
# list01[2][1]    list01[1][2]
# list01[3][1]    list01[1][3]
for r in range(3,4):
    # list01[r][2]    list01[2][r]
    pass
# list01[3][2]    list01[2][3]
"""
for c in range(len(list01)-1):
    for r in range(c+1, len(list01)):
       list01[r][c],list01[c][r] = list01[c][r] ,list01[r][c]

print(list01)

"""
    列表推导式嵌套
"""
list01 = ["香蕉","苹果","哈密瓜"]
list02 = ["咖啡","牛奶","雪碧","可乐"]
# list03 = []
# for r in list01:
#     for c in list02:
#         list03.append(r +c)
list03 = [r + c for r in list01 for c in list02]

print(list03)

• 小结
  • 字符串：存储字符编码，不可变序列
  • 列表：存储变量，可变序列
  • 元组：存储变量，不可变序列
  • 字典：存储键值对，可变散列
  • 集合：存储键，可变散列