day6 -元组和字典

day6 -元组和字典

一、列表相关函数和方法

1.列表（序列）相关函数：max、min、sum、len、sored、reversed、list

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

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

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

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

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

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

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

print(len([10, 20, 'abc', [10, 20], range(3)]))

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

​ sorted（序列， reverse=True) - 将序列中的元素从大到小排序，返回一个排序以后的新列表

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

new_nums = sorted(nums, reverse=True)
print(nums, new_nums)

6）reversed（序列） - 将序列中的元素倒序，产生一个新的迭代器

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

# 切片倒序
print(nums[::-1])

7）list(序列) - 将其它将序列转换成列表

rint(int(2.9), int(True), int(False), int('345'), float('3e4'))
print(list('abc'))
print(list(range(1, 3)))
print(list(new_nums))

2.列表的相关方法

1）列表.clear() - 清空列表

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

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

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

print(id(names), id(names2), id(new_names))

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

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

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

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

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

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

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

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

7）列表.sort() - 将列表中的元素从小到大排序

nums = [78, 60, 67, 90, 56]
nums.sort()
print(nums)

二、列表推导式（重要）

列表推导式 - 用来创建列表的表达式

推导式的应用：创建列表、元素筛选、元素的变换

1.推导式通用格式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]
list1 = [x/10 for x in scores]
print(list1)

2.补充：三目运算符

1)C的三目运算符：
表达式1？表达式2：表达式3 -> 如果表达式1的值为0，整个运算表达式的结果是表达式3
否则整个表达式的值是表达式2
2)Python的三目运算符：
变量 = 表达式2 if 表达式1 else 表达式3

age = 17
result = '成年' if age >= 18 else '未成年'
print(result)

# 练习：scores = [89, 34, 56, 23, 90, 100],将列表中的乘积转换成及格，不及格
scores = [89, 34, 56, 23, 90, 100]
list1 = ['及格' if x >= 60 else '不及格' for x in scores]
print(list1)

3.推导式通用格式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 == 1]
print(new_nums)

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

三、推导式整理

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

方案：[表达式 for 变量 in 序列] -表达式用来描述新序列中的元素和原序列元素之间的规则

nums = [23, 789, 90, 67, 22, 31]
result = [x % 10 for x in nums]
print(result)

2.部分变换（按照两种不同的方式变换）

方案：[三目运算 for 变量 in 序列]

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

3…筛选、删除

方案：[表达式 for 变量 in 序列 if 条件语句]

scores = [89, 33, 67, 8, 98, 23, 66, 81]
result = [x for x in scores if x >= 60]
print(result)

四、元组

1.什么是元组

元组是容器型数据类型（序列），将()作为容器标志，里面多个元素用逗号隔开：(元素1, 元素2, 元素3)
元组是不可变的（不支持增删改）、元组是有序（支持下标操作）
任何类型的数据都可以作为元组的元素

1）空元组

t1 = ()
print(t1, type(t1), len(t1))

2）只有一个元素的元组:元素后面的逗号不能省

l1 = [100]
t1 = (100,)
print(t1, type(t1))  # (100,) <class 'tuple'>
t2 = (100)
print(t2, type(t2))  # 100 <class 'int'>

3）普通元组

t4 = (10, 12.9, 'abc', 10)
print(t4, type(t4))

2.元组就是不可变的列表

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

1）查

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

for x in t5:
    print('x:', x)

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

2）+ 、 * 、in、not in

t6 = (10, 20)
print(t6 + (100, 200))
print(t6 * 3)

print(1 in t6)
print(10 in t6)

3） max、min、sum、sorted、reversed、len、tuple

scores = (98, 78, 67, 56, 23, 45, 99, 82, 86, 99)
print(max(scores))
print(min(scores))
print(sum(scores))
print(sorted(scores))  # [23, 45, 56, 67, 78, 82, 86, 98, 99]
print(tuple('abc'))
print(tuple([10, 230, 4]))

4）相关方法：count、index

print(scores.count(99))
print(scores.index(56))

3.元组不只是不可变列表

1）元组的（）在没有歧义的情况下可以去掉(元组特有的)

t1 = 10, 20, 30
print(t1, type(t1))
t2 = 10, 20, 30 * 2
print(t2)

2） 获取元组元素：让变量个数和元组中元素个数一致 （列表和元组都支持）

point1 = (10, 98)
print(point1[0], point1[1])
x, y = point1
print(x, y)

point2 = (-19, 89, 29)
x, y, z = point2
print(x, y, z)

point1 = [10, 98]
x, y = point1
print(x, y)

3）获取元组元素: 让变量个数小于元组中元素的个数，但必须在某一个变量前加* （列表和元组都支持）

先让不带的变量按照位置去获取元组中的元素，然后让剩下的元素全部作为一个列表返回给带的变量

t2 = (100, 200, 'abc', '男', True, 300)  # 列表也适用
x, *y, z = t2
print(x, z)
print(y)

*x, y, z = t2
print(y, z)
print(x)

x, y, *z = t2
print(x, y)
print(z)