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

2021/7/31 1:07:31

本文主要是介绍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(字典)的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!


扫一扫关注最新编程教程