YAML

Getting Started

Fundamental YAML concepts and basic syntax for beginners.

Basic Syntax

YAML fundamentals including comments, key-value pairs, and indentation rules.

Basic key-value pair

Simple key-value pairs are the foundation of YAML syntax. Keys are followed by a colon and space, then the value.

Code

1
name: John Doe
2
age: 30
3
city: New York

Execution

1
python -c "import yaml; print(yaml.safe_load(open('config.yaml')))"

Output

1
{'name': 'John Doe', 'age': 30, 'city': 'New York'}

Indentation is crucial in YAML; use spaces, not tabs.
Keys and values are separated by a colon and at least one space.

Comments in YAML

Comments begin with

Code

1
# This is a comment
2
name: John Doe  # inline comment
3
age: 30
4
# Another comment
5
city: New York

Execution

1
python -c "import yaml; print(yaml.safe_load(open('config.yaml')))"

Output

1
{'name': 'John Doe', 'age': 30, 'city': 'New York'}

Comments can be placed on their own line or at the end of a line.
Use comments to document configuration intent and choices.

Data Types

Understanding YAML data types including strings, numbers, booleans, and null values.

Different data types

YAML automatically infers data types based on content. Explicitly quote strings to avoid type inference issues.

Code

1
string: "Hello World"
2
integer: 42
3
float: 3.14
4
boolean_true: true
5
boolean_false: false
6
null_value: null

Execution

1
python -c "import yaml; print(yaml.safe_load(open('types.yaml')))"

Output

1
{'string': 'Hello World', 'integer': 42, 'float': 3.14, 'boolean_true': True, 'boolean_false': False, 'null_value': None}

YAML supports strings, integers, floats, booleans, and null values.
Unquoted strings like 'true' and 'false' are parsed as booleans.

Quoted strings

Quoting forces YAML to treat values as strings. Single and double quotes work similarly in YAML.

Code

1
single_quoted: 'hello'
2
double_quoted: "world"
3
unquoted: plain text
4
number_as_string: '42'

Execution

1
python -c "import yaml; print(yaml.safe_load(open('quotes.yaml')))"

Output

1
{'single_quoted': 'hello', 'double_quoted': 'world', 'unquoted': 'plain text', 'number_as_string': '42'}

Quote numbers if you want them treated as strings.
Unquoted strings are converted based on content interpretation.

Comments

How to use comments effectively in YAML files for documentation and clarity.

Comment placement and styles

Comments provide documentation without affecting the parsed data structure.

Code

1
# Top-level comment explaining the file
2
# This configuration defines application settings
3

4
app:
5
  name: MyApp  # The application name
6
  version: 1.0  # Version number
7
  # Debug mode settings
8
  debug: false

Execution

1
python -c "import yaml; print(yaml.safe_load(open('comments.yaml')))"

Output

1
{'app': {'name': 'MyApp', 'version': 1.0, 'debug': False}}

Comments are ignored during parsing and do not appear in the output.
Use comments to explain the purpose of configuration values.

Documenting complex structures

Comments help explain the purpose of configuration sections and individual settings.

Code

1
# Database connection settings
2
database:
3
  # Connection string for PostgreSQL
4
  host: localhost
5
  port: 5432  # Standard PostgreSQL port
6
  # Credentials for authentication
7
  username: admin
8
  password: secret

Execution

1
python -c "import yaml; print(yaml.safe_load(open('db_config.yaml')))"

Output

1
{'database': {'host': 'localhost', 'port': 5432, 'username': 'admin', 'password': 'secret'}}

Group related comments with the sections they document.
Keep comments concise and focused on the 'why', not the 'what'.

Data Structures

Understanding dictionaries, lists, and mixed nested structures in YAML.

Dictionaries

Creating and using dictionaries (key-value mappings) in YAML.

Simple dictionary

A dictionary is created by indenting key-value pairs under a parent key.

Code

1
person:
2
  name: John Doe
3
  age: 30
4
  email: john@example.com

Execution

1
python -c "import yaml; print(yaml.safe_load(open('person.yaml')))"

Output

1
{'person': {'name': 'John Doe', 'age': 30, 'email': 'john@example.com'}}

Use consistent indentation to define dictionary membership.
Each key-value pair must have the same indentation level.

Nested dictionaries

Dictionaries can be nested multiple levels deep by continuing to indent.

Code

1
user:
2
  profile:
3
    name: Alice
4
    contact:
5
      email: alice@example.com
6
      phone: "555-1234"
7
  settings:
8
    theme: dark
9
    notifications: true

Execution

1
python -c "import yaml; print(yaml.safe_load(open('nested.yaml')))"

Output

1
{'user': {'profile': {'name': 'Alice', 'contact': {'email': 'alice@example.com', 'phone': '555-1234'}}, 'settings': {'theme': 'dark', 'notifications': True}}}

Each level of nesting increases indentation by 2 spaces.
Maintain consistent indentation to correctly represent hierarchy.

Lists

Creating and using lists (arrays) in YAML.

Simple list

Lists are created using dashes (-) followed by a space, with each item on a new line.

Code

1
fruits:
2
  - apple
3
  - banana
4
  - orange
5
  - grape

Execution

1
python -c "import yaml; print(yaml.safe_load(open('fruits.yaml')))"

Output

1
{'fruits': ['apple', 'banana', 'orange', 'grape']}

Each list item starts with a dash and a space.
All list items must have the same indentation level.

Nested lists

Lists can contain other lists, creating multi-dimensional structures.

Code

Execution

1
python -c "import yaml; print(yaml.safe_load(open('matrix.yaml')))"

Output

1
{'matrix': [[1, 2, 3], [4, 5, 6], [7, 8, 9]]}

Nested lists use additional indentation and dashes.
Readability decreases with deep nesting; simplify when possible.

Mixed Structures

Combining dictionaries and lists in complex nested structures.

List of dictionaries

Each list item is a dictionary with multiple key-value pairs. The dash precedes the first key of each dictionary.

Code

1
employees:
2
  - name: Alice
3
    department: Engineering
4
    salary: 80000
5
  - name: Bob
6
    department: Sales
7
    salary: 60000
8
  - name: Carol
9
    department: Engineering
10
    salary: 85000

Execution

1
python -c "import yaml; print(yaml.safe_load(open('employees.yaml')))"

Output

1
{'employees': [{'name': 'Alice', 'department': 'Engineering', 'salary': 80000}, {'name': 'Bob', 'department': 'Sales', 'salary': 60000}, {'name': 'Carol', 'department': 'Engineering', 'salary': 85000}]}

The dash and first key are at the same indentation level.
Subsequent keys are indented to align under the first key.

Dictionary with list values

Dictionary values can be lists. The list starts on the next indented line with dashes.

Code

1
project:
2
  name: MyProject
3
  team:
4
    - Alice
5
    - Bob
6
    - Carol
7
  tools:
8
    - Python
9
    - Docker
10
    - Kubernetes

Execution

1
python -c "import yaml; print(yaml.safe_load(open('project.yaml')))"

Output

1
{'project': {'name': 'MyProject', 'team': ['Alice', 'Bob', 'Carol'], 'tools': ['Python', 'Docker', 'Kubernetes']}}

List values are indented further than the parent key.
Each list item is indented consistently.

Advanced Syntax

Exploring advanced YAML features like multiline strings and special characters.

Multiline Strings

Handling strings that span multiple lines using block scalars.

Literal block scalar

The pipe (|) operator preserves newlines and formatting within the string.

Code

1
description: |
2
  This is a literal block scalar.
3
  Newlines are preserved exactly as written.
4
  Each line becomes a separate line in the string.

Execution

1
python -c "import yaml; print(repr(yaml.safe_load(open('literal.yaml'))['description']))"

Output

1
'This is a literal block scalar.\nNewlines are preserved exactly as written.\nEach line becomes a separate line in the string.\n'

Literal blocks preserve all whitespace and newlines.
Content must be indented below the pipe character.

Folded block scalar

The greater-than (>) operator folds lines into a single line, preserving paragraph breaks.

Code

1
summary: >
2
  This is a folded block scalar.
3
  Line breaks are converted to spaces.
4
  Paragraphs are separated by blank lines.

Execution

1
python -c "import yaml; print(repr(yaml.safe_load(open('folded.yaml'))['summary']))"

Output

1
'This is a folded block scalar. Line breaks are converted to spaces. Paragraphs are separated by blank lines.\n'

Folded blocks join lines with spaces.
Blank lines create paragraph separations.

Special Strings

Handling quoted strings, escape sequences, and special characters.

Quoted strings with escapes

Double and single quotes allow special characters and escape sequences within strings.

Code

1
single: 'It''s a string'
2
double: "Line 1\nLine 2"
3
path: "C:\\Users\\name\\file.txt"
4
colon: "key: value"

Execution

1
python -c "import yaml; d = yaml.safe_load(open('quoted.yaml')); print({k: repr(v) for k, v in d.items()})"

Output

1
{'single': "It's a string", 'double': 'Line 1\nLine 2', 'path': 'C:\\Users\\name\\file.txt', 'colon': 'key: value'}

Single quotes preserve most escapes literally; double quotes interpret them.
Escape special characters like colons by quoting the entire string.

Escape sequences

Escape sequences in double-quoted strings are interpreted as special characters.

Code

1
newline: "Line 1\nLine 2"
2
tab: "Column1\tColumn2"
3
quote: "She said \"hello\""
4
backslash: "Path: C:\\\\folder"

Execution

1
python -c "import yaml; d = yaml.safe_load(open('escapes.yaml')); print({k: repr(v) for k, v in d.items()})"

Output

1
{'newline': 'Line 1\nLine 2', 'tab': 'Column1\tColumn2', 'quote': 'She said "hello"', 'backslash': 'Path: C:\\folder'}

Common escapes include \\n (newline), \\t (tab), \\\\ (backslash).
Single quotes do not interpret most escape sequences.

Anchors and Aliases

Creating references to reuse content within a YAML file.

Basic anchor and alias

Anchors (&) mark content for reference, and aliases (*) reuse that content with the merge key (<<).

Code

1
defaults: &default_settings
2
  timeout: 30
3
  retries: 3
4
  debug: false
5

6
api_config:
7
  <<: *default_settings
8
  endpoint: https://api.example.com

Execution

1
python -c "import yaml; print(yaml.safe_load(open('anchor.yaml')))"

Output

1
{'defaults': {'timeout': 30, 'retries': 3, 'debug': False}, 'api_config': {'timeout': 30, 'retries': 3, 'debug': False, 'endpoint': 'https://api.example.com'}}

Anchors are defined with & followed by a name.
Aliases reference anchors with * followed by the same name.

Multiple alias usage

The same anchor can be referenced multiple times by different aliases throughout the file.

Code

1
common: &common_values
2
  version: 1.0
3
  author: 'Mohammad Abu Mattar'
4

5
service1:
6
  <<: *common_values
7
  name: Service One
8

9
service2:
10
  <<: *common_values
11
  name: Service Two

Execution

1
python -c "import yaml; print(yaml.safe_load(open('multi_alias.yaml')))"

Output

1
{'common': {'version': 1.0, 'author': 'Admin'}, 'service1': {'version': 1.0, 'author': 'Admin', 'name': 'Service One'}, 'service2': {'version': 1.0, 'author': 'Admin', 'name': 'Service Two'}}

Each alias creates an independent copy of the anchored content.
Anchors must be defined before they are used with aliases.

Advanced Features

Exploring anchors, aliases, and merge keys for configuration inheritance.

Anchors

Defining and naming anchors for content reuse.

Defining anchors

Anchors are defined using & followed by a name, marking content for later reference.

Code

1
default_env: &default_env
2
  LOG_LEVEL: info
3
  DEBUG: false
4

5
db_config: &db_defaults
6
  host: localhost
7
  port: 5432
8
  pool_size: 10

Execution

1
python -c "import yaml; print(yaml.safe_load(open('anchors.yaml')))"

Output

1
{'default_env': {'LOG_LEVEL': 'info', 'DEBUG': False}, 'db_config': {'host': 'localhost', 'port': 5432, 'pool_size': 10}}

Anchor names should be descriptive and follow naming conventions.
Anchors mark the exact structure they're placed on (dictionaries or values).

Named anchors for inheritance

Named anchors allow defining base configurations that can be inherited by multiple services.

Code

1
base_service: &base
2
  image: ubuntu:20.04
3
  restart_policy: always
4
  environment:
5
    APP_ENV: production
6

7
web_service:
8
  <<: *base
9
  ports:
10
    - 80:8080

Execution

1
python -c "import yaml; print(yaml.safe_load(open('base.yaml')))"

Output

1
{'base_service': {'image': 'ubuntu:20.04', 'restart_policy': 'always', 'environment': {'APP_ENV': 'production'}}, 'web_service': {'image': 'ubuntu:20.04', 'restart_policy': 'always', 'environment': {'APP_ENV': 'production'}, 'ports': ['80:8080']}}

Anchors are local to the file and cannot be referenced across files.
The merge key (<<) combines anchored content with additional properties.

Aliases

Using aliases to reference anchored content.

Using aliases

Aliases (asterisk) reference anchored content, creating independent copies in each location.

Code

1
shared_config: &shared
2
  timeout: 30
3
  retries: 3
4

5
api_service:
6
  name: API
7
  config: *shared
8

9
worker_service:
10
  name: Worker
11
  config: *shared

Execution

1
python -c "import yaml; d = yaml.safe_load(open('alias_usage.yaml')); import json; print(json.dumps(d, indent=2))"

Output

1
{
2
  "shared_config": {"timeout": 30, "retries": 3},
3
  "api_service": {"name": "API", "config": {"timeout": 30, "retries": 3}},
4
  "worker_service": {"name": "Worker", "config": {"timeout": 30, "retries": 3}}
5
}

An alias creates a new copy of the anchored content, not a reference.
Aliases must refer to previously defined anchors.

Multiple references to same anchor

A single anchor can be referenced multiple times throughout the file via separate aliases.

Code

1
defaults: &defaults
2
  cache: redis
3
  cache_ttl: 3600
4

5
app_settings:
6
  cache_settings: *defaults
7

8
service_settings:
9
  cache_settings: *defaults
10

11
worker_settings:
12
  cache_settings: *defaults

Execution

1
python -c "import yaml; print(yaml.safe_load(open('multi_ref.yaml')))"

Output

1
{'defaults': {'cache': 'redis', 'cache_ttl': 3600}, 'app_settings': {'cache_settings': {'cache': 'redis', 'cache_ttl': 3600}}, 'service_settings': {'cache_settings': {'cache': 'redis', 'cache_ttl': 3600}}, 'worker_settings': {'cache_settings': {'cache': 'redis', 'cache_ttl': 3600}}}

Each alias reference creates an independent copy of the content.
Modifying one copy does not affect others.

Merge Keys

Using the merge key (<<) to inherit and extend configurations.

Using merge key for inheritance

The merge key (<<) incorporates anchored content and allows overriding specific values.

Code

1
defaults: &defaults
2
  timeout: 30
3
  retries: 3
4
  debug: false
5

6
production:
7
  <<: *defaults
8
  environment: production
9
  debug: false
10

11
staging:
12
  <<: *defaults
13
  environment: staging
14
  debug: true

Execution

1
python -c "import yaml; print(yaml.safe_load(open('merge_inherit.yaml')))"

Output

1
{'defaults': {'timeout': 30, 'retries': 3, 'debug': False}, 'production': {'timeout': 30, 'retries': 3, 'debug': False, 'environment': 'production'}, 'staging': {'timeout': 30, 'retries': 3, 'debug': True, 'environment': 'staging'}}

The merge key must be used with an alias.
Values defined after the merge key override inherited values.

Multiple merge keys

Multiple anchors can be merged using a list syntax [*anchor1, *anchor2].

Code

1
base: &base
2
  port: 8080
3
  timeout: 30
4

5
logging: &logging
6
  log_level: info
7
  log_file: /var/log/app.log
8

9
service:
10
  <<: [*base, *logging]
11
  name: MyService
12
  replicas: 3

Execution

1
python -c "import yaml; print(yaml.safe_load(open('multi_merge.yaml')))"

Output

1
{'base': {'port': 8080, 'timeout': 30}, 'logging': {'log_level': 'info', 'log_file': '/var/log/app.log'}, 'service': {'port': 8080, 'timeout': 30, 'log_level': 'info', 'log_file': '/var/log/app.log', 'name': 'MyService', 'replicas': 3}}

When multiple anchors are merged, keys from later anchors override earlier ones if there are conflicts.

Collections and Nesting

Deep nesting, complex hierarchies, and organizing multi-level structures.

Nested Dictionaries

Creating and managing deeply nested dictionary structures.

Simple nested dictionaries

Nested dictionaries use increasing indentation to show hierarchical relationships.

Code

1
company:
2
  name: TechCorp
3
  location: New York
4
  departments:
5
    engineering:
6
      team_lead: Alice
7
      members: 10
8
    sales:
9
      team_lead: Bob
10
      members: 5

Execution

1
python -c "import yaml; d = yaml.safe_load(open('nested_dict.yaml')); print(d['company']['departments']['engineering'])"

Output

1
{'team_lead': 'Alice', 'members': 10}

Each indentation level represents one level of nesting.
Maintain consistent indentation (typically 2 spaces per level).

Deeply nested structure

Multiple levels of nesting create a clear hierarchy for complex configurations.

Code

1
system:
2
  server:
3
    production:
4
      database:
5
        primary:
6
          host: prod-db-1.example.com
7
          port: 5432
8
          credentials:
9
            username: prod_user
10
            password: secret123

Execution

1
python -c "import yaml; d = yaml.safe_load(open('deep_nest.yaml')); print(d['system']['server']['production']['database']['primary']['credentials'])"

Output

1
{'username': 'prod_user', 'password': 'secret123'}

Keep nesting reasonable (3-4 levels) for readability.
Consider flattening deeply nested structures using descriptive keys.

Nested Lists

Creating and managing lists containing other lists.

List of lists

Nested lists use additional dashes and indentation to represent multi-dimensional arrays.

Code

1
grid:
2
  - - North
3
    - South
4
    - East
5
    - West
6
  - - Up
7
    - Down
8
    - Left
9
    - Right

Execution

1
python -c "import yaml; print(yaml.safe_load(open('grid.yaml')))"

Output

1
{'grid': [['North', 'South', 'East', 'West'], ['Up', 'Down', 'Left', 'Right']]}

Each nesting level adds one dash and indentation.
Readability decreases with excessive nesting.

List with mixed nesting

Nested lists can represent matrices or multi-dimensional structures.

Code

1
data:
2
  - - 1
3
    - 2
4
  - - 3
5
    - 4
6
  - - 5
7
    - 6

Execution

1
python -c "import yaml; print(yaml.safe_load(open('mixed_nest.yaml')))"

Output

1
{'data': [[1, 2], [3, 4], [5, 6]]}

Consistent indentation is critical for correct parsing.

Complex Nesting

Combining lists and dictionaries in intricate structures.

List of objects with nested values

Complex structures combine list items (projects) with nested list values (tasks), each containing dictionaries.

Code

1
projects:
2
  - name: ProjectA
3
    status: active
4
    tasks:
5
      - name: Task 1
6
        assigned_to: Alice
7
        priority: high
8
      - name: Task 2
9
        assigned_to: Bob
10
        priority: medium
11
  - name: ProjectB
12
    status: planning
13
    tasks:
14
      - name: Task 3
15
        assigned_to: Carol
16
        priority: high

Execution

1
python -c "import yaml; d = yaml.safe_load(open('projects.yaml')); print(d['projects'][0]['tasks'])"

Output

1
[{'name': 'Task 1', 'assigned_to': 'Alice', 'priority': 'high'}, {'name': 'Task 2', 'assigned_to': 'Bob', 'priority': 'medium'}]

The dash for list items aligns with the first key of each item.
Nested lists use additional indentation and dashes.

Hierarchical configuration

Hierarchical structures can represent multi-level configurations with lists of objects containing nested data.

Code

1
environments:
2
  - name: development
3
    services:
4
      - name: api
5
        port: 3000
6
        env_vars:
7
          DEBUG: 'true'
8
          LOG_LEVEL: debug
9
      - name: db
10
        port: 5432
11
        env_vars:
12
          POSTGRES_DB: dev_db
13
  - name: production
14
    services:
15
      - name: api
16
        port: 8080
17
        env_vars:
18
          DEBUG: 'false'
19
          LOG_LEVEL: error

Execution

1
python -c "import yaml; d = yaml.safe_load(open('envs.yaml')); print(len(d['environments'][0]['services']))"

Output

1
2

Maintain consistent indentation throughout complex nesting.
Document structure clearly to aid understanding.

Practical Examples

Real-world YAML usage, best practices, and solutions.

Configuration Files

Using YAML for application and service configuration.

Application configuration

Application configurations define settings for the entire application, including database and logging.

Code

1
app:
2
  name: MyApplication
3
  version: 1.0.0
4
  port: 8000
5

6
database:
7
  host: localhost
8
  port: 5432
9
  name: myapp_db
10
  credentials:
11
    username: app_user
12
    password: secure_pwd
13

14
logging:
15
  level: info
16
  output: stdout

Execution

1
python -c "import yaml; conf = yaml.safe_load(open('app.yaml')); print(f\"App: {conf['app']['name']}, DB: {conf['database']['name']}\")"

Output

1
App: MyApplication, DB: myapp_db

Group related settings under common keys.
Use meaningful section names for clarity.

Docker Compose service

Docker Compose YAML defines multi-container services with images, ports, volumes, and environment variables.

Code

1
services:
2
  web:
3
    image: nginx:latest
4
    ports:
5
      - "80:80"
6
    volumes:
7
      - ./html:/usr/share/nginx/html
8
    environment:
9
      NGINX_ENV: production
10
  db:
11
    image: postgres:13
12
    environment:
13
      POSTGRES_DB: mydb
14
      POSTGRES_PASSWORD: secret
15
    ports:
16
      - "5432:5432"

Execution

docker-compose config

Output

services defined and validated

Each service is a list item with specific configuration.
Environment variables are key-value pairs in a dictionary.

Best Practices

Following YAML best practices for readability and maintainability.

Proper indentation and structure

Proper indentation, comments, and consistent structure improve readability and maintainability.

Code

1
# Database configuration - consistent spacing and indentation
2
database:
3
  primary:
4
    host: db-primary.example.com
5
    port: 5432
6
    credentials:
7
      username: admin
8
      password: secure_password
9
  replica:
10
    host: db-replica.example.com
11
    port: 5432
12
    credentials:
13
      username: replica_user
14
      password: replica_password

Execution

1
python -c "import yaml; print(yaml.safe_load(open('db_config.yaml')))"

Output

1
proper YAML structure loaded successfully

Use 2 spaces for each indentation level consistently.
Include comments explaining configuration purpose.

Avoiding common mistakes

Clear naming, proper structure, and meaningful comments make YAML files more maintainable.

Code

1
# Good: Clear naming and structure
2
services:
3
  - name: api_service
4
    port: 8000
5
    timeout: 30
6
  - name: worker_service
7
    port: 8001
8
    timeout: 60
9

10
# Bad: Unclear abbreviations and comments
11
# svc:
12
#   - nm: api  # Too abbreviated
13
#     p: 8000

Execution

1
python -c "import yaml; d = yaml.safe_load(open('good.yaml')); print(f\"Services: {[s['name'] for s in d['services']]}\")"

Output

1
Services: ['api_service', 'worker_service']

Use full, descriptive names instead of abbreviations.
Avoid overly clever or minimal formatting.

Validation and Use

Parsing YAML, validating syntax, and loading in different languages.

Parsing YAML in Python

Python's `yaml` module (PyYAML) can parse YAML files into Python dictionaries.

Code

1
application:
2
  name: PythonApp
3
  debug: true
4
  port: 5000
5
  database:
6
    host: localhost
7
    port: 5432

Execution

1
import yaml
2
with open('app.yaml', 'r') as f:
3
  config = yaml.safe_load(f)
4
print(config['application']['name'])
5
print(config['application']['database']['host'])

Output

1
PythonApp
2
localhost

Always use `safe_load()` to avoid executing arbitrary code.
Handle file exceptions for missing or invalid YAML files.

YAML validation

YAML validation tools check for syntax errors and formatting issues before using configuration.

Code

# Using yamllint for syntax validation
yamllint config.yaml

# Or validating with Python
python -c "import yaml; yaml.safe_load(open('config.yaml'))"

Execution

yamllint config.yaml

Output

config.yaml is valid

Use yamllint for comprehensive linting and style checking.
Python's `safe_load()` provides basic syntax validation.

YAML

Getting Started

Basic Syntax

Accessibility

Best Practices

Common Errors

Advanced Notes

Keywords

Basic key-value pair

Comments in YAML

Data Types

Accessibility

Best Practices

Common Errors

Keywords

Different data types

Quoted strings

Comments

Accessibility

Best Practices

Common Errors

Keywords

Comment placement and styles

Documenting complex structures

Data Structures

Dictionaries

Accessibility

Best Practices

Common Errors

Keywords

Simple dictionary

Nested dictionaries

Lists

Accessibility

Best Practices

Common Errors

Keywords

Simple list

Nested lists

Mixed Structures

Accessibility

Best Practices

Common Errors

Keywords

List of dictionaries

Dictionary with list values

Advanced Syntax

Multiline Strings

Accessibility

Best Practices

Common Errors

Keywords

Literal block scalar

Folded block scalar

Special Strings

Accessibility

Best Practices

Common Errors

Keywords

Quoted strings with escapes

Escape sequences

Anchors and Aliases

Accessibility

Best Practices

Common Errors

Keywords

Basic anchor and alias

Multiple alias usage

Advanced Features

Anchors

Accessibility

Best Practices

Common Errors

Keywords

Defining anchors

Named anchors for inheritance

Aliases

Accessibility

Best Practices

Common Errors