012.Python的字典和集合的相关函数

一 字典的相关函数

1.1 增函数

dictvar = {"a":1,"b":2}
dictvar["c"] = 3
print(dictvar)

执行

[[email protected] python]# python3 test.py test.py
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3}

fromkeys()

使用一组键和默认值创建字典 (不常用 赋初始值)

listvar = [‘a‘,‘b‘,‘c‘]
res = {}.fromkeys(listvar,None)
print(res)
res = {}.fromkeys(listvar,[1,2])
print(res)

执行

[[email protected] python]# python3 test.py test.py
{‘a‘: None, ‘b‘: None, ‘c‘: None}
{‘a‘: [1, 2], ‘b‘: [1, 2], ‘c‘: [1, 2]}

1.2 删函数

pop()

通过键去删除键值对 (若没有该键可设置默认值,预防报错)

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
res = dictvar.pop("tiantang")
print(res)
print(dictvar)
# pop可以在第二个参数上指定默认值,预防不存在改键时报错
res = dictvar.pop("ppoiiiiuiuiuiiiuiui","对不起,改键不存在")
print(res)

执行

天堂
{‘renjian‘: ‘人间‘, ‘diyu‘: ‘地狱‘}
对不起,改键不存在

popitem() 删除最后一个键值对

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
res= dictvar.popitem()
print(res)
print(dictvar)

执行

[[email protected] python]# python3 test.py test.py
(‘diyu‘, ‘地狱‘)
{‘tiantang‘: ‘天堂‘, ‘renjian‘: ‘人间‘}

clear()  清空字典

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
dictvar.clear()
print(dictvar)

执行

[[email protected] python]# python3 test.py test.py
{}

1.3 更改函数

update()

批量更新(有该键就更新,没该键就添加)

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
dictvar.update({‘tiantang‘:111,"jungle":"盘古"}) # 在括号里面写字典数据 (一个字典即可)
print(dictvar)
# 写法二
dictvar.update(a=1,b=2)  #(在括号里面写关键字参数,是多个)
print(dictvar)

执行

[[email protected] python]# python3 test.py test.py
{‘tiantang‘: 111, ‘renjian‘: ‘人间‘, ‘diyu‘: ‘地狱‘, ‘jungle‘: ‘盘古‘}
{‘tiantang‘: 111, ‘renjian‘: ‘人间‘, ‘diyu‘: ‘地狱‘, ‘jungle‘: ‘盘古‘, ‘a‘: 1, ‘b‘: 2}

1.4 查找函数

get()

通过键获取值(若没有该键可设置默认值,预防报错)

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
res = dictvar.get("tiantang123")
print(res)
# 如果这个键不存在,可以指定默认值, 如果不写第二个参数值,默认返回None
res = dictvar.get("tiantang123","对不起,该键不存在")
print(res)
res = dictvar[‘tiantang‘]
print(res)

执行

[[email protected] python]# python3 test.py test.py
None
对不起,该键不存在
天堂

keys()

将字典的键组成新的可迭代对象

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
res = dictvar.keys()
print(res)
for i in dictvar.keys():
        print(i)
print("==============================")
for i in dictvar:
        print(i)

执行

tiantang
renjian
diyu
==============================
tiantang
renjian
diyu

values()

将字典中的值组成新的可迭代对象

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}
res = dictvar.values()
print(res)
for i in res:
        print(i)

执行

dict_values([‘天堂‘, ‘人间‘, ‘地狱‘])
天堂
人间
地狱

items()

将字典的键值对凑成一个个元组,组成新的可迭代对象

dictvar = {"tiantang":"天堂","renjian":"人间","diyu":"地狱"}res = dictvar.items()
print(res)
for i in res:
        print(i)
print ("================================")
for a,b in res:
        print(a,b)

执行

dict_items([(‘tiantang‘, ‘天堂‘), (‘renjian‘, ‘人间‘), (‘diyu‘, ‘地狱‘)])
(‘tiantang‘, ‘天堂‘)
(‘renjian‘, ‘人间‘)
(‘diyu‘, ‘地狱‘)
================================
tiantang 天堂
renjian 人间
diyu 地狱

二 集合的相关操作

作用:交差并补

2.1 intersection() 交集

set1 = {"曹操","刘禅","孙权","刘备"}
set2 = {"郭嘉","刘禅","张昭","诸葛亮"}
res = set1.intersection(set2)
print(res)
res = set1 & set2
print(res)

2.2 difference()   差集

set1 = {"曹操","刘禅","孙权","刘备"}
set2 = {"郭嘉","刘禅","张昭","诸葛亮"}
res = set1.difference(set2)
print(res)
res = set2.difference(set1)
print(res)
res = set1 - set2
print(res)

执行

{‘刘备‘, ‘孙权‘, ‘曹操‘}
{‘郭嘉‘, ‘张昭‘, ‘诸葛亮‘}
{‘刘备‘, ‘孙权‘, ‘曹操‘}

2.3 union()  并集

set1 = {"曹操","刘禅","孙权","刘备"}
set2 = {"郭嘉","刘禅","张昭","诸葛亮"}
res = set1.union(set2)
print(res)
res = set1 | set2
print(res)

执行

[[email protected] python]# python3 test.py test.py
{‘孙权‘, ‘曹操‘, ‘刘备‘, ‘郭嘉‘, ‘张昭‘, ‘刘禅‘, ‘诸葛亮‘}
{‘孙权‘, ‘曹操‘, ‘刘备‘, ‘郭嘉‘, ‘张昭‘, ‘刘禅‘, ‘诸葛亮‘}

2.4 symmetric_difference() 对称差集 (补集情况涵盖在其中)

set1 = {"曹操","刘禅","孙权","刘备"}
set2 = {"郭嘉","刘禅","张昭","诸葛亮"}
res = set1.symmetric_difference(set2)
print(res)

res = set1 ^ set2
print(res)

执行

[[email protected] python]# python3 test.py test.py
{‘曹操‘, ‘郭嘉‘, ‘刘备‘, ‘孙权‘, ‘张昭‘, ‘诸葛亮‘}
{‘曹操‘, ‘郭嘉‘, ‘刘备‘, ‘孙权‘, ‘张昭‘, ‘诸葛亮‘}

2.5 issubset()   判断是否是子集

真子集:子集元素一定少于父集,完全被包含在其中

set_father = {"曹操","刘禅","孙权","刘备"}
set_son = {"曹操","刘禅"}
res = set_son.issubset(set_father)
print(res)
res = set_son < set_father
print(res)

print ("==========================================")
set_father = {"曹操","刘禅","孙权","刘备"}
set_son = {"曹操","刘禅","孙权","刘备"}

res = set_son <=  set_father
print(res)

执行

True
True
==========================================
True

2.6 判断是否是父集

set_father = {"曹操","刘禅","孙权","刘备"}
set_son = {"曹操","刘禅"}
res = set_father.issuperset(set_son)
print(res)
res = set_father > set_son
print(res)
print ("==========================================")
set_father = {"曹操","刘禅","孙权","刘备"}
set_son = {"曹操","刘禅","孙权","刘备"}

res = set_son >=  set_father
print(res)

执行

[[email protected] python]# python3 test.py test.py
True
True
==========================================
True

2.7 isdisjoint() 检测两集合是否不相交

不相交 True  相交False

set_father = {"曹操","刘禅","孙权","刘备"}
set_son = {"曹操","刘禅"}
res = set_father.isdisjoint(set_son)
print(res)

执行

[[email protected] python]# python3 test.py test.py
False

三 集合的相关函数

3.1 增函数

add()    向集合中添加数据

setvar = {"曹操","刘禅","孙权","刘备"}
setvar.add("曹丕")
print(setvar)

执行

[[email protected] python]# python3 test.py test.py
{‘曹丕‘, ‘刘禅‘, ‘曹操‘, ‘刘备‘, ‘孙权‘}

update() 迭代着增加

setvar = {"曹操","刘禅","孙权","刘备"}
lst = [‘曹植‘,‘曹丕‘]
setvar.update(lst)
print(setvar)

print("==================================")
setvar = {"曹操","刘禅","孙权","刘备"}
setavar = "abcd"
setvar.update(setvar)print(setvar)

把列表当中的元素一个一个拿出来放进集合中,需要时可迭代性数据

执行

{‘孙权‘, ‘刘禅‘, ‘曹操‘, ‘刘备‘, ‘曹丕‘, ‘曹植‘}
==================================
{‘刘禅‘, ‘孙权‘, ‘曹操‘, ‘刘备‘}

3.2 删除函数

clear()  清空集合

setvar = {"曹操","刘禅","孙权","刘备"}
setvar.clear()
print(setvar)

执行

[[email protected] python]# python3 test.py test.py
set()

pop()    随机删除集合中的一个数据

setvar = {"曹操","刘禅","孙权","刘备"}
setvar.clear()
print(setvar)

执行三次

[[email protected] python]# python3 test.py test.py
刘备
{‘孙权‘, ‘曹操‘, ‘刘禅‘}
[[email protected] python]# python3 test.py test.py
曹操
{‘刘备‘, ‘刘禅‘, ‘孙权‘}
[[email protected] python]# python3 test.py test.py
刘禅
{‘曹操‘, ‘刘备‘, ‘孙权‘}

remove()  删除集合中指定的值(不存在则报错)

setvar = {"曹操","刘禅","孙权","刘备"}
setvar.remove("刘禅")
print(setvar)

执行

[[email protected] python]# python3 test.py test.py
{‘曹操‘, ‘刘备‘, ‘孙权‘}

discard() 删除集合中指定的值(不存在的不删除 推荐使用)

setvar = {"曹操","刘禅","孙权","刘备"}
setvar.discard("刘禅121211212") # 如果这个值不存在,就不删除,也不报错
print(setvar)
setvar.discard("刘禅") # 如果这个值不存在,就不删除,也不报错
print(setvar)

执行

[[email protected] python]# python3 test.py test.py
{‘刘备‘, ‘刘禅‘, ‘曹操‘, ‘孙权‘}
{‘刘备‘, ‘曹操‘, ‘孙权‘}

3.3 冰冻集合

frozenset 可强转容器类型数据变为冰冻集合
冰冻集合一旦创建,不能在进行任何修改,只能做交叉并补操作

定义一个空冰冻集合

fz = frozenset()
print(fz,type(fz))

fz1 = frozenset([1,"2",3,4])
fz2 = frozenset("7892")
print(fz1,fz2)

执行

frozenset() <class ‘frozenset‘>
frozenset({1, 3, 4, ‘2‘}) frozenset({‘9‘, ‘7‘, ‘8‘, ‘2‘})

并冻集合只能做交叉并补

fz1 = frozenset([1,"2",3,4])
fz2 = frozenset("7892")
res = fz1 & fz2
print(res)

执行

[[email protected] python]# python3 test.py test.py
frozenset({‘2‘})

原文地址：https://www.cnblogs.com/zyxnhr/p/12271645.html

时间： 2024-10-03 05:14:59

012.Python的字典和集合的相关函数的相关文章

Python 之字典与集合

进入python的字典与集合的学习. 先回顾下集合. 在python中,集合用set表示.花括号与set()可以用来创建集合. 还是先创建一个空的集合 不能用s={}来创建一个集合,创建一个空的集合使用set(). 集合是无序的,不重复的,所以在创建集合的时候重复的元素会被去掉. 集合的基本运算: 交    & 并    | 差    - 对称差 ^ 举个例子: 设集合s1={1,2,3,4},集合s2={2,3,5} 则: >>> s1={1,2,3,4} >>&g

Python的字典和集合

字典 字典是Python种唯一的映射类型.映射类型中的数据是无序排列的.在映射类型种,我们使用键直接‘映射’到值,这就是为什么叫映射类型的原因,映射类型通常被称做哈希表,因为字典对象就是哈希类型的.哈希表的算法是获取键,对键执行一个叫做哈希函数的操作,并根据计算的结果,选择在数据结构的某个地址中来存储值.任何一个值存储的地址取决于它的键,因此,哈希表中的值是没有顺序的.哈希表有一个很好的性能,因为用键查询相当快. 字典的基本操作 #字典的赋值 >>> dict1 = {} >>

Python中字典和集合

映射类型: 表示一个任意对象的集合,且可以通过另一个几乎是任意键值的集合进行索引 与序列不同,映射是无序的,通过键进行索引 任何不可变对象都可用作字典的键,如字符串.数字.元组等 包含可变对象的列表.字典和元组不能用作键 引用不存在的键会引发KeyError异常 1)字典 dict { } 空字典 { key1:value1,key2:value2,... } 字典在其它编程语言中又称作关联数组或散列表: 通过键实现元素存取:无序集合:可变类型容器,长度可变,异构,嵌套 支持的操作: len(D

Day4—python基础—字典and集合

字典就是键值对应,键唯一,无序.集合用来去重,关系测试,无序. 字典这种数据类型常用的方法有: 1.clear() print(name.clear()) 清除字典中的数据,输出结果为none 2.fromkeys() print(name.fromkeys(["c","z","p"],100)) 创建字典,通过列表的方式指定多个key,并将这些key赋予相同的值 输出结果为: {'c': 100, 'z': 100, 'p': 100} 3.g

Python中字典和集合的用法

本人开始学习python 希望能够慢慢的记录下去 写下来只是为了害怕自己忘记. python中的字典和其他语言一样 也是key-value的形式  利用空间换时间 可以进行快速的查找 key 是唯一的 不可变的类型 比如 str int 等  不能是list之类的可变类型 1.定义 定义一个字典 格式{key:value,key:value} a = {'a':80,'b':90,1:'a',2:[1,2]} print(a) 如果是定义如下 a = {'a':90,[1,2,3]:10} 则会

python之字典和集合

字典 字典的创建 >>> a = {'one': 1, 'two': 2, 'three': 3} >>> b = dict(one=1, two=2, three=3) >>> c = dict([('two', 2), ('one', 1), ('three', 3)]) >>> a == b == c True >>> d = {}.fromkeys(('x', 'y'), 1) >>> d

Python 核心技术与实战 --02 字典和集合

什么是字典?字典是一系列由键(key) 和 值(value) 配对组成的元素集合,在python3.7+ , 字典被确定为有序(注意在3.6 中,字典有序是一个implementation detail, 在3.7 才正式成为语言特性),而在3.6 无法100% 保证有序性,而在3.6 之前是无序的,其长度大小可变,元素可以任意地删减和改变. 相比于列表和元组,字典的性能更优,特别是相对于查找/添加/删除的操作,字典都能在常数时间复杂度内完成. 而集合和字典基本相同,唯一的区别,就是集合没有键和

python 学习笔记day05-python字典和集合、条件和循环、文件和输入输出

字典和集合 字典基础操作 创建字典 通过{}操作符创建字典 通过dict()工厂函数创建字典 通过fromkeys()创建具有相同值的默认字典 >>> aDict = {'Name':'Bob','age':23}                >>> import tab                >>> bDict = dict((['name','bob'],['age',23]))                >>> p

python基础知识——基本的数据类型2——列表，元组，字典，集合

磨人的小妖精们啊!终于可以归置下自己的大脑啦,在这里我要把--整型,长整型,浮点型,字符串,列表,元组,字典,集合,这几个知识点特别多的东西,统一的捯饬捯饬,不然一直脑袋里面乱乱的. 一.列表 1.列表的全部方法 如:['1','2'].['wupeiqi', 'alex'] 1 >>> dir(list) 2 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '_