萌新学 Python 之列表 list

list 列表：用中括号定义，元素写在中括号之间，元素之间使用逗号分隔

list1 = []   # 空列表
list2 = [1]  # 元素为1个
list3 = ['a', 'b', 'c']
print(type(list1), type(list2), type(list3))   # <class 'list'> <class 'list'> <class 'list'>

1.列表属于可变数据类型，当元素修改后，内存地址不会改变

2.可变类型可以对列表进行增删改查

3.列表的元素类型不受限制，可以是任意类型

可以使用 list 内置函数创建列表

格式：list(可迭代对象)

对象为集合去重且无序

对象为字典返回键 key

# 对象为字符串
list4 = list('python')
print(list4)                       # ['p', 'y', 't', 'h', 'o', 'n']
# 对象为元组、列表、字典、集合
list5 = list((1, 2, 3))
print(list5)                       # [1, 2, 3]
list6 = list(['a', 'b'])
print(list6)                       # ['a', 'b']
list7 = list({'a', 'b', 'b'})
print(list7)                       # ['b', 'a']       对象为集合去重且无序
list8 = list({'name': 'zhangsan', 'age': 18})
print(list8)                       # ['name', 'age']  对象为字典返回键key

列表的索引和切片：

格式：列表[起始索引: 结束索引: 步长]

没有冒号是索引，有冒号是切片，切片范围左闭右开，左边包含右边不包含

步长默认 1，默认从下标 0 开始

#    0    1      2         3       4       5                 6
l = [1, 3.14, 'python', (1, 2), [1, 2], {1, 2}, {'name': 'zhangsan', 'age': 18}]
# 列表的索引
print(l[1],l[-2])         # 3.14 {1, 2}
# 列表的切片
print(l[1:4])             # [3.14, 'python', (1, 2)]
print(l[::-2])            # [{'name': 'zhangsan', 'age': 18}, [1, 2], 'python', 1]

列表的修改：

通过索引值修改列表元素，修改后，内存地址 id 不变

#    0    1      2         3       4       5                 6
l = [1, 3.14, 'python', (1, 2), [1, 2], {1, 2}, {'name': 'zhangsan', 'age': 18}]
print(id(l))                     # 2307829475136
# 修改指定索引值的元素，id不变
l[3] = ('a', 'b')
print(id(l))                     # 2307829475136
print(l)    # [1, 3.14, 'python', ('a', 'b'), [1, 2], {1, 2}, {'name': 'zhangsan', 'age': 18}]

元组属于不可变的类型，特殊情况下，元组的元素为可变类型，修改元组元素 id 不变

tup = (1, 2, [1, 2])
print(id(tup))      # 2208925687424
# 修改元组中索引值为2的列表中第一个元素
tup[2][0] = 3
print(tup)          # (1, 2, [3, 2])
print(id(tup))      # 2208925687424

列表增加元素（append、extend、insert）：

1.在原列表中添加元素，元素可以是任意类型

格式：列表.append(元素)

lst = []  # 空列表
# 添加字符串
lst.append('123')
print(lst)   # ['123']
# 添加字典
lst.append({'name': 'zhangsan', 'age': 18})
print(lst)   # ['123', {'name': 'zhangsan', 'age': 18}]

2. extend 添加元素，将可迭代对象扩展到列表中

格式：列表.extend(可迭代对象)

字符串返回一个个元素

字典返回键 key

lst2 = []  # 空列表
# 添加字符串，将字符串拆分成一个个元素返回
lst2.extend('python')
print(lst2)       # ['p', 'y', 't', 'h', 'o', 'n']
# 添加字典，返回键key
lst2.extend({'name': 'zhangsan', 'age': 18})
print(lst2)       # ['p', 'y', 't', 'h', 'o', 'n', 'name', 'age']

3. insert 添加元素，指定索引位置插入元素，当索引值超出范围则添加到最后

格式：列表.insert(索引值, 元素对象)

lst3 = []   # 空列表
# 在下标0的位置插入元素
lst3.insert(0, 'abc')
print(lst3)    # ['abc']
# 在下标10的位置插入元素，因为超出范围，所有添加到最后
lst3.insert(10, '123')
print(lst3)    # ['abc', '123']

列表增加元素总结：

append 添加一个元素

extend 扩展多个元素

insert 指定位置插入一个元素

列表中元素的删除：remove、pop、clear

1. remove 从原列表中移除元素

格式：列表.remove(指定元素)

若移除不存在的元素则报错

l2 = ['good', 'good', 'study', 'day', 'day', 'up']
# 移除指定元素
l2.remove('good')
print(l2)          # ['good', 'study', 'day', 'day', 'up']

2. pop 从原列表中删除指定索引值的元素

格式：列表.pop(索引值)

索引值超出则报错

没有指定索引值，默认删除最后一个元素

l2 = ['good', 'good', 'study', 'day', 'day', 'up']
l2.pop(1)   # 删除下标1
print(l2)   # ['good', 'study', 'day', 'day', 'up']
l2.pop()
print(l2)   # ['good', 'study', 'day', 'day']

3. clear 清空列表元素，返回空列表

格式：列表.clear()

l2 = ['good', 'good', 'study', 'day', 'day', 'up']
l2.clear()     # 列表清空
print(l2)      # [] 空列表

列表中删除元素总结：

remove 移除指定元素

pop 删除指定索引的元素，默认删除最后一个

clear 清空列表元素

列表元素的查询：

通过 列表[索引值] 返回元素

sort 对原列表元素进行排序，默认升序

格式：列表.sort(key = 自定义函数, reverse = False)

列表的元素必须是相同的类型，否则无法排序，程序将报错

当 reverse = False 时，升序排序

当 reverse = True 时，降序排序

# 升序排序
list9 = [5, 1, 9, 6]
list9.sort()
print(list9)   # [1, 5, 6, 9]
# 降序排序
list9 = [5, 1, 9, 6]
list9.sort(reverse=True)
print(list9)   # [9, 6, 5, 1]

对元组列表排序，按元组中第二个元素排序

lambda 参数:表达式

将表达式的结果返回，参数是传给表达式

# 对元组列表排序，按元组中第二个元素排序
list10 = [('张三', 18), ('李四', 20), ('王五', 15)]
# lambda 参数:表达式      将表达式的结果返回，参数是传给表达式
list10.sort(key=lambda x:x[1])
print(list10)    # [('王五', 15), ('张三', 18), ('李四', 20)]

key=lambda x 是将元组命名为 x，即 ('张三', 18) 是 x

lambda x:x[1] 是元组的下标 1 也就是第二个元素 18

就可以实现按元组中第二个元素排序

默认是会按元组中第一个元素排序

reverse 列表转置，将列表进行反转

list11 = [1, 2, 3, 4]
list11.reverse()
print(list11)        # [4, 3, 2, 1]

copy 列表的拷贝：不可变的元素完全独立，可变的元素共享使用

l3 = [1, 2, [3, 4, 5]]
l4 = l3.copy()
print(id(l3), l3)    # 2541099811008 [1, 2, [3, 4, 5]]
print(id(l4), l4)    # 2541099811072 [1, 2, [3, 4, 5]]l3[2].append(6)      # 增加可变类型，元素共享
print(id(l3), l3)    # 2541099811008 [1, 2, [3, 4, 5, 6]]
print(id(l4), l4)    # 2541099811072 [1, 2, [3, 4, 5, 6]]l3.append(7)         # 不可变的元素完全独立
print(id(l3), l3)    # 2541099811008 [1, 2, [3, 4, 5, 6], 7]
print(id(l4), l4)    # 2541099811072 [1, 2, [3, 4, 5, 6]]

其他函数比如 len、max、min、del 与元组类似