一、序列

序列的概念：按照某种顺序排列的数据类型就叫做序列，比如字符串，列表，元组，集合

序列的共同点是都有下标，支持index()方法和count()，也支持切片处理(等同于字符串序列的切片处理)

l1 = [0, 1, 1, 2, 3, 4, 2, 4, 5]
print(l1.index(1))
print(l1.count(1))
print(l1[:3][::-1])
print(l1[::2])

二、列表（可变类型）

列表 表达符号使用中括号 [] 里面可以是数字，字符串，布尔类型，列表，元组，字典，集合...

# 定义空列表new_empty_list = list()
print(empty_list, new_empty_list)

列表是一个有序，并且元素可以重复的和可变动的元素类型

list1 = ['Apple', 'Orange', 'Grape']
list2 = ['Orange', 'Apple', 'Grape']
if list1 == list2:print("{}和{}相等".format(list1, list2))
else:print("{}和{}不相等".format(list1, list2))

1、列表元素的删除

pop方法

pop方法可以进行删除列表中的元素，默认删除最后一个索引位置的元素，删除并同时可以返回此元素，也可以指定下标索引去删除

list1 = ['Apple', 'Orange', 'Grape']print(list1.pop())
print(list1)
print(list1.pop(0))
print(list1)

remove()方法

remove()方法是指定元素去删除；

list1 = ['Apple', 'Orange', 'Grape','Durian']list1.remove('Durian')
print(list1)

del

也可以通过指定对应的下标元素值去删除 也可以针对变量进行删除 删除后就会报变量未定NameError: name 'xxxx' is not defined

list1 = ['Apple', 'Orange', 'Grape','Durian']del list1[1]
print(list1)

clear()方法

clear()方法是清空列表;

list1 = ['Apple', 'Orange', 'Grape','Durian']list1.clear()
print(list1)

2、列表元素的增加

1、append()方法

默认是添加元素到列表的末尾；

list1 = ['Apple', 'Orange', 'Grape']list1.append('Pear')
print(list1)

2、insert()方法 指定索引位置，在索引前面一个位置插入

list1 = ['Apple', 'Orange', 'Grape']list1.insert(1, 'Cherry')
print(list1)

3、extend()方法 是可以跟其他序列进行拼接 相当于+拼接

list1 = ['Apple', 'Orange', 'Grape']list3 = ['watermelon']
string1 = 'test'
list1.extend(list3)
print(list1)
print(list1 + list3)

# 字符串如果被使用这个extend方法添加到列表中，则先会把字符串拆分成列表，然后添加进去

list1 = ['Apple', 'Orange', 'Grape']list1.extend(string1)
print(list1)

3、列表元素的获取

list1 = ['Apple', 'Orange', 'Grape']
list2 = ['Orange', 'Apple', 'Grape']print(list1[-1], list1[2])

列表长度的获取

num_list = [1, 2, 3, 4, 5,]
print(len(num_list))

有几个元素，列表长度就为几

4、列表元素的修改

list2 = ['Orange', 'Apple', 'Grape']list1[2] = 'Durian'
print(list1)

5、列表元素的排序

sort()方法

sort()方法可以实现对列表元素进行排序 按照默认的由低到高的顺序排序；

num_list = [2, 1, 6, 3, 7, 9]
num_list.sort()
print(num_list)alpha_list = ['b', 'd', 'w', 'x', 'a', 'c']
alpha_list.sort()
print(alpha_list)

# # sort()方法的reverse参数可以实现反向输出，默认不加的话就是reverse=False（也就是关闭了反向输出），如果需要指定则照如下方式使用

num_list = [2, 1, 6, 3, 7, 9]
num_list.sort()
print(num_list)num_list.sort(reverse=True)
print(num_list)

reverse()方法

reverse()方法可以实现将列表元素反向输出；

num_list = [2, 1, 6, 3, 7, 9]num_list.reverse()
print(num_list)

总结：列表元素的反向输出有三种办法

list1 = ['Apple', 'Orange', 'Grape']
list2 = ['Orange', 'Apple', 'Grape']
num_list = [2, 1, 6, 3, 7, 9]# 1） 列表切片实现
print(num_list[::-1])
# 2)  reverse()方法
print(list2)
list2.reverse()
print(list2)
# 3) reversed()内置函数 返回序列给定的值的一个反向的迭代器 如果需要输出对应的数据类型 则需要使用对应的数方法进行转化
print(list(reversed(list2)))

6、列表元素的去重

not in

对num_list进行去重；

num_list = [1, 2, 3, 4, 5, 5, 4, 3]
empty_list = []
for i in num_list:if i not in empty_list:empty_list.append(i)
print(empty_list)

7、 列表元素的求值

列表元素的求和

digit_list = [3, 4, 5, 6]# 1) for循环求和
for_total = 0
for i in digit_list:for_total += i
print(for_total)

digit_list = [3, 4, 5, 6]# 2) while循环求和
while_total = 0
i = 0
while i < len(digit_list):while_total += digit_list[i]i += 1
print(while_total)

# 3) 使用sum函数实现
print(sum(digit_list))

列表元素的最大值，最小值

# 求列表最大值 求平均值的  求最小值的digit_list = [3, 4, 5, 6]
print(max(digit_list))
print(min(digit_list))

列表元素的平均值

# 1) statistics module,其中包含一个内置函数来计算数字的平均值或平均值statistics.mean() functio用于计算输入值或数据集的平均值/平均值。

digit_list = [3, 4, 5, 6]from statistics import mean
print(mean(digit_list))

# 2) 先求和再求平均值

digit_list = [3, 4, 5, 6]print(sum(digit_list) / len(digit_list))

# 3) NumPy 模块有一个内置函数来计算数据集或列表中存在的数据项的平均值/平均值。

digit_list = [3, 4, 5, 6]import numpy
print(numpy.average(digit_list))

8、 列表推导式/列表生成式

# 使用普通for循环创建一个1-10的一个列表

slist = []
for i in range(1,11):slist.append(i)
print(slist)

# 列表推导式语法：[exp1 for x in data if condition]

print([x*x for x in range(1, 11)])
print(sum([i for i in range(1,11)]))

9、列表的拷贝

浅拷贝

# 浅拷贝 深拷贝 针对可变序列 面试重点知识 需要记忆
"""
copy()方法是浅拷贝(shallow copy) 如果一个可变序列是多层次嵌套的值，则浅拷贝因为是浅层次的拷贝，所以拷贝后的对象浅层次的值不会随着之前的源对象
值改变而改变，而深层次的嵌套的值因为浅拷贝无法拷贝过去，也就是说拷贝的是源数据的一个引用，因此如果我们修改浅层次的数据，源数据不会更改，深层次数据
修改后，源数据也会修改 可以理解为深层次的数据是做了个软链接
"""

list3 = [1, 2, 3, ['a', 'b', 'c'], 5]
list4 = list3.copy()
print(id(list3), id(list4))
list4[0] = 0
list4[-2][0] = 'a1'
print(list3)
print(list4)

浅拷贝，不是完整的拷贝，他只能拷贝第一层的元素；

如果你是多层列表的话，他只能拷贝第一层元素，第二层元素他并没有拷贝，相当于做了一个引用，并不是真的拷贝走了，所以你在修改浅拷贝列表的第二层元素的时候，相当于在原列表上修改了；

# 这里发现浅拷贝深层次的子列表对象的内存地址值id是完全一样的 说明深层次只是做了个引用 无法实现创建新对象

print(id(list3[-2]))
print(id(list4[-2]))

深拷贝

list5 = deepcopy(list3)
print(list5)
list5[0] = 9
list5[3][1] = 'bag'
print(list3)
print(list5)

深拷贝，他就是完整的拷贝；

如果是多层列表的话，就拷贝走了整个列表，相当于创建了一个新的完整的的列表，所以你在新的列表上进行修改，是不会影响到原列表的；

# 这里发现深拷贝的深层次的子列表对象的内存地址值id是完全不一样的 说明实现创建了新对象

print(id(list3[-2]))
print(id(list5[-2]))