python操作yaml说明
1.安装PyYAML
pipinstallPyYAML
2.加载yaml文件
直接使用yaml.load()函数
demo.yml:
kind:Deployment apiVersion:apps/v1 metadata: name:podinfo namespace:yaml-demo spec: replicas:1 selector: matchLabels: app:podinfo template: metadata: labels: app:podinfo spec: containers: -name:podinfod image:quay.io/stefanprodan/podinfo:0.3.0 ports: -containerPort:9898
load.py:
importyaml
importjson
result=yaml.load(open('demo.yml'))
printjson.dumps(result,indent=2)
输出:
{
"kind":"Deployment",
"spec":{
"replicas":1,
"template":{
"spec":{
"containers":[
{
"image":"quay.io/stefanprodan/podinfo:0.3.0",
"name":"podinfod",
"ports":[
{
"containerPort":9898
}
]
}
]
},
"metadata":{
"labels":{
"app":"podinfo"
}
}
},
"selector":{
"matchLabels":{
"app":"podinfo"
}
}
},
"apiVersion":"apps/v1",
"metadata":{
"namespace":"yaml-demo",
"name":"podinfo"
}
}
3.持久化dict到yml文件
使用yaml.safe_dump()函数
dump.py:
importyaml
d={
"kind":"Deployment",
"spec":{
"replicas":1,
"template":{
"spec":{
"containers":[
{
"image":"quay.io/stefanprodan/podinfo:0.3.0",
"name":"podinfod",
"ports":[
{
"containerPort":9898
}
]
}
]
},
"metadata":{
"labels":{
"app":"podinfo"
}
}
},
"selector":{
"matchLabels":{
"app":"podinfo"
}
}
},
"apiVersion":"apps/v1",
"metadata":{
"namespace":"yaml-demo",
"name":"podinfo"
}
}
result=yaml.safe_dump(d,encoding='utf-8',allow_unicode=True,default_flow_style=False)
open('demo.yml','w').write(result)
demo.yml:
apiVersion:apps/v1 kind:Deployment metadata: name:podinfo namespace:yaml-demo spec: replicas:1 selector: matchLabels: app:podinfo template: metadata: labels: app:podinfo spec: containers: -image:quay.io/stefanprodan/podinfo:0.3.0 name:podinfod ports: -containerPort:9898
补充知识：Python的PyYAML模块详解
简介
Python的PyYAML模块是Python的YAML解析器和生成器。
安装
简单安装
pipinstallpyyaml
从源码安装
下载源码包PyYAML-3.13.tar.gz并解压，在命令行下切换到解压后的包目录内并执行如下命令：
pythonsetup.pyinstall
如果想使用比纯Python版本更快的LibYAML绑定，需要先下载并安装LibYAML，然后在安装PyYAML的时候执行如下命令：
pythonsetup.py--with-libyamlinstall
为了使用基于LibYAML的解析器和生成器，请使用CParser和CEmitter类。例如：
fromyamlimportload,dump try: fromyamlimportCloaderasLoader,CDumperasDumper exceptImportError: fromyamlimportLoader,Dumper #... data=load(stream,Loader=Loader) #... output=dump(data,Dumper=Dumper)
请注意，基于纯Python和基于LibYAML的YAML解析器和生成器之间有一些细微但并不真正重要的区别。
最常被问到的问题
为什么如下所示的YAML文档在反序列化后再序列化，得到的YAML文档的格式与原来不一样？
importyaml document=""" a:1 b: c:3 d:4 """ print(yaml.dump(yaml.load(document)))
其中，上面代码的输出为：
a:1
b:{c:3,d:4}
关于这个问题，其实，尽管最后得到的YAML文档的样式与原来的文档的样式不一致，但是却是正确的结果。
因为PyYAML默认会根据一个集合中是否有嵌套的集合来决定用哪种格式表示这个集合。如果一个集合中嵌套有其他集合，那么会使用块样式来表示，否则会使用流样式来表示。
如果想要集合总是以块样式表示，可以将dump()方法的default_flow_style参数值设为False，如下所示：
print(yaml.dump(yaml.load(document),default_flow_style=False))
上面代码的输出为：
a:1
b:
c:3
d:4
使用详解
先导入yaml模块：
importyaml
加载YAML
警告：调用yaml.load处理从不可信任的源接收的数据可能存在风险。yaml.load与pickle.load的功能一样强大，可以调用所有Python函数。
yaml.load函数的作用是用来将YAML文档转化成Python对象。如下所示：
>>>yaml.load("""
...-Hesperiidae
...-Papilionidae
...-Apatelodidae
...-Epiplemidae
...""")
['Hesperiidae','Papilionidae','Apatelodidae','Epiplemidae']
yaml.load函数可以接受一个表示YAML文档的字节字符串、Unicode字符串、打开的二进制文件对象或者打开的文本文件对象作为参数。若参数为字节字符串或文件，那么它们必须使用utf-8、utf-16或者utf-16-le编码。yaml.load会检查字节字符串或者文件对象的BOM(byteordermark)并依此来确定它们的编码格式。如果没有发现BOM，那么会假定他们使用utf-8格式的编码。
yaml.load方法的返回值为一个Python对象，如下所示：
>>>yaml.load("'hello':''")
{'hello':'\uf8ff'}
>>>withopen('document.yaml','w')asf:
...f.writelines('-Python\n-Ruby\n-Java')
...
>>>stream=open('document.yaml')
>>>yaml.load(stream)
['Python','Ruby','Java']
如果字符串或者文件中包含多个YAML文档，那么可以使用yaml.load_all函数将它们全部反序列化，得到的是一个包含所有反序列化后的YAML文档的生成器对象：
>>>documents=""" ...name:bob ...age:18 ...--- ...name:alex ...age:20 ...--- ...name:jason ...age:16 ...""" >>>datas=yaml.load_all(documents) >>>datas>>>fordataindatas: ...print(data) ... {'name':'bob','age':18} {'name':'alex','age':20} {'name':'jason','age':16}
PyYAML允许用户构造任何类型的Python对象，如下所示：
>>>document="""
...none:[~,null]
...bool:[true,false,on,off]
...int:55
...float:3.1415926
...list:[Red,Blue,Green,Black]
...dict:{name:bob,age:18}
..."""
>>>yaml.load(document)
{'none':[None,None],'bool':[True,False,True,False],'int':55,'float':3.1415926,'list':['Red','Blue','Green','Black'],'dict':{'name':'bob','age':18}}
即使是Python类的实例，也可以使用标签!!python/object来进行构建，如下所示：
>>>classPerson:
...def__init__(self,name,age,gender):
...self.name=name
...self.age=age
...self.gender=gender
...def__repr__(self):
...returnf"{self.__class__.__name__}(name={self.name!r},age={self.age!r},gender={self.gender!r})"
...
>>>yaml.load("""
...!!python/object:__main__.Person
...name:Bob
...age:18
...gender:Male
...""")
Person(name='Bob',age=18,gender='Male')
注意，如果从不信任的源(例如互联网)接收一个YAML文档并由此构建一个任意的Python对象可能存在一定的风险。而使用yaml.safe_load方法能够将这个行为限制为仅构造简单的Python对象，如整数或者列表。
定义一个继承自yaml.YAMLObject类的子类，然后将这个子类的类属性yaml_loader的值设置为yaml.SafeLoader，这样，这个类的对象就被标记为是安全的，从而可以被yaml.safe_load方法识别。不过有一点需要注意，在反序列化这样的Python对象时，只能使用safe_load和safe_load_all方法。
转储YAML
yaml.dump函数接受一个Python对象并生成一个YAML文档。
>>>importyaml
>>>emp_info={'name':'Lex',
...'department':'SQA',
...'salary':8000,
...'annualleaveentitlement':[5,10]
...}
>>>print(yaml.dump(emp_info))
annualleaveentitlement:[5,10]
department:SQA
name:Lex
salary:8000
yaml.dump可以接受第二个可选参数，用于写入生成的YAML文本，这个参数的值可以是打开的文本或者二进制文件对象。如果不提供这个可选参数，则直接返回生成的YAML文档。
>>>withopen('document.yaml','w')asf:
...yaml.dump(emp_info,f)
...
>>>importos
>>>os.system('catdocument.yaml')
annualleaveentitlement:[5,10]
department:SQA
name:Lex
salary:8000
0
如果要将多个Python对象序列化到一个YAML流中，可以使用yaml.dump_all函数。该函数接受一个Python的列表或者生成器对象作为第一个参数，表示要序列化的多个Python对象。
>>>obj=[{'name':'bob','age':19},{'name':20,'age':23},{'name':'leo','age':25}]
>>>print(yaml.dump_all(obj))
{age:19,name:bob}
---{age:23,name:20}
---{age:25,name:leo}
你甚至可以序列化一个Python类的实例，如下所示：
>>>classPerson:
...def__init__(self,name,age,gender):
...self.name=name
...self.age=age
...self.gender=gender
...def__repr__(self):
...returnf"{self.__class__.__name__}(name={self.name!r},age={self.age!r},gender={self.gender!r})"
...
>>>print(yaml.dump(Person('Lucy',26,'Female')))
!!python/object:__main__.Person{age:26,gender:Female,name:Lucy}
yaml.dump和yaml.dump_all方法还支持多个关键字参数，用来指定生成的YAML流中YAML文档的样式和是否包含其他信息。下面就来详细介绍下每个参数的含义和用法。
stream
指定由于输出YAML流的打开的文件对象。默认值为None，表示作为函数的返回值返回。
default_flow_style
是否默认以流样式显示序列和映射。默认值为None，表示对于不包含嵌套集合的YAML流使用流样式。设置为True时，序列和映射使用块样式。
default_style
默认值为None。表示标量不使用引号包裹。设置为'"'时，表示所有标量均以双引号包裹。设置为"'"时，表示所有标量以单引号包裹。
canonical
是否以规范形式显示YAML文档。默认值为None，表示以其他关键字参数设置的值进行格式化，而不使用规范形式。设置为True时，将以规范形式显示YAML文档中的内容。
indent
表示缩进级别。默认值为None，表示使用默认的缩进级别（两个空格），可以设置为其他整数。
width
表示每行的最大宽度。默认值为None，表示使用默认的宽度80。
allow_unicode
是否允许YAML流中出现unicode字符。默认值为False，会对unicode字符进行转义。设置为True时，YAML文档中将正常显示unicode字符，不会进行转义。
line_break
设置换行符。默认值为None，表示换行符为''，即空。可以设置为\n、\r或\r\n。
encoding
使用指定的编码对YAML流进行编码，输出为字节字符串。默认值为None，表示不进行编码，输出为一般字符串。
explicit_start
每个YAML文档是否包含显式的指令结束标记。默认值为None，表示流中只有一个YAML文档时不包含显式的指令结束标记。设置为True时，YAML流中的所有YAML文档都包含一个显式的指令结束标记。
explicit_end
每个YAML文档是否包含显式的文档结束标记。默认值为None，表示流中的YAML文档不包含显式的文档结束标记。设置为True时，YAML流中的所有YAML文档都包含一个显式的文档结束标记。
version
用于在YAML文档中指定YAML的版本号，默认值为None，表示不在YAML中当中指定版本号。可以设置为一个包含两个元素的元组或者列表，但是第一个元素必须为1，否则会引发异常。当前可用的YAML的版本号为1.0、1.1和1.2。
tags
用于指定YAML文档中要包含的标签。默认值为None，表示不指定标签指令。可以设置为一个包含标签的字典，字典中的键值对对应各个不同的标签名和值。
>>>data={'code':200,'status':'success','message':[10,True,"Gotit"]}
>>>print(yaml.dump(data,version=(1,2)))#设置YAML版本
%YAML1.2
---
code:200
message:[10,true,Gotit]
status:success
>>>print(yaml.dump(data,version=(1,2),tags={'!name!':'test'}))#设置标签指令
%YAML1.2
%TAG!name!test
---
code:200
message:[10,true,Gotit]
status:success
>>>print(yaml.dump(data,#设置使用块样式
...version=(1,2),
...tags={'!name!':'test'},
...default_flow_style=False))
%YAML1.2
%TAG!name!test
---
code:200
message:
-10
-true
-Gotit
status:success
>>>print(yaml.dump(data,#设置标量使用单引号包裹
...version=(1,2),
...tags={'!name!':'test'},
...default_flow_style=False,
...default_style="'"))
%YAML1.2
%TAG!name!test
---
'code':!!int'200'
'message':
-!!int'10'
-!!bool'true'
-'Gotit'
'status':'success'
>>>print(yaml.dump(data,#设置标量使用双引号包裹
...version=(1,2),
...tags={'!name!':'test'},
...default_flow_style=False,
...default_style='"'))
%YAML1.2
%TAG!name!test
---
"code":!!int"200"
"message":
-!!int"10"
-!!bool"true"
-"Gotit"
"status":"success"
>>>print(yaml.dump(data,#设置YAML文档包含显式的指令结束标记和文档结束标记
...explicit_start=True,
...explicit_end=True))
---
code:200
message:[10,true,Gotit]
status:success
...
>>>print(yaml.dump(data,canonical=True))#设置文档使用规范形式
---
!!map{
?!!str"code"
:!!int"200",
?!!str"message"
:!!seq[
!!int"10",
!!bool"true",
!!str"Gotit",
],
?!!str"status"
:!!str"success",
}
>>>print(yaml.dump(data,encoding='utf-8'))#将YAML流使用utf-8格式进行编码
b'code:200\nmessage:[10,true,Gotit]\nstatus:success\n'
>>>user_info={'name':'张学友','age':57,'外号':['歌神','乌蝇哥']}
>>>print(yaml.dump(user_info))#若不设置allow_unicode参数，则unicode字符会转义
age:57
name:"\u5F20\u5B66\u53CB"
"\u5916\u53F7":["\u6B4C\u795E","\u4E4C\u8747\u54E5"]
>>>print(yaml.dump(user_info,allow_unicode=True))#设置允许包含unicode字符
age:57
name:张学友
外号:[歌神,乌蝇哥]
构造、表示和解析
可以定义自己的特定于应用程序的标记。最简单的方法是定义yaml.YAMLObject的子类，如下所示：
>>>classPerson(yaml.YAMLObject):
...yaml_tag='!Person'
...def__init__(self,name,age,gender):
...self.name=name
...self.age=age
...self.gender=gender
...def__repr__(self):
...returnf"{self.__class__.__name__}(name={self.name!r},age={self.age!r},gender={self.gender!r})"
...
如上的定义已经足够自动化反序列化和序列化Person对象：
>>>text="""
...---!Person
...name:Bob
...age:22
...gender:Male
..."""
>>>yaml.load(text)
Person(name='Bob',age=22,gender='Male')
>>>print(yaml.dump(Person('Bob',22,'Male')))
!Person{age:22,gender:Male,name:Bob}
yaml.YAMLObject使用元类魔法注册了一个用来将YAML节点转换为类实例的constructors和用来将YAML节点反序列化为Python类实例的表示器representers。
如果你不想使用元类，你可以使用yaml.add_constructor和yaml.add_representer来注册你的constructors和representers。如下所示：
>>>classDice(tuple): ...def__new__(cls,a,b): ...returntuple.__new__(cls,[a,b]) ...def__repr__(self): ...return'Dice(%s,%s)'%self ... >>>print(Dice(3,6)) Dice(3,6)
默认的Dice对象的表示看起来不太美观：
>>>print(yaml.dump(Dice(3,6))) !!python/object/new:__main__.Dice -!!python/tuple[3,6]
假如你想要一个Dice对象序列化后表示成AdB这样的形式，例如：
print(yaml.dump(Dict(3,6)))#期待输出为：3d6
首先，需要定义一个用来将Dict对象转化成使用!dict标签标记的标量节点的*representers，然后注册它，如下所示：
>>defdice_representer(dumper,data):
...returndumper.represent_scalar('!dice','%sd%s'%data)
...
>>>yaml.add_representer(Dice,dice_representer)
现在，序列化一个Dice对象的实例后的输入就与期望的一样了：
>>>yaml.add_representer(Dice,dice_representer)
>>>print(yaml.dump({'gold':Dice(10,6)}))
{gold:!dice'10d6'}
下面，我们再来实现一个将使用!dice标签标记的标量节点转化为Dice对象的constructor并注册它：
>>>defdice_constructor(loader,node):
...value=loader.construct_scalar(node)
...a,b=map(int,value.split('d'))
...returnDice(a,b)
...
>>>yaml.add_constructor('!dice',dice_constructor)
然后，你就可以加载一个Dice对象了：
>>>text='initialhitpoints:!dice8d4'
>>>print(yaml.load(text))
{'initialhitpoints':Dice(8,4)}
如果你不想在任何地方都指定!dice标签，那么可以使用add_implicit_resolver函数告诉PyYAML所有未标记的形如XdY的普通标量具有显式标签!dice，如下所示：
>>>importre
>>>pattern=re.compile(r'^\d+d\d+$')
>>>yaml.add_implicit_resolver('!dice',pattern)
现在，在定义Dice对象的时候可以不使用标签了，如下所示：
>>>print(yaml.dump({'treasure':Dice(10,20)}))
{treasure:10d20}
>>>print(yaml.load('damage:5d10'))
{'damage':Dice(5,10)}
当将一个对象标记为安全的时候，在反序列化这样的对象时只能使用safe_load或safe_load_all方法，否则会报错，如下所示：
>>>classPerson(yaml.YAMLObject):
...yaml_tag='!Person'
...yaml_loader=yaml.SafeLoader
...def__init(self,name,age,gender):
...self.name=name
...self.age=age
...self.gender=gender
...def__repr__(self):
...returnf"Person(name={self.name!r},age={self.age!r},gender={self.gender!r})"
...
>>>text="""
...!Person
...name:Bob
...age:22
...gender:Male
..."""
>>>yaml.load(text)#不使用safe_load或safe_load_all方法会报错
Traceback(mostrecentcalllast):
...
yaml.constructor.ConstructorError:couldnotdetermineaconstructorforthetag'!Person'
in"",line2,column1:
!Person
^
>>>yaml.safe_load(text)#使用safe_load方法可以正常反序列化
Person(name='Bob',age=22,gender='Male')
YAML语法
这一部分将介绍最常见的YAML结构以及相应的Python对象。
文档
YAML流是零个或多个YAML文档的集合。空的YAML流不包含YAML文档。YAML文档间用文档开始标记---进行分隔。YAML文档可以包含一个可选的文档结束标记...。如果流中只有一个文档，那么可以不使用文档开始标记。包含文档开始标记的文档可以称为显式文档，不包含文档开始标记的文档可以称为隐式文档。
下面是一个隐式文档：
-Multimedia
-Internet
-Education
下面是一个显式文档：
---
-Afterstep
-CTWM
-Oroborus
...
下面是一个包含多个文档的YAML流：
---
-Employee
-Manager
-CEO
-CTO
---
-Student
---
-C
-C##YAML中使用‘#'来表示注释（‘#'前面要有一个空格）
-C++
-ColdFusion
块序列
在块内容中，使用破折号(dash)-后跟一个空格（Space）来表示序列中的项。
下面是一个包含块序列的文档：
-id
-name
-age
上述文档表示的一个如下的Python对象：
['id','name','age']
块序列是可以嵌套的：
-
-Python
-Ruby
-JavaScript
-PHP
-
-Unix
-Linux
-Windows
上述文档表示如下的Python对象：
[['Python','Ruby','JavaScript','PHP'],['Unix','Linux','Windows']]
在嵌套的块序列中，内层的序列可以直接从当前行开始而不必从新的一行开始，如下所示：
--Python
-Ruby
-JavaScript
-PHP
--Unix
-Linux
-Windows
块序列中可以嵌套在块映射之中，在这种情况下，块序列不需要缩进，如下所示：
ProgramingLanguages：
-Java
-Swift
-C++
-Go
OperationSystem：
-Unix
-Linux
-Windows
-OSX
上述文档表示如下的Python对象：
{'ProgramingLanguages':['Java','Swift','C++','Go'],
'OperationSystem':['Unix','Linux','Windows']}
块映射
块内容中，使用冒号:后跟一个空格来分隔映射中的键和值。
name:bob age:28 gender:Male
上述文档表示如下的Python对象：
{'name':'bob','age':28,'gender':'Male'}
复杂的键使用问号?后跟一个空格来表示，如下所示：
?!!python/tuple[0,0] :Start ?!!python/tuple[3,5] :End
上述文档表示如下的Python对象：
{(0,0):'Start',(3,5):'End'}
块映射是可以嵌套的，如下所示：
Employee: Job_title:Employee Salary:5000 AnnualLeave:10 Manager: Job_title:Manager Salary:8000 AnnualLeave:15
上述文档表示如下的Python对象：
{'Employee':{'Job_title':'Employee','Salary':5000,'AnnualLeave':10},
'Manager':{'Job_title':'Manager','Salary':8000,'AnnualLeave':15}}
块映射可以嵌套在块序列中，如下所示：
-name:PyYAML
status:4
license:MIT
language:Python
-name:PySyck
status:5
license:BSD
language:Python
上述文档表示如下的Python对象：
[{'name':'PyYAML','status':4,'license':'MIT','language':'Python'},
{'name':'PySyck','status':5,'license':'BSD','language':'Python'}]
流集合
YAML中流集合的语法与Python中列表和字典结构的语法很像，如下所示：
{str:[15,17],con:[16,16],dex:[17,18],wis:[16,16],int:[10,13],chr:[5,8]}
上述文档表示如下的Python对象：
{'dex':[17,18],'int':[10,13],'chr':[5,8],'wis':[16,16],'str':[15,17],'con':[16,16]}
标量
YAML中的标量共有5中样式，其中块标量有两种样式：
文字样式（literalstyle）
折叠样式（foldedstyle）
流标量有三种样式：
普通样式（plainstyle）
单引号样式（single-quotedstyle）
双引号样式（double-quotedstyle）
这五种样式的示例如下：
plain:HelloWorld
single-quoted:'所有内容都会原样输出'
double-quoted:"需要用反斜杠转移特殊字符"
literal:|
每一行
都会
包含换行符
中间的每一个空行
都会用换行符代替
folded:>
除过最后一行的
换行符
会保留
其他行末尾的换行符
都会使用一个空格代替
中间的空行
将会使用一个换行符代替
上述文档表示如下的Python对象：
{'plain':'HelloWorld',
'single-quoted':'所有内容都会原样输出',
'double-quoted':'需要用反斜杠转移特殊字符',
'literal':'每一行\n都会\n包含换行符\n中间的每一个空行\n\n都会用换行符代替\n',
'folded':'除过最后一行的换行符会保留其他行末尾的换行符都会使用一个空格代替中间的空行\n将会使用一个换行符代替\n'}
每种样式都有其特点。普通标量不使用指示符来表示其开始和结束，因此它是最受限制的样式。普通标量自然适用于表示参数和属性的名称
使用单引号标量，可以表示不包含特殊字符的任何值。单引号标量不存在转义，除非是一对相邻的引号''被单引号所替换”。
双引号是最强大的样式，也是惟一可以表示任何标量值的样式。双引号标量内的字符允许转义。使用转义序列\x*和\u***，可以表达任何ASCII或Unicode字符。
块标量样式有两种：文字样式和折叠样式。文字样式是最适合于大型文本块(如源代码)的样式。折叠样式类似于文字样式，但是两个相邻的非空行中间的换行符会被替换成一个空格从而变成一行。
别名
使用YAML可以表示任何类图结构的对象。如果希望从文档的不同部分引用相同的对象，则需要使用锚和别名。
其中，锚用&表示，别名用*表示。下面的例子将会演示锚和别名的使用：
emp1:&A name:bob age:28 gender:Male emp2:*A
上述文档表示如下的Python对象：
{'emp1':{'name':'bob','age':28,'gender':'Male'},
'emp2':{'name':'bob','age':28,'gender':'Male'}}
PyYAML现在已经支持递归对象，下面的文档表示一个Python的列表，这个列表的元素是这个列表自身。
&A[*A]
标签
标签用来标识节点的数据类型。标准的YAML标签的定义可以参考该文档：
http://yaml.org/type/index.html
标签可以是隐式地，如下所示：
boolen:true integer:3 float:3.14
上述文档表示如下的Python对象：
{'boolean':True,'integer':3,'float':3.14}
标签也可以是显式的，如下所示：
boolean:!!bool"true" integer:!!int"3" float:!!float"3.14"
上述文档表示如下的Python对象：
{'boolean':True,'integer':3,'float':3.14}
没有显式定义标签的普通标量受制于隐式标签解析。隐式标签解析根据一组正则表达式检查标量值，如果其中一个匹配，则为标量分配相应的标记。PyYAML允许应用程序添加自定义隐式标签解析器。
YAML标签和Python3对象
| YAML标签 | Python对象 |
|---|---|
| 标准的YAML标签 | |
| !!null | None |
| !!bool | bool |
| !!int | int |
| !!float | float |
| !!binary | bytes |
| !!timestamp | datetime.datetime |
| !!omap,!!pairs | 元素为一个二元组的list |
| !!set | set |
| !!str | str |
| !!seq | list |
| !!map | dict |
| Python的特殊标签 | |
| !!python/none | None |
| !!python/bool | bool |
| !!python/bytes | bytes |
| !!python/str | str |
| !!python/unicode | str |
| !!python/int | int |
| !!python/long | int |
| !!python/float | float |
| !!python/complex | complex |
| !!python/list | list |
| !!python/tuple | tuple |
| !!python/dict | dict |
| 复杂的Python标签 | |
| !!python/name:module.name | module.name |
| !!python/module:package.module | package.module |
| !!python/object:module.cls | module.cls的实例 |
| !!python/object/new:module.cls | module.cls的实例 |
| !!python/object/apply:module.func | 方法func(...)的返回值 |
字符串转换
在Python3中，str类型的对象将被转变成使用标签!!str标识的标量；bytes类型的对象将被转变成使用标签!!binary标识的标量。为了考虑兼容性，标签!!python/str和!!python/unicode仍然可以使用，被其标识的标量将被转变成str类型的对象。
名称和模块
要表示静态的Python对象，如函数和类，可以使用复杂的标签Python!!python/name。下面的例子演示了如何表示yaml模块中的dump方法：
!!python/name:yaml.dump
类似的，模块可以使用标签!!python/module:
!!python/module.yaml
对象
任何pickleable对象都可以使用标签!!python/object来序列化：
!!python/object:module.Class{attribute:value,...}
为了支持pickle协议，PyYAML提供了两个附加的标签
!!python/object/new:module.Class和!!python/object/apply:module.function
这两个标签的使用方法如下：
!!python/object/new:module.Class
args:[argument,...]
kwds:{key:value,...}
stat:...
listitems:[item,...]
dictitems:[key:value,...]
!!python/object/apply:module.function
args:[argument,...]
kwds:{key:value,...}
state:...
listitems:[item,...]
dictitems:[key:value,...]
以上这篇python操作yaml说明就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持毛票票。