定义：列表和元组都是存储变量的数据结构，类似 java 中的数组

区别：列表是可变的，后续还可以对列表进行增删查改操作
           元组是不可变的，一旦创建后，里面的数据就不可发生改变

列表的相关操作：

一.创建列表

# 1.直接使用方括号来创建列表
a = []
print(a)
# 结果
# []

# 2.使用 list() 方法创建列表
b = list()
print(b)
# 结果
# []

# 3.在创建列表的时候直接对列表进行初始化
c = [1, 2, 3, 4]
print(c)
# 结果
# [1, 2, 3, 4]

        和 java 中的数组很不一样的一点是，数组中放的都是同一类型的变量，列表中也可以放不同类型的变量。

二.切片切片的基本使用

1. 切片操作的基本使用

a = [1, 2, 3, 4, 5]
print(a[1:3])

# 结果
# [2, 3]

# 当右边界取到一个很大的数时，切片操作并不会报错
# 而是尽力向右边取到最后一个元素，并不会出现列表越界的情况
print(a[1:100])

# 结果
# [2, 3, 4, 5]

        这里的 ：两边的数字就代表左右两个下标所代表的区间，注意，前闭后开

2. 使用切片的时候，省略边界

# 省略后边界，从下标 1 开始，一直到末尾
a = [1, 2, 3, 4, 5]
print(a[1:])

# 结果
# [2, 3, 4, 5]

# 省略前边界，从 0 下标开始取，一直到右边界(不取右边界)
print(a[:2])

# 结果
# [1, 2]

切片是一个非常高效的操作，不是对原数组的拷贝

所以即使是数据量非常大的时候，切片操作仍然很高效

3. 切片操作的时候，使用步长作为第三个操作数

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 对 1 - 7 左闭右开区间每隔 2 步取出一个元素
print(a[1:7:2])

# 结果
# [2, 4, 6]

# 同样也可以逆序取出元素，不过左右边界的下标要交换位置
print(a[7:1:-2])

# 结果
# [8, 6, 4]

三.列表的遍历

1. 使用 for 循环对列表进行遍历

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 使用这种方式时，a 必须是一个可迭代对象
for elem in a:
    print(elem, end = " ")

# 结果
# 1 2 3 4 5 6 7 8 9 10 

这里如果不想每打印 1 次就换行，而是显示在一行上

就可以手动设置 end 参数为空格 , 不写的话默认参数 end 就为  \n 

2. 使用 for 循环，通过下标进行遍历

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in range(len(a)):
    print(a[i], end = ' ')

# 结果
# 1 2 3 4 5 6 7 8 9 10

        但这两种方式有什么区别呢，通过以下代码进行展示

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for elem in a:
    elem += 10
print(a)

# 结果
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for i in range(len(a)):
    a[i] += 10
print(a)
# 结果
# [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

        可以发现，通过下标访问时，对每个元素 + 10，原列表中的数据也会发生变化； 通过迭代对象进行操作，则不会对原数组产生影响。
        这说明在通过数组下标操作时，访问的就是原数组实际元素；而迭代对象只是对应元素的临时元素，所以在不同的场景下要谨慎使用这两种方式。 

四. 列表的增删查改操作

1. 列表的增加元素方法

方法必须依赖对象使用，函数则可以脱离对象单独使用。

注意这两个名词的使用范围。在 python 中，这里的对象就可以看作” 变量 “

        1.1 append() 方法, 尾插

a = [5]
# 这里的 append 方法是尾插的方式
a.append(6)
print(a)

# 结果
# [5, 6]

        1.2 insert() 方法，按照下标在任意位置插入。第一个参数是下标，第二个参数是插入的元素

a = [1, 2, 3, 4, 5]

a.insert(1, 6)
print(a)

# 结果
# [1, 6, 2, 3, 4, 5]

2. 查找操作

        2.1 使用关键字 in 来判断某个元素在列表中是否存在

a = [1, 2, 3, 4, 5]
var = 1 in a
print(var)
# 结果
# True
var = 6 in a
print(var)
# 结果
# False

        2.1 使用 index() 方法，找到元素在数组中的位置，并返回下标。如果不存在，就会抛出异常

a = [1, 2, 3, 4, 5]
index = a.index(3)
print(index)
# 结果
# 2
index = a.index(6)
# 结果
# 报错

3.删除操作

        3.1  pop() 方法，尾删

a = [1, 2, 3, 4, 5]
a.pop()
print(a)

# 结果
# [1, 2, 3, 4]

        3.2  pop() 方法，传入下标，删除任意位置的元素。若传入的下标导致列表越界访问，则抛出异常

a = [1, 2, 3, 4, 5]
a.pop(2)
print(a)
# 结果
# [1, 2, 4, 5]
a.pop(5)
print(a)
# 结果
# 报错

        3.2  remove() 方法，传入元素值，根据元素值删除对应下标

a = [1, 2, 3, 4, 5]
a.remove(4)
print(a)
# 结果
# [1, 2, 3, 5]

五. 列表的拼接

1. 使用 + 拼接两个字符串，这里会返回一个新的字符串，并不会影响 a， b

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
c = a + b
print(c)
# 结果
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2. 使用 extend() 方法拼接字符串，把 b 的内容接入到 a 里，返回值为 None，表示没有返回值。

这里利用的还是列表可以修改的特性，如果换做元组或 java 中的数组肯定是不可行的

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
c = a.extend(b)
print(a)
print(c)
# 结果
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# None

3. a += b  => a = a + b 执行效果和 extend() 方法类似
但这个操作多了数据的拷贝构造和数据的回收，相比 extend() 显然更低效

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]
a += b
print(a)
# 结果
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

六. 元组的操作

创建元组：b = tuple()

其余的操作和列表并没有什么区别，但是少了对元组进行修改的操作，因为元组是不可变的

一句话 ：元组是 “只读” 的，不可修改。

不可变对象是可以哈希的