قراءة وكتابة ملفات JSON في بايثون: دليل شامل لتحميل البيانات وتحليلها

مرحباً بك! إذا كنت ترغب في تعلم كيفية التعامل مع ملفات JSON في بايثون، فهذه المقالة هي دليلك الشامل. ستكتشف هنا كل ما تحتاج معرفته عن هذا التنسيق الحيوي وكيفية استغلال قوة بايثون للعمل معه بكفاءة.

في هذا الدليل، ستتعلم الآتي:

• لماذا يُعد تنسيق JSON مهماً للغاية في عالم البرمجة.
• بنيته الأساسية وأنواع البيانات التي يدعمها.
• كيف تتفاعل قواميس بايثون مع تنسيق JSON.
• كيفية استخدام وحدة json المدمجة في بايثون.
• تحويل سلاسل JSON إلى كائنات بايثون والعكس.
• الاستخدام الفعال لدالتي loads() و dumps().
• كيفية تنسيق سلاسل JSON تلقائياً لإخراج مقروء.
• قراءة ملفات JSON في بايثون باستخدام الدالة load().
• كتابة البيانات إلى ملفات JSON في بايثون باستخدام الدالة dump().
• والمزيد من النصائح والتقنيات المتقدمة!

هل أنت مستعد؟ لننطلق في هذه الرحلة التقنية الشيقة! ✨

مقدمة: ما هو تنسيق JSON؟

تنسيق JSON (اختصار لـ JavaScript Object Notation) هو تنسيق قياسي لتبادل البيانات خفيف الوزن وقابل للقراءة من قبل البشر. وقد استُلهم في الأصل من بناء جملة لغة JavaScript (لغة برمجة تُستخدم لتطوير الويب). ولكن منذ ذلك الحين، أصبح تنسيق بيانات مستقلاً عن اللغة، ويمكن لمعظم لغات البرمجة التي نستخدمها اليوم إنشاء وقراءة ملفات JSON.

أهمية تنسيق JSON وحالات استخدامه

يُعد JSON أساساً تنسيقاً يُستخدم لتخزين البيانات أو تمثيلها. وتشمل حالات استخدامه الشائعة تطوير الويب وملفات التكوين (Configuration Files).

تطوير الويب

يُستخدم JSON بشكل شائع لإرسال البيانات من الخادم إلى العميل والعكس في تطبيقات الويب. ويُسهل هذا التنسيق عملية تبادل المعلومات بين الأنظمة المختلفة بفضل بساطته ومرونته.

ملفات التكوين (Configuration Files)

يُستخدم JSON أيضاً لتخزين الإعدادات والتكوينات. على سبيل المثال، لإنشاء تطبيق لمتصفح Google Chrome، تحتاج إلى تضمين ملف JSON يُسمى manifest.json لتحديد اسم التطبيق ووصفه وإصداره الحالي وخصائص وإعدادات أخرى.

بنية وتنسيق JSON

بعد أن عرفت ما هو تنسيق JSON وما هي استخداماته، دعنا نلقي نظرة على بنيته الأساسية من خلال مثال يمثل بيانات طلب بيتزا:

{
  "size": "medium",
  "price": 15.67,
  "toppings": ["mushrooms", "pepperoni", "basil"],
  "extra_cheese": false,
  "delivery": true,
  "client": {
    "name": "Jane Doe",
    "phone": null,
    "email": "janedoe@email.com"
  }
}

هذه هي الخصائص الرئيسية لتنسيق JSON:

• يوجد تسلسل من أزواج المفتاح-القيمة (key-value pairs) محاطة بأقواس متعرجة {}.
• يتم ربط كل مفتاح بقيمة معينة باستخدام هذا التنسيق: "key" : <value>.
• 💡 نصيحة: يجب أن تكون القيم التي تتطلب علامات اقتباس محاطة بعلامات اقتباس مزدوجة.
• يتم فصل أزواج المفتاح-القيمة بفاصلة. الزوج الأخير فقط لا يتبعه فاصلة.

{
  "size": "medium",  # فاصلة!
  "price": 15.67
}

💡 نصيحة: عادةً ما نقوم بتنسيق JSON بمستويات مختلفة من المسافات البادئة (indentation) لجعل البيانات أسهل في القراءة. في هذه المقالة، ستتعلم كيفية إضافة المسافة البادئة تلقائياً باستخدام بايثون.

أنواع بيانات JSON: المفاتيح والقيم

تتبع ملفات JSON قواعد محددة تحدد أنواع البيانات الصالحة للمفاتيح والقيم:

• المفاتيح (Keys): يجب أن تكون دائماً سلاسل نصية (strings).
• القيم (Values): يمكن أن تكون إما سلسلة نصية (string)، أو رقماً (number)، أو مصفوفة (array)، أو قيمة منطقية (boolean) (true / false)، أو null، أو كائناً من نوع JSON (JSON object).

وفقاً لوثائق بايثون الرسمية:

المفاتيح في أزواج المفتاح-القيمة في JSON هي دائماً من النوع str. عندما يتم تحويل قاموس إلى JSON، يتم تحويل جميع مفاتيح القاموس إلى سلاسل نصية.

دليل الأنماط (Style Guide)

وفقاً لدليل أنماط JSON من Google:

• اختر دائماً أسماء ذات معنى (meaningful names).
• يجب أن تكون أسماء المفاتيح لأنواع المصفوفات (array types) بصيغة الجمع.
• يجب أن تكون جميع أسماء المفاتيح الأخرى بصيغة المفرد. على سبيل المثال: استخدم "orders" بدلاً من "order" إذا كانت القيمة المقابلة مصفوفة.
• يجب ألا توجد تعليقات (comments) في كائنات JSON.

الفرق بين JSON وقواميس بايثون (Python Dictionaries)

قد تبدو JSON وقواميس بايثون متشابهة جداً للوهلة الأولى (بصرياً)، لكنهما يختلفان تماماً. دعنا نرى كيف يرتبطان ببعضهما البعض وكيف يكملان بعضهما البعض لجعل بايثون أداة قوية للعمل مع ملفات JSON.

JSON هو تنسيق ملف يُستخدم لتمثيل وتخزين البيانات، بينما قاموس بايثون هو بنية البيانات الفعلية (الكائن) التي تُحفظ في الذاكرة أثناء تشغيل برنامج بايثون.

كيف تعمل JSON وقواميس بايثون معاً

عندما نعمل مع ملفات JSON في بايثون، لا يمكننا ببساطة قراءتها واستخدام البيانات في برنامجنا مباشرة. هذا لأن الملف بأكمله سيتم تمثيله كسلسلة نصية واحدة، ولن نتمكن من الوصول إلى أزواج المفتاح-القيمة بشكل فردي. إلا إذا…

استخدمنا أزواج المفتاح-القيمة من ملف JSON لإنشاء قاموس بايثون يمكننا استخدامه في برنامجنا لقراءة البيانات واستخدامها وتعديلها (إذا لزم الأمر). هذا هو الارتباط الرئيسي بين JSON وقواميس بايثون.

JSON هو التمثيل النصي للبيانات، والقواميس هي هياكل البيانات الفعلية في الذاكرة التي يتم إنشاؤها عند تشغيل البرنامج.

رائع! الآن بعد أن عرفت المزيد عن JSON، دعنا نبدأ في الغوص في الجوانب العملية لكيفية العمل مع JSON في بايثون.

وحدة JSON في بايثون

لحسن حظنا، تأتي بايثون مع وحدة مدمجة تُسمى json. يتم تثبيتها تلقائياً عند تثبيت بايثون، وتتضمن دوالاً لمساعدتك في العمل مع ملفات وسلاسل JSON. سنستخدم هذه الوحدة في الأمثلة القادمة.

كيفية استيراد وحدة JSON

لاستخدام json في برنامجنا، نحتاج فقط إلى كتابة عبارة استيراد (import statement) في أعلى الملف. هكذا:

باستخدام هذا السطر، ستتمكن من الوصول إلى الدوال المعرفة في الوحدة. سنستخدم العديد منها في الأمثلة.

💡 نصيحة: إذا كتبت عبارة الاستيراد هذه، فستحتاج إلى استخدام هذا البناء لاستدعاء دالة معرفة في وحدة json:

بايثون وسلاسل JSON

لتوضيح كيفية عمل بعض أهم دوال وحدة json، سنستخدم سلسلة نصية متعددة الأسطر بتنسيق JSON.

سلسلة JSON

على وجه التحديد، سنستخدم هذه السلسلة في الأمثلة. إنها مجرد سلسلة بايثون عادية متعددة الأسطر تتبع تنسيق JSON.

data_JSON = """
{
  "size": "Medium",
  "price": 15.67,
  "toppings": ["Mushrooms", "Extra Cheese", "Pepperoni", "Basil"],
  "client": {
    "name": "Jane Doe",
    "phone": "455-344-234",
    "email": "janedoe@email.com"
  }
}
"""

لتحديد سلسلة نصية متعددة الأسطر في بايثون، نستخدم علامات الاقتباس الثلاثية. ثم، نقوم بتعيين السلسلة للمتغير data_JSON.

💡 نصيحة: يوصي دليل أنماط بايثون (Python Style Guide) باستخدام علامات اقتباس مزدوجة للسلاسل ذات الاقتباس الثلاثي.

تحويل سلسلة JSON إلى قاموس بايثون

سنستخدم السلسلة ذات تنسيق JSON لإنشاء قاموس بايثون يمكننا الوصول إليه والعمل معه وتعديله. للقيام بذلك، سنستخدم الدالة loads() من وحدة json، بتمرير السلسلة كوسيط. هذا هو البناء الأساسي:

إليك الكود:

# استيراد الوحدة
import json

# سلسلة بتنسيق JSON
data_JSON = """
{
  "size": "Medium",
  "price": 15.67,
  "toppings": ["Mushrooms", "Extra Cheese", "Pepperoni", "Basil"],
  "client": {
    "name": "Jane Doe",
    "phone": "455-344-234",
    "email": "janedoe@email.com"
  }
}
"""

# تحويل سلسلة JSON إلى قاموس
data_dict = json.loads(data_JSON)

دعنا نركز على هذا السطر:

data_dict = json.loads(data_JSON)

تقوم json.loads(data_JSON) بإنشاء قاموس جديد بأزواج المفتاح-القيمة من سلسلة JSON، وتقوم بإرجاع هذا القاموس الجديد. ثم يتم تعيين القاموس المرتجع للمتغير data_dict.

رائع! إذا قمنا بطباعة هذا القاموس، سنرى هذا الإخراج:

{'size': 'Medium', 'price': 15.67, 'toppings': ['Mushrooms', 'Extra Cheese', 'Pepperoni', 'Basil'], 'client': {'name': 'Jane Doe', 'phone': '455-344-234', 'email': 'janedoe@email.com'}}

لقد تم ملء القاموس ببيانات سلسلة JSON. تمت إضافة كل زوج مفتاح-قيمة بنجاح. الآن دعنا نرى ما يحدث عندما نحاول الوصول إلى قيم أزواج المفتاح-القيمة بنفس البناء الذي سنستخدمه للوصول إلى قيم قاموس بايثون عادي:

print(data_dict["size"])
print(data_dict["price"])
print(data_dict["toppings"])
print(data_dict["client"])

الإخراج هو:

Medium
15.67
['Mushrooms', 'Extra Cheese', 'Pepperoni', 'Basil']
{'name': 'Jane Doe', 'phone': '455-344-234', 'email': 'janedoe@email.com'}

بالضبط ما توقعناه. يمكن استخدام كل مفتاح للوصول إلى قيمته المقابلة.

💡 نصيحة: يمكننا استخدام هذا القاموس تماماً مثل أي قاموس بايثون آخر. على سبيل المثال، يمكننا استدعاء دوال القاموس، وإضافة وتحديث وإزالة أزواج المفتاح-القيمة، والمزيد. يمكننا حتى استخدامه في حلقة for.

تحويل الأنواع: من JSON إلى بايثون

عند استخدام loads() لإنشاء قاموس بايثون من سلسلة JSON، ستلاحظ أن بعض القيم ستتحول إلى قيمها وأنواع بيانات بايثون المقابلة. يلخص هذا الجدول المقدم في وثائق بايثون لوحدة json التوافق من أنواع وقيم بيانات JSON إلى أنواع وقيم بيانات بايثون:

💡 نصيحة: ينطبق نفس جدول التحويل عندما نعمل مع ملفات JSON.

تحويل قاموس بايثون إلى سلسلة JSON

أنت تعرف الآن كيفية إنشاء قاموس بايثون من سلسلة بتنسيق JSON. ولكن في بعض الأحيان قد نحتاج إلى القيام بالعكس تماماً، أي إنشاء سلسلة بتنسيق JSON من كائن (على سبيل المثال، قاموس) لطباعتها أو عرضها أو تخزينها أو العمل معها كسلسلة.

للقيام بذلك، يمكننا استخدام الدالة dumps() من وحدة json، بتمرير الكائن كوسيط:

💡 نصيحة: ستُرجع هذه الدالة سلسلة نصية.

هذا مثال نحول فيه قاموس بايثون client إلى سلسلة بتنسيق JSON ونخزنه في متغير:

# قاموس بايثون
client = {
  "name": "Nora",
  "age": 56,
  "id": "45355",
  "eye_color": "green",
  "wears_glasses": False
}

# الحصول على سلسلة بتنسيق JSON
client_JSON = json.dumps(client)

دعنا نركز على هذا السطر:

client_JSON = json.dumps(client)

تقوم json.dumps(client) بإنشاء وإرجاع سلسلة تحتوي على جميع أزواج المفتاح-القيمة للقاموس بتنسيق JSON. ثم يتم تعيين هذه السلسلة للمتغير client_JSON.

إذا قمنا بطباعة هذه السلسلة، سنرى هذا الإخراج:

{"name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": false}

💡 نصيحة: لاحظ أن القيمة الأخيرة (false) قد تغيرت. في قاموس بايثون، كانت هذه القيمة False (بحرف كبير)، ولكن في JSON، القيمة المكافئة هي false (بحرف صغير). يساعدنا هذا في تأكيد أن القاموس الأصلي أصبح ممثلاً كسلسلة بتنسيق JSON.

إذا تحققنا من نوع بيانات هذا المتغير، سنرى:

<class 'str'>

لذا فإن القيمة المرتجعة لهذه الدالة كانت بالتأكيد سلسلة نصية.

تحويل الأنواع: من بايثون إلى JSON

تحدث عملية تحويل للأنواع أيضاً عندما نحول قاموساً إلى سلسلة JSON. يوضح هذا الجدول من وثائق بايثون القيم المقابلة:

كيفية طباعة JSON بمسافات بادئة (Indentation)

إذا استخدمنا الدالة dumps() وقمنا بطباعة السلسلة التي حصلنا عليها في المثال السابق، سنرى:

{"name": "Nora", "age": 56, "id": "45355", "eye_color": "green", "wears_glasses": false}

لكن هذا ليس قابلاً للقراءة جداً، أليس كذلك؟ يمكننا تحسين قابلية قراءة سلسلة JSON عن طريق إضافة مسافات بادئة (indentation). للقيام بذلك تلقائياً، نحتاج فقط إلى تمرير وسيط ثانٍ لتحديد عدد المسافات التي نريد استخدامها لعمل المسافة البادئة لسلسلة JSON:

💡 نصيحة: يجب أن يكون الوسيط الثاني عدداً صحيحاً غير سالب (عدد المسافات) أو سلسلة نصية. إذا كانت indent سلسلة (مثل "\t")، فسيتم استخدام هذه السلسلة لعمل مسافة بادئة لكل مستوى.

الآن، إذا استدعينا dumps() بهذا الوسيط الثاني:

client_JSON = json.dumps(client, indent=4)

نتيجة طباعة client_JSON هي:

{
    "name": "Nora",
    "age": 56,
    "id": "45355",
    "eye_color": "green",
    "wears_glasses": false
}

هذا رائع، أليس كذلك؟ الآن سلسلتنا منسقة بشكل جميل. سيكون هذا مفيداً جداً عندما نبدأ العمل مع الملفات لتخزين البيانات بتنسيق قابل للقراءة من قبل البشر.

كيفية فرز المفاتيح (Sorting Keys)

يمكنك أيضاً فرز المفاتيح بترتيب أبجدي إذا كنت بحاجة إلى ذلك. للقيام بذلك، تحتاج فقط إلى كتابة اسم الوسيط sort_keys وتمرير القيمة True:

💡 نصيحة: قيمة sort_keys هي False افتراضياً إذا لم تمرر قيمة.

على سبيل المثال:

client_JSON = json.dumps(client, sort_keys=True)

تُرجع هذه السلسلة مع المفاتيح مرتبة أبجدياً:

{
  "age": 56,
  "eye_color": "green",
  "id": "45355",
  "name": "Nora",
  "wears_glasses": false
}

كيفية الفرز أبجدياً والمسافة البادئة (في نفس الوقت)

لإنشاء سلسلة JSON مرتبة أبجدياً ومنسقة بمسافات بادئة، تحتاج فقط إلى تمرير الوسيطين معاً:

في هذه الحالة، يكون الإخراج:

{
    "age": 56,
    "eye_color": "green",
    "id": "45355",
    "name": "Nora",
    "wears_glasses": false
}

💡 نصيحة: يمكنك تمرير هذه الوسائط بأي ترتيب (بالنسبة لبعضها البعض)، ولكن يجب أن يكون الكائن هو الوسيط الأول في القائمة.

رائع! أنت تعرف الآن كيفية العمل مع سلاسل JSON، لذا دعنا نرى كيف يمكنك العمل مع ملفات JSON في برامج بايثون الخاصة بك.

التعامل مع ملفات JSON

عادةً، يُستخدم JSON لتخزين البيانات في الملفات، لذا توفر لنا بايثون الأدوات التي نحتاجها لقراءة هذه الأنواع من الملفات في برنامجنا، والعمل مع بياناتها، وكتابة بيانات جديدة.

💡 نصيحة: ملف JSON له امتداد .json:

دعنا نرى كيف يمكننا العمل مع ملفات .json في بايثون.

كيفية قراءة ملف JSON في بايثون

لنفترض أننا أنشأنا ملف orders.json بهذه البيانات التي تمثل طلبين في متجر بيتزا:

{
  "orders": [
    {
      "size": "medium",
      "price": 15.67,
      "toppings": ["mushrooms", "pepperoni", "basil"],
      "extra_cheese": false,
      "delivery": true,
      "client": {
        "name": "Jane Doe",
        "phone": null,
        "email": "janedoe@email.com"
      }
    },
    {
      "size": "small",
      "price": 6.54,
      "toppings": null,
      "extra_cheese": true,
      "delivery": false,
      "client": {
        "name": "Foo Jones",
        "phone": "556-342-452",
        "email": null
      }
    }
  ]
}

يرجى أخذ لحظة لتحليل بنية ملف JSON هذا. إليك بعض النصائح السريعة:

• لاحظ أنواع البيانات للقيم، والمسافة البادئة، والبنية العامة للملف.
• قيمة المفتاح الرئيسي "orders" هي مصفوفة من كائنات JSON (سيتم تمثيل هذه المصفوفة كقائمة في بايثون).
• يحتوي كل كائن JSON على بيانات طلب بيتزا.

إذا أردنا قراءة هذا الملف في بايثون، نحتاج فقط إلى استخدام عبارة with:

💡 نصيحة: في البناء أعلاه، يمكننا تعيين أي اسم للمتغير file (المربع الأخضر). هذا متغير يمكننا استخدامه داخل عبارة with للإشارة إلى كائن الملف.

سطر الكود الرئيسي في هذا البناء هو:

data = json.load(file)

تقوم json.load(file) بإنشاء وإرجاع قاموس بايثون جديد بأزواج المفتاح-القيمة في ملف JSON. ثم يتم تعيين هذا القاموس للمتغير data.

💡 نصيحة: لاحظ أننا نستخدم load() بدلاً من loads(). هذه دالة مختلفة في وحدة json. ستتعلم المزيد عن اختلافاتهم في نهاية هذه المقالة.

بمجرد أن يكون محتوى ملف JSON مخزناً في المتغير data كقاموس، يمكننا استخدامه للقيام بأي شيء نريده بشكل أساسي.

أمثلة

على سبيل المثال، إذا كتبنا:

print(len(data["orders"]))

الإخراج هو 2 لأن قيمة المفتاح الرئيسي "orders" هي قائمة تحتوي على عنصرين.

يمكننا أيضاً استخدام المفاتيح للوصول إلى قيمها المقابلة. هذا ما نفعله عادةً عندما نعمل مع ملفات JSON. على سبيل المثال، للوصول إلى إضافات الطلب الأول، سنكتب:

data["orders"][0]["toppings"]

أولاً، نختار المفتاح الرئيسي "orders". ثم نختار العنصر الأول في القائمة (الفهرس 0). أخيراً، نختار القيمة التي تتوافق مع المفتاح "toppings".

يمكنك رؤية هذا “المسار” بيانياً في الرسم التخطيطي:

إذا قمنا بطباعة هذه القيمة، يكون الإخراج:

['mushrooms', 'pepperoni', 'basil']

بالضبط ما توقعناه. تحتاج فقط إلى “التعمق” في بنية القاموس باستخدام المفاتيح والفهارس الضرورية. يمكنك استخدام ملف/سلسلة JSON الأصلية كمرجع مرئي. بهذه الطريقة، يمكنك الوصول إلى أي قيمة أو تعديلها أو حذفها.

💡 نصيحة: تذكر أننا نعمل مع القاموس الجديد. التغييرات التي يتم إجراؤها على هذا القاموس لن تؤثر على ملف JSON. لتحديث محتوى الملف، نحتاج إلى الكتابة إلى الملف.

كيفية الكتابة إلى ملف JSON

دعنا نرى كيف يمكنك الكتابة إلى ملف JSON. السطر الأول من عبارة with مشابه جداً. التغيير الوحيد هو أنك تحتاج إلى فتح الملف في وضع 'w' (الكتابة) لتتمكن من تعديل الملف.

💡 نصيحة: إذا لم يكن الملف موجوداً بالفعل في دليل العمل الحالي (المجلد)، فسيتم إنشاؤه تلقائياً. باستخدام وضع 'w'، سنقوم باستبدال المحتوى الكامل للملف إذا كان موجوداً بالفعل.

هناك طريقتان بديلتان للكتابة إلى ملف JSON في جسم عبارة with:

• dump()
• dumps()

دعنا نراهما بالتفصيل.

النهج الأول: الدالة dump()

هذه دالة تأخذ وسيطين:

• الكائن الذي سيتم تخزينه بتنسيق JSON (على سبيل المثال، قاموس).
• الملف الذي سيتم تخزينه فيه (كائن ملف).

لنفترض أن متجر البيتزا يريد إزالة بيانات العملاء من ملف JSON وإنشاء ملف JSON جديد يُسمى orders_new.json بهذا الإصدار الجديد. يمكننا القيام بذلك باستخدام هذا الكود:

# فتح ملف orders.json
with open("orders.json") as file:
  # تحميل محتواه وإنشاء قاموس جديد
  data = json.load(file)

  # حذف زوج المفتاح-القيمة "client" من كل طلب
  for order in data["orders"]:
    del order["client"]

# فتح (أو إنشاء) ملف orders_new.json
# وتخزين الإصدار الجديد من البيانات.
with open("orders_new.json", 'w') as file:
  json.dump(data, file)

كان هذا هو الإصدار الأصلي للبيانات في ملف orders.json. لاحظ أن زوج المفتاح-القيمة "client" موجود.

{
  "orders": [
    {
      "size": "medium",
      "price": 15.67,
      "toppings": ["mushrooms", "pepperoni", "basil"],
      "extra_cheese": false,
      "delivery": true,
      "client": {
        "name": "Jane Doe",
        "phone": null,
        "email": "janedoe@email.com"
      }
    },
    {
      "size": "small",
      "price": 6.54,
      "toppings": null,
      "extra_cheese": true,
      "delivery": false,
      "client": {
        "name": "Foo Jones",
        "phone": "556-342-452",
        "email": null
      }
    }
  ]
}

هذا هو الإصدار الجديد في ملف orders_new.json:

{"orders": [{"size": "medium", "price": 15.67, "toppings": ["mushrooms", "pepperoni", "basil"], "extra_cheese": false, "delivery": true}, {"size": "small", "price": 6.54, "toppings": null, "extra_cheese": true, "delivery": false}]}

إذا حللت هذا بعناية، سترى أن زوج المفتاح-القيمة "clients" قد تمت إزالته من جميع الطلبات. ومع ذلك، هناك شيء مفقود في هذا الملف، أليس كذلك؟ يرجى أخذ لحظة للتفكير في هذا… ماذا يمكن أن يكون؟

المسافة البادئة (Indentation)، بالطبع! لا يبدو الملف حقاً كملف JSON، ولكن يمكننا إصلاح ذلك بسهولة عن طريق تمرير الوسيط indent=4 إلى dump().

الآن يبدو محتوى الملف هكذا:

{
  "orders": [
    {
      "size": "medium",
      "price": 15.67,
      "toppings": ["mushrooms", "pepperoni", "basil"],
      "extra_cheese": false,
      "delivery": true
    },
    {
      "size": "small",
      "price": 6.54,
      "toppings": null,
      "extra_cheese": true,
      "delivery": false
    }
  ]
}

يا له من فرق! هذا هو بالضبط ما نتوقعه أن يبدو عليه ملف JSON. أنت تعرف الآن كيفية القراءة والكتابة إلى ملفات JSON باستخدام load() و dump(). دعنا نرى الاختلافات بين هذه الدوال والدوال التي استخدمناها للعمل مع سلاسل JSON.

مقارنة بين load() و loads()

يلخص هذا الجدول الاختلافات الرئيسية بين هاتين الدالتين:

💡 نصيحة: فكر في loads() على أنها “تحميل سلسلة” (load string) وهذا سيساعدك على تذكر الدالة المستخدمة لأي غرض.

مقارنة بين dump() و dumps()

إليك جدول يلخص الاختلافات الرئيسية بين هاتين الدالتين:

💡 نصيحة: فكر في dumps() على أنها “تفريغ سلسلة” (dump string) وهذا سيساعدك على تذكر الدالة المستخدمة لأي غرض.

مصطلحات مهمة في JSON

أخيراً، هناك مصطلحان مهمان تحتاج إلى معرفتهما للعمل مع JSON:

• التحويل إلى سلسلة (Serialization): تحويل كائن بايثون إلى سلسلة JSON.
• التحويل من سلسلة (Deserialization): تحويل سلسلة JSON إلى كائن بايثون.

الخلاصة التقنية

تُقدم هذه المقالة دليلاً شاملاً وواضحاً للتعامل مع تنسيق JSON في بايثون، وهو أمر حيوي لأي مطور يتعامل مع تبادل البيانات. لقد استعرضنا الأدوات الأساسية في وحدة json المدمجة، بدءاً من فهم بنية JSON وأنواع بياناته، وصولاً إلى التطبيق العملي لدوال التحويل بين سلاسل JSON وكائنات بايثون، سواء كانت هذه الكائنات في الذاكرة أو مخزنة في ملفات. التركيز على استخدام indent و sort_keys يُبرز أهمية قابلية القراءة والصيانة للبيانات، وهي ممارسات برمجية فضلى. الفهم الدقيق للاختلافات بين دوال load/loads و dump/dumps يضمن استخدام الأداة الصحيحة للمهمة المناسبة، مما يعزز كفاءة معالجة البيانات ويقلل الأخطاء. هذه المعرفة أساسية لبناء تطبيقات قوية تتفاعل بفعالية مع مصادر البيانات الخارجية.

ملخص

باختصار، يمكننا تلخيص النقاط الرئيسية التي تناولناها في هذه المقالة:

• JSON (JavaScript Object Notation) هو تنسيق يُستخدم لتمثيل وتخزين البيانات، ويُستخدم بشكل شائع لنقل البيانات عبر الويب وتخزين إعدادات التكوين.
• تأتي ملفات JSON بامتداد .json.
• يمكنك تحويل سلاسل JSON إلى كائنات بايثون والعكس.
• يمكنك قراءة ملفات JSON وإنشاء كائنات بايثون من أزواج المفتاح-القيمة الخاصة بها.
• يمكنك الكتابة إلى ملفات JSON لتخزين محتوى كائنات بايثون بتنسيق JSON.

آمل حقاً أن تكون قد استمتعت بمقالتي ووجدتها مفيدة. أنت الآن تعرف كيفية العمل مع JSON في بايثون.