Hari Saya Mengautomasikan Pemeriksaan Medan XML dengan Python

Semuanya bermula apabila saya diberi tugas untuk menyemak beberapa fail XML untuk medan yang hilang. Pasukan perlu memastikan semua medan wajib ada dalam fail ini sebelum kami boleh meneruskan langkah seterusnya. Bunyi cukup mudah, bukan? Baiklah, tidak begitu.

Saya membuka fail XML pertama, mengimbas melalui sifat, mencari medan yang diperlukan secara manual dan menanda kotak semasa saya pergi. Seperti yang anda jangkakan, ia menjadi letih dengan cepat. Selepas hanya beberapa minit dalam satu fail, mata saya berkaca-kaca, dan saya tidak mempunyai keyakinan sebenar bahawa saya tidak terlepas sesuatu yang penting. Maksud saya, XML boleh menjadi sangat cerewet dan satu medan yang hilang boleh menyebabkan masalah besar.

Saya mengalami perasaan gerun yang meruncing ini, kerana mengetahui saya masih mempunyai banyak fail untuk dilalui. Dan, sudah tentu, ketepatan adalah kritikal-satu medan yang hilang yang diabaikan boleh menyebabkan bencana. Oleh itu, selepas menarik nafas panjang dan seketika untuk berfikir, saya memutuskan bahawa perlu ada cara yang lebih baik untuk menangani perkara ini.

Epiphany: Automasi untuk Menyelamat

Sebagai seorang pengaturcara, saya mempunyai idea: mengapa tidak menulis skrip untuk melakukan kerja membosankan ini untuk saya? Daripada menyemak setiap medan secara manual, saya boleh mengautomasikannya dan menjamin ketepatan sambil menjimatkan kewarasan saya dalam proses itu. Sudah tiba masanya untuk memanfaatkan kuasa Python.

Konsepnya mudah:

• Saya mempunyai senarai medan yang diperlukan disimpan dalam fail JSON, yang menjadikan skrip sangat boleh digunakan semula dan boleh disesuaikan. Dengan menggunakan pendekatan ini, skrip boleh memproses fail XML lain dengan mudah, walaupun dengan struktur yang berbeza. Anda hanya perlu mengemas kini fail JSON dengan medan yang diperlukan untuk sebarang format XML baharu, membenarkan skrip melaraskan secara automatik kepada skema XML yang berbeza tanpa pengubahsuaian.
• Saya perlu menulis skrip Python yang akan melalui setiap fail XML, semak jika mana-mana medan yang diperlukan tiada, dan kemudian keluarkan ringkasan.

Dengan cara ini, saya dapat dengan mudah mengenal pasti berapa kali medan hilang dalam setiap fail, bilangan sifat yang ada dan mendapatkan laporan yang jelas—tiada lagi pemeriksaan manual yang tidak berkesudahan, tiada lagi kesilapan. Begini cara saya mendekatinya.

Menulis Skrip Utiliti

Perkara pertama dahulu, saya perlu memuatkan senarai medan yang diperlukan. Ini disimpan dalam fail JSON di bawah kekunci required_fields, jadi saya menulis fungsi untuk membaca fail ini:

import os
import json
import xml.etree.ElementTree as ET

def load_required_fields(json_file_path):
    with open(json_file_path, 'r') as file:
        data = json.load(file)
        return data.get("required_fields", [])

Kemudian datang keajaiban sebenar. Saya menulis fungsi untuk menghuraikan setiap fail XML, mengulangi sifatnya dan menyemak kehadiran setiap medan yang diperlukan:

def check_missing_fields(file_path, required_fields):
    # Load the XML file
    tree = ET.parse(file_path)
    root = tree.getroot()

    # Initialize variables to store counts and track missing fields
    total_properties = 0
    missing_fields_counts = {field: 0 for field in required_fields}

    # Loop through each property to check for missing fields
    for property in root.findall('.//property'):
        total_properties += 1
        for field in required_fields:
            # Use the find() method to look for direct children of the property element
            element = property.find(f'./{field}')
            # Check if the field is completely missing (not present)
            if element is None:
                missing_fields_counts[field] += 1

    # Print the results
    print('-----------------------------------------')
    print(f'File: {os.path.basename(file_path)}')
    print(f'Total number of properties: {total_properties}')
    print('Number of properties missing each field:')
    for field, count in missing_fields_counts.items():
        print(f'  {field}: {count} properties')
    print('-----------------------------------------')

Fungsi ini memuatkan fail XML, mengira bilangan sifat dan menjejaki bilangan sifat yang tiada setiap medan yang diperlukan. Fungsi ini mencetak laporan yang menunjukkan keputusan untuk setiap fail yang diproses.

Akhir sekali, saya menyusun semuanya dalam fungsi main(). Ia akan berulang ke atas semua fail XML dalam direktori tertentu dan menjalankan fungsi semakan medan pada setiap fail:

def main():
    # Directory containing XML files
    xml_dir = 'xmls'
    json_file_path = 'required_fields.json'

    # Load required fields from JSON file
    required_fields = load_required_fields(json_file_path)

    # Iterate over each file in the xmls directory
    for file_name in os.listdir(xml_dir):
        if file_name.endswith('.xml'):
            file_path = os.path.join(xml_dir, file_name)
            check_missing_fields(file_path, required_fields)

if __name__ == "__main__":
    main()

Selepas menjalankan proses, anda akan menerima ringkasan keputusan yang serupa dengan ini:

File: properties.xml
Total number of properties: 4170
Number of properties missing each field:
  Title: 0 properties
  Unit_Number: 0 properties
  Type: 0 properties
  Bedrooms: 0 properties
  Bathrooms: 0 properties
  Project: 0 properties
  Price: 0 properties
  VAT: 0 properties
  Status: 10 properties
  Area: 0 properties
  Location: 100 properties
  Latitude: 30 properties
  Longitude: 0 properties
  Apartment_Floor: 0 properties
  Block: 0 properties
  Phase: 0 properties
  Construction_Stage: 0 properties
  Plot_Size: 0 properties
  Yard: 120 properties
  Description: 0 properties
  gallery: 27 properties

Keputusan: Kewarasan Disimpan

Setelah saya menyediakan segala-galanya, saya menjalankan skrip pada direktori fail XML saya. Outputnya betul-betul seperti yang saya perlukan: ringkasan ringkas menunjukkan kepada saya bilangan sifat dalam setiap fail yang tiada medan dan jumlah kiraan sifat dalam setiap XML.

Daripada menghabiskan masa berjam-jam menyemak setiap fail secara manual, saya mendapat jawapan saya dalam beberapa saat. Skrip menangkap beberapa medan yang hilang yang mungkin saya terlepas pandang jika saya meneruskan laluan manual.

Pengajaran

1. Automasi ialah penyelamat: Setiap kali anda berhadapan dengan tugasan yang berulang, fikirkan cara anda boleh mengautomasikannya. Ia bukan sahaja menjimatkan masa anda, malah ia juga akan mengurangkan risiko kesilapan manusia.
2. Ketepatan penting: Dalam situasi seperti ini, ketepatan adalah yang terpenting. Skrip mudah seperti yang saya tulis boleh memastikan anda tidak terlepas pandang apa-apa, yang penting terutamanya apabila berurusan dengan data kritikal.
3. Gunakan kemahiran pengaturcaraan anda: Kadangkala, kita terperangkap dalam melakukan sesuatu secara manual, walaupun apabila kita mempunyai kemahiran untuk menjadikan hidup kita lebih mudah. Luangkan sedikit masa untuk berundur dan tanya diri anda, “Adakah cara yang lebih berkesan untuk melakukan ini?”

Akhirnya, apa yang bermula sebagai tugasan yang memenatkan dan terdedah kepada kesilapan bertukar menjadi pengalaman yang bermanfaat. Kini, apabila saya mendapat tugasan yang membosankan atau terdedah kepada kesilapan, saya mengingatkan diri saya tentang kuasa skrip dan automasi. Saya tertanya-tanya berapa banyak tugas lain yang boleh saya lancarkan seterusnya…

Anda boleh mula dengan cepat menggunakan automasi ini dengan mengkloning repositori Pemeriksa XML yang telah saya buat. Ini akan memberi anda semua yang anda perlukan, termasuk skrip dan fail contoh. Dari situ, anda akan dapat menjalankan automasi sendiri, menyesuaikannya agar sesuai dengan keperluan anda atau memperluaskan lagi fungsinya.

Nikmati!

Atas ialah kandungan terperinci Hari Saya Mengautomasikan Pemeriksaan Medan XML dengan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!