YAML is an intuitive data serialization format that can be recognized by computers, which is easy to be read by humans and easy to interact with scripting languages. YAML is similar to XML, but the syntax is much simpler than XML, and is very simple and effective when converting it into arrays or data that can have.
1. PyYaml
1. load(): Return an object
Let's create a yml file first,:
name: Tom Smith
age: 37
spouse:
name: Jane Smith
age: 25
children:
- name: Jimmy Smith
age: 15
- name1: Jenny Smith
age1: 12Read the yml file:
import yaml
f = open(r'E:\AutomaticTest\Test_Framework\config\')
y = (f)
print (y)result:
{'name': 'Tom Smith', 'age': 37, 'spouse': {'name': 'Jane Smith', 'age': 25}, 'children': [{'name': 'Jimmy Smith', 'age': 15}, {'name1': 'Jenny Smith', 'age1': 12}]}2. Load_all() generates an iterator
If a string or file contains several yaml documents, you can use yaml.load_all to parse all documents.
import yaml
f = '''
---
name: James
age: 20
---
name: Lily
age: 19
'''
y = _all(f)
for data in y:
print(data)Execution results:
{'name': 'James', 'age': 20}
{'name': 'Lily', 'age': 19}3. Generate a python object into a yaml document
import yaml
aproject = {'name': 'Silenthand Olleander',
'race': 'Human',
'traits': ['ONE_HAND', 'ONE_EYE']
}
print((aproject，))Execution results:
name: Silenthand Olleander
race: Human
traits: [ONE_HAND, ONE_EYE]The second parameter received must be an open text file or binary file, which will write the generated yaml document into the file.
import yaml
aproject = {'name': 'Silenthand Olleander',
'race': 'Human',
'traits': ['ONE_HAND', 'ONE_EYE']
}
f = open(r'E:\AutomaticTest\Test_Framework\config\','w')
print((aproject,f))4. yaml.dump_all() outputs multiple segments to a file
import yaml
obj1 = {"name": "James", "age": 20}
obj2 = ["Lily", 19]
with open(r'E:\AutomaticTest\Test_Framework\config\', 'w') as f:
yaml.dump_all([obj1, obj2], f)Output to file:
{age: 20, name: James}
--- [Lily, 19]2. Yaml syntax
1. Basic rules
1.Case sensitivity2. Use indentation to represent hierarchical relationships3. Tab is not allowed during indentation, only spaces are allowed4. The number of indented spaces does not matter, as long as elements of the same level are left aligned5. # means comment, from the beginning to the end of the line, it is ignored2. Yaml to dictionary
The representation of mapping or dictionary is supported in yaml, as follows:
# The following format will be a dict in Python
name:Gray blueage: 0
job: TesterOutput:
{'name': 'Gray Blue', 'age': 0, 'job': 'Tester'}3. Yaml to list
The representation of lists or arrays is supported in yaml, as follows:
# The following format will be a list in Python
-Gray blue- 0
- TesterOutput:
['Gray Blue',0, 'Tester']4. Composite structure:
Dictionary and list can be used in combination, as follows:
# The following format reads that Python contains dict
- name:Gray blue age: 0
job: Tester
- name: James
age: 30Output:
[{'name': 'Gray Blue', 'age': 0, 'job': 'Tester'}, {'name': 'James', 'age': 30}]5. Basic types:
There are the following basic types in yaml:
String
Integer
Floating point type
Boolean typenulltime
dateLet's write an example:
# This example outputs a dictionary where value includes all basic types
str: "Hello World!"
int: 110
float: 3.141
boolean: true # or false
None: null # You can also use the ~ sign to represent null
time: 2016-09-22t11:43:30.20+08:00 # ISO8601, writing method Baidu
date: 2016-09-22 # Same ISO8601Output:
{'str': 'Hello World!', 'int': 110, 'float': 3.141, 'boolean': True, 'None': None, 'time': datetime.datetime(2016, 9, 22, 3, 43, 30, 200000), 'date': datetime.date(2016, 9, 22)}If the string has no spaces or special characters, no quotes are required, but if there are spaces or special characters, no quotes are required
str: Gray blue
str1: "Hello World"
str2: "Hello\nWorld"Output:
{'str': 'Gray Blue', 'str1': 'Hello World', 'str2': 'Hello\nWorld'}Here we should pay attention to the difference between single quotes and double quotes. Special characters in single quotes will be escaped when transferred to Python, that is, they will be output as it is in the end, and double quotes will not be escaped by Python, and special characters will be output at the end; such as:
str1: 'Hello\nWorld'
str2: "Hello\nWorld"Output:
{'str1': 'Hello\\nWorld', 'str2': 'Hello\nWorld'}You can see that the '\n' in single quotes is output in the end, and the '\n' in double quotes is finally escaped into a carriage return.
6. Quote
& and * are used for reference
name: &name Gray Blue
tester: *nameThis is equivalent to the following script:
name: Gray blue
tester: Gray blueOutput:
{'name': 'Gray Blue', 'tester': 'Gray Blue'}7. Cases
Yaml can be cast, and it is implemented with !!, as follows:
str: !!str 3.14
int: !!int "123"Output:
{'int': 123, 'str': '3.14'}It is obvious that 123 has been forced to be converted to the int type, while float type 3.14 has been forced to be converted to the str type.
8. Segmentation
In the same yaml file, you can use - to segment it, so that multiple documents can be written in one file
---
name: James
age: 20
---
name: Lily
age: 193. Constructors, representations, and resolvers
1、
Use metaclasses to register a constructor (that is, in the codeinit() method), let you convert the yaml node into a Python object instance and use a representor (that is, the coderepr() function) lets you convert Python objects into yaml nodes, see the code:
import yaml
class Person():
yaml_tag = '!person'
def __init__(self, name, age):
= name
= age
def __repr__(self):
return '%s(name=%s, age=%d)' % (self.__class__.__name__, , )
james = Person('James', 20)
print ((james)) # Convert Python object instance to yaml
lily = ('!person {name: Lily, age: 19}')
print (lily) # Convert yaml to Python object instanceOutput:
!person {age: 20, name: James}
Person(name=Lily, age=19)2. yaml.add_constructor and yaml.add_representer
You may not want to use the above metaclass method during use, but want to define normal classes. Then, you can use these two methods
import yaml
class Person(object):
def __init__(self, name, age):
= name
= age
def __repr__(self):
return 'Person(%s, %s)' % (, )
james = Person('James', 20)
print ((james)) # Before adding a display
def person_repr(dumper, data):
return dumper.represent_mapping(u'!person', {"name": , "age": }) # mapping standpoint, used for dict
yaml.add_representer(Person, person_repr) # Use the add_representer method to add a representor to the object
print ((james)) # After adding the indicator
def person_cons(loader, node):
value = loader.construct_mapping(node) # mapping constructor for dict
name = value['name']
age = value['age']
return Person(name, age)
yaml.add_constructor(u'!person', person_cons) # Use the add_constructor method to add a constructor to the specified yaml tag
lily = ('!person {name: Lily, age: 19}')
print (lily)Output:
!!python/object:__main__.Person {age: 20, name: James}
!person {age: 20, name: James}
Person(Lily, 19)The first line is how ugly it is before adding a display! The middle line is added with a notation and becomes a standard format. A constructor is added below to convert the !person tag into a Person object.
IV. Example
Yaml is a very clear and concise format, and it is very compatible with Python and is very easy to operate. When we build an automated testing framework, we can use Yaml as a configuration file or use case file. Here is an example of a use case.
# Test using included Django test app
# First install python-django
# Then launch the app in another terminal by doing
# cd testapp
# python testserver test_data.json
# Once launched, tests can be executed via:
# python http://localhost:8000
---
- config:
- testset: "Tests using test app"
- test: # create entity
- name: "Basic get"
- url: "/api/person/"
- test: # create entity
- name: "Get single person"
- url: "/api/person/1/"
- test: # create entity
- name: "Get single person"
- url: "/api/person/1/"
- method: 'DELETE'
- test: # create entity by PUT
- name: "Create/update person"
- url: "/api/person/1/"
- method: "PUT"
- body: '{"first_name": "Gaius","id": 1,"last_name": "Baltar","login": "gbaltar"}'
- headers: {'Content-Type': 'application/json'}
- test: # create entity by POST
- name: "Create person"
- url: "/api/person/"
- method: "POST"
- body: '{"first_name": "Willim","last_name": "Adama","login": "theadmiral"}'
- headers: {Content-Type: application/json}