一、列表相关操作

1.运算符
1）数学运算符：+ 和 *
列表1 + 列表2 -> 产生一个新的列表，新列表中的元素是两个列表中元素的合并
列表 * N -> 列表中的元素重复N次，产生一个新的列表

list1 = [1, 2, 3]
list2 = ["张三", "李四"]
print(list1 + list2)    # [1, 2, 3, '张三', '李四']
print(list1 * 3)    # [1, 2, 3, 1, 2, 3, 1, 2, 3]

2）比较运算符：
==， !=
列表1 == 列表2 -> 判断两个列表的值是否相等

list3 = [1, 2, 3]
list4 = [2, 1, 3]
print(list3 == list4)   # False
list4 = [1, 2, 3]
print(list3 == list4)   # True

3）is 也是比较是否相等，与 == 有区别
变量1 is 变量2 -> 判断地址是否相等

li1 = [1, 2]
li2 = [1, 2]
print(li1 == li2)       # True
print(li1 is li2)       # False

4）>, <, >=, <=(了解)
print([1, 2, 3] > [10, 20]) # False
比较元素的大小，一对一的比，一比较出大小就结束，元素必须是数字，否则报错
5）in和not in
元素 in 列表 -> 判断列表中是否存在指定元素，有就返回True，没有就返回False
元素 not in 列表 -> 判断列表中是否不存在指定元素，有就返回True，没有就返回False

names = ["小明", "小红", "张三", "李四"]
print('小红' in names)       # True
print('小张' in names)       # False
print(['小明'] in names)      # False

3.相关函数：len，max，min，list，sum
1）len(序列) —— 获取序列的长度(元素的个数)
2）max/min
max(序列)/min(序列) -> 获取序列中元素的最大值和最小值
要求：不是任何序列都行，a.序列中所有元素的类型要一致(数字看成一种类型)，b.元素本身支持比较大小

scores = [20, 30, 89, 98]
print(max(scores))      # 98
print(min(scores))      # 20

3）sum
sum(数字序列) -> 求序列中所有元素的和

scores = [1, 2, 3, 4]
print(sum(scores))      # 10
print(sum(range(101)))  # 5050

4）list
list(数据) -> 把指定的数据转换成列表；数据必须是序列(所有的序列都可以转换成列表)

print(list("hello"))    # ['h', 'e', 'l', 'l', 'o']
print(list(range(5)))   # [0, 1, 2, 3, 4]
# print(list(100))        # TypeError: 'int' object is not iterable

二、列表相关方法

1.列表.count(元素) -> 统计列表中指定元素的个数

names = ['曹操', "刘备", "赵云", "小乔", "貂蝉", "吕布", "赵云"]
print(names.count('赵云'))    # 2
print(names.count('小乔'))    # 1
print(names.count('大乔'))    # 0

2.列表.extend()

names = ['曹操', "刘备", "赵云", "小乔", "貂蝉", "吕布", "赵云"]
names.append('后裔')
print(names)        # ['曹操', '刘备', '赵云', '小乔', '貂蝉', '吕布', '赵云', '后裔']
names.extend('后裔')
print(names)        # ['曹操', '刘备', '赵云', '小乔', '貂蝉', '吕布', '赵云', '后裔', '后', '裔']
names.append([1, 2])
print(names)        # ['曹操', '刘备', '赵云', '小乔', '貂蝉', '吕布', '赵云', '后裔', '后', '裔', [1, 2]]
names.extend([1, 2])
print(names)        # ['曹操', '刘备', '赵云', '小乔', '貂蝉', '吕布', '赵云', '后裔', '后', '裔', [1, 2], 1, 2]

3.列表.index(元素) -> 获取指定元素在列表中的下标(下标值0~长度-1)
如果元素不存在会报错
如果元素有多个则只取第一个元素的下标

nums = [10, 20, 30, 2, 30]
print(nums.index(100))      # ValueError: 100 is not in list
print(nums.index(30))   # 2
print(nums.index(10))   # 0

4.列表.reverse() -> 将原来的列表倒序(反过来)

nums = [1, 9, 3]
nums.reverse()
print(nums)     # [3, 9, 1]
nums = [1, 9, 3]
new_nums = nums[::-1]
print(nums,new_nums)    # [1, 9, 3] [3, 9, 1]

5.列表.clear() -> 清空列表
注意：一般清空列表用clear，而不是直接赋值为[]

nums = [10, 3, 50, 3, 90]
nums.clear()
print(nums)
nums = [10, 3, 50, 3, 90]
nums = []
print(nums)

6.列表.copy() —> 复制列表中的元素，产生一个新的列表，将新列表的地址返回，赋值后两个不影响
和列表[:]的功能一模一样，都属于浅拷贝

heroes = ['后裔', '甄姬', '凯', '庄周']
heroes2 = heroes
del heroes2[-1]
print(heroes, heroes2)     # ['后裔', '甄姬', '凯'] ['后裔', '甄姬', '凯']

heroes = ['后裔', '甄姬', '凯', '庄周']
heroes2 = heroes.copy()
heroes2.reverse()
print(heroes, heroes2)      # ['后裔', '甄姬', '凯', '庄周'] ['庄周', '凯', '甄姬', '后裔']

7.列表.sort() -> 将列表中的元素从小到大排序(直接修改列表元素的顺序，不会产生心得列表)
列表.sort(reserse=True) -> 将列表中的元素从大到小排序(直接修改列表元素的顺序，不会产生心得列表)
列表.sort(reserse=True) 相当于 列表.scort;列表.reverse()。但前者性能更优

cores = [78, 89, 90, 56, 60, 99]
scores.sort()
print(scores)       # [56, 60, 78, 89, 90, 99]

scores = [78, 89, 90, 56, 60, 99]
scores.sort(reverse=True)
print(scores)       # [99, 90, 89, 78, 60, 56]

8.排序函数：sorted(序列) -> 不修改原序列，排序后，产生一个新的列表(升序)(无论哪种序列排序后都转换成列表)
sorted(序列，reverse=True) -> 不修改原序列，排序后，产生一个新的列表(降序)(无论哪种序列排序后都转换成列表)
reversed(序列) -> 将序列中的元素倒序，产生一个新的序列对应的迭代器

scores = [78, 89, 90, 56, 60, 99]
new_scores = sorted(scores)
print(scores)   # [78, 89, 90, 56, 60, 99]
print(new_scores)   # [56, 60, 78, 89, 90, 99]

三、元组

1.什么是元组(tuple)
元组就是不可变的列表
元组是容器型数据，将()作为容器标志，里面对各元素用逗号隔开：(元素1, 元素2, 元素3,...)
元组不可变(不支持增删改操作)，有序(支持下标操作)
元素可以是任何类型的数据
tuple1 = (1, 2, 3)

2.查
1)获取操作
列表获取元素的操作元组都支持

tuple2 = (10, 20, 30, 25)
print(tuple2[-1])  # 25
print(tuple2[1])  # 20
print(tuple2[2:])  # (30, 25)

2）相关运算：+、*、==、!=、is、in、not in、min、max、sum、sorted
都和list相同
tuple(数据) —— 将数转换成元组(数据必须是序列)

print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')

3.元组特有的操作或者频率偏高的操作
1）单个元素的元组
单个元素元组元素最后必须加逗号，比如tuple = (10,)

tuple3 = (10)
print(tuple3,type(tuple3))  # 10 <class 'int'>
tuple3 = (10,)
print(tuple3,type(tuple3))  # 10 <class 'tuple'>

2）单独使用的元组的值，()可以省略 -> 直接多个数据用逗号隔开，表示的还是一个元组

tuple4 = 10, 20, 30
print(tuple4, type(tuple4))  # (10, 20, 30) <class 'tuple'>

3）可以通过让变量的个数和元组中元素的个数保持一致来分别获取元组中的元素
变量1, 变量2, 变量3,... = 元组

tuple5 = (20, 30)
x, y = tuple5
print(x, y)     # 20 30
x, y = (20, 30) -> x, y = 20, 30

4）同时声明多个变量获取元组中的元素，变量的个数可以比元组中元素的个数少，但是这个时候
多个变量中的某一个变量的前面必须加""，带的变量可以获取不带*的变量获取完剩下的部分

tuple5 = (20, 30, 230, 50, 23, 40)
x1, x2, *x3 = tuple5
print(x1, x2, x3)  # 20 30 [230, 50, 23, 40]