Python数据类型之“集合（Sets）与映射（Mapping）”
⼀、集合类型(Sets)
集合对象是不同的(不可重复)hashable对象的⽆序集合。常见⽤法包括：成员关系测试、移除序列中的重复、以及科学计算，例如交集、并集、差分和对称差分。通俗点来说，集合是⼀个⽆序不重复元素的数据集，其基本功能是进⾏成员关系测试和消除重复元素。
⽬前有两种内置的集合类型：set 和 frozenset。set类型是可变的--可以使⽤add() 和 remove()等⽅法更改其内容。由于它是可变的，它没有hash值，因此它不能被当做字典的键值或另⼀集合的元素。frozenset类型是不可变的和 hashable的，它的内容不能再创建后改变，因此它可以⽤作字典的键值或作为另⼀个集合的元素。
set类构建函数
class set([iterable])
class frozenset([iterable])
set的构建⽅式
将⼀个⽤逗号分割的元素列表放在⼀堆花括号内可以创建⼀个⾮空set集合，如{'Tom', 'Jerry', 'Peter'}
给set的构建函数传递⼀个空值将会创建⼀个空set集合(注意：{}表⽰的是⼀个空字典⽽不是空set集合)
给set的构架你函数传⼀个⾮空iterable参数将会创建⼀个⾮空set集合
注意：
再次强调，⼀个set集合内的元素必须是hashable的（不可变的）。要想表⽰⼀个set的set，那么内部的set必须是frozenset对象，因为frozenset是不可变的，是
hashable的。
set构建⽰例
>>> {'Tom', 'Jerry', 'Peter'} # 使⽤花括号创建⾮空set集合
{'Jerry', 'Tom', 'Peter'}
>>> set() # 使⽤set构建函数创建空set集合
set()
>>> set((1, 2, 3 ,4)) # 使⽤set构建函数创建⾮空set集合
{1, 2, 3, 4}
>>> set((1, 2, 3 ,['a', 'b', 'c'])) # set集合中的元素必须是不可变的、可哈希的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
set 和 frozenset都⽀持的操作
作为⽆序集合，set不记录元素位置或插⼊顺序。因此set不⽀持索引、切⽚或其他类序列⾏为。
len(set) # 获取集合中的条⽬个数
x in set # 成员关系测试--包含
x not in set # 成员关系测试--不包含
for x in set # 循环遍历集合中的条⽬
isdisjoint(other) # 判断该集合是否与另外⼀个集合不相交(当且仅当交集为空)，不相交则返回True
issubset(other) 或 set <= other # 判断该集合是否是另外⼀个集合的⼦集
set < other # 判断该集合是否是另外⼀个集合的真⼦集
issuperset(other) 或 set >= other # 判断该集合是否是另外⼀个集合的⽗集
set > other # 判断该集合是否是另外⼀个集合的真⽗集
union(other,...) 或 set | other | ... # 求该集合与另外⼀个或多个集合的并集
intersection(other,...) 或 set & other & ... # 求该集合与另外⼀个或多个集合的交集
difference(other,...) 或 set - other - ... # 求该集合与另外⼀个或多个集合的差集(该集合中存在但其它集合中不存在的元素集合)
symmetric_difference(other) 或 set ^ other # 求该集合与另外⼀个集合的对称差集(该集合中存在但另⼀集合中不存在，或另⼀集合中存在但该集合中不存在的元素集合)
copy() # 返回⼀个新的浅拷贝集合
说明：
a) union()、intersection()、differnce()、symmetric_difference()、issubset() 和 issuperset()⽅法的可接受任何可迭对象作为参数。相⽐之下，它们的基于运算符的相应操作需要它们的参数是set。这避免了像set('abc') & 'cbs'这样易出错的结构，有利于更易读的结构，如set('abc').intersection('cbs')。
>>> set('abc')
{'c', 'a', 'b'}
>>> set('abc') & 'cbs' # 使⽤操作符进⾏相关操作，操作符两边都必须是set类型
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'set' and 'str'
>>> set('abc') & set('cbs')
{'c', 'b'}
>>> set('abc').intersection('cbs') # 调⽤⽅法进⾏相关操作，参数可以是任意可迭代对象
{'c', 'b'}
>>> set('abc').intersection(['c','s', 'b'])
{'c', 'b'}
b) set和frozenset⽀持集合与集合进⾏⽐较操作。
当且仅当每个集合的每个元素都包含在另⼀个(每个集合都是另⼀个的⼦集)时，两个集合是相等的；
当且仅当第⼀集合是第⼆集合的真⼦集(是⼦集，但不相等)时，集合⼩于另⼀集合；
当且仅当第⼀集合是第⼆集合的真⽗集(是⽗集，但不相等)时，集合⼤于另⼀集合；
c) set和frozenset之间是基于它们的成员进⾏⽐较的。⽐如set('abc') == frozenset('abc')返回True，因此set('abc') in set([frozenset('abc')])
>>> set('abc') == frozenset('abc')
True
>>> set('abc') in frozenset('abc')
False
>>> set('abc') in set(frozenset('abc'))
False
>>> set('abc') in set([frozenset('abc')])
True
d) ⼦集和相等的⽐较不推⼴到总排序函数。例如，任何两个⾮空且不相交的集合是不相等的，并且不是彼此的⼦集。因此，它们对应的以下操作都返回False: a<b, a==b, a>b。
e) 因为set之定义了部分排序(⼦集关系)，因此灭有为set的list定义list.sort()⽅法。
f) set集合的元素像dict的键⼀样，必须是可哈希的。
g) set实例与frozenset实例混合进⾏⼆进制操作将会返回第⼀个操作数的类型。例如：frozenset('ab')
| set('bc')会返回⼀个frozenset实例。
set⽀持但frozenset不⽀持的操作
set是可变集合，⽽frozenset是不可变集合，因此set的有些修改操作是frozenset不⽀持的。
add(elem) # 向集合中添加⼀个元素
remove(elem) # 从集合中删除⼀个元素，如果集合中不包含该元素会抛出KeyError错误
discard(elem) # 如果集合中包含该元素则删除它，这个⽅法明显⽐remove()好⽤
pop() # 由于set集合是⽆序的，因此该⽅法会移除并返回⼀个随机元素，⽽不是像list.pop()移除并返回最后⼀个元素
clear() # 清除set集合中的所有元素
update(other,...) 或 set |= other | ... # 更新set集合，将其它集合中的元素添加进来；简单点来说就是与其它⼀个或多个集合求并集并将结果赋值给⾃⼰
intersection_update(other,...) 或 set &= other & ... # 更新set集合，只保留所有集合中都存在的元素；
简单点来说就是与其它⼀个或多个集合求交集并将结果赋值为⾃⼰
difference_update(other,...) 或 set -= other | ... # 与其它⼀个或多个集合求差集并将结果赋值给⾃⼰
symmetric_difference_update(other) 或 set ^= other # 与另外⼀个集合求对称差集并将结果赋值给⾃⼰；对称差集就是A-B 与 B-A 的并集
说明:
上⾯这些update⽅法也是可以接受任何可迭代对象作为参数。另外，remove(elem)和discard(elem)等⽅法中参数elem可以是⼀个set集合。为了⽀持搜索等效的
frozenset，elem集合会在搜索期间被暂时修改，然后恢复。在搜索期间，elem不应该被读取或改动，因为它没有有意义的值。
⼆、映射类型(mapping)
⼀个mapping对象将可哈希的值映射为任意对象。映射是可变对象。⽬前Python中只有⼀种标准映射类型，就是字典(dict)。dcit和Set集合⼀样也是⽤花括号表⽰，但是花括号中
的每个元素都是⼀个键值对(key:value)。字典中的键值对也是⽆序的，且key必须是可哈希的不可变类型，如字符串、数字、布尔值和不包含可变类型的tuple。⽽list和包含可变
类型的tuple是不能做字典的key的。另外，同⼀个字典中，key不能重复，否则会覆盖之前的值。、
⽤于键的数字类型遵守数字⽐较的正常规则：如果两个数字⽐较相等（⽐如1和1.0），则它们可以互相使⽤以索引相同的字典条⽬。但是需要注意，由于计算机存储浮点数作为
近似值，因此使⽤它们作为字典的键通常是不明智的。
dict类构建函数
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
上⾯的dict构建函数会返回⼀个新的字典，这个新的字典是从⼀个可选的位置参数和⼀组可能为空关键字参数初始化的。
dict的构建⽅式
将以逗号分隔的 key:value （键值对)列表放置在⼀对花括号中：{},{'Tom':1, 'Jerry':2, 'Peter':3}
使⽤不传递位置参数的构建函数，创建空字典：dict()，等同于{}
如果给定了位置参数，并且它是映射对象，则使⽤与该映射对象相同的键值对创建字典；否则，位置参数必须是可迭代对象。可迭代对象中的每个条⽬本⾝必须是具有两个
对象的可迭代对象。每个条⽬的第⼀个对象将会成为新字典中的键，第⼆个对象将会成为对应的值。如果键多次出现，则该键的最后⼀个值将成为新字典中的相应值。
如果给出了关键字参数，则将关键字参数及其值添加到从位置参数创建的字典中。如果要添加的键已经存在，则来⾃关键字参数的值将替换位置参数中的值。
dict构建⽰例
空字典
>>> a = {}
>>> a
{}
>>> b = dict()
>>> b
{}
>>> a == b
True
⾮空字典
>>> a = {'one': 1, 'two': 2, 'three': 3} # 将以逗号分隔的键值对列表放置在⼀对花括号中
>>> b = dict(one=1, two=2, three=3) # 使⽤dict构建函数，并传递关键字参数
>>> c = dict([('two', 2), ('one', 1), ('three', 3)]) # 使⽤dict构建函数，并传递可迭代对象为位置参数
>>> d = dict({'three': 3, 'two': 2, 'one': 1}) # 使⽤dict构建函数，并传递可迭代对象作为位置参数
>>> e = dict({'three': 3, 'two': 2, 'one': 1}, four=4, five=5) # 使⽤dict构建函数，同时传递可迭代位置参数和关键字参数
>>> e
{'five': 5, 'two': 2, 'three': 3, 'one': 1, 'four': 4}
>>> a == b == c == d
True
关于[('one', 1), ('two', 2), ('three', 3)]这种格式的列表我们可以通过zip类来创建(zip在Python 2.x中是⼀个内建函数，⽽在Python 3.x中是⼀个类)，zip类的构建函数如下：
zip(iter1 [,iter2 [...]])
为了⽅便查看效果，我们使⽤Python 2.x来做下实验：
>>> zip(['one', 'two', 'three'], [1, 2, 3])
[('one', 1), ('two', 2), ('three', 3)]
>>> zip(['one', 'two', 'three'], [1, 2, 3], ('I', 'II', 'III'))
[('one', 1, 'I'), ('two', 2, 'II'), ('three', 3, 'III')]
>>> zip(['one', 'two', 'three', 'four'], [1, 2, 3, 4], ('I', 'II', 'III')) # 结果中的条⽬数与此处条⽬数最少的可迭代对象⼀致
[('one', 1, 'I'), ('two', 2, 'II'), ('three', 3, 'III')]
dict⽀持的操作
len(d) # 返回字典d中的条⽬数
key in d # 如果字典d中包含key这个键则返回True, 否则返回False
key not in d # 与上⾯刚好相反
d[key] # 返回key对应的条⽬的值，如果key不存在会抛出KeyError异常
get(key[, default]) # 如果key存在则返回其对应的值，否则返回default参数指定的值。如果default没有被指定，则default取None，因此该⽅法永远不会抛出KeyError异常。
setdefault(key[,default]) # 如果key存在则返回这个key对应的值，如果key不存在则插⼊⼀个键值对key:default并返回default的值。default默认值为None。
classmethod fromkeys(seq[,value]) # 这是个类⽅法，⽤于创建⼀个新的字典。seq序列中的元素将作为新字典中的key，⽽value将会是这些key共同的值，value默认为None。
copy() # 返回该dict的⼀个浅拷贝
keys() # 返回⼀个字典键的新视图
values() # 返回⼀个字典值的新视图
items() # 返回⼀个字典条⽬的新视图：(key, value)
iter(d) # 返回字典键的⼀个迭代器，这是iter(d.keys())的简写⽅式
d[key] = value # 如果key不存在则表⽰新增⼀个条⽬，如果key已经存在则表⽰修改该条⽬的值
update([other]) # ⽤other中的键值对更新字典的内容，覆盖现有的key。other可以是⼀个字典对象或键/值对(⽐如长度为2的元组或其它可迭代对象)。如果指定了关键字参数，字典将会使⽤关键字参数对字典的键/值对更新，如：d.update(红⾊=1, 蓝⾊del d[key] # 删除key对应的表⽊，如果key不存在会抛出KeyError异常
popitem() # 从字典中删除并返回⼀个任意(key, value)对，如果字典为空会抛出KeyError异常。该⽅法对于破坏性的遍历字典很有⽤，常⽤于集合算法。
pop(key[,default]) # 如果key存在就删除它并返回它的值，否则返回default的值。如果default没有被给出并且key不存在，则抛出KeyError异常。
clear() # 清空dict中的所有条⽬
操作⽰例
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> len(d)
3
>>> 'two' in d
True
>>> 'two' not in d
False
>>>
>>> d['three']
3
>>> d['four']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'four'
>>> d.get('three')
3
>>> d.get('four', 'default')
'default'
>>> d
{'one': 1, 'two': 2, 'three': 3}
>>> d.setdefault('three', 'default')
3
>>> d
{'one': 1, 'two': 2, 'three': 3}
>>> d.setdefault('four', 'default')
'default'
>>> d
{'one': 1, 'two': 2, 'four': 'default', 'three': 3}
>>> dict.fromkeys(['one', 'two', 'three'])
{'one': None, 'two': None, 'three': None}
>>> dict.fromkeys(['one', 'two', 'three'], 'default')
{'one': 'default', 'two': 'default', 'three': 'default'}
>>>
>>> d.copy()
{'one': 1, 'two': 2, 'four': 'default', 'three': 3}
>>> d['four'] = 4
>>> d
{'one': 1, 'two': 2, 'four': 4, 'three': 3}
>>> d['five'] = 5
>>> d
{'one': 1, 'two': 2, 'five': 5, 'four': 4, 'three': 3}
>>> d.update({'two': 'II', 'six': 6})
>>> d
{'one': 1, 'two': 'II', 'four': 4, 'five': 5, 'six': 6, 'three': 3}
>>> d.update(two=2, seven=7)
>>> d
{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 3}
>>> d.update([('three', 'III'), ('eight', 8)])
>>> d
{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'eight': 8, 'six': 6, 'seven': 7, 'three': 'III'}
>>>
>>> d.keys()
dict_keys(['one', 'two', 'four', 'five', 'eight', 'six', 'seven', 'three'])
>>> d.values()
dict_values([1, 2, 4, 5, 8, 6, 7, 'III'])
>>> d.items()
dict_items([('one', 1), ('two', 2), ('four', 4), ('five', 5), ('eight', 8), ('six', 6), ('seven', 7), ('three', 'III')])
>>> iter(d)
<dict_keyiterator object at 0x000001EA21A179A8>
>>> iter(d.keys())
<dict_keyiterator object at 0x000001EA21A175E8>
>>>
>>> del d['eight']
>>> d
{'one': 1, 'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 'III'}
union是什么类型>>> d.popitem()
('one', 1)
>>> d
{'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7, 'three': 'III'}
>>> d.pop('three')
'III'
>>> d
{'two': 2, 'four': 4, 'five': 5, 'six': 6, 'seven': 7}
>>> d.pop('three')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'three'
>>> d.pop('three',None)
>>> d.pop('three','default')
'default'
>>> d.clear()
>>> d.popitem()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
字典视图对象(Dictionary view objects)
对于dict.keys()、dict.values()和dict.items()这些函数，在Python 2.x中返回的是list对象，⽽在Python 3.x中返回的是⼀个叫做字典视图的对象。
python 2.x
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> d.keys()
['three', 'two', 'one']
>>> d.values()
[3, 2, 1]
>>> d.items()
[('three', 3), ('two', 2), ('one', 1)]
python 3.x
>>> d = {'one': 1, 'two': 2, 'three': 3}
>>> dkeys = d.keys()
>>> dkeys
dict_keys(['one', 'three', 'two'])
>>> dvalues = d.values()
>>> dvalues
dict_values([1, 3, 2])
>>> ditems = d.items()
>>> ditems
dict_items([('one', 1), ('three', 3), ('two', 2)])
字典视图在字典条⽬上提供了⼀个动态视图，这意味着当字典发⽣变化时，相应的视图也会发⽣变化。要保存固定的值需要将字典视图强制转换为其他类型的对象进⾏保存，通常保存为list类型。
>>> d['four'] = 4
>>> d
{'one': 1, 'three': 3, 'two': 2, 'four': 4}
>>> dkeys
dict_keys(['one', 'three', 'two', 'four'])
>>> dvalues
dict_values([1, 3, 2, 4])
>>> ditems
dict_items([('one', 1), ('three', 3), ('two', 2), ('four', 4)])
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论