Python列表（超详细）
Python列表基础（完结）
列表= list。
整数类型int、浮点数类型float、字符串类型str、列表类型list、元组类型tuple、字典类型dict、集合类型set、布尔类型bool、复数类型complex。
a = 1 # 整数类型
print(a, type(a)) # 1
a = 1.1 # 浮点数类型
print(a, type(a)) # 1.1
a = "星期五" # 字符串类型
print(a, type(a)) # 星期五
a = [1, 1.1, "星期五", [1, 2], (1, 2)] # 列表类型
print(a, type(a)) # [1, 1.1, '星期五', [1, 2], (1, 2)]
a = (1, 1.1, "星期五", [1, 2], (1, 2)) # 元组类型
print(a, type(a)) # (1, 1.1, '星期五', [1, 2], (1, 2))
a = {1: "星期五", 2: "星期六"} # 字典类型
print(a, type(a)) # {1: '星期五', 2: '星期六'}
a = {1, 2, 3, 4, 5} # 集合类型
print(a, type(a)) # {1, 2, 3, 4, 5}
a = 12 + 0.2j # 复数类型
print(a, type(a)) # (12+0.2j) Python中的序列是一块可以存放多个值的连续内存空间。
# 字符串
x = "123"
print(x) # 123
# 列表
x = [1, 2, 3]
print(x) # [1, 2, 3]
# 元组
x = (1, 2, 3)
print(x) # (1, 2, 3)
# 字典
x = {1: "星期一", 2: "星期二"}
print(x) # {1: '星期一', 2: '星期二'}
# 集合
x = {1, 2, 3}
print(x) # {1, 2, 3}Python中的序列分为:字符串str、列表list、元组tuple、字典dict、集合set。
# 字符串
x = "123"
print(x) # 123
# 列表
x = [1, 2, 3]
print(x) # [1, 2, 3]
# 元组
x = (1, 2, 3)
print(x) # (1, 2, 3)
# 字典
x = {1: "星期一", 2: "星期二"}
print(x) # {1: '星期一', 2: '星期二'}
# 集合
x = {1, 2, 3}
print(x) # {1, 2, 3}Python中的序列分为:可变序列和不可变序列。
# 可变序列列表:list
a = [1, 2, 3, 4, 5]
print(a, id(a)) # [1, 2, 3, 4, 5] 2829704483008
a.append(6)
print(a, id(a)) # [1, 2, 3, 4, 5, 6] 2829704483008
# 可变序列字典:dict
a = {1: "星期一", 2: "星期二"}
print(a, id(a)) # {1: '星期一', 2: '星期二'} 2067298958400
a.update({3: "星期三"})
print(a, id(a)) # {1: '星期一', 2: '星期二', 3: '星期三'} 2067298958400
# 可变序列集合:set
a = {1, 2, 3, 4, 5}
print(a, id(a)) # {1, 2, 3, 4, 5} 1846846369888
a.update({6, 7, 8})
print(a, id(a)) # {1, 2, 3, 4, 5, 6, 7, 8} 1846846369888
# 不可变序列字符串:str
a = "星期五"
print(a, id(a)) # 星期五 2017509557712
a = "星期六"
print(a, id(a)) # 星期六 2017509055664
# 不可变序列元组:tuple
a = (1, 2, 3, 4, 5)
print(a, id(a)) # (1, 2, 3, 4, 5) 2905462829392
a = (6, 7, 8, 9, 10)
print(a, id(a)) # (6, 7, 8, 9, 10) 2905463836960可变序列分为:列表list、字典dict、集合set（可变数据类型自带添加元素的方法）。
# 可变序列:list
a = [1, 2, 3, 4, 5]
print(a, id(a)) # [1, 2, 3, 4, 5] 2829704483008
a.append(6)
print(a, id(a)) # [1, 2, 3, 4, 5, 6] 2829704483008
# 可变序列:dict
a = {1: "星期一", 2: "星期二"}
print(a, id(a)) # {1: '星期一', 2: '星期二'} 2067298958400
a.update({3: "星期三"})
print(a, id(a)) # {1: '星期一', 2: '星期二', 3: '星期三'} 2067298958400
# 可变序列:set
a = {1, 2, 3, 4, 5}
print(a, id(a)) # {1, 2, 3, 4, 5} 1846846369888
a.update({6, 7, 8})
print(a, id(a)) # {1, 2, 3, 4, 5, 6, 7, 8} 1846846369888不可变序列分为:字符串str、元组tuple（不可变数据类型没有添加元素的方法）。
# 不可变序列:str
a = "星期五"
print(a, id(a)) # 星期五 2017509557712
a = "星期六"
print(a, id(a)) # 星期六 2017509055664
# 不可变序列:tuple
a = (1, 2, 3, 4, 5)
print(a, id(a)) # (1, 2, 3, 4, 5) 2905462829392
a = (6, 7, 8, 9, 10)
print(a, id(a)) # (6, 7, 8, 9, 10) 2905463836960可变序列:是指变量的值发生变化时，其对应的内存地址不会跟着发生变化（可变数据类型自带添加元素的方法）。
# 可变序列:list
a = [1, 2, 3, 4, 5]
print(a, id(a)) # [1, 2, 3, 4, 5] 2829704483008
a.append(6)
print(a, id(a)) # [1, 2, 3, 4, 5, 6] 2829704483008
# 可变序列:dict
a = {1: "星期一", 2: "星期二"}
print(a, id(a)) # {1: '星期一', 2: '星期二'} 2067298958400
a.update({3: "星期三"})
print(a, id(a)) # {1: '星期一', 2: '星期二', 3: '星期三'} 2067298958400
# 可变序列:set
a = {1, 2, 3, 4, 5}
print(a, id(a)) # {1, 2, 3, 4, 5} 1846846369888
a.update({6, 7, 8})
print(a, id(a)) # {1, 2, 3, 4, 5, 6, 7, 8} 1846846369888不可变序列:是指变量的值发生变化时，其对应的内存地址也会跟着发生变化（不可变数据类型没有添加元素的方法）。
# 不可变序列:str
a = "星期五"
print(a, id(a)) # 星期五 2017509557712
a = "星期六"
print(a, id(a)) # 星期六 2017509055664
# 不可变序列:tuple
a = (1, 2, 3, 4, 5)
print(a, id(a)) # (1, 2, 3, 4, 5) 2905462829392
a = (6, 7, 8, 9, 10)
print(a, id(a)) # (6, 7, 8, 9, 10) 2905463836960输入dir(list)或dir([])查看列表中的所有方法。
print(dir(list))
print(dir([]))可以使用列表将多个值同时存储在一个变量中。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2)]如果把数组比作一个集装箱的话，那么Python的列表就是一个工厂的仓库。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2)]创建列表非常简单，用中括号括起一堆数据就可以了，数据之间用逗号隔开。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2)]可以创建一个鱼龙混杂的列表，可以创建一个空列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2)]
x = []
print(x) # []可以使用list()函数创建一个列表。
x = list([1, 2, 3])
print(x) # [1, 2, 3]可以使用list()函数将其它序列转换成列表。
# 将字符串转换成列表
x = "123"
print(list(x)) # ['1', '2', '3']
# 将列表转换成列表
x = [1, 2, 3]
print(list(x)) # [1, 2, 3]
# 将元组转换成列表
x = (1, 2, 3)
print(list(x)) # [1, 2, 3]
# 将字典转换成列表
x = {1: "星期一", 2: "星期二"}
print(list(x)) # [1, 2]
# 将集合转换成列表
x = {1, 2, 3}
print(list(x)) # [1, 2, 3]可以使用for循环和while循环遍历列表（遍历序列经常使用for循环）。
# 使用for循环遍历列表
x = [1, 2, 3]
for i in x:
print(i)
# 使用while循环遍历列表
x = [1, 2, 3]
y = 0
while y < len(x):
print(x[y])
y += 1加号+和乘号*也可以运用到列表中，但是加号+和乘号*并没有改变原来的列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = [3, 4]
# 加号的使用
print(x+y) # [1, 1.1, '星期五', [1, 2], (1, 2), 3, 4]
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2)]
# 乘号的使用
print(y*3) # [3, 4, 3, 4, 3, 4]
print(y) # [3, 4]在Python中，两个相同的可变序列的内存地址是不同的。
# 可变序列:列表
a1, a2 = [1, 2, 3], [1, 2, 3]
print(a1 is a2) # False
print([1, 2, 3] is [1, 2, 3]) # False
# 可变序列:字典
a1, a2 = {1: "星期一", 2: "星期二"}, {1: "星期一", 2: "星期二"}
print(a1 is a2) # False
print({1: "星期一", 2: "星期二"} is {1: "星期一", 2: "星期二"}) # False
# 可变序列:集合
a1, a2 = {1, 2, 3}, {1, 2, 3}
print(a1 is a2) # False
print({1, 2, 3} is {1, 2, 3}) # False在Python中，两个相同的不可变序列的内存地址是相同的。
# 不可变序列:整数
a1, a2 = 10, 10
print(a1 is a2) # True
# 不可变序列:字符串
a1, a2 = "星期五", "星期五"
print(a1 is a2) # True
# 不可变序列:元组
a1, a2 = (1, 2, 3), (1, 2, 3)
print(a1 is a2) # True在身份运算符中，不可变序列只能对变量做判断，可变序列既可以对变量做判断，也可以对值做判断。
# 不可变序列:整数
a1, a2 = 10, 10
print(a1 is a2) # True
print(a1 is not a2) # False
# print(10 is 10) # 报错
# 不可变序列:字符串
a1, a2 = "星期五", "星期五"
print(a1 is a2) # True
print(a1 is not a2) # False
# print("星期五" is "星期五") # 报错
# 不可变序列:元组
a1, a2 = (1, 2, 3), (1, 2, 3)
print(a1 is a2) # True
print(a2 is not a2) # False
# print((1, 2, 3) is (1, 2, 3)) # 报错
# 可变序列:列表
a1, a2 = [1, 2, 3], [1, 2, 3]
print(a1 is a2) # False
print(a1 is not a2) # True
print([1, 2, 3] is [1, 2, 3]) # False
print([1, 2, 3] is not [1, 2, 3]) # True
# 可变序列:字典
a1, a2 = {1: "星期一", 2: "星期二"}, {1: "星期一", 2: "星期二"}
print(a1 is a2) # False
print(a1 is not a2) # True
print({1: "星期一", 2: "星期二"} is {1: "星期一", 2: "星期二"}) # False
print({1: "星期一", 2: "星期二"} is not {1: "星期一", 2: "星期二"}) # True
# 可变序列:集合
a1, a2 = {1, 2, 3}, {1, 2, 3}
print(a1 is a2) # False
print(a1 is not a2) # True
print({1, 2, 3} is {1, 2, 3}) # False
print({1, 2, 3} is not {1, 2, 3}) # True使用is关键字判断两个列表是否引用同一个id，是返回True，不是返回False。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x is y) # False
print([1, 1.1, "星期五", [1, 2], (1, 2)] is [1, 1.1, "星期五", [1, 2], (1, 2)]) # False使用is not关键字判断两个变量是否引用不同id，是返回True，不是返回False。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x is not y) # True
print([1, 1.1, "星期五", [1, 2], (1, 2)] is not[1, 1.1, "星期五", [1, 2], (1, 2)]) # True使用in关键字判断左边的值是否包含在右边的列表中，包含返回True，不包含返回False。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print("星期五" in x) # True
print([1, 2] in x) # True使用not in关键字判断左边的值是否不包含在右边的列表中，不包含返回True，包含返回False。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print("星期五" not in x) # False
print([1, 2] not in x) # FalsePython列表 append()方法（完结）
向列表中添加元素有四种方法:append()、extend()、insert()、+=。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]
x += [1, 2]
print(x) # [[1, 2], [1, 2], 1, 2, 1, 2]使用append()方法向列表末尾添加一个元素或添加一个序列。
x = []
x.append(1)
print(x) # [1]
x.append("星期五")
print(x) # [1, '星期五']
x.append([2, 3])
print(x) # [1, '星期五', [2, 3]]
x.append((4, 5))
print(x) # [1, '星期五', [2, 3], (4, 5)]
x.append({1: "星期五"})
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期五'}]
x.append({6, 7})
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期五'}, {6, 7}]
x.append(None)
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期五'}, {6, 7}, None]append()方法不返回值，但更新列表。
x = []
y = x.append(1)
print(y) # None
print(x.append(2)) # None
print(x) # [1, 2]因为append()方法没有产生值，所以不能将append()方法赋给一个变量，不能使用print()函数将append()方法直接输出。
x = []
y = x.append(1)
print(y) # None
print(x.append(2)) # None
print(x) # [1, 2]使用append()方法和insert()方法添加元素时，既可以添加单个元素，也可以添加序列，使用extend()方法添加元素时，只能添加序列，不能添加单个元素。
x = []
x.append([1, 2])
x.append(1)
print(x) # [[1, 2], 1]
x.insert(len(x), [1, 2])
x.insert(len(x), 1)
print(x) # [[1, 2], 1, [1, 2], 1]
x.extend([1, 2])
print(x) # [[1, 2], 1, [1, 2], 1, 1, 2]append()方法和insert()方法是将整个序列添加进去，extend()方法是将序列拆分后一个元素一个元素的添加进去。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]浅拷贝:拷贝这个对象的内存地址，原对象发生变化，浅拷贝的新对象也会跟着发生变化。
x = []
y = x
x.append("星期五")
print(y) # ['星期五']深拷贝:拷贝这个对象的全部内容，原对象发生变化，深拷贝的新对象不会跟着发生变化。
x = []
y = x.copy()
x.append("星期五")
print(x) # ['星期五']
print(y) # []append()方法和insert()方法添加序列时，使用的是浅拷贝，使用extend()方法添加序列时，使用的是深拷贝。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]使用append()方法和insert()方法添加序列时，添加的是内存地址，而不是实际的值，如果原序列发生变化，添加进去的序列也会跟着发生变化，使用extend()方法添加序列时，添加的是全部内容，如果原序列发生变化添加进去的序列不会跟着发生变化（涉及到了浅拷贝和深拷贝）。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]Python列表 extend()方法（完结）
向列表中添加元素有四种方法:append()、extend()、insert()、+=。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]
x += [1, 2]
print(x) # [[1, 2], [1, 2], 1, 2, 1, 2]使用extend()方法向列表末尾添加多个元素，它的参数必须是一个序列。
x = []
x.extend("星期五") # 字符串
print(x) # ['星', '期', '五']
x.extend([5, 6]) # 列表
print(x) # ['星', '期', '五', 5, 6]
x.extend((7, 8)) # 元组
print(x) # ['星', '期', '五', 5, 6, 7, 8]
x.extend({1: "星期一", 2: "星期二"}) # 字典
print(x) # ['星', '期', '五', 5, 6, 7, 8, 1, 2]
x.extend({9, 10}) # 集合
print(x) # ['星', '期', '五', 5, 6, 7, 8, 1, 2, 9, 10]extend()方法不返回值，但更新列表。
x = []
y = x.extend([1, 2])
print(y) # None
print(x.extend([3, 4])) # None
print(x) # [1, 2, 3, 4]因为extend()方法没有产生值，所以不能将extend()方法赋给一个变量，不能使用print()函数将extend()方法直接输出。
x = []
y = x.extend([1, 2])
print(y) # None
print(x.extend([3, 4])) # None
print(x) # [1, 2, 3, 4]使用append()方法和insert()方法添加元素时，既可以添加单个元素，也可以添加序列，使用extend()方法添加元素时，只能添加序列，不能添加单个元素。
x = []
x.append([1, 2])
x.append(1)
print(x) # [[1, 2], 1]
x.insert(len(x), [1, 2])
x.insert(len(x), 1)
print(x) # [[1, 2], 1, [1, 2], 1]
x.extend([1, 2])
print(x) # [[1, 2], 1, [1, 2], 1, 1, 2]append()方法和insert()方法是将整个序列添加进去，extend()方法是将序列拆分后一个元素一个元素的添加进去。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]浅拷贝:拷贝这个对象的内存地址，原对象发生变化，浅拷贝的新对象也会跟着发生变化。
x = []
y = x
x.append("星期五")
print(y) # ['星期五']深拷贝:拷贝这个对象的全部内容，原对象发生变化，深拷贝的新对象不会跟着发生变化。
x = []
y = x.copy()
x.append("星期五")
print(x) # ['星期五']
print(y) # []append()方法和insert()方法添加序列时，使用的是浅拷贝，使用extend()方法添加序列时，使用的是深拷贝。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]使用append()方法和insert()方法添加序列时，添加的是内存地址，而不是实际的值，如果原序列发生变化，添加进去的序列也会跟着发生变化，使用extend()方法添加序列时，添加的是全部内容，如果原序列发生变化添加进去的序列不会跟着发生变化（涉及到了浅拷贝和深拷贝）。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]+=与extend()方法实现的效果是一样的。
x = []
x += "星期五" # 字符串
print(x) # ['星', '期', '五']
x += [5, 6] # 列表
print(x) # ['星', '期', '五', 5, 6]
x += (7, 8) # 元组
print(x) # ['星', '期', '五', 5, 6, 7, 8]
x += {1: "星期一", 2: "星期二"} # 字典
print(x) # ['星', '期', '五', 5, 6, 7, 8, 1, 2]
x += {9, 10} # 集合
print(x) # ['星', '期', '五', 5, 6, 7, 8, 1, 2, 9, 10]Python列表 insert()方法（完结）
向列表中添加元素有四种方法:append()、extend()、insert()、+=。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]
x += [1, 2]
print(x) # [[1, 2], [1, 2], 1, 2, 1, 2]使用insert()方法向列表中指定的位置插入指定的元素，它有两个参数第一个参数代表要插入的位置，第二个参数代表要插入的元素。
x = []
x.insert(0, 1) # 整数
print(x) # [1]
x.insert(1, "星期五") # 字符串
print(x) # [1, '星期五']
x.insert(2, [2, 3]) # 列表
print(x) # [1, '星期五', [2, 3]]
x.insert(3, (4, 5)) # 元组
print(x) # [1, '星期五', [2, 3], (4, 5)]
x.insert(4, {1: "星期一", 2: "星期二"}) # 字典
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期一', 2: '星期二'}]
x.insert(5, {10, 11}) # 集合
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期一', 2: '星期二'}, {10, 11}]
x.insert(6, None) # None
print(x) # [1, '星期五', [2, 3], (4, 5), {1: '星期一', 2: '星期二'}, {10, 11}, None]insert()方法不返回值，但更新列表。
x = []
y = x.insert(0, 1)
print(y) # None
print(x.insert(1, [2, 3])) # None
print(x) # [1, [2, 3]]因为insert()方法没有产生值，所以不能将insert()方法赋给一个变量，不能使用print()函数将insert()方法直接输出。
x = []
y = x.insert(0, 1)
print(y) # None
print(x.insert(1, [2, 3])) # None
print(x) # [1, [2, 3]]使用append()方法和insert()方法添加元素时，既可以添加单个元素，也可以添加序列，使用extend()方法添加元素时，只能添加序列，不能添加单个元素。
x = []
x.append([1, 2])
x.append(1)
print(x) # [[1, 2], 1]
x.insert(len(x), [1, 2])
x.insert(len(x), 1)
print(x) # [[1, 2], 1, [1, 2], 1]
x.extend([1, 2])
print(x) # [[1, 2], 1, [1, 2], 1, 1, 2]append()方法和insert()方法是将整个序列添加进去，extend()方法是将序列拆分后一个元素一个元素的添加进去。
x = []
x.append([1, 2])
print(x) # [[1, 2]]
x.insert(1, [1, 2])
print(x) # [[1, 2], [1, 2]]
x.extend([1, 2])
print(x) # [[1, 2], 1, 2]浅拷贝:拷贝这个对象的内存地址，原对象发生变化，浅拷贝的新对象也会跟着发生变化。
x = []
y = x
x.append("星期五")
print(y) # ['星期五']深拷贝:拷贝这个对象的全部内容，原对象发生变化，深拷贝的新对象不会跟着发生变化。
x = []
y = x.copy()
x.append("星期五")
print(x) # ['星期五']
print(y) # []append()方法和insert()方法添加序列时，使用的是浅拷贝，使用extend()方法添加序列时，使用的是深拷贝。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]使用append()方法和insert()方法添加序列时，添加的是内存地址，而不是实际的值，如果原序列发生变化，添加进去的序列也会跟着发生变化，使用extend()方法添加序列时，添加的是全部内容，如果原序列发生变化添加进去的序列不会跟着发生变化（涉及到了浅拷贝和深拷贝）。
x = []
y = [1, 2]
x.append(y)
print(x) # [[1, 2]]
y.append(3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.insert(1, y)
print(x) # [[1, 2]]
y.insert(2, 3)
print(x) # [[1, 2, 3]]
x = []
y = [1, 2]
x.extend([1, 2])
print(x) # [1, 2]
y.extend([3])
print(x) # [1, 2]insert()方法和len()函数可以搭配在一起。
# 方法1
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.insert(len(x), "星期六")
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2), '星期六']
# 方法2
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.insert(99, "星期六")
print(x) # [1, 1.1, '星期五', [1, 2], (1, 2), '星期六']Python列表 remove()方法（完结）
删除列表中的元素有三种方法:remove()、del、pop()。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
del x[0]
print(x) # ['星期五', [1, 2], (1, 2)]
y = x.pop()
print(y) # (1, 2)使用remove()方法删除列表中指定的元素，你并不需要知道该元素在列表中的具体位置，只需要知道它存在列表中就可以了，如果要删除的元素不存在则会报错。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.remove("星期五")
print(x) # [1, 1.1, [1, 2], (1, 2)]
x.remove(2)
print(x) # 报错remove()方法不返回值，但更新列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.remove(1)
print(y) # None
print(x.remove("星期五")) # None
print(x) # [1.1, [1, 2], (1, 2)]因为remove()方法没有产生值，所以不能将remove()方法赋给一个变量，不能直接使用print()函数将remove()方法输出。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.remove(1)
print(y) # None
print(x.remove("星期五")) # None
print(x) # [1.1, [1, 2], (1, 2)]如果列表中有多个相同的元素，remove()方法只会删除第一个元素。
x = [1, 2, 1]
x.remove(1)
print(x) # [2, 1]可以使用for循环和remove()方法删除列表中多个相同的元素。
x = [1, 2, 1, 3, 1]
for i in x:
if i == 1:
x.remove(1)
print(x) # [2, 3]del关键字和remove()方法只更新列表不返回值，pop()方法即更新列表又返回弹出的值。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)如果要从列表中删除一个元素，并且不在以任何方式使用它就使用del关键字和remove()方法，如果要从列表中删除一个元素，且还要继续使用它就使用pop()方法。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)Python列表 del关键字（完结）
删除列表中的元素有三种方法:remove()、del、pop()。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
del x[0]
print(x) # ['星期五', [1, 2], (1, 2)]
y = x.pop()
print(y) # (1, 2)可以使用del关键字删除列表中任意位置的元素，可以使用del关键字删除整个列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x
print(x) # 列表不存在所以报错del关键字不返回值，但更新列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = del x[0]
print(y) # 报错
print(del x[1]) # 报错因为del是关键字，所以不能将del赋给一个变量，不能直接使用print()函数将del输出。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = del x[0]
print(y) # 报错
print(del x[1]) # 报错del关键字和remove()方法只更新列表不返回值，pop()方法即更新列表又返回弹出的值。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)如果要从列表中删除一个元素，并且不在以任何方式使用它就使用del关键字和remove()方法，如果要从列表中删除一个元素，且还要继续使用它就使用pop()方法。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)使用del关键字删除原列表，浅拷贝的新列表不会跟着删除。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x
del x
print(y) # [1, 1.1, '星期五', [1, 2], (1, 2)]
print(x) # 报错使用del关键字删除原列表，深拷贝的新列表不会跟着删除。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.copy()
del x
print(y) # [1, 1.1, '星期五', [1, 2], (1, 2)]
print(x) # 报错Python列表 pop()方法（完结）
删除列表中的元素有三种方法:remove()、del、pop()。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
del x[0]
print(x) # ['星期五', [1, 2], (1, 2)]
y = x.pop()
print(y) # (1, 2)使用pop()方法弹出列表中最后一个元素，当你为它加上一个索引的时候它会弹出这个索引对应的元素。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.pop()
print(x) # [1, 1.1, '星期五', [1, 2]]
x.pop(0)
print(x) # [1.1, '星期五', [1, 2]]使用pop()方法时，如果没有在括号里面加上索引值，Python默认括号里面的索引值为-1，这就是为什么pop()方法总是弹出最后一个元素的原因。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.pop()
print(x) # [1, 1.1, '星期五', [1, 2]]
x.pop(0)
print(x) # [1.1, '星期五', [1, 2]]pop()方法即返回弹出的值，又更新列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.pop(0)
print(y) # 1
print(x.pop(1)) # 星期五
print(x) # [1.1, [1, 2], (1, 2)]del关键字和remove()方法只更新列表不返回值，pop()方法即更新列表又返回弹出的值。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)如果要从列表中删除一个元素，并且不在以任何方式使用它就使用del关键字和remove()方法，如果要从列表中删除一个元素，且还要继续使用它就使用pop()方法。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
del x[0]
print(x) # [1.1, '星期五', [1, 2], (1, 2)]
y = x.remove(1.1)
print(y) # None
y = x.pop()
print(y) # (1, 2)Python列表 count()方法（完结）
使用count()方法计算它的参数在列表中出现的次数。
x = [1, 2, 1, 2, 1, 2]
y = x.count(1)
print(y) # 3
print(x.count(2)) # 3count()方法只返回值，不更新列表，但是必须要接收返回的值。
x = [1, 2, 1, 2, 1, 2]
y = x.count(1)
print(y) # 3
print(x.count(2)) # 3在列表中count()方法只有一个参数，在字符串中count()方法有三个参数。
x = [1, 2, 1, 2, 1, 2]
y = x.count(1)
print(y) # 3
print(x.count(2)) # 3
x = "121212"
y = x.count("1", 0, 3)
print(y) # 2
print(x.count("1", 2, 4)) # 1Python列表 index()方法（完结）
使用index()方法计算它的参数在列表中出现的位置。
x = [1, 2, 1, 2, 1, 2]
y = x.index(1)
print(y) # 0
print(x.index(2)) # 1使用index()方法时，如果列表中有相同的元素，只会返回相同元素的第一个元素的索引。
x = [1, 2, 1, 2, 1, 2]
y = x.index(1)
print(y) # 0
print(x.index(2)) # 1index()方法只返回值，不更新列表，但是必须要接收返回的值。
x = [1, 2, 1, 2, 1, 2]
y = x.index(1)
print(y) # 0
print(x.index(2)) # 1在列表中index()方法有三个参数，在字符串中index()方法有三个参数。
x = [1, 2, 1, 2, 1, 2]
y = x.index(1, 0, 3)
print(y) # 0
print(x.index(2, 2, 4)) # 3
x = "121212"
y = x.index("1", 0, 3)
print(y) # 0
print(x.index("2", 2, 4)) # 3Python列表 sort()方法（完结）
sort(key=None,reverse=False)方法有两个参数:key和reverse。
语法:sort(*, key=None,reverse=False)使用sort()方法，对列表进行排序，默认从小到大排序。
x = [5, 1, 4, 2, 3]
x.sort()
print(x) # [1, 2, 3, 4, 5]sort()方法不返回值，但更新列表。
x = [5, 1, 4, 2, 3]
y = x.sort()
print(y) # None
print(x.sort()) # None
print(x) # [1, 2, 3, 4, 5]因为sort()方法没有产生值，所以不能将sort()方法赋给一个变量，不能使用print()函数将sort()方法直接输出。
x = [5, 1, 4, 2, 3]
y = x.sort()
print(y) # None
print(x.sort()) # None
print(x) # [1, 2, 3, 4, 5]一维序列和二维序列中的排序元素必须是同一数据类型，否则会报错。
# 一维序列
x = [2, 1, 3, 4]
x.sort()
print(x) # [1, 2, 3, 4]
# 二维序列
x = [[3, 2, 1], [1, 2, 3], [2, 3, 4]]
x.sort()
print(x) # [[1, 2, 3], [2, 3, 4], [3, 2, 1]]
x = [["a", 1, 2], ["b", 3, 4], ["c", 5, 6]]
x.sort()
print(x) # [['a', 1, 2], ['b', 3, 4], ['c', 5, 6]]
x = [["a", 2, 3], [1, "b", 3], [2, 3, "b"]]
x.sort()
print(x) # 报错在列表中多个字符串之间也可以进行排序，是根据ASCII码值的大小进行排序，默认是从第一个字符开始比较，只要有一个PK赢了就算整个字符串赢了。
x = ["c", "b", "a"]
x.sort()
print(x) # ['a', 'b', 'c']
x = ["abc", "aba", "abb"]
x.sort()
print(x) # ['aba', 'abb', 'abc']
x = ["1abc", "3abc", "2abc"]
x.sort()
print(x) # ['1abc', '2abc', '3abc']在列表中多个列表之间也可以进行排序，默认是从第一个字符开始比较，只要有一个PK赢了就算整个列表赢了。
x = [[3, 2, 1], [1, 2, 3], [2, 3, 4]]
x.sort()
print(x) # [[1, 2, 3], [2, 3, 4], [3, 2, 1]]
x = [["a", 1, 2], ["b", 3, 4], ["c", 5, 6]]
x.sort()
print(x) # [['a', 1, 2], ['b', 3, 4], ['c', 5, 6]]
x = [["a", 2, 3], [1, "b", 3], [2, 3, "b"]]
x.sort()
print(x) # 报错在列表中多个元组之间也可以进行排序，默认是从第一个字符开始比较，只要有一个PK赢了就算整个元组赢了。
x = [(3, 2, 1), (1, 2, 3), (2, 3, 4)]
x.sort()
print(x) # [(1, 2, 3), (2, 3, 4), (3, 2, 1)]
x = [("a", 1, 2), ("b", 3, 4), ("c", 5, 6)]
x.sort()
print(x) # [('a', 1, 2), ('b', 3, 4), ('c', 5, 6)]
x = [("a", 2, 3), (1, "b", 3), (2, 3, "b")]
x.sort()
print(x) # 报错在列表中多个字典和集合之间不能进行排序，因为字典和集合都是无序的。
x = [{1, 2}, {5, 6}, {3, 4}]
x.sort()
print(x) # [{1, 2}, {5, 6}, {3, 4}]
x = [{2: "星期二"}, {1: "星期一"}]
x.sort()
print(x) # 报错key通常用于指定从二维序列中的第几个字符开始比较。
def x(y):
return y[1] # 索引为1，表示从第二个元素开始比较
a = ["abc", "cab", "acb"]
a.sort(key=x)
print(a) # ['cab', 'abc', 'acb']
def x(y):
return y[0] # 索引为0，表示从第一个元素开始比较
a = [[1, "星期一"], [3, "星期三"], [2, "星期二"]]
a.sort(key=x)
print(a) # [[1, '星期一'], [2, '星期二'], [3, '星期三']]key后面跟的是一个函数，表示从列表中依次取出二维序列，并将其传入到函数的形参中，最后通过返回值返回某个位置的元素，接着执行reverse=False进行从小到大排序。
def x(y):
return y[1] # 索引为1，表示从第二个元素开始比较
a = ["abc", "cab", "acb"]
a.sort(key=x)
print(a) # ['cab', 'abc', 'acb']
def x(y):
return y[0] # 索引为0，表示从第一个元素开始比较
a = [[1, "星期一"], [3, "星期三"], [2, "星期二"]]
a.sort(key=x)
print(a) # [[1, '星期一'], [2, '星期二'], [3, '星期三']]key和lambda函数经常搭配在一起。
a = [[1, "星期一"], [3, "星期三"], [2, "星期二"]]
a.sort(key=lambda x: x[0])
print(a) # [[1, '星期一'], [2, '星期二'], [3, '星期三']]key=len表示按字符串的长度进行排序，默认从小到大排序。
x = ["aa", "aaaa", "aaa"]
x.sort(key=len)
print(x) # ['aa', 'aaa', 'aaaa']reverse=True:表示从大到小排序。
x = [1, 3, 5, 4, 2]
x.sort(reverse=True)
print(x) # [5, 4, 3, 2, 1]reverse=False:表示从小到大排序。
x = [1, 3, 5, 4, 2]
x.sort(reverse=False)
print(x) # [1, 2, 3, 4, 5]Python列表 reverse()方法（完结）
使用reverse()方法，将整个列表原地翻转。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
x.reverse()
print(x) # [(1, 2), [1, 2], '星期五', 1.1, 1]reverse()方法不返回值，但更新列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.reverse()
print(y) # None
print(x) # [(1, 2), [1, 2], '星期五', 1.1, 1]
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x.reverse()) # None
print(x) # [(1, 2), [1, 2], '星期五', 1.1, 1]因为reverse()方法没有产生值，所以不能将reverse()方法赋给一个变量，不能使用print()函数将reverse()方法直接输出。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.reverse()
print(y) # None
print(x) # [(1, 2), [1, 2], '星期五', 1.1, 1]
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
print(x.reverse()) # None
print(x) # [(1, 2), [1, 2], '星期五', 1.1, 1]Python列表 copy()方法（完结）
使用copy()方法拷贝一个列表，并将拷贝的列表赋给一个变量（copy()是深拷贝）。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.copy()
print(y) # [1, 1.1, '星期五', [1, 2], (1, 2)]
print(x.copy()) # [1, 1.1, '星期五', [1, 2], (1, 2)]copy()方法只返回值，不更新列表。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.copy()
print(y) # [1, 1.1, '星期五', [1, 2], (1, 2)]
print(x.copy()) # [1, 1.1, '星期五', [1, 2], (1, 2)]因为copy()方法只返回值，所以需要使用一个变量去接收这个返回的值。
x = [1, 1.1, "星期五", [1, 2], (1, 2)]
y = x.copy()
print(y) # [1, 1.1, '星期五', [1, 2], (1, 2)]
print(x.copy()) # [1, 1.1, '星期五', [1, 2], (1, 2)]浅拷贝:拷贝这个对象的内存地址，原对象发生变化，浅拷贝的新对象也会跟着发生变化。
x = []
y = x
x.append("星期五")
print(y) # ['星期五']深拷贝:拷贝这个对象的全部内容，原对象发生变化，深拷贝的新对象不会跟着发生变化。
x = []
y = x.copy()
x.append("星期五")
print(x) # ['星期五']
print(y) # []Python索引（完结）
序列中的每一个元素都对应着一个索引值，通过索引值就可以访问序列中的单个元素，字典和集合除外。
x = "你好星期五"
print(x[0]) # 你
print(x[4]) # 五
x = ["星期一", "星期二", "星期三"]
print(x[0]) # 星期一
print(x[2]) # 星期三
x = ("星期一", "星期二", "星期三")
print(x[0]) # 星期一
print(x[2]) # 星期三因为字典和集合都是无序的，所以它们不支持索引、切片、相加、相乘等操作。
x = "你好星期五"
print(x[0]) # 你
print(x[4]) # 五
x = ["星期一", "星期二", "星期三"]
print(x[0]) # 星期一
print(x[2]) # 星期三
x = ("星期一", "星期二", "星期三")
print(x[0]) # 星期一
print(x[2]) # 星期三索引分为正数索引和负数索引。
x = "你好星期五"
print(x[0]) # 你
print(x[-1]) # 五
x = ["星期一", "星期二", "星期三"]
print(x[0]) # 星期一
print(x[-1]) # 星期三
x = ("星期一", "星期二", "星期三")
print(x[0]) # 星期一
print(x[-1]) # 星期三Python中的正数索引都是从0开始，执行顺序从左往右。
# 正数索引
x = "你好星期五"
print(x[0]) # 你
print(x[4]) # 五
x = ["星期一", "星期二", "星期三"]
print(x[0]) # 星期一
print(x[2]) # 星期三
x = ("星期一", "星期二", "星期三")
print(x[0]) # 星期一
print(x[2]) # 星期三Python中的负数索引都是从-1开始，执行顺序从右往左。
# 负数索引
x = "你好星期五"
print(x[-1]) # 五
print(x[-5]) # 你
x = ["星期一", "星期二", "星期三"]
print(x[-1]) # 星期三
print(x[-3]) # 星期一
x = ("星期一", "星期二", "星期三")
print(x[-1]) # 星期三
print(x[-3]) # 星期一在索引和切片中0和-1跟数学中的0和-1有所不同，在Python中0前面并不是-1,0和-1是分开的。
通过将索引指定为-1可以让Python返回序列中最后一个元素。
x = "你好星期五"
print(x[-1]) # 五
x = ["星期一", "星期二", "星期三"]
print(x[-1]) # 星期三
x = ("星期一", "星期二", "星期三")
print(x[-1]) # 星期三Python切片（完结）
切片有三个参数:start参数、end参数、step参数。
语法:变量[start,end,step]如果需要从序列中一次性获取多个元素，可以使用切片，字典和集合除外。
x = "你好星期五"
print(x[0:5]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')因为字典和集合都是无序的，所以它们不支持索引、切片、相加、相乘等操作。
x = "你好星期五"
print(x[0:5]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')start参数代表开始位置，如果没有开始位置，Python会默认开始位置为0。
x = "你好星期五"
print(x[0:5]) # 你好星期五
print(x[:5]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
print(x[:3]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')
print(x[:3]) # ('星期一', '星期二', '星期三')end参数代表结束位置，如果没有结束位置，Python会得到从指定索引值开始到序列末尾的所有元素。
x = "你好星期五"
print(x[0:5]) # 你好星期五
print(x[0:]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
print(x[0:]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')
print(x[0:]) # ('星期一', '星期二', '星期三')step参数代表步长，不指定它的时候默认为1。
x = "你好星期五"
print(x[0:5]) # 你好星期五
print(x[0:5:1]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
print(x[0:3:1]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')
print(x[0:3:1]) # ('星期一', '星期二', '星期三')切片只返回值，不更新列表。
x = "你好星期五"
y = x[0:5]
print(y) # 你好星期五
print(x[0:]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
y = x[0:3]
print(y) # ['星期一', '星期二', '星期三']
print(x[0:]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
y = x[0:3]
print(y) # ('星期一', '星期二', '星期三')
print(x[0:]) # ('星期一', '星期二', '星期三')因为切片只返回值，所以需要使用一个变量去接收这个返回的值。
x = "你好星期五"
y = x[0:5]
print(y) # 你好星期五
print(x[0:]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
y = x[0:3]
print(y) # ['星期一', '星期二', '星期三']
print(x[0:]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
y = x[0:3]
print(y) # ('星期一', '星期二', '星期三')
print(x[0:]) # ('星期一', '星期二', '星期三')在使用切片时，序列中有多少个元素，结束位置就是多少。
x = "你好星期五"
print(x[0:5]) # 你好星期五
print(x[0:]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3]) # ['星期一', '星期二', '星期三']
print(x[0:]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3]) # ('星期一', '星期二', '星期三')
print(x[0:]) # ('星期一', '星期二', '星期三')如果在切片中没有放入任何索引值只有一个冒号或两个冒号:将得到整个序列的深拷贝。
x = "你好星期五"
y1 = x[:]
y2 = x[::]
print(y1) # 你好星期五
print(y2) # 你好星期五
print(x[:]) # 你好星期五
print(x[::]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
y1 = x[:]
y2 = x[::]
print(y1) # ['星期一', '星期二', '星期三']
print(y2) # ['星期一', '星期二', '星期三']
print(x[:]) # ['星期一', '星期二', '星期三']
print(x[::]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
y1 = x[:]
y2 = x[::]
print(y1) # ('星期一', '星期二', '星期三')
print(y2) # ('星期一', '星期二', '星期三')
print(x[:]) # ('星期一', '星期二', '星期三')
print(x[::]) # ('星期一', '星期二', '星期三')切片的参数可以是正数也可以是负数，但不能是浮点数。
x = "你好星期五"
print(x[0:5:1]) # 你好星期五
print(x[::1]) # 你好星期五
x = "你好星期五"
print(x[5::-1]) # 五期星好你
print(x[::-1]) # 五期星好你切片的步长可以是正数也可以是负数，但不能是0（切片的步长默认为1）。
x = ["星期一", "星期二", "星期三"]
print(x[::1]) # ['星期一', '星期二', '星期三']
print(x[::-1]) # ['星期三', '星期二', '星期一']
print(x[::0]) # 报错如果取值范围超过下标，系统不会报错，系统会自动把它更改为边界值。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[0:20]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]在索引和切片中0和-1跟数学中的0和-1有所不同，在Python中0前面并不是-1,0和-1是分开的。
如果步长为正数执行顺序从左往右，如果步长为负数执行顺序从右往左。
x = ["星期一", "星期二", "星期三"]
print(x[::1]) # ['星期一', '星期二', '星期三']
print(x[::-1]) # ['星期三', '星期二', '星期一']如果步长为正数，开始位置和结束位置必须正着写。
x = "你好星期五"
print(x[0:5:1]) # 你好星期五
print(x[::1]) # 你好星期五
x = ["星期一", "星期二", "星期三"]
print(x[0:3:1]) # ['星期一', '星期二', '星期三']
print(x[::1]) # ['星期一', '星期二', '星期三']
x = ("星期一", "星期二", "星期三")
print(x[0:3:1]) # ('星期一', '星期二', '星期三')
print(x[::1]) # ('星期一', '星期二', '星期三')如果步长为负数，开始位置和结束位置必须反着写。
x = "你好星期五"
print(x[5::-1]) # 五期星好你
print(x[::-1]) # 五期星好你
x = ["星期一", "星期二", "星期三"]
print(x[3::-1]) # ['星期三', '星期二', '星期一']
print(x[::-1]) # ['星期三', '星期二', '星期一']
x = ("星期一", "星期二", "星期三")
print(x[3::-1]) # ('星期三', '星期二', '星期一')
print(x[::-1]) # ('星期三', '星期二', '星期一')执行顺序的从左往右和步长为-1的从右往左发生冲突，从而导致输出一个空序列，解决办法就是把步长改为正数。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[:9:-1]) # []执行顺序的从右往左和步长为1的从左往右发生冲突，从而导致输出一个空序列，解决办法就是把步长改为负数。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[9:]) # []
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[9::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1]在切片中，结束位置不能是0也不能是-1，因为0和-1已经是第一个数了，没办法做加一操作，所以最好的解决办法就是结束位置省略不写。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[9:0:-1]) # [9, 8, 7, 6, 5, 4, 3, 2]
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[-9:-1:1]) # [1, 2, 3, 4, 5, 6, 7, 8]如果切片中有正数索引和负数索引，我们很难看懂，就把负数索引转换成对应的正数索引，这样更容易看懂。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[:-5]) # [1, 2, 3, 4]
# print(x[:-5]) = print(x[:4]) # [1, 2, 3, 4]切片中的三个参数可以是表达式，但是表达式的结果必须为整数。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[2-2:2*5:7 % 2]) # [1, 2, 3, 4, 5, 6, 7, 8, 9]Python还支持连续切片。
x = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(x[4:][0:3]) # [5, 6, 7]Python还可以在其它对象后面直接使用切片。
for i in range(0, 101)[::2]:
print(i)
x = [1, 2, 3, 4, 5, 6, 7, 8, 9][4:]
print(x) # [5, 6, 7, 8, 9]Python多维列表（完结）
多维列表分为:一维列表、二维列表、三维列表、四维列表等等。
# 一维列表
x = [1, 2, 3, 4, 5]
print(x[0]) # 1
# 二维列表
x = [[1, 2], [3, 4], [5, 6]]
print(x[0][0]) # 1
# 三维列表
x = [[[1, 2], [3, 4], [5, 6]]]
print(x[0][0][0]) # 1
# 四维列表
x = [[[[1, 2], [3, 4], [5, 6]]]]
print(x[0][0][0][0]) # 1一维列表和二维列表都是比较常见的，三维列表和四维列表极少数地方才用的到。
x = ["一维列表"]
print(x[0]) # 一维列表
x = ["一维列表", ["二维列表"]]
print(x[1][0]) # 二维列表
x = ["一维列表", ["二维列表", ["三维列表"]]]
print(x[1][1][0]) # 三维列表
x = ["一维列表", ["二维列表", ["三维列表", ["四维列表"]]]]
print(x[1][1][1][0]) # 四维列表在Python中可以直接创建一个二维列表。
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(x[0][0]) # 1
print(x[1][3]) # 9通过向一维列表中添加一维列表来创建二维列表。
a1 = [1, 2, 3]
a2 = [4, 5, 6]
a3 = [7, 8, 9]
x = []
x.append(a1)
x.append(a2)
x.append(a3)
print(x) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]通过给指定的索引重新赋一个一维列表来创建二维列表。
x = [[], [], []]
x[0] = [1, 2, 3]
x[1] = [4, 5, 6]
x[2] = [7, 8, 9]
print(x) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]可以使用嵌套的for循环将二维列表转换成一维列表。
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = []
for i in x:
for j in i:
y.append(j)
print(y) # [1, 2, 3, 4, 5, 6, 7, 8, 9]可以使用列表推导式将二维列表转换成一维列表。
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = [j for i in x for j in i]
print(y) # [1, 2, 3, 4, 5, 6, 7, 8, 9]可以使用嵌套的for循环遍历二维列表。
x = [[1, 2], [3, 4], [5, 6]]
for i in x:
for j in i:
print(j)
# 1
# 2
# 3
# 4
# 5
# 6可以使用嵌套的for循环遍历一维列表和二维列表中的元素。
x = [[1, 2], 3, 4, [5, 6]]
for i in x:
if type(i) == list:
for j in i:
print(j)
else:
print(i)
# 1
# 2
# 3
# 4
# 5
# 6可以对一维列表做乘法，也可以对二维列表做乘法，但不能做加法。
x = [[0] * 3] * 3
print(x) # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
x[0][0] = 1
print(x) # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]Python列表推导式（完结）
列表推导式是Python构建列表的一种快捷方式，使用一行简洁的代码就可以创建出一个列表。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*3 for i in "python"]
print(x) # ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']列表推导式是指循环创建列表，又称为列表解析式。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]Python有三种推导式分别是:列表推导式、字典推导式、集合推导式（没有元组推导式）。
x = (i for i in range(6))
print(x) # at 0x0000020B459CDC40> 列表推导式的语法:[返回值 for 自定义变量 in 可迭代对象 if 条件表达式]。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*3 for i in "python"]
print(x) # ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']列表推导式是写在一个列表里面，它都是从for循环开始执行。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*3 for i in "python"]
print(x) # ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']列表推导式先遍历for循环后面的可迭代对象，然后将遍历的元素放到for循环前面的表达式中进行计算，最终生成列表。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*3 for i in "python"]
print(x) # ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']使用for循环来创建一个列表，而列表推导式就相当于for循环创建列表的简化版。
# 使用for循环来创建列表
x = []
for i in range(6):
x.append(i)
print(x) # [0, 1, 2, 3, 4, 5]
# 使用列表推导式来创建列表
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]对于不熟悉列表推导式的人来说，可以使用for循环来实现相同的功能（代码写的烂不要紧，能跑就行）。
# 使用for循环来创建列表
x = []
for i in range(6):
x.append(i)
print(x) # [0, 1, 2, 3, 4, 5]
# 使用列表推导式来创建列表
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]range()函数是列表推导式中最常见的一种可迭代对象。
x = [i for i in range(6)]
print(x) # [0, 1, 2, 3, 4, 5]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*3 for i in "python"]
print(x) # ['ppp', 'yyy', 'ttt', 'hhh', 'ooo', 'nnn']在列表推导式中for循环后面还可以跟if条件判断，if条件判断是嵌套在for循环中的语句。
x = [i for i in range(11) if i % 2 == 0]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i*2 for i in range(6)]
print(x) # [0, 2, 4, 6, 8, 10]
x = [i for i in range(11)[::2]]
print(x) # [0, 2, 4, 6, 8, 10]如果列表推导式太长，可以把列表推导式分为多行。
x = [i for i in range(11) if i % 2 == 0]
print(x) # [0, 2, 4, 6, 8, 10]
x = [
i
for i in range(11)
if i % 2 == 0
]
print(x) # [0, 2, 4, 6, 8, 10]列表推导式是一个局部作用域，列表推导式内部的局部变量只在列表推导式中起作用。
x = 6
y = [x for x in range(6)]
print(y) # [0, 1, 2, 3, 4, 5]
print(x) # 6在列表推导式中可以把返回值写成三元运算符。
x = [i if i % 2 == 0 else "奇数" for i in range(6)]
print(x) # [0, '奇数', 2, '奇数', 4, '奇数']可以在列表推导式中再嵌套一个列表推导式，其实就是把返回值写成列表推导式。
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = [[j for j in i] for i in x]
print(y) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = [j for i in x for j in i]
print(y) # [1, 2, 3, 4, 5, 6, 7, 8, 9]for循环创建列表和列表推导式创建列表，在小范围循环影响不大，如果循环次数达到千万级，列表推导式比for循环运行速度更快。
# for循环
代码运行时间:1.3431036140000001
# 列表推导式
代码运行时间:0.9749278849999999