列表、元组与字典和作业

1、列表的相关函数

1.max、min - 求最大值、最小值

nums = [34, 89, 78, 56, 90, 23]
print(max(nums), min(nums))  # 90 23

2.sum - 求数字序列中求和

print(sum(nums))   # 370

3.sorted - 排序;不修改原序列中元素的顺序而是产生一个新的列表

sorted(序列);sorted(序列,reverse = True)

new_nums = sorted(nums)
print(nums) # [34, 89, 78, 56, 90, 23]
print(new_nums)   # [23, 34, 56, 78, 89, 90]

列表.sort();列表.sort(reverse = True)

nums = [34, 89, 78, 56, 90, 23]
result = nums.sort()
print(nums)  # [23, 34, 56, 78, 89, 90]
print(result)  # None

4、len - 获取序列中元素的个数

len（序列）

5、list - 列表类型转换

list（序列）   -  所有的序列都可以转换成列表：转换的是时候直接将序列中的元素转换成列表的元素

2、列表推导式

1）推导式的几种常见结构

'''
结构一：
[表达式 for 变量 in 序列]

结构二：
[表达式 for 变量 in 序列 if 条件语句]
'''

list1 = [10 for i in range(4)]
print(list1)  # [10, 10, 10, 10]

list2 = [x for x in range(4)]
print(list2)   # [0, 1, 2, 3]

list3 = [x * 2 + 1 for x in range(4)]
print(list3)  # [1, 3, 5, 7]

scores = [89, 67, 34, 56, 10, 90]
list4 = [x * 2 for x in scores]
print(list4)  # [178, 134, 68, 112, 20, 180]

list5 = [x >= 60 for x in scores]
print(list5)  # [True, True, False, False, False, True]

list7 = [10 for x in range(4) if x % 2]
print(list7)    #[10, 10]

list8 = [x for x in range(4) if x % 2]
print(list8)    # [1, 3]

list9 = [x for x in scores if x >= 60]
print(list9)   # [89, 67, 90]

2）推导式的应用

"""
应用1：让序列中所有的元素进行统一变换
[表达式 for 变量 in 序列]

应用2：将序列中满足某个条件的元素进行变换（根据某个条件是否满足做两种不同的变换）
[表达式1 if 条件语句 else 表达式2 for 变量 in 序列]

应用3：提取序列中满足某个条件的元素（提取、删除）
[表达式 for 变量 in 序列] if 条件语句]
"""
# [89， 67， 34， 56， 10，90, 35] ->  [[0, 89], [1, 67], ...]
nums = [89, 67, 34, 56, 10, 90, 35]
nums_new = [[x, nums[x]] for x in range(len(nums))]
print(nums_new)

# 练习1.将nums中所有的偶数除以2
# [89， 67， 34， 56， 10，90] -> [89, 67, 17, 28, 5, 45, 35]
nums_new2 = [x//2 if x % 2 == 0 else x for x in nums]
print(nums_new2)

# 练习2：删除所有的偶数（提取所有的奇数）
# [89, 67, 34, 56, 10, 90, 35] -> [89, 67, 35]
nums = [89, 67, 34, 56, 10, 90, 35]
nums_new3 = [x for x in nums if x % 2]
print(nums_new3)

3、元组

元组与列表很相似，就是不可变的列表

1）什么元组（tuple）

"""
元组是容器型数据类型；将（）作为容器的标志，里面多个元素用逗号隔开：（元素1，元素2，。。。）
元组不可变（只能查）；元组有序 - 支持下标操作
元素：和列表一样

"""
# 1)空元组
t1 = ()
print(type(t1), len(t1))  # <class 'tuple'>   0

# 2)只有一个元素的元组
t2 = (12)
print(type(t2))  #  <class 'int'> 1

t3 = (12,)
print(type(t3), len(t3))   # <class 'tuple'> 1

# 3)普通情况
t4 = (10, 34, 78)
print(t4)

# 4)在没有歧义的情况下，元组的小括号可以省略（直接将多个数据逗号隔开表示的也是一个元组）
t5 = 10, 34, 78
print(t5, type(t5))

2）元组的查 - 获取元素

# 1）列表获取元素的方式元组都支持
nums = (23, 45, 90, 78, 6, 34)
print(nums[1], nums[-5])

for x in nums:
    print(x)

for index in range(len(nums)):
    print(index, nums[index])

for index, item in enumerate(nums):
    print(index, item)

print(nums[1:])
print(nums[::-1])

# 2)通过变量获取元组的元素1 -
point = (10, 23, 12)
x, y, z = point
print(x, y, z)

x, y, z = 10, 23, 12

# 3)通过变量获取元组的元素2
# 如果变量的一个数小于元素的个数，那么必须在其中一个变量前加*。
# 取的时候先让没有*变量按照位置关系获取元素，剩下的全部给带*的变量（以列表的形式）
info = ('张三', 18, 175, 180, 90, 67, 89)
name, age, *other = info
print(name, age)     # 张三 18
print(type(other))   #  <class 'list'>

name, age, *other, a = info
print(name, age, a)  # 张三 18 89

name, *other, a, m = info
print(name, a, m)   # 张三 67 89

3）元组是不可变的列表 - 列表中不可变的相关操作元组支持

# + *
# in 和 not in
# 比较运算
# 元组.count\元组.index
# max(元组)\min(元组)\sum(元组)\sorted(元组)\len(元组)\tuple(序列)
point = (10, 23, 12)
print(sorted(point))  # [10, 12, 23]
print((1, 2, 3) + (4, 5, 6))  # (1, 2, 3, 4, 5, 6)
print((1, 2, 3) * 2)  # (1, 2, 3, 1, 2, 3)
print(1 in (1, 2, 3))  # True
print(1 not in (1, 2, 3))  # False
print((1, 2, 3) > (4, 5, 6))   # False
print(point.count(10))  #  1
print(point.index(12))  # 2
print(max(point))   # 23
print(min(point))   #  10
print(sum(point))   #  45
print(len(point))  # 3
print(tuple([1, 2, 3]))  # (1, 2, 3)

4、字典

1）定义一个变量保存一个学生的信息

stu = ['小明', 20, '男', 60, 89, 70, 55]

stu = {
    'name': '小明',
    'age': 20,
    'gender': 'nan',
    '体重': 60,
    'math': 89,
    '语文': 70,
    '英语': 55
}
print(stu['name'])

2）什么是字典（dict）

"""
字典是容器型数据类型：将{}作为容器标志，里面多个键值对用逗号隔开：{键1：值1, 键2：值2, 。。。}
字典是可变的（支持增删改）：字典是无序（不支持下标操作）
元素的要求：字典元素是键值对
            键 - 键必须是不可变的数据（例如：数字、字符串、元组）；键是唯一的
            值 - 没有要求
"""
# 1）空字典：{}
d1 = {}
print(type(d1), len(d1))   # <class 'dict'> 0

# 2)键是不可变数据类型
d2 ={1: 20, 'a': 30, (10, 20): 40}
print(d2)

# 3)键是唯一的
# d3 = {1: 20, 'a': 30, [10, 20]: 40}  # 报错
d4 = {'a': 20, 'b': 30, 'c': 40, 'b': 40}

# 4）字典是无序的
print({'a': 20, 'b': 30} == {'b': 30, 'a':20})  # True
print([10, 20] == [20, 10])  # False

3）字典的查

# 查 - 获取字典的值
# a.获取单个值
"""
字典[键]  -  获取字典中指定键对应的值，如果不存在会报错
字典.get(键)  - 获取字典中指定键对应的值，如果不存在返回None或者返回默认值
"""
dog = {'name': '财财', 'age': 3, 'breed': '土狗', 'gender': '母狗', 'color': '黑色'}
print(dog['name'])
print(dog['gender'])

print(dog.get('name'))
print(dog.get('height'))   # None
print(dog.get('height', '不存在'))  # 不存在

# b.遍历
# 通过for循环遍历字典的时候i，循环变量依次取到的是字典里的键
"""
for 变量 in 字典：
    循环
"""
for key in dog:
    print(key, dog[key])

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

for key, value in dog.items():
    print(key, value)

for key in dog.items():
    print(key)

5、练习

1.创建一个列表，列表中有10个整数, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

例如：随机生成了[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
		--- 去重之后 [70, 88, 91, 107, 234, 177, 282, 197]
  	---- 降序排序 [282, 234, 197, 177, 107, 91, 88, 70]

list1 = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
list2 = []
for i in list1:
    if i not in list2:
        list2.append(i)
list2.sort(reverse=True)
print(list2)

2.利用列表推导式, 完成以下需求

a. 生成一个存放1-100中各位数为3的数据列表

结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]

list3 = [x for x in range(3, 100, 10)]
print(list3)

b. 利用列表推导式将 列表中的整数提取出来

例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]

list4 = [True, 17, "hello", "bye", 98, 34, 21] 
list5 = [x for x in list4 if type(x) == int]
print(list5)

c.利用列表推导式 存放指定列表中字符串的长度

例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]

list6 = ["good", "nice", "see you", "bye"]
list7 = [len(x) for x in list6]
print(list7)

4.已经一个班级字典如下：

class1 = {
    'name': 'python2104',
    'address': '23教',
    'lecturer': {'name': '余婷', 'age': 18, 'QQ': '726550822'},
    'leader': {'name': '舒玲', 'age': 18, 'QQ': '2343844', 'tel': '110'},
    'students': [
        {'name': 'stu1', 'school': '清华大学', 'tel': '1123', 'age': 18, 'score': 98, 'linkman': {'name': '张三', 'tel': '923'}},
        {'name': 'stu2', 'school': '攀枝花学院', 'tel': '8999', 'age': 28, 'score': 76, 'linkman': {'name': '李四', 'tel': '902'}},
        {'name': 'stu3', 'school': '成都理工大学', 'tel': '678', 'age': 20, 'score': 53, 'linkman': {'name': '小明', 'tel': '1123'}},
        {'name': 'stu4', 'school': '四川大学', 'tel': '9900', 'age': 30, 'score': 87, 'linkman': {'name': '小花', 'tel': '782'}},
        {'name': 'stu5', 'school': '西南交大', 'tel': '665', 'age': 22, 'score': 71, 'linkman': {'name': '老王', 'tel': '009'}},
        {'name': 'stu6', 'school': '成都理工大学', 'tel': '892', 'age': 32, 'score': 80, 'linkman': {'name': '老王2', 'tel': '0091'}},
        {'name': 'stu7', 'school': '四川大学', 'tel': '431', 'age': 17, 'score': 65, 'linkman': {'name': '老王3', 'tel': '0092'}},
        {'name': 'stu8', 'school': '攀枝花学院', 'tel': '2333', 'age': 16, 'score': 32, 'linkman': {'name': '老王4', 'tel': '0093'}},
        {'name': 'stu9', 'school': '攀枝花学院', 'tel': '565', 'age': 21, 'score': 71, 'linkman': {'name': '老王5', 'tel': '0094'}}
    ]
}

1获取班级位置

print(class1['address'])

2）获取班主任的名字和电话

print(class1['leader']['name'],class1['leader']['tel'])

3）获取所有学生的姓名和分数

for x in class1['students']:
    print(x['name'], x['score'])

4）获取所有学生联系人的名字和电话

for x in class1['students']:
    print(x['linkman']['name'], x['linkman']['tel'])

5）获取班级最高分

list1 = []
for x in class1['students']:
    list1.append(x['score'])
print(max(list1))

6）获取班级分数最高的学生的姓名

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

7）计算班级学生的平均分

print(sum(list1)/len(list1))

8）统计班级中未成年人数

sum1 = 0
for x in class1['students']:
    if x['age'] < 18:
        sum1 += 1
print('未成年人数：'sum1)

9）用字典统计每个学校的人数, 类似: {'清华大学': 1, '攀枝花学院': 3}

dict2 = {}
for x in class1['students']:
    school_name = x['school']
    if school_name in dict2:
        dict2[school_name] += 1
    else:
        dict2[school_name] = 1
print(dict2)