04-03 基本数据类型制之列表类型及其内置方法

补充：以下我们通过4个方面来讲，作用、定义、类型转换、使用。其中作用我们在基本数据类型中已经提到，不需要再进行称述了。基本数据类型网址: https://www.cnblogs.com/yang1333/p/12411707.html

一、定义

li = [1, 1.2, 'a']  # li=list([1, 1.2, 'a'])

二、类型转换

• 强调：list可以把但凡能够被for循环遍历的类型都可以当作参数传给list()转成列表

# 1、把字符串转换成列表
res = list('hello')
print(res)  # ['h', 'e', 'l', 'l', 'o']


# 2、把字典转换成列表（转成列表，列表中存放的是字典的key）
# 注意：字典是无序的，python2你能直观的看到，python3中进行了优化，你并不能直观的看到，字典的无序排列。
res = list({'k1': 'valu1', 'k2': 'valu2', 'k3': 'valu3'})
print(res)  # ['k1', 'k2', 'k3']
    
# list底层的工作原理
li = []
for i in 'hello':
    li.append(i)
print(li)   # ['h', 'e', 'l', 'l', 'o']

三、使用：内置方法

👇优先掌握的操作👇

1、按照索引取值（正向取+反向取）：可存、可改

li = [111, 'egon', 'hello']

# 正向取
print(li[0])    # 111

# 反向取
print(li[-1])   # hello

# 可以取也可以改：索引存在，则修改对应的值
li[0] = 222
print(li)       # [222, 'egon', 'hello']

# 无论是取值操作还是赋值操作:索引不存在则报错(简称：索引越界)
li[3] = 333     # IndexError: list assignment index out of range (列出超出范围的赋值索引)

2、切片（顾头不顾尾、步长）

li = [111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]
# 1、顾头不顾尾顾头不顾尾、步长
print(li[0:3])      # [111, 'egon', 'hello']
print(li[0:5:2])    # [111, 'hello', 'b']

# 3、完完整整的切片
print(li[:len(li)])
print(li[0:])
print(li[:])    # 推荐使用，[111, 'egon', 'hello', 'a', 'b', 'c', 'd', [1, 2, 3]]

# 4、颠倒列表
print(li[::-1])  # [[1, 2, 3], 'd', 'c', 'b', 'a', 'hello', 'egon', 111]

# 5、验证：切片行为，等同于拷贝行为，而且相当于浅拷贝
li1 = li[:]
print(id(li1), id(li))          # 2371813973056 2371813973568
# 争对可变类型
print(id(li[1]), id(li1[1]))    # 2371813971376 2371813971376
li[1] = 'EGON'
print(id(li[1]), id(li1[1]))    # 2371813972912 2371813971376

# 争对不可变类型
print(id(li[-1][-1]), id(li1[-1][-1]))  # 140703318001376 140703318001376
li[-1][-1] = 333
print(id(li[-1][-1]), id(li1[-1][-1]))  # 2371813411216 2371813411216
print(li[-1], li1[-1])  # [1, 2, 333] [1, 2, 333]

# 6、验证：如果你的容器类型是，不可改的类型，拷贝（无论是浅copy或者深copy）以后不会生成新的地址，例如：字符串，元组
# 6.1 字符串
res = 'hello:egon:<>:18[]==123'
# 浅copy：切片
new_res = res[:]    

# 浅copy：copy
# new_res = res.copy()

# 深copy
# import copy
# new_res = copy.deepcopy(res)
print(id(res), id(new_res))  # 2289600632032 2289600632032

# 6.2 元组
res = (1, 2, 3)
new_res = res[:]
print(id(res), id(new_res))  # 2289599962048 2289599962048

3、长度len

li = [111, 'egon', 'hello']
print(len(li))  # 3

4、成员运算int和not in

• 判断一个值是否在一个列表第一层中。

print('aaa' in ['aaa', 1, 2])   # True
print(1 in ['aaa', 1, 2])       # True

5、添加 append、insert、extend

• append 追加值到列表末尾。只传1个任意类型的值，把该值追加到列表末尾。
• insert 插入值到列表指定位置。传的第1个值是int类型，用于指定索引位置。传的第2个值是任意类型，用于把改值插入到该索引位置。
• extend 扩展值到列表指定位置。只有1个参数，指定可迭代对象，会把该可迭代对象中的每个值按照先后顺序追加到列表末尾。（可迭代对象，可以理解为可以被for循环循环取值的，底层原理就是使用for循环取出每个值，再使用append追加到列表末尾。）

# 5.1 append
li = [111, 'egon', 'hello']
li.append(3333)
li.append(4444)
print(li)       # [111, 'egon', 'hello', 3333, 4444]

# 2、insert
li = [111, 'egon', 'hello']
li.insert(1, 222)
print(li)       # [111, 222, 'egon', 'hello']

# 3、extend
new_l = [1, 2, 3]
li = [111, 'egon', 'hello']
li.extend(new_l)
print(li)       # [111, 'egon', 'hello', 1, 2, 3]

# extend底层实现原理
li = [111, 'egon', 'hello']
new_l = [1, 2, 3]
for i in new_l:
    li.append(i)
print(li)       # [111, 'egon', 'hello', 1, 2, 3]

6、删除 del、pop、remove

• del 通用的删除方法，只是单纯的删除，没有返回值（注意：不支持赋值语法）
• pop 指定索引进行删除，默认不指定参数删除一个末尾的值。只传1个int类型值，该值就是指定索引删除对应的值。（注意：pop会返回删除的那个值）
• remove 根据指定元素删除。只传一个任意类型的值。（注意：remove默认没有返回值，只是python为了防止报错，默认给这种没有返回值的类型会追加一个返回值None）
• 如何区分使用？如果你只是单纯的想删除，并不需要拿到你刚刚删除的值就使用del、remove。如果你想删除，并且你想拿到你刚刚删除的值就是用pop。

# 1、通用的删除方法，只是单纯的删除、没有返回值
li = [111, 'egon', 'hello']
del li[1]
# x = del li[1]  # SyntaxError: invalid syntax
print(li)


# 2、pop根据索引删除，会返回删除的值
li = [111, 'egon', 'hello']
# 不指定参数删除一个末尾的值
li.pop()    
print(li)   # [111, 'egon']

# 指定索引进行删除
li.pop(0)
print(li)       # ['egon']

# pop会返回删除的那个值
print(li.pop(0))    # egon


# 3、remove()根据元素删除，返回None
li = [111, 'egon', [1, 2, 3], 'hello']
# 根据指定元素删除
res = li.remove([1, 2, 3])
print(li)   # [111, 'egon', 'hello']

# remove默认没有返回值，只是python为了防止报错，默认给这种没有返回值的类型会追加一个返回值None
print(res)  # None

7、排序 sort

• 排序前提：列表内元素必须是同种类型才可以排序
• sort 默认从小到大排序。传的第1个参数占时不说，可以不指定。传的第2个参数指定reverse=True(默认reverse=False)，让sort按照从大到小的顺序排序。

li = [11, -3, 9, 2, 3.1]
# 默认从小到大
li.sort()
print(li)    # [-3, 2, 3.1, 9, 11]   

# 修改排序规则，按照从大到小
li.sort(reverse=True)
print(li)    # [11, 9, 3.1, 2, -3]

# 不同种类型排序报错
li = [11, 'a', 12]
# li.sort()    # TypeError: '<' not supported between instances of 'str' and 'int'   

9、由排序sort引申出相同类型之间比较大小（只有整型和浮点型可以跨类型比较）

• 使用sort进行排序前提条件：列表内的元素必须是同种类型(其中整型与浮点型类型除外)

# 字符串比较大小，按照ASCII表的先后顺序区别字符的大小。按照对应位置的字符的大小按照区分，先匹配第一位，如果第一位分出胜负，后面就不再比较，如果没有则继续比较，直到分出胜负。
print('a' > 'b')             # Fasle，'a' > 'b'  --> ascii 97 > 98
print('abz' > 'abcdefg')    # True, 'z' > 'c'   --> ascii 122 > 99

# 列表之间比较大小，按照索引对应位置依次pk。如果不是同种类型就会报错，如果是同种类型则会依次pk，直到分出胜负。
li1 = [1, 'abc', 'zaa']
li2 = [1, 'abc', 'zaa']
li3 = [1, 'abc', 'za']
print(li1 < li2)    # False, 'zaa' > 'zaa' --> 'a' > 'a' --> 97 > 97
print(li3 < li2)    # True，  'za' < 'zaa' --> '' < 'a' --> '' < 97

9、循环

• 强调：在循环过程中，不要把遍历的那个列表中的元素删除或修改这样会引发程序的错乱，非常危险。

li = [1, 'aaa', 'bbb']
for x in li:
    li.pop(1)	# 非常危险。
    print(x)

👇需要掌握的操作👇

1、count

• count 统计元素在列表中的个数。只传1个任意类型的值，统计该值在列表中的个数。

li = [1, 'aaa', 'bbb', 'aaa', 'aaa']
print(li.count('aaa'))      # 3

2、index

• index 更具值按照先后顺序统计对应值的索引。(注意：先后顺序指的是从左到右的顺序，找到了就返回索引值)
• 注意：列表没有字符串的这些方法find、rfind、rindex

li = [1, 'aaa', 'bbb', 'aaa', 'aaa']
print(li.index('aaa'))         # 1
# print(li.index('aaaaaaaaa'))  # ValueError: 'aaaaaaaaa' is not in list

3、copy

我们在浅拷贝中已经提到在这里不多赘述：https://www.cnblogs.com/yang1333/p/12451969.html

4、clear

• clear 没有参数，清空列表。

li = [1, 'aaa', 'bbb', 'aaa', 'aaa']
li.clear()
print(li)       # []

5、reverse

• reverse 将列表反转（注意：reverse直接修改的是源列表，不是排序，就是简单的将列表倒过来）

# 注意：reverse不是排序，就是将列表倒过来，颠倒的是原值
li = [1, 'egon', 'alex', 'lxx']
li.reverse()
print(li)   # ['lxx', 'alex', 'egon', 1]

# 也可以使用切片，将列表颠倒，而切片颠倒的不是原值，是copy后生成的新的列表
new_li = li[::-1]
print(id(new_li), id(li))   # 2100236984256 2100236983744

👇补充👇

1、队列 first in first out 简称 FIFO 先进先出

• 举例：争对列表，类似于吃和拉

li = []
# 入队操作（使用append）
li.append('first')
li.append('second')
li.append('third')
print(li)       # ['first', 'second', 'third']

# 出队操作（使用pop，指定参数0。注意：不能使用remove，remove没有返回值，并不是出队）
print(li.pop(0))    # first
print(li.pop(0))    # second
print(li.pop(0))    # third

2、堆栈 first in last out 简称 FILO

• 举例：争对列表，类似于叠衣服

li = []
# 入栈操作（使用append）
li.append('first')
li.append('second')
li.append('third')
print(li)       # ['first', 'second', 'third']

# 出栈操作（使用pop，默认不指定参数）
print(li.pop())  # third
print(li.pop())  # second
print(li.pop())  # first