Python 列表

列表

​ Python中的列表，类型是list。

​ 由于Python是动态语言，所以list中可存储任意类型的数据，这与静态语言有很大的区别。

基本声明

​ 以下是使用类的形式进行声明：

li = list((1, 2, 3, 4, 5))
print("值:%s,类型%s" % (li, type(li)))
# 值:[1, 2, 3, 4, 5],类型<class 'list'>

​ 也可以选择使用更方便的字面量形式，使用[]对元素进行包裹：

li = [1, 2, 3, 4, 5]
print("值:%s,类型%s" % (li, type(li)))
# 值:[1, 2, 3, 4, 5],类型<class 'list'>

多维列表

​ 当一个列表中嵌套另一个列表，该列表就可以称为多维列表。

​ 如下，定义一个二维列表：

li = [1,2,["三","四"]]
print("值:%s,类型:%s"%(li,type(li)))
# 值:[1, 2, ['三', '四']],类型:<class 'list'>

类型转换

​ 列表支持与bool和str以及set进行转换：

li = [1,2,3]
b_list = bool(li)  # 布尔类型
s_list = str(li)  # 字符串类型
set_list = set(li)  # 集合类型

print("值:%s,类型:%s"%(b_list,type(b_list)))
print("值:%s,类型:%s"%(s_list,type(s_list)))
print("值:%s,类型:%s"%(set_list,type(set_list)))

# 值:True,类型:<class 'bool'>
# 值:[1, 2, 3],类型:<class 'str'>
# 值:{1, 2, 3},类型:<class 'set'>

​ 如果多维列表遵循一定的规律，那么也可以将其转换为dict：

li = [["k1","v1"],["k2","v2"],["k3","v3"]]
d_list = dict(li)
print("值:%s，类型:%s"%(d_list,type(d_list)))
# 值:{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}，类型:<class 'dict'>

四则运算

​ 列表支持与元组，列表相加，做到合并的效果，类似于extend()方法：

l1 = [1, 2, 3]
l2 = [4, 5, 6]
result = l1 + l2
print(result)
# [1, 2, 3, 4, 5, 6]

​ 列表支持与数字进行*运算，这会重复向被乘的列表中添加元素：

l1 = [1, 2, 3]
result = l1 * 3
print(result)

​ 除此之外的运算符均不支持（一些增量运算符是允许的，如*=，+=，但是这样的使用场景非常少，故不举例）：

l1 = [1, 2, 3]
l2 = [4, 5, 6]
result = l1 - l2
print(result)
# TypeError: unsupported operand type(s) for -: 'list' and 'list'

其他特性

​ 列表是属于引用类型，即当传递时不会进行复制，而是进行引用传递。

​ 列表属于可变容器类型，不同于str的原子容器类型，list允许使用index进行改值操作。

li = [1, 2, 3]
print(id(li))  # 12379848
li[1] = "二"
print(id(li))  # 12379848

索引切片

​ 列表的索引切片与字符串相同，可参见文章：https://www.cnblogs.com/YunyaSir/articles/13832635.html

基本使用

​ 使用索引可对列表中的元素进行删，改，查：

li = ["A", "B", "C", "D"]

# 删
del li[0]
print(li)
# ['B', 'C', 'D']

# 改
li[-1] = "d"
print(li)
# ['B', 'C', 'd']

# 查
result = li[2]
print(result)
# d

​ 试图访问一个超出索引之外的元素，将抛出异常：

li = ["A", "B", "C", "D"]

print(li[100])
# IndexError: list index out of range

​ 也可以从列表中进行截取操作，如使用[:]将当前列表进行复制，需要注意的是它将重新开辟一个内存空间，类似于浅拷贝，这与str不同，str不会进行拷贝而是进行引用：

li = ["A", "B", "C", "D"]
print("值:%s,地址编号:%d"%(li,id(li)))
copy_li = li[:]
print("值:%s,地址编号:%d"%(copy_li,id(copy_li)))

# 值:['A', 'B', 'C', 'D'],地址编号:12904136
# 值:['A', 'B', 'C', 'D'],地址编号:12906344

多维取值

​ 使用多重索引来对多维列表进行取值，如下示例，在三维列表中取出元素9：

li = [1, 2, 3, [4, 5, 6, [7, 8, 9]]]
result = li[3][3][-1]
print(result)
# 9

解构方法

*语法

​ 使用*语法可对列表进行解构，将列表中的元素全部提取出来：

li = [1, 2, 3]
print(*li)
# 1 2 3

​ 我们可以利用*语法的特性，来达到两个列表进行合并的效果：

l1 = [1, 2, 3]
l2 = [4, 5, 6]
result = [*l1, *l2]
print(result)
# [1, 2, 3, 4, 5, 6]

解构赋值

​ 如果一个列表中的元素需要赋值到变量中，可使用解构赋值，需要注意的是变量接收位置与列表中的元素位置一一对应：

li = ["云崖", 19]
name, age = li
print(name, age)
# 云崖 19

常用方法

获取长度

​ 使用len()来进行长度的获取。

​ 返回int类型的值。

li = ["A", "B", "C", "D"]
print(
    len(li) # 4
    )

追加元素

​ 使用append(ele)来对当前列表新增一个子元素。

​ 返回None。

li = ["A", "B", "C", "D"]
li.append("E")
print(li)  # ['A', 'B', 'C', 'D', 'E']

列表合并

​ 使用extend(iter)来让当前列表与另一个可迭代对象进行合并。

​ 返回None。

l1 = [1, 2, 3]
l2 = [3, 4, 5]
l1.extend(l2)
print(l1)
# [1, 2, 3, 3, 4, 5]

插入元素

​ 使用insert(int,ele)将特定元素插入当前列表中的指定位置。

​ 返回None。

l1 = [1, 2, 3]
l1.insert(1, "二")
print(l1)
# [1, '二', 2, 3]

列表拷贝

​ 使用copy(li)将当前列表进行浅拷贝。

​ 返回当前列表的拷贝对象。

l1 = [1, 2, 3]
result = l1.copy()
print(result)
# [1, 2, 3]

弹出元素

​ 使用pop(int)弹出当前列表中在此索引的元素。

​ 返回被弹出的元素。

l1 = [1, 2, 3]
result = l1.pop(2)  # 如不指定改参数，默认弹出 -1
print(result)
# 2

删除元素

​ 使用remove(eleName)删除当前列表中的元素，按照元素名进行删除。

​ 如果有多个同名的元素，则只会删除第一个。

​ 返回None。

li = ["first","last","first","last"]
li.remove("first")
print(li)
# ['last', 'first', 'last']

清空元素

​ 使用clear()将当前列表中进行清空，即删除所有元素。

​ 返回None。

li = ["A", "B", "C"]
li.clear()
print(li)
# []

统计次数

​ 使用count(eleName)统计元素在该列表中出现的次数。

​ 返回int。

li = ["A", "B", "C"]
result = li.count("A")
print(result)
# 1

查找位置

​ 使用index(eleName)找到元素在当前列表中所在的索引值，如元素不存在则抛出异常。

​ 返回int。

li = ["A", "B", "C"]
result = li.index("A")
print(result)
# 0

顺序排列

​ 使用sort(li)将当前列表中的元素按照ASCII码顺序进行排列，默认从小到大。

​ 可指定参数resverse，用于是否翻转列表，如翻转列表则代表从大到小。

​ 返回None。

注意：由于强类型编程语言的原因，不支持int与str的对比

li = ["A", "a", "c","d","B"]
li.sort(reverse=True)  # 从大到小
print(li)
# ['d', 'c', 'a', 'B', 'A']

翻转列表

​ 使用reservse(li)将当前列表进行翻转。

​ 返回None。

li = ["A", "B", "C"]
li.reverse()
print(li)
# ['C', 'B', 'A']

底层存储

​ 原子容器类型str与可变容器类型list有什么差异？同属于容器类型为什么str不允许修改而list允许修改呢？

​ 这是因为底层存储方式的不同，str是占用一整块连续内存，而list是引用一块内存后做顺序存储故可进行修改。

​ 如下图所示：

>>> li = ["a","b","c"]
>>> id(li)
2210045360960   # 变量名li 绑定的内存地址
>>> id(li[0])
2210044891248
>>> li[0] = "A"
>>> id(li)
2210045360960   # 可以看到其中元素已经改变了，但是其li 绑定的内存地址依旧没有任何改变
>>> id(li[0])
2210045361456   # li中0号元素内存地址发生了变化
>>>