Python3列表

一、列表

1. 通用的列表操作

列表是可变的，可以修改其内容

1.1 列表的创建

只要把逗号分隔的不同的数据项使用方括号括起来即可

>>> a = [1, 2, 3, 4]
>>> a
[1, 2, 3, 4]

 

​空列表是使用不包含任何内容的两个方括号表示

>>> a = []
>>> a
[]
>>> type(a)                       #type()函数用于获取对象的类型
<class 'list'>

如果要创建一个可包含5个元素的空列表（即表示还没有在列表中添加任何内容），

这种情况在可使用None（表示什么都没有）

>>> [None] * 5
[None, None, None, None, None]

 

1.2 列表的索引

列表可以使用下标索引来访问列表中的值。索引0指向第一个元素，索引-1指向最后一个元素。

>>> broswer = ['google', 'baidu', 'souhu']
>>> broswer[1]
'baidu'
>>> a = 'hello'                     #字符串就是由字符组成的序列
>>> a[0]
'h'
>>> a[-1]
'o'

 

1.3 切片

除了使用索引来访问单个元素外，还可以使用切片来访问特定范围内的元素。其中第一个索引号是包含第一个元素的编号（即第一个索引指定的元素包含在切片内），但第二个索引号是切片后余下的第一个元素的编号（第二个索引指定的元素不包含在切片内），第三个索引号为步长，是指当取出前一项时，移动多少个元素去取下一个值（若没有这一项，默认为1），也可以使用负数来表示列表.

>>> a[1:3]
[2, 3]
>>> a[1:4:2]
[2, 4]

 

1.4 列表的相加和相乘

可以使用“+”操作符来拼接序列（不能拼接列表和字符串一般而言，不能拼接不同类型的序列）

可以使用“*”操作符来重复这个序列n次，并且创建一个新序列

>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> 
>>> 'hello' * 3
'hellohellohello'
>>> [42] * 3
[42, 42, 42]

1.5 列表的成员资格

 

要检查特定的值是否包含在序列中，可使用运算符in。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值

>>> users = ['Bob', 'Sally', 'Green']
>>> 'Bob' in users
True
>>> 'Siry' in users
False

 

1.6 列表的嵌套

使用嵌套列表即可在列表里创建其他列表

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> c = [a, b]
>>> c
[[1, 2, 3], [4, 5, 6]]

 

2. 列表的函数

2.1 len()

返回序列包含的元素个数

​2.2 max()/min()

返回序列中最大/最小的元素

2.3 list()

 

将序列转换为列表，如果参数是列表，就原封不动的地返回它；如果参数是字符串，也转换为列表

 

>>> a = [1, 2, 3]
>>> len(a)
3
>>> max(a)
3
>>> 
>>> list((1, 2, 3))         
[1, 2, 3]
>>> list([1, 2, 3])
[1, 2, 3]
>>> list({1, 2, 3})
[1, 2, 3]
>>> list('123')
['1', '2', '3']

 

3. 列表的基本操作

3.1 修改列表

使用索引来给特定位置的元素赋值

>>> a = [1, 2, 3]
>>> a[1] = 5

 

​3.2 删除元素

使用del()语句删除列表的元素，会改变列表的长度

>>> a = [1, 2, 3]
>>> del a[1]
>>> a
[1, 3]
>>> del a            #直接删除列表
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

 

​3.3 给切片赋值

 

>>> a = ['p', 'e', 'r', 'l']
>>> a[1:] = ['y', 't', 'h', 'o', 'n']   #使用切片可以同时给多个元素赋值。通过使用切片赋值，可 
                                         以将列表替换为长度与其不同的列表
>>> a
['p', 'y', 't', 'h', 'o', 'n']
>>> a = [1, 2, 3]
>>> a[1:1] = [2, 3, 4]                  #使用切片赋值话可以在不替换原有元素的情况下插入新元素
>>> a
[1, 2, 3, 4, 2, 3]
>>> a = [1, 2, 3, 4, 2, 3]
>>> a[1:4] = []                         #使用切片赋值还可以删除切片
>>> a
[1, 2, 3]

4. 列表方法

 

 

方法	含义
append	用于将一个对象附加到列表末尾append也就地修改列表。这意味着它不会返回修改后的新列表，而是直接修改旧列表
pop	从列表中删除一个元素（默认为最后一个元素），并返回这一元素。pop是唯一既修改列表又返回一个非None值的列表方法
remove	用于删除第一个为指定值的元素，就地修改且不返回值
insert	用于将一个元素插入元素
clear	就地清空列表的内容
copy	用于复制列表。常规复制只是将另一个名称关联到列表
count	计算指定的元素在列表中出现的次数
extend	能同时将多个值附加到列表末尾，可使用一个列表来扩展另一个列表
reverse	按相反的顺序排列列表中的元素，修改列表，但不返回任何值
sort	用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本，修改列表且不返回任何值

4.1 append()

用于将一个对象附加到列表末尾append也就地修改列表。这意味着它不会返回修改后的新列表

 

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

4.2 clear()

就地清空列表的内容

>>> a = [1, 2, 3]
>>> a.clear()
>>> a
[]

 

4.3 copy()

用于复制列表。

 

常规复制只是将另一个名称关联到列表
>>> a = [1, 2, 3]
>>> b = a
>>> b[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]

要让a和b指向不同的列表，就必须将b关联到a的副本
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> b[1] = 4
>>> a
[1, 2, 3]
>>> b
[1, 4, 3]


>>> a = [[1, 2], 2, 3]
>>> b = a.copy()
>>> b[0][1] = 3
>>> a
[[1, 3], 2, 3]
>>> b
[[1, 3], 2, 3]

 

​4.4 count()

计算指定的元素在列表中出现的次数

>>> a = [[1,2], 1, 2, [2, 1, [1, 2]]]
>>> a.count(1)
1
>>> a.count([1,2])
1
>>> ['p', 'y', 't', 'h', 'o', 'n', 'p'].count('p')
2

 

 

 

4.5 extend()

能同时将多个值附加到列表末尾，可使用一个列表来扩展另一个列表

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

这看起来类似于拼接，但有一个重要差别，那就是将修改被扩展的
列表（这里是a）。常规拼接中，返回一个全新的列表
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]

 

​4.6 index()

 

在列表中查找制定你元素第一次出现的索引

>>> ['hello', 'nice', 'to', 'meet', 'you!'].index('to')
2
>>> [1, 2, 3, 1, 2, 4, 1, 1].index(1)
0

 

4.7 insert()

用于将一个元素插入元素

>>> a = [1, 2, 4]
>>> a.insert(3, 'three')
>>> a
[1, 2, 4, 'three']
>>> a.insert(10, 'ten')        #超出列表长度不会报错，会插在末尾最后一个之后
>>> a
[1, 2, 4, 'three', 'ten']

 

4.8 pop()

从列表中删除一个元素（默认为最后一个元素），并返回这一元素。

pop是唯一既修改列表又返回一个非None值的列表方法

>>> a = [3, 4, 1, 2, 10, 8]
>>> a.pop()
8
>>> a
[3, 4, 1, 2, 10]
>>> a.pop()
10
>>> a
[3, 4, 1, 2]

 

​4.9 remove()

用于删除第一个为指定值的元素，就地修改且不返回值

>>> a = [3, 4, 1, 2, 10, 8]
>>> a.remove(4)
>>> a
[3, 1, 2, 10, 8]

 

4.10 reverse()

按相反的顺序排列列表中的元素，修改列表，但不返回任何值

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

如果要按相反的顺序迭代序列，可使用函数reversed()。这个函数不返回
列表，而是返回一个迭代器，可使用list将返回的对象转换为列表
>>> a = [1, 2, 3]
>>> reversed(a)
<list_reverseiterator object at 0x7fdf6e581be0>
>>> list(reversed(a))
[3, 2, 1]

 

4.11 sort()

 

用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本，修改列表且不返回任何值

 

 

>>> a = [4, 2, 5, 8, 9, 7]
>>> a.sort()
>>> a
[2, 4, 5, 7, 8, 9]

>>> a = [4, 2, 5, 8, 9, 7]
>>> b = a.sort()             #sort对需要排序后的列表副本并保留原始列表不变时，通常会遇到以下错误
>>> print(b)
None

为获取排序后的列表的副本，可使用函数sorted()函数
>>> a = [4, 2, 5, 8, 9, 7]
>>> b = sorted(a)
>>> a
[4, 2, 5, 8, 9, 7]
>>> b
[2, 4, 5, 7, 8, 9]

4.12 高级排序

 

 

sort(cmp=None, key=None, reverse=False) 

cmp

用于比较的函数，比较什么由key决定

key

参数key类似于参数cmp：可以将其设置为一个用于排序的函数。然而，不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。因此，要根据长度对元素进行排序，可将参数key设置为函数len

>>> a = ['python', 'c', 'java', 'javascript', 'shell', 'php']
>>> a.sort(key=len)
>>> a
['c', 'php', 'java', 'shell', 'python', 'javascript']

 

reverse

对于另一个关键字参数reverse，只需将其指定为一个真值（True或False，），以指出是否要按相反的顺序对列表进行排序

>>> a = [4, 2, 5, 8, 9, 7]
>>> a.sort(reverse=True)
>>> a
[9, 8, 7, 5, 4, 2]