رابط التحميل

The post علوم وتحليلات البيانات المتقدمة مع بايثون appeared first on فيلم تعلم البرمجيات للطالب العربي.

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

يتميز هذا الإصدار بالعديد من الأمثلة والمشكلات الجديدة والمنقحة من مجالات التطبيق المتنوعة وتغطية أكثر شمولاً للتحليل والمحاكاة باستخدام MATLAB .

download

The post تصميم وتحسين الأنظمة الحرارية باستخدام تطبيقات MATLAB appeared first on فيلم تعلم البرمجيات للطالب العربي.

يقدم التعرف على الأنماط والذكاء الحسابي باستخدام Matlab ؛ يتضمن مزيجًا من النظرية والرياضيات والخوارزميات ، مما يتيح للقراء فهم المفاهيم بسرعة ؛ يحدد مجموعة من المصنفات ونماذج الانحدار المختلفة والاختبارات الإحصائية وتقنيات التعرف على الأنماط باستخدام الذكاء الحسابي.

جدول المحتويات :

المقدمة … الصفحات من الأول إلى الثالث عشر
تقنيات تقليل الأبعاد …. الصفحات 1-29
تقنيات المصنف الخطي …. الصفحات 31-67
تقنيات الانحدار …. الصفحات 69-120
المصنف الاحتمالي الخاضع للإشراف والتكتل غير الخاضع للإشراف …. الصفحات 121-163
الذكاء الحسابي …. الصفحات 165-228
اختبار إحصائي للتعرف على الأنماط …. الصفحات 229-249
العودة … الصفحات 251-256

download

The post التعرف على الأنماط وتقنيات الذكاء الحسابي باستخدام MATLAB appeared first on فيلم تعلم البرمجيات للطالب العربي.

يعد توفير نظام طاقة وطاقة موثوق به وآمن أحد التحديات الرئيسية في العصر الجديد. نظرًا للطبيعة متعددة الأهداف غير الخطية لهذه المشكلات ، فإن الطرق التقليدية ليست مناهج مناسبة لحل معضلات تشغيل نظام الطاقة على نطاق واسع.

تمت مناقشة تكامل خوارزميات التحسين في أنظمة الطاقة في العديد من الكتب المدرسية ، ولكن هذا هو الأول الذي يتضمن طرق التكامل والرموز المطورة.

على هذا النحو ، فهو مورد مفيد للطلاب الجامعيين والخريجين والباحثين والمهندسين الذين يحاولون حل مشاكل تحسين الطاقة والطاقة باستخدام الأنظمة التقنية والذكية الحديثة القائمة على دراسات الحالة النظرية والتطبيق. من المتوقع أن يتمتع القراء بخلفية رياضية أساسية.

download

The post تحسين مشاكل نظام الطاقة: الطرق والخوارزميات و رموز MATLAB appeared first on فيلم تعلم البرمجيات للطالب العربي.

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

الميزات الرئيسية: يوفر فهمًا بديهيًا لنهج ترشيح كالمان نظرة عامة موجزة للمفاهيم لتعزيز إمكانية الوصول وجذب جمهور عريض تقنيات التعلم التفاعلية مع أمثلة التعليمات البرمجية

المقدمة

يوفر مرشح كالمان ، الذي تصوره الدكتور رودولف إي. هذا نوع شائع من المواقف في دراسة العديد من الأنظمة الديناميكية العملية ، في مجالات متنوعة.
كان لمرشح كالمان تأثير مهم على التقدم في المجالات المتعلقة بملاحة السفن والطائرات والمركبات الفضائية. في مجالات الاستخدام الأولية هذه ، تم استخدام مرشح Kalman بشكل حصري تقريبًا لتطبيقات محددة للغاية ، من قبل مجموعة صغيرة جدًا من المستخدمين المتخصصين للغاية. ومع ذلك ، في القرن الحادي والعشرين ، أدى تطبيقه المحتمل على الروبوتات الصغيرة والمركبات المصغرة بدون طيار إلى توسيع نطاق جاذبية نهج التقدير القوي هذا لجمهور أوسع بكثير. علاوة على ذلك ، فإن الظهور الأخير لوحدات القياس بالقصور الذاتي المصغرة الرخيصة (IMUs) أو وحدات الاستشعار المغناطيسية والمعدل الزاوي والجاذبية (MARG) في التطبيقات المعاصرة قد زاد من أهمية تقنيات مثل ترشيح كالمان ، القادرة على دمج المعلومات من أجهزة استشعار متعددة. بالطبع ، كل هذه التطبيقات المعاصرة تعمل البيانات الرقمية ، وعلى هذا النحو ، يتم تناولها بواسطة عامل تصفية منفصل كالمان ، وهو موضوع هذا الكتاب.
هذا الكتاب هو جهدنا لتزويد ذلك الجمهور الأوسع بعرض تقديمي لمرشح كالمان الذي لا يمثل مجرد قائمة “كتاب طبخ” من الخطوات (والتي قد تؤدي إلى استخدام دون المستوى الأمثل لهذه الأداة المهمة) ، مع عدم مطالبة القارئ خاض العديد من البراهين الرسمية لإنجاز اشتقاق صارم للخوارزمية. هذه البراهين قدمها كالمان في ورقته البحثية عام 1960 وآخرين درسوا القضية من منظور رسمي منذ ذلك الحين.

download

The post فهم بديهي لتصفية كالمان باستخدام MATLAB appeared first on فيلم تعلم البرمجيات للطالب العربي.

• الطراز القديم مقابل فئات الطراز الجديد
  فئات الطراز القديم
  فئات جديدة الطراز
  
• النوع والفئة
  
• تعريف الفصل ديناميكيًا
  مثال 1
  مثال 2
  مثال 3
  مثال 4
  
• Metaclass مخصص
  
• هل هذا حقا ضروري؟
  
• خاتمة
  

يشير مصطلح metaprogramming إلى إمكانية حصول البرنامج على معرفة أو التلاعب بنفسه. تدعم Python شكلاً من أشكال البرمجة الوصفية للفئات تسمى metaclasses.

Metaclasses هي مفهوم OOP مقصور على فئة معينة ، كامنة وراء كل كود Python تقريبًا. أنت تستخدمها سواء كنت على علم بذلك أم لا. بالنسبة للجزء الأكبر ، لا تحتاج إلى أن تكون على دراية بذلك. نادرًا ما يفكر معظم مبرمجي بايثون في الفوقية.

ومع ذلك ، عندما تظهر الحاجة ، توفر Python قدرة لا تدعمها جميع اللغات الموجهة للكائنات: يمكنك الحصول على الغطاء وتحديد الفئات الوصفية المخصصة. يعد استخدام metaclasses المخصص مثيرًا للجدل إلى حد ما ، كما هو مقترح في الاقتباس التالي من Tim Peters ، معلم Python الذي قام بتأليف Zen of Python:

“Metaclasses هي سحر أعمق مما ينبغي أن يقلق بشأنه 99٪ من المستخدمين. إذا كنت تتساءل عما إذا كنت بحاجة إليها ، فأنت لست (الأشخاص الذين يحتاجون إليها بالفعل يعرفون على وجه اليقين أنهم بحاجة إليهم ، ولا يحتاجون إلى تفسير لماذا) “.

– تيم بيترز

هناك Pythonistas (كما هو معروف هواة Python) الذين يعتقدون أنه لا يجب عليك استخدام metaclasses المخصصة. قد يكون هذا بعيدًا بعض الشيء ، ولكن ربما يكون صحيحًا أن الفئات الوصفية المخصصة ليست ضرورية في الغالب. إذا لم يكن من الواضح تمامًا أن المشكلة تستدعيها ، فمن المحتمل أن تكون أنظف وأكثر قابلية للقراءة إذا تم حلها بطريقة أبسط.

ومع ذلك ، فإن فهم Python metaclasses مفيد ، لأنه يؤدي إلى فهم أفضل للداخلية في صفوف Python بشكل عام. أنت لا تعرف أبدًا: قد تجد نفسك يومًا ما في واحدة من تلك المواقف التي تعرف فيها فقط أن metaclass المخصص هو ما تريده.

الطراز القديم مقابل فئات الطراز الجديد

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

فئات الطراز القديم

في الفصول ذات النمط القديم ، لا يكون الفصل والنوع نفس الشيء تمامًا. يتم دائمًا تنفيذ مثيل لفئة ذات نمط قديم من نوع مضمن واحد يسمى مثيل. إذا كان obj مثيلًا لفئة ذات نمط قديم ، فإن obj .__ class__ تحدد الفئة ، لكن النوع (obj) هو دائمًا مثيل. المثال التالي مأخوذ من Python 2.7:

>>> class Foo:
...     pass
...
>>> x = Foo()
>>> x.__class__
<class __main__.Foo at 0x000000000535CC48>
>>> type(x)
<type 'instance'>

فئات جديدة الطراز

توحد الفصول ذات النمط الجديد مفاهيم الفئة والنوع. إذا كان obj مثيلًا لفئة ذات نمط جديد ، فإن النوع (obj) هو نفسه obj .__ class__:

>>> class Foo:
...     pass
>>> obj = Foo()
>>> obj.__class__
<class '__main__.Foo'>
>>> type(obj)
<class '__main__.Foo'>
>>> obj.__class__ is type(obj)
True

>>> n = 5
>>> d = { 'x' : 1, 'y' : 2 }

>>> class Foo:
...     pass
...
>>> x = Foo()

>>> for obj in (n, d, x):
...     print(type(obj) is obj.__class__)
...
True
True
True

النوع والفئة

في Python 3 ، كل الفئات هي فئات جديدة. وبالتالي ، في Python 3 ، من المعقول الإشارة إلى نوع الكائن وفئته بالتبادل.

ملاحظة: في Python 2 ، تكون الفئات هي النمط القديم افتراضيًا. قبل Python 2.2 ، لم تكن الفئات ذات النمط الجديد مدعومة على الإطلاق. من Python 2.2 فصاعدًا ، يمكن إنشاؤها ولكن يجب الإعلان عنها صراحة على أنها نمط جديد.

تذكر أن كل شيء في بايثون هو كائن. الفئات هي كائنات أيضًا. نتيجة لذلك ، يجب أن يكون للفصل نوع. ما هو نوع الفصل؟

ضع في اعتبارك ما يلي:

>>> class Foo:
...     pass
...
>>> x = Foo()

>>> type(x)
<class '__main__.Foo'>

>>> type(Foo)
<class 'type'>

نوع x هو فئة Foo ، كما تتوقع. لكن نوع Foo ، الفئة نفسها ، هي النوع. بشكل عام ، نوع أي فئة ذات نمط جديد هو النوع.

نوع الفصول المضمنة التي تعرفها هو أيضًا نوع:

>>> for t in int, float, dict, list, tuple:
...     print(type(t))
...
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>
<class 'type'>

لهذه المسألة ، نوع النوع هو النوع أيضًا (نعم ، حقًا):

>>> type(type)
<class 'type'>

النوع هو metaclass ، والفئات هي أمثلة. تمامًا كما أن الكائن العادي هو مثيل لفئة ، فإن أي فئة ذات نمط جديد في Python ، وبالتالي أي فئة في Python 3 ، هي مثيل من النوع metaclass.

في الحالة أعلاه:

• x هو مثيل للفئة Foo.
  
• Foo هو مثيل من النوع metaclass.
  
• النوع هو أيضًا مثيل من النوع metaclass ، لذا فهو مثيل لنفسه.
  

تعريف الفصل ديناميكيًا

دالة type () المضمنة ، عند تمرير وسيطة واحدة ، ترجع نوع الكائن. بالنسبة لفئات النمط الجديد ، يكون هذا بشكل عام هو نفسه سمة __class__ للكائن:

>>> type(3)
<class 'int'>

>>> type(['foo', 'bar', 'baz'])
<class 'list'>

>>> t = (1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>

>>> class Foo:
...     pass
...
>>> type(Foo())
<class '__main__.Foo'>

يمكنك أيضًا استدعاء النوع () بثلاث وسيطات – النوع (<name> ، <bases> ، <dct>):

• <name> يحدد اسم الفئة. تصبح هذه سمة __name__ للفئة.
  
• يحدد <bases> مجموعة من الفئات الأساسية التي ترث منها الفئة. تصبح هذه السمة __bases__ للفصل.
  
• يحدد <dct> قاموس مساحة اسم يحتوي على تعريفات لجسم الفئة. تصبح هذه سمة __dict__ للطبقة.
  

يؤدي استدعاء type () بهذه الطريقة إلى إنشاء مثيل جديد من النوع metaclass. بمعنى آخر ، يتم إنشاء فئة جديدة ديناميكيًا.

في كل من الأمثلة التالية ، يُعرِّف المقتطف العلوي فئة ديناميكيًا بالنوع () ، بينما يُعرِّف المقتطف أدناه الفئة بالطريقة المعتادة ، باستخدام عبارة الفئة. في كل حالة ، المقتطفان متكافئان وظيفيًا.

مثال 1

في هذا المثال الأول ، تكون الوسيطات <bases> و <dct> التي تم تمريرها إلى النوع () فارغة. لم يتم تحديد وراثة من أي فئة أصل ، ولا يتم وضع أي شيء مبدئيًا في قاموس مساحة الاسم. هذا هو أبسط تعريف ممكن للفئة:

>>> Foo = type('Foo', (), {})

>>> x = Foo()
>>> x
<__main__.Foo object at 0x04CFAD50>

>>> class Foo:
...     pass
...
>>> x = Foo()
>>> x
<__main__.Foo object at 0x0370AD50>

مثال 2

هنا ، <bases> عبارة عن مجموعة تحتوي على عنصر واحد Foo ، تحدد الفئة الرئيسية التي يرث Bar منها. يتم وضع السمة ، Attr ، في البداية في قاموس مساحة الاسم:

>>> Bar = type('Bar', (Foo,), dict(attr=100))

>>> x = Bar()
>>> x.attr
100
>>> x.__class__
<class '__main__.Bar'>
>>> x.__class__.__bases__
(<class '__main__.Foo'>,)

>>> class Bar(Foo):
...     attr = 100
...

>>> x = Bar()
>>> x.attr
100
>>> x.__class__
<class '__main__.Bar'>
>>> x.__class__.__bases__
(<class '__main__.Foo'>,)

مثال 3

هذه المرة ، أصبحت <bases> فارغة مرة أخرى. يتم وضع كائنين في قاموس مساحة الاسم عبر الوسيطة <dct>. الأول هو سمة تسمى attr والثاني وظيفة تسمى attr_val ، والتي تصبح طريقة للفئة المحددة:

>>> Foo = type(
...     'Foo',
...     (),
...     {
...         'attr': 100,
...         'attr_val': lambda x : x.attr
...     }
... )

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
100

>>> class Foo:
...     attr = 100
...     def attr_val(self):
...         return self.attr
...

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
100

مثال 4

يمكن تعريف الوظائف البسيطة جدًا فقط باستخدام lambda في Python. في المثال التالي ، يتم تعريف دالة أكثر تعقيدًا من الخارج ثم يتم تعيينها إلى attr_val في قاموس مساحة الاسم عبر الاسم f:

>>> def f(obj):
...     print('attr =', obj.attr)
...
>>> Foo = type(
...     'Foo',
...     (),
...     {
...         'attr': 100,
...         'attr_val': f
...     }
... )

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
attr = 100

>>> def f(obj):
...     print('attr =', obj.attr)
...
>>> class Foo:
...     attr = 100
...     attr_val = f
...

>>> x = Foo()
>>> x.attr
100
>>> x.attr_val()
attr = 100

Metaclass مخصص

ضع في اعتبارك مرة أخرى هذا المثال البالي:

>>> class Foo:
...     pass
...
>>> f = Foo()

ينشئ التعبير Foo () مثيلًا جديدًا للفئة Foo. عندما يواجه المترجم Foo () ، يحدث ما يلي:

• يتم استدعاء طريقة __call __ () لفئة Foo الرئيسية. نظرًا لأن Foo هي فئة نمطية جديدة قياسية ، فإن صنفها الرئيسي هو النوع metaclass ، لذلك يتم استدعاء طريقة type’s __call __ ().

• تستدعي طريقة __call __ () هذه بدورها ما يلي:
  __جديد__()
  __فيه__()
  

إذا لم يعرّف Foo __new __ () و __init __ () ، يتم توريث الطرق الافتراضية من أصل Foo. ولكن إذا حدد Foo هذه الأساليب ، فإنها تلغي تلك الموجودة في الأصل ، مما يسمح بسلوك مخصص عند إنشاء مثيل Foo.

في ما يلي ، يتم تعريف طريقة مخصصة تسمى new () وتعيينها على أنها طريقة __new __ () لـ Foo:

>>> def new(cls):
...     x = object.__new__(cls)
...     x.attr = 100
...     return x
...
>>> Foo.__new__ = new

>>> f = Foo()
>>> f.attr
100

>>> g = Foo()
>>> g.attr
100

يعدل هذا سلوك إنشاء مثيل للفئة Foo: في كل مرة يتم إنشاء مثيل لـ Foo ، يتم تهيئته افتراضيًا بسمة تسمى attr ، والتي لها قيمة 100. (عادةً ما يظهر رمز مثل هذا في طريقة __init __ () وليس عادةً في __new __ (). تم إنشاء هذا المثال لأغراض توضيحية.)

الآن ، كما تم التأكيد عليه بالفعل ، تعتبر الفئات كائنات أيضًا. لنفترض أنك أردت تخصيص سلوك إنشاء مثيل بشكل مشابه عند إنشاء فئة مثل Foo. إذا كنت ستتبع النمط أعلاه ، فعليك مرة أخرى تحديد طريقة مخصصة وتعيينها على أنها طريقة __new __ () للفئة التي يمثل Foo مثيلًا لها. Foo هو مثيل من النوع metaclass ، لذلك تبدو الشفرة كما يلي:

# Spoiler alert:  This doesn't work!
>>> def new(cls):
...     x = type.__new__(cls)
...     x.attr = 100
...     return x
...
>>> type.__new__ = new
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    type.__new__ = new
TypeError: can't set attributes of built-in/extension type 'type'

باستثناء ، كما ترى ، لا يمكنك إعادة تعيين طريقة __new __ () من النوع metaclass. بايثون لا تسمح بذلك.

ربما هذا فقط كذلك. النوع هو metaclass الذي يتم اشتقاق منه جميع فئات النمط الجديد. لا ينبغي أن تتلاعب بها على أي حال. ولكن بعد ذلك ما هو الملاذ الموجود ، إذا كنت تريد تخصيص مثيل فئة؟

أحد الحلول الممكنة هو metaclass مخصص. بشكل أساسي ، بدلاً من الالتفاف حول النوع metaclass ، يمكنك تحديد metaclass الخاص بك ، والذي يشتق من الكتابة ، ومن ثم يمكنك التخلص منه بدلاً من ذلك.

الخطوة الأولى هي تحديد metaclass المشتق من الكتابة ، على النحو التالي:

>>> class Meta(type):
...     def __new__(cls, name, bases, dct):
...         x = super().__new__(cls, name, bases, dct)
...         x.attr = 100
...         return x
...

فئة رأس التعريف Meta (type): تحدد أن Meta مشتق من النوع. نظرًا لأن الكتابة هي metaclass ، فهذا يجعل Meta metaclass أيضًا.

لاحظ أنه تم تعريف طريقة __new __ () المخصصة للميتا. لم يكن من الممكن القيام بذلك على نوع metaclass مباشرة. تقوم طريقة __new __ () بما يلي:

• المفوضين عبر () super إلى طريقة __new __ () الخاصة بالفئة الوصفية الأصلية (النوع) لإنشاء فصل دراسي جديد بالفعل
  
• يعيّن سمة السمة المخصصة للفئة بقيمة 100
  
• إرجاع الفصل الذي تم إنشاؤه حديثًا
  

الآن النصف الآخر من الشعوذة: حدد فئة جديدة Foo وحدد أن metaclass الخاص بها هو Metaclass Meta المخصص ، بدلاً من نوع metaclass القياسي. يتم ذلك باستخدام الكلمة الأساسية metaclass في تعريف الفئة على النحو التالي:

>>> class Foo(metaclass=Meta):
...     pass
...
>>> Foo.attr
100

هاهو! اختار Foo سمة Attr تلقائيًا من Meta metaclass. بالطبع ، أي فئات أخرى تحددها بالمثل ستفعل الشيء نفسه:

>>> class Bar(metaclass=Meta):
...     pass
...
>>> class Qux(metaclass=Meta):
...     pass
...
>>> Bar.attr, Qux.attr
(100, 100)

بالطريقة نفسها التي يعمل بها الفصل كقالب لإنشاء الكائنات ، يعمل metaclass كقالب لإنشاء الفئات. يشار إلى Metaclasses أحيانًا بمصانع الطبقة.

قارن بين المثالين التاليين:

مصنع الكائن:

>>> class Foo:
...     def __init__(self):
...         self.attr = 100
...

>>> x = Foo()
>>> x.attr
100

>>> y = Foo()
>>> y.attr
100

>>> z = Foo()
>>> z.attr
100

مصنع كلاس:

>>> class Meta(type):
...     def __init__(
...         cls, name, bases, dct
...     ):
...         cls.attr = 100
...
>>> class X(metaclass=Meta):
...     pass
...
>>> X.attr
100

>>> class Y(metaclass=Meta):
...     pass
...
>>> Y.attr
100

>>> class Z(metaclass=Meta):
...     pass
...
>>> Z.attr
100

هل هذا حقا ضروري؟

بسيط مثل مثال مصنع الفئة أعلاه ، فهو جوهر كيفية عمل metaclasses. أنها تسمح بتخصيص إنشاء مثيل للفئة.

ومع ذلك ، هناك الكثير من الجلبة فقط لمنح سمة السمات المخصصة لكل فئة تم إنشاؤها حديثًا. هل تحتاج حقًا إلى metaclass فقط من أجل ذلك؟

في بايثون ، هناك طريقتان أخريان على الأقل يمكن من خلالها تحقيق الشيء نفسه بشكل فعال:

الميراث البسيط:

>>> class Base:
...     attr = 100
...

>>> class X(Base):
...     pass
...

>>> class Y(Base):
...     pass
...

>>> class Z(Base):
...     pass
...

>>> X.attr
100
>>> Y.attr
100
>>> Z.attr
100

مصمم فئة:

>>> def decorator(cls):
...     class NewClass(cls):
...         attr = 100
...     return NewClass
...
>>> @decorator
... class X:
...     pass
...
>>> @decorator
... class Y:
...     pass
...
>>> @decorator
... class Z:
...     pass
...

>>> X.attr
100
>>> Y.attr
100
>>> Z.attr
100

خاتمة

كما يقترح تيم بيترز ، يمكن أن تنحرف الطبقات الوصفية بسهولة إلى عالم كونها “حل بحثًا عن مشكلة”. ليس من الضروري عادةً إنشاء فئات وصفية مخصصة. إذا كان من الممكن حل المشكلة المطروحة بطريقة أبسط ، فمن المحتمل أن تكون كذلك. ومع ذلك ، من المفيد فهم الفصول الوصفية بحيث تفهم فئات بايثون بشكل عام ويمكن أن تتعرف على ما إذا كانت metaclass هي الأداة المناسبة للاستخدام.

The post ميتاكلاس بايثون appeared first on فيلم تعلم البرمجيات للطالب العربي.

• الاستثناءات مقابل الأخطاء النحوية
  
• رفع استثناء
  
• استثناء AssertionError
  
• كتلة المحاولة والاستثناء: معالجة الاستثناءات
  
• شرط آخر
  
• التنظيف بعد الاستخدام أخيرًا
  
• تلخيص لما سبق
  

ينتهي برنامج بايثون بمجرد أن يواجه خطأ. في Python ، يمكن أن يكون الخطأ خطأ نحويًا أو استثناءً. في هذه المقالة ، سترى ما هو الاستثناء وكيف يختلف عن الخطأ النحوي. بعد ذلك ، ستتعرف على كيفية رفع الاستثناءات وتقديم التأكيدات. بعد ذلك ، ستنتهي مع عرض توضيحي لمحاولة الاستثناء.

الاستثناءات مقابل الأخطاء النحوية

تحدث أخطاء بناء الجملة عندما يكتشف المحلل اللغوي عبارة غير صحيحة. لاحظ المثال التالي:

>>> print( 0 / 0 ))
  File "<stdin>", line 1
    print( 0 / 0 ))
                  ^
SyntaxError: invalid syntax

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

>>> print( 0 / 0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

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

بدلاً من إظهار خطأ استثناء الرسالة ، توضح Python نوع خطأ الاستثناء الذي تمت مواجهته. في هذه الحالة ، كان خطأ ZeroDivisionError. تأتي Python مع العديد من الاستثناءات المضمنة بالإضافة إلى إمكانية إنشاء استثناءات محددة ذاتيًا.

رفع استثناء

يمكننا استخدام الزيادة لطرح استثناء في حالة حدوث شرط. يمكن استكمال البيان مع استثناء مخصص.

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

x = 10
if x > 5:
    raise Exception('x should not exceed 5. The value of x was: {}'.format(x))

عند تشغيل هذا الرمز ، سيكون الإخراج كما يلي:

Traceback (most recent call last):
  File "<input>", line 4, in <module>
Exception: x should not exceed 5. The value of x was: 10

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

استثناء AssertionError

بدلاً من انتظار تعطل البرنامج في منتصف الطريق ، يمكنك أيضًا البدء بتأكيد في Python. نؤكد أنه تم استيفاء شرط معين. إذا تبين أن هذا الشرط صحيح ، فهذا ممتاز! يمكن أن يستمر البرنامج. إذا تبين أن الشرط خاطئ ، فيمكنك جعل البرنامج يطرح استثناء AssertionError.

ألق نظرة على المثال التالي ، حيث تم التأكيد على أن الكود سيتم تنفيذه على نظام Linux:

import sys
assert ('linux' in sys.platform), "This code runs on Linux only."

إذا قمت بتشغيل هذا الرمز على جهاز Linux ، فسيتم تمرير التأكيد. إذا كنت ستقوم بتشغيل هذا الرمز على جهاز يعمل بنظام Windows ، فستكون نتيجة التأكيد False وستكون النتيجة كما يلي:

Traceback (most recent call last):
  File "<input>", line 2, in <module>
AssertionError: This code runs on Linux only.

في هذا المثال ، يعد طرح استثناء AssertionError هو آخر شيء سيفعله البرنامج. سيتوقف البرنامج ولن يستمر. ماذا لو لم يكن هذا ما تريده؟

كتلة المحاولة والاستثناء: معالجة الاستثناءات

تُستخدم كتلة try and except في Python للقبض على الاستثناءات ومعالجتها. تنفذ Python التعليمات البرمجية التي تلي تعليمة try كجزء “عادي” من البرنامج. الكود الذي يتبع تعليمة الاستثناء هو استجابة البرنامج لأي استثناءات في عبارة try السابقة.

كما رأيت سابقًا ، عندما تصطدم الشفرة الصحيحة من الناحية التركيبية بخطأ ، فإن Python ستطلق خطأ استثناء. سيؤدي خطأ الاستثناء هذا إلى تعطل البرنامج إذا لم تتم معالجته. يحدد بند الاستثناء كيف يستجيب برنامجك للاستثناءات.

يمكن أن تساعدك الوظيفة التالية في فهم كتلة المحاولة والاستثناء:

def linux_interaction():
    assert ('linux' in sys.platform), "Function can only run on Linux systems."
    print('Doing something.')

يمكن تشغيل linux_interaction () على نظام Linux فقط. سوف يطرح التأكيد في هذه الوظيفة استثناء AssertionError إذا قمت باستدعائه على نظام تشغيل آخر غير Linux.

يمكنك تجربة الوظيفة باستخدام الكود التالي:

try:
    linux_interaction()
except:
    pass

الطريقة التي تعاملت بها مع الخطأ هنا هي بتسليمك تمريرة. إذا كنت ستقوم بتشغيل هذا الرمز على جهاز يعمل بنظام Windows ، فستحصل على الإخراج التالي:

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

try:
    linux_interaction()
except:
    print('Linux function was not executed')

قم بتنفيذ هذا الرمز على جهاز يعمل بنظام Windows:

Linux function was not executed

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

ما لم تراه هو نوع الخطأ الذي تم إلقاؤه نتيجة لاستدعاء الوظيفة. لكي ترى الخطأ الذي حدث بالضبط ، ستحتاج إلى اكتشاف الخطأ الذي أحدثته الوظيفة.

الكود التالي هو مثال حيث يمكنك التقاط AssertionError وإخراج تلك الرسالة إلى الشاشة:

try:
    linux_interaction()
except AssertionError as error:
    print(error)
    print('The linux_interaction() function was not executed')

يؤدي تشغيل هذه الوظيفة على جهاز يعمل بنظام Windows إلى ما يلي:

Function can only run on Linux systems.
The linux_interaction() function was not executed

الرسالة الأولى هي AssertionError ، تخبرك أنه لا يمكن تنفيذ الوظيفة إلا على جهاز Linux. تخبرك الرسالة الثانية بالوظيفة التي لم يتم تنفيذها.

في المثال السابق ، قمت باستدعاء دالة كتبتها بنفسك. عند تنفيذ الوظيفة ، اكتشفت استثناء AssertionError وطباعته على الشاشة.

إليك مثال آخر حيث تفتح ملفًا وتستخدم استثناءًا مضمنًا:

try:
    with open('file.log') as file:
        read_data = file.read()
except:
    print('Could not open file.log')

إذا لم يكن file.log موجودًا ، فستخرج كتلة التعليمات البرمجية هذه ما يلي:

Could not open file.log

هذه رسالة إعلامية ، وسيستمر تشغيل برنامجنا. في مستندات Python ، يمكنك أن ترى أن هناك الكثير من الاستثناءات المضمنة التي يمكنك استخدامها هنا. الاستثناء الوحيد الموضح في تلك الصفحة هو ما يلي:

استثناء FileNotFoundError

يُطلق عند طلب ملف أو دليل ولكنه غير موجود. يتوافق مع errno ENOENT.

للقبض على هذا النوع من الاستثناءات وطباعته على الشاشة ، يمكنك استخدام الكود التالي:

try:
    with open('file.log') as file:
        read_data = file.read()
except FileNotFoundError as fnf_error:
    print(fnf_error)

في هذه الحالة ، إذا لم يكن file.log موجودًا ، فسيكون الإخراج كما يلي:

[Errno 2] No such file or directory: 'file.log'

يمكن أن يكون لديك أكثر من استدعاء دالة في جملة try وتوقع اصطياد استثناءات مختلفة. الشيء الذي يجب ملاحظته هنا هو أن الكود في جملة try سيتوقف بمجرد مواجهة استثناء.

تحذير: Catching Exception يخفي كل الأخطاء … حتى تلك غير المتوقعة تمامًا. هذا هو السبب في أنه يجب عليك تجنب البنود العارية باستثناء البنود في برامج بايثون الخاصة بك. بدلاً من ذلك ، سترغب في الرجوع إلى فئات استثناء محددة تريد التقاطها والتعامل معها. يمكنك معرفة المزيد حول سبب اعتبار هذه فكرة جيدة في هذا البرنامج التعليمي.

انظر إلى الكود التالي. هنا ، تقوم أولاً باستدعاء الدالة linux_interaction () ثم تحاول فتح ملف:

try:
    linux_interaction()
    with open('file.log') as file:
        read_data = file.read()
except FileNotFoundError as fnf_error:
    print(fnf_error)
except AssertionError as error:
    print(error)
    print('Linux linux_interaction() function was not executed')

إذا لم يكن الملف موجودًا ، فسيؤدي تشغيل هذا الرمز على جهاز يعمل بنظام Windows إلى إخراج ما يلي:

Function can only run on Linux systems.
Linux linux_interaction() function was not executed

داخل جملة try ، واجهت استثناء على الفور ولم تصل إلى الجزء الذي تحاول فيه فتح file.log. انظر الآن إلى ما يحدث عند تشغيل الكود على جهاز Linux:

[Errno 2] No such file or directory: 'file.log'

فيما يلي النقاط الرئيسية:

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

شرط آخر

في Python ، باستخدام تعليمة else ، يمكنك توجيه برنامج لتنفيذ كتلة معينة من التعليمات البرمجية فقط في حالة عدم وجود استثناءات.

ننظر إلى المثال التالي:

try:
    linux_interaction()
except AssertionError as error:
    print(error)
else:
    print('Executing the else clause.')

إذا كنت ستقوم بتشغيل هذا الرمز على نظام Linux ، فسيكون الإخراج كما يلي:

Doing something.
Executing the else clause.

نظرًا لأن البرنامج لم يتم تشغيله في أي استثناءات ، تم تنفيذ جملة else.

يمكنك أيضًا محاولة تشغيل التعليمات البرمجية داخل جملة else والتقاط الاستثناءات المحتملة هناك أيضًا:

try:
    linux_interaction()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)

إذا كنت ستقوم بتنفيذ هذا الرمز على جهاز Linux ، فستحصل على النتيجة التالية:

Doing something.
[Errno 2] No such file or directory: 'file.log'

من الإخراج ، يمكنك أن ترى أن وظيفة linux_interaction () تعمل. بسبب عدم وجود استثناءات ، تم إجراء محاولة لفتح file.log. هذا الملف غير موجود ، وبدلاً من فتح الملف ، اكتشفت استثناء FileNotFoundError.

التنظيف بعد الاستخدام أخيرًا

تخيل أنه كان عليك دائمًا تنفيذ نوع من الإجراءات للتنظيف بعد تنفيذ التعليمات البرمجية الخاصة بك. تمكنك لغة بايثون من القيام بذلك باستخدام الجملة النهائية.

ألق نظرة على المثال التالي:

try:
    linux_interaction()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('Cleaning up, irrespective of any exceptions.')

في الكود السابق ، سيتم تنفيذ كل شيء في الجملة النهائية. لا يهم إذا واجهت استثناء في مكان ما في جمل try أو else. سيؤدي تشغيل الكود السابق على جهاز يعمل بنظام Windows إلى إخراج ما يلي:

Function can only run on Linux systems.
Cleaning up, irrespective of any exceptions.

تلخيص لما سبق

بعد رؤية الفرق بين أخطاء بناء الجملة والاستثناءات ، تعلمت طرقًا مختلفة لرفع الاستثناءات والتقاطها والتعامل معها في Python. في هذه المقالة ، رأيت الخيارات التالية:

• يسمح لك رفع استثناء في أي وقت.
  
• يمكنك التأكيد من التحقق مما إذا تم استيفاء شرط معين ورمي استثناء إذا لم يكن كذلك.
  
• في جملة try ، يتم تنفيذ جميع العبارات حتى يتم مواجهة استثناء.
  
• يتم استخدام ما عدا لالتقاط ومعالجة الاستثناء (الاستثناءات) التي تمت مواجهتها في عبارة try.
  
• يتيح لك else أقسام التعليمات البرمجية التي يجب تشغيلها فقط عند عدم وجود استثناءات في جملة try.
  
• يتيح لك أخيرًا تنفيذ أقسام التعليمات البرمجية التي يجب تشغيلها دائمًا ، مع أو بدون أي استثناءات تمت مواجهتها مسبقًا.
  

نأمل أن تساعدك هذه المقالة في فهم الأدوات الأساسية التي يجب أن تقدمها Python عند التعامل مع الاستثناءات.

The post استثناءات بايثون: مقدمة appeared first on فيلم تعلم البرمجيات للطالب العربي.

• مشكلة معالجة مسار ملف بايثون
  
• خلق المسارات
  
• قراءة وكتابة الملفات
  
• انتقاء مكونات المسار
  
• نقل وحذف الملفات
  
• أمثلة
  عد الملفات
  عرض شجرة الدليل
  ابحث عن آخر ملف تم تعديله
  قم بإنشاء اسم ملف فريد
  
• اختلافات نظام التشغيل
  
• المسارات ككائنات مناسبة
  
• خاتمة
  

هل واجهت صعوبة في التعامل مع مسار الملف في بايثون؟ في Python 3.4 وما فوق ، انتهى الصراع الآن! لم تعد بحاجة إلى خدش رأسك فوق التعليمات البرمجية مثل:

>>> path.rsplit('\\', maxsplit=1)[0]

أو الاستياء من الإسهاب في:

>>> os.path.isfile(os.path.join(os.path.expanduser('~'), 'realpython.txt'))

في هذا البرنامج التعليمي ، سوف ترى كيفية التعامل مع مسارات الملفات – أسماء الأدلة والملفات – في Python. ستتعلم طرقًا جديدة لقراءة الملفات وكتابتها ، ومعالجة المسارات ونظام الملفات الأساسي ، بالإضافة إلى الاطلاع على بعض الأمثلة حول كيفية سرد الملفات وتكرارها. باستخدام وحدة pathlib ، يمكن إعادة كتابة المثالين أعلاه باستخدام رمز Pythonic أنيق وقابل للقراءة مثل:

>>> path.parent
>>> (pathlib.Path.home() / 'realpython.txt').is_file()

مشكلة معالجة مسار ملف بايثون

يعد العمل مع الملفات والتفاعل مع نظام الملفات أمرًا مهمًا لأسباب عديدة مختلفة. قد تتضمن أبسط الحالات قراءة الملفات أو كتابتها فقط ، ولكن في بعض الأحيان تكون المهام الأكثر تعقيدًا في متناول اليد. ربما تحتاج إلى سرد جميع الملفات في دليل من نوع معين ، أو العثور على الدليل الأصل لملف معين ، أو إنشاء اسم ملف فريد غير موجود بالفعل.

تقليديًا ، تمثل Python مسارات الملفات باستخدام سلاسل نصية عادية. بدعم من مكتبة os.path القياسية ، كان هذا مناسبًا على الرغم من كونه مرهقًا بعض الشيء (كما يوضح المثال الثاني في المقدمة). ومع ذلك ، نظرًا لأن المسارات ليست سلاسل ، تنتشر الوظائف المهمة في جميع أنحاء المكتبة القياسية ، بما في ذلك المكتبات مثل os و glob و shutil. يحتاج المثال التالي إلى ثلاث عبارات استيراد فقط لنقل جميع الملفات النصية إلى دليل أرشيف:

import glob
import os
import shutil

for file_name in glob.glob('*.txt'):
    new_path = os.path.join('archive', file_name)
    shutil.move(file_name, new_path)

مع المسارات التي يتم تمثيلها بواسطة سلاسل ، من الممكن ، ولكن عادة ما تكون فكرة سيئة ، استخدام طرق سلسلة منتظمة. على سبيل المثال ، بدلاً من ضم مسارين مع + مثل السلاسل العادية ، يجب عليك استخدام os.path.join () ، الذي يربط المسارات باستخدام فاصل المسار الصحيح في نظام التشغيل. تذكر أن Windows يستخدم \ بينما يستخدم Mac و Linux / كفاصل. يمكن أن يؤدي هذا الاختلاف إلى أخطاء يصعب تحديدها ، مثل مثالنا الأول في المقدمة الذي يعمل مع مسارات Windows فقط.

تم تقديم وحدة pathlib في Python 3.4 (PEP 428) للتعامل مع هذه التحديات. إنه يجمع الوظائف الضرورية في مكان واحد ويجعلها متاحة من خلال الأساليب والخصائص على كائن مسار سهل الاستخدام.

في وقت مبكر ، لا تزال الحزم الأخرى تستخدم سلاسل لمسارات الملفات ، ولكن اعتبارًا من Python 3.6 ، يتم دعم وحدة pathlib في جميع أنحاء المكتبة القياسية ، ويرجع ذلك جزئيًا إلى إضافة بروتوكول مسار نظام الملفات. إذا كنت عالقًا في Python القديمة ، فهناك أيضًا منفذ خلفي متاح لـ Python 2.

حان وقت العمل: دعونا نرى كيف يعمل pathlib عمليًا.

خلق المسارات

كل ما تحتاج إلى معرفته حقًا هو فئة pathlib.Path. هناك عدة طرق مختلفة لإنشاء المسار. أولاً وقبل كل شيء ، هناك طرق فصل مثل .cwd () (دليل العمل الحالي) و .home () (الدليل الرئيسي للمستخدم):

>>> import pathlib
>>> pathlib.Path.cwd()
PosixPath('/home/gahjelle/realpython/')

ملاحظة: خلال هذا البرنامج التعليمي ، سنفترض أن pathlib قد تم استيراده ، دون توضيح استيراد pathlib على النحو الوارد أعلاه. نظرًا لأنك ستستخدم فئة المسار بشكل أساسي ، يمكنك أيضًا القيام بذلك من pathlib import Path وكتابة Path بدلاً من pathlib.Path.

يمكن أيضًا إنشاء المسار بشكل صريح من تمثيل السلسلة الخاص به:

>>> pathlib.Path(r'C:\Users\gahjelle\realpython\file.txt')
WindowsPath('C:/Users/gahjelle/realpython/file.txt')

نصيحة صغيرة للتعامل مع مسارات Windows: في Windows ، يكون فاصل المسار عبارة عن شرطة مائلة للخلف ، \. ومع ذلك ، في العديد من السياقات ، تُستخدم الشرطة المائلة العكسية أيضًا كحرف هروب من أجل تمثيل الأحرف غير القابلة للطباعة. لتجنب المشاكل ، استخدم القيم الحرفية للسلسلة الأولية لتمثيل مسارات Windows. هذه عبارة عن سلسلة حرفية لها حرف r مُسبق لها. في سلسلة الأحرف الأولية ، يمثل \ خط مائل عكسي حرفي: r’C: \ Users ‘.

الطريقة الثالثة لبناء مسار هي الانضمام إلى أجزاء المسار باستخدام عامل التشغيل الخاص /. يتم استخدام عامل تشغيل الشرطة المائلة للأمام بشكل مستقل عن فاصل المسار الفعلي على المنصة:

>>> pathlib.Path.home() / 'python' / 'scripts' / 'test.py'
PosixPath('/home/gahjelle/python/scripts/test.py')

يمكن أن يصل / إلى عدة مسارات أو مزيج من المسارات والسلاسل (على النحو الوارد أعلاه) طالما أن هناك كائن مسار واحد على الأقل. إذا لم تعجبك الخاص / الترميز ، يمكنك فعل الشيء نفسه باستخدام طريقة .joinpath ():

>>> pathlib.Path.home().joinpath('python', 'scripts', 'test.py')
PosixPath('/home/gahjelle/python/scripts/test.py')

لاحظ أنه في الأمثلة السابقة ، يتم تمثيل pathlib.Path إما بواسطة WindowsPath أو PosixPath. يعتمد الكائن الفعلي الذي يمثل المسار على نظام التشغيل الأساسي. (بمعنى ، تم تشغيل مثال WindowsPath على نظام التشغيل Windows ، بينما تم تشغيل أمثلة PosixPath على نظام التشغيل Mac أو Linux.) راجع قسم “اختلافات نظام التشغيل” لمزيد من المعلومات.

قراءة وكتابة الملفات

تقليديًا ، كانت طريقة قراءة أو كتابة ملف في Python هي استخدام وظيفة open () المضمنة. لا يزال هذا صحيحًا لأن الوظيفة open () يمكنها استخدام كائنات المسار مباشرةً. يعثر المثال التالي على جميع الرؤوس في ملف Markdown ويطبعها:

path = pathlib.Path.cwd() / 'test.md'
with open(path, mode='r') as fid:
    headers = [line.strip() for line in fid if line.startswith('#')]
print('\n'.join(headers))

بديل مكافئ هو استدعاء .open () على كائن المسار:

with path.open(mode='r') as fid:
    ...

في الواقع ، يقوم Path.open () باستدعاء العنصر الداخلي open () خلف الكواليس. الخيار الذي تستخدمه هو في الأساس مسألة ذوق.

لقراءة الملفات وكتابتها بشكل بسيط ، هناك طريقتان ملائمتان في مكتبة pathlib:

• .read_text (): افتح المسار في وضع النص وأعد المحتويات كسلسلة.
  
• .read_bytes (): افتح المسار في الوضع الثنائي / البايت وأعد المحتويات كاختبار بايت.
  
• .write_text (): افتح المسار واكتب بيانات السلسلة إليه.
  
• .write_bytes (): افتح المسار في الوضع الثنائي / بايت واكتب البيانات إليه.
  

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

>>> path = pathlib.Path.cwd() / 'test.md'
>>> path.read_text()
<the contents of the test.md-file>

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

>>> pathlib.Path('test.md').read_text()
<the contents of the test.md-file>

سيجد الأسلوب .resolve () المسار الكامل. أدناه ، نؤكد أن دليل العمل الحالي يُستخدم لأسماء الملفات البسيطة:

>>> path = pathlib.Path('test.md')
>>> path.resolve()
PosixPath('/home/gahjelle/realpython/test.md')

>>> path.resolve().parent == pathlib.Path.cwd()
True

>>> path.parent == pathlib.Path.cwd()
False

لاحظ أنه عند مقارنة المسارات ، يتم مقارنة تمثيلاتها. في المثال أعلاه ، path.parent لا يساوي pathlib.Path.cwd () ، لأن path.parent يتم تمثيله بواسطة “.” بينما يتم تمثيل pathlib.Path.cwd () بـ “/ home / gahjelle / realpython /”.

انتقاء مكونات المسار

الأجزاء المختلفة من المسار متوفرة بسهولة كخصائص. تشمل الأمثلة الأساسية ما يلي:

• .name: اسم الملف بدون أي دليل
  
• .parent: الدليل الذي يحتوي على الملف ، أو الدليل الأصل إذا كان المسار عبارة عن دليل
  
• .stem: اسم الملف بدون اللاحقة
  
• .suffix: امتداد الملف
  
• .anchor: جزء المسار قبل الدلائل
  

فيما يلي هذه الخصائص قيد التشغيل:

>>> path
PosixPath('/home/gahjelle/realpython/test.md')
>>> path.name
'test.md'
>>> path.stem
'test'
>>> path.suffix
'.md'
>>> path.parent
PosixPath('/home/gahjelle/realpython')
>>> path.parent.parent
PosixPath('/home/gahjelle')
>>> path.anchor
'/'

لاحظ أن .parent ترجع كائن مسار جديد ، بينما تقوم الخصائص الأخرى بإرجاع سلاسل. هذا يعني على سبيل المثال أنه يمكن ربط .parent كما في المثال الأخير أو حتى دمجها مع / لإنشاء مسارات جديدة تمامًا:

>>> path.parent.parent / ('new' + path.suffix)
PosixPath('/home/gahjelle/new.md')

توفر ورقة غش Pathlib الممتازة تمثيلًا مرئيًا لهذه الخصائص والطرق وغيرها.

نقل وحذف الملفات

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

لنقل ملف ، استخدم .replace (). لاحظ أنه إذا كانت الوجهة موجودة بالفعل ، فسيحل محلها .replace (). لسوء الحظ ، لا يدعم pathlib صراحة النقل الآمن للملفات. لتجنب احتمال الكتابة فوق مسار الوجهة ، فإن أبسط شيء هو اختبار ما إذا كانت الوجهة موجودة قبل استبدال:

if not destination.exists():
    source.replace(destination)

ومع ذلك ، فإن هذا يترك الباب مفتوحًا لظروف السباق المحتملة. قد تضيف عملية أخرى ملفًا في مسار الوجهة بين تنفيذ تعليمة if وطريقة .replace (). إذا كان هذا مصدر قلق ، فإن الطريقة الأكثر أمانًا هي فتح مسار الوجهة لإنشاء حصري ونسخ بيانات المصدر بشكل صريح:

with destination.open(mode='xb') as fid:
    fid.write(source.read_bytes())

سيؤدي الكود أعلاه إلى رفع FileExistsError إذا كانت الوجهة موجودة بالفعل. من الناحية الفنية ، هذا ينسخ ملفًا. لإجراء نقل ، ما عليك سوى حذف المصدر بعد الانتهاء من النسخ (انظر أدناه). تأكد من عدم وجود استثناء على الرغم من.

عندما تعيد تسمية الملفات ، قد تكون الطرق المفيدة .with_name () و .with_suffix (). كلاهما يعيد المسار الأصلي ولكن مع استبدال الاسم أو اللاحقة ، على التوالي.

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

>>> path
PosixPath('/home/gahjelle/realpython/test001.txt')
>>> path.with_suffix('.py')
PosixPath('/home/gahjelle/realpython/test001.py')
>>> path.replace(path.with_suffix('.py'))

يمكن حذف الدلائل والملفات باستخدام .rmdir () و .unlink () على التوالي. (مرة أخرى ، كن حذرا!)

أمثلة

في هذا القسم ، سترى بعض الأمثلة على كيفية استخدام pathlib للتعامل مع التحديات البسيطة.

عد الملفات

هناك عدة طرق مختلفة لسرد العديد من الملفات. أبسطها هي طريقة .iterdir () ، والتي تتكرر عبر جميع الملفات في الدليل المحدد. يجمع المثال التالي بين .iterdir () والمجموعات. فئة Counter لحساب عدد الملفات الموجودة لكل نوع ملف في الدليل الحالي:

>>> import collections
>>> collections.Counter(p.suffix for p in pathlib.Path.cwd().iterdir())
Counter({'.md': 2, '.txt': 4, '.pdf': 2, '.py': 1})

يمكن إنشاء قوائم ملفات أكثر مرونة باستخدام الأساليب .glob () و .rglob () (الكرة العودية العودية). على سبيل المثال ، يقوم pathlib.Path.cwd (). glob (‘*. txt’) بإرجاع جميع الملفات التي تحتوي على لاحقة .txt في الدليل الحالي. فيما يلي فقط أنواع الملفات التي تبدأ بـ p:

>>> import collections
>>> collections.Counter(p.suffix for p in pathlib.Path.cwd().glob('*.p*'))
Counter({'.pdf': 2, '.py': 1})

عرض شجرة الدليل

يحدد المثال التالي دالة ، الشجرة () ، والتي ستطبع شجرة مرئية تمثل التسلسل الهرمي للملف ، متجذرة في دليل معين. هنا ، نريد سرد الأدلة الفرعية أيضًا ، لذلك نستخدم طريقة .rglob ():

def tree(directory):
    print(f'+ {directory}')
    for path in sorted(directory.rglob('*')):
        depth = len(path.relative_to(directory).parts)
        spacer = '    ' * depth
        print(f'{spacer}+ {path.name}')

لاحظ أننا نحتاج إلى معرفة المسافة البُعدية التي يقع فيها الملف عن الدليل الجذر. للقيام بذلك ، نستخدم أولاً .relative_to () لتمثيل مسار متعلق بالدليل الجذر. بعد ذلك ، نحسب عدد الأدلة (باستخدام خاصية .parts) في التمثيل. عند التشغيل ، تنشئ هذه الوظيفة شجرة مرئية مثل ما يلي:

>>> tree(pathlib.Path.cwd())
+ /home/gahjelle/realpython
    + directory_1
        + file_a.md
    + directory_2
        + file_a.md
        + file_b.pdf
        + file_c.py
    + file_1.txt
    + file_2.txt

ملاحظة: لا تعمل سلاسل f إلا في Python 3.6 والإصدارات الأحدث. في لغة Pythons الأقدم ، يمكن كتابة التعبير f ‘{spacer} + {path.name}’ {0} + {1} ‘. (spacer، path.name).

ابحث عن آخر ملف تم تعديله

تعتبر طرق .iterdir () و .glob () و .rglob () مناسبة جدًا لتعبيرات المولد وفهم القوائم. للعثور على الملف في دليل تم تعديله مؤخرًا ، يمكنك استخدام طريقة .stat () للحصول على معلومات حول الملفات الأساسية. على سبيل المثال ، يعطي .stat (). st_mtime وقت آخر تعديل لملف:

>>> from datetime import datetime
>>> time, file_path = max((f.stat().st_mtime, f) for f in directory.iterdir())
>>> print(datetime.fromtimestamp(time), file_path)
2018-03-23 19:23:56.977817 /home/gahjelle/realpython/test001.txt

يمكنك حتى الحصول على محتويات الملف الذي تم تعديله آخر مرة بتعبير مشابه:

>>> max((f.stat().st_mtime, f) for f in directory.iterdir())[1].read_text()
<the contents of the last modified file in directory>

يمثل الطابع الزمني الذي تم إرجاعه من خصائص .stat (). st_ المختلفة الثواني منذ الأول من يناير 1970. بالإضافة إلى datetime.fromtimestamp ، يمكن استخدام time.localtime أو time.ctime لتحويل الطابع الزمني إلى شيء أكثر قابلية للاستخدام.

قم بإنشاء اسم ملف فريد

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

def unique_path(directory, name_pattern):
    counter = 0
    while True:
        counter += 1
        path = directory / name_pattern.format(counter)
        if not path.exists():
            return path

path = unique_path(pathlib.Path.cwd(), 'test{:03d}.txt')

إذا كان الدليل يحتوي بالفعل على الملفين test001.txt و test002.txt ، فسيقوم الرمز أعلاه بتعيين المسار إلى test003.txt.

اختلافات نظام التشغيل

لاحظنا سابقًا أنه عندما قمنا بإنشاء مثيل لـ pathlib.Path ، تم إرجاع كائن WindowsPath أو PosixPath. يعتمد نوع الكائن على نظام التشغيل الذي تستخدمه. هذه الميزة تجعل من السهل إلى حد ما كتابة رمز متوافق عبر الأنظمة الأساسية. من الممكن أن تطلب WindowsPath أو PosixPath صراحة ، لكنك ستقتصر رمزك على هذا النظام فقط دون أي فوائد. لا يمكن استخدام مسار ملموس مثل هذا في نظام مختلف:

>>> pathlib.WindowsPath('test.md')
NotImplementedError: cannot instantiate 'WindowsPath' on your system

قد تكون هناك أوقات تحتاج فيها إلى تمثيل المسار دون الوصول إلى نظام الملفات الأساسي (في هذه الحالة قد يكون من المنطقي أيضًا تمثيل مسار Windows على نظام بخلاف Windows أو العكس). يمكن القيام بذلك باستخدام كائنات PurePath. تدعم هذه الكائنات العمليات التي تمت مناقشتها في القسم الخاص بمكونات المسار ولكن ليس الطرق التي تصل إلى نظام الملفات:

>>> path = pathlib.PureWindowsPath(r'C:\Users\gahjelle\realpython\file.txt')
>>> path.name
'file.txt'
>>> path.parent
PureWindowsPath('C:/Users/gahjelle/realpython')
>>> path.exists()
AttributeError: 'PureWindowsPath' object has no attribute 'exists'

يمكنك إنشاء مثيل PureWindowsPath أو PurePosixPath مباشرة على جميع الأنظمة. سيؤدي Instantiating PurePath إلى إرجاع أحد هذه الكائنات اعتمادًا على نظام التشغيل الذي تستخدمه.

المسارات ككائنات مناسبة

في المقدمة ، لاحظنا بإيجاز أن المسارات ليست سلاسل ، والدافع وراء pathlib هو تمثيل نظام الملفات بالكائنات المناسبة. في الواقع ، التوثيق الرسمي لـ pathlib هو pathlib – مسارات نظام الملفات الموجهة للكائنات. إن النهج الموجه للكائنات مرئي بالفعل في الأمثلة أعلاه (خاصة إذا كنت تتناقض مع طريقة os.path القديمة للقيام بالأشياء). ومع ذلك ، دعني أترك لك بعض الحكايات الأخرى.

بصرف النظر عن نظام التشغيل الذي تستخدمه ، يتم تمثيل المسارات بأسلوب Posix ، مع استخدام الشرطة المائلة للأمام كفاصل للمسار. في Windows ، سترى شيئًا كهذا:

>>> pathlib.Path(r'C:\Users\gahjelle\realpython\file.txt')
WindowsPath('C:/Users/gahjelle/realpython/file.txt')

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

>>> str(pathlib.Path(r'C:\Users\gahjelle\realpython\file.txt'))
'C:\\Users\\gahjelle\\realpython\\file.txt'

هذا مفيد بشكل خاص إذا كنت تستخدم مكتبة لا تعرف كيفية التعامل مع كائنات pathlib.Path. هذه مشكلة أكبر في إصدارات Python قبل 3.6. على سبيل المثال ، في Python 3.5 ، يمكن لمكتبة configparser القياسية استخدام مسارات سلسلة فقط لقراءة الملفات. طريقة معالجة مثل هذه الحالات هي القيام بالتحويل إلى سلسلة بشكل صريح:

>>> from configparser import ConfigParser
>>> path = pathlib.Path('config.txt')
>>> cfg = ConfigParser()
>>> cfg.read(path)                     # Error on Python < 3.6
TypeError: 'PosixPath' object is not iterable
>>> cfg.read(str(path))                # Works on Python >= 3.4
['config.txt']

في Python 3.6 والإصدارات الأحدث ، يوصى باستخدام os.fspath () بدلاً من str () إذا كنت بحاجة إلى إجراء تحويل صريح. يعد هذا أكثر أمانًا لأنه سيؤدي إلى حدوث خطأ إذا حاولت عن طريق الخطأ تحويل كائن لا يشبه المسار.

من المحتمل أن يكون الجزء الأكثر غرابة من مكتبة pathlib هو استخدام العامل /. لإلقاء نظرة خاطفة على الغطاء ، دعونا نرى كيف يتم تنفيذ ذلك. هذا مثال على التحميل الزائد للمشغل: يتغير سلوك المشغل حسب السياق. لقد رأيت هذا من قبل. فكر في كيف + تعني أشياء مختلفة للسلاسل والأرقام. تنفذ Python التحميل الزائد للمشغل من خلال استخدام أساليب الشرطة السفلية المزدوجة (المعروفة أيضًا بأساليب dunder).

يتم تحديد عامل التشغيل / بواسطة طريقة .__ truediv __ (). في الواقع ، إذا ألقيت نظرة على الكود المصدري لـ pathlib ، فسترى شيئًا مثل:

class PurePath(object):

    def __truediv__(self, key):
        return self._make_child((key,))

خاتمة

منذ Python 3.4 ، أصبح pathlib متاحًا في المكتبة القياسية. باستخدام pathlib ، يمكن تمثيل مسارات الملفات بواسطة كائنات المسار المناسبة بدلاً من السلاسل العادية كما في السابق. هذه الكائنات تجعل التعليمات البرمجية تتعامل مع مسارات الملفات:

• أسهل للقراءة ، خاصةً لأنه / يُستخدم لربط المسارات معًا
  
• أكثر قوة ، مع توفر معظم الأساليب والخصائص الضرورية مباشرة على الكائن
  
• أكثر اتساقًا عبر أنظمة التشغيل ، حيث يتم إخفاء خصائص الأنظمة المختلفة بواسطة كائن المسار
  

في هذا البرنامج التعليمي ، رأيت كيفية إنشاء كائنات المسار ، وقراءة الملفات وكتابتها ، ومعالجة المسارات ونظام الملفات الأساسي ، بالإضافة إلى بعض الأمثلة عن كيفية التكرار عبر العديد من مسارات الملفات.

The post وحدة مسار بايثون 3: ترويض نظام الملفات appeared first on فيلم تعلم البرمجيات للطالب العربي.

• تاريخ موجز (جدًا) لـ JSON
  
• انظروا ، إنه JSON!
  
• لغة Python تدعم JSON أصلاً!
  القليل من المفردات
  تسلسل JSON
  مثال بسيط على التسلسل
  بعض حجج الكلمات الرئيسية المفيدة
  إلغاء تسلسل JSON
  مثال بسيط على إلغاء التسلسل
  
• مثال من العالم الحقيقي (نوعًا ما)
  
• ترميز وفك ترميز كائنات Python المخصصة
  تبسيط هياكل البيانات
  ترميز أنواع مخصصة
  أنواع مخصصة فك التشفير
  
• كله تمام!
  

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

لحسن الحظ ، هذه مهمة شائعة جدًا ، وكما هو الحال مع المهام الأكثر شيوعًا ، فإن بايثون تجعلها سهلة بشكل مثير للاشمئزاز. لا تخف يا رفاق بايثونير و بايثونيستاس. هذا سيكون نسيم!

إذن ، نستخدم JSON لتخزين البيانات وتبادلها؟ نعم ، لقد حصلت عليه! إنه ليس أكثر من تنسيق قياسي يستخدمه المجتمع لتمرير البيانات. ضع في اعتبارك أن JSON ليس التنسيق الوحيد المتاح لهذا النوع من العمل ، ولكن XML و YAML هما على الأرجح التنسيقان الآخران الوحيدان اللذان يستحق الذكر في نفس الوقت.

تاريخ موجز (جدًا) لـ JSON

ليس من المستغرب أن JavaScript Object Notation مستوحى من مجموعة فرعية من لغة برمجة JavaScript التي تتعامل مع بناء الجملة الحرفية للكائن. لديهم موقع أنيق يشرح الأمر برمته. لا داعي للقلق: لقد أصبحت JSON منذ فترة طويلة حيادية اللغة وهي موجودة كمعيارها الخاص ، لذلك يمكننا لحسن الحظ تجنب JavaScript من أجل هذه المناقشة.

في النهاية ، اعتمد المجتمع ككل JSON لأنه من السهل على كل من البشر والآلات الإنشاء والفهم.

انظروا ، إنه JSON!

إستعد. أنا على وشك أن أريكم بعض صور JSON الواقعية – تمامًا كما كنت سترى هناك في البرية. لا بأس: من المفترض أن تكون لغة JSON قابلة للقراءة من قبل أي شخص يستخدم لغة من النمط C ، و Python هي لغة من النمط C … لذلك هذا أنت!

{
    "firstName": "Jane",
    "lastName": "Doe",
    "hobbies": ["running", "sky diving", "singing"],
    "age": 35,
    "children": [
        {
            "firstName": "Alice",
            "age": 6
        },
        {
            "firstName": "Bob",
            "age": 8
        }
    ]
}

كما ترى ، يدعم JSON الأنواع الأولية ، مثل السلاسل والأرقام ، بالإضافة إلى القوائم والكائنات المتداخلة.

انتظر ، هذا يشبه قاموس بايثون! أنا أوافق؟ إنه رمز كائن عالمي إلى حد كبير في هذه المرحلة ، لكنني لا أعتقد أن UON يتدحرج على لسانه بشكل جيد تمامًا. لا تتردد في مناقشة البدائل في التعليقات.

يا للعجب! لقد نجوت من مواجهتك الأولى مع بعض JSON البرية. الآن تحتاج فقط إلى تعلم كيفية ترويضها.

لغة Python تدعم JSON أصلاً!

تأتي Python مع حزمة مدمجة تسمى json لتشفير وفك تشفير بيانات JSON.

فقط ارمي هذا الرجل الصغير في أعلى الملف الخاص بك:

import json

القليل من المفردات

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

ييكيس! هذا يبدو تقنيًا جدًا. قطعا. لكن في الواقع ، كل ما نتحدث عنه هنا هو القراءة والكتابة. فكر في الأمر على هذا النحو: الترميز هو لكتابة البيانات على القرص ، بينما فك التشفير هو لقراءة البيانات في الذاكرة.

تسلسل JSON

ماذا يحدث بعد معالجة الكمبيوتر للكثير من المعلومات؟ يجب أن تأخذ تفريغ البيانات. وفقًا لذلك ، تعرض مكتبة json طريقة التفريغ () لكتابة البيانات إلى الملفات. هناك أيضًا طريقة dumps () (تُنطق باسم “dump-s”) للكتابة إلى سلسلة Python.

يتم ترجمة كائنات Python البسيطة إلى JSON وفقًا لتحويل بديهي إلى حد ما.
Python JSON
كائن ديكت
قائمة ، مجموعة الصفيف
سلسلة str
عدد صحيح ، طويل ، عائم
حقيقي حقيقي
خطأ خطأ
لا شيء فارغ

مثال بسيط على التسلسل

تخيل أنك تعمل مع كائن Python في الذاكرة يبدو قليلاً مثل هذا:

data = {
    "president": {
        "name": "Zaphod Beeblebrox",
        "species": "Betelgeusian"
    }
}

من الأهمية بمكان أن تقوم بحفظ هذه المعلومات على القرص ، لذا فإن مهمتك هي كتابتها في ملف.

باستخدام مدير سياق Python ، يمكنك إنشاء ملف يسمى data_file.json وفتحه في وضع الكتابة. (تنتهي ملفات JSON بسهولة بامتداد .json.)

with open("data_file.json", "w") as write_file:
    json.dump(data, write_file)

لاحظ أن dump () يأخذ وسيطين موضعيين: (1) كائن البيانات المراد تسلسله ، و (2) الكائن الشبيه بالملف الذي سيتم كتابة البايت عليه.

أو ، إذا كنت تميل إلى الاستمرار في استخدام بيانات JSON المتسلسلة هذه في برنامجك ، فيمكنك كتابتها إلى كائن Python str أصلي.

json_string = json.dumps(data)

لاحظ أن الكائن الذي يشبه الملف غائب نظرًا لأنك لا تكتب فعليًا على القرص. بخلاف ذلك ، فإن عمليات التفريغ () تشبه تمامًا التفريغ ().

الصيحة! لقد أنجبت طفلاً JSON ، وأنت على استعداد لإطلاقه في البرية لتنمو بشكل كبير وقوي.

بعض حجج الكلمات الرئيسية المفيدة

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

ملاحظة: كلا الأسلوبين dump () و dumps () تستخدمان نفس الوسيطات الأساسية.

الخيار الأول الذي يريد معظم الناس تغييره هو المسافة البيضاء. يمكنك استخدام وسيطة الكلمة الأساسية للمسافة البادئة لتحديد حجم المسافة البادئة للبنى المتداخلة. تحقق من الاختلاف بنفسك باستخدام البيانات ، التي حددناها أعلاه ، وتشغيل الأوامر التالية في وحدة التحكم:

>>> json.dumps(data)
>>> json.dumps(data, indent=4)

خيار تنسيق آخر هو وسيطة الكلمات الأساسية الفواصل. بشكل افتراضي ، هذه هي مجموعتان من السلاسل الفاصلة (“،”، “:”) ، ولكن البديل الشائع لـ JSON المضغوط هو (“،”، “:”). ألقِ نظرة على نموذج JSON مرة أخرى لترى أين تلعب هذه الفواصل.

هناك آخرون ، مثل sort_keys ، لكن ليس لدي أي فكرة عما يفعله هذا الشخص. يمكنك العثور على قائمة كاملة في المستندات إذا كنت مهتمًا.

إلغاء تسلسل JSON

رائع ، يبدو أنك قد التقطت لنفسك بعض JSON البري! حان الوقت الآن لإضفاء الشكل. في مكتبة json ، ستجد load () و load () لتحويل البيانات المشفرة JSON إلى كائنات Python.

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

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

في الواقع ، ربما يكون الأمر أشبه بإقناع صديق بترجمة شيء ما إلى اليابانية وصديق آخر لترجمته مرة أخرى إلى اللغة الإنجليزية. بغض النظر ، فإن أبسط مثال هو ترميز tuple واستعادة قائمة بعد فك التشفير ، مثل:

>>> blackjack_hand = (8, "Q")
>>> encoded_hand = json.dumps(blackjack_hand)
>>> decoded_hand = json.loads(encoded_hand)

>>> blackjack_hand == decoded_hand
False
>>> type(blackjack_hand)
<class 'tuple'>
>>> type(decoded_hand)
<class 'list'>
>>> blackjack_hand == tuple(decoded_hand)
True

مثال بسيط على إلغاء التسلسل

هذه المرة ، تخيل أن لديك بعض البيانات المخزنة على القرص والتي ترغب في معالجتها في الذاكرة. ستظل تستخدم مدير السياق ، ولكن هذه المرة ستفتح ملف data_file.json الحالي في وضع القراءة.

with open("data_file.json", "r") as read_file:
    data = json.load(read_file)

الأمور واضحة ومباشرة هنا ، ولكن ضع في اعتبارك أن نتيجة هذه الطريقة يمكن أن ترجع أيًا من أنواع البيانات المسموح بها من جدول التحويل. هذا مهم فقط إذا كنت تقوم بتحميل بيانات لم تراها من قبل. في معظم الحالات ، سيكون الكائن الجذر عبارة عن إملاء أو قائمة.

إذا كنت قد سحبت بيانات JSON من برنامج آخر أو حصلت بطريقة أخرى على سلسلة من البيانات بتنسيق JSON في Python ، فيمكنك إلغاء تسلسل ذلك بسهولة باستخدام الأحمال () ، والتي يتم تحميلها بشكل طبيعي من سلسلة:

json_string = """
{
    "researcher": {
        "name": "Ford Prefect",
        "species": "Betelgeusian",
        "relatives": [
            {
                "name": "Zaphod Beeblebrox",
                "species": "Betelgeusian"
            }
        ]
    }
}
"""
data = json.loads(json_string)

هاهو! لقد قمت بترويض JSON البري ، وهو الآن تحت سيطرتك. لكن ما تفعله بهذه القوة متروك لك. يمكنك إطعامها ، ورعايتها ، وحتى تعليمها الحيل. ليس الأمر أنني لا أثق بك … لكني أبقيه مقيدًا ، حسنًا؟

مثال من العالم الحقيقي (نوعًا ما)

لمثالك التمهيدي ، ستستخدم JSONPlaceholder ، وهو مصدر رائع لبيانات JSON المزيفة لأغراض التدريب.

قم أولاً بإنشاء ملف نصي يسمى scratch.py ​​، أو أي شيء تريده. لا أستطيع حقًا إيقافك.

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

import json
import requests

الآن ، ستعمل مع قائمة TODOs مثل … كما تعلم ، إنها طقوس المرور أو أي شيء آخر.

انطلق وقم بتقديم طلب إلى JSONPlaceholder API لنقطة نهاية todos /. إذا لم تكن على دراية بالطلبات ، فهناك بالفعل طريقة json () مفيدة ستؤدي كل العمل نيابة عنك ، ولكن يمكنك التدرب على استخدام مكتبة json لإلغاء تسلسل سمة النص لكائن الاستجابة. يجب أن يبدو مثل هذا:

response = requests.get("https://jsonplaceholder.typicode.com/todos")
todos = json.loads(response.text)

لا تعتقد أن هذا يعمل؟ حسنًا ، قم بتشغيل الملف في الوضع التفاعلي واختبره بنفسك. أثناء تواجدك فيه ، تحقق من نوع المهام. إذا كنت تشعر بالمغامرة ، ألق نظرة خاطفة على أول 10 عناصر أو نحو ذلك في القائمة.

>>> todos == response.json()
True
>>> type(todos)
<class 'list'>
>>> todos[:10]
...

انظر ، لن أكذب عليك ، لكنني سعيد لأنك متشكك.

ما هو الوضع التفاعلي؟ آه ، أعتقد أنك لن تسأل أبدًا! هل تعرف كيف تقفز دائمًا ذهابًا وإيابًا بين المحرر والمحطة؟ حسنًا ، نحن مستخدمي Pythoneers الخادعين نستخدم العلامة التفاعلية -i عند تشغيل البرنامج النصي. هذه خدعة صغيرة رائعة لاختبار الكود لأنه يقوم بتشغيل البرنامج النصي ثم يفتح موجه أوامر تفاعلي مع إمكانية الوصول إلى جميع البيانات من البرنامج النصي!

حسنًا ، حان الوقت لبعض العمل. يمكنك رؤية بنية البيانات من خلال زيارة نقطة النهاية في المتصفح ، ولكن إليك نموذج TODO:

{
    "userId": 1,
    "id": 1,
    "title": "delectus aut autem",
    "completed": false
}

هناك عدة مستخدمين ، لكل منهم معرف مستخدم فريد ، ولكل مهمة خاصية مكتملة منطقية. هل يمكنك تحديد المستخدمين الذين أكملوا معظم المهام؟

# Map of userId to number of complete TODOs for that user
todos_by_user = {}

# Increment complete TODOs count for each user.
for todo in todos:
    if todo["completed"]:
        try:
            # Increment the existing user's count.
            todos_by_user[todo["userId"]] += 1
        except KeyError:
            # This user has not been seen. Set their count to 1.
            todos_by_user[todo["userId"]] = 1

# Create a sorted list of (userId, num_complete) pairs.
top_users = sorted(todos_by_user.items(), 
                   key=lambda x: x[1], reverse=True)

# Get the maximum number of complete TODOs.
max_complete = top_users[0][1]

# Create a list of all users who have completed
# the maximum number of TODOs.
users = []
for user, num_complete in top_users:
    if num_complete < max_complete:
        break
    users.append(str(user))

max_users = " and ".join(users)

نعم ، نعم ، التنفيذ أفضل ، ولكن النقطة المهمة هي أنه يمكنك الآن معالجة بيانات JSON ككائن Python عادي!

لا أعرف شيئًا عنك ، ولكن عندما أقوم بتشغيل البرنامج النصي بشكل تفاعلي مرة أخرى ، أحصل على النتائج التالية:

>>> s = "s" if len(users) > 1 else ""
>>> print(f"user{s} {max_users} completed {max_complete} TODOs")
users 5 and 10 completed 12 TODOs

هذا رائع وكل شيء ، لكنك هنا للتعرف على JSON. لمهمتك النهائية ، ستقوم بإنشاء ملف JSON يحتوي على TODOs المكتملة لكل من المستخدمين الذين أكملوا الحد الأقصى لعدد TODO.

كل ما عليك فعله هو تصفية المهام وكتابة القائمة الناتجة إلى ملف. من أجل الأصالة ، يمكنك استدعاء ملف الإخراج filtered_data_file.json. قد توجد طرق يمكنك اتباعها لحل هذا الأمر ، ولكن إليك إحدى الطرق:

# Define a function to filter out completed TODOs 
# of users with max completed TODOS.
def keep(todo):
    is_complete = todo["completed"]
    has_max_count = str(todo["userId"]) in users
    return is_complete and has_max_count

# Write filtered TODOs to file.
with open("filtered_data_file.json", "w") as data_file:
    filtered_todos = list(filter(keep, todos))
    json.dump(filtered_todos, data_file, indent=2)

رائع ، لقد تخلصت من جميع البيانات التي لا تحتاجها وحفظت الأشياء الجيدة في ملف جديد تمامًا! قم بتشغيل البرنامج النصي مرة أخرى وتحقق من filtered_data_file.json للتحقق من نجاح كل شيء. سيكون في نفس الدليل مثل scratch.py ​​عند تشغيله.

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

ترميز وفك ترميز كائنات Python المخصصة

ماذا يحدث عندما نحاول إجراء تسلسل لفئة Elf من تطبيق Dungeons & Dragons الذي تعمل عليه؟

class Elf:
    def __init__(self, level, ability_scores=None):
        self.level = level
        self.ability_scores = {
            "str": 11, "dex": 12, "con": 10,
            "int": 16, "wis": 14, "cha": 13
        } if ability_scores is None else ability_scores
        self.hp = 10 + self.ability_scores["con"]

ليس من المستغرب أن تشتكي Python من أن Elf غير قابل للتسلسل (وهو ما ستعرفه إذا كنت قد حاولت إخبار Elf بخلاف ذلك):

>>> elf = Elf(level=4)
>>> json.dumps(elf)
TypeError: Object of type 'Elf' is not JSON serializable

على الرغم من أن وحدة json يمكنها التعامل مع معظم أنواع Python المضمنة ، إلا أنها لا تفهم كيفية تشفير أنواع البيانات المخصصة افتراضيًا. يبدو الأمر أشبه بمحاولة وضع مشبك مربّع في ثقب دائري — أنت بحاجة إلى منشار أزيز وإشراف أبوي.

تبسيط هياكل البيانات

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

كل ما عليك فعله هو تمثيل بياناتك من حيث الأنواع المضمنة التي يفهمها json بالفعل. بشكل أساسي ، تقوم بترجمة الكائن الأكثر تعقيدًا إلى تمثيل أبسط ، والذي تترجمه وحدة json بعد ذلك إلى JSON. إنها مثل خاصية متعدية في الرياضيات: إذا كانت A = B و B = C ، إذن A = C.

لفهم هذا الأمر ، ستحتاج إلى كائن معقد لتلعب به. يمكنك استخدام أي فئة مخصصة تريدها ، لكن لغة Python بها نوع مضمن يسمى معقد لتمثيل الأرقام المعقدة ، ولا يمكن إجراء تسلسل افتراضيًا. لذلك ، من أجل هذه الأمثلة ، سيكون كائنك المعقد كائنًا معقدًا. مرتبك حتى الآن؟

>>> z = 3 + 8j
>>> type(z)
<class 'complex'>
>>> json.dumps(z)
TypeError: Object of type 'complex' is not JSON serializable

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

من الأسئلة الجيدة التي يجب أن تطرحها على نفسك عند العمل مع أنواع مخصصة ما هو الحد الأدنى من المعلومات اللازمة لإعادة إنشاء هذا الكائن؟ في حالة الأعداد المركبة ، ما عليك سوى معرفة الأجزاء الحقيقية والخيالية ، وكلاهما يمكنك الوصول إليه كسمات على الكائن المعقد:

>>> z.real
3.0
>>> z.imag
8.0

يعد تمرير نفس الأرقام إلى مُنشئ معقد كافيًا لإرضاء عامل المقارنة __eq__:

>>> complex(3, 8) == z
True

يعد تقسيم أنواع البيانات المخصصة إلى مكوناتها الأساسية أمرًا بالغ الأهمية لكل من عمليات التسلسل وإلغاء التسلسل.

ترميز أنواع مخصصة

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

def encode_complex(z):
    if isinstance(z, complex):
        return (z.real, z.imag)
    else:
        type_name = z.__class__.__name__
        raise TypeError(f"Object of type '{type_name}' is not JSON serializable")

لاحظ أنه من المتوقع أن تثير خطأ TypeError إذا لم تحصل على نوع الكائن الذي كنت تتوقعه. بهذه الطريقة ، تتجنب إجراء تسلسل غير مقصود لأي من الجان. الآن يمكنك محاولة ترميز العناصر المعقدة بنفسك!

>>> json.dumps(9 + 5j, default=encode_complex)
'[9.0, 5.0]'
>>> json.dumps(elf, default=encode_complex)
TypeError: Object of type 'Elf' is not JSON serializable

لماذا قمنا بترميز العدد المركب على هيئة tuple؟ سؤال رائع! لم يكن هذا بالتأكيد هو الخيار الوحيد ، كما أنه ليس بالضرورة الخيار الأفضل. في الواقع ، لن يكون هذا تمثيلًا جيدًا جدًا إذا أردت في أي وقت فك تشفير الكائن لاحقًا ، كما سترى قريبًا.

الطريقة الأخرى الشائعة هي تصنيف JSONEncoder القياسي وتجاوز طريقة () الافتراضية الخاصة به:

class ComplexEncoder(json.JSONEncoder):
    def default(self, z):
        if isinstance(z, complex):
            return (z.real, z.imag)
        else:
            return super().default(z)

بدلاً من رفع TypeError بنفسك ، يمكنك ببساطة السماح للفئة الأساسية بمعالجتها. يمكنك استخدام هذا إما مباشرة في طريقة dump () عبر المعامل cls أو عن طريق إنشاء مثيل من المشفر واستدعاء طريقة encode ():

>>> json.dumps(2 + 5j, cls=ComplexEncoder)
'[2.0, 5.0]'

>>> encoder = ComplexEncoder()
>>> encoder.encode(3 + 6j)
'[3.0, 6.0]'

أنواع مخصصة فك التشفير

في حين أن الأجزاء الحقيقية والخيالية للعدد المركب ضرورية للغاية ، إلا أنها في الواقع ليست كافية تمامًا لإعادة إنشاء الكائن. هذا ما يحدث عندما تحاول ترميز رقم معقد باستخدام ComplexEncoder ثم فك ترميز النتيجة:

>>> complex_json = json.dumps(4 + 17j, cls=ComplexEncoder)
>>> json.loads(complex_json)
[4.0, 17.0]

كل ما تحصل عليه هو قائمة ، وعليك تمرير القيم إلى مُنشئ معقد إذا أردت هذا الكائن المعقد مرة أخرى. أذكر مناقشتنا حول النقل الآني. ما ينقص هو البيانات الوصفية ، أو المعلومات حول نوع البيانات التي تقوم بتشفيرها.

أفترض أن السؤال الذي يجب أن تطرحه على نفسك حقًا هو ما هو الحد الأدنى من المعلومات الضرورية والكافية لإعادة إنشاء هذا الكائن؟

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

{
    "__complex__": true,
    "real": 42,
    "imag": 36
}

رؤية الشيء الذكي؟ هذا المفتاح “__complex__” هو البيانات الوصفية التي تحدثنا عنها للتو. لا يهم حقًا ما هي القيمة المرتبطة. لجعل هذا الاختراق الصغير يعمل ، كل ما عليك فعله هو التحقق من وجود المفتاح:

def decode_complex(dct):
    if "__complex__" in dct:
        return complex(dct["real"], dct["imag"])
    return dct

إذا لم يكن “__complex__” موجودًا في القاموس ، يمكنك فقط إرجاع الكائن والسماح لوحدة فك الترميز الافتراضية بالتعامل معه.

في كل مرة تحاول طريقة load () تحليل كائن ما ، يتم منحك الفرصة للتوسط قبل أن تشغل وحدة فك التشفير الافتراضية طريقها مع البيانات. يمكنك القيام بذلك عن طريق تمرير وظيفة فك التشفير الخاصة بك إلى معلمة object_hook.

العب الآن نفس نوع اللعبة كما كان من قبل:

>>> with open("complex_data.json") as complex_data:
...     data = complex_data.read()
...     z = json.loads(data, object_hook=decode_complex)
... 
>>> type(z)
<class 'complex'>

في حين أن object_hook قد يبدو وكأنه المقابل للمعامل الافتراضي لطريقة dump () ، فإن القياس يبدأ وينتهي هناك.

هذا لا يعمل مع كائن واحد فقط. جرب وضع قائمة الأعداد المركبة هذه في complex_data.json وتشغيل البرنامج النصي مرة أخرى:

[
  {
    "__complex__":true,
    "real":42,
    "imag":36
  },
  {
    "__complex__":true,
    "real":64,
    "imag":11
  }
]

إذا سارت الأمور على ما يرام ، فستحصل على قائمة بالكائنات المعقدة:

>>> with open("complex_data.json") as complex_data:
...     data = complex_data.read()
...     numbers = json.loads(data, object_hook=decode_complex)
... 
>>> numbers
[(42+36j), (64+11j)]

يمكنك أيضًا تجربة التصنيف الفرعي JSONDecoder وتجاوز object_hook ، ولكن من الأفضل التمسك بالحل خفيف الوزن كلما أمكن ذلك.

كله تمام!

تهانينا ، يمكنك الآن استخدام القوة الجبارة لـ JSON لجميع احتياجات Python الشائنة.

في حين أن الأمثلة التي عملت معها هنا هي بالتأكيد مفتعلة ومفرطة في التبسيط ، فإنها توضح سير عمل يمكنك تطبيقه على مهام أكثر عمومية:

1. قم باستيراد حزمة json.
   
2. اقرأ البيانات مع load () أو loads ().
   
3. معالجة البيانات.
   
4. اكتب البيانات المعدلة مع تفريغ () أو تفريغ ().
   

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

لقد قمت اليوم برحلة: لقد التقطت بعض JSON البرية وقمت بترويضها ، وقمت بالعودة في الوقت المناسب لتناول العشاء! كمكافأة إضافية ، فإن تعلم حزمة json سيجعل تعلم المخلل والتنظيم أمرًا سريعًا.

حظًا سعيدًا في كل مساعيك البايثونية المستقبلية!

The post العمل مع بيانات JSON في بايثون appeared first on فيلم تعلم البرمجيات للطالب العربي.