【千锋Python2205班9.28笔记-day08-字典（一阶段）】

01-review

# 1. 字典的应用场景 - 同时保存多个意义的不同的数据
stu = {
    'name': '余婷',
    'age': 18,
    'weight': 67
}

# 2.什么是字典(dict)
"""
容器；{键1:值1, 键2:值2,...}
可变的；无序的；

键  - 不可变的数据;唯一的
值  - 没有要求
"""
dict1 = {}

# 3.增删改查
# 1)查
"""
查单个：字典[键]、字典.get(键)、字典.get(键, 默认值)


for 变量 in 字典:
    循环体(变量是键)
    
for 变量1,变量2 in 字典.items():
    循环体
"""
dict1 = {'a': 10, 'b': 20}
print(dict1['a'])

list1 = [10, dict1, {'abc': 100}]
print(list1[1]['a'])            # dict1['a']

# 2)增
"""
字典[键] = 值
字典.setdefault(键, 值)
"""

# 3）删
"""
del 字典[键]

字典.pop(键)
"""

# 3）改
# 字典[键] = 值

# 4.相关操作和函数
# 1) in 和 not in   -  判断键是否存在
# 2) len
# 3) dict(数据)
# result = dict(['abc', 10])
result = dict(['ab', [10, 20], range(2)])
print(result)       # {'a': 'b', 10: 20, 0: 1}

stu = {'name': '余婷', 'age': 18, 'gender': '女'}
print(list(stu))        # ['name', 'age', 'gender']

# 5.相关方法
dict

02-homework

# 1.已知一个列表获取列表中指定元素所有的下标
list1 = [10, 20, 34, 10, 9, 78]
data = 20
indexs = []
for index, item in enumerate(list1):
    if item == data:
        indexs.append(index)

print(data, '的下标有:', indexs)

# 2.已知一个数字列表，写程序判断这个列表是否是连续递增列表。
list1 = [23, 45, 68, 90]
for index in range(1, len(list1)):
    if list1[index] < list1[index-1]:
        print(False)
        break
else:
    print(True)

# 3.已知两个列表，将两个列表按照下面的规律交叉合并
A = [10, 20, 30, 40, 50]
B = [100, 200, 300]
result = []
while True:
    result.append(A.pop(0))
    result.append(B.pop(0))
    if A == [] or B == []:
        break
result += A + B

print(result)


# 4. 定义一个变量保存一个学生的信息，学生信心中包括：姓名、年龄、成绩(单科)、电话、性别
stu = {'name': '小明', 'age': 18, 'score': 89, 'tel': '1929233', 'gender': '男'}

# 5. 定义一个列表，在列表中保存6个学生的信息(学生信息中包括: 姓名、年龄、成绩(单科)、电话、性别(男、女、不明) )
students = [
    {'name': '小花', 'age': 20, 'score': 60, 'tel': '1829321', 'gender': '女'},
    {'name': '小红', 'age': 17, 'score': 100, 'tel': '1292930'},
    {'name': '李华', 'age': 15, 'score': 57, 'tel': '11222389', 'gender': '男'},
    {'name': '小明', 'age': 18, 'score': 89, 'tel': '1929233', 'gender': '男'},
    {'name': '张三', 'age': 30, 'score': 100, 'tel': '1929238'},
    {'name': '李敏', 'age': 20, 'score': 99, 'tel': '919234', 'gender': '女'}
]



# 1）统计不及格学生的个数
count = 0
for x in students:
    if x['score'] < 60:
        count += 1
print('不及格学生的个数:', count)


# 2)打印不及格未成年学生的名字和对应的成绩
for x in students:
    if x['age'] < 18 and x['score'] < 60:
        print(x['name'], x['score'])

# 3)求所有男生的平均年龄
total_age = count = 0
for x in students:
    if x.get('gender') == '男':
        total_age += x['age']
        count += 1
print('男生的平均年龄:', total_age / count)

# 4）打印最高分和对应的学生的名字
print('------------------------------------------华丽的分割线------------------------------------------------')
# 方法1：
max_score = students[0]['score']
for x in students[1:]:
    if x['score'] > max_score:
        max_score = x['score']

for x in students:
    if x['score'] == max_score:
        print(x['name'])

print('------------------------------------------华丽的分割线------------------------------------------------')
# 方法2：
max_score = students[0]['score']
names = [students[0]['name']]
for x in students[1:]:
    if x['score'] > max_score:
        max_score = x['score']
        names.clear()
        names.append(x['name'])
    elif x['score'] == max_score:
        names.append(x['name'])
print(max_score, names)

# 5)删除性别不明的所有学生
# 方法1：
result = [x for x in students if x.get('gender')]
print(result)

# 方法2：
# for x in students[:]:
#     if not x.get('gender'):
#         students.remove(x)

# 6）将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)
# 方法1：
result = sorted(students, key=lambda item: item['score'], reverse=True)
print(result)

# 方法2：选择排序
"""
0  -> 1、2、3、4
1  -> 2、3、4
2  -> 3、4
3  -> 4
[20, 50,  30, 70, 45]
第一轮结束：[70, 20, 30, 50, 45]
第二轮结束：[70, 50, 20, 30, 45]
第三轮结束：[70, 50, 45, 20, 30]
第四轮结束：[70, 50, 45, 30, 20]
"""
# nums = [20, 50,  30, 70, 45]
# for i in range(len(nums)-1):
#     for j in range(i+1, len(nums)):
#         if nums[j] > nums[i]:
#             nums[i], nums[j] = nums[j], nums[i]
# print(nums)

for i in range(len(students)-1):
    for j in range(i+1, len(students)):
        if students[j]['score'] > students[i]['score']:
            students[i], students[j] = students[j], students[i]
print(students)


"""
第1轮：50,30,70,45,20: 0-1、1-2、2-3、3-4           0-3(5-1)
第2轮：50,70,45,30,20：0-1,1-2,2-3                  0-2(5-2)
第3轮：70,50,45,30,20: 0-1,1-2                     0-1(5-3)
第4轮：70,50,45,30,20: 0-1                         0(5-4)
"""
nums = [20, 50,  30, 70, 45]
for i in range(1, len(nums)):
    for j in range(len(nums) - i):
        if nums[j+1] > nums[j]:
            nums[j + 1], nums[j] = nums[j], nums[j + 1]

print(nums)

# 7.已知一个列表保存了多个狗对应的字典:
dogs = [
  {'name': '贝贝', 'color': '白色', 'breed': '银狐', 'age': 3, 'gender': '母'},
  {'name': '花花', 'color': '灰色', 'breed': '法斗', 'age': 2},
  {'name': '财财', 'color': '黑色', 'breed': '土狗', 'age': 5, 'gender': '公'},
  {'name': '包子', 'color': '黄色', 'breed': '哈士奇', 'age': 1},
  {'name': '可乐', 'color': '白色', 'breed': '银狐', 'age': 2},
  {'name': '旺财', 'color': '黄色', 'breed': '土狗', 'age': 2, 'gender': '母'}
]
print('------------------------------------------华丽的分割线------------------------------------------------')
# 1)利用列表推导式获取所有狗的品种
# ['银狐', '法斗', ...]
result = [x['breed'] for x in dogs]
print(result)

# 2)利用列表推导式获取所有白色狗的名字
# ['贝贝', '可乐']
result = [x['name'] for x in dogs if x['color'] == '白色']
print(result)

# 3)给dogs中没有性别的狗添加性别为 ‘公’
for x in dogs:
    x.setdefault('gender', '公')
print(dogs)

# 4)统计 '银狐' 的数量
count = 0
for x in dogs:
    if x['breed'] == '银狐':
        count += 1
print(count)

03-元组

# 1.什么是元组（tuple）
"""
容器型数据类型; 将()作为容器的标志，里面多个数据用逗号隔开：(数据1, 数据2, 数据3,...)
不可变(不支持增删改)；有序的(支持下标操作)

任何类型的数据都可以是元组的元素。
"""
# 空元组
t1 = ()

# 只有一个元素的元组(重要!): 唯一的元素后面必须加逗号
t2 = (19)
print(t2, type(t2))     # 19 <class 'int'>

t2 = (19,)
print(t2, type(t2))     # (19,) <class 'tuple'>

# 在没有歧义的情况下，表示一个元组的时候，元组的小括号可以省略
t3 = (10, 29, 39)
print(t3, type(t3))         # (10, 29, 39) <class 'tuple'>

t3 = 10, 29, 39
print(t3, type(t3))         # (10, 29, 39) <class 'tuple'>

print('------------------------------------------华丽的分割线------------------------------------------------')
# 2.获取元组的元素
# 1)列表怎么获取元素的元组就怎么获取元素
t4 = ('星期1', '星期2', '星期3', '星期4', '星期5', '星期6', '星期天')
print(t4[-1], t4[0])
print(t4[1:-1:2])       # ('星期2', '星期4', '星期6')
print(t4[-2:2])         # ()
print(t4[3::-1])        # ('星期4', '星期3', '星期2', '星期1')
print('------------------------------------------华丽的分割线------------------------------------------------')
for x in t4:
    print(x)

print('------------------------------------------华丽的分割线------------------------------------------------')
for x in range(len(t4)):
    print(x, t4[x])

print('------------------------------------------华丽的分割线------------------------------------------------')
for x1, x2 in enumerate(t4):
    print(x1, x2)

# 2)通过多个变量来获取元组(列表也支持)
# a. 直接让变量的个数和元组(列表)中元素的个数保持一致，来让变量依次获取元组中的元素
t5 = (10, 20, 30)
x, y, z = t5
print(x, y, z)

# x, y, z = (10, 20, 30)
x, y, z = 10, 20, 30

d1 = {'a': 10, 'b': 20, 'c': 30}
# d1.items() -> [('a', 10), ('b', 20), ('c', 30)]
# x1, x2 = ('a', 10)
for x1, x2 in d1.items():
    print(x1, x2)

print('------------------------------------------华丽的分割线------------------------------------------------')
nums = [89, 70, 66]
for x1, x2 in enumerate(nums):
    print(x1, x2)

print('------------------------------------------华丽的分割线------------------------------------------------')
# b.让变量的数量小于元组(列表)中元素的数量，但是必须在某一个变量前加*；
# 先让不带*的变量按照位置关系去获取数据，剩下的全部给带*的变量
stu = (89, 18, 78, 67, 90, 167)
x, *y = stu
print(x, y)     # 89 [18, 78, 67, 90, 167]

*x, y = stu
print(y, x)        # 167 [89, 18, 78, 67, 90]

*a, b, c = stu
print(c, b, a)        # 167 90 [89, 18, 78, 67]

a, b, *c = stu
print(a, b, c)          # 89 18 [78, 67, 90, 167]

a, *b, c = stu
print(a, c, b)         # 89 167 [18, 78, 67, 90]

stu = ('小明', 18, 78, 67, 90, 167)
name, age, *score, height = stu
print(score)
print(name)

# 3.元组相关操作和函数  - 和列表一样
t1 = (10, 20, 30)
t2 = (100, 200)
print(t1 + t3)      # (10, 20, 30, 10, 29, 39)
print(t1 * 3)       # (10, 20, 30, 10, 20, 30, 10, 20, 30)

t1 = (101, 20, 30)
print(t1 > t2)

t1 = (101, 20, 30)
print(101 in t1)

t1 = (101, 20, 301)
print(max(t1), sum(t1), sorted(t1))     # 301 422 [20, 101, 301]
print(len(t1))
print(tuple('abc'))

# 4.元组相关方法：count、index

04-集合

# 1. 什么是集合（set）
"""
容器型数据; 将{}作为容器的标志，{数据1, 数据2, 数据3,...}
集合是可变的(支持增删改); 集合是无序的

集合中的元素必须是不可变类型的数据；集合中的元素是唯一(自带去重的功能)
"""
# 1）空集合
s1 = set()
print(type(s1), len(s1))

# 2）集合的元素是不可变类型的数据
s2 = {10, 'abc', True, (10, 20)}
print(s2)

# s3 = {10, 'abc', True, [10, 20]}      # 报错！

# 3）集合中的元素是唯一
nums = {10, 20, 30, 10, 40, 20, 20}
print(nums)     # {40, 10, 20, 30}

names = ['张三', '小明', '张三', '李四', '小明', '张三', '王五']
print(set(names))       # {'小明', '王五', '李四', '张三'}

# 4)集合无序
print({10, 23, 40} == {23, 10, 40})     # True

print('------------------------------------------华丽的分割线------------------------------------------------')
# 2. 数学集合运算（python集合的本质是数学的集合，支持数学集合运算）
"""
{1, 2, 3}  - 集合
{1, 2, 3}的子集： {}, {1}, {2}, {3}, {1, 2}, {2, 3}, {1, 3}, {1, 2, 3}
{1, 2, 3}的真子集：{}, {1}, {2}, {3}, {1, 2}, {2, 3}, {1, 3}
"""
# python的集合支持的数学集合操作：交集、并集、差集、对称差集、判断是否是子集、判断是否是真子集
s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {4, 5, 6, 7, 8, 9}

# 1）交集：&
# 集合1 & 集合2  -  获取两个集合的公共部分
result = s1 & s2
print(result)       # {4, 5, 6, 7}

# 2)并集: |
# 集合1 | 集合2  -  合并两个集合产生一个新的集合
result = s1 | s2
print(result)

# 3)差集: -
# 集合1 - 集合2      -    获取集合1中除了包含在集合2以外的部分
# 集合2 - 集合1      -    获取集合2中除了包含在集合1以外的部分
s1 = {1, 2, 3, 4, 5, 6, 7}
s2 = {4, 5, 6, 7, 8, 9}
print(s1 - s2)      # {1, 2, 3}
print(s2 - s1)      # {8, 9}

# 4)对称差集：^
# 集合1 ^ 集合2     -       合并集合1和集合2去掉部分获取剩下的部分
print(s1 ^ s2)      # {1, 2, 3, 8, 9}

# 5)判断是否是子集：>=、<=
# 6)判断是否是真子集: >、<
# 集合1 > 集合2   -  判断集合2是否是集合1的真子集
# 集合1 <= 集合2   -  判断集合1是否是集合2的子集
print({100, 200, 300, 400} > {1, 2})        # False
print({100, 200, 300, 400} > {100, 400})    # True