python中的list、tuple、dict、set

发表于 | 分类于 |

python API 速查表

list(列表)

创建

属于python内置的一种数据类型。list是一种有序集合，是python中最常见的数据类型。可以任意添加和删除其中的元素，索引从0开始。

1
2
3
>>> list1 = ['Tom', 'Alice', 'Kevin', 'Bill']
>>> list1
['Tom', 'Alice', 'Kevin', 'Bill']

也可以不同类型组合

1
2
3
>>> list2 = ['Tome', 20, True, 23.2]
>>> list2
['Tome', 20, True, 23.2]

获取list集合的长度

1
2
3
4
>>> len(list1)
4
>>> len(list2)
4

组合

1
2
>>> list1 + list2
['Tom', 'Alice', 'Kevin', 'Bill', 'Tome', 20, True, 23.2]

重复

1
2
>>> list1 * 3
['Tom', 'Alice', 'Kevin', 'Bill', 'Tom', 'Alice', 'Kevin', 'Bill', 'Tom', 'Alice', 'Kevin', 'Bill']

元素是否存在于列表中

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

迭代

1
2
3
4
>>> for x in [1, 2, 3]:
...     print x,
...
1 2 3

访问

访问list集合中的数据：用索引来找出每一个位置对应的值

1
2
3
4
5
6
7
8
9
10
>>> list1[0]
'Tom'
>>> list1[3]
'Bill'
>>> list1[0 : 2]
['Tom', 'Alice']
>>> list1[4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界, 索引范围0 到 len(list)-1
当然也可反向取值，用负数做索引

1
2
3
4
5
6
7
8
>>> list1[-1]
'Bill'
>>> list1[-4]
'Tom'
>>> list1[-5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

也是存在范围的，倒数第五个就越界了。

更新

可以用append()方法追加列表项

1
2
3
>>> list1.append('Jason')
>>> list1
['Tom', 'Alice', 'Kevin', 'Bill', 'Jason']

也可以用insert()把元素插入到指定的位置

1
2
3
>>> list1.insert(2, 'Jack')
>>> list1
['Tom', 'Alice', 'Jack', 'Kevin', 'Bill', 'Jason']

用pop()方法来删除指定的元素，返回被你删除的元素

1
2
3
4
5
>>> d = list1.pop(2)
>>> d
'Jack'
>>> list1
['Tom', 'Alice', 'Kevin', 'Bill', 'Jason']

如果不传索引默认删除最后一项

1
2
3
4
5
6

>>> d = list1.pop()
>>> d
'Jason'
>>> list1
['Tom', 'Alice', 'Kevin', 'Bill']

关于删除还可以使用del语句来实现删除列表的元素或者删除整个list

1
2
3
4
5
6
7
8
>>> del list2[3]
>>> list2
['Tome', 20, True]
>>> del list2
>>> list2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'list2' is not defined

有兴趣的还可以查查remove()方法的使用。

如果要修改某一个值，直接用索引给对应的位置赋值

1
2
3
>>> list1[1] = 'Rose'
>>> list1
['Tom', 'Rose', 'Kevin', 'Bill']

list元素也可以是另一个list，比如：

1
2
3
4
5
6
>>> list3 = [1, 2, 3]
>>> l = [4, 5, 6, list3, 7]
>>> l
[4, 5, 6, [1, 2, 3], 7]
>>> len(l)
5

可以把l看成一个二维数组了，可以有三维，四维….

1
2
>>> l[3][1]
2

Python列表函数&方法

  1. list.append(obj) 在列表末尾添加新的对象
  2. list.count(obj) 统计某个元素在列表中出现的次数
  3. list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
  4. list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
  5. list.insert(index, obj) 将对象插入列表
  6. list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
  7. list.remove(obj) 移除列表中某个值的第一个匹配项
  8. list.reverse() 反向列表中元素
  9. list.sort([func]) 对原列表进行排序

tuple (元组)

Python的有序列表元组与列表类似，不同之处在于元组的元素一旦初始化就不能修改，列表使用方括号，元组使用小括号。

创建

使用逗号分隔

1
2
3
>>> tuple1 = ('Tom', 'Jack', 'Rose')
>>> tuple1
('Tom', 'Jack', 'Rose')

tuple不能修改，没有append()和insert()这样的方法，可以正常使用tuple1[0]但不能赋值。
因为tuple不可变它的优势就是代码更安全，如果有可能建议尽量tuple代替list使用

访问tuple

1
2
3
4
>>> tuple1[0]
'Tom'
>>> tuple1[-1]
'Rose'

只有一个元素的定义

1
2
3
>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,来消除歧义：

1
2
3
>>> t = (1,)
>>> t
(1,)

tuple元素的取值、删除、运算，索引截取包括内置函数都和list一致，
需要注意的是，元组的元素是可以为list的，什么意思呢，我们来看一下

1
2
3
4
5
6
7
>>> t = ('a', 'b', ['c', 'd'], 'e')
>>> t
('a', 'b', ['c', 'd'], 'e')
>>> t[2][0]
'c'
>>> t[2][1]
'd'

需要注意的是这个时候元组的元素list是可以修改更新的

1
2
3
4
5
6
>>> t[2][0] = 'f'
>>> t
('a', 'b', ['f', 'd'], 'e')
>>> t[2].append('q')
>>> t
('a', 'b', ['f', 'd', 'q'], 'e')

dict（字典）

字典是另一种可变容器模型，且可存储任意类型对象，dict的全称是dictionary，也可以理解为map,它是使用key-value进行存储，使用字典采用花括号(大括号){}
特点： 占用空间大，查找速度快，不会随着字典的大小影响查找效率

创建

1
2
3
>>> dict1 = {'Jack' : 20, 'Jason' : 21, 'Alice' : '18'}
>>> dict1
{'Jason': 21, 'Jack': 20, 'Alice': '18'}

特点:
key在字典中是唯一的不可变的，如果重复，后面的会覆盖前面的，变量不能充当key
value不需要唯一并且可以取任何数据类型，可以是标准的对象，也可以是用户定义的对象

访问

根据key查找value

1
2
>>> dict1['Jack']
20

如果key不存在则会报错

1
2
3
4
>>> dict1['Bill']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Bill'

所以我们可以判断当前字典中是否存在来规避出现错误

1
2
3
4
5
>>> 'Bill' in dict1
False
>>> dict1.get('Bill')
>>> dict1.get('Bill', 'None')
'None'

修改

找出对应的key的位置直接赋值

1
2
3
>>> dict1['Jason'] = 23
>>> dict1
{'Jason': 23, 'Jack': 20, 'Alice': '18'}

删除

删除操作跟list类似这不过字典是根据key来删除某一项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

>>> dict1.pop('Jason')
23
>>> dict1
{'Jack': 20, 'Alice': '18'}
>>> del dict1['Jack']
>>> dict1
{'Alice': '18'}
>>> dict1.clear()  # 清空词典所有条目
>>> dict1
{}
>>> del dict1     # 删除词典
>>> dict1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'dict1' is not defined

字典内置函数&方法

  • mp(dict1, dict2)比较两个字典元素。
  • len(dict) 比较两个字典元素。
  • str(dict) 输出字典可打印的字符串表示
  • type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。
  1. dict.clear() 删除字典内所有元素
  2. dict.copy() 返回一个字典的浅复制
  3. dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
  4. dict.has_key(key) 如果键在字典dict里返回true，否则返回false
  5. dict.items() 以列表返回可遍历的(键, 值) 元组数组
  6. dict.keys()以列表返回一个字典所有的键
  7. dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
  8. dict.update(dict2) 把字典dict2的键/值对更新到dict里
  9. dict.values() 以列表返回字典中的所有值
  10. pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
  11. popitem() 随机返回并删除字典中的一对键和值

set（集合）

set只能存储key, 同样不能重复
它有可变集合(set())和不可变集合(frozenset)两种。创建集合set、集合set添加、集合删除、交集、并集、差集的操作都是非常实用的方法。

创建

1
2
3
4
5
6
>>> s1 = set([1, 2, 3])
>>> s1
set([1, 2, 3])
>>> s1 = set('1234')
>>> s1
set(['1', '3', '2', '4'])

注意，传入的参数[1, 2, 3]是一个list，而显示的set([1, 2, 3])只是告诉你这个set内部有1，2，3这3个元素，显示的[]不表示这是一个list

重复元素 无效会被自动过滤 只保留唯一

1
2
3
>>> s1 = set([1,2,3,4,2,3,1])
>>> s1
set([1, 2, 3, 4])

集合添加

python 集合的添加有两种常用方法，分别是add和update。
集合add方法：是把要传入的元素做为一个整个添加到集合中

1
2
3
4
5
6
>>> s1 = set('123')
>>> s1
set(['1', '3', '2'])
>>> s1.add('456')
>>> s1
set(['1', '3', '2', '456'])

集合update方法：是把要传入的元素拆分，做为个体传入到集合中

1
2
3
>>> s1.update('789')
>>> s1
set(['456', '1', '3', '2', '7', '9', '8'])

删除

集合删除操作方法：remove

1
2
3
4
5
6
7
>>> s1.remove('456')
>>> s1
set(['1', '3', '2', '7', '9', '8'])
>>> s1.remove('789')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: '789'

操作符

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作

1
2
3
4
5
6
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])
python符号 含义
- 差集，相对补集
& 交集
丨 合集，并集
!= 不等于
== 等于
in 成员关系
not in 不是成员关系 
1
2
3
4
5
6
7
8
9
10
11
12
>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2  # 交集
set([2, 3])
>>> s1 | s2  # 合集
set([1, 2, 3, 4]) 
>>> s1 - s2 # 差集，相对补集
set([1])
>>> s1 in s2 # 成员关系
False
>>> s1 not in s2 # 非成员关系
True