[Python基础]列表List

列表List

0.概述
1.创建列表
2.向列表添加元素
- append(val)
- extend(val)
- insert(index,val)
3.从列表中获取元素
4.从列表删除元素
- remove(val)
- pop(index)
- del
5.列表切片
- 切片语法
6.常用操作
- 运算符
- 常用方法
- - count()
  - index()
  - reverse()
  - sort()

0.概述

在其他的高级编程语言中，如Java，将一些相互之间有关联的数据保存在一起，这个数据结构就是数组，数组允许把一些相同类型的数据放在一起，然后通过下标进行索引。

Python中也有类似数组的数据结构，但是Python中的数组与其他编程语言不同，由于Python变量没有数据类型，所以Python的”数组“可以同时存放不同类型的变量，这就是列表List。

1.创建列表

Python中创建列表非常简单，只需要使用中括号将数据包裹起来，如：

lst = [1, 2, 3, 4, 5, 6]
print(type(lst))  # <class 'list'>

对其进行遍历打印：

for item in lst:print(item)
"""123456
"""

Python中列表可以存储不同数据类型：

mix = [520, "Abo", 3.14, [1, 2, 3]]

mix列表中同时拥有整型、字符串、浮点型甚至还包含另一个列表。

同样，也可以创建空列表

empty = []

2.向列表添加元素

append(val)

append()是属于列表对象的一个方法，在原列表的尾部插入一个元素（尾插法）

numbers = [1, 2, 3, 4, 5]
numbers.append(6)
print(numbers)  # [1, 2, 3, 4, 5, 6]

但是如果想要插入多个元素，使用append()函数是无法一次性完成的，如：

numbers = [1, 2, 3, 4, 5]
numbers.append(6, 7)# 报错信息如下：
"""
Traceback (most recent call last):File "C:\WorkSpace\PythonProjects\PythonBase\test\demo2.py", line 6, in <module>numbers.append(6, 7)
TypeError: list.append() takes exactly one argument (2 given)
"""

extend(val)

extend()函数可以向原列表尾部插入多个元素（尾插法），实际上是使用一个列表来扩充另一个列表，所以extend()的参数实际上是另外一个列表

numbers = [1, 2, 3, 4, 5]
numbers.extend([6, 7, 8])
print(numbers)  # [1, 2, 3, 4, 5, 6, 7, 8]

insert(index,val)

insert()函数可以往列表的任意未知插入元素，insert()函数有两个参数：

index：插入的索引值
val：插入的元素值

numbers = [1, 2, 3, 4, 5]
numbers.insert(0, 0)
print(numbers)  # [0, 1, 2, 3, 4, 5]

如上就是把0这个值插入在了列表的0索引处

Python中索引与元素值的对应关系如下图所示：

接着上面的代码，如下代码就是在索引为6的地方插入元素值6

numbers.insert(6, 6)
print(numbers)  # [0, 1, 2, 3, 4, 5, 6]

与Java不同的是，Python中的索引可以是负数，表示与尾部的相对距离，最后一个元素的索引为-1，往前一位为-2，以此类推

如下图所示：

如果接着上述代码在索引为5位置(也是索引值为-2)插入元素5.5，可以这样表示：

numbers.insert(-2, 5.5)
print(numbers)  # [0, 1, 2, 3, 4, 5.5, 5, 6]

3.从列表中获取元素

通过索引值可以直接获取列表中的某个元素：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
print(eggs[0])  # 鸡蛋
print(eggs[-1])  # 铁蛋

如果要将“鸭蛋”和“铁蛋”的位置进行调换，可以这么写：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
temp = eggs[1]
eggs[1] = eggs[-1]
eggs[-1] = temp
print(eggs)  # ['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']

经典冒泡排序交换位置的写法，这里的temp是一个临时变量，不过Python提供了更加方便的交换语法：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
eggs[1], eggs[-1] = eggs[-1], eggs[1]
print(eggs)  # ['鸡蛋', '铁蛋', '鹅蛋', '鸭蛋']

有时候可能需要开发一个具有抽奖功能的程序，只需要先将奖项放到列表里，然后再配合random模块即可实现：

import randomprizes = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
print(random.choice(prizes))  # 铁蛋
print(random.choice(prizes))  # 鸭蛋

random的choice()方法可以从一个非空的序列(如列表)中随机获取一个元素

如果列表中还包含另一个列表，如果要获取内部列表的某个元素，可以使用两次索引，如：

eggs = ['鸡蛋', '鸭蛋', ['天鹅蛋', '企鹅蛋', '鸵鸟蛋'], '鹅蛋', '铁蛋']
print(eggs[2][2])  # 鸵鸟蛋

4.从列表删除元素

remove(val)

remove()方法需要指定一个待删除的元素：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
eggs.remove('铁蛋')
print(eggs)  # ['鸡蛋', '鸭蛋', '鹅蛋']

使用remove()删除元素时，不需要知道该元素在列表中的位置，但是如果指定的元素不在列表中，程序会报错：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋', '铁蛋']
eggs.remove('天鹅蛋')  # 不在列表中
"""
Traceback (most recent call last):File "C:\WorkSpace\PythonProjects\PythonBase\test\demo2.py", line 5, in <module>eggs.remove('天鹅蛋')
ValueError: list.remove(x): x not in list
"""

如果列表中存在多个相同的元素，则删除该元素第一次出现的位置上的元素

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋', '铁蛋']
eggs.remove('天鹅蛋')
print(eggs)  # ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']

pop(index)

pop()方法是将列表中指定的元素"弹"出来，也就是取出并删除的意思，它的参数是索引值,如果不带参数，默认弹出列表中的最后一个元素，如：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
print(eggs.pop())  # 铁蛋
print(eggs)  # ['鸡蛋', '鸭蛋', '鹅蛋']

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
print(eggs.pop(1))  # 鸭蛋
print(eggs)  # ['鸡蛋', '鹅蛋', '铁蛋']

del

del是Python语句，而不是列表方法亦或是BIF方法

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
del eggs[0]
print(eggs)  # ['鸭蛋', '鹅蛋', '铁蛋']

del不仅可以删除某个或者某些元素，也可以直接删除整个变量，如：

eggs = ['鸡蛋', '鸭蛋', '鹅蛋', '铁蛋']
del eggs
print(eggs)
"""
Traceback (most recent call last):File "C:\WorkSpace\PythonProjects\PythonBase\test\demo2.py", line 6, in <module>print(eggs)
NameError: name 'eggs' is not defined
"""

5.列表切片

切片(slice)语法可以说是Python十分高端的一种玩法了，这是让Java语言十分羡慕的一种语法。

需求：将list1的三个元素取出来，放到list2里面

看到这个需求后，正常coding出来的代码大致如下：

list1 = ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '闪电侠']
list2 = [list1[2], list1[3], list1[4]]
print(list2)  # ['蝙蝠侠', '绿灯侠', '闪电侠']

那如果取200个元素呢？其实用for也是可以完成的，但是Python提供了更加强大的切片方法：

list1 = ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '闪电侠']
list2 = list1[2:5]
print(list2)  # ['蝙蝠侠', '绿灯侠', '闪电侠']

切片语法

[start, end[, step]]

参数说明：

start:：开始位置(包括)
end：结束位置(不包括)
step：步长，默认值1

当然，切片的语法也是可以简化的，如上述的例子，也可写成：

list1 = ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '闪电侠']
list2 = list1[2:]
print(list2)  # ['蝙蝠侠', '绿灯侠', '闪电侠']

表示从索引2开始一直到list1结束

同理，也能验证出以下几种使用方式：

list1 = ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '闪电侠']
print(list1[2:])  # ['蝙蝠侠', '绿灯侠', '闪电侠']
print(list1[:2])  # ['钢铁侠', '蜘蛛侠']
print(list1[:])  # ['钢铁侠', '蜘蛛侠', '蝙蝠侠', '绿灯侠', '闪电侠']

如果省略了开始位置，Python会从0这个位置开始，同样道理，如果要得到从指定位置到结尾，只需要将结束位置省略掉即可，如果啥都没有，Python将返回整个列表的拷贝。

如果想要获取列表最后几个元素，可以这样写：

list1 = list(range(101))
print(list1[-10:])  # [91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

tips: 列表切片不会修改列表自身的组成结构和数据，它其实是为列表创建一个新的拷贝(副本)并返回

切片操作还有第三个参数步长，默认值是1，现在将步长修改为2：

list1 = list(range(11))
print(list1[0:-1:2])  # [0, 2, 4, 6, 8]

其实直接写成list1[::2]效果是一样的

将步长修改成-1：

list1 = list(range(11))
print(list1[::-1])  # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

将步长修改成-1相当于实现了列表的反转

6.常用操作

运算符

大多数操作符都可以运用到列表中，如：

list1 = [123]
list2 = [456]
print(list1 > list2)  # F
print(list1 <= list2)  # Tlist3 = ['apple']
list4 = ['pineapple']
print(list3 < list4)  # Tlist5 = [123, 456]
list6 = [234, 123]
print(list5 > list6)  # F

列表中只有一个元素时是可以比较的，如list1和list2

list3和list4也是直接比较的，只不过比较的是ASCII码

而当列表中包含多个元素的时候，默认是从第一个元素开始比较，所以实际比较的是123和234

list1 = [123, 456]
list2 = [234, 123]
list3 = list1 + list2
print(list3)  # [123, 456, 234, 123]

加号(+)也就是拼接操作，相当于把多个列表对象合并在一起，不过一般情况下更建议使用extend()，同理通过+也只能拼接列表

list1 = [123, 456]
list2 = list1 * 3
print(list2)  # [123, 456, 123, 456, 123, 456]

乘号(*)也叫重复操作符

成员关系操作符in和not in判断某元素是否在列表中，但是只能判断一层，如：

list1 = ['Abo', 'Jack', 'Riven', ['Graven', 'Seven', 'Master']]
print('Abo' in list1)  # T
print('Seven' in list1)  # F

在开发中，如果需要去除列表重复的数据，就可以使用in和not in实现：

old_list = ['西班牙', '葡萄牙', '葡萄牙', '牙买加', '匈牙利']
new_list = []
for item in old_list:if item not in new_list:new_list.append(item)
print(new_list)  # ['西班牙', '葡萄牙', '牙买加', '匈牙利']

常用方法

通过dir()查看list的方法：

print(dir(list))
"""
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
"""

有很多已经提到过的方法，如append()、insert()、pop()、remove()等，除此之外还有一些常见的方法。

count()

count()方法是统计某个元素在列表中出现的次数，如：

list1 = [1, 2, 3, 4, 5, 6, 1, 1, 1]
print(list1.count(1))  # 4

index()

index()方法是返回某个元素第一次出现的索引值，如：

list1 = [1, 2, 3, 4, 5, 6, 1, 1, 1]
print(list1.index(1))  # 0

index()方法也可以限定查找的范围：

list1 = [1, 2, 3, 4, 5, 6, 1, 1, 1]
start = list1.index(1) + 1
stop = len(list1)
print(list1.index(1, start, stop))  # 6

语法：index(val, start, end)

val：需要查找的元素值
start：开始位置
end：结束位置

reverse()

reverse()方法的作用是将整个列表原地翻转：

list1 = [1, 2, 3, 4, 5, 6, 1, 1, 1]
list1.reverse()
print(list1)  # [1, 1, 1, 6, 5, 4, 3, 2, 1]

sort()

sort()方法的作用是对列表元素进行排序,默认是升序排序，需要修改成降序排列的话需要将sort中的属性reverse修改为True，它的默认值是sort(revert=False)

list1 = [1, 2, 3, 4, 5, 6, 1, 1, 1]
list1.sort()
print(list1)  # [1, 1, 1, 1, 2, 3, 4, 5, 6]list1.sort(reverse=True)
print(list1)  # [6, 5, 4, 3, 2, 1, 1, 1, 1]