Python-列表

分类 Python 标签 Python 评论:

列表
使用如下比较运算符对两个列表进行比较，比较规则为：首先比较两个列表中的第一个元素，如果相等则继续比较下去，直到两个列表中的元素不相等时，其比较结果就是两个列表的比较结果，两个列表中的所有后续元素将不再被比较```bash>>=<<=

列表

列表相当于其他编程语言中的数组

特点：

列表中所有数据是按顺序有序排列的；
列表中的所有数据都有两个整数类型的索引，通过指定的索引总能映射到唯一的数据；（正向0到n，反向-1到-n）；
列表中可以存在重复的数据；
列表中可以保存任何类型的数据，多种类型的数据可以混合存储在一个列表中；
列表可以根据需要动态伸缩，也就是说，系统会根据需要动态的分配和回收内存，在使用前无需先声明列表的容量；

列表的创建：

1、使用中括号

>>> L = ['Python', 19, True, None]
>>> L
['Python', 19, True, None]

2、调用内置函数list

>>> L = list(range(6))
>>> L
[0, 1, 2, 3, 4, 5]

只能传递一个参数，列表元素需要用[]/()/{}括起来

>>> list(1, 2, 3)                                      
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list expected at most 1 arguments, got 3

>>> L1 = list([1, 2, 3])
>>> L1
[1, 2, 3]

>>> L2 = list((1, 2, 3))
>>> L2
[1, 2, 3]

>>> L3 = list({1, 2, 3})
>>> L3
[1, 2, 3]

获取索引

查询列表中的元素的索引，如果有重复相同的元素，则返回第一个元素的索引号，通过index()方法查询

>>> L = ['a', 'b', 'c', 'd', 'e', 'b']
>>>
>>> L.index('a')
0
>>>
>>> L.index('b')             ##最后还有一个'b'，返回的是第一个'b'
1
>>> L.index('c')
2

>>> L.index('c', -5, -2)
2

index()方法还可以指定起始索引和结束索引两个参数，但是如果只传其中一个参数，那么只能传起始索引，不能传结束索引，start、stop同样也是左闭右开

>>> L
['a', 'b', 'c', 'd', 'e', 'b']


>>> L.index('c', 1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'c' is not in list


>>> L.index('c', 2, 3)
2

通过索引查询列表中的元素，一次只能获得一个元素

>>> L = ['a', 'b', 'c', 'd', 'e', 'b']
>>>
>>> L[0]
'a'
>>> L[5]
'b'
>>> L[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

>>> L[-5]
'b'
>>> L[-6]
'a'
>>>
>>> L[-7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

切片

切片获取列表中的元素，一次获取多个元素
切片语法格式：[start, stop, step]
切片不包括索引为stop的元素，左闭右开
如果不指定step，则默认为1，此时语法可以简化为[start, stop]
当step为正数时：

如果不指定start，切片的第一个元素默认是列表的第一个元素。
如果不指定stop，切片的最后一个元素默认是列表的最后一个元素。
从索引start开始往后进行切片计算

当step为负数时：

如果不指定start，切片的第一个元素默认是列表的最后一个元素。
如果不指定stop，切片的最后一个元素默认是列表的第一个元素。
从索引start开始往前进行切片计算

切片操作十分有用。我们先创建一个0-99的数列：

>>> L = list(range(100)) 
>>> L 
[0, 1, 2, 3, ..., 99]

可以通过切片轻松取出某一段数列。
前10个数：

>>> L[:10] 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10个数：

>>> L[-10:] 
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

>>> L[-10:-1]            
[90, 91, 92, 93, 94, 95, 96, 97, 98]

需要注意的是，当想要切出从倒数第一个元素到倒数第2个元素的时候，不能使用[-2 : -1]，因为[-2 : -1]并不包括-1，而是包括-2，如果需要切出倒数第一个到倒数第二个，需要使用[-2 : ]，后面不能跟-1。

前11-20个数：

>>> L[10:20] 
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10个数，每两个取一个：

>>> L[:10:2] 
[0, 2, 4, 6, 8]

所有数，每5个取一个：

>>> L[::5] 
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不写，只写[:]就可以原样复制一个list：

>>> L[:] 
[0, 1, 2, 3, ..., 99]

>>> L[：:] 
[0, 1, 2, 3, ..., 99]

步长为负数的情况

>>> L[::-1]                         ##可用于反转列表
[99, 98, 97, 96, ..., 0]

从50往前切片，到30

>>> L[50:30:-2]
[50, 48, 46, 44, 42, 40, 38, 36, 34, 32]

因为step为负数，因此只能往前切片，所以stop为100切不到，返回空列表

>>> L[50:100:-2]
[]

切片操作是允许索引越界的，就是说，超出索引的范围，仍可以进行切片操作

>>> L[:200:2]
[0, 2, 4, 6, ..., 98]

>>> L[:-200:-2]
[99, 97, 95, 93, ..., 1]

切片还有一种内置函数可以调用，就是slice()内置函数，其有三种调用方式

slice(stop)
slice(start, stop)
slice(start, stop, step)

start、stop、step的默认值都是None。
slice(start, stop, step)与切片的start, stop, step是等价的。

slice()返回的是一个切片对象，可以赋值给变量，再使用变量来进行切片，例如：

>>> L = list(range(100))
>>>
>>> myslice = slice(10, 20, 2)
>>>
>>> myslice
slice(10, 20, 2)
>>>
>>> L[myslice]                    ##这里是[]而不是()
[10, 12, 14, 16, 18]

使用in关键字判断列表中是否存在元素，存在返回True，不存在返回False，例如：

>>> L = list(range(100))
>>> 10 in L
True
>>> 200 in L
False

tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串’xxx’也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作（但是不能修改，字符串是不可变对象），只是操作结果仍是字符串：


>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

修改元素

有两种常用方式：
1、为指定元素赋一个新值（一次只能修改一个元素）

>>> L = [1, 2, 3, 4, 5]
>>> L[2] = 'a'
>>> L
[1, 2, 'a', 4, 5]

2、为指定的切片赋一个新值（一次至少修改一个元素），等号左右的元素个数可以不同，赋的值必须也是一个列表

>>> L = [1, 2, 3, 4, 5]
>>> L[1:4] = ['a', 'b', 'c']
>>> L
[1, 'a', 'b', 'c', 5]
>>> L[1:4] = ['OK']
>>> L
[1, 'OK', 5]

特殊情况，字符串也可以当作一个列表，因为没有用[]括起来，所以不会修改为’ok’整个字符串

>>> L[:2] = 'ok'
>>> L
['o', 'k', 5]

添加元素（append()、extend()、insert()、给指定的切片赋一个新值）

1、append方法，在列表末尾添加新的对象

>>> L = [1, 2, 3]

>>> L.append(6)
>>> L
[1, 2, 3, 6]

>>> L.append([7, 8])
>>> L
[1, 2, 3, 6, [7, 8]]

2、extend()方法，在列表末尾一次性追加另一个序列的多个值，用新序列扩展原来的列表

>>> L = [1, 2, 3]
>>> L.extend([4, 5, 6])
>>> L
[1, 2, 3, 4, 5, 6]

3、insert()方法，在列表的任意位置添加元素，一次只能添加一个元素，原来该位置后的元素依次向后移一个位置

>>> L = [1, 2, 3]
>>> L.insert(1, 'a')
>>> L
[1, 'a', 2, 3]

>>> L.insert(1, 'a', 'b')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: insert() takes exactly 2 arguments (3 given)

4、为指定的切片赋一个新值，在列表的任意位置添加元素，一次可以添加多个元素，原来该位置后的元素依次向后移一个位置，（extend只能在列表末尾添加）

>>> L = [1, 2, 3]
>>> L[1:1] = 'a'
>>> L
[1, 'a', 2, 3]

>>> L[2:2] = ['b', 'c']
>>> L
[1, 'a', 'b', 'c', 2, 3]

删除元素（remove()、pop()、del关键字、给指定的切片赋值一个空列表、clear()）

1、remove()方法，一次只删除一个元素。删除元素后面的元素依次向前移动一个位置

>>> L = [1, 2, 3, 4, 5]
>>> L.remove(2)                      ##参数是元素，而不是元素索引
>>> L
[1, 3, 4, 5]

如果列表中存在多个指定元素，只删除第一个指定的元素

>>> L = [1, 2, 3, 2, 1]
>>> L.remove(2)
>>> L
[1, 3, 2, 1]

2、pop()方法，一次只删除一个指定索引的元素，该方法并返回该被删除元素，如果不指定索引，则默认是最后一个元素的索引

>>> L = [1, 2, 3, 4, 5]
>>> L.pop(2)                       ##参数是元素的索引
3

>>> L = [1, 2, 4, 5]
>>> L.pop()
5

>>> L
[1, 2, 4]

3、del关键字，一次至少删除一个元素

>>> L = [1, 2, 3, 4, 5]
>>> del L[2]
>>> L
[1, 2, 4, 5]

>>> del L[:2]           ##删除指定切片
>>> L
[4, 5]

4、给指定的切片赋值一个空列表

>>> L = [1, 2, 3, 4, 5]
>>> L[1:3] = []
>>> L
[1, 4, 5]

清空列表

>>> L[:] = []          使用这种方法清空列表，该对象是不变的，如果直接使用L = []赋予一个空列表，该对象是不同的
>>> L
[]

>>> L = [1, 2, 3]         
>>> id(L)
140438784964680
>>>
>>> L[:] = []                      ##内存地址不变
>>> id(L)
140438784964680

>>> L = [1, 2, 3]
>>> id(L)
140438784964680
>>>
>>>
>>> L = []                         ##内存地址发生了变化
>>> id(L)
140438784966152

clear()方法，清空列表，对象也是不变的

>>> L = [1, 2, 3, 4, 5]
>>> id(L)
140438784966152
>>>
>>> L.clear()
>>>
>>> L
[]
>>> id(L)
140438784966152

列表反转

1、reverse()方法

>>> L = [1, 2, 3]
>>> L.reverse()
>>> L
[3, 2, 1]

2、内置函数reversed()，返回的是一个迭代器对象，原列表不变

>>> L = [1, 2, 3, 4, 5]
>>> iter = reversed(L)
>>> iter
<list_reverseiterator object at 0x7f4488635f98>
>>> list(iter)
[5, 4, 3, 2, 1]
>>> L
[1, 2, 3, 4, 5]

3、使用列表切片反转

>>> L = [1, 2, 3, 4, 5]
>>> L[::-1]
[5, 4, 3, 2, 1]

列表统计元素

1、count()方法，统计元素在列表中出现的次数

>>> L = [3, 2, 3, 4, 8, 1, 4, 1, 4]
>>> L.count(3)
2
>>> L.count(1)
2
>>> L.count(4)
3

列表排序元素

1、sort()方法，默认从小到大排序，指定reverse = True后，从大到小排序

>>> L = [3, 2, 3, 4, 8, 1]
>>> L.sort()
>>> L
[1, 2, 3, 3, 4, 8]

>>> L = [3, 2, 3, 4, 8, 1]
>>> L.sort(reverse = True)
>>> L
[8, 4, 3, 3, 2, 1]

2、内置函数sorted()，返回值是排序后的新列表，被排序的列表不发生变化，同样可以使用reverse进行逆序排序

>>> L = [3, 2, 3, 4, 8, 1]
>>> sorted(L)
[1, 2, 3, 3, 4, 8]
>>> L
[3, 2, 3, 4, 8, 1]

>>> sorted(L, reverse = True)
[8, 4, 3, 3, 2, 1]

3、调用内置函数sorted()时，还可以指定参数key = 函数名，或者key = 类名.方法名，这样会对列表中的所有元素分别调用指定的函数或方法，然后按照函数或方法的返回值进行排序，从而自定义排序规则

>>> s = ['python', 'java', 'php']
>>> sorted(s, key = len)
['php', 'java', 'python']

4、同样的使用方法sort()的时候，也可以按照上述的方法，来自定义排序规则

>>> s.sort(key = len)
>>> s
['php', 'java', 'python']

使用运算符加法和乘法操作列表

1、可以使用加法运算符将两个列表合并后生成一个新的列表，被合并的两个列表不会发生变化。

>>> L1 = [1, 2, 3]
>>> L2 = [4, 5, 6]
>>> L3 = L1 + L2
>>> L3
[1, 2, 3, 4, 5, 6]
>>> L1
[1, 2, 3]
>>> L2
[4, 5, 6]

>>> L1 = L2 = [1, 2]
>>> L1 = L1 + [3, 4]
>>> L1
[1, 2, 3, 4]
>>> L2
[1, 2]

>>> L1 = L2 = [1, 2]
>>> L1 += [3, 4]                ##参数赋值运算符“+=”会对列表对象本身进行修改，但是对字符串或者数字类型的对象不会，因为其仅会改变可变对象
>>> L1
[1, 2, 3, 4]
>>> L2
[1, 2, 3, 4]

>>> a = b =1                    ##对于不可变对象，就不会对对象本身进行修改
>>> a += 1
>>> a
2
>>> b
1

2、使用乘法运算符操作列表，可以将列表中的所有元素重复n次后生成一个新列表，被乘的列表不发生任何变化

>>> L1 = [1, 2]
>>> L2 = L1 * 3
>>> L1
[1, 2]
>>> L2
[1, 2, 1, 2, 1, 2]

>>> L1 = L2 = [1, 2]            ##参数赋值运算符“+=”会对列表对象本身进行修改，但是对字符串或者数字类型的对象不会，因为其仅会改变可变对象
>>> L1 *= 3
>>> L1
[1, 2, 1, 2, 1, 2]
>>> L2
[1, 2, 1, 2, 1, 2]

3、常用于列表的初始化

>>> L = [0] * 5
>>> L
[0, 0, 0, 0, 0]

比较运算符比较列表

使用如下比较运算符对两个列表进行比较，比较规则为：首先比较两个列表中的第一个元素，如果相等则继续比较下去，直到两个列表中的元素不相等时，其比较结果就是两个列表的比较结果，两个列表中的所有后续元素将不再被比较
```bash
>
>=
<
<=


 

## 多维列表
一维列表的操作也适用于多维列表

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 289211569@qq.com