元组和字典及列表相关

列表(序列) 相关函数: max 、 min、 sum、len、 sorted、reversed、list

max(序列) - 获取序列中最大的元素（要求序列中的元素本身必须支持比较运算，并且元素之间可以比较大小）

nums = [89, 23, 45, 890, 82, 12, 40]
print(max(nums))  # 890

min(序列) - 获取序列中最小的元素

nums = [89, 23, 45, 890, 82, 12, 40]
print(min(nums))    # 12

sum(序列) - 求序列中所有元素的和(序列中的元素必须是数字)

nums = [89, 23, 45, 890, 82, 12, 40]
print(sum(nums))
print(sum(range(1, 101)))

len(序列) - 求序列中元素的个数

sorted(序列) - 将序列中的元素从小到大排序，返回一个排完序以后的新列表

sorted(序列, reverse = True) - 将序列中的元素从大到小排序，返回一个排完序的新列表

nums = [89, 23, 45, 890, 82, 12, 40]
new_nums = sorted(nums)
new_nums2 = sorted(nums, reverse=True)
print(new_nums)
print(new_nums2)

reversed(序列) - 将序列中的元素倒序，产生一个新的迭代器(序列)

nums = [89, 23, 45, 890, 82, 12, 40]
new_nums = reversed(nums)
print(new_nums)  # <list_reverseiterator object at 0x0000020D5AE04520>

list(序列) - 将其他序列转换成列表

print(list('abc'))
print(list(range(1, 10)))

列表的相关方法(只有列表能用)

列表.clear() - 清空列表(直接操作原列表)

names = ['罗小黑战记', '海贼王', '一人之下', '进击的巨人', '死亡笔记']
names.clear()
print(names)   # []

列表.copy() - 复制原列表，产生一个一模一样的新列表

names = ['罗小黑战记', '海贼王', '一人之下', '进击的巨人', '死亡笔记']
new_names = names.copy()
print(new_names)
print(id(names), id(new_names))  # 保存地址

列表.count(元素) - 统计指定元素在列表中出现的次数

names = ['罗小黑战记', '海贼王', '一人之下', '海贼王', '海贼王', '进击的巨人', '死亡笔记']
print(names.count('死亡笔记'))
print(names.count('死神'))
print(names.count('海贼王'))

列表.extend(序列) - 将序列中所有的元素都添加到列表中(批量添加)

names = ['罗小黑战记', '海贼王', '一人之下', '进击的巨人', '死亡笔记']
names.extend(['妖精的尾巴', '火影忍者', range(1, 4), 'abc'])
print(names)  # ['罗小黑战记', '海贼王', '一人之下', '进击的巨人', '死亡笔记', '妖精的尾巴', '火影忍者', range(1, 4), 'abc']

列表.index(元素) - 获取指定元素对应的下标(从0开始的下标)

names = ['罗小黑战记', '海贼王', '海贼王', '一人之下', '进击的巨人', '死亡笔记']
print(names.index('一人之下'))
# print(names.index('火影'))  # ValueError: '火影' is not in list
print(names.index('海贼王'))  # 1  有多个时，只返回第一个

列表.reverse() - 将列表倒序(不会产生新的列表)

names = ['罗小黑战记', '海贼王', '海贼王', '一人之下', '进击的巨人', '死亡笔记']
names.reverse()
print(names)

列表.sort() - 将列表从小到大排序(不会产生新的列表)

nums = [10, 9, 90, 82, 75]
nums.sort()
print(nums)

列表推导式

• 用来创建列表的表达式
• 推导式的应用：创建列表、元素的筛选、元素的变化、

推导式通用格式1

"""
[表达式 for 变量 in 序列]
表达式： 描述新列表产生的规则

创建列表的原理：
list1 = []
for 变量 in 序列:
	list1.append(表达式)
"""
list1 = [x for x in range(4)]
print(list1)

list2 = [2*x + 3 for x in range(4)]
print(list2)

list3 = [x*2 for x in 'abc']
print(list3)

# 练习：已知列表scores = [89, 34, 56, 23, 90, 100],将列表的成绩转换成十分制的值
scores = [89, 34, 56, 23, 90, 100]
list4 = [x / 10 for x in scores]
list4 = ['及格' if x >= 60 else '不及格' for x in scores]
print(list4)

推导式通用格式2

"""
[表达式 for 变量 in 序列 if 条件语句]
原理：
list1 = []
for 变量 in 序列:
	if 条件语句:
		list1.append(表达式)
"""
nums = [23, 89, 98, 67, 23, 44, 60]
new_nums = [x for x in nums if x % 2 != 0]
print(new_nums)

# 练习：删除列表中所有的空值和0值
list5 = [12, 'abc', True, 0, 0.00, 0.02, '', [], [1, 2]]
list6 = [x for x in list5 if x]   # if x  ->  if bool(x) == True
print(list6)

补充：三目运算符

"""
C的三目运算符：
表达式1?表达式2:表达式3  ->  如果表达式1的值是0，整个运算表达式的结果是表达式3
						 否则整个运算表达式的值是表达式2
						 
python的三目运算符:
变量 = 表达式2 if 表达式1 else 表达式3  ->  如果表达式1为True，结果是表达式2
										否则结果是表达式3
"""
age = 19
result = '成年' if age >= 18 else '未成年'
print(result)

整理推导式

1. 整体变化 - 将原序列中的元素通过统一的规则，转换成一个新的序列

# 方案 ： [表达式 for 变量 in 序列]  -  表达式用来描述新序列中的元素和原序列元素之间的规则
nums = [23, 789, 90, 67, 22, 31]
new_nums = [x % 10 for x in nums]
print(new_nums)  # [3, 9, 0, 7, 2, 1]

2. 部分变换(按照两种不同的方式变换)

list1 = [23, 'abc', 78, '234', [10, 30], 1.23]
new_list1 = [x * 10 if type(x) in [int, float] else x for x in list1]
print(new_list1)  # [230, 'abc', 780, '234', [10, 30], 12.3]

3. 筛选、删除

# 方案:  [表达式 for 变量 in 序列 if 条件语句]
scores = [89, 33, 67, 8, 98, 23, 66, 81]
result = [x for x in scores if x >= 60]
print(result)  # [89, 67, 98, 66, 81]

元组

什么是元组（tuple）

"""
元组是容器型数据类型(序列),将()作为容器标志，里面多个元素用逗号隔开: (元素1, 元素2, 元素3, ...)
元组是不可变的(不支持增删改)、元组是有序的(支持下标操作)
任何类型数据都可以作为元组的元素
"""
# 1)空元组
t1 = ()
print(t1, type(t1), len(t1))

# 2)只有一个元素的元组  -  元素后面的逗号不能省
t2 = (100)
print(t2, type(t2))  # 100 <class 'int'>

t3 = (100,)
print(t3, type(t3))  # (100,) <class 'tuple'>

# 普通元组
t4 = (10, 12.9, 'abc', 10)
print(t4, type(t4))

元组就是不可变的列表

# 列表中，凡是和增删改不相关的操作，元组都支持
# 1)查

t5 = ('肖申克的救赎', '阿甘正传', '霸王别姬', '美丽人生', '黑客帝国', '触不可及', '这个杀手不太冷', 'V字仇杀队')
print(t5[1])
print(t5[-1])
print(t5[1:])
print(t5[3:0])
print(t5[2:-2:2])

# 2)遍历
for x in t5:
    print(x)

for x in range(len(t5)):
    print(x, t5[x])


# 3)
t6 = (10, 20)
print(t6 + (100, 200))  # (10, 20, 100, 200)
print(t6 * 3)   # (10, 20, 10, 20, 10, 20)
print(1 in t6)  # False
print(10 in t6)  # True


# 4)max、 min、 sum、 sorted、 reversed、 len、 tuple
scores = (98, 78, 67, 56, 23, 45, 99, 82, 86, 86)
print(max(scores))
print(min(scores))
print(sum(scores))
print(sorted(scores))   # [23, 45, 56, 67, 78, 82, 86, 98, 99]
print(tuple('abc'))  # ('a', 'b', 'c')
print(tuple([10, 30, 4]))  # (10, 30, 4)


# 5) 相关方法： count 、 index
print(scores.count(86))
print(scores.index(82))

元组不只是不可变列表

# 1) 元组的()在没有歧义的情况下可以去掉 (元组特有的)
t1 = 10, 20, 30
print(t1, type(t1))  # (10, 20, 30) <class 'tuple'>

# 2) 获取元组元素的时候： 让变量个数和元组中元素个数(列表和元组都支持)
point1 = (10, 98)
x, y = point1
print(x, y)

point2 = (10, 82, 72)
x, y, z = point2
print(point2)

# 3)获取元组元素: 让变量个数小于元组中元素的个数，但是必须在某一个变量前加* （列表和元祖都支持）
# 先让不带* 的变量，按照位置关系去获取元组中的元素，然后让剩下的元素全部作为一个列表返回给带* 的变量
t2 = (100, 200, 'abc', '男', True, 300)
*x, y, z = t2
print(y, z)  # True 300

x, *y, z = t2
print(x, z)  # 100 300

x, y, *z = t2
print(x, y)  # 100 200

认识字典

# 定义一个变量保存一个学生的信息
test = {
    'name': '小明',
    'age': 18,
    'height': 180,
    'weight': 74,
    'score': 80
}
print(test['name'])   # 小明

作业

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

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

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

# a.生成一个存放1-100中个位数为3的数据列表
list1 = [x for x in range(1, 100) if x % 10 == 3]
print(list1)

# b.利用列表推导式将列表中的数据提取出来
# 例如[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]
list1 = [True, 17, "hello", "bye", 98, 34, 21]
list2 = [x for x in list1 if type(x) in [int, float]]
print(list2)

# c.利用列表推导式 存放指定列表中字符串的长度
# 例如["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]
list1 = ["good", "nice", "see you", "bye"]
list2 = [len(x) for x in list1]
print(list2)

# d.利用列表推导式删除列表中整数个位数小于5的元素
# 例如：[24, 'abc', 99, True, 21, 38, 'hello'] --- ['abc', 99, True, 38, 'hello']
list1 = [24, 'abc', 99, True, 21, 38, 'hello']
list2 = [x for x in list1 if type(x) in [int, float]]
list3 = [x for x in list2 if x % 10 < 5]
list4 = [x for x in list1 if x not in list3]
print(list4)

# e.利用列表推导式获取元素是元组的列表中每个元组的最后一个元素
# 例如：[(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]  --- [30, 'hello', 3.4, False]
list1 = [(10, 20, 30), ('abc', 'hello'), (1, 2, 3.4), (True, False)]
list2 = []
[list2.append(x[-1]) for x in list1]
print(list2)

3.已知代码如下，请回答出各个print的结果，并说明原有

nums = [17, 39, 28, 51]
nums2 = nums
nums2.pop()
print(len(nums))  # 这个结果是什么   请描述原因  长度为3，nums2和nums 指向的是同一个数据

numlist = [17, 22, 39, 58, [55, 43]]
nums3 = numlist.copy()
print(numlist is nums3)  # 结果  原因是什么  copy方法是复制原列表，然后产生一个新的列表，两个内存不一样
numlist[-1][0] = 99
print(nums3)  # num3会不会发生变化  ??

(试一下). 定义一个列表，在列表中保存6个学生的信息(学生信息中包括: 姓名、年龄、成绩(单科)、电话、性别(男、女、不明) )

list1 = [
    {'name': '小明','age': 18,'score': 40,'tel': 123456,'sex': '男'}, 
    {'name': '小红','age': 17,'score': 85,'tel': 1234567,'sex': '女'},
    {'name': '小H','age': 20,'score': 55,'tel': 12345698,'sex': '男'},
    {'name': '小O','age': 21, 'score': 70,'tel': 123456929,'sex': '男'}, 
    {'name': '小李','age': 15,'score': 85,'tel': 123456213,'sex': '男'},
    {'name': '小王','age': 17,'score': 98,'tel': 12345685,'sex': '男'}
]
# a.统计不及格学生的个数
stu_count = []
[stu_count.append(x) for x in list1 if x['score'] < 60]
print(len(stu_count))

# b.打印不及格学生的名字和对应的成绩
stu_count2 = []
[stu_count2.append(x) for x in list1 if x['score'] < 60]
for x in stu_count2:
    print(x['name'], ':', x['score'], sep='')
    
# c.统计未成年学生的个数
list3 = []
[list3.append(x) for x in list1 if x['age'] < 18]
print(len(list3))

# d.打印手机尾号是8的学生的名字
tel_name = []
[tel_name.append(x['name'])for x in list1 if x['tel'] % 10 == 8]
print(tel_name)

# e.打印最高分和对应的学生的名字
# f.删除性别不明的所有学生
# g.将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)