Làm cách nào để tạo tệp yml trong Python?

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 các tài liệu XML trong JavaScript chậm và tẻ nhạt vì XML đã sửa, 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 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. Ngoài ra, việc sử dụng các mô hình xử lý XML khác—[, , hoặc ]—cũng sẽ ảnh hưởng đến hiệu suất

Việc triển khai sang một bên, cú pháp linh hoạt, tự do và phức tạp của YAML khiến cho việc phân tích cú pháp và tuần tự hóa chậm nhất cho đến nay. Ở phía bên kia của quang phổ, bạn sẽ tìm thấy JSON, ngữ pháp của nó có thể phù hợp với danh thiếp. Ngược lại, tài liệu ngữ pháp riêng của YAML tuyên bố rằng việc tạo một trình phân tích cú pháp tuân thủ đầy đủ đã được chứng minh là gần như không thể

Sự thật thú vị. yaml chính thức. trang web org được viết dưới dạng tài liệu YAML hợp lệ

Khi nói đến kích thước tài liệu, JSON lại là người chiến thắng rõ ràng. Mặc dù các dấu ngoặc kép, dấu phẩy và dấu ngoặc nhọn thừa chiếm không gian quý giá nhưng bạn có thể xóa tất cả khoảng trắng giữa các thành phần riêng lẻ. Bạn có thể làm tương tự với các tài liệu XML, nhưng nó sẽ không khắc phục được chi phí mở và thẻ đóng. YAML nằm ở đâu đó ở giữa bằng cách có kích thước tương đối trung bình

Về mặt lịch sử, XML đã có sự hỗ trợ tốt nhất trên nhiều loại công nghệ. JSON là một định dạng trao đổi toàn diện không thể đánh bại để truyền dữ liệu trên Internet. Vì vậy, ai sử dụng YAML và tại sao?

Công dụng thực tế của YAML

Như đã lưu ý trước đó, YAML chủ yếu được đánh giá cao về khả năng đọc của nó, điều này làm cho nó trở nên hoàn hảo để lưu trữ tất cả các loại dữ liệu cấu hình ở định dạng mà con người có thể đọc được. Nó trở nên đặc biệt phổ biến đối với các kỹ sư DevOps, những người đã xây dựng các công cụ tự động hóa xung quanh nó. Một vài ví dụ về các công cụ như vậy bao gồm

• ansible. Sử dụng YAML để mô tả trạng thái mong muốn của cơ sở hạ tầng từ xa, quản lý cấu hình và điều phối các quy trình CNTT
• Docker Soạn. Sử dụng YAML để mô tả các vi dịch vụ bao gồm ứng dụng Dockerized của bạn
• Kubernetes. Sử dụng YAML để xác định các đối tượng khác nhau trong cụm máy tính để sắp xếp và quản lý

Ngoài ra, một số công cụ, thư viện và dịch vụ đa năng cung cấp cho bạn tùy chọn định cấu hình chúng thông qua YAML, mà bạn có thể thấy thuận tiện hơn các định dạng dữ liệu khác. Ví dụ: các nền tảng như CircleCI và GitHub thường chuyển sang YAML để xác định các quy trình tích hợp, triển khai và phân phối [CI/CD] liên tục. Đặc tả OpenAPI cho phép tạo sơ khai mã dựa trên mô tả YAML của API RESTful

Ghi chú. Tài liệu về khung ghi nhật ký của Python đề cập đến YAML mặc dù thực tế là ngôn ngữ này không hỗ trợ YAML nguyên bản

Có thể bạn sẽ quyết định áp dụng YAML trong dự án tương lai của mình sau khi hoàn thành hướng dẫn này

Cú pháp YAML

YAML lấy cảm hứng từ các định dạng dữ liệu và ngôn ngữ khác mà bạn có thể đã nghe nói đến trước đây. Có lẽ yếu tố nổi bật và quen thuộc nhất trong cú pháp của YAML là thụt lề khối của nó, giống với mã Python. Khoảng trắng hàng đầu trên mỗi dòng xác định phạm vi của một khối, loại bỏ nhu cầu về bất kỳ ký tự hoặc thẻ đặc biệt nào để biểu thị nơi bắt đầu hoặc kết thúc

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

Tài liệu mẫu này xác định một cây phả hệ với

{
    "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": 
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Ghi chú. Đặc tả YAML cấm sử dụng tab để thụt đầu dòng và coi việc sử dụng chúng là lỗi cú pháp. Điều này trùng khớp với khuyến nghị của Python PEP8 về việc ưu tiên khoảng trắng hơn các tab

Đồng thời, YAML cho phép bạn tận dụng cú pháp khối nội tuyến thay thế mượn từ JSON. Bạn có thể viết lại cùng một tài liệu theo cách sau

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Lưu ý cách bạn có thể kết hợp các khối thụt lề và khối nội tuyến trong một tài liệu. Ngoài ra, bạn có thể đặt cả thuộc tính và giá trị của chúng trong dấu ngoặc đơn [

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

YAMLPythonDescription_______114

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

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

Đừng lo lắng nếu điều đó có vẻ khó hiểu. Dù sao thì bạn cũng sẽ muốn chỉ định các chuỗi ký tự không được trích dẫn trong YAML. Một ngoại lệ đáng chú ý là khai báo một chuỗi mà trình phân tích cú pháp có thể hiểu sai thành kiểu dữ liệu sai. Ví dụ:

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

Ba cấu trúc dữ liệu cơ bản trong YAML về cơ bản giống như trong Perl, từng là ngôn ngữ kịch bản phổ biến. Họ là những người sau đây

1. vô hướng. Các giá trị đơn giản như số, chuỗi hoặc Booleans
2. Mảng. Chuỗi vô hướng hoặc các bộ sưu tập khác
3. Băm. Mảng kết hợp, còn được gọi là bản đồ, từ điển, đối tượng hoặc bản ghi bao gồm các cặp khóa-giá trị

Bạn có thể xác định một đại lượng YAML tương tự như một đại lượng tương ứng. Đây là vài ví dụ

Kiểu dữ liệuYAMLNull

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

Bạn có thể viết các từ dành riêng trong YAML bằng chữ thườ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"
        }
    }
}

Ghi chú. Kiểu gõ ẩn trong YAML này có vẻ tiện lợi, nhưng nó giống như chơi với lửa và nó có thể gây ra sự cố nghiêm trọng trong các trường hợp cạnh. Kết quả là, YAML 1. 2 đã bỏ hỗ trợ cho một số chữ tích hợp sẵ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"
        }
    }
}

Các chuỗi trong YAML giống như danh sách Python hoặc mảng JSON. Họ sử dụng cú pháp dấu ngoặc vuông tiêu chuẩ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"
        }
    }
}

%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

Bạn có thể giữ các mục trong danh sách của mình ở cùng mức thụt đầu dòng như tên thuộc tính của chúng hoặc thêm nhiều khoảng thụt lề hơn nếu điều đó cải thiện khả năng đọc cho bạn

Cuối cùng, YAML có các giá trị băm tương tự như các đối tượng Python hoặc JavaScript. Chúng được tạo thành từ các khóa, còn được gọi là tên thuộc tính hoặc thuộc tính, theo sau là dấu hai chấm [

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

%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

Bạn vừa xác định một người, John Doe, người đã kết hôn với Jane Smith và có hai con, Bobby và Molly. Lưu ý cách danh sách trẻ em chứa các đối tượng ẩn danh, không giống như, ví dụ, người phối ngẫu được xác định theo thuộc tính có tê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"
        }
    }
}

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

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

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

Ngoài ra, bạn có thể 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"
        }
    }
}

Tài liệu YAML ở trên sẽ dịch sang từ điển Python sau

________số 8

Lưu ý cách thức, với sự trợ giúp của các thẻ YAML, trình phân tích cú pháp đã biến các giá trị thuộc tính thành các loại dữ liệu Python khác nhau, bao gồm một chuỗi, một tập hợp, một đối tượng byte, một bộ, một số phức và thậm chí là một thể hiện của lớp tùy chỉnh

Các tính năng mạnh mẽ khác của YAML là các ký tự neo và bí danh, cho phép bạn xác định một phần tử một lần và sau đó tham chiếu phần tử đó nhiều lần trong cùng một tài liệu. Các trường hợp sử dụng tiềm năng bao gồm

• Sử dụng lại địa chỉ giao hàng để lập hóa đơn
• Luân phiên các bữa ăn trong thực đơn
• Bài tập tham khảo trong chương trình đào tạo

Để khai báo một ký tự neo, mà bạn có thể coi là một biến được đặt tên, bạn sẽ sử dụng ký hiệu dấu 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"
        }
    }
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

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

Ngược lại với vô hướng dòng chảy, vô hướng khối cho phép thay đổi cách xử lý , , hoặc. 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"
        }
    }
}

Đầu tiên, tạo một tập lệnh Python mẫu để in JSON trên đầu ra tiêu chuẩn

{
    "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

Hiện tại, bạn sẽ gắn bó với PyYAML trong phần còn lại của hướng dẫn này vì nó là lựa chọn tiêu chuẩn cho hầu hết các dự án Python. Lưu ý rằng các công cụ được liệt kê trước đó—yamllint, yq và shyaml—sử dụng PyYAML dưới bề mặt

Đọc và viết tài liệu YAML đầu tiên của bạn

Giả sử bạn muốn đọc và phân tích cú pháp một email giả định đã được đăng tuần tự thành định dạng YAML và được lưu trữ trong một biến chuỗi trong Python

>>>

%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

Cách nhanh nhất để giải tuần tự hóa một đoạn YAML như vậy vào từ điển Python là thông qua hàm

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

>>>

%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

Gọi

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

Ghi chú. Trước phiên bản 6. 0 của thư viện PyYAML, cách phân tích cú pháp tài liệu YAML mặc định luôn là hàm

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

Việc giới thiệu tham số bổ sung này là một thay đổi đột phá dẫn đến nhiều lời phàn nàn từ những người bảo trì phần mềm phụ thuộc vào PyYAML. Vẫn còn một vấn đề được ghim trên kho lưu trữ GitHub của thư viện về sự không tương thích ngược này

Tại thời điểm viết hướng dẫn này, tài liệu PyYAML chính thức cũng như tài liệu đi kèm chưa được cập nhật để phản ánh cơ sở mã hiện tại và chúng chứa các ví dụ không còn hoạt động nữa

Hàm

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

>>>

%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

Một điều cần nhớ khi sử dụng các hàm tốc ký là chúng mã hóa cứng việc triển khai Python thuần túy. Nếu bạn muốn sử dụng triển khai C nhanh hơn, thì bạn phải tự viết một chút mã soạn sẵ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

Trước tiên, bạn thử nhập một trong các lớp trình tải có tiền tố là chữ C để biểu thị việc sử dụng liên kết thư viện C. Nếu thất bại, thì bạn nhập một lớp tương ứng được triển khai trong Python. Thật không may, điều này làm cho mã của bạn trông dài dòng hơn và ngăn bạn sử dụng các chức năng phím tắt được đề cập

Ghi chú. Nếu YAML của bạn chứa nhiều tài liệu, thì

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

Trước đây, bạn đã xê-ri hóa một đối tượng Python thành YAML bằng cách lạm dụng mô-đun

{
    "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 1.2
---
person:
  dateOfBirth: 1969-12-31
  firstName: John
  lastName: Doe
  married: true
  spouse:
    dateOfBirth: null  # This is a comment
    firstName: Jane
    lastName: Doe

Kết quả là một đối tượng chuỗi có thông báo email của bạn được tuần tự hóa lại thành YAML. Tuy nhiên, nó không hoàn toàn giống với YAML mà bạn đã bắt đầu với ban đầu. Như bạn có thể thấy,

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

Chọn lớp Trình tải

Nếu bạn muốn hiệu suất phân tích cú pháp tốt nhất có thể, thì bạn cần phải nhập thủ công lớp trình nạp phù hợp và chuyển nó vào hàm chung

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

Để tìm hiểu, hãy xem tổng quan cấp cao này về các bộ tải theo ý của bạn. Các mô tả ngắn gọn sẽ cung cấp cho bạn một ý tưởng chung về các lựa chọn có sẵn

Loader ClassFunctionDescription

%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

%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

%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

%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

%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

%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

%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

%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

Ba trình tải mà bạn có nhiều khả năng sử dụng nhất có các hàm tốc ký tương ứng mà bạn có thể gọi hàm này thay vì chuyển một lớp trình tải sang hàm chung chung

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

%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

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

Để biết phân tích chi tiết hơn về các tính năng được hỗ trợ bởi các lớp trình tải riêng lẻ, hãy xem bảng bên dưới

Loader ClassAnchor, AliasesYAML TagsPyYAML TagsCác loại phụ trợCác loại tùy chỉnhThực thi mã

%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

%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

%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

%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

%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

%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