前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >python操作yaml说明

python操作yaml说明

作者头像
砸漏
发布2020-10-27 10:43:13
3.9K0
发布2020-10-27 10:43:13
举报
文章被收录于专栏:恩蓝脚本

1. 安装PyYAML

pip install PyYAML

2. 加载yaml文件

直接使用yaml.load()函数

demo.yml :

代码语言:javascript
复制
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 :

代码语言:javascript
复制
import yaml
import json

result = yaml.load(open('demo.yml'))
print json.dumps(result, indent=2)

输出 :

代码语言:javascript
复制
{
 "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 :

代码语言:javascript
复制
import yaml

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 :

代码语言:javascript
复制
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解析器和生成器。

安装

简单安装

pip install pyyaml

从源码安装

下载源码包PyYAML-3.13.tar.gz 并解压,在命令行下切换到解压后的包目录内并执行如下命令:

python setup.py install

如果想使用比纯Python版本更快的LibYAML绑定,需要先下载并安装LibYAML,然后在安装PyYAML的时候执行如下命令:

python setup.py –with-libyaml install

为了使用基于LibYAML的解析器和生成器,请使用 CParser 和 CEmitter 类。例如:

代码语言:javascript
复制
from yaml import load, dump
try:
  from yaml import Cloader as Loader, CDumper as Dumper
except ImportError:
  from yaml import Loader, Dumper

# ...

data = load(stream, Loader=Loader)

# ...

output = dump(data, Dumper=Dumper)

请注意,基于纯Python和基于LibYAML的YAML解析器和生成器之间有一些细微但并不真正重要的区别。

最常被问到的问题

为什么如下所示的YAML文档在反序列化后再序列化,得到的YAML文档的格式与原来不一样?

代码语言:javascript
复制
import yaml
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 模块:

import yaml

加载YAML

警告:调用 yaml.load 处理从不可信任的源接收的数据可能存在风险。yaml.load 与 pickle.load 的功能一样强大,可以调用所有Python函数。

yaml.load 函数的作用是用来将YAML文档转化成Python对象。如下所示:

代码语言:javascript
复制
    yaml.load("""
... - Hesperiidae
... - Papilionidae
... - Apatelodidae
... - Epiplemidae
... """)
['Hesperiidae', 'Papilionidae', 'Apatelodidae', 'Epiplemidae']

yaml.load 函数可以接受一个表示YAML文档的字节字符串、Unicode字符串、打开的二进制文件对象或者打开的文本文件对象作为参数。若参数为字节字符串或文件,那么它们必须使用 utf-8 、utf-16 或者 utf-16-le 编码。yaml.load 会检查字节字符串或者文件对象的BOM(byte order mark)并依此来确定它们的编码格式。如果没有发现 BOM ,那么会假定他们使用 utf-8 格式的编码。

yaml.load 方法的返回值为一个Python对象,如下所示:

代码语言:javascript
复制
    yaml.load("'hello': ''")
{'hello': '\uf8ff'}
    with open('document.yaml', 'w') as f:
...   f.writelines('- Python\n- Ruby\n- Java')
... 
    stream = open('document.yaml')
    yaml.load(stream)
['Python', 'Ruby', 'Java']

如果字符串或者文件中包含多个YAML文档,那么可以使用 yaml.load_all 函数将它们全部反序列化,得到的是一个包含所有反序列化后的YAML文档的生成器对象:

代码语言:javascript
复制
    documents = """
... name: bob
... age: 18
... ---
... name: alex
... age: 20
... ---
... name: jason
... age: 16
... """
    datas = yaml.load_all(documents)
    datas
<generator object load_all at 0x105682228 
    for data in datas:
...   print(data)
... 
{'name': 'bob', 'age': 18}
{'name': 'alex', 'age': 20}
{'name': 'jason', 'age': 16}

PyYAML允许用户构造任何类型的Python对象,如下所示:

代码语言:javascript
复制
    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 来进行构建,如下所示:

代码语言:javascript
复制
    class Person:
...   def __init__(self, name, age, gender):
...     self.name = name
...     self.age = age
...     self.gender = gender
...   def __repr__(self):
...     return f"{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文档。

代码语言:javascript
复制
    import yaml
    emp_info = { 'name': 'Lex',
... 'department': 'SQA',
... 'salary': 8000,
... 'annual leave entitlement': [5, 10]
... }
    print(yaml.dump(emp_info))
annual leave entitlement: [5, 10]
department: SQA
name: Lex
salary: 8000

yaml.dump 可以接受第二个可选参数,用于写入生成的YAML文本,这个参数的值可以是打开的文本或者二进制文件对象。如果不提供这个可选参数,则直接返回生成的YAML文档。

代码语言:javascript
复制
    with open('document.yaml', 'w') as f:
...   yaml.dump(emp_info, f)
... 
    import os
    os.system('cat document.yaml')
annual leave entitlement: [5, 10]
department: SQA
name: Lex
salary: 8000
0

如果要将多个Python对象序列化到一个YAML流中,可以使用 yaml.dump_all 函数。该函数接受一个Python的列表或者生成器对象作为第一个参数,表示要序列化的多个Python对象。

代码语言:javascript
复制
    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类的实例,如下所示:

代码语言:javascript
复制
    class Person:
...   def __init__(self, name, age, gender):
...     self.name = name
...     self.age = age
...     self.gender = gender
...   def __repr__(self):
...     return f"{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,表示不指定标签指令。可以设置为一个包含标签的字典,字典中的键值对对应各个不同的标签名和值。

代码语言:javascript
复制
    data = {'code': 200, 'status': 'success', 'message': [10, True, "Got it"]}
    print(yaml.dump(data, version=(1, 2))) # 设置YAML版本
%YAML 1.2
---
code: 200
message: [10, true, Got it]
status: success

    print(yaml.dump(data, version=(1, 2), tags={'!name!': 'test'})) # 设置标签指令
%YAML 1.2
%TAG !name! test
---
code: 200
message: [10, true, Got it]
status: success

    print(yaml.dump(data, # 设置使用块样式
...         version=(1, 2),
...         tags={'!name!': 'test'},
...         default_flow_style=False))
%YAML 1.2
%TAG !name! test
---
code: 200
message:
- 10
- true
- Got it
status: success

    print(yaml.dump(data, # 设置标量使用单引号包裹
...         version=(1, 2),
...         tags={'!name!': 'test'},
...         default_flow_style=False,
...         default_style="'"))
%YAML 1.2
%TAG !name! test
---
'code': !!int '200'
'message':
- !!int '10'
- !!bool 'true'
- 'Got it'
'status': 'success'

    print(yaml.dump(data, # 设置标量使用双引号包裹 
...         version=(1, 2),
...         tags={'!name!': 'test'},
...         default_flow_style=False,
...         default_style='"'))
%YAML 1.2
%TAG !name! test
---
"code": !!int "200"
"message":
- !!int "10"
- !!bool "true"
- "Got it"
"status": "success"

    print(yaml.dump(data, # 设置YAML文档包含显式的指令结束标记和文档结束标记
...         explicit_start=True,
...         explicit_end=True))
---
code: 200
message: [10, true, Got it]
status: success
...

    print(yaml.dump(data, canonical=True)) # 设置文档使用规范形式
---
!!map {
 ? !!str "code"
 : !!int "200",
 ? !!str "message"
 : !!seq [
  !!int "10",
  !!bool "true",
  !!str "Got it",
 ],
 ? !!str "status"
 : !!str "success",
}

    print(yaml.dump(data, encoding='utf-8')) # 将YAML流使用utf-8格式进行编码
b'code: 200\nmessage: [10, true, Got it]\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 的子类,如下所示:

代码语言:javascript
复制
    class Person(yaml.YAMLObject):
...   yaml_tag = '!Person'
...   def __init__(self, name, age, gender):
...     self.name = name
...     self.age = age
...     self.gender = gender
...   def __repr__(self):
...     return f"{self.__class__.__name__}(name={self.name!r}, age={self.age!r}, gender={self.gender!r})"
... 

如上的定义已经足够自动化反序列化和序列化 Person 对象:

代码语言:javascript
复制
    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。如下所示:

代码语言:javascript
复制
    class Dice(tuple):
...   def __new__(cls, a, b):
...     return tuple.__new__(cls, [a, b])
...   def __repr__(self):
...     return 'Dice(%s, %s)' % self
... 
    print(Dice(3, 6))
Dice(3, 6)

默认的 Dice 对象的表示看起来不太美观:

代码语言:javascript
复制
    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,然后注册它,如下所示:

代码语言:javascript
复制
   def dice_representer(dumper, data):
...   return dumper.represent_scalar('!dice', '%sd%s' % data)
... 
    yaml.add_representer(Dice, dice_representer)

现在,序列化一个 Dice 对象的实例后的输入就与期望的一样了:

代码语言:javascript
复制
    yaml.add_representer(Dice, dice_representer)
    print(yaml.dump({'gold': Dice(10, 6)}))
{gold: !dice '10d6'}

下面,我们再来实现一个将使用 !dice 标签标记的标量节点转化为 Dice 对象的 constructor 并注册它:

代码语言:javascript
复制
    def dice_constructor(loader, node):
...   value = loader.construct_scalar(node)
...   a, b = map(int, value.split('d'))
...   return Dice(a, b)
... 
    yaml.add_constructor('!dice', dice_constructor)

然后,你就可以加载一个 Dice 对象了:

代码语言:javascript
复制
    text = 'initial hit points: !dice 8d4'
    print(yaml.load(text))
{'initial hit points': Dice(8, 4)}

如果你不想在任何地方都指定 !dice 标签,那么可以使用 add_implicit_resolver 函数告诉PyYAML所有未标记的形如 XdY 的普通标量具有显式标签 !dice,如下所示:

代码语言:javascript
复制
    import re
    pattern = re.compile(r'^\d+d\d+$')
    yaml.add_implicit_resolver('!dice', pattern)

现在,在定义 Dice 对象的时候可以不使用标签了,如下所示:

代码语言:javascript
复制
    print(yaml.dump({'treasure': Dice(10, 20)}))
{treasure: 10d20}

    print(yaml.load('damage: 5d10'))
{'damage': Dice(5, 10)}

当将一个对象标记为安全的时候,在反序列化这样的对象时只能使用 safe_load 或 safe_load_all 方法,否则会报错,如下所示:

代码语言:javascript
复制
    class Person(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):
...     return f"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 (most recent call last):
 ...
yaml.constructor.ConstructorError: could not determine a constructor for the tag '!Person'
 in "<unicode string ", line 2, column 1:
  !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++ – Cold Fusion

块序列

在块内容中,使用破折号(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

块序列中可以嵌套在块映射之中,在这种情况下,块序列不需要缩进,如下所示:

Programing Languages: – Java – Swift – C++ – Go Operation System: – Unix – Linux – Windows – OSX

上述文档表示如下的Python对象:

代码语言:javascript
复制
{'Programing Languages': ['Java', 'Swift', 'C++', 'Go'],
 'Operation System': ['Unix', 'Linux', 'Windows']}

块映射

块内容中,使用冒号 : 后跟一个空格来分隔映射中的键和值。

代码语言:javascript
复制
name: bob
age: 28
gender: Male

上述文档表示如下的Python对象:

{‘name’: ‘bob’, ‘age’: 28, ‘gender’: ‘Male’}

复杂的键使用问号 ? 后跟一个空格来表示,如下所示:

代码语言:javascript
复制
? !!python/tuple [0, 0]
: Start
? !!python/tuple [3, 5]
: End

上述文档表示如下的Python 对象:

{(0, 0): ‘Start’, (3, 5): ‘End’}

块映射是可以嵌套的,如下所示:

代码语言:javascript
复制
Employee:
 Job_title: Employee
 Salary: 5000
 Annual Leave: 10
Manager:
 Job_title: Manager
 Salary: 8000
 Annual Leave: 15

上述文档表示如下的Python对象:

{‘Employee’: {‘Job_title’: ‘Employee’, ‘Salary’: 5000, ‘Annual Leave’: 10}, ‘Manager’: {‘ Job_title’: ‘Manager’, ‘Salary’: 8000, ‘Annual Leave’: 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中样式,其中块标量有两种样式:

文字样式(literal style)

折叠样式(folded style)

流标量有三种样式:

普通样式(plain style)

单引号样式(single-quoted style)

双引号样式(double-quoted style)

这五种样式的示例如下:

plain: Hello World single-quoted: ‘所有内容都会原样输出’ double-quoted: “需要用反斜杠转移特殊字符” literal: | 每一行 都会 包含换行符 中间的每一个空行 都会用换行符代替 folded: 除过最后一行的 换行符 会保留 其他行末尾的换行符 都会使用一个空格代替 中间的空行 将会使用一个换行符代替

上述文档表示如下的Python对象:

{‘plain’: ‘Hello World’, ‘single-quoted’: ‘所有内容都会原样输出’, ‘double-quoted’: ‘需要用反斜杠转移特殊字符’, ‘literal’: ‘每一行\n都会\n包含换行符\n中间的每一个空行\n\n都会用换行符代替\n’, ‘folded’: ‘除过最后一行的 换行符 会保留 其他行末尾的换行符 都会使用一个空格代替 中间的空行\n将会使用一个换行符代替\n’}

每种样式都有其特点。普通标量不使用指示符来表示其开始和结束,因此它是最受限制的样式。普通标量自然适用于表示参数和属性的名称

使用单引号标量,可以表示不包含特殊字符的任何值。单引号标量不存在转义,除非是一对相邻的引号 ” 被单引号所替换”。

双引号是最强大的样式,也是惟一可以表示任何标量值的样式。双引号标量内的字符允许转义。使用转义序列 \x* 和 \u*** ,可以表达任何ASCII或Unicode字符。

块标量样式有两种:文字样式和折叠样式。文字样式是最适合于大型文本块(如源代码)的样式。折叠样式类似于文字样式,但是两个相邻的非空行中间的换行符会被替换成一个空格从而变成一行。

别名

使用YAML可以表示任何类图结构的对象。如果希望从文档的不同部分引用相同的对象,则需要使用锚和别名。

其中,锚用 & 表示,别名用 * 表示。下面的例子将会演示锚和别名的使用:

代码语言:javascript
复制
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

标签可以是隐式地,如下所示:

代码语言:javascript
复制
boolen: true
integer: 3
float: 3.14

上述文档表示如下的Python对象:

{‘boolean’: True, ‘integer’: 3, ‘float’: 3.14}

标签也可以是显式的,如下所示:

代码语言:javascript
复制
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

这两个标签的使用方法如下:

代码语言:javascript
复制
!!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说明就是小编分享给大家的全部内容了,希望能给大家一个参考。

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2020-09-11 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
相关产品与服务
文件存储
文件存储(Cloud File Storage,CFS)为您提供安全可靠、可扩展的共享文件存储服务。文件存储可与腾讯云服务器、容器服务、批量计算等服务搭配使用,为多个计算节点提供容量和性能可弹性扩展的高性能共享存储。腾讯云文件存储的管理界面简单、易使用,可实现对现有应用的无缝集成;按实际用量付费,为您节约成本,简化 IT 运维工作。
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档