Python基础语法——数据结构

1.列表

列表是 Python 常用的数据类型，也是最基本的数据结构。Python 的列表是由方括号 [] 括起，使用 “,” 分隔的序列，序列中的数据类型不要求一致，序列的索引从0开始。

【示例1-1】创建一个列表，只要把逗号分隔的不同数据项使用方括号括起来即可。

>>> list1 = ['Google','Huawei',1999,2000]
>>> list2 = [1,2,3,4,5]
>>> list3 = ["a","b","c","d"]
>>> list4 = ["all of them", list1, list2, list3]
>>> print ("list1[0]:", list1[0])
list1[0]: Google
>>> print ("list2[1:5]:", list2[1:5])
list2[1:5]: [2, 3, 4, 5]
>>> print (list4)
['all of them', ['Google', 'Huawei', 1999, 2000], [1, 2, 3, 4, 5], ['a', 'b', 'c', 'd']]
>>> print (list4[1][1])
Huawei

【示例1-2】更新一个列表，可以对列表的数据项进行修改，也可以使用 append() 方法添加列表项。

>>> list = ['Google','Huawei',1999,2000]
>>> print ("第三个元素为:", list[2])
第三个元素为: 1999
>>> list[2] = 2020
>>> print ("更新后的第三个元素为:", list[2])
更新后的第三个元素为: 2020
>>> list.append('xiaomi')
>>> print ("追加后的最后一个元素为:", list[-1])
追加后的最后一个元素为: xiaomi
>>> list.insert(2, 'qq')
>>> print ("第三个位置插入的元素为:", list[2])
第三个位置插入的元素为: qq
>>> print (list)
['Google', 'Huawei', 'qq', 2020, 2000, 'xiaomi']

【示例1-3】删除列表中的某个元素

>>> list = ['Google', 'Huawei', 1999, 2000]
>>> del list[0]
>>> print (list)
['Huawei', 1999, 2000]

列表中还有一些其他的操作，如列表对 + 和 * 的操作符与字符串相似， + 号可以用于组合列表， * 号用于重复列表。

>>> len([1,2,3])
3
>>> [1,2,3] + [4,5,6]
[1, 2, 3, 4, 5, 6]
>>> ['Hi!'] * 10
['Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!', 'Hi!']
>>> 3 in [1,2,3]
True
>>> 5 in [1,2,3]
False
>>> for x in [1,2,3]: print(x, end=" ")
...
1 2 3 >>>
>>> max([1,2,3])
3
>>> min([1,2,3])
1

列表常用的方法可参见下表：

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

2. 元组

元组与列表类似，用“()”括起， “,”分隔的序列，不同于列表的是，元组是只读的，无法被修改，在定义时其元素必须确定下来，也可以像列表一样使用索引来访问。

【示例2-1】元组的应用

>>> t = ('Google', 'Huawei', 1999, 2000)    # 定义一个元组
>>> t[0]    # 使用列表一样的方式访问相应元素
'Google'
>>> t[1]
'Huawei'
>>> t[0] = 'Baidu'    # 修改元组的值将会抛出异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> t = ()    # 定义一个空的元组
>>> type(t)
<class 'tuple'>
>>> t = (1,)    # 定义一个只有一个元素的元组，“,” 是元组的特征
>>> (1) == 1    # 注意（1）等于1，不是元组
True

注意：元组元素不变是指元组的每个元素指向永远不变，如果元组的某个元素是一个列表，那么这个列表的元素是可以被改变的，但元组指向这个列表永远不变。

【示例2-2】元组的某个元素是列表。

>>> a = ['a', 'b']    # 定义一个列表a
>>> b = ['c', 'd']    # 定义一个列表b
>>> t = ('e', 'f', a)    # 定义一个元组t，第三个元素指向列表a
>>> t
('e', 'f', ['a', 'b'])
>>> t[2][0] = 'x'    # 这一步相当于修改a[0] =x
>>> t[2][1] = 'y'    # 这一步相当于修改a[1] =y
>>> a                  # 验证a
['x', 'y']
>>> t
('e', 'f', ['x', 'y'])
>>> t[2] = b         # t[2] 指向的是列表a，这个指向无法被修改
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

如果希望元组中的每个元素无法被修改，那就必须保证每个元组的每个元素本身也不能变，如数字、字符串、元组等不可变数据类型。

3. 字典

字典是一个key-value类型的数据结构。在字典里，要查找的key是唯一的，但不同的key对应的value可能相同。定义一个字典非常简单：使用一对花括号 {} 括起，键值对之间实验 “,” 分隔，例如：

>>> dict = {'hello':'你好', 'world':'世界',}
>>> dict
{'hello': '你好', 'world': '世界'}
>>> dict['hello']
'你好'
>>> len(dict)
2
>>> str(dict)
"{'hello': '你好', 'world': '世界'}"

字典的value可以是任何Python对象，即可以是标准对象，也可以是用户自定义的对象，但key不行。两个重要点需要记住：
（1）不允许同一个key出现两次。创建是如果同一个key被赋值两次，前面的值将被覆盖。
【示例3-1】不允许同一个key出现两次。

>>> dict = {'hello':'你好', 'world':'世界', 'hello':'world'}   # 键hello的值被更新为world
>>> dict
{'hello': 'world', 'world': '世界'}

（2）key必须为不可变数据类型，所以可以用数字、字符串或元组充当，用列表不行。
【示例3-2】key必须为不可变数据类型。

>>> d = {'a':1, 'b':2, ['a']:'abc'}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

【示例3-2】遍历字典

>>> d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
>>> for key,value in d.items():    # d.items() 方法返回一个键值对的元组（key，value）
...     print(key, value)
...
a 1
b 2
c 3
d 4
e 5
f 6
>>> for key in d:    # 以键来取值
...     print(key, d[key])
...
a 1
b 2
c 3
d 4
e 5
f 6

【示例3-3】修改字典

>>> d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
>>> d['b'] = 'b'
>>> d
{'a': 1, 'b': 'b', 'c': 3, 'd': 4, 'e': 5, 'f': 6}

【示例3-4】删除字典元素。可以删除一个单一元素，也可以一次性删除所有元素，清空字典，显示地删除一个字典用del命令。

>>> d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
>>> del d['b']    # 删除键b
>>> d
{'a': 1, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
>>> d.clear()    # 清空字典
>>> d
{}
>>> del d    # 删除字典
>>> d    # 删除字典后，字典d已不存在
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'd' is not defined

Python 字典的内置方法可参见下表：

方法	说明
d.clear()	删除字典内所有元素
d.copy()	返回一个字典的浅复制
d.fromKeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
d.get(key, default=None)	反馈指定键的值，如果值不在字典中，则返回default值
key in dict	如果键在字典中，则返回true，否则返回false
d.items()	以列表返回可变量的元组数据
d.keys()	以列表返回一个字典的所有的键
d.setDefault(key, default=None)	与get()类似，但如果键不存在字典中，则会添加键并将值设置为default
d.update(dict2)	把字典dict2的键/值对更新到dict中
d.values()	以列表返回字典中的所有值
pop(key[,default]	删除字典给定键key所对应的值，返回值为删除的值。key值必须给出。否则，返回default值
popitem()	随机返回并删除字典中的一对键和值（一般删除末尾对）

4.集合

集合set是一个无序不重复元素集，基本功能包括关系测试和消除重复元素。集合对象还支持 union（联合）、intersection（交）、difference（差）和sysmmetric difference（对称差集）等数学运算。
在 Python 中可以使用“x in set”来判断x是否在集合中，使用“len(set)”来获取集合元素个数，使用“for x in set”来遍历集合中的元素。但由于集合不记录元素位置，因此集合不支持获取元素位置和切片等操作。

【示例4-1】集合的定义和常见用法。

>>> s = {'k1','k2','k2'}
>>> s
{'k2', 'k1'}
>>> x = set('abcd')    # 创建集合x由单个字符组成
>>> y = set(['a', 'bc', 'd', 10])    # 创建集合y由列表的元素组成
>>> x,y      # 打印x,y
({'a', 'b', 'd', 'c'}, {10, 'a', 'd', 'bc'})
>>> x & y      # 取交集
{'a', 'd'}
>>> x | y      # 取并集
{'a', 'd', 10, 'c', 'b', 'bc'}
>>> x - y      # 取差集
{'c', 'b'}
>>> x ^ y      # 对称差集（项在x或y中，但不会同时出现在二者中）
{10, 'c', 'b', 'bc'}

【示例4-2】使用集合去除重复元素。

>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
{33, 11, 44, 22}

集合的基本操作可参见下表：

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

扩展阅读

Python列表常用方法
Python集合（Set）常用操作