Python基础-06

目录

1.列表引导式

练习：

2.元组 tuple

2.1定义

2.2基础操作

2.3作用

练习

3.字典

3.1定义

3.2基础操作

3.3字典与列表对比

3.4字典推导式

3.5根据value查找key

练习

---

1.列表引导式

• 定义：使用简易方法，将可迭代对象转换为列表。

• 语法：

  变量 = [表达式 for 变量 in 可迭代对象]
  变量 = [表达式 for 变量 in 可迭代对象 if 条件]

# 将列表list01所有元素加1后存入列表list02
list01 = [5,56,6,7,7,8,9]
list02 = []
for item in list01:
    list02.append(item+1)
print(list02)
​
# 重点来啦！！！
list01 = [5,56,6,7,7,8,9]
list02 = [item+1 for item in list01]
​
# -----------------------------------------------
# 将列表list01所有大于10的元素加1后存入列表list02
list01 = [5,56,6,7,7,8,9]
list02 = []
for item in list01:
    if item>10:
    list02.append(item+1)
print(list02)
​
# 重点来啦！！！
list01 = [5,56,6,7,7,8,9]
list02 = [item +1 for item in list01 if item>10]
print(list02)

练习：

# 练习
"""
使用range生成一个1-10之间的数字，将数字的平分存入list01中；将list01中的所有奇数存入list02中；将list01中的所有偶数存入list03中；将list01中所有大于5的偶数加+1后存入list04
"""
list01 = [item ** 2 for item in range(1, 11)]
list02 = [item for item in list01 if item % 2 == 1]
list03 = [item for item in list01 if item % 2 == 0]
list04 = [item + 1 for item in list01 if item > 5 and item%2 == 0]
​
print(list01)
print(list02)
print(list03)
print(list04)

2.元组 tuple

2.1定义

元组内存图（按需分配，不可变）

• 由一系列变量组成的不可变序列容器（元组与列表的区别就在于元组不可变而列表可变，列表会预留空间）

  列表扩容原理：①列表都会预留空间；②当预留空间不足时，会再创建一个新列表（开一个更大的空间）；③将原有数据拷贝到新列表中；④替换引用（原先的箭头变虚，画出新的实线箭头）

  list01 = []
  for i in range(4):
      list01.append((i + 1) * 10)
      print(list01)
      print(id(list01))
  """输出结果：
  [10]
  2062891914240
  [10, 20]
  2062891914240
  [10, 20, 30]
  2062891914240
  [10, 20, 30, 40]
  2062891914240
  """
  # 列表虽然发生变化，但是列表的id却没有变化，因为id指向的是表头

• 不可变是指一旦创建，不可以再添加/删除/修改元素

2.2基础操作

1.创建元组（创建之后不可变）

# 创建空元组
tuple01 = () 
# 等同于：tuple01 = tuple()
​
# 创建具有默认值的元组
tuple02 = (1,2,3)
​
# 列表 → 元组(灵活运用两种存储机制)
tuple03 = tuple(["a","b","c"])
​
# 元组 → 列表（灵活运用两种存储机制）
list01 = list(tuple02)

2.获取元素：元组切片后还是元组

可以直接将元组赋值给多个变量，列表也可行，但是一般用元组。

tuple01 = ("a","b","c","d")
# 索引
e01 = tuple01[1]        # "b"
print(type(e01))        # "str"
​
# 切片
e02 = tuple01[-2:]
print(type(e02))        # "tuple"
​
# 直接把元组赋值给变量--------------------------------------
tuple02 = (100,200)
a,b = tuple02
print(a)    # 100
print(b)    # 200
​
tuple03 = (100,200，300)
a,b = tuple02
print(a)    # 会报错
print(b)    # 会报错
​
list02 = [100,200]
a,b=list02
print(a)    # 100
print(b)    # 200

3.遍历元素

tuple01 = (100,200)
# 正向
for item in tuple01:
    print(item)
​
# 反向
for i in range(len(tuple01)-1,-1,-1):
    print(tuple01[i])

2.3作用

• 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所有可以增加元素。

• 元组会按需分配内存，所有如果变量数量固定，建议使用元组，因为占用空间更小。

• 应用：

  变量交换的本质就是创建元组：x,y = y,x

  x = 100
  y = 200
  x, y = y, x
  print(x)        # 200
  print(y)        # 100

  格式化字符串的本质就是创建元组："姓名%s，年级%d"%("Alex",15)

练习

1.借助元组完成功能：输入月份输出天数

思想：用容器统一管理数据

month = int(input("请输入月份："))
if month == 2:
    print("28天")
elif month in (4, 6, 9, 11):
    print("30天")
elif month in (1, 3, 5, 7, 8, 10, 12):
    print("31天")
else:
    print("月份输入有误")
    
# 方式二：
month = int(input("请输入月份："))
day_of_month = (31,28,31,30,31,30,31,31,30,31,30,31)
#                1  2  3  4  5  6  7  8  9  10 11 12
if month<1 or month>12:
    print("月份输入有误")
else:
    print(day_of_month[month-1])

2.在控制台中录入日期（年月日），计算这是这一年的第几天

# 索引
month = int(input("请输入月份："))
day = int(input("请输入日期："))
total = day
msg = "日期为：{}月{}日".format(month, day)
print(msg)
​
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
#                1  2    3   4   5   6   7   8   9  10  11  12
​
for index in range(month - 1):
    total += day_of_month[index]
​
text = "{}月{}日是一年的第{}天".format(month, day, total)
print(text)
​
# 切片
month = int(input("请输入月份："))
day = int(input("请输入日期："))
​
msg = "日期为：{}月{}日".format(month, day)
print(msg)
​
day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
#                1  2    3   4   5   6   7   8   9  10  11  12
​
total = sum(day_of_month[:month - 1]) + day
​
​
text = "{}月{}日是一年的第{}天".format(month, day, total)
print(text)

3.字典

3.1定义

• 由一系列键值对组成的可变映射容器。

• 映射：一对一的对应关系，且每条记录无序。

• 键必须唯一且不可变（字符串/数字/元组），值没有限制。

• 所有的容器中字典查找是最快的。（原因：哈希算法。运用空间换取时间，空间即内存，时间即CPU）

哈希算法：根据键计算出位置（通过运算决定位置）。

3.2基础操作

1.创建字典

# 空字典
dict01 = {}
dict02 = dict{}
​
# 默认值
dict01 = {"wj": 100, "zm": 80, "zr": 90}
dict02 = dict([("a", "b"), ("c", "d")])
print(dict02)   # {'a': 'b', 'c': 'd'}

2.查找元素

根据键查找值（key→value），注意这里是根据键查找字典的值，而不是索引。

如果键不存在，查找时会报错。（查找的时候一定要加判断）

dict01 = {"wj": 100, "zm": 80, "zr": 90}
print(dict01["zm"])     # 80
​
if "qyx" in dict01:
    print(dict01["qyx"])

3.修改

dict01 = dict([("a", "b"), ("c", "d")])
print(dict01)   # {'a': 'b', 'c': 'd'}
​
dict01["a"] = "BB"
print(dict01)   # {'a': 'BB', 'c': 'd'}

4.添加

添加与修改的代码相同，区别就在于，修改元素之前就存在key，而添加之前不存在key。

dict01 = dict([("a", "b"), ("c", "d")])
print(dict01)   # {'a': 'b', 'c': 'd'}
​
dict01["e"] = "f"
print(dict01)   # {'a': 'b', 'c': 'd', 'e': 'f'}

5.删除

只能根据键来删除，没有索引相关功能。

dict01 = dict([("a", "b"), ("c", "d")])
print(dict01)  # {'a': 'b', 'c': 'd'}
​
del dict01["a"]
print(dict01)   # {'c': 'd'}

6.遍历（获取字典中所有元素，由于字典内部元素是无序的，所以就无所谓正向反向）

dict01 = dict([("a", "b"), ("c", "d")])
print(dict01)  # {'a': 'b', 'c': 'd'}
​
# 遍历字典，获取key
for key in dict01:
    print(key)  # 打印出来的是键
    print(dict01[key])  # 打印出来的是值
​
# 遍历字典，获取value
for value in dict01.values():
    print(value)  # b d
​
# 遍历字典，获取key & value(键值对)
for item in dict01.items():
    print(item)  # ('a', 'b') ('c', 'd')
​
# 直接获取字典的键与值
for k, v in dict01.items():
    print(k)  # a c
    print(v)  # b d

3.3字典与列表对比

• 字典

  优点：根据键获取值，读取速度快；代码可读性相对于列表高（根据键获VS根据索引获取）

  缺点：内存占用大；获取值只能根据键不灵活

• 列表

  优点：根据索引/切片获取元素，获取元素更灵活（可以正向、反向、一个、多个）；相比字典占内存更小

  缺点：通过索引获取，如果信息较多可读性不高

3.4字典推导式

已知条件为：

键：1,2,3,4,5,6,7,8,9,10

值：对应的平方

dict_result = {}
for item in range(1, 11):
    dict_result[item] = item ** 2
print(dict_result)
​
# 重点来啦！！！
dict_result = {item: item ** 2 for item in range(1, 11)}
print(dict_result)
​
# --------------------------------------------------
# 满足已知条件且只记录大于5的数字
dict_result = {}
for item in range(1, 11):
    if item > 5:
        dict_result[item] = item ** 2
print(dict_result)
​
# 重点来啦！！！
dict_result = {item: item ** 2 
               for item in range(1, 11) if item > 5}
print(dict_result)
​

3.5根据value查找key

补充：字典无法根据value查找key

因为在Python中字典的键（key）是根据哈希算法来定位的，定好位置之后才加入值（value），即值根本不进行哈希运算

方案一：键值互换

缺点：如果值不唯一，交换或则丢失数据

dict01 = {'无忌': 101, '赵敏': 102, '周芷若': 103}
dict02 = {value:key
          for key,value in dict01.items()}
print(dict02)
# {101: '无忌', 102: '赵敏', 103: '周芷若'}

方案二：列表内嵌元组

查找时遍历列表，虽然会失去字典快速查找的功能，但是没有办法。

dict01 = {'无忌': 101, '赵敏': 102, '周芷若': 102}
result = [(key, value) for key, value in dict01.items()]
print(result)
# [('无忌', 101), ('赵敏', 102), ('周芷若', 102)]

练习

1.在控制台中循环录入商品信息（名称，单价）。如果名称输入空字符，则停止录入并将所有信息逐行打印。

product_dict = {}
while True:
    product = input("请输入商品名称：")
    if product == "":
        break
    else:
        price = float(input("请输入商品价格："))
        product_dict[product] = price
​
for key, value in product_dict.items():
    print("{}的价格是{}".format(key, value))

2.在控制台中循环录入学生信息（姓名，年龄，成绩，性别）。如果姓名输入空字符，则停止录入并将所有信息逐行打印。 ——总结字典内嵌元组、字典内嵌字典、列表内嵌字典各自的优缺点及使用的场合（选择策略）

内嵌的思想很重要，在开发中要灵活运用。

# 字典内嵌元组：优点是根据键获取值，所以读取速度快；缺点是取列表中的元素用索引，代码的可读性不好
dict_student = {}
while True:
    name = input("请输入学生姓名：")
    if name == "":
        break
​
    age = input("请输入该名学生的年龄：")
    score = input("请输入该名学生的成绩：")
    gender = input("请输入该名学生的性别：")
    dict_student[name] = (age, score, gender, )
​
for name, info in dict_student.items():
    text = "学生{}的年龄为{}岁，成绩为{}分，性别为{}".format(name, info[0], info[1], info[2])
    print(text)
    
# -------------------------------------------------------------------------------
"""
字典内嵌字典：优点是根据键获取值，所以读取速度快；方便但是不灵活，因为字典内部无序，所以无法获取最先或最后录入的三名学生信息
""" 
dict_student = {}
while True:
    name = input("请输入学生姓名：")
    if name == "":
        break
​
    age = input("请输入该名学生的年龄：")
    score = input("请输入该名学生的成绩：")
    gender = input("请输入该名学生的性别：")
    dict_student[name] = {"age":age, "score":score,"gender": gender}
​
for name, info in dict_student.items():
    text = "学生{}的年龄为{}岁，成绩为{}分，性别为{}".format(name, info["age"], info["score"], info["gender"])
    print(text)
    
# ------------------------------------------------------------------------------
# 列表内嵌字典：有序，可以获取前三个录入或最后录入的学生信息
list_student = []
while True:
    name = input("请输入学生姓名：")
    if name == "":
        break
​
    age = input("请输入该名学生的年龄：")
    score = input("请输入该名学生的成绩：")
    gender = input("请输入该名学生的性别：")
    dict_student = {"name": name, "age": age, "score": score, "gender": gender}
    list_student.append(dict_student)
​
for item in list_student:
    text = "学生{}的年龄为{}岁，成绩为{}分，性别为{}".format(item["name"], item["age"], item["score"], item["gender"])
    print(text)

3.在控制台中录入多个人的多个喜好。例如：

请输入姓名：

请输入第1个喜好：

请输入第2个喜好：

...输入空字符串表示结束

请输入姓名：

...在控制台打印所有人的所有喜好

# 字典内嵌列表
dict_hobby = {}
​
while True:
    name = input("请输入姓名：")
    count = 1
    if name == "":
        break
    else:
        list_hobby = []
        hobby = input("请输入第%d个爱好：" % count)
        while hobby:
            list_hobby.append(hobby)
            count += 1
            hobby = input("请输入第%d个爱好：" % count)
            dict_hobby[name] = list_hobby
print(dict_hobby)
​
for name, list_hobby in dict_hobby.items():
    print("名字为：%s" % name)
    for index in range(len(list_hobby)):
        text = "第{}个爱好是：{}".format(index + 1, list_hobby[index])
        print(text)
    print()

4.将1970年到2050年中的闰年存入列表

list_year = []
for year in range(1970,2051):
    if year%4==0 and year%100!=0 or year%400==0:
        list_year.append(year)
print(list_year)
​
# ------------------------------------------------------------
# 可以用列表推导式但是不简洁
list_year = [year for year in range(1970, 2051) if year % 4 == 0 and year % 100 != 0 or year % 400 == 0]
print(list_year)

5.存储全国各个城市的景区与美食，在控制台中显示出来。

北京：

景区：故宫，天安门，天坛

美食：烤鸭，炸酱面，豆汁，卤煮

成都：

景区：九寨沟，峨眉山，春熙路

美食：火锅，串串香，兔头

# 字典内嵌列表
dict_hobby = {}

while True:
    name = input("请输入姓名：")
    count = 1
    if name == "":
        break
    else:
        list_hobby = []
        hobby = input("请输入第%d个爱好：" % count)
        while hobby:
            list_hobby.append(hobby)
            count += 1
            hobby = input("请输入第%d个爱好：" % count)
            dict_hobby[name] = list_hobby
print(dict_hobby)

for name, list_hobby in dict_hobby.items():
    print("名字为：%s" % name)
    for index in range(len(list_hobby)):
        text = "第{}个爱好是：{}".format(index + 1, list_hobby[index])
        print(text)
    print()

6.计算一个字符串中的字符以及出现的次数，如：abcdefce

a：1 ；b:1；c:2；d:1；e:2；f：1

tips：逐一判断字符出现的次数，如果统计过则加1，如果未统计过则等于1

str_input = input("请输入内容：")
dict_result = {}
for item in str_input:
    if item not in dict_result:
        dict_result[item] = 1
    else:
        dict_result[item] += 1
print(dict_result)

7.已知列表，将列表中的元素作为键，相应的长度作为值，输出字典

list_name = ["无忌","赵敏","周芷若"]
dict_result = {}
for item in list_name:
    dict_result[item] = len(item)
print(dict_result)
​
# 字典推导式
list_name = ["无忌","赵敏","周芷若"]
dict_result = {item:len(item)
               for item in list_name}
print(dict_result)

8、已知姓名和相应的房间号列表，合并为字典

list_name = ["无忌","赵敏","周芷若"]
list_room = [101,102,103]
dict_result = {}
for index in range(len(list_name)):
    dict_result[list_name[index]] = list_room[index]
print(dict_result)
​
# 字典推导式
list_name = ["无忌","赵敏","周芷若"]
list_room = [101,102,103]
dict_result = {list_name[index]:list_room[index]
               for index in range(len(list_name))}
print(dict_result)