温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
& & &Installation 下载源代码&PyYAML-3.08.tar.gz 并解压缩. 在目录PyYAML-3.08运行 $ python setup.py install
如果想使用LibYAML绑定, （要比纯的python版速度快）需要下载并安装&. 之后通过下列命令安装： $ python setup.py --with-libyaml install
为了使用& 的 parser and emitter, 需要使用classes&CParser and&CEmitter. 例如,
from yaml import load, dump
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)
注： pure Python and&based parsers and emitters 之间有微小的差异。 & & 常见问题： & & &非嵌套collections的字典没有正常dump 例如，为什么
import yaml &document = """
print yaml.dump(yaml.load(document))
得到结果 a: 1
b: {c: 3, d: 4}
(see&,&)? 事实上这事一个正确的输出，它来自嵌套mapping的样式的差异。 默认情况下, PyYAML 选择collection的样式基于它是否具有嵌套的collection。如果它有嵌套的collections，它将会被赋予block样式。否则它将是flow样式。 如果你期望collections总是在block样式中串行，设置dump()的参数&default_flow_style 为 False. 例如,
&&& print yaml.dump(yaml.load(document), default_flow_style=False)
& & Python 3 support 从&3.08 版本开始, PyYAML 和 LibYAML bindings 完全支持 Python 3. 下面是 Python 2 和 Python 3 版本PyYAML API的区别概要. In Python 2:
str 对象被转化成&!!str,&!!python/str 或&!binary 节点，基于是否该对象的字符串类型是 ASCII, UTF-8 或 binary. unicode 对象被转化成&!!python/unicode 或&!!str 节点，基于对象是否是一个ASCII字符串 yaml.dump(data) 产生一个 UTF-8 encoded&str 对象的文档. yaml.dump(data, encoding=('utf-8'|'utf-16-be'|'utf-16-le')) 产生一个指定编码的&str 对象。 yaml.dump(data, encoding=None) 产生一个&unicode 对象.
In Python 3:
str 对象被转化成&!!str nodes. bytes 对象被转化成&!!binary nodes. 为了兼容&!!python/str 和&!python/unicode 标签仍然被支持，相应的节点被转化成&str 对象. yaml.dump(data) 产生一个&str 对象的文档. yaml.dump(data, encoding=('utf-8'|'utf-16-be'|'utf-16-le')) 产生一个制定编码的&bytes 对象
& & 教程 首先引入&yaml package.
&&& import yaml
& & &装载 YAML 注意: 从未获认证的数据源中调用&yaml.load 有安全隐患。&yaml.load 有和 pickle.load 一样强的能力，也就是能够调用任何Python 函数. 检查&yaml.safe_load 函数，如果你不能确认. 函数&yaml.load 将一个 YAML 文档转化成一个 Python 对象.
&&& yaml.load("""
... - Hesperiidae
... - Papilionidae
... - Apatelodidae
... - Epiplemidae
['Hesperiidae', 'Papilionidae', 'Apatelodidae', 'Epiplemidae']
yaml.load 接收 一个 byte 字符串, 一个 Unicode 字符串, 一个 open binary file 对象, 或一个 open text file 对象作为输入. byte 字符串或 file 必须是以下方式编码的：utf-8,&utf-16-be 或者&utf-16-le.&yaml.load 通过检查 字符串或者file 开端的BOM (byte order mark)序列来验证字符编码。 如果找不到&BOM 信息, 默认使用&utf-8 编码。 yaml.load 返回一个 Python 对象.
&&& yaml.load(u"""
... hello: Привет!
# In Python 3, do not use the 'u' prefix
{'hello': u'\П\р\и\в\е\т!'}
&&& stream = file('document.yaml', 'r')
# 'document.yaml' contains a single YAML document.
&&& yaml.load(stream) [...]
# A Python object corresponding to the document.
如果一个字符串或者文件包含多个文档，可以使用函数&yaml.load_all 来装载所有的文档。
&&& documents = """
... name: The Set of Gauntlets 'Pauraegen'
... description: &
A set of handgear with sparks that crackle
across its knuckleguards.
... name: The Set of Gauntlets 'Paurnen'
... description: &
A set of gauntlets that gives off a foul,
acrid odour yet remains untarnished.
... name: The Set of Gauntlets 'Paurnimmen'
... description: &
A set of handgear, freezing with unnatural cold.
&&& for data in yaml.load_all(documents):
print data
{'description': 'A set of handgear with sparks that crackle across its knuckleguards.\n',
'name': "The Set of Gauntlets 'Pauraegen'"}
{'description': 'A set of gauntlets that gives off a foul, acrid odour yet remains untarnished.\n',
'name': "The Set of Gauntlets 'Paurnen'"}
{'description': 'A set of handgear, freezing with unnatural cold.\n',
'name': "The Set of Gauntlets 'Paurnimmen'"}
PyYAML 允许你构建任何类型的 Python 对象。
&&& yaml.load("""
... none: [~, null]
... bool: [true, false, on, off]
... int: 42
... float: 3.14159
... list: [LITE, RES_ACID, SUS_DEXT]
... dict: {hp: 13, sp: 5}
{'none': [None, None], 'int': 42, 'float': 3.9999,
'list': ['LITE', 'RES_ACID', 'SUS_DEXT'], 'dict': {'hp': 13, 'sp': 5},
'bool': [True, False, True, False]}
甚至Python 类的实例也能通过使用!!python/object 标签来构建.
&&& class Hero:
def __init__(self, name, hp, sp):
self.name = name
self.hp = hp
self.sp = sp
def __repr__(self):
return "%s(name=%r, hp=%r, sp=%r)" % (
self.__class__.__name__, self.name, self.hp, self.sp)
&&& yaml.load("""
... !!python/object:__main__.Hero
... name: Welthyr Syxgon
... hp: 1200
Hero(name='Welthyr Syxgon', hp=1200, sp=0)
注意：如果是从网络上未认证的源接收数据并有能力构建任意的Python对象。函数&yaml.safe_load 限制构建简单Python对象如 integers 或 lists. 可以将一个 python 对象标记为安全的，然后就可以通过&yaml.safe_load 识别了。 标记的方式是, 将其派生自&yaml.YAMLObject (将在&Constructors, representers, resolvers 中介绍) 并明确设置它的类属性&yaml_loader 为&yaml.SafeLoader. & & &输出 YAML yaml.dump 函数接受Python对象，并产生一个YAML文档。
&&& print yaml.dump({'name': 'Silenthand Olleander', 'race': 'Human',
... 'traits': ['ONE_HAND', 'ONE_EYE']})
name: Silenthand Olleander
race: Human
traits: [ONE_HAND, ONE_EYE]
yaml.dump 可以接受第二个可选参数，该参数必须是一个open text或者binary 文件。这样，YAML文档被写入文件，否则函数将返回文档。
&&& stream = file('document.yaml', 'w')
&&& yaml.dump(data, stream)
# Write a YAML representation of data to 'document.yaml'.
&&& print yaml.dump(data)
# Output the document to the screen.
如果需要输出多个YAML文档到同一个流，可以使用函数yaml.dump_all.&yaml.dump_all 接受一个 list 或者 一个 generator 然后将Python对象串行化到YAML问当中。第二个可选参数同样是输出到文件。
&&& print yaml.dump([1,2,3], explicit_start=True)
--- [1, 2, 3]
&&& print yaml.dump_all([1,2,3], explicit_start=True)
同样可以导出Python类的实例.
&&& class Hero:
def __init__(self, name, hp, sp):
self.name = name
self.hp = hp
self.sp = sp
def __repr__(self):
return "%s(name=%r, hp=%r, sp=%r)" % (
self.__class__.__name__, self.name, self.hp, self.sp)
&&& print yaml.dump(Hero("Galain Ysseleg", hp=-3, sp=2))
!!python/object:__main__.Hero {hp: -3, name: Galain Ysseleg, sp: 2}
yaml.dump 支持一系列标识emitter格式信息的关键词数值参数。例如，可以设定缩进和宽度偏好，为scalars和collections使用规范的YAML格式或者偏好样式。
&&& print yaml.dump(range(50)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49]
&&& print yaml.dump(range(50), width=50, indent=4)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47, 48, 49]
&&& print yaml.dump(range(5), canonical=True)
--- !!seq [
!!int "0",
!!int "1",
!!int "2",
!!int "3",
!!int "4", ]
&&& print yaml.dump(range(5), default_flow_style=False)
&&& print yaml.dump(range(5), default_flow_style=True, default_style='"')
[!!int "0", !!int "1", !!int "2", !!int "3", !!int "4"]
& & &Constructors, representers, resolvers 可以自定义应用描述标签。最简单的做法是继承自&yaml.YAMLObject: &&& class Monster(yaml.YAMLObject):
yaml_tag = u'!Monster'
def __init__(self, name, hp, ac, attacks):
self.name = name
self.hp = hp
self.ac = ac
self.attacks = attacks
def __repr__(self):
return "%s(name=%r, hp=%r, ac=%r, attacks=%r)" % (
self.__class__.__name__, self.name, self.hp, self.ac, self.attacks)
上述的定义足以自动装载和导出Monster对象。
&&& yaml.load("""
... --- !Monster
... name: Cave spider
... hp: [2,6]
... ac: 16
... attacks: [BITE, HURT]
Monster(name='Cave spider', hp=[2, 6], ac=16, attacks=['BITE', 'HURT'])
&&& print yaml.dump(Monster(
name='Cave lizard', hp=[3,6], ac=16, attacks=['BITE','HURT']))
attacks: [BITE, HURT]
hp: [3, 6]
name: Cave lizard
yaml.YAMLObject 使用 metaclass 来注册一个 constructor, 它实现了从一个YAML节点到一个类实例的转化；以及一个 representer, 实现从一个类实例串行化到一个YAML节点。 如果不想使用 metaclasses, 可以使用函数&yaml.add_constructor and&yaml.add_representer来注册constructors 和 representers。&例如为Dict类添加constructor 和 &representer&:
&&& 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)
默认的Dict对象表达方式效果不好：
&&& print yaml.dump(Dice(3,6))
!!python/object/new:__main__.Dice -
!!python/tuple [3, 6]
假设你期望使用Dice对象在YAML中表示为AdB&:
&&& print yaml.dump(Dice(3,6))
首先定义一个&representer 将dice对象转化成一个标识!dice的scalar节点然后进行注册。
&&& def dice_representer(dumper, data):
return dumper.represent_scalar(u'!dice', u'%sd%s' % data)
&&& yaml.add_representer(Dice, dice_representer)
现在可以导出Dice对象的实例:
&&& print yaml.dump({'gold': Dice(10,6)})
{gold: !dice '10d6'}
接下来添加构建Dice对象的代码：
&&& def dice_constructor(loader, node):
value = loader.construct_scalar(node)
a, b = map(int, value.split('d'))
return Dice(a, b)
&&& yaml.add_constructor(u'!dice', dice_constructor)
然后可以导入Dice对象了：
&&& print yaml.load("""
... initial hit points: !dice 8d4
{'initial hit points': Dice(8,4)}
如果想省略无处不在的标签&!dice. 这里还有一种可以告诉PyYAML将所有未标识的标量XdY隐式识别为Dice对象的方式。那就是使用&add_implicit_resolver:
&&& import re
&&& pattern = re.compile(r'^\d+d\d+$')
&&& yaml.add_implicit_resolver(u'!dice', pattern)
然后就可以省略标签来定义Dice对象了:
&&& print yaml.dump({'treasure': Dice(10,20)})
{treasure: 10d20}
&&& print yaml.load("""
... damage: 5d10
{'damage': Dice(5,10)}
& & &YAML 语法 YAML 语法的良好描述是：&. 你也可以通过& 来了解. 注 该书是针对Ruby实现和旧的YAML 1.0的语法来编写的。 这里我们给出常用的YAML文档和对应的Python对象。 文档（Documents） YAML 流（stream）是0个或者多个文档的集合. 一个空的流不包含文档。文档通过&--- 来区分. 文档也可以用... 来结尾. 一个单一文档可以通过&--- 显式标记也可不标记。 隐式标记的文档: - Multimedia
- Internet
- Education
显式标记的文档: ---
- Afterstep
- Oroborus
同一流内多个文档： ---
- Assembly
# Note that comments are denoted with ' #' (space and #).
- Cold Fusion
& & &块序列（Block sequences） 在块的内容（context）里，序列记录用&- (dash and space)来标注: # YAML
- The Dagger 'Narthanc'
- The Dagger 'Nimthanc'
- The Dagger 'Dethanc'
# Python ["The Dagger 'Narthanc'", "The Dagger 'Nimthanc'", "The Dagger 'Dethanc'"]
块序列可以嵌套: # YAML
- GNU Hurd
# Python [['HTML', 'LaTeX', 'SGML', 'VRML', 'XML', 'YAML'], ['BSD', 'GNU Hurd', 'Linux']]
多层嵌套的例子，可以不必从新行开始 连续两个dash: # YAML
# Python [1.1, [2.1, 2.2], [[3.1, 3.2, 3.3]]]
块序列可以被嵌套成一个块映射（mapping），注 在这一情况下，缩进sequence不是必须的。 # YAML
left hand:
- Ring of Teleportation
- Ring of Speed
right hand:
- Ring of Resist Fire
- Ring of Resist Cold
- Ring of Resist Poison
# Python {'right hand': ['Ring of Resist Fire', 'Ring of Resist Cold', 'Ring of Resist Poison'],
'left hand': ['Ring of Teleportation', 'Ring of Speed']}
& & &块映射（Block mappings） 在块的内容中，键和映射值以&: 进行区分(colon and space): # YAML
base armor class: 0
base damage: [4,4]
plus to-hit: 12
plus to-dam: 16
plus to-ac: 0
# Python {'plus to-hit': 12, 'base damage': [4, 4], 'base armor class': 0, 'plus to-ac': 0, 'plus to-dam': 16}
复合键以&? 标注(question mark and space): # YAML
? !!python/tuple [0,0] : The Hero
? !!python/tuple [0,1] : Treasure
? !!python/tuple [1,0] : Treasure
? !!python/tuple [1,1] : The Dragon
# Python {(0, 1): 'Treasure', (1, 0): 'Treasure', (0, 0): 'The Hero', (1, 1): 'The Dragon'}
块映射可以嵌套： # YAML
# Python {'hero': {'hp': 34, 'sp': 8, 'level': 4}, 'orc': {'hp': 12, 'sp': 0, 'level': 2}}
块映射可以被嵌套在块序列中: # YAML
- name: PyYAML
license: MIT
language: Python
- name: PySyck
license: BSD
language: Python
# Python [{'status': 4, 'language': 'Python', 'name': 'PyYAML', 'license': 'MIT'},
{'status': 5, 'license': 'BSD', 'name': 'PySyck', 'language': 'Python'}]
& & &流集合（Flow collections） YAML中流集合的语法近似于Python中的list和dictionary构造器: # YAML { 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]}
& & &标量（Scalars） YAML中有5种类型的标量:普通文本（plain）, 单引号标注（single-quoted）, 双引号标注（double-quoted）, 斜体（literal）, 以及闭合标注（folded）: # YAML
plain: Scroll of Remove Curse
single-quoted: 'EASY_KNOW'
double-quoted: "?"
literal: |
# Borrowed from http://www.kersbergen.com/flump/religion.html
)_____________\\
/_ /=== == === === =\ _\_
( /)=== == === === == Y
`-------------------(
It removes all ordinary curses from all equipped items.
Heavy or permanent curses are unaffected.
# Python {'plain': 'Scroll of Remove Curse',
'literal':
)_____________\\\\
' /_ /=== == === === =\\ _\\_\n'
'( /)=== == === === == Y
' `-------------------(
\\___/\n',
'single-quoted': 'EASY_KNOW',
'double-quoted': '?',
'folded': 'It removes all ordinary curses from all equipped items. Heavy or permanent curses are unaffected.\n'}
每个样式都有自己的行为。一个plain标量不使用标识符来描述起始位置，所以是最严格的样式。属性和参数名字是它的典型应用。 single-quoted 的标量, 可以表示不包含特殊字符的任意值。重复的单引号''被代替为一个单引号'，除此之外没有别的特殊替换（escaping）。 Double-quoted 是功能最强的样式，也是唯一能表示所有标量值的样式。它允许escaping，使用&\x** 和\u****, 可以表示任意的ASCII 或 Unicode 字符. 有两种块标量样式：&literal 和&folded. literal 最适合大块 的文本比如源代码。后者跟literal相似，但是连续的非空行通过空格字符来连接。 & & &别名（Aliases） 注： PyYAML 目前为止没有支持递归对象. 使用YAML你可以表示任意图形类结构的对象。如果需要在文档中引用其余位置的对象，可以使用anchors 和 aliases. 锚(Anchors)用标识符&& 表示，别名（aliases）用 * 标识符表示。 left hand: &A
name: The Bastard Sword of Eowyn
weight: 30
right hand: *A
表示一个双手都持有重剑的英雄。 PyYAML 到这里完全可以支持递归对象了 &A [ *A ]
产生一个包含指向自身的引用的 list 对象。
标签用于表示YAML节点的类型。参考标准的YAML标签定义&. 标签可以是隐式的： boolean: true
integer: 3
float: 3.14
{'boolean': True, 'integer': 3, 'float': 3.14}
也可以是显式的: boolean: !!bool "true"
integer: !!int "3"
float: !!float "3.14"
{'boolean': True, 'integer': 3, 'float': 3.14}
没有显式标签定义的Plain 标量会得到隐式标签resolve的处理。标量的值被一系列正则表达式检测。如果发现匹配，则相应的标签被赋予该标量。PyYAML允许应用添加自定义的标签resolvers。
下表描述了不同标签的节点转化成为不同的Python对象。
YAML tag Python type
Standard YAML tags
!!null None
!!bool bool
!!int int or&long (int in Python 3)
!!float float
!!binary str (bytes in Python 3)
!!timestamp datetime.datetime
!!omap,&!!pairs list of pairs
!!str str or&unicode (str in Python 3)
!!seq list
!!map dict
Python-specific tags
!!python/none None
!!python/bool bool
!!python/bytes (bytes in Python 3)
!!python/str str (str in Python 3)
!!python/unicode unicode (str in Python 3)
!!python/int int
!!python/long long (int in Python 3)
!!python/float float
!!python/complex complex
!!python/list list
!!python/tuple tuple
!!python/dict dict
Complex Python tags
!!python/name:module.name module.name
!!python/module:package.module package.module
!!python/object:module.cls module.cls instance
!!python/object/new:module.cls module.cls instance
!!python/object/apply:module.f value of&f(...)
& & &字符串转化（String conversion） (针对 Python 2) 有四种标签被转化成&str 和&unicode 值:&!!str,&!!binary,&!!python/str, 以及&!!python/unicode. !!str 标注的标量如果它的值是&ASCII 将被转化为&str 对象，否则被转化成&unicode.&!!binary 标注的标量被转化成&str 对象，它的值被按照&base64 encoding来解码.&!!python/str 标量以&utf-8 编码被转化成&str 对象.&!!python/unicode 标量被转化成&unicode 对象. 反过来说, 一个&str 对象是从以下节点转化而来的：
!!str 的值是&ASCII 的标量。 !!python/str 的值是正确的&utf-8 序列的标量. !!binary 标量.
一个 unicode 对象来自以下节点
!!python/unicode 的值为s&ASCII 的标量。 !!str 标量.
& & &String conversion (Python 3 only) 在Python 3中str对象被转化成&!!str 标量，&bytes 对象转化&!!binary 标量. 为了兼容性, 标签&!!python/str 和&!!python/unicode依旧被支持，并转化成str对象。 命名和模块（Names and modules）
为了表示静态的Python对象如（函数或类），需要用到复杂标签&!!python/name. 例如函数&yaml.dump 可以被表示为 !!python/name:yaml.dump
相似的表示模块使用标签&!python/module: !!python/module:yaml
& & &对象（Objects） 任何 pickleable 的对象都可以使用&!!python/object 标签来进行串行化: !!python/object:module.Class { attribute: value, ... }
为了支持pickle协议，标签&!!python/object 提供了两种额外的形式: !!python/object/new:module.Class
args: [argument, ...]
kwds: {key: value, ...}
state: ...
listitems: [item, ...]
dictitems: [key: value, ...]
!!python/object/apply:module.function
args: [argument, ...]
kwds: {key: value, ...}
state: ...
listitems: [item, ...]
dictitems: [key: value, ...]
只有&args 域非空的情况下，以上的记录才能被简写: !!python/object/new:module.Class [argument, ...]
!!python/object/apply:module.function [argument, ...]
& & &引用（Reference） 注意: 不保证API 的稳定性''' & & &yaml程序包（The yaml package）
scan(stream, Loader=Loader)
scan(stream) 扫描给定的流输出token序列.
parse(stream, Loader=Loader)
emit(events, stream=None, Dumper=Dumper,
canonical=None,
indent=None,
width=None,
allow_unicode=None,
line_break=None)
parse(stream) 解析给定流输出解析事件序列. emit(events, stream=None) 串行化给定的解析事件，将它们写入到流中。如果流是None，返回产生流.
compose(stream, Loader=Loader)
compose_all(stream, Loader=Loader)
serialize(node, stream=None, Dumper=Dumper,
encoding='utf-8', # encoding=None (Python 3)
explicit_start=None,
explicit_end=None,
version=None,
tags=None,
canonical=None,
indent=None,
width=None,
allow_unicode=None,
line_break=None)
serialize_all(nodes, stream=None, Dumper=Dumper, ...)
compose(stream) 解析给定流，返回流中第一个文档的图形表示的root引用。如果流中没有文档，则返回None。 compose_all(stream) 解析给定流，返回流中文档对应的图形表示的序列. serialize(node, stream=None) 串行化给定的图形表示到流中。如果流是None，返回产生流。 serialize_all(node, stream=None) 串行化给定图形表示序列到给定的流中。如果流是None，返回产生流.
load(stream, Loader=Loader)
load_all(stream, Loader=Loader)
safe_load(stream)
safe_load_all(stream)
dump(data, stream=None, Dumper=Dumper,
default_style=None,
default_flow_style=None,
encoding='utf-8', # encoding=None (Python 3)
explicit_start=None,
explicit_end=None,
version=None,
tags=None,
canonical=None,
indent=None,
width=None,
allow_unicode=None,
line_break=None)
dump_all(data, stream=None, Dumper=Dumper, ...)
safe_dump(data, stream=None, ...)
safe_dump_all(data, stream=None, ...)
load(stream) 解析给定流，返回由流中第一个文档构造的一个Python对象。如果流中没有对象，则返回None。 load_all(stream) 解析给定流，返回流中文档对应的Python对象序列。 safe_load(stream) 解析给定流，返回流中第一个文档构造的Python对象。如果流中没有文档返回None.&safe_load 只识别标准的YAML标签，无法构造任意的Python对象。 一个对象可以被标为可信任，然后被&yaml.safe_load 识别. 做法是，派生自&yaml.YAMLObject (详见之前章节&Constructors, representers, resolvers) 并且显式的设定它的类属性&yaml_loader 到&yaml.SafeLoader. safe_load_all(stream) 解析给定的流并返回流中文档对应Python对象序列。safe_load_all 只识别所有的标准YAML标签，不能构造任意的Python对象。 dump(data, stream=None) 序列化给定的Python对象到流中。如果流是None，返回产生流。 dump_all(data, stream=None) 序列化给定Python对象序列到流中，返回流中文档对应的Python对象序列。如果流是None，返回产生流。每个对象被表示成一个YAML文档。 safe_dump(data, stream=None) 序列化给定的Python对象到流中，如果流是None，返回产生流。safe_dump 只输出标准的YAML标签，不能表示任意Python对象。 safe_dump_all(data, stream=None) 序列化给定的Python对象序列到流中，如果流是None，返回产生流。safe_dump 只输出标准的YAML标签，不能表示任意Python对象。每个对象被表示成一个YAML文档。&safe_dump_all 只输出标准的YAML标签，不能表示任意Python对象。
def constructor(loader, node):
return data
def multi_constructor(loader, tag_suffix, node):
return data
add_constructor(tag, constructor, Loader=Loader)
add_multi_constructor(tag_prefix, multi_constructor, Loader=Loader)
add_constructor(tag, constructor) 允许为给定的标签指定一个构造器. 构造器是一个能够把YAML表示图的一个节点转化成一个原生Python对象的函数。一个构造器接收装载器的实例，YAML节点，并返回一个Python对象。 add_multi_constructor(tag_prefix, multi_constructor) 允许为给定的标签前缀指定一个多元构造器。一个多元构造器是一个函数，它能将YAML表示图的节点转化成为原生Python对象。多元构造器接受一个装载器的实例，节点标签的后缀，节点，返回Python对象。
def representer(dumper, data):
return node
def multi_representer(dumper, data):
return node
add_representer(data_type, representer, Dumper=Dumper)
add_multi_representer(base_data_type, multi_representer, Dumper=Dumper)
add_representer(data_type, representer) 允许为给定数据类型的Python对象指定一个表示器。一个表示器是这样一个函数，它能将Python对象转化成YAML表示图的一个节点。表示器接受导出器的实例和一个对象，并返回一个节点。 add_multi_representer(base_data_type, multi_representer) 允许为给定的base_data_type以及它的子类的的Python对象指定一个多元表示器。一个多元表示器是一个函数，能将一个Python对象转化YAML表示图的节点。多元表示器接受导出器的实例和一个对象，并返回一个节点。
add_implicit_resolver(tag, regexp, first, Loader=Loader, Dumper=Dumper)
add_path_resolver(tag, path, kind, Loader=Loader, Dumper=Dumper)
add_implicit_resolver(tag, regexp, first) 添加一个隐式的针对Plain标量的resolver。如果标量匹配给定的regexp，它将会被赋予标签。first参数是可能的初始字符（或None）的列表。 add_path_resolver(tag, path, kind) 添加基于path的隐式标签resolver。path是表示图中形成到一个节点路径的keys的列表。Path的元素可以是字符串的值，整数，或者None。节点的类型可以是&str,&list,&dict, or&None. & & &标记（Mark）
Mark(name, index, line, column, buffer, pointer)
Mark的实例指向输入流中一个确定的位置。&name 是流的名字，（如输入流是文件的话，name是文件名）&line 和 column 是位置的行和列(从0开始).&buffer, 如果不是None的话，是输入流包含该位置的一部分，&pointer 指向buffer中的位置。 & & &错误（YAMLError）
YAMLError()
如果YAML 解析器遇到错误，将抛出异常（异常是YAMLError或子类的一个实例）。一个应用可以捕获该异常并通知用户。
config = yaml.load(file('config.yaml', 'r'))
except yaml.YAMLError, exc:
print "Error in configuration file:", exc
YAML 处理器抛出的一个异常很可能指向了出现问题的位置。
yaml.load("unbalanced blackets: ][")
... except yaml.YAMLError, exc:
if hasattr(exc, 'problem_mark'):
mark = exc.problem_mark
print "Error position: (%s:%s)" % (mark.line+1, mark.column+1)
Error position: (1:22)
& & &句柄（Tokens） Tokens 是由YAML扫描器产生的（YAML scanner）. 除非是底层的YAML应用外，很少被用到（例如语法高亮）。 PyYAML scanner 产生以下类型的tokens:
StreamStartToken(encoding, start_mark, end_mark) # Start of the stream.
StreamEndToken(start_mark, end_mark) # End of the stream.
DirectiveToken(name, value, start_mark, end_mark) # YAML directive, either %YAML or %TAG.
DocumentStartToken(start_mark, end_mark) # '---'.
DocumentEndToken(start_mark, end_mark) # '...'.
BlockSequenceStartToken(start_mark, end_mark) # Start of a new block sequence.
BlockMappingStartToken(start_mark, end_mark) # Start of a new block mapping.
BlockEndToken(start_mark, end_mark) # End of a block collection.
FlowSequenceStartToken(start_mark, end_mark) # '['.
FlowMappingStartToken(start_mark, end_mark) # '{'.
FlowSequenceEndToken(start_mark, end_mark) # ']'.
FlowMappingEndToken(start_mark, end_mark) # '}'.
KeyToken(start_mark, end_mark) # Either '?' or start of a simple key.
ValueToken(start_mark, end_mark) # ':'.
BlockEntryToken(start_mark, end_mark) # '-'.
FlowEntryToken(start_mark, end_mark) # ','.
AliasToken(value, start_mark, end_mark) # '*value'.
AnchorToken(value, start_mark, end_mark) # '&value'.
TagToken(value, start_mark, end_mark) # '!value'.
ScalarToken(value, plain, style, start_mark, end_mark) # 'value'.
start_mark 和&end_mark 分别表示一个token的开始和结束。 Example:
&&& document = """
... block sequence:
... - BlockEntryToken
... block mapping:
? KeyToken
: ValueToken
... flow sequence: [FlowEntryToken, FlowEntryToken]
... flow mapping: {KeyToken: ValueToken}
... anchors and tags:
... - &A !!int '5'
&&& for token in yaml.scan(document):
print token
StreamStartToken(encoding='utf-8')
DocumentStartToken()
BlockMappingStartToken()
KeyToken()
ScalarToken(plain=True, style=None, value=u'block sequence')
ValueToken()
BlockEntryToken()
ScalarToken(plain=True, style=None, value=u'BlockEntryToken')
KeyToken()
ScalarToken(plain=True, style=None, value=u'block mapping')
ValueToken()
BlockMappingStartToken()
KeyToken()
ScalarToken(plain=True, style=None, value=u'KeyToken')
ValueToken()
ScalarToken(plain=True, style=None, value=u'ValueToken')
BlockEndToken()
KeyToken()
ScalarToken(plain=True, style=None, value=u'flow sequence')
ValueToken()
FlowSequenceStartToken()
ScalarToken(plain=True, style=None, value=u'FlowEntryToken')
FlowEntryToken()
ScalarToken(plain=True, style=None, value=u'FlowEntryToken')
FlowSequenceEndToken()
KeyToken()
ScalarToken(plain=True, style=None, value=u'flow mapping')
ValueToken()
FlowMappingStartToken()
KeyToken()
ScalarToken(plain=True, style=None, value=u'KeyToken')
ValueToken()
ScalarToken(plain=True, style=None, value=u'ValueToken')
FlowMappingEndToken()
KeyToken() ScalarToken(plain=True, style=None, value=u'anchors and tags')
ValueToken()
BlockEntryToken()
AnchorToken(value=u'A')
TagToken(value=(u'!!', u'int'))
ScalarToken(plain=False, style="'", value=u'5')
BlockEntryToken()
AliasToken(value=u'A')
BlockEndToken()
DocumentEndToken() StreamEndToken()
& & &事件（Events） 事件被用于底层解析器和发射器接口（ Parser and Emitter interfaces，很像SAX API. 解析器解析一个YAML流并产生一个事件序列，发射器接受事件序列发射一个YAML流。 下面是预定义的事件:
StreamStartEvent(encoding, start_mark, end_mark)
StreamEndEvent(start_mark, end_mark)
DocumentStartEvent(explicit, version, tags, start_mark, end_mark)
DocumentEndEvent(start_mark, end_mark)
SequenceStartEvent(anchor, tag, implicit, flow_style, start_mark, end_mark)
SequenceEndEvent(start_mark, end_mark)
MappingStartEvent(anchor, tag, implicit, flow_style, start_mark, end_mark)
MappingEndEvent(start_mark, end_mark)
AliasEvent(anchor, start_mark, end_mark)
ScalarEvent(anchor, tag, implicit, value, style, start_mark, end_mark)
flow_style 标志指明了集合是block还是flow的。可能的值是&None,&True,&False. 一个标量的style 标志指明了标量的样式。可能的值是None,&'',&'\'',&'"',&'|',&'&'. start event集合的implicit 标志指明了如果集合被发射时标签是否能够忽略。标量event的implicit标志是一对布尔值，它指明了当标量被发射为plain或者响应的非plain样式时，标签是否能够省略。 Example:
&&& document = """
... scalar: &A !!int '5'
... alias: *A
... sequence: [1, 2, 3]
... mapping: [1: one, 2: two, 3: three]
&&& for event in yaml.parse(document):
print event
StreamStartEvent()
DocumentStartEvent()
MappingStartEvent(anchor=None, tag=None, implicit=True)
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'scalar')
ScalarEvent(anchor=u'A', tag=u'tag:yaml.org,2002:int', implicit=(False, False), value=u'5')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'alias')
AliasEvent(anchor=u'A')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'sequence')
SequenceStartEvent(anchor=None, tag=None, implicit=True)
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'1')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'2')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'3')
SequenceEndEvent()
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'mapping')
MappingStartEvent(anchor=None, tag=None, implicit=True)
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'1')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'one')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'2')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'two')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'3')
ScalarEvent(anchor=None, tag=None, implicit=(True, False), value=u'three')
MappingEndEvent()
MappingEndEvent()
DocumentEndEvent()
StreamEndEvent()
&&& print yaml.emit([
yaml.StreamStartEvent(encoding='utf-8'),
yaml.DocumentStartEvent(explicit=True),
yaml.MappingStartEvent(anchor=None, tag=u'tag:yaml.org,2002:map', implicit=True, flow_style=False),
yaml.ScalarEvent(anchor=None, tag=u'tag:yaml.org,2002:str', implicit=(True, True), value=u'agile languages'),
yaml.SequenceStartEvent(anchor=None, tag=u'tag:yaml.org,2002:seq', implicit=True, flow_style=True),
yaml.ScalarEvent(anchor=None, tag=u'tag:yaml.org,2002:str', implicit=(True, True), value=u'Python'),
yaml.ScalarEvent(anchor=None, tag=u'tag:yaml.org,2002:str', implicit=(True, True), value=u'Perl'),
yaml.ScalarEvent(anchor=None, tag=u'tag:yaml.org,2002:str', implicit=(True, True), value=u'Ruby'),
yaml.SequenceEndEvent(),
yaml.MappingEndEvent(),
yaml.DocumentEndEvent(explicit=True),
yaml.StreamEndEvent(),
--- agile languages: [Python, Perl, Ruby]
& & &节点（Nodes） 节点是YAML信息模型的实体。有三种节点:标量，序列和映射（&scalar,&sequence, and&mapping）. 在PyYAML中, 节点由Composer产生，并可以被Serializer串行化为YAML流。
ScalarNode(tag, value, style, start_mark, end_mark)
SequenceNode(tag, value, flow_style, start_mark, end_mark)
MappingNode(tag, value, flow_style, start_mark, end_mark)
标志style 和&flow_style 具有跟事件中相同的含义。一个标量的值必须是一个unicode字符串。一个序列节点的值必须是一个节点列表。映射节点的值是一个key，value节点对组成的列表。&例如:
&&& print yaml.compose("""
... kinds:
... - scalar
... - sequence
... - mapping
MappingNode(tag=u'tag:yaml.org,2002:map', value=[
(ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'kinds'), SequenceNode(tag=u'tag:yaml.org,2002:seq', value=[
ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'scalar'),
ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'sequence'),
ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'mapping')]))])
&&& print yaml.serialize(yaml.SequenceNode(tag=u'tag:yaml.org,2002:seq', value=[
yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'scalar'),
yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'sequence'),
yaml.ScalarNode(tag=u'tag:yaml.org,2002:str', value=u'mapping')]))
- sequence
& & &装载器（Loader）
Loader(stream)
SafeLoader(stream)
BaseLoader(stream)
# The following classes are available only if you build LibYAML bindings.
CLoader(stream)
CSafeLoader(stream)
CBaseLoader(stream)
Loader(stream) 是上述类中应用最多的类。stream是一个YAML输入流，可以是字符串，Unicode字符串，打开文件或者Unicode打开文件。 Loader 支持所有预定义的标签，并能够构造任意的Python对象。因此用它来装载非认证源接受的文档是不安全的。默认情况下，scan,&parse,&compose,&construct, 等都使用&Loader. SafeLoader(stream) 只支持标准的YAML标签，不能构造类实例，接收为认证数据源的文档可能是安全的。函数safe_load和&safe_load_all 使用该装载器来解析流。 BaseLoader(stream) 不支持resolver任何标签，只能构造基本Python对象：lists，dictionaries，和Unicode字符串。 CLoader,&CSafeLoader,&CBaseLoader 是以上类的C版本，使用了& library.
Loader.check_token(*TokenClasses)
Loader.peek_token()
Loader.get_token()
Loader.check_token(*TokenClasses) 如果流中下一个token是一个给定TokenClasses的实例，返回&True；否则返回 False。 Loader.peek_token() 返回流中的下一个token，但是在内部token队列中并不做删除。到达流结尾时返回None。 Loader.get_token() 返回流中下个token，并在内部token队列中做删除。到达流结尾时返回None。
Loader.check_event(*EventClasses)
Loader.peek_event()
Loader.get_event()
Loader.check_event(*EventClasses) 如果流中下一个event是一个给定EventClasses的实例，返回&True；否则返回 False。 Loader.peek_event() 返回流中的下一个event，但是在内部event队列中并不做删除。到达流结尾时返回None。 Loader.get_event() 返回流中下个event，并在内部event队列中做删除。到达流结尾时返回None。
Loader.check_node()
Loader.get_node()
Loader.check_node() 如果流中还有文档返回True，否则返回False。 Loader.get_node() 构造流中下一个文档的表示图，返回它的root节点。
Loader.check_data()
Loader.get_data()
Loader.add_constructor(tag, constructor) # Loader.add_constructor is a class method.
Loader.add_multi_constructor(tag_prefix, multi_constructor) # Loader.add_multi_constructor is a class method.
Loader.construct_scalar(node)
Loader.construct_sequence(node)
Loader.construct_mapping(node)
Loader.check_data()如果流中还有文档返回True，否则返回False。 Loader.get_data() 构造和返回流中下一个文档对应的Python对象。 Loader.add_constructor(tag, constructor): 参见&add_constructor. Loader.add_multi_constructor(tag_prefix, multi_constructor): 参见&add_multi_constructor. Loader.construct_scalar(node) 检查给定节点是一个标量并返回它的值。该函数设计用于构造器。 Loader.construct_sequence(node) 检查给定节点是一个序列并返回对应节点item的一个Python对象的list。该函数设计用于构造器。 Loader.construct_mapping(node)检查给定节点是一个映射并返回该节点key：values对应的Python对象的dictionary
Loader.add_implicit_resolver(tag, regexp, first) # Loader.add_implicit_resolver is a class method.
Loader.add_path_resolver(tag, path, kind) # Loader.add_path_resolver is a class method.
Loader.add_implicit_resolver(tag, regexp, first): 参见&add_implicit_resolver. Loader.add_path_resolver(tag, path, kind): 参见&add_path_resolver. & & &导出器（Dumper）
Dumper(stream,
default_style=None,
default_flow_style=None,
canonical=None,
indent=None,
width=None,
allow_unicode=None,
line_break=None,
encoding=None,
explicit_start=None,
explicit_end=None,
version=None,
tags=None)
SafeDumper(stream, ...)
BaseDumper(stream, ...)
# The following classes are available only if you build LibYAML bindings.
CDumper(stream, ...)
CSafeDumper(stream, ...)
CBaseDumper(stream, ...)
Dumper(stream) 是用得最多的。stream是一个YAML输出流，可以时打开文件或者打开Unicode文件。 Dumper 支持所有的预定义的标签，可以表示任意的Python对象。因此它可能产生一个无法被其它YAML处理器所装载的文档。默认情况下，&emit,&serialize,&dump, 等使用&Dumper. SafeDumper(stream) 只产生标准的YAML标签，因此不能白欧式类实例，可能更加兼容其它的YAML处理器。函数safe_dump和&safe_dump_all 使用&SafeDumper 来产生YAML文档。 BaseDumper(stream) 不支持任何标签，只对创建子类有效。 CDumper,&CSafeDumper,&CBaseDumper 是上述类的C版本，使用了& library.
Dumper.emit(event)
Dumper.emit(event) 序列化给定的事件将其写入输出流。
Dumper.open()
Dumper.serialize(node)
Dumper.close()
Dumper.open() 发送&StreamStartEvent. Dumper.serialize(node) 序列化给定的表示图到输出流。 Dumper.close() 发送&StreamEndEvent.
Dumper.represent(data)
Dumper.add_representer(data_type, representer) # Dumper.add_representer is a class method.
Dumper.add_multi_representer(base_data_type, multi_representer) # Dumper.add_multi_representer is a class method.
Dumper.represent_scalar(tag, value, style=None)
Dumper.represent_sequence(tag, value, flow_style=None)
Dumper.represent_mapping(tag, value, flow_style=None)
Dumper.represent(data) 序列化给定的Python对象到YAML输出流 Dumper.add_representer(data_type, representer): 参见&add_representer. Dumper.add_multi_representer(base_data_type, multi_representer): 参见&add_multi_representer. Dumper.represent_scalar(tag, value, style=None) 返回具有给定tag，value和style的标量节点。该函数设计用于表示器。 Dumper.represent_sequence(tag, sequence, flow_style=None) 返回给定tag的序列节点，以及给定序列对应生成的子节点。 Dumper.represent_mapping(tag, mapping, flow_style=None) 返回一个给定tag的映射节点，已经给定映射的key和value对应的子节点。
Dumper.add_implicit_resolver(tag, regexp, first) # Dumper.add_implicit_resolver is a class method.
Dumper.add_path_resolver(tag, path, kind) # Dumper.add_path_resolver is a class method.
Dumper.add_implicit_resolver(tag, regexp, first): 参加&add_implicit_resolver. Dumper.add_path_resolver(tag, path, kind): 参见&add_path_resolver. & & &YAML对象（YAMLObject）
class MyYAMLObject(YAMLObject):
yaml_loader = Loader
yaml_dumper = Dumper
yaml_tag = u'...'
yaml_flow_style = ...
@classmethod
def from_yaml(cls, loader, node):
return data
@classmethod
def to_yaml(cls, dumper, data):
return node
继承&YAMLObject 是为你的类一个定义标签，构造器，表示器的简单方式。你只需要重载yaml_tag属性。如果你想定义你的自定义构造器和解释器，重定义from_yaml和to_yaml方法。 & & &对规范的背离（Deviations from the specification） 需要更新该节
tabs 的处理规则在YAML非常让人困惑。可能spec和parser都需要做调整。不管怎样，YAML中最好的tabs规则是不使用他们。 Byte order mark. The initial BOM is stripped, but BOMs inside the stream are considered as parts of the content. It can be fixed, but it's not really important now. 空的plain标量在已经指定了别名或标签的情况下是不允许的。 这么做能够预防歧义，比如&[ !tag, value], 能被解释成两种意思&[ !&!tag,& value ] 和&[ !&!tag& "", "value" ]. 应该被修正。 流式集合的缩进。规定要求它们要做比它们的block parent 节点更多的缩进. 不幸的是这条规则让许多只管正确的构造变得非法了，例如： block: { } # this is indentation violation according to the spec.
':' 在流式模式中plain标量的不被允许。.&{1:2} 被解释为&{ 1 : 2 }.
阅读(3217)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'PyYAML 文档（中文版）',
blogAbstract:'& & PyYAML 文档（中文版 by ） ',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:2,
publishTime:2,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'0',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}}