Python基本数据类型（四）——Set(集合)、Dictionary(字典)

本文主要是介绍Python基本数据类型（四）——Set(集合)、Dictionary(字典)，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

- Set集合
- - 一、创建集合
  - 二、集合运算符
  - 三、内置方法
- Dictionary字典
- - 一、创建字典
  - - 1、用{}标识
    - 2、构造函数dict
    - 3、其它方法
  - 二、基本操作
  - 三、内置函数
  - 四、内置方法

Set集合

无序、不重复

由一个或数个形态各异的大小整体组成，构成集合的事物或对象称作元素或是成员

基本功能：进行成员关系测试和删除重复元素

一、创建集合

使用大括号 { } 或者 set() 函数

注意：创建一个空集合必须用 set() 而不是 { }， { } 用来创建一个空字典

代码示例：

# 创建集合
a = {'1', 2, 2,'R','A','B'}
b = set('12343335')

#输出集合，不输出重复的元素，元素是无序的
print(a)  
print(b)

# 成员测试
if '1' in a :
    print('1 在集合中')
else :
    print('1 不在集合中')



'''
输出结果：
{2, 'B', 'A', 'R', '1'}
{'3', '1', '2', '4', '5'}
1 在集合中
'''

二、集合运算符

符号	运算
差集	-
并集	\|
交集	&
异或(不同时存在的元素)	^

代码示例：

# 集合运算
a = set('1234567')
b = {'1','3','5','6','7','8'}
print(a)
print(b)
print('1' in a)	# 元素1是否在a中
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素



'''
输出结果：
{'1', '5', '3', '7', '4', '2', '6'}
{'1', '3', '7', '8', '6', '5'}
True
{'4', '2'}
{'1', '5', '3', '7', '4', '2', '8', '6'}
{'1', '5', '3', '7', '6'}
{'4', '2', '8'}
'''

三、内置方法

方法	描述
s.add(x)	将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作
s.update( x )	添加元素，参数可以是列表，元组，字典等
s.remove( x )	将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误
s.discard( x )	移除元素，如果元素不存在，不会发生错误
s.pop()	随机删除集合中的一个元素
s.copy()	复制集合
s.clear()	清空集合
len(s)	计算集合 s 元素个数
x in s	判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False

代码示例：

s = set('13557')
print(s)

s.add('4')
print('s.add(\'4\'): ',s)

s.update(('4','5','6'))  #元组
print('s.update((\'4\',\'5\',\'6\')): ',s)

s.remove('6')
s.discard('5')
print('s.remove(\'6\')、s.discard(\'5\'): ',s)

s.pop()
print('s.pop()：',s)

s.pop()
print('s.pop()：',s)

s1 = s.copy()
print('s1 = s.copy():',s1)
print('len(s):',len(s))

print('\'1\' in s:','1' in s)


s.clear()
print('s.clear():',s)



'''
输出结果：
{'7', '1', '3', '5'}
s.add('4'):  {'5', '4', '7', '1', '3'}
s.update(('4','5','6')):  {'5', '6', '4', '7', '1', '3'}
s.remove('6')、s.discard('5'):  {'4', '7', '1', '3'}
s.pop()： {'7', '1', '3'}
s.pop()： {'1', '3'}
s1 = s.copy(): {'1', '3'}
len(s): 2
'1' in s: True
s.clear(): set()

'''

方法	描述
s.isdisjoint(s1)	判断两个集合是否包含相同的元素，没有相同元素返回 True，否则返回 False
s.issubset(s1)	判断集合s的所有元素是否都包含在s1中，如果是则返回 True，否则返回 False
s.issuperset(s1)	判断s1的所有元素是否都包含在s中，如果是则返回 True，否则返回 False

s = {'0','1','2'}
s1 = set("34")
print(s)
print(s1)
print('s.isdisjoint(s1):',s.isdisjoint(s1))     #没有相同元素返回true

print('---------------------')
s = {'0','1','2'}
s1 = set("01234")
print(s)
print(s1)
print('s.issubset(s1):',s.issubset(s1))     #判断集合s的所有元素是否都包含在s1中

print('---------------------')
s = {'0','1','2'}
s1 = set("01234")
s2 = set('01')
print(s)
print(s1)
print(s2)
print('s.issuperset(s1):',s.issuperset(s1))    #判断s1的所有元素是否都包含在s中
print('s.issuperset(s2):',s.issuperset(s2))    #判断s2的所有元素是否都包含在s中



'''
输出结果：
{'1', '0', '2'}
{'3', '4'}
s.isdisjoint(s1): True
---------------------
{'1', '0', '2'}
{'0', '4', '2', '1', '3'}
s.issubset(s1): True
---------------------
{'1', '0', '2'}
{'0', '4', '2', '1', '3'}
{'1', '0'}
s.issuperset(s1): False
s.issuperset(s2): True

'''

方法	描述
s.union(s1, s2…)	并集，返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次
s.difference(s1)	差，s-s1，不改变集合
s.difference_update(s1)	差，移除两个集合中都存在的元素,s-s1，改变集合s
s.intersection(s1, s2 … )	交集，即相同元素，不改变集合
s.intersection_update(s1, s2 … )	交集，即相同元素，改变集合s
s.symmetric_difference(s1)	异或，返回两个集合中不重复的元素的集合
s.symmetric_difference_update(s1)	异或，移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中

print('---------并集（s1 ∪ s2）----------')
s1 = {'0','1','2'}
s2 = set("0234")
print('s1:',s1)
print('s2:',s2)
print('s1.union(s2):',s1.union(s2))
print("执行后：(不改变s1,s2)")
print('s1:',s1)
print('s2:',s2)



'''
输出结果：
---------并集（s1 ∪ s2）----------
s1: {'1', '2', '0'}
s2: {'4', '0', '2', '3'}
s1.union(s2): {'1', '2', '0', '4', '3'}
执行后：(不改变s1,s2)
s1: {'1', '2', '0'}
s2: {'4', '0', '2', '3'}

'''

print("-------------差集（s1-s2）-----------------")
s1 = {'0','1','2','3','4'}
s2 = set("23456")
print('s1:',s1)
print('s2:',s2)
print('s1.difference(s2):',s1.difference(s2))
print("执行后：(不改变s1,s2)")
print('s1.difference(s2),s1:',s1)
print('s1.difference(s2),s2:',s2)

print()
s1.difference_update(s2)
print("执行后：(改变s1)")
print('s1.difference_update(s2),s1:',s1)
print('s1.difference_update(s2),s2:',s2)



'''
输出结果：
-------------差集（s-s1）-----------------
s1: {'4', '2', '0', '1', '3'}
s2: {'4', '2', '5', '3', '6'}
s1.difference(s2): {'1', '0'}
执行后：(不改变s1,s2)
s1.difference(s2),s1: {'4', '2', '0', '1', '3'}
s1.difference(s2),s2: {'4', '2', '5', '3', '6'}

执行后：(改变s1,s2)
s1.difference_update(s2),s1: {'0', '1'}
s1.difference_update(s2),s2: {'4', '2', '5', '3', '6'}

'''

print('------------交集------------')
s = {'0','1','2'}
s1 = set("0234")
s2 = set('12456')
print('s:',s)
print('s1:',s1)
print('s2:',s2)
print('s.intersection(s1):',s.intersection(s1))
print("执行后：(不改变s,s1)")
print('s.intersection(s1),s:',s)
print('s.intersection(s1),s1:',s1)
print()
print('s.intersection(s1,s2):',s.intersection(s1,s2))
print("执行后：(不改变s,s1)")
print('s.intersection(s1),s:',s)
print('s.intersection(s1),s1:',s1)

print()
s.intersection_update(s1)
print("执行后：(改变s)")
print('s.intersection_update(s1),s:',s)
print('s.intersection_update(s1),s1:',s1)
s.intersection_update(s1,s2)
print('s.intersection_update(s1,s2),s:',s)



'''
输出结果：
------------交集------------
s: {'0', '2', '1'}
s1: {'3', '0', '4', '2'}
s2: {'2', '5', '4', '6', '1'}
s.intersection(s1): {'0', '2'}
执行后：(不改变s,s1)
s.intersection(s1),s: {'0', '2', '1'}
s.intersection(s1),s1: {'3', '0', '4', '2'}

s.intersection(s1,s2): {'2'}
执行后：(不改变s,s1)
s.intersection(s1),s: {'0', '2', '1'}
s.intersection(s1),s1: {'3', '0', '4', '2'}
'''

print('------------异或（保留不相同元素）------------')
s = {'0','1','2'}
s1 = set("0234")
s2 = set('12456')
print('s:',s)
print('s1:',s1)
s.symmetric_difference(s1)
print('s.symmetric_difference(s1):',s.symmetric_difference(s1))
print("执行后：(不改变s)")
print('s.symmetric_difference(s1),s:',s)
print('s.symmetric_difference(s1),s1:',s1)

print()
s.symmetric_difference_update(s1)
print("执行后：(改变s)")
print('s.symmetric_difference_update(s1),s:',s)#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中
print('s.symmetric_difference_update(s1),s1:',s1)



'''
输出结果：
------------异或（保留不相同元素）------------
s: {'1', '0', '2'}
s1: {'3', '0', '2', '4'}
s.symmetric_difference(s1): {'3', '1', '4'}
执行后：(不改变s)
s.symmetric_difference(s1),s: {'1', '0', '2'}
s.symmetric_difference(s1),s1: {'3', '0', '2', '4'}

执行后：(改变s)
s.symmetric_difference_update(s1),s: {'3', '1', '4'}
s.symmetric_difference_update(s1),s1: {'3', '0', '2', '4'}
'''

Dictionary字典

Python中另一个非常有用的内置数据类型

字典是无序的对象集合（列表是有序的对象集合）

字典是一种映射类型，用 { } 标识，key和value用":“隔开，键值对之间用”,"分隔，是一个无序的 键值(key-value) 集合

元素通过键key来存取，在同一个字典中，键(key)唯一

键(key)必须使用不可变类型（Number、String、Tuple），值可以取任何数据类型

一、创建字典

1、用{}标识

代码示例：

# create dictionary
d1= {}
d1['哈哈'] = 'haha'
d1['嘿嘿']= 'heihei'
d2 = {'昵称': '入错行的北北','码龄': '1年','博客':'北北的博客'}
# print dictionary
print (d1["哈哈"])       # 输出键为"哈哈"的值
print (d1["嘿嘿"])       # 输出键为"嘿嘿"的值
print(d1)
print (d1.keys())   # 输出所有键
print (d1.values()) # 输出所有值
print()
print (d2)          # 输出完整的字典
print (d2.keys())   # 输出所有键
print (d2.values()) # 输出所有值

d = { }				#创建空字典
print(d)




'''
输出结果：
haha
heihei
{'哈哈': 'haha', '嘿嘿': 'heihei'}
dict_keys(['哈哈', '嘿嘿'])
dict_values(['haha', 'heihei'])

{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
dict_keys(['昵称', '码龄', '博客'])
dict_values(['入错行的北北', '1年', '北北的博客'])
{}
'''

2、构造函数dict

构造函数 dict() 可以直接从键值对序列中构建字典

代码示例：

# create dictionary
d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])
print (d)          # 输出完整的字典
print(d['昵称'])
print(d['码龄'])
print(d['博客'])
print (d.keys())   # 输出所有键
print (d.values()) # 输出所有值



'''
输出结果：
{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
入错行的北北
1年
北北的博客
dict_keys(['昵称', '码龄', '博客'])
dict_values(['入错行的北北', '1年', '北北的博客'])
'''

3、其它方法

代码示例1：

d = {x: x ** 2 for x in (2, 4, 6)} #**2,平方; **n,n次方
print(d)



'''
输出结果：
{2: 4, 4: 16, 6: 36}
'''

代码示例2：

d = dict(aa=1, bb=2, cc=3)
print(d)



'''
输出结果：
{'aa': 1, 'bb': 2, 'cc': 3}
'''

二、基本操作

修改字典

d = dict([('昵称','北北'), ('码龄','1年'), ('博客','北北的博客')])
print (d)          # 输出完整的字典
d['昵称'] = '入错行的北北'  #修改
print(d)



'''
输出结果：
{'昵称': '北北', '码龄': '1年', '博客': '北北的博客'}
{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
'''

删除字典元素
删除单一元素
清空字典

d = dict([('昵称','北北'), ('码龄','1年'), ('博客','北北的博客')])
print ('原始字典：',d)          # 输出完整的字典
del d['码龄'] # 删除键 '码龄'
print('del d[\'码龄\']:',d)
d.clear()     # 清空字典
print('d.clear():',d)




'''
输出结果：
原始字典： {'昵称': '北北', '码龄': '1年', '博客': '北北的博客'}
del d['码龄']: {'昵称': '北北', '博客': '北北的博客'}
d.clear(): {}

'''

删除字典

del d        # 删除字典
print(d)


'''
输出结果：(报错)
NameError: name 'd' is not defined
'''

三、内置函数

函数名	作用
len()	求长度
type()	查询类型
str()	字典以可打印的字符串表示

代码示例：

d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])

print ("d字典长度len(d): ", len(d))
print ("d的类型type(d): ", type(d))
print()
print('输出字典d :' , d)            #输出字典
print ( '输出字典str(d) :' , str(d))     #输出字典，以可打印的字符串表示





'''
代码示例：
d字典长度len(d):  3
d的类型type(d):  <class 'dict'>

输出字典d : {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
输出字典str(d) : {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}


'''

四、内置方法

方法名	描述
copy()	返回一个字典的浅复制
clear()	删除字典内所有元素
get()	返回指定键的值，如果值不在字典中返回default值
key in dict	判断键是否存在于字典中，是则为true
key not in	与in相反
dict.items()	返回视图对象

d = dict([('昵称','入错行的北北'), ('码龄','1年'), ('博客','北北的博客')])

d1 = d.copy()
print('d.items():',d.items())
print('d1 = d.copy(): ' , d1)
d.clear()           #删除字典内所有元素
print('d.clear(): ',d)
print()
print('d1.get(\'昵称\') :' ,d1.get('昵称'))
print('昵称' in d)
print('name' not in d)

'''
输出结果：
d.items():dict_items([('昵称', '入错行的北北'), ('码龄', '1年'), ('博客', '北北的博客')])
d1 = d.copy():  {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
d.clear():  {}

d1.get('昵称') : 入错行的北北
True
True
'''

方法名	描述
keys()	返回一个迭代器，可以使用 list() 来转换为列表
values()	返回一个迭代器，可以使用 list() 来转换为列表
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

d = dict([('昵称','入错行的北北'), ('码龄', '1年')])
print('d.keys():',d.keys())
print('d.values():',d.values())

print()
print("昵称 键的值为 : %s" % dict.setdefault('昵称', None))
print("博客 键的值为 : %s" % dict.setdefault('博客', '北北的博客'))
print("新字典为：", dict)


'''
输出结果：
d.keys(): dict_keys(['昵称',  '博客'])
d.values(): dict_values(['入错行的北北', '北北的博客'])

昵称 键的值为 : 入错行的北北
博客 键的值为 : 北北的博客
新字典为： {'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
'''

方法名	描述
dict.fromkeys(seq[, value])	创建一个新字典，seq中元素为键，value为键对应的初始值
update(dict2)	把字典dict2的键/值对更新到dict里
pop(key[,default])	删除字典给定键 key 所对应的值，返回值为被删除的值
popitem()	随机返回并删除字典中的一对键和值(一般删除末尾对）

seq = ('昵称', '码龄', '博客')
dict = dict.fromkeys(seq)
print("新的字典为 :" ,str(dict))

value = ('你猜')
dict = dict.fromkeys(seq, value)
print("新的字典为 : %s" % str(dict))

print()
d1 = dict([('昵称','入错行的北北'), ('码龄', '1年')])
d2 = {'博客':'北北的博客'}
d1.update(d2)
print(d1)

print('d1.pop(\'码龄\'):',d1.pop('码龄'))
print('d1:',d1)

print()
print('d1.popitem():',d1.popitem())	#默认删除末尾
print('d1:',d1)
'''
输出结果：
新的字典为 : {'昵称': None, '码龄': None, '博客': None}
新的字典为 : {'昵称': '你猜', '码龄': '你猜', '博客': '你猜'}

{'昵称': '入错行的北北', '码龄': '1年', '博客': '北北的博客'}
d1.pop('码龄'): 1年
d1: {'昵称': '入错行的北北', '博客': '北北的博客'}

d1.popitem(): ('博客', '北北的博客')
d1: {'昵称': '入错行的北北'}

'''

这篇关于Python基本数据类型（四）——Set(集合)、Dictionary(字典)的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Python教程