文章目录
  1. 1. 1.1.2 列表
    1. 1.1. 常用列表方法
      1. 1.1.1. append这个是向列表末尾追加一个元素,如下:
      2. 1.1.2. clear 清除一个列表中的所有元素
    2. 1.2. copy 复制一个列表
      1. 1.2.1. count 计算某个元素在列表中出现的次数,如下:
      2. 1.2.2. extend 直接向列表末尾一次性追加另一个列表,如下:
      3. 1.2.3. index 从列表中找出某个值第一个匹配的索引位置
      4. 1.2.4. insert 将对象插入列表中
      5. 1.2.5. pop 移除列表中的最后一个元素,默认是最后一个
      6. 1.2.6. remove 移除列表中第一个匹配的元素
      7. 1.2.7. reverse 将列表中的元素反向存放
      8. 1.2.8. sort 对列表排序,这个我比较喜欢,里面挺多好玩的东西,下面做个简单的介绍
    3. 1.3. 使用 in 判断值是否存在
    4. 1.4. 使用 len() 获取长度
    5. 1.5. 使用=赋值,使用copy()复制

1.1.2 列表

列表由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或 所有家庭成员姓名的列表;也可以将任何东西加入列表中,其中的元素之间可以没有任何关系。 鉴于列表通常包含多个元素,给列表指定一个表示复数的名称(如names)是个不错的主意。

列表非常适合利用顺序和位置定位某一元素,尤其是当元素的顺序或内容经常发生改变时。与字符串不同,列表是可变的。你可以直接对原始列表进行修改:添加新元素、删除 或覆盖已有元素。在列表中,具有相同值的元素允许出现多次。

常用列表方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
>>> dir(list)

['__add__',
'__class__',
'__contains__',
'__delattr__',
'__delitem__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__gt__',
'__hash__',
'__iadd__',
'__imul__',
'__init__',
'__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这个是向列表末尾追加一个元素,如下:

1
2
3
4
>>> numbers = [1,2,2,3,3,3]
>>> numbers.append(4)
>>> numbers
[1, 2, 2, 3, 3, 3, 4]

clear 清除一个列表中的所有元素

1
2
3
4
5
6
7
>>> n
[1, 2, 3, 4, 5]

>>> n.clear()

>>> n
[]

copy 复制一个列表

1
2
3
4
5
6
7
8
9
10
11
12
>>> n = [1,2,3,4,5]

>>> n.copy()
[1, 2, 3, 4, 5]

>>> n.copy()
[1, 2, 3, 4, 5]

>>> num = n.copy()

>>> num
[1, 2, 3, 4, 5]

count 计算某个元素在列表中出现的次数,如下:

1
2
3
4
5
6
7
8
9
10
>>> numbers
[1, 2, 2, 3, 3, 3, 4]
>>> numbers.count(1)
1
>>> numbers.count(2)
2
>>> numbers.count(3)
3
>>> numbers.count(4)
1

extend 直接向列表末尾一次性追加另一个列表,如下:

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

index 从列表中找出某个值第一个匹配的索引位置

1
2
3
4
5
6
7
8
9
10
>>> numbers
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> numbers.index(1)
0
>>> numbers.index(2)
1
>>> numbers.index(3)
3
>>> numbers.index(4)
6

insert 将对象插入列表中

1
2
3
4
5
>>> numbers
[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> numbers.insert(0,0)
>>> numbers
[0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

pop 移除列表中的最后一个元素,默认是最后一个

1
2
3
4
5
6
>>> numbers
[0, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
>>> numbers.pop()
4
>>> numbers
[0, 1, 2, 2, 3, 3, 3, 4, 4, 4]

remove 移除列表中第一个匹配的元素

1
2
3
4
5
6
7
8
>>> num
[1, 2, 1, 3, 2]
>>> num.remove(1)
>>> num
[2, 1, 3, 2]
>>> num.remove(2)
>>> num
[1, 3, 2]

reverse 将列表中的元素反向存放

1
2
3
4
5
>>> numbers
[0, 1, 2, 2, 3, 3, 3, 4, 4, 4]
>>> numbers.reverse()
>>> numbers
[4, 4, 4, 3, 3, 3, 2, 2, 1, 0]

sort 对列表排序,这个我比较喜欢,里面挺多好玩的东西,下面做个简单的介绍

默认排序:

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

自定义排序:

查看sort的使用方法

1
2
>>> L.sort.__doc__
'L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*'

根据提供的key函数为元素产生一个键,列表的元素按照这个键值来排序

1
2
3
4
>>> x = ['abc','a','bc','abcd']
>>> x.sort(key=len)
>>> x
['a', 'bc', 'abc', 'abcd’]

反向排序

1
2
3
4
>>> n = [3, 1, 2, 5]
>>> n.sort(reverse=True)
>>> n
[5, 3, 2, 1]

使用 in 判断值是否存在

判断一个值是否存在于给定的列表中的许多方式,其中最具有 Python 风格的是使用 in:

1
2
3
4
5
6
>>> num = [1, 2, 3]
>>> 1 in num
True
>>> 5 in num
False
>>>

同一个值可能出现在列表的多个位置,但只要至少出现一次,in就会返回Ture

1
2
3
>>> num = [1, 1, 2, 3]
>>> 1 in num
True

使用 len() 获取长度

len() 可以返回列表长度:

1
2
3
>>> num = [1, 2, 3]
>>> len(num)
3

使用=赋值,使用copy()复制

如果将一个列表赋值给了多个变量,改变其中的任何一处造成其他变量对应的值也被修改,如下所示:

1
2
3
4
 >>> a = [1, 2, 3]
>>> a
[1, 2, 3]
>>> b = a
>>> b
[1, 2, 3]
>>> a[0] = 'surprise'
>>> a ['surprise', 2, 3]
>>> b
['surprise', 2, 3]

还记得解释变量的时候,那个贴标签的比喻吗?b与a实际上指向的是同一个对象,因此,无论我们是通过a还是b来修改列表的内容,其结果都会作用于双方:

1
2
3
>>> b
['surprise', 2, 3]
>>> b[0] = 'I love surprises' 
>>> b ['I love surprises', 2, 3]
>>> a ['I love surprises', 2, 3]

通过下面任意一种方法,都可以将一个列表的值复制到另一个新的列表中:

  • 列表 copy() 函数
  • list() 转换函数
  • 列表分片 [:]
1
2
3
4
5
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:]
>>> a[0] = 'one'
>>> a
['one', 2, 3]
>>> b [1, 2, 3] >>> c [1, 2, 3] >>> d [1, 2, 3]

b、c、d 都是a的复制:它们是自身带有值的新对象,与原始的a所指向的列表对象[1, 2, 3]没有任何关联。所以改变a不影响b、c、d的复制。

文章目录
  1. 1. 1.1.2 列表
    1. 1.1. 常用列表方法
      1. 1.1.1. append这个是向列表末尾追加一个元素,如下:
      2. 1.1.2. clear 清除一个列表中的所有元素
    2. 1.2. copy 复制一个列表
      1. 1.2.1. count 计算某个元素在列表中出现的次数,如下:
      2. 1.2.2. extend 直接向列表末尾一次性追加另一个列表,如下:
      3. 1.2.3. index 从列表中找出某个值第一个匹配的索引位置
      4. 1.2.4. insert 将对象插入列表中
      5. 1.2.5. pop 移除列表中的最后一个元素,默认是最后一个
      6. 1.2.6. remove 移除列表中第一个匹配的元素
      7. 1.2.7. reverse 将列表中的元素反向存放
      8. 1.2.8. sort 对列表排序,这个我比较喜欢,里面挺多好玩的东西,下面做个简单的介绍
    3. 1.3. 使用 in 判断值是否存在
    4. 1.4. 使用 len() 获取长度
    5. 1.5. 使用=赋值,使用copy()复制