1.什么是字典

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列
• 在存储数据时要经过hash(key)的计算，计算的结果就是存储的位置，因此字典的键值对顺序并不是按照存储时的先后顺序决定的，而是经过计算得到的存储位置。
• 字典中的键必须时不可变序列，否则当键改变时，hash计算的结果就会发生变化，导致存储位置发生变化。因此键必须要使用不可变序列

• 字典的实现原理
• 与查新华字典类似，差字典是先根据部首或者拼音查找相应的页码，Python中的字典是根据 key去查找value的所在位置

2.字典的创建方式

#字典创建的两种方式
#第一种，使用花括号
dict_1 = {'num':'20210101','name':'Liming','sex':'male'}
print(dict_1)
#第二种，使用内置函数dict()
# 2.1 通过其他字典创建
dict_2 = dict(dict_1)
print(dict_2)
print(dict_2 is dict_2)     # True

# 2.2 通过关键字参数创建
dict_3 = dict(num = "20210101",name = "Liming",sex = 'male')
print(dict_3)
print(dict_1 == dict_3)     #True
print(dict_1 is dict_3)     #False

# 2.3 通过键值对的序列创建
dict_4 = dict([('num',"20210101"),('name',"Liming"),('sex',"male")])
print(dict_3)

#2.4 通过dict和zip结合创建
dict_5 = dict(zip(['num','name','sex'],['20210101','Liming','male']))
print(dict_5)

if dict_1 == dict_2 == dict_3 == dict_4 == dict_5:   #判断字典的值是否相同
    print("创建字典的5种方式相同")
else:
    print("创建字典的5种方式不同")

• 字典种的键是唯一的，创建字典时若出现"键"相同的情况，则后定义的"键-值"对将覆盖先定义的"键-值"对。

x = {'a':1,'b':2,"b":3}
print(x)
#运行结果
{'a': 1, 'b': 3}

• fromkeys()方法创建字典：当所有的键对应同一个值的时候，可以使用fromkeys创建字典
• dict.fromkeys(seq[,value])：
• seq:为字典"键"的值列表
• value：为设置键序列(seq)的值，省略时默认为None

dict_1 = dict.fromkeys(['zhangsan','wangwu'])
print(dict_1)
dict_2 = dict.fromkeys(['zhang_san','wang_wu'],18)
print(dict_2)
dict_3 = dict.fromkeys(['zhang_san','wang_wu'],b)
print(dict_3)
#从下面四行代码可以看出，当他们值为可变序列并且引用地址相同时，类似于浅copy
dict_3['wang_wu'].pop()
print(dict_3)
dict_3['wang_wu'].append(10)
print(dict_3)

#运行结果
{'zhangsan': None, 'wangwu': None}
{'zhang_san': 18, 'wang_wu': 18}
{'zhang_san': [18], 'wang_wu': [18]}
{'zhang_san': [], 'wang_wu': []}
{'zhang_san': [10], 'wang_wu': [10]}

3.字典的访问

a.根据键访问值

• 字典中每个元素表示一种映射关系，将提供的"键'作为下标可以访问对应的值
• 如果字典中不存在这个"键"，则会抛出异常

#根据键访问值
dict_1 = {"name":"张飞","age":18,"sex":"male"}
print(dict_1["name"])
print(dict_1["sex"])
#print(dict_1["x"])   指定的键不存在，抛出异常

b.使用get（）方法访问值

• 在访问字典时，若不确定字典中是否由某个键，可通过get（）方法进行获取。
• 若该键存在，则返回对应的值
• 若该键不存在，则返回默认值
• 语法格式
• dict.get([key[,default = None])
• key:要查找的键
• default：默认值，默认为None，可自行设置需要输出的默认值。如果指定的键不存在，则返回默认值，当default为空时，返回None

#使用get()方法访问值
dict_1 = {"name":"张飞","age":18,"sex":"male"}
print(dict_1.get("name"))
print(dict_1.get("x"))    #返回None
print(dict_1.get("x",18))   #当键不存在时，输出设置的默认值，并不会把键x存入dect_1
print(dict_1.get("age",19))   #当键存在时，输出age原本的值

4.in 和 not in 在字典中的使用

• 判断键是否在字典中

#in和not in在字典中的使用：判断键是否在字典中
dict_1 = {"name":"张飞","age":18,"sex":"male"}
print("name" in dict_1)           #True
print("张飞" in dict_1)            #False
print("张飞" not in dict_1)        #True

5.修改和添加字典中的元素

• 当以指定键为下标为字典元素赋值时，有两种含义：
• 若该键存在字典中，则表示修改该键对应的值
• 若该键不存在字典中，则表示添加一个新的键值对，也就是添加一个新元素到字典中

dict_1 = {"name":"张飞","age":18}
print(dict_1)
dict_1["name"] = "李四"   #name键存在字典dict_1中，所以此处为修改name的值
print(dict_1)
dict_1["sex"] = "male"    #sex键不存在字典dict_1中，所以此处为添加新的键值对
print(dict_1)

#输出结果
{'name': '张飞', 'age': 18}
{'name': '李四', 'age': 18}
{'name': '李四', 'age': 18, 'sex': 'male'}

6.删除字典中的元素 del命令 clear()方法 pop()方法 popitem()方法

• del命令：根据"键"删除字典中的元素

dict_1 = {"name":"张飞","age":18,"sex":"male"}
del dict_1["name"]
print(dict_1)
#运行结果
{'age': 18, 'sex': 'male'}

• clear()方法：用于清除字典中所有元素，其语法格式如下：

dict_1 = {"name":"张飞","age":18,"sex":"male"}
dict_1.clear()
print(dict_1)
#运行结果
{}

• pop()方法：用于获取指定"键"的值，并将这个键值对从字典中移除，并返回该键的值。
• dict.pop(key[,default])
• key:要被删除的键
• default：默认值，当字典中没有要被删除的key时，该方法返回指定的默认值

dict_1 = {"name":"张飞","age":18,"sex":"male"}
print(dict_1.pop("age"))     #删除键age与其值，pop（）方法的返回值为，删除的该键的值
print(dict_1)
print(dict_1.pop('age',17))
print(dict_1)
print(dict_1.pop('name',"里斯"))
print(dict_1)

• popitem()方法：用于随机获取一个键值对，将其删除，并以元组的方式返回被删除的键值对
• dict.popitem():该方法无参数

dict_1 = {"name":"张飞","age":18,"sex":"male"}
x = dict_1.popitem()
print(x,type(x))
print(dict_1)
#运行结果
('sex', 'male') <class 'tuple'>
{'name': '张飞', 'age': 18}

7.更新字典

• 使用update()方法：可以将新字典的键值对，一次性全部添加到当前字典中
• 如果两个字典存在相同的键，则以新字典中的值为准，更新当前字典
• dict.updata(dict2)
• dict:当前字典
• dict2：新字典

dict_1 = {"name":"张飞","age":18}
dict_2 = {"name":"李四","sex":"male"}
dict_1.update(dict_2)
print(dict_1)
print(dict_2)
#运行结果
{'name': '李四', 'age': 18, 'sex': 'male'}
{'name': '李四', 'sex': 'male'}

8.获取字典视图的三个方法

• key（）方法

#keys()方法：获取字典中所有的key
dict_1 = {"name":"张飞","age":18,"sex":"male"}
key_1 = dict_1.keys()
print(key_1,type(key_1)) #可以看出获取到了字典所有的键，并存放在了一个貌似列表的dict_keys视图中
key_2 = list(key_1)    #将对象key_1视图变成列表,并不改变原来的key_1视图
print(key_1)
print(key_2)
#运行结果
dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>
dict_keys(['name', 'age', 'sex'])
['name', 'age', 'sex']

• values()方法

#values()方法：获取字典中所有的value
dict_1 = {"name":"张飞","age":18,"sex":"male"}
value_1 = dict_1.values()
print(value_1,type(value_1)) #可以看出获取到了字典所有的值，并存放在了一个貌似列表的dict_values视图中
value_2 = list(value_1)
print(value_1)
print(value_2)
#运行结果
dict_values(['张飞', 18, 'male']) <class 'dict_values'>
dict_values(['张飞', 18, 'male'])
['张飞', 18, 'male']

• items(）方法

#items()方法：获取字典中所有的键值对
dict_1 = {"name":"张飞","age":18,"sex":"male"}
items_1 = dict_1.items()
#可以看出获取到了字典所有的键值对，并将键值对存放在了元组中，再把元组存放在列表中，视图类型为：dict_items
print(items_1,type(items_1))
items_2 = list(items_1)     #将视图转换成列表
print(items_2)
items_3 = tuple(items_2)    #将列表转换成元组
print(items_2)
print(items_3)
#运行结果
dict_items([('name', '张飞'), ('age', 18), ('sex', 'male')]) <class 'dict_items'>
[('name', '张飞'), ('age', 18), ('sex', 'male')]
[('name', '张飞'), ('age', 18), ('sex', 'male')]
(('name', '张飞'), ('age', 18), ('sex', 'male'))

9.遍历字典

• *使用for循环遍历，列表、元组和集合的组合时

·当变量x为一个时，x会直接获取列表（元组）的值

·当变量x,y···的个数刚好与列表（元组）的个数相同时，则直接将值依次赋给变量

注意：只有在使用列表和元组和集合的两两组合时才能这样使用。

"""
使用for循环遍历，列表和元组的组合时，
    ·当变量x为一个时，x会直接获取列表（元组）的值
    ·当变量x,y···的个数刚好与列表（元组）的个数相同时，则直接将值依次赋给变量
"""
a = [('Mary', 'C',"d"),('Jone', 'java',"d"),('Lily', 'Python',"d"),('Lily', 'Python',"d")]
for x in a:
    print(x)        #列表里面存储的元组，只有一个变量x，所以将元组直接赋值给x
print("============================================")
for x,y,z in a:     #列表里面存储的元组，每个元组里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素
    print(x,y,z)
print("============================================")

a = (['Mary', 'C',"d"],['Jone', 'java',"d"],['Lily', 'Python',"d"],['Lily', 'Python',"d"])
for x in a:         #元组里面存储的列表，只有一个变量x，所以将元组直接赋值给x
    print(x)
print("============================================")
for x,y,z in a:     #元组里面存储的列表，每个列表里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素
    print(x,y,z)
#运行结果
('Mary', 'C', 'd')
('Jone', 'java', 'd')
('Lily', 'Python', 'd')
('Lily', 'Python', 'd')
============================================
Mary C d
Jone java d
Lily Python d
Lily Python d
============================================
['Mary', 'C', 'd']
['Jone', 'java', 'd']
['Lily', 'Python', 'd']
['Lily', 'Python', 'd']
============================================
Mary C d
Jone java d
Lily Python d
Lily Python d

a = {('Mary', 'C',"A"),('Jone', 'java',"B"),('Lily', 'Python',"C"),('Lily', 'Python',"D")}
for x in a:         #集合里面存储的元组，只有一个变量x，所以将元组直接赋值给x
    print(x)
for x,y,z in a:      #集合里面存储的元组，每个元组里面存储了3个元素，刚好可以用三个变量xyz接收这三个元素
    print(x,y,z)
#运行结果
('Mary', 'C', 'A')
('Lily', 'Python', 'D')
('Jone', 'java', 'B')
('Lily', 'Python', 'C')
Mary C A
Lily Python D
Jone java B
Lily Python C

• 遍历字典中所有的键值对
• 使用items()方法，该方法以列表的形式返回可遍历的键值对元组

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for name,cla in stu_class.items():
    print(name,"选修的课程为：",cla)
#运行结果
Mary 选修的课程为： C
Jone 选修的课程为： java
Lily 选修的课程为： Python
Lilo 选修的课程为： Python

• 遍历字典中所有的键
• 当不需要字典中的值时，可使用keys()方法，只遍历字典中的键，该方法以列表返回一个字典中所有的键

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for name in stu_class.keys():
    print(name)
#运行结果
Mary
Jone
Lily
Lilo

• 遍历字典中所有的值
• 当只关心字典所包含的值时，可以使用values()方法，该方法以列表形式返回字典中所有的值

stu_class = {
    'Mary': 'C',
    'Jone': 'java',
    'Lily': 'Python',
    'Lilo': 'Python'
}
for cla in stu_class.values():
    print(cla)
#运行结果
C
java
Python
Python

10.字典的特点

• 字典中所有的元素都是一个键值对（key - value）,key不允许重复，但是value可以重复
• 字典中的元素是无序的
• 字典中的key是不可变对象（不可变序列）
• 字典页可以根据需要动态伸缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据

11.复制字典

• 直接赋值：对象的引用
• 浅复制（copy()方法）：拷贝父对象，引用对象内部的子对象
• 深复制（deepcopy()方法）:copy模块的deepcopy()方法，完全复制父对象及其子对象

dict1 = {'user':'runoob','num':[123]}
dict2 = dict1       #引用对象
dict3 = dict1.copy()    #浅复制，深复制父对象，子对象不复制，还是引用
import copy
dict4 = copy.deepcopy(dict1) #深复制，完全复制父对象和子对象
print(1,dict1,id(dict1))　　　　　　　　　　　　　　　　#1 {'user': 'runoob', 'num': [123]} 1630766832896
dict1['user'] = 'root'　　　　　　　　　　　　　　　　 　print(1,dict1,id(dict1))　　　　　　　　　　　　　　　　#1 {'user': 'root', 'num': [123, 23]} 1630766832896
print(2,dict2,id(dict2))　　　　　　　　　　　　　　　　#2 {'user': 'root', 'num': [123, 23]} 1630766832896
print(3,dict3,id(dict3))　　　　　　　　　　　　　　　　#3 {'user': 'runoob', 'num': [123, 23]} 1630766833088
print(4,dict4,id(dict4))　　　　　　　　　　　　　　　　#4 {'user': 'runoob', 'num': [123]} 1630767214080

Python集合（set）

1.什么是集合

• python语言提供的内置数据结构
• 与列表和字典一样，都属于可变序列，同时与字典一样无序的可变序列
• 集合是没有value的字典
• 集合类型与其他类型最大的区别在于，它不包含重复元素
• 集合中的元素是不可变的，但是整个集合是可变的

2.集合创建

#集合创建方式一：使用{}
set_1 = {"Python","Hello",90}
print(set_1)
set_2 = {1,1,2,3,4,4,"Python","Python"}    #集合中的元素不允许重复
print(set_2)
set_3 = {1,2.2,(1,2,3,4),"Python"}
print(set_3)
#set_4 = {1,2.2,[1,2,3,4]}    # 代码报错：集合中的元素不允许为 可变数据类型（可变序列）

#集合创建方式二：使用内置函数 set():将字符出、列表、元组、range()等对象转化成集合
set_4 = set("python")
print(set_4)
set_5 = set([1,2,3,4,5])
print(set_5)
set_6 = set((1,2,"Hello"))
print(set_6)
set_7 = set(range(5))
print(set_7)
set_8 = set()          #创建空集合
print(set_8)
set_9 = {}
print(type(set_9))     #  :所以创建空集合的时候，不能直接使用{}

注意：在Python的集合中0代表Flase，1代表True

set_1 = {2,3,4,5,6,True,False}
print(set_1)    #{False, True, 2, 3, 4, 5, 6}

set_2 = {0,1,2,3,4,5,6,True,False}
print(set_2)    #{0, 1, 2, 3, 4, 5, 6}

set_3 = {0,2,3,4,5,6,True,False}
print(set_3)    #{0, True, 2, 3, 4, 5, 6}

3.集合的判断操作

• in 或者 not in : 判断元素是否在集合中

set_1 = {10,20,30,40,50}
print(10 in set_1)          #True
print(100 in set_1)         #False
print(20 not in set_1)      #False
print(100 not in set_1)     #True

4.集合添加元素 add()方法 update()方法

set_1.add(x)方法：如果数据项x不在结合set_1中，将x添加到set_1中 （一次添加一个元素，元素不重复的前提下）

set_1.update(T)方法：合并结合T中的元素到当前集合set_1中，并自动去除重复元素 （至少添加一个元素，元素不重复的前提下）

#集合添加元素
set_1 = {1,2.2,"Python"}
set_2 = {(1,2,True,"Hello"),2.2,"Python","China"}
set_1.add((1,2,True,"Hello"))
print(set_1)
set_1.update(set_2)
print(set_1)
set_1.update([10,20,30])   #可以添加集合中的元素
print(set_1)
set_1.update((40,50,60))   #可以添加元组中过的元素
print(set_1)
#运行结果
{1, 2.2, (1, 2, True, 'Hello'), 'Python'}
{1, 2.2, 'China', (1, 2, True, 'Hello'), 'Python'}
{1, 2.2, 'China', 10, (1, 2, True, 'Hello'), 20, 'Python', 30}
{1, 2.2, 'China', 40, 10, (1, 2, True, 'Hello'), 50, 20, 'Python', 60, 30}

5.集合删除元素 remove()方法 discard()方法 pop()方法 clear()方法

S.remove(x)方法：如果x在集合S中，移除该元素；如果x不存在则抛出异常

S.discard(x)方法：如果x在集合S中，移除该元素；如果x不存在不会报错

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
set_1.remove(1)
print(set_1)
# set_1.remove(1)   #集合中无元素1，执行此代码会抛出异常
set_1.discard(2.2)
print(set_1)
set_1.discard(2.2)  #集合中无元素2.2，不过执行此代码不会抛出异常
print(set_1)
#运行结果
{(1, 2, True, 'Hello'), 2.2, 'Python'}
{(1, 2, True, 'Hello'), 'Python'}
{(1, 2, True, 'Hello'), 'Python'}

S.pop()方法：随机删除并返回集合中过的一个元素，如果集合为空则抛出异常

S.clear()方法：清空集合

set_1 = {1,(1,2,True,"Hello"),2.2,"Python"}
print(set_1.pop())
print(set_1)
set_1.clear()
print(set_1)
#set_1.pop() #集合为空，执行此行代码，会抛出异常
#运行结果
1
{2.2, 'Python', (1, 2, True, 'Hello')}
set()

6.集合间的关系

• 两个集合是否相等 == 、 != 、 is 、not is

set_1 = {10,20,30,40}
set_2 = {40,30,10,20}
print(set_1 == set_2)   #True    比较集合的值是否相等
print(set_1 is set_2)   #False   比较集合的引用地址是否相等

• 一个集合是否是另一个集合的子集
• 可以调用方法issubset() 判断
• B是A的子集

A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(B.issubset(A))     #True  B是A的子集

• 一个集合是否是另一个集合的超集
• 可以调用方法issuperset() 判断
• A是B的子集

A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.issuperset(B))   #True  A是B的超集

• 两个集合是否没有交集

• 可以调用方法isdisjoint() 判断

A = {1,2,3,4,5,6}
B = {1,2,3,4}
print(A.isdisjoint(B))   #False  判断A和B是否没有交集
B = {7,8,9,10}
print(A.isdisjoint(B))   #True  判断A和B是否没有交集

7.集合的数据关系

pass

Original: https://www.cnblogs.com/fjfsu/p/15398094.html
Author: J.FengS
Title: Python字典和集合

相关阅读

Title: 【腾讯开源项目】可视化的任务流程编排和执行的系统，轻量级的调度编排类SaaS产品，蓝鲸标准运维源码对外开放

标准运维（SOPS）是通过可视化的图形界面进行任务流程编排和执行的系统，是腾讯蓝鲸产品体系中一款轻量级的调度编排类SaaS产品。

标准运维有两大核心服务。一个是流程编排服务：基于腾讯蓝鲸PaaS平台的API网关服务，对接企业内部各个系统 API的能力，
将在多系统间切换的工作模式整合到一个流程中，实现一键自动化调度。另一个是自助化服务：标准运维屏蔽了底层系统之间的差异，
让运维人员可以将业务日常的运维工作交给产品、开发、测试等人员执行，实现业务发布、变更等日常工作的自助化，除此之外，为降低非运维人员的操作成本，
标准运维与蓝鲸PaaS平台深度整合，为用户提供了"轻应用"和"职能化"功能，提高自助率。

标准运维后台使用 Python 作为开发语言，使用 Django 开发框架；前端使用 Vue 开发页面，使用 jQuery 开发标准插件，通过配置式的开发模式，
不断降低用户开发标准插件前端表单的难度。

底层流程引擎 SDK：bamboo-engine

Overview

• 架构设计
• 代码目录
• 使用场景

Features

• 多元接入支持：标准运维对接了蓝鲸通知、作业平台、配置平台等服务，作为官方标准插件库提供服务，还支持用户自定义接入企业内部系统，定制开发标准插件。
• 可视化流程编排：通过拖拽方式组合标准插件节点到一个流程模板。
• 多种流程模式：支持标准插件节点的串行、并行，支持子流程，可以根据全局参数自动选择分支执行，节点失败处理机制可配置。
• 参数引擎：支持参数共享，支持参数替换。
• 可交互的任务执行：任务执行中可以随时暂停、继续、撤销，节点失败后可以重试、跳过。
• 通用权限管理：通过配置平台同步业务角色，支持流程模板的使用权限控制。

了解更多功能，请参考标准运维白皮书

Getting started

• 开发环境后台部署
• 开发环境前端部署
• 正式环境源码部署
• 正式环境上传部署
• 移动端部署
• 标准插件开发
• 标准运维开发者工具包

Usage

• API使用说明
• 标准插件说明
• 标准插件远程加载
• 变量引擎
• Tag使用和开发说明
• 移动端使用说明
• redis 部署模式支持
• 版本升级注意事项
• 故障排查手册

Releases

• 已发布版本

BlueKing Community

• BK-CMDB：蓝鲸配置平台（蓝鲸 CMDB）是一个面向资产及应用的企业级配置管理平台。
• BK-CI：蓝鲸持续集成平台是一个开源的持续集成和持续交付系统，可以轻松将你的研发流程呈现到你面前。
• BK-BCS：蓝鲸容器管理平台是以容器技术为基础，为微服务业务提供编排管理的基础服务平台。
• BK-PaaS：蓝鲸 PaaS 平台是一个开放式的开发平台，让开发者可以方便快捷地创建、开发、部署和管理 SaaS 应用。
• BK-SOPS：标准运维（SOPS）是通过可视化的图形界面进行任务流程编排和执行的系统，是蓝鲸体系中一款轻量级的调度编排类 SaaS 产品。
• BK-JOB：蓝鲸作业平台(Job)是一套运维脚本管理系统，具备海量任务并发处理能力。

Support

• 源码
• wiki
• 白皮书
• 蓝鲸论坛
• 蓝鲸 DevOps 在线视频教程

Contributing

如果你有好的意见或建议，欢迎给我们提 Issues 或 Pull Requests，为蓝鲸开源社区贡献力量。关于标准运维分支管理、Issue 以及 PR 规范，
请阅读 Contributing Guide。

腾讯开源激励计划 鼓励开发者的参与和贡献，期待你的加入。

FAQ

FAQ

License

标准运维是基于 MIT 协议， 详细请参考 LICENSE 。

我们承诺未来不会更改适用于交付给任何人的当前项目版本的开源许可证（MIT 协议）。

源码地址

Gitee：https://gitee.com/Tencent-BlueKing/bk-sops
GitHub：https://github.com/Tencent/bk-sops/

Original: https://www.cnblogs.com/tencent-blueking/p/16287448.html
Author: 腾讯蓝鲸智云
Title: 【腾讯开源项目】可视化的任务流程编排和执行的系统，轻量级的调度编排类SaaS产品，蓝鲸标准运维源码对外开放