Định dạng danh sách kết xuất python yaml

Bối cảnh lịch sử

YAML, vần với lạc đà, là từ viết tắt đệ quy viết tắt của YAML Ain't Markup Language bởi vì nó không phải là ngôn ngữ đánh dấu. Thật thú vị, bản nháp ban đầu cho đặc tả YAML đã xác định ngôn ngữ là Yet Another Markup Language, nhưng sau đó, từ viết tắt hiện tại đã được sử dụng để mô tả chính xác hơn mục đích của ngôn ngữ

Một ngôn ngữ đánh dấu thực tế, chẳng hạn như Markdown hoặc HTML, cho phép bạn chú thích văn bản với các hướng dẫn định dạng hoặc xử lý xen kẽ với nội dung của bạn. Do đó, các ngôn ngữ đánh dấu chủ yếu liên quan đến các tài liệu văn bản, trong khi YAML là một định dạng tuần tự hóa dữ liệu tích hợp tốt với các loại dữ liệu phổ biến có nguồn gốc từ nhiều ngôn ngữ lập trình. Không có văn bản vốn có trong YAML, chỉ có dữ liệu để thể hiện

YAML ban đầu được dùng để đơn giản hóa Ngôn ngữ đánh dấu mở rộng [XML], nhưng trên thực tế, nó có nhiều điểm chung hơn với Ký hiệu đối tượng JavaScript [JSON]. Trên thực tế, đó là một siêu bộ JSON

Mặc dù XML ban đầu được thiết kế để trở thành ngôn ngữ kim loại để tạo ngôn ngữ đánh dấu cho tài liệu, mọi người đã nhanh chóng sử dụng nó làm định dạng tuần tự hóa dữ liệu tiêu chuẩn. Cú pháp giống như HTML của dấu ngoặc nhọn làm cho XML trông quen thuộc. Đột nhiên, mọi người đều muốn sử dụng XML làm định dạng cấu hình, tính bền vững hoặc thông báo của họ

Là đứa trẻ đầu tiên trong khối, XML đã thống trị hiện trường trong nhiều năm. Nó đã trở thành một định dạng trao đổi dữ liệu trưởng thành và đáng tin cậy, đồng thời giúp hình thành các khái niệm mới như xây dựng các ứng dụng web tương tác. Xét cho cùng, chữ X trong AJAX, một kỹ thuật lấy dữ liệu từ máy chủ mà không cần tải lại trang, không gì khác chính là XML

Trớ trêu thay, chính AJAX cuối cùng đã dẫn đến sự suy giảm mức độ phổ biến của XML. Cú pháp XML dài dòng, phức tạp và dư thừa đã lãng phí rất nhiều băng thông khi dữ liệu được gửi qua mạng. Phân tích cú pháp tài liệu XML trong JavaScript chậm và tẻ nhạt do mô hình đối tượng tài liệu cố định [DOM] của XML, không khớp với mô hình dữ liệu của ứng dụng. Cộng đồng cuối cùng đã thừa nhận rằng họ đã sử dụng sai công cụ cho công việc

Đó là khi JSON vào bức tranh. Nó được xây dựng từ đầu với ý tưởng tuần tự hóa dữ liệu. Các trình duyệt web có thể phân tích nó một cách dễ dàng vì JSON là một tập hợp con của JavaScript mà chúng đã hỗ trợ. Cú pháp tối giản của JSON không chỉ hấp dẫn các nhà phát triển mà còn giúp việc chuyển sang các nền tảng khác dễ dàng hơn so với XML. Cho đến ngày nay, JSON vẫn là định dạng trao đổi dữ liệu văn bản mỏng nhất, nhanh nhất và linh hoạt nhất trên Internet

YAML ra đời cùng năm với JSON và hoàn toàn trùng hợp, nó gần như là một siêu bộ hoàn chỉnh của JSON ở cấp độ cú pháp và ngữ nghĩa. Bắt đầu từ YAML 1. 2, định dạng này chính thức trở thành một siêu bộ nghiêm ngặt của JSON, nghĩa là mọi tài liệu JSON hợp lệ cũng là một tài liệu YAML

Tuy nhiên, trên thực tế, hai định dạng trông khác nhau, vì đặc tả YAML nhấn mạnh hơn vào khả năng đọc của con người bằng cách thêm nhiều đường cú pháp và tính năng hơn trên JSON. Do đó, YAML phù hợp hơn với các tệp cấu hình được chỉnh sửa thủ công hơn là lớp vận chuyển

So sánh với XML và JSON

Nếu bạn đã quen thuộc với XML hoặc JSON, thì bạn có thể tự hỏi YAML mang lại điều gì cho bảng. Cả ba đều là các định dạng trao đổi dữ liệu chính, chia sẻ một số tính năng chồng chéo. Ví dụ: tất cả chúng đều dựa trên văn bản và ít nhiều có thể đọc được bằng con người. Đồng thời, chúng khác nhau ở nhiều khía cạnh mà bạn sẽ tìm hiểu tiếp theo

Ghi chú. Có các định dạng dữ liệu văn bản khác, ít phổ biến hơn như TOML, mà hệ thống xây dựng mới trong Python dựa trên. Hiện tại, chỉ các công cụ quản lý phụ thuộc và đóng gói bên ngoài như Thơ mới có thể đọc TOML, nhưng Python 3. 11 sẽ sớm có bộ phân tích cú pháp TOML trong thư viện chuẩn

Các định dạng tuần tự hóa dữ liệu nhị phân phổ biến mà bạn tìm thấy trong tự nhiên bao gồm Bộ đệm giao thức của Google và Avro của Apache

Bây giờ hãy xem một tài liệu mẫu được thể hiện ở cả ba định dạng dữ liệu nhưng đại diện cho cùng một người. Bạn có thể nhấp để mở rộng các phần có thể thu gọn và hiển thị dữ liệu được đăng nhiều kỳ ở các định dạng đó

XMLHiển thị/Ẩn

    1969-12-31
    true
    
        
             
        
    

JSONHiển thị/Ẩn

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

YAMLHiển thị/Ẩn

%YAML 1.2
---
person:
  dateOfBirth: 1969-12-31
  firstName: John
  lastName: Doe
  married: true
  spouse:
    dateOfBirth: null  # This is a comment
    firstName: Jane
    lastName: Doe

Thoạt nhìn, XML dường như có cú pháp đáng sợ nhất, gây ra nhiều tiếng ồn. JSON cải thiện đáng kể tình hình về mặt đơn giản, nhưng nó vẫn chôn vùi thông tin bên dưới các dấu phân cách bắt buộc. Mặt khác, YAML sử dụng thụt lề khối kiểu Python để xác định cấu trúc, làm cho nó trông rõ ràng và đơn giản. Nhược điểm là bạn không thể thu gọn khoảng trắng để giảm dung lượng khi truyền tin nhắn qua dây

Ghi chú. JSON là định dạng dữ liệu duy nhất không hỗ trợ nhận xét. Chúng đã bị xóa khỏi đặc điểm kỹ thuật nhằm mục đích đơn giản hóa trình phân tích cú pháp và ngăn mọi người lạm dụng chúng để nhận các hướng dẫn xử lý tùy chỉnh

Đây là một so sánh hơi chủ quan về XML, JSON và YAML để cung cấp cho bạn ý tưởng về cách chúng xếp chồng lên nhau như các định dạng trao đổi dữ liệu ngày nay

XMLJSONYAMLAáp dụng và hỗ trợ⭐⭐⭐⭐⭐⭐⭐⭐⭐⭐Khả năng đọc⭐⭐⭐⭐⭐⭐⭐⭐⭐Tốc độ đọc và ghi⭐⭐⭐⭐⭐⭐⭐Kích thước tệp⭐⭐⭐⭐⭐⭐

Khi bạn xem Google Xu hướng để theo dõi sở thích trong ba cụm từ tìm kiếm, thì bạn sẽ kết luận rằng JSON là người chiến thắng hiện tại. Tuy nhiên, XML không thua xa, với YAML thu hút ít sự quan tâm nhất. Ngoài ra, có vẻ như mức độ phổ biến của XML đã giảm dần kể từ khi Google bắt đầu thu thập dữ liệu

Ghi chú. Trong số ba định dạng này, XML và JSON là những định dạng duy nhất mà Python hỗ trợ ngay lập tức, trong khi nếu bạn muốn làm việc với YAML, thì bạn phải tìm và cài đặt thư viện bên thứ ba tương ứng. Mặc dù vậy, Python không phải là ngôn ngữ duy nhất hỗ trợ XML và JSON tốt hơn YAML. Bạn có thể tìm thấy xu hướng này trên các ngôn ngữ lập trình

YAML được cho là dễ nhìn nhất, vì tính dễ đọc luôn là một trong những nguyên tắc cốt lõi của nó, nhưng JSON cũng không tệ. Một số thậm chí có thể thấy JSON ít lộn xộn và ồn ào hơn do cú pháp tối giản của nó và giống với các danh sách và từ điển Python. XML là dài dòng nhất, vì nó yêu cầu gói mọi mẩu thông tin trong một cặp thẻ mở và thẻ đóng

Trong Python, hiệu suất khi làm việc với các định dạng dữ liệu này sẽ khác nhau và sẽ rất nhạy cảm với cách triển khai mà bạn chọn. Việc triển khai Python thuần túy sẽ luôn thua thư viện C đã biên dịch. In addition to this, using different XML processing models—[DOM, SAX, or StAX]—will also impact performance

Implementations aside, YAML’s versatile, liberal, and complex syntax makes it by far the slowest to parse and serialize. On the other side of the spectrum, you’ll find JSON, whose grammar can fit on a business card. In contrast, YAML’s own grammar documentation claims that creating a fully compliant parser has proven almost impossible

Fun Fact. The official yaml. org website is written as a valid YAML document

When it comes to document size, JSON is a clear winner again. While the extra quotation marks, commas, and curly brackets take up valuable space, you can remove all the whitespace between the individual elements. You can do the same with XML documents, but it won’t overcome the overhead of the opening and closing tags. YAML sits somewhere in the middle by having a comparatively medium size

Historically, XML has had the best support across a wide range of technologies. JSON is an unbeatable all-around interchange format for transferring data on the Internet. So, who uses YAML and why?

Practical Uses of YAML

As noted earlier, YAML is mostly praised for its readability, which makes it perfect for storing all kinds of configuration data in a human-readable format. It became especially popular among DevOps engineers, who’ve built automation tools around it. A few examples of such tools include

• Ansible. Uses YAML to describe the desired state of the remote infrastructure, manage the configuration, and orchestrate IT processes
• Docker Compose. Uses YAML to describe the microservices comprising your Dockerized application
• Kubernetes. Uses YAML to define various objects in a computer cluster to orchestrate and manage

Apart from that, some general-purpose tools, libraries, and services give you the option to configure them through YAML, which you may find more convenient than other data formats. For example, platforms like CircleCI and GitHub frequently turn to YAML to define continuous integration, deployment, and delivery [CI/CD] pipelines. The OpenAPI Specification allows for code stub generation based on a YAML description of RESTful APIs

Ghi chú. The documentation for Python’s logging framework mentions YAML despite the fact that the language doesn’t support YAML natively

Maybe you’ll decide to adopt YAML in your future project after completing this tutorial

YAML Syntax

YAML draws heavy inspiration from other data formats and languages that you might have heard of before. Perhaps the most striking and familiar element of YAML’s syntax is its block indentation, which resembles Python code. The leading whitespace on each line defines the scope of a block, eliminating the need for any special characters or tags to denote where it begins or ends

grandparent:
  parent:
    child:
      name: Bobby
    sibling:
      name: Molly

This sample document defines a family tree with

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

Note. The YAML specification forbids using tabs for indentation and considers their use a syntax error. This coincides with Python’s PEP 8 recommendation about preferring spaces over tabs

At the same time, YAML lets you leverage an alternative inline-block syntax borrowed from JSON. You can rewrite the same document in the following way

grandparent:
  parent:
    child: {name: Bobby}
    sibling: {'name': "Molly"}

Notice how you can mix the indented and inline blocks in one document. Also, you’re free to enclose both the attributes and their values in single quotes [

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

YAMLPythonDescription

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Don’t worry if that looks confusing. You’ll want to specify unquoted string literals in YAML for the most part, anyway. One notable exception would be declaring a string that the parser could misinterpret as the wrong data type. For example,

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

The three fundamental data structures in YAML are essentially the same as in Perl, which was once a popular scripting language. They’re the following

1. Scalars. Simple values like numbers, strings, or Booleans
2. Arrays. Sequences of scalars or other collections
3. Hashes. Associative arrays, also known as maps, dictionaries, objects, or records comprised of key-value pairs

You can define a YAML scalar similarly to a corresponding Python literal. Here are a few examples

Data TypeYAMLNull

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

You can write reserved words in YAML in lowercase [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Note. This implicit typing in YAML seems convenient, but it’s like playing with fire, and it can cause serious problems in edge cases. As a result, the YAML 1. 2 specification dropped support for some built-in literals like

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Sequences in YAML are just like Python lists or JSON arrays. They use the standard square bracket syntax [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

You can keep your list items at the same indentation level as their property name or add more indentation if that improves readability for you

Finally, YAML has hashes analogous to Python dicts or JavaScript objects. They’re made of keys, also known as attribute or property names, followed by a colon [

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

You’ve just defined a person, John Doe, who’s married to Jane Smith and has two children, Bobby and Molly. Notice how the list of children contains anonymous objects, unlike, for example, the spouse defined under a property named

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Ghi chú. Tên thuộc tính trong YAML khá linh hoạt, vì chúng có thể chứa các ký tự khoảng trắng và trải rộng trên nhiều dòng. Hơn nữa, bạn không bị giới hạn chỉ sử dụng các chuỗi. Không giống như JSON, nhưng tương tự như từ điển Python, hàm băm YAML cho phép bạn sử dụng hầu hết mọi loại dữ liệu cho một khóa

Đương nhiên, bạn mới chỉ vạch ra bề nổi ở đây, vì YAML có rất nhiều tính năng nâng cao hơn để cung cấp. Bạn sẽ tìm hiểu về một số trong số họ bây giờ

Tính năng độc đáo

Trong phần này, bạn sẽ xem một số tính năng độc đáo nhất của YAML, bao gồm

• Loại dữ liệu
• thẻ
• Neo và bí danh
• thuộc tính hợp nhất
• Phong cách dòng chảy và khối
• Luồng nhiều tài liệu

Mặc dù XML là tất cả về văn bản và JSON kế thừa một số kiểu dữ liệu của JavaScript, tính năng xác định của YAML là tích hợp chặt chẽ với các hệ thống kiểu của ngôn ngữ lập trình hiện đại. Ví dụ: bạn có thể sử dụng YAML để tuần tự hóa và giải tuần tự hóa các loại dữ liệu được tích hợp trong Python, chẳng hạn như ngày và giờ

YAMLPython

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

YAML hiểu các định dạng ngày và giờ khác nhau, bao gồm tiêu chuẩn ISO 8601 và có thể hoạt động với các múi giờ tùy chọn. Dấu thời gian như 23. 59. 59 được deserialized thành số giây trôi qua kể từ nửa đêm

Để giải quyết sự mơ hồ tiềm ẩn, bạn có thể truyền giá trị cho các loại dữ liệu cụ thể bằng cách sử dụng thẻ YAML, bắt đầu bằng dấu chấm than kép [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

Việc sử dụng thẻ

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Moreover, you can use the

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

The YAML document above would translate into the following Python dictionary

{
    "text": "2022-01-16",
    "numbers": {8, 13, 5},
    "image": b"GIF87a\x08\x00\x08\x00\xf0\x00…",
    "pair": ["black", "white"],
    "center_at": [3.14+2.72j],
    "person": 
}

Notice how, with the help of YAML tags, the parser turned property values into various Python data types, including a string, a set, a bytes object, a tuple, a complex number, and even a custom class instance

Other powerful features of YAML are anchors and aliases, which let you define an element once and then refer to it many times within the same document. Potential use cases include

• Reusing the shipping address for invoicing
• Rotating meals in a meal plan
• Referencing exercises in a training program

To declare an anchor, which you can think of as a named variable, you’d use the ampersand [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

recursive: &cycle [*cycle]

exercises:
  - muscles: &push-up
      - pectoral
      - triceps
      - biceps
  - muscles: &squat
      - glutes
      - quadriceps
      - hamstrings
  - muscles: &plank
      - abs
      - core
      - shoulders

schedule:
  monday:
    - *push-up
    - *squat
  tuesday:
    - *plank
  wednesday:
    - *push-up
    - *plank

Tại đây, bạn đã tạo một kế hoạch tập luyện từ các bài tập mà bạn đã xác định trước đó, lặp lại chúng trong các thói quen hàng ngày khác nhau. Ngoài ra, thuộc tính

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Ghi chú. Không giống như XML và JSON thuần túy, chỉ có thể biểu thị các cấu trúc phân cấp dạng cây với một phần tử gốc duy nhất, YAML cũng cho phép mô tả các cấu trúc đồ thị có hướng bằng các chu kỳ đệ quy. Tuy nhiên, có thể tham chiếu chéo trong XML và JSON với sự trợ giúp của các tiện ích mở rộng hoặc phương ngữ tùy chỉnh

Bạn cũng có thể hợp nhất [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Đối tượng

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Vô hướng trong YAML hỗ trợ kiểu dòng hoặc kiểu khối, cung cấp cho bạn các mức kiểm soát khác nhau đối với việc xử lý dòng mới trong chuỗi nhiều dòng. Vô hướng luồng có thể bắt đầu trên cùng một dòng với tên thuộc tính của chúng và có thể trải rộng trên nhiều dòng

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Trong trường hợp như vậy, khoảng trắng ở đầu và cuối của mỗi dòng sẽ luôn được xếp vào một khoảng trắng duy nhất, biến các đoạn văn thành các dòng. Điều này hoạt động hơi giống HTML hoặc Markdown, dẫn đến đoạn văn bản sau

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Và, trong trường hợp bạn đang thắc mắc, Lorem ipsum là một văn bản giữ chỗ phổ biến được sử dụng trong văn bản và thiết kế web để lấp đầy khoảng trống có sẵn. Nó không mang bất kỳ ý nghĩa nào, vì nó cố tình vô nghĩa và được viết bằng tiếng Latinh không phù hợp để giúp bạn tập trung vào hình thức hơn là nội dung

Trái ngược với vô hướng dòng chảy, vô hướng khối cho phép thay đổi cách xử lý các dòng mới, dòng mới theo sau hoặc thụt đầu dòng. Ví dụ: chỉ báo đường ống [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Tài liệu YAML ở trên định nghĩa một thuộc tính có tên là

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Nếu bạn chỉ muốn gấp các dòng có thụt đầu dòng được xác định bởi dòng đầu tiên trong đoạn văn, thì hãy sử dụng dấu lớn hơn [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Điều này sẽ tạo ra đầu ra sau

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Cuối cùng, bạn có thể lưu trữ nhiều tài liệu YAML trong một tệp duy nhất được phân tách bằng dấu gạch ngang ba lần [

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Tuần tự hóa các tài liệu YAML dưới dạng JSON

Mặc dù Python không cung cấp trình phân tích cú pháp YAML hoặc trình tuần tự hóa chuyên dụng, nhưng bạn có thể khắc phục vấn đề này ở một mức độ nào đó với sự trợ giúp của mô-đun

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

First, make a sample Python script to print out JSON on the standard output

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Bạn tạo một từ điển và sau đó gọi

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Bây giờ, hãy chạy tập lệnh của bạn và cung cấp đầu ra của nó cho một trong các trình phân tích cú pháp YAML dòng lệnh đã đề cập trước đó, chẳng hạn như

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Tốt đẹp. Cả hai trình phân tích cú pháp đã định dạng dữ liệu của bạn ở định dạng YAML chính tắc hơn mà không phàn nàn. Tuy nhiên, vì

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Ghi chú. Để sử dụng

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Được rồi, điều đó giống như gian lận và nó chỉ hoạt động theo một cách, vì bạn không thể đọc lại tệp YAML vào Python bằng mô-đun

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Cài đặt thư viện PyYAML

Cho đến nay, thư viện YAML bên thứ ba phổ biến nhất của Python là PyYAML, đây luôn là một trong những gói hàng đầu được tải xuống từ PyPI. Nó có giao diện trông hơi giống với mô-đun JSON tích hợp, nó được duy trì tích cực và nó được trang web YAML chính thức hỗ trợ, liệt kê nó cùng với một số ứng cử viên ít phổ biến hơn

Để cài đặt PyYAML vào môi trường ảo đang hoạt động của bạn, hãy nhập lệnh sau trong thiết bị đầu cuối của bạn

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Thư viện độc lập và không yêu cầu bất kỳ phụ thuộc nào nữa vì nó được viết bằng Python thuần túy. Tuy nhiên, hầu hết các bản phân phối đều gói một liên kết C đã biên dịch cho thư viện LibYAML, giúp PyYAML chạy nhanh hơn nhiều. Để xác nhận xem cài đặt PyYAML của bạn có liên kết C hay không, hãy mở trình thông dịch Python tương tác và chạy đoạn mã này

>>>

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Mặc dù PyYAML là tên của thư viện bạn đã cài đặt, nhưng bạn sẽ nhập gói

{
    "person": {
        "dateOfBirth": "1969-12-31",
        "firstName": "John",
        "lastName": "Doe",
        "married": true,
        "spouse": {
            "dateOfBirth": null,
            "firstName": "Jane",
            "lastName": "Doe"
        }
    }
}

Mặc dù phổ biến nhưng PyYAML có một số nhược điểm. Ví dụ: nếu bạn cần sử dụng các tính năng được giới thiệu trong YAML 1. 2, chẳng hạn như tuân thủ JSON đầy đủ hoặc nghĩa đen an toàn hơn, thì tốt hơn hết bạn nên sử dụng ruamel. thư viện yaml, bắt nguồn từ phiên bản PyYAML cũ hơn. Như một phần thưởng, nó có thể thực hiện phân tích cú pháp khứ hồi để giữ lại các nhận xét và định dạng ban đầu khi cần

Mặt khác, nếu an toàn loại là mối quan tâm chính của bạn hoặc bạn muốn xác thực các tài liệu YAML dựa trên một lược đồ, thì hãy xem StrictYAML, nó cố ý hạn chế đặc tả YAML bằng cách bỏ qua các tính năng rủi ro nhất của nó. Chỉ cần lưu ý rằng nó sẽ không chạy nhanh như hai thư viện kia