python操作yaml说明

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

import yaml
import json

result = yaml.load(open('demo.yml'))
print json.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"
 }
}

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)

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

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)

import yaml
document = """
a: 1
b:
 c: 3
 d: 4
"""
print(yaml.dump(yaml.load(document)))

> yaml.load("""
... - Hesperiidae
... - Papilionidae
... - Apatelodidae
... - Epiplemidae
... """)
['Hesperiidae', 'Papilionidae', 'Apatelodidae', 'Epiplemidae']

> 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']

> 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}

> 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}}

> 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')

> 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

> 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

> 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}

> 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}

> 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 {
 "code"
 : !!int "200",
 "message"
 : !!seq [
  !!int "10",
  !!bool "true",
  !!str "Got it",
 ],
 "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: 张学友
外号: [歌神, 乌蝇哥]

> 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})"
... 

> 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}

> 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)

> print(yaml.dump(Dice(3, 6)))
!!python/object/new:__main__.Dice
- !!python/tuple [3, 6]

 def dice_representer(dumper, data):
...   return dumper.represent_scalar('!dice', '%sd%s' % data)
... 
> yaml.add_representer(Dice, dice_representer)

> yaml.add_representer(Dice, dice_representer)
> print(yaml.dump({'gold': Dice(10, 6)}))
{gold: !dice '10d6'}

> 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)

> text = 'initial hit points: !dice 8d4'
> print(yaml.load(text))
{'initial hit points': Dice(8, 4)}

> import re
> pattern = re.compile(r'^\d+d\d+$')
> yaml.add_implicit_resolver('!dice', pattern)

> print(yaml.dump({'treasure': Dice(10, 20)}))
{treasure: 10d20}

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

> 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')

{'Programing Languages': ['Java', 'Swift', 'C++', 'Go'],
 'Operation System': ['Unix', 'Linux', 'Windows']}

name: bob
age: 28
gender: Male

"htmlcode">

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可以表示任何类图结构的对象。如果希望从文档的不同部分引用相同的对象，则需要使用锚和别名。
其中，锚用 & 表示，别名用 * 表示。下面的例子将会演示锚和别名的使用：




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说明就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持。