python 集合能作为字典的值吗 python中集合与字典的异同

文章目录

• 集合定义
• 集合的内置方法

• 多个集合的交集、并集、差集和对等差分以及判断

• 集合应用案例
• frozenset
• 字典的定义
• 字典的创建
• 字典的内建方法
• 字典应用
• 默认字典应用
• 内置数据结构总结

集合定义

（1）集合：集合与数组元组一样，也用于存储数据；只是存储的数据元素不可重复；集合存储不可变数据类型，列表为可变数据类型，不可以放到集合中，数字类型、字符串可以放到集合中；
列表元素转换为集合,但列表中不可以有嵌套列表：

s1=set([1,2,3])
>>> s1
{1, 2, 3}

（2）特性：

• 数据元素不可重复
• 集合内部会对数据元素自动按一定顺序处理，但不是自动排序
• 无切片，无索引

（3）定义空集合四种方式：

s=set()#元组转换为集合
s=set({})
s=set([])#空列表转换为集合
s=set('')#空字符串转换为集合
s=set('abc') #将字符串‘abc’转换为集合,将每一个元素拆分为字符串组成的集合 ： {'a','b','c'}

集合的内置方法

add：增加单个元素
update：增加多个元素
remove（元素）：删除指定元素，元素不存在会报错
discard（元素）：删除指定元素，元素不存在不会报错
clear()：清空集合
pop（）：随机删除元素，返回删除的元素
注意： 集合是一个无序的数据类型，增加元素位置不确定，因此索引值会随时变化，所以集合不可以索引和切片

>>> s
{'people', 1, 'hello', 2, 3.5, 0, 'bye'}
>>> s.add(5)
>>> s
{'people', 1, 'hello', 2, 3.5, 0, 5, 'bye'}
>>>s.update({2, 3, 4, 5, 6})
>>>s
{'people', 1, 'hello', 2, 3.5, 0, 5, 'bye',2, 3, 4, 5, 6}
>>> s
{'people', 1, 'hello', 2, 3.5, 0, 5, 10, 'bye'}
>>> s.pop()
'people'
>>> s.remove(2)
>>> s
{1, 'hello', 3.5, 0, 5, 10, 'bye'}
>>>s.clear()
>>>s
{}

多个集合的交集、并集、差集和对等差分以及判断

（1）交集
使用方法：& 或 .intersection

>>>set1 = {1, 2, 3}
>>>set2 = {1, 2, 4}
>>>print("交集是: ", set1.intersection(set2)) 
交集是:  {1, 2}
>>>print("交集是: ", set1 & set2)
交集是:  {1, 2}
>>>set1.interaection_update(set2) #s1与s2求交集并赋值给set1
>>>set1
{1,2}

(2) 并集
使用方法：| 或 .union()

>>>print("并集是: ", set1 | set2)  
>>>print("并集是: ", set1.union(set2)) 
并集是:  {1, 2, 3, 4}
并集是:  {1, 2, 3, 4}

（3）差集 : set1 - set2 = set1 - (set1 & set2)
使用方法：- 或.difference（）

>>>print("差集是: ", set1 - set2) 
>>>print("差集是: ", set1.difference(set2))   
差集是:  {3}
差集是:  {3}

(4)对等差分 : (set1 | set2) - (set1 & set1)
使用方法：^或.symmetric_difference（）

>>>print("对等差分是: ", set1.symmetric_difference(set2)) 
>>>print("对等差分是: ", set2 ^ set1) 
对等差分是:  {3, 4}

（5）子集判断、不相交判断
·A.issubset(B)· 表示A是否是B的子集；返回值为bool类型

s1={1,2} s2={1,2,3}
s1.isdisjoint(s2) #s1与s2没有交集 返回False
s1.issubset(s2)#s1是s2的子集  返回True
s1.issuperset(s2)#s2包含s1  返回True

集合应用案例

一：去重

#对给定数组去重
a=input('>>>').split()
print(list(set(a)))

二：求数组交集

a=input('>>>').split()
b=input('>>>').split()
print(list(set(a) & set(b)))

三：判断数组是否存在重复元素

a=input('>>>').split()
print(len(a)==len(set(a)))

四：先用计算机生成了N个1到1000之间的
随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉；再把这些数从大到小排序。
去重+排序

import random
num=set() #定义一个空集合
N=int(input('>>')) #用户输入指定生成的随机数个数
for i in range(N) :#生成N个随机数，因此遍历N次
    i=random.randint(1, 1000)
    num.add(i)
#list(num).sort(reverse=True)   从大到小排序
#排序中： sort只能对列表排序，sorted()可以对任意数据类排序
print(sorted(num,reverse=True))

frozenset

#1). 当集合元素不需要改变时,使用 frozenset 代替 set 更安全。
#2). 当某些 API 需要不可变对象时,必须用 frozenset 代替set。

>>>set1 = frozenset({1, 2, 3, 4})
>>>print(set1, type(set1))
>>>set2 = {1, 2, set1}
>>>print(set2)
frozenset({1, 2, 3, 4}) <class 'frozenset'>
{1, 2, frozenset({1, 2, 3, 4})}

字典的定义

(1）存储键值对数据元素的数据结构类型，另一种可变容器模型，且可存储任意类型对象。
字典可以快速通过key值查询到value值。
(2). key值是唯一的， value值无所谓
(3). 字典的key值必须是不可变的数据类型, value值可以是任意数据类型
(4)字典没有切片
(5)字典中的for循环，是对字典中key的循环

字典的创建

(1)定义一个空字典

d={}
d=dict()

(2)字典简单创建的三种方法

• zip
  num=zip(['name','passwd'],['scq','redhat']) #zip:对应位置元素组成元组，可以转成列表或字典查看

>>>list(num)
[('name', 'scq'), ('passwd', 'redhat')]
>>>print(dict(num)) #转成字典
{'name': 'scq', 'passwd': 'redhat'}

• 向字典传值、直接定义

>>>num=dict(age='18',gender='male') #dict传值
>>>print(num)
{'age': '18', 'gender': 'male'}
>>>info = {
    'name' : 'root',  
    'password': 'westos',
    'member': ['kiosk', 'student']

} #直接定义字典

• 内建方法{}.fromkey((),‘XXX’):第一个括号写键，第二个写value,默认为none，所有的键有相同的value

#创建100个银行卡号，密码全为666666
import pprint
num=set()
for i in range(100):
    num1='%.3d'%(i+1)
    num2='610103'+str(num1)
    num.add(num2)
card={}.fromkeys(num,'666666')#键值从集合num中取，value均为666666，存储在字典中
pprint.pprint(card)

字典的内建方法

• 字典查看应用：通过key返回对应value

>>>a=dict(
name1='1',
name2='2',
name3='3')
>>>print(a['name1']) #key：name1为字符串，查看对应value值时要加引号
1
>>>print(a['name4'])#'name4'不存在，报错
KeyError: 'name4'

• get方法在key不存在下返回默认值none，可以指定默认值

>>>a.get('name1')
'1'
>>>a.get('name999','no user') #当key不存在时，指定返回‘no user’
'no user'

• 查看所有key值/value值/key-value值

>>>print(a.keys())#以列表返回
dict_keys(['name1', 'name2', 'name3'])
>>>print(a.values()) #以列表返回
dict_values(['1', '2', '3'])
>>>print(a.items()) #key-value对组成元组存入列表
dict_items([('name1', '1'), ('name2', '2'), ('name3', '3')])

• 遍历字典的key-value

>>>for key,value in a.items(): 遍历列表内的元组
		print(key,value)
name1 1
name2 2
name3 3

• 字典的增加
  （1）key:增加、修改

a['name1']='dfkh' #修改
a['name4']='gdfvg' #增加

（2）setdefault 只是增加不修改，只对字典中没有的key值有效

a.setdefault('name8','ldx')

(3)update 批量添加

>>>b=dict(
name5='11',
name6='11',
name7='11',)

>>>a.update(b)
>>>a
{'name1': '1',
 'name2': '2',
 'name3': '3',
 'name5': '11',
 'name6': '11',
 'name7': '11'}

• 字典的删除
  （1）del a['name1'] (2) pop #删除key对应的value值并返回删除的value值

c=a.pop('name1')
c=a.pop('name100','no user') #key不存在，要指定返回的默认值‘no user’

（3）popitem 随机删除键值对并返回删除的值

key,value=a.popitem()

字典应用

一：英文词频统计器,返回高频元素。字典通过key查看，也通过key增加value值

from collections import Counter
words=['a','b','c','b']
nums={} #定义一个空字典
for item in words:
    b=words.count(item) #求列表中每一个元素的次数
    nums[item]=b #元素与次数传给字典nums，如果遍历到相同的元素同时求次数，Key增加的方法会修改已经存在的key-value对，因此不影响
print(nums)
counter=Counter(nums) #对字典中的value找大小
print(counter.most_common(2)) #打印频次最高的前2位,两个元组中存入元素以及对应次数
top=[] #只打印频次最高的前2位的元素
for key,value in counter.most_common(2):
    top.append(key)
print(top)

#方法二：

for item in words:
    if item not in nums:
        nums[item]=1#初始化放到空字典中，value值均为1，后期遍历相同的直接加一将item,1键值对传入字典nums中
    else:
        nums[item]+=1 #通过key值查找对应value值并加一，相当于计数count

#方法三：

counter=Counter(words) #记录列表中每一个元素对应的次数以字典形式存入counter
  print(counter.most_common(2))

二：字典去重：因为字典的key值是不能重复的.

>>>num=[1,1,1,1,2]
>>>print({}.fromkeys(num).keys()) #默认num中每一个元素的value值为none，以列表形式返回去重后所有的key值
dict_keys([1, 2])

三：字典swich语句实现，输入一个成绩，输出相应的成绩等级

grade=input('>>')
grade_dict=dict(A='good',B='ok',C='not bad',D='bad')
print(grade_dict.get(grade,'无效等级')) #输入除了ABCD的字符，返回无效等级

四：md5加密、解密
Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。hashlib库进行md5加密,操作如下

import hashlib

#md5加密需要传递的时bytes类型
passwd = b'westos'
md5_passwd = hashlib.md5(passwd).hexdigest()
print(md5_passwd)

生成MD5加密数据库信息：

from string import  digits
#Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。hashlib库进行md5加密,操作如下
import hashlib
#显示程序运行的进度条
from tqdm import tqdm
import json

db = {}
for item1 in tqdm(digits):
    for item2 in digits:
        for item3 in digits:
            for item4 in digits:
                for item5 in digits:
                    for item6 in digits:
                        passwd1 = item1  + item2 + item3 + item4 + item5 + item6
                        # md5加密需要的字符串时bytes类型, 将utf-8的编码格式编码成bytes类型
                        passwd = passwd1.encode('utf-8')
                        md5_passwd = hashlib.md5(passwd).hexdigest()
                        db[md5_passwd] = passwd1

#将db字典的信息以json的格式存储到md5.json文件中
json.dump(db, open('md5.json', 'w'))
print("生成数据库成功.......")

默认字典应用

defaultDict：defaultdict 是 dict 的子类。但它与 dict 最大的区别在于，如果程序试图根据不存在的 key 访问 value，会引发 KeyError 异常；而 defaultdict 提供default_factory 属性，该为不存在的 key 来自动生成生成默认的 value。
需求： 我们想要一个能将键（key）映射到多个值的字（即所谓的一键多值字典）。
方法：
（ 1). 字典是一种关联容器，每个键都映射到一个单独的值上。如果想让键映射到多个值，需要将这些多个
值保存到容器（列表或者集合）中。
（2). 利用collections模块中的defaultdict类自动初始化第一个值，这样只需关注添加元素.
举例：

from collections import  defaultdict

info = defaultdict(int)  #对key：a不断修改value值，value类型为int
info['a'] += 1
info['a'] += 2
info['a'] += 3
print(info['a'],info) #打印key：‘a’对应的value值和整个字典

info = defaultdict(list) #value类型为list
info['a'].append(1)
info['a'].append(2)
info['b'].append(4)
print(info['a'],info)

info = defaultdict(set) #value类型为set
info['a'].add(1)
info['a'].add(2)
info['b'].add(4)
print(info['a'],info)

输出结果为：
6 defaultdict(<class 'int'>, {'a': 6})
[1, 2] defaultdict(<class 'list'>, {'a': [1, 2], 'b': [4]})
{1, 2} defaultdict(<class 'set'>, {'a': {1, 2}, 'b': {4}})

应用：
一：用defaultDict来做一个练习,把list(随机生成50个1-100之间的随机数)中大于66的元素和小于66的元素放到字典中

from collections import defaultdict
import random
li=[]
for i in range(50) :
    li.append(random.randint(1,100))

sort_dict=defaultdict(list) #创建value值类型为列表的默认字典，value默认为空
for item in li:
    if item > 66:
        sort_dict['大于66的元素'].append(item)
    else:
        sort_dict['小于66的元素'].append(item)
print(sort_dict)

内置数据结构总结

可变数据类型:可以增删改。列表通过索引修改元素，id不变，但元素改变 。列表、集合、字典均为可变数据类型。可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。

不可变数据类型:不可以增删改， id改变 ，字符串相当于重新创建。

有序序列特性: 索引、切片、连接操作符、重复操作符以及成员操作符等特性。