Python-基础类型list

用途

序列中的每个元素都分配一个数字表示它的位置，也叫索引。与字符串一样，第一个位置的索引是0，第二个索引是1，依此类推。下面介绍的元组的索引也算如此计算。

定义

在[ ]内用逗号分割开多个任意类型的元素

l = [1,2,'hello',[3,4]]

数据类型转换

res1=list("hello")
print(res1)
res2=list({"k1":1,"k2":2,"k3":3})
print(res2)
-------------------------------------
['h', 'e', 'l', 'l', 'o']
['k1', 'k2', 'k3']

常用操作与内置方法

按索引存取值

(正向存取+反向存取)：即可以取可以改值,不能加值

list1 = [11,22,33,44,55]
print(list1[0])
print(list1[-1])
print(id(list1))
list1[0] = 100
print(id(list1))  # 修改列表中元素的值不会改变列表本身的id
print(list1)
--------------------------
11
55
140559080074624
140559080074624
[100, 22, 33, 44, 55]

切片(顾头不顾尾，步长)

l1 = [11,22,[66,77]]
res=l1[2:4]
print(res)
print(l1)
-----------------
[[66, 77]]
[11, 22, [66, 77]]

深浅copy

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

深拷贝(deepcopy)： 需要利用copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。

l2=l1[:]
l2=l1.copy()

print(id(l1[0]),id(l1[1]),id(l1[2]))
print(id(l2[0]),id(l2[1]),id(l2[2]))

l1[0] = "aaa"
l1[1] = "bbb"
l1[2] = "ccc"
l1[2][0] = 8888

print(l2)

from copy import deepcopy
l3=deepcopy(l1)
print(id(l3[0]),id(l3[1]),id(l3[2]))

l1[2][0]=6666
print(l1)
print(l3)

# 示范1：
l1[0]=1000
print(l1)
print(l2)

# 示范2：
l1[-1][0]=666
print(l1)
print(l2)

# 了解：
res=l1[-1:-4:-1]
res=l1[::-1]
print(res)

长度len

list1 = [11,22,[66,77]]  # 嵌套的列表也只能算是list1其中的一个元素
print(len(list1))
------------
3

成员运算in和not in

list1 = [111, 22, [66, 77]]
print([66, 77] in list1)
print(66 in list1)
print(66 not in list1)
------------------
True
False
True

追加append

# append：在列表最后追加元素,且括号内会被视为一个元素，若加入列表，则直接追加列表，不会取出列表中的值再追加
l1=[11,22]
l1.append(33)
l1.append(44)
l1.append([55,66])
--------------------------------
[11, 22, 33, 44, [55, 66]]

插入insert

# insert在指定位置加入元素，将原来位置的元素挤到后一个位置
l1 = [11,22,[66,77]]
l1.insert(0,'新元素')
print(l1)
-----------------------------
['新元素', 11, 22, [66, 77]]


l1 = [11,22,[66,77]]
l1.insert(1,'新元素')
print(l1)
----------------------------------
[11, '新元素', 22, [66, 77]]

删除

万能删除del

按照索引删除，没有返回值，代表的是单纯的删除。

l1=[11,22,[33,44]]
del l1[0]  # 指定删除0号索引位置，若输入的索引不存在报错
print(l1)
del l1[1]  # 此次删除的列表已经是[22, [33, 44]]
print(l1)
-----------------------------
[22, [33, 44]]
[22]

指定元素删除remove

如果你不知道某个元素的索引但是知道他的内容，那么可以使用remove。不是按照索引删除,返回值为None（相当于无返回值），代表的是单纯的删除

l1=[11,22,[33,44]]
res = l1.remove(11)  # 指定11这个元素删除，不是按照索引删除,当删除的元素不存在会报错
print(res)
print(l1)
----------------------------------
None
[22, [33, 44]]

指定索引删除pop

如果你知道元素的索引，并且在删除这个值之后还想利用他，可以使用pop。有返回值，代表的是取走操作。

若不加参数，则默认删除最后一个元素

l1=[11,22,[33,44]]
res = l1.pop()  # 不加参数，默认取走最后一个元素
res1 = l1.pop(0)  # 取走索引0的元素，若输入一个不存在的索引会报错
print(res)
print(res1)  # 返回值是自己取走的元素
print(l1)
--------------------------
[33, 44]
11
[22]

循环for

l1=[11,222,[1,2]]
for x in l1:
    print(x)

需要掌握的操作：

清空列表clear

l1=[11,22,333,333,333,]
l1.clear()
print(l1)
------------
[]

统计count

计算某个字符出现次数

l1=[11,22,33,33,33]
print(l1.count(33))  # 计算33这个字符出现了几次
------------------
3

extend

在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

小例子：有l1，l2两个列表，将l2列表的元素取出加入l1中。

# 方法一、直接用extend
l1 = [11,22,33]
l2 = [44,55,66]
l1.extend(l2)
print(l1)
------------------------
[11, 22, 33, 44, 55, 66]

# 方法二、用for循环，将l2的值取出来，再用append追加
l1 = [11,22,33]
l2 = [44,55,66]
for i in l2:
    l1.append(i)
print(l1)
------------------------
[11, 22, 33, 44, 55, 66]

列表查找index

使用：list.index(x[, start[, end]])，顾头不顾尾

注意，字符串中海油fiind方法，列表中没有此方法

l1=[11,22,33,33,33,44]
# res1=l1.index(33,0,2)  直接报错，在索引0-2（不包括2，即0-1）中没有33元素
res2=l1.index(44)
print(res2)
----------------------------------
5

列表反转reverse

常见面试题
让列表反转的两种方法：

# 方法一、使用reverse
l1=[11,22,"aaa",'bbb']
l1.reverse()
# 方法二、利用列表切片
l1=l1[::-1]  # 两个:不能省略
print(l1)

排序sort与sorted

使用sort方法是永久性排序，而sorted方法是临时性排序。这两个方法的使用方式也有所不同。

sort方法：

• 执行完后会改变原来的list，如果你不需要原来的list，这种效率稍微高点

• 为了避免混乱，其会返回none

sorted方法：

• sorted()不会改变原来的list，而是会返回一个新的已经排序好的list
• list.sort()方法仅仅被list所定义，sorted()可用于任何一个可迭代对象

# sort
list1 = [33,22,88,55,44]
list1.sort()
print(list1)  # 打印原列表，顺序改变了
------------------------
[22, 33, 44, 55, 88]

# sorted
list1 = [33, 22, 88, 55, 44]
print(sorted(list1))
print(list1)  # 打印原列表，顺序不变
--------------------------
[22, 33, 44, 55, 88]
[33, 22, 88, 55, 44]

两个方法都是排序且都默认从小到大，中间加入reverse=True都可变成从大到小排序。

字符串与整型之间无法比较排序，可以比较整型与浮点型，字符串与字符串可以比较

字符串与整型无法排序
# l1 = [11, 22, "aaa", 'bbb'] 
l1 = [11, 22, 1.2, 3.3]
l1.sort()  # 返回值为None
print(l1)
------------------------------------
[1.2, 3.3, 11, 22]

字符串之间排序
l1 = ['aa', '220', 'b', 'nn']
l1.sort()
print(l1)
-------------------------------
['220', 'aa', 'b', 'nn']

排序方法扩展：

在两个方法中都有一个key参数用来在进行比较之前指定每个列表元素上要调用的函数。这句话可能不好理解，通过例子就知道了。key应该是一个函数，其接收一个参数，并且返回一个用于排序依据的key。

'''
在这个排序中，列表中的每个元素都要执行lower
'''
res = sorted("This is a test string from Andrew".split(), key=str.lower)
print(res)
------------------------------------------
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

列表类型总结

1.存多个值
2.有序
3.可变类型