5 字典、集合

2018-12-09 11:22:08来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

一、字典

  字典同样是一个序列,不过字典的元素是由 key(键,可理解为关键字或名称)与 values (值)组成。就好像我们查字典,一个拼音对应着与之关联的一个或多个汉字,拼音就 key,而对应的 汉字就是 values。其中每一个元素都是“key:values”的形式,并且每个元素间 以逗号分隔。

  说明:这种能够通过名称引用值的数据类型称做映射(Mapping),字典是 Python 中唯 一内建的映射类型。映射的概念好像比较难懂,以我个人的理解,映射就是名称集合与值集合的对应关系。名称集合中每个名称都是唯一的(即 Key 不可重复),并有唯一的值 (Key 与 Value 相对应);值集合中,值可以是唯一的也可以是重复的,但每个值也只能 有唯一的名称。

 

定义:{key1:value1,key2:value2}

特性:

  1. key-value结构

  2. key必须可hash、且必须为不可变数据类型、必须唯一

  3. 可存放任意多个值、可修改、可以不唯一

  4. 无序

 

字典的创建可以直接按格式创建,也可以使用 dict()方法进行创建。

  • dict(**kwarg):参数**kwarg 为可变关键字参数。

  • dict(mapping, **kwarg):参数 mapping 为映射函数。

  • dict(iterable, **kwarg):参数 iterable 为可迭代对象。

d = {}  # 创建空字典
d = dict()  # 创建空字典 
d = {'name':['路飞','索隆','山治'],'age':'22','sex':''}  # 创建字典
d = dict(name='路飞',age =22)  # 通过可变参数创建字典
d = dict([('name','路飞'), ('age','22')])    # 通过可迭代对象(列表)创建字典

另外,还有一种字典的创建方式,通过 fromkeys(seq,value)方法进行创建,参数 seq 为包 含 key 的序列,参数 value 为 key 的默认值。

k = ['波多','新垣'] # key 的列表
d1 = dict.fromkeys(k) # 仍 key 的列表创建字典
d2 = dict.fromkeys(k,'哦哦') # 仍 key 的列表创建字典,并赋予默认值 
print(d1) # 显示输出结果为:{'波多': None, '新垣': None} 
print(d2) # 显示输出结果为:{'波多': '哦哦', '新垣': '哦哦'}

 

查询:

首先,查询字典中的元素。我们可以使用 items()方法,通过 items()方法可以获取到字典中所有元素的迭代器

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.items())  # 显示输出结果为:dict_items([('name', '路飞'), ('age', 22)])

然后,查询字典中元素的键。 我们可以使用 keys()方法,通过 keys()方法可以获取到字典中所有元素键的迭代器。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.keys())  # 显示输出结果为:dict_keys(['name', 'age'])

最后,查询字典中元素的值。查询元素值有多种方法:
第一种,通过键可以获取相对应的值:字典[键]

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d['name'])  # 显示输出结果为:路飞
print(d['age'])  # 显示输出结果为:22

第二种,通过 get(k,default)方法查询,参数 k 为查询的键,参数 default 为未查询到结果 时的默认值。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.get('name','海贼王'))  # 显示输出结果为:路飞
print(d.get('sex','人妖'))  # 显示输出结果为:人妖

第三种、通过 values()方法可以获取到字典中所有元素值的迭代器。 

d = dict(name='路飞',age =22)  # 通过可变参数创建字典
print(d.values())  # 显示输出结果为:dict_values(['路飞', 22])

 

添加元素:

添加单个元素:
首先,可以通过“字典[键]=值”的方式进行添加,如果字典中不存在相同的键则自动添加, 否则修改已存在的键所对应的值。

d = {"name":"路飞","age":20}
d["sex"] = ""   # 添新元素到字典
d["船员"] = "索隆", "山治"     # 添加值为元组的新元素到字典
print(d)    # 输出结果为:{'name': '路飞', 'age': 20, 'sex': '男', '船员': ('索隆', '山治')}

另外,还可以通过 setdefault(k,default)方法进行添加,参数 k 为指定的键,参数 default 为默认值。当字典中存在指定的键时,能够返回该键所对应的值;如果不存在指定的键时, 则会返回参数 default 中设置的值,同时,在字典中会添加新元素,新元素的键即为参数 k,值即为参数 default。 

d = {"name":"路飞","age":20}
print(d.setdefault('name', '索隆'))  # 字典中存在相应的键,则返回该键对应的值,显示输 出结果为:路飞
print(d.setdefault('sex', ''))  # 字典中不存在相应的键,则返回 default 参数的值,显 示输出结果为:男
print(d)  # 当字典中不存在相应的键时,添加新元素,显示输出结果为:{'name': '路飞', 'age': 20, 'sex': '男'}

添加多个元素:通过 update(m,kwargs)方法进行添加,参数 m(mapping)为映射函数, kwargs 为可变参数。 

d = {"name":"路飞","age":20}
d.update(sex="",money=15)   # 通过可变参数添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update((("sex",""),("money",15)))  # 通过元组添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update([("sex",""),("money",15)])  # 通过列表添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d = {"name":"路飞","age":20}
d.update({"sex":"","money":15})  # 通过列表添加多个元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

d1 = {"name":"路飞","age":20}
d2 = {"sex":"","money":15}
d1.update(d2)   # 合并字典元素
print(d)    #{'name': '路飞', 'age': 20, 'sex': '男', 'money': 15}

 

修改元素:

修改某个键对应的元素:字典[键]=新值

d = {"name":"路飞","age":20}
d["name"] = "索隆"
print(d)    #{'name': '索隆', 'age': 20}

 

删除元素:

使用 del 指令可以通过键删除某个元素:del 字典[键] 

d = {"name":"路飞","age":20}
del d["age"]
print(d)    #{'name': '路飞'}

 

可以使用clear()删除字典中的所有项或元素

d = {"name":"路飞","age":20}
d.clear()
print(d)    # {}

 

取出元素与元素值 :

使用 popitem()方法在字典中取出元素。 

d = {"name":"路飞","age":20}
print(d.popitem())  #('age', 20)
print(d)    #{'name': '路飞'}

以使用 pop(k,default)方法在字典中取出指定元素的值,参数 k 为指定元素 的键,参数 default 为未取到结果时的默认值。 

d = {"name":"路飞","age":20}
print(d.pop("age"))  #20
print(d.pop("sex",""))  #
print(d)    #{'name': '路飞'}

 

设置默认值:

d = {"name":"路飞","age":20}
print(d.setdefault('name', '索隆'))  # 字典中存在相应的键,则返回该键对应的值,显示输 出结果为:路飞
print(d.setdefault('sex', ''))  # 字典中不存在相应的键,则返回 default 参数的值,显 示输出结果为:男
print(d)  # 当字典中不存在相应的键时,添加新元素,显示输出结果为:{'name': '路飞', 'age': 20, 'sex': '男'}

 

其他:

字典也支持使用以下方法:
clear():清空字典
copy():复制字典:
len():获取字典元素数量
max():获取字典中最大的键
min():获取字典中最小的键
同时,字典也支持通过 in 和 not in 进行成员关系的判断

 

二、集合

集合通过 set(iterable)方法创建,参数 iterable 为可迭代对象。 

s1 = set("好好学习天天向上") # 将字符串分解为单个字符,作为集合的元素创建集吅
s2 = set(('好好', '学习', '天天', '想上'))  # 将元组分解为单个元素,作为集吅元素创建集合
s3 = set(['好好', '学习', '天天', '想上'])  # 将列表分解为单个元素,作为集吅元素创建集合
print(s1)   #{'好', '上', '学', '天', '习', '向'}
print(s2)   #{'想上', '好好', '天天', '学习'}
print(s3)   #{'想上', '好好', '天天', '学习'}

 

特性:

  1. 集合可以通过可迭代对象(字符串、元组、列表等)进行创建;

  2. 集合中的元素不可重复; 

  3. 集合中的元素无序排列。 

 

添加:

集合添加元素的方法有两种。
添加单个元素:使用 add(element)函数,参数 element 为集合允许添加的元素(例如数字、 字符串、元组等)。
添加多个元素:使用 update(iterable)函数,参数 iterable 为可迭代对象。

s1 = {1,2,3}
s2 = {'123'}
s3 = {'abc'}

s1.add(4)
s2.update(['4','5','6'])    # 添加列表到集合,列表元素会被分解为单个元素后添加到集合
s3.update('de')  # 添加字符串到集合,字符串会被分解为单个元素后添加到集合

print(s1)   #{1, 2, 3, 4}
print(s2)   #{'5', '4', '123', '6'}
print(s3)   #{'abc', 'e', 'd'}

 

删除:

集合删除元素的方法有两种。
第一种:使用 remove(element)方法删除指定元素,参数 element 为需要删除的元素。
第二种:使用 discard(element)方法删除指定元素,参数 element 为需要删除的元素。

当集合中不存在这两个方法参数中填入的元素时,remove()方法会抛出异常,而 discard() 方法则没有仸何影响。

s1 = {1,2,3}
s2 = {'123'}
s3 = {'abc'}

s1.remove(1)
s1.discard(4)
print(s1)   #{2, 3}
s1.remove(4)
print(s1)   # Traceback (most recent call last):
           File "E:/python/test/test1.py", line 367, in <module>
             s1.remove(4)
         KeyError: 4

 

取出元素:

使用pop(),由于集合是无序的,pop返回的结果不能确定,切当集合为空时调用pop会抛出异常。

s1 = {1,2,3}
print(s1)   #{1, 2, 3}
print(s1.pop()) # 1
print(s1)   #{2, 3}

 

清空:

s1 = {1,2,3}
s1.clear()
print(s1)   # set()

 

交集/并集/补集/差集:

首先我们来看张图,理解交集、并集、补集、差集的概念。

假设有集吅 A{1,2,3}和 B{3,4,5}。
交集:A 和 B 中相同部分的内容,{3}。
并集:A 和 B 去重后的全部内容,{1,2,3,4,5}。
补集:A 去除与 B 相交部分后的内容,{1,2}。
差集:A 和 B 不相交部分的全部内容,{1,2,4,5}。

 

创建集合

s1 = set('python')
s2 = set('pycharm')

交集操作:获取两个集合中共有的元素

print(s1 & s2)    #{'y', 'p', 'h'}
print(s1.intersection(s2))  #{'y', 'p', 'h'}

并集操作:获取两个集合去除重复元素后的全部元素

print(s1 | s2)    #{'p', 'a', 'o', 't', 'c', 'm', 'n', 'r', 'h', 'y'}
print(s1.union(s2))  #{'p', 'a', 'o', 't', 'c', 'm', 'n', 'r', 'h', 'y'}

 补集操作:获取当前集合去除与另一集合交集元素后的全部元素

print(s1 - s2)    #{'o', 't', 'n'}
print(s1.difference(s2))  #{'o', 't', 'n'}
print(s2 - s1)    #{'a', 'c', 'm', 'r'}
print(s2.difference(s1))  #{'a', 'c', 'm', 'r'}

差集操作:获取两个集合去除交集元素后的全部元素

print(s1 ^ s2)    #{'c', 'n', 'a', 't', 'r', 'm', 'o'}
print(s1.symmetric_difference(s2))  #{'c', 'n', 'a', 't', 'r', 'm', 'o'}

 

difference_update(set)函数,能够将当前集合和指定集合进行补集运算,并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.difference(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化,显示输出结果为:{'3', '4', '2', '1'}
s1.difference_update(s2)    # 更新集合 s1 的内容为 s1-s2 后的结果
print(s1)   #{'3', '1', '2'}

intersection_update(set) 函数,能够将当前集合和指定集合进行交集运算,并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.intersection(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化,显示输出结果为:{'2', '1', '4', '3'}
s1.intersection_update(s2)    # 更新集合 s1 的内容为 s1 & s2 后的结果
print(s1)   #{'4'}

 

symmetric_difference_update(set) 函数,能够将当前集合和指定集合进行差集运算,并将当前集合内容更新为运算结果

s1 = set('1234')
s2 = set('456')
s1.symmetric_difference(s2)    # 该操作对 s1 内容无影响
print(s1)    # s1 无变化,显示输出结果为:{'2', '1', '4', '3'}
s1.symmetric_difference_update(s2)    # 更新集合 s1 的内容为 s1 ^ s2 后的结果
print(s1)   #{'2', '5', '3', '1', '6'}

 

另外,我们还可以使用“not in”,判断操作符前方的值是否未被后方的序列包含(非成员关系)。
在集合中,我们同样可以使用这两个操作符。
另外,我们还可以通过以下方法,判断一个集合是否另外一个集合的子集或超集以及没有 交集。
isdisjoint(set):可以判断集合是否与指定集合不存在交集,参数 set 为集合;如果成立返回结果为 True,否则为 False。
issubset(set):可以判断集合是否指定集合的子集,参数 set 为集合;如果成立返回结果为 True,否则为 False。
issuperset(set):可以判断集合是否指定集合的超集,参数 set 为集合;如果成立返回结果为 True,否则为 False。

s1 = set('好好学习')
s2 = set('天天想上')
s3 = set('好好学习天天想上')
print('' in s1)    # True
print('' not in s2)    # True
print(s1.isdisjoint(s2))    # True
print(s1.issubset(s3))  # True
print(s3.issuperset(s1))    #True

 

复制集合

a = set('红酥手黄藤酒')   # 创建集合存入变量 a
b = a    # 创建变量 b 引用变量 a 的集合
c = a.copy()    # 创建变量 c 复制变量 a 的值
print(a)    #{'手', '酒', '红', '黄', '酥', '藤'}
print(b)    #{'手', '酒', '红', '黄', '酥', '藤'}
print(c)    #{'手', '藤', '酥', '酒', '红', '黄'}
a.remove('')    # 删除变量 a 中集合的一个元素
print(a)    #变量 a 发生改变,{'手', '黄', '酒', '酥', '藤'}
print(b)    # 变量 b 因为引用变量 a,同样发生改变,{'酥', '藤', '手', '黄', '酒'}
print(c)    #变量 c 没有改变,{'酥', '藤', '酒', '手', '黄', '红'}

代码中,b = a 实际上是将 b 指向了 a 的内容,所以当 a 的内容发生变化时,b 同步发生了变化。
而 c = a.copy()则是将 a 的内容真正进行了复制,不再受 a 的变化影响。

 

其他

集合也支持 len()方法进行元素数量的获取,也支持 max()方法和 min 方法获取集合中的最大元素与最小元素

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:leetcode 921. 使括号有效的最少添加(Python)

下一篇:并发编程(4)-进程中的锁、信号量、 事件和队列