python-2.列表

列表

• 概述

列表的特点：
    可以存储多个数据
    可以储存多种数据
    支持下标操作
    支持切片操作
    是一个可迭代对象
    是可变类型

• 列表的创建

1. 手工直接创建(list是保留字不要用来创建)
    变量名 = [值1，值2，。。。]
    list1 = [1,2,3,3] 整型列表
    list2 = ['a', 'b'] 字符串列表
    list3 = ['a', 1, 2] 一般列表(混合列表)
    [] 空列表
2. 利用构造方法
    list(): 返回空列表
    list(iterable): 利用可迭代对象的元素，创建一个新列表

代码：
l1 = ['a', 1, 2]
print(l1)
l2 = list()
print(l2)
l3 = list('abcd')
print(l3)

效果：
['a', 1, 2]
[]
['a', 'b', 'c', 'd']

• 添加元素(增)

1. append(obj):
    向列表的末尾添加一个元素
2. extend(iterable):
    把可迭代对象中的元素添加到列表中
    可以添加多个元素
3. insert(index, obj):
    在index对应的下标前，插入obj

代码：
l1 = [1, 2, 3]
l1.append(4)
print(l1)
l2 = [5, 6]
l1.extend(l2)
print(l1)
l1.insert(0, 99)
print(l1)

效果：
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6]
[99, 1, 2, 3, 4, 5, 6]

• 删除元素(删)

1. clear():
    清空列表中所有元素，列表本身不删除
2. pop([index])：
    根据下标删除并返回这个元素，默认删除最后一个
3. remove(value):
    从列表中删除value对象
    如果有多个value（重复的）存在，删除下标最小的（第一个）
4. 删除语句
    del 元素， 列表[下标]

代码：
l1 = [1, 2, 3]
l1.clear()
print(l1)
l1 = [1, 2, 3, 3, 4, 5, 6]
l1.pop()
l1.pop(0)
print(l1)
l1.remove(3)
print(l1)
del l1[0]
print(l1)

效果：
[]
[2, 3, 3, 4, 5]
[2, 3, 4, 5]
[3, 4, 5]

• 修改元素（改）

代码：
# 手动修改
l1 = [1, 2, 3]
print(l1)
l1[0] = 99
print(l1)

效果：
[1, 2, 3]
[99, 2, 3]

• 访问元素(查)

访问：获取 删除 修改 (引(使)用旧的数据)
1. 访问一个元素
    通过下标 l1[1]
    列表的下标从0开始算起
2. 访问多个元素
    利用切片进行访问
3. 访问所有元素
    所有元素访问一边，不重复，不遗漏：遍历
    for 循环

代码：
l1 = [1, 2, 3, 4, 5, 6]
print(l1[1])
print(l1[1:5])
for i in l1:
    print(i, end='***')

效果：
2
[2, 3, 4, 5]
1***2***3***4***5***6***

• 列表的其他方法

代码：
# 1.copy()
#   浅拷贝
l1 = [1, 2, 3]
l2 = l1.copy()
print(l1, id(l1), l2, id(l2))
# 2.count(value)
#   返回value在列表中出现的次数
l3 = [1, 2, 3, 3, 4, 5, 3]
print(l3.count(3))
# 3.index(value, [start, [stop]])
#   在start到stop，value出现的下标(位置)
#   start默认0
#   stop默认到最后
#   如果有多个值，只返回最小的下标
print(l3.index(3, 2, 5))
# 4.reverse()
#   原地反转
l3.reverse()
print(l3)
# 5. sort(key=None,reverse=False)
#   排序(八大排序)
#   sort():排序方法：python2：归并排序 python2.3开始引用Timsort Timsort:结合了归并+插入
#   key:排序规则
#   reverse:是否要反转， True反转， False：默认(升序)
l3.sort()
print(l3)

效果：
[1, 2, 3] 1141123065216 [1, 2, 3] 1141124007616
3
2
[3, 5, 4, 3, 3, 2, 1]
[1, 2, 3, 3, 3, 4, 5]

• 切片

分片：splice
语法：list1[start:stop]
范围：[start:stop]
对于索引，下标不可以越界；对于切片下标可以越界
1.切片的下标可以越界
2.取值到最后，stop默认可以不写
3.从第一个值开始取，start默认可以不写
补充：列表的下标可以是负数，-号仅代表方向，负数下标从-1开始
4.切片操作的高级用法
    切片不仅仅可以传入两个参数，可以有第三个参数
    list[start:stop:step]
5.切片操作会返回一个新的数据(还是列表)
    切片常用于数据拷贝

代码：
l = list('abcdefg') # 6
print(l)
l1 = l[2:5]
print(l, l1)
l2 = l[5:10]
print(l, l2)
l3 = l[::2]
print(l, l3)
l4 = l[-6:-1:2]
l5 = l[-1:-6:-2]
print(l4, l5)

效果：
['a', 'b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c', 'd', 'e', 'f', 'g'] ['c', 'd', 'e']
['a', 'b', 'c', 'd', 'e', 'f', 'g'] ['f', 'g']
['a', 'b', 'c', 'd', 'e', 'f', 'g'] ['a', 'c', 'e', 'g']
['b', 'd', 'f'] ['g', 'e', 'c']

• 列表支持的运算符

1. 比较运算，布尔运算 > < >= <= == !=
    比较规则：从0下标开始，主个比较大小，只要比出大小则不再比较
2. 拼接运算符 +
3. 重复操作符：本质就是拼接运算，输出在一个列表中
4. 成员关系运算符 in not in 

代码：
l1 = [1, 2, 3]
l2 = [4, 5]
print(l2>l1)
l3 = l1 + l2
print(l3)
l4 = l2 * 2
print(l4)
print(3 in l1)

效果：
True
[1, 2, 3, 4, 5]
[4, 5, 4, 5]
True

• 二维列表

一维列表下的一维列表
1. 创建二维列表
    手动创建  l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    构造方法   传入二维数据，可以构建二维列表
    列表推导式 
2. 访问二维列表
    访问一个 list[index1][index2]
    访问多个 切片操作
    访问所有 遍历 双重循环

代码：
l1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(l1)
l2 = [[i+j for j in range(1, 10)] for i in range(1, 10)]
print(l2)

效果：
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[[2, 3, 4, 5, 6, 7, 8, 9, 10], [3, 4, 5, 6, 7, 8, 9, 10, 11], [4, 5, 6, 7, 8, 9, 10, 11, 12], [5, 6, 7, 8, 9, 10, 11, 12, 13], [6, 7, 8, 9, 10, 11, 12, 13, 14], [7, 8, 9, 10, 11, 12, 13, 14, 15], [8, 9, 10, 11, 12, 13, 14, 15, 16], [9, 10, 11, 12, 13, 14, 15, 16, 17], [10, 11, 12, 13, 14, 15, 16, 17, 18]]