文章目录
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: {'昵称': '入错行的北北'}
'''