Mundo ng Python Programming

Gabay sa YAML gamit ang Python: Config at Custom Tag

Manipulasyon at Pagsusuri ng Datos
目次

1. Ano ang YAML?

Pangkalahatang-ideya ng YAML

Ang YAML (YAML Ain’t Markup Language) ay isa sa mga format ng serialisasyon ng data, na malawakang ginagamit para magpahayag ng istrukturadong data. Katulad ito ng JSON at XML, ngunit ang tampok ng YAML ay ang pagiging simple at mataas na nababasa. Lalo na, dahil maaaring ipakita ang hierarchy gamit ang indentation, ito ay isang malaking bentahe dahil madaling basahin ng tao.

Pagkakaiba sa JSON at XML

Ang JSON at XML ay mga format din para ilarawan ang data, ngunit ang YAML ay may kaunting redundant na mga simbolo kumpara sa mga ito, kaya simple at madaling maintindihan. Halimbawa, ang JSON ay madalas gumagamit ng mga braces {} at kuwit ,, na maaaring magpababa ng readability lalo na kapag humahawak ng malalaking data. Sa kabilang banda, ang YAML ay nagpapakita ng istruktura gamit ang indentation, na nagbibigay ng visual na madaling maunawaan ang hierarchy ng data.

Magandang Pagkakatugma sa Python

Ang syntax ng Python ay may katangiang gumagamit ng indentation para ipakita ang mga block, kaya ito ay tugma sa format ng YAML. Bukod pa rito, sa pamamagitan ng library na “PyYAML” para sa Python, madaling magbasa at magsulat ng mga YAML file, kaya madalas itong ginagamit bilang configuration file.

2. Paraan ng pagbabasa at pagsulat ng YAML file gamit ang Python

Pagbabasa ng YAML file

Upang basahin ang YAML file gamit ang Python, una i-install ang library na “PyYAML” at gamitin ang function na yaml.safe_load(). Ang function na ito ay nagko-convert ng YAML data sa mga dictionary o list ng Python sa isang ligtas na paraan. Narito ang isang pangunahing halimbawa ng pagbasa.
import yaml

# Buksan ang YAML file at basahin ang nilalaman
with open('config.yaml', 'r') as file:
    data = yaml.safe_load(file)

print(data)
Ang code na ito ay nagbabasa ng data mula sa YAML file at tinatrato ito bilang dictionary ng Python. Halimbawa, basahin natin ang sumusunod na YAML file.
database:
  host: localhost
  port: 3306
Sa kasong ito, makakakuha ka ng dictionary sa Python tulad nito.
{'database': {'host': 'localhost', 'port': 3306}}

Pagsulat ng YAML file

Upang isulat ang data ng Python sa format na YAML, gamitin ang function na yaml.dump(). Sa susunod na halimbawa, sinusulat natin ang dictionary ng Python sa isang YAML file.
import yaml

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

with open('output.yaml', 'w') as file:
    yaml.dump(data, file)
Sa code na ito, sine-save ang dictionary data sa file na tinatawag na output.yaml. Bilang resulta, maglalabas ito ng data sa format na YAML tulad ng sumusunod.
age: 30
city: New York
name: John Doe

Paghawak ng wikang Hapon

Kapag humahawak ng Japanese sa YAML, mahalagang tukuyin ang opsyon na allow_unicode=True upang maiwasan ang garbled na teksto. Ito ay nagsisiguro na tama ang pagpapakita ng Japanese sa loob ng YAML file.
yaml.dump(data, file, allow_unicode=True)

3. Mga Advanced na Operasyon sa YAML

Paglikha ng Custom na Tag

Ang YAML ay hindi lamang kayang mag-serialize at deserialize ng mga pangunahing uri ng data (tulad ng listahan, diksyunaryo, atbp.), kundi pati na rin ng mga Python object. Sa kasong ito, gumagamit ng custom na tag. Narito ang isang halimbawa kung paano i-save ang isang Python class sa format na YAML.
import yaml

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

def person_representer(dumper, data):
    return dumper.represent_mapping('!Person', {'name': data.name, 'age': data.age})

def person_constructor(loader, node):
    values = loader.construct_mapping(node)
    return Person(values['name'], values['age'])

yaml.add_representer(Person, person_representer)
yaml.add_constructor('!Person', person_constructor)

# I-convert ang object sa YAML at i-save
person = Person('Alice', 25)
with open('person.yaml', 'w') as file:
    yaml.dump(person, file)

# I-reconstruct ang object mula sa YAML file
with open('person.yaml', 'r') as file:
    loaded_person = yaml.load(file, Loader=yaml.FullLoader)
Sa ganitong paraan, maaari mong i-save ang mga Python object sa YAML gamit ang custom na format, at magamit muli ito sa hinaharap.

Pagpapanatili ng Order

Sa PyYAML, hindi pinapanatili ang order ng mga dictionary bilang default, kaya kung mahalaga ang order, inirerekomenda ang paggamit ng ruamel.yaml. Sa ruamel.yaml, pinananatili ang order ng mga susi ng dictionary, kaya ito ay kapaki-pakinabang kapag humahawak ng mga configuration file na nangangailangan ng tamang order.

4. Halimbawa ng Paggamit ng YAML: Pamamahala ng Config File

Kaginhawaan ng YAML bilang Config File

YAML ay malawakang ginagamit bilang config file. Lalo na sa mga Python application, ginagamit ito bilang pinakamainam na format para pamahalaan ang configuration data. Ito ay dahil madaling basahin ng tao ang YAML at madaling maunawaan ang hierarchical na istruktura visually. Halimbawa, impormasyon ng koneksyon sa database at mga setting ng log ng application, atbp., ang YAML ay angkop para sa pamamahala ng komplikadong configuration nang sabay-sabay.
database:
  host: localhost
  port: 3306
  username: user
  password: pass

logging:
  level: DEBUG
  file: /var/log/app.log
Tulad ng nasa itaas, maaaring ilahad ang maraming setting nang maikli, at ito ay madaling maunawaan visually.

Halimbawa ng Paggamit ng YAML sa Totoong Proyekto

Ang YAML ay ginagamit sa iba’t ibang proyekto tulad ng Python frameworks na Django at Flask, CI tool na CircleCI, at container orchestration tool na Kubernetes. Sa mga proyektong ito, kadalasan itong ginagamit para sa configuration management at pagde-define ng environment variables. Halimbawa ng Paggamit ng YAML sa Django: Sa mga Django project, maaaring gamitin ang YAML para basahin ang external config file, na nagpapasimple ng deployment at environment setup. Sa paggamit ng YAML bilang config file, maaaring flexible na pamahalaan ang iba’t ibang setting depende sa development o production environment.
import yaml

with open('config.yaml', 'r') as file:
    config = yaml.safe_load(file)

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': config['database']['name'],
        'USER': config['database']['username'],
        'PASSWORD': config['database']['password'],
        'HOST': config['database']['host'],
        'PORT': config['database']['port'],
    }
}

Paghahambing sa JSON at XML

Ang YAML ay mas madaling gamitin bilang config file kumpara sa JSON at XML. Ang JSON ay gumagamit ng braces at commas, na nagiging mahirap basahin kapag mahaba. Ang XML naman ay nangangailangan ng opening at closing tags kaya nagiging redundant. Samantalang ang YAML ay gumagamit ng indentation para ipakita ang hierarchy, kaya madaling maunawaan ang nilalaman ng config file. Paghahambing ng JSON at YAML:
{
  "database": {
    "host": "localhost",
    "port": 3306,
    "username": "user",
    "password": "pass"
  },
  "logging": {
    "level": "DEBUG",
    "file": "/var/log/app.log"
  }
}
database:
  host: localhost
  port: 3306
  username: user
  password: pass

logging:
  level: DEBUG
  file: /var/log/app.log
Malinaw na ang YAML ay mas simple at madaling basahin kumpara sa JSON.

5. Pag-troubleshoot at Pag-handle ng Error

Mga Karaniwang Error at ang Kanilang Solusyon

Isa sa mga karaniwang error na nangyayari kapag humahawak ng mga YAML file ay ang mga problemang tulad ng “walang file” o “hindi tamang format ang file”. Maaaring maiwasan ang mga error na ito sa pamamagitan ng pag-implement ng angkop na pag-handle ng error. Halimbawa, kung nagkakaroon ng parse error sa YAML file, maaaring mahuli ang exception gamit ang yaml.YAMLError. Bilang tugon sa kaso na walang file, maaaring i-handle ang FileNotFoundError upang maipakita sa user ang angkop na mensahe.
import yaml

def load_yaml(file_path):
    try:
        with open(file_path, 'r') as file:
            data = yaml.safe_load(file)
    except FileNotFoundError:
        print(f"Error: The file {file_path} does not exist.")
        return None
    except yaml.YAMLError as e:
        print(f"Error: Failed to parse YAML file. {e}")
        return None
    return data

config = load_yaml('config.yaml')
if config:
    print(config)

Pinakamahusay na Praktis sa Pag-handle ng Error

  1. Pag-check ng Pag-iral ng File: Tiyaking umiiral ang file, at kung wala, magpakita ng mensahe ng error.
  2. Pag-handle ng Parse Error: Kapag mali ang syntax ng YAML, hulihin ang error at magbigay ng detalyadong mensahe.
  3. Pag-log: Kapag may problema, i-record ang mensahe ng error sa log file upang magamit sa pag-troubleshoot mamaya.

6. Buod

Ang YAML ay isang format ng data serialization na kilala sa pagiging simple at mataas na nababasa ng tao. Ang pagbabasa at pagsulat ng YAML sa Python ay napakadali, at nagdadala ng maraming benepisyo sa pamamahala ng mga configuration file. Posible rin ang mga advanced na operasyon tulad ng custom na mga tag at serialization ng mga klase, pati na ang pagpapanatili ng order, at sa pamamagitan ng paggamit ng mga ito, makakamit ang mas flexible at makapangyarihang pamamahala ng configuration ng aplikasyon. Ang paggamit ng YAML ay hindi lamang limitado sa pamamahala ng configuration file, kundi malawak din itong ginagamit bilang format ng pag-iimbak ng data, at inaasahan na patuloy na gagamitin sa iba’t ibang proyekto sa hinaharap.