• الطراز القديم مقابل فئات الطراز الجديد
  فئات الطراز القديم
  فئات جديدة الطراز
  
• النوع والفئة
  
• تعريف الفصل ديناميكيًا
  مثال 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 فيلم تعلم البرمجيات للطالب العربي.

• الشروع في العمل: طباعة قيمة متغير
  
• تعبيرات الطباعة
  
• يخطو من خلال التعليمات البرمجية
  إدراج رمز المصدر
  
• استخدام نقاط التوقف
  
• استمرار التنفيذ
  
• عرض التعبيرات
  
• معرف المتصل بيثون
  
• أوامر pdb الأساسية
  
• تصحيح أخطاء بايثون باستخدام PDB: الخاتمة
  

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

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

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

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

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

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

يستخدم رمز المثال في هذا البرنامج التعليمي Python 3.6. يمكنك العثور على الكود المصدري لهذه الأمثلة على GitHub.

في نهاية هذا البرنامج التعليمي ، يوجد مرجع سريع لأوامر pdb الأساسية.

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

الشروع في العمل: طباعة قيمة متغير

في هذا المثال الأول ، سننظر في استخدام pdb في أبسط صوره: التحقق من قيمة المتغير.

أدخل الكود التالي في المكان الذي تريد اقتحام مصحح الأخطاء فيه:

import pdb; pdb.set_trace()

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

بدءًا من Python 3.7 ، هناك طريقة أخرى للدخول إلى مصحح الأخطاء. يصف PEP 553 نقطة توقف الوظيفة المضمنة () ، مما يجعل إدخال مصحح الأخطاء أمرًا سهلاً ومتسقًا:

breakpoint()

بشكل افتراضي ، ستقوم نقطة التوقف () باستيراد pdb واستدعاء pdb.set_trace () ، كما هو موضح أعلاه. ومع ذلك ، يعد استخدام نقطة التوقف () أكثر مرونة ويسمح لك بالتحكم في سلوك تصحيح الأخطاء عبر واجهة برمجة التطبيقات واستخدام متغير البيئة PYTHONBREAKPOINT. على سبيل المثال ، سيؤدي تعيين PYTHONBREAKPOINT = 0 في بيئتك إلى تعطيل نقطة التوقف () تمامًا ، وبالتالي تعطيل تصحيح الأخطاء. إذا كنت تستخدم Python 3.7 أو إصدارًا أحدث ، فأنا أشجعك على استخدام نقطة التوقف () بدلاً من pdb.set_trace ().

يمكنك أيضًا اقتحام مصحح الأخطاء ، دون تعديل المصدر واستخدام pdb.set_trace () أو نقطة التوقف () ، عن طريق تشغيل Python مباشرةً من سطر الأوامر وتمرير الخيار -m pdb. إذا كان التطبيق الخاص بك يقبل وسيطات سطر الأوامر ، فمررها كما تفعل عادةً بعد اسم الملف. فمثلا:

$ python3 -m pdb app.py arg1 arg2

هناك الكثير من أوامر pdb المتاحة. في نهاية هذا البرنامج التعليمي ، توجد قائمة بأوامر pdb الأساسية. في الوقت الحالي ، دعنا نستخدم الأمر p لطباعة قيمة المتغير. أدخل p Vari_name في موجه (Pdb) لطباعة قيمته.

دعونا نلقي نظرة على المثال. إليك مصدر example1.py:

#!/usr/bin/env python3

filename = __file__
import pdb; pdb.set_trace()
print(f'path = {filename}')

إذا قمت بتشغيل هذا من shell الخاص بك ، يجب أن تحصل على الإخراج التالي:

$ ./example1.py 
> /code/example1.py(5)<module>()
-> print(f'path = {filename}')
(Pdb) 

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

أدخل الآن اسم الملف p. يجب أن ترى:

(Pdb) p filename
'./example1.py'
(Pdb)

نظرًا لأنك تعمل في shell وتستخدم CLI (واجهة سطر الأوامر) ، انتبه إلى الأحرف والتنسيق. سيعطونك السياق الذي تحتاجه:

• > يبدأ السطر الأول ويخبرك بالملف المصدر الذي تستخدمه. بعد اسم الملف ، يوجد رقم السطر الحالي بين قوسين. التالي هو اسم الوظيفة. في هذا المثال ، نظرًا لأننا لم نتوقف مؤقتًا داخل دالة وعلى مستوى الوحدة ، نرى <module> ().
  
• -> يبدأ السطر الثاني وهو سطر المصدر الحالي حيث يتم إيقاف Python مؤقتًا. لم يتم تنفيذ هذا الخط حتى الآن. في هذا المثال ، هذا هو السطر 5 في example1.py ، من> السطر أعلاه.
• (Pdb) هو موجه pdb. إنها تنتظر أمرًا.

استخدم الأمر q لإنهاء التصحيح والخروج.

تعبيرات الطباعة

عند استخدام الأمر print p ، فأنت تقوم بتمرير تعبير ليتم تقييمه بواسطة Python. إذا قمت بتمرير اسم متغير ، فإن pdb يطبع قيمته الحالية. ومع ذلك ، يمكنك فعل الكثير للتحقق من حالة التطبيق قيد التشغيل.

في هذا المثال ، يتم استدعاء الدالة get_path (). لفحص ما يحدث في هذه الوظيفة ، قمت بإدخال استدعاء إلى pdb.set_trace () لإيقاف التنفيذ مؤقتًا قبل أن يعود:

#!/usr/bin/env python3

import os


def get_path(filename):
    """Return file's path or empty string if no path."""
    head, tail = os.path.split(filename)
    import pdb; pdb.set_trace()
    return head


filename = __file__
print(f'path = {get_path(filename)}')

إذا قمت بتشغيل هذا من قوقعتك ، فيجب أن تحصل على الإخراج:

$ ./example2.py 
> /code/example2.py(10)get_path()
-> return head
(Pdb) 

اين نحن؟

• >: نحن في الملف المصدر example2.py في السطر 10 في الوظيفة get_path (). هذا هو الإطار المرجعي الذي سيستخدمه الأمر p لحل أسماء المتغيرات ، أي النطاق أو السياق الحالي.
  
• ->: توقف التنفيذ عند رأس العودة. لم يتم تنفيذ هذا الخط حتى الآن. هذا هو السطر 10 في example2.py في الوظيفة get_path () ، من> السطر أعلاه.
  

دعنا نطبع بعض التعبيرات لإلقاء نظرة على الحالة الحالية للتطبيق. أستخدم الأمر ll (القائمة الطويلة) مبدئيًا لسرد مصدر الوظيفة:

(Pdb) ll
  6     def get_path(filename):
  7         """Return file's path or empty string if no path."""
  8         head, tail = os.path.split(filename)
  9         import pdb; pdb.set_trace()
 10  ->     return head
(Pdb) p filename
'./example2.py'
(Pdb) p head, tail
('.', 'example2.py')
(Pdb) p 'filename: ' + filename
'filename: ./example2.py'
(Pdb) p get_path
<function get_path at 0x100760e18>
(Pdb) p getattr(get_path, '__doc__')
"Return file's path or empty string if no path."
(Pdb) p [os.path.split(p)[1] for p in os.path.sys.path]
['pdb-basics', 'python36.zip', 'python3.6', 'lib-dynload', 'site-packages']
(Pdb) 

يمكنك تمرير أي تعبير Python صالح إلى p للتقييم.

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

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

يخطو من خلال التعليمات البرمجية

هناك أمران يمكنك استخدامهما للتنقل عبر التعليمات البرمجية عند تصحيح الأخطاء:
وصف الأمر
n (التالي) تابع التنفيذ حتى يتم الوصول إلى السطر التالي في الوظيفة الحالية أو يعود.
s (الخطوة) قم بتنفيذ السطر الحالي وتوقف عند أول مناسبة ممكنة (إما في وظيفة تسمى أو في الوظيفة الحالية).

هناك أمر ثالث يسمى unt (حتى). إنه مرتبط بـ n (التالي). سنلقي نظرة عليها لاحقًا في هذا البرنامج التعليمي في قسم التنفيذ المستمر.

الفرق بين n (التالي) و s (الخطوة) حيث يتوقف pdb.

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

استخدم s (الخطوة) لتنفيذ السطر الحالي والتوقف في وظيفة خارجية إذا تم استدعاء أحدها. فكر في الخطوة على أنها “خطوة إلى”. إذا تم إيقاف التنفيذ في وظيفة أخرى ، فسيتم طباعة – Call -.

سيتوقف كل من n و s عن التنفيذ عند الوصول إلى نهاية الوظيفة الحالية والطباعة –Return – جنبًا إلى جنب مع القيمة المعادة في نهاية السطر التالي بعد ->.

دعونا نلقي نظرة على مثال باستخدام كلا الأمرين. إليك مصدر example3.py:

#!/usr/bin/env python3

import os


def get_path(filename):
    """Return file's path or empty string if no path."""
    head, tail = os.path.split(filename)
    return head


filename = __file__
import pdb; pdb.set_trace()
filename_path = get_path(filename)
print(f'path = {filename_path}')

إذا قمت بتشغيل هذا من shell الخاص بك وأدخلت n ، يجب أن تحصل على الإخراج:

$ ./example3.py 
> /code/example3.py(14)<module>()
-> filename_path = get_path(filename)
(Pdb) n
> /code/example3.py(15)<module>()
-> print(f'path = {filename_path}')
(Pdb) 

مع n (التالي) ، توقفنا عند السطر 15 ، السطر التالي. “بقينا محليين” في <module> () و “تخطينا” المكالمة لـ get_path (). الوظيفة هي <module> () نظرًا لأننا حاليًا في مستوى الوحدة ولم نتوقف مؤقتًا داخل وظيفة أخرى.

دعونا نجرب ما يلي:

$ ./example3.py 
> /code/example3.py(14)<module>()
-> filename_path = get_path(filename)
(Pdb) s
--Call--
> /code/example3.py(6)get_path()
-> def get_path(filename):
(Pdb) 

باستخدام s (الخطوة) ، توقفنا عند السطر 6 في الوظيفة get_path () حيث تم استدعاؤها في السطر 14. لاحظ السطر – Call – بعد الأمر s.

بشكل ملائم ، يتذكر pdb آخر أمر لك. إذا كنت تتنقل عبر الكثير من التعليمات البرمجية ، يمكنك فقط الضغط على Enter لتكرار الأمر الأخير.

يوجد أدناه مثال على استخدام كل من s و n للتنقل عبر الكود. أقوم بإدخال s في البداية لأنني أريد “الدخول إلى” الوظيفة get_path () والتوقف. ثم أدخل n مرة واحدة “للبقاء محليًا” أو “تخطي” أي استدعاءات وظيفية أخرى واضغط فقط على Enter لتكرار الأمر n حتى أصل إلى آخر سطر مصدر.

$ ./example3.py 
> /code/example3.py(14)<module>()
-> filename_path = get_path(filename)
(Pdb) s
--Call--
> /code/example3.py(6)get_path()
-> def get_path(filename):
(Pdb) n
> /code/example3.py(8)get_path()
-> head, tail = os.path.split(filename)
(Pdb) 
> /code/example3.py(9)get_path()
-> return head
(Pdb) 
--Return--
> /code/example3.py(9)get_path()->'.'
-> return head
(Pdb) 
> /code/example3.py(15)<module>()
-> print(f'path = {filename_path}')
(Pdb) 
path = .
--Return--
> /code/example3.py(15)<module>()->None
-> print(f'path = {filename_path}')
(Pdb) 

لاحظ السطور – Call – and –Return -. هذا هو pdb الذي يتيح لك معرفة سبب إيقاف الإعدام. n (التالي) و s (الخطوة) ستتوقف قبل أن تعود الدالة. لهذا السبب ترى سطور “العودة” أعلاه.

لاحظ أيضًا -> “.” في نهاية السطر بعد أول – رجوع – أعلاه:

--Return--
> /code/example3.py(9)get_path()->'.'
-> return head
(Pdb) 

عندما يتوقف pdb في نهاية دالة قبل أن تعود ، فإنه يطبع أيضًا قيمة الإرجاع لك. في هذا المثال هو “.”.

إدراج رمز المصدر

لا تنس الأمر ll (القائمة الطويلة: سرد شفرة المصدر بالكامل للوظيفة أو الإطار الحالي). إنه مفيد حقًا عندما تتخطى رمزًا غير مألوف أو تريد فقط رؤية الوظيفة الكاملة للسياق.

هذا مثال:

$ ./example3.py 
> /code/example3.py(14)<module>()
-> filename_path = get_path(filename)
(Pdb) s
--Call--
> /code/example3.py(6)get_path()
-> def get_path(filename):
(Pdb) ll
  6  -> def get_path(filename):
  7         """Return file's path or empty string if no path."""
  8         head, tail = os.path.split(filename)
  9         return head
(Pdb) 

لرؤية مقتطف أقصر من التعليمات البرمجية ، استخدم الأمر l (قائمة). بدون وسيطات ، سيتم طباعة 11 سطرًا حول السطر الحالي أو متابعة القائمة السابقة. مرر الحجة. لإدراج 11 سطرًا دائمًا حول السطر الحالي: l.

$ ./example3.py 
> /code/example3.py(14)<module>()
-> filename_path = get_path(filename)
(Pdb) l
  9         return head
 10     
 11     
 12     filename = __file__
 13     import pdb; pdb.set_trace()
 14  -> filename_path = get_path(filename)
 15     print(f'path = {filename_path}')
[EOF]
(Pdb) l
[EOF]
(Pdb) l .
  9         return head
 10     
 11     
 12     filename = __file__
 13     import pdb; pdb.set_trace()
 14  -> filename_path = get_path(filename)
 15     print(f'path = {filename_path}')
[EOF]
(Pdb) 

استخدام نقاط التوقف

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

استخدم الأمر ب (فاصل) لتعيين نقطة توقف. يمكنك تحديد رقم سطر أو اسم وظيفة حيث تم إيقاف التنفيذ.

صيغة الاستراحة هي:

b(reak) [ ([filename:]lineno | function) [, condition] ]

إذا لم يتم تحديد filename: قبل lineno رقم السطر ، فسيتم استخدام ملف المصدر الحالي.

لاحظ الوسيطة الثانية الاختيارية لـ b: condition. هذا قوي جدا. تخيل موقفًا تريد كسره فقط في حالة وجود حالة معينة. إذا قمت بتمرير تعبير Python باعتباره الوسيطة الثانية ، فسوف ينكسر pdb عندما يكون التعبير صحيحًا. سنفعل هذا في مثال أدناه.

في هذا المثال ، توجد وحدة الأداة المساعدة util.py. لنقم بتعيين نقطة توقف لإيقاف التنفيذ في دالة get_path ().

في ما يلي مصدر النص الرئيسي example4.py:

#!/usr/bin/env python3

import util

filename = __file__
import pdb; pdb.set_trace()
filename_path = util.get_path(filename)
print(f'path = {filename_path}')

إليك مصدر وحدة الأداة المساعدة util.py:

def get_path(filename):
    """Return file's path or empty string if no path."""
    import os
    head, tail = os.path.split(filename)
    return head

أولاً ، لنقم بتعيين نقطة توقف باستخدام اسم ملف المصدر ورقم السطر:

$ ./example4.py 
> /code/example4.py(7)<module>()
-> filename_path = util.get_path(filename)
(Pdb) b util:5
Breakpoint 1 at /code/util.py:5
(Pdb) c
> /code/util.py(5)get_path()
-> return head
(Pdb) p filename, head, tail
('./example4.py', '.', 'example4.py')
(Pdb) 

يستمر الأمر c (متابعة) في التنفيذ حتى يتم العثور على نقطة توقف.

بعد ذلك ، دعنا نضبط نقطة توقف باستخدام اسم الوظيفة:

$ ./example4.py 
> /code/example4.py(7)<module>()
-> filename_path = util.get_path(filename)
(Pdb) b util.get_path
Breakpoint 1 at /code/util.py:1
(Pdb) c
> /code/util.py(3)get_path()
-> import os
(Pdb) p filename
'./example4.py'
(Pdb) 

أدخل b بدون وسيطات لعرض قائمة بجميع نقاط التوقف:

(Pdb) b
Num Type         Disp Enb   Where
1   breakpoint   keep yes   at /code/util.py:1
(Pdb) 

يمكنك تعطيل وإعادة تمكين نقاط التوقف باستخدام الأمر تعطيل bpnumber وتمكين bpnumber. bpnumber هو رقم نقطة التوقف من العمود الأول لقائمة نقاط التوقف Num. لاحظ تغير قيمة عمود Enb:

(Pdb) disable 1
Disabled breakpoint 1 at /code/util.py:1
(Pdb) b
Num Type         Disp Enb   Where
1   breakpoint   keep no    at /code/util.py:1
(Pdb) enable 1
Enabled breakpoint 1 at /code/util.py:1
(Pdb) b
Num Type         Disp Enb   Where
1   breakpoint   keep yes   at /code/util.py:1
(Pdb) 

لحذف نقطة توقف ، استخدم الأمر cl (مسح):

cl(ear) filename:lineno
cl(ear) [bpnumber [bpnumber...]]

دعنا الآن نستخدم تعبير Python لتعيين نقطة توقف. تخيل موقفًا تريد التوقف فيه فقط إذا تلقت وظيفتك المضطربة مدخلات معينة.

في هذا السيناريو المثال ، تفشل وظيفة get_path () عندما تتلقى مسارًا نسبيًا ، أي أن مسار الملف لا يبدأ بـ /. سأقوم بإنشاء تعبير يتم تقييمه إلى صحيح في هذه الحالة وتمريره إلى b باعتباره الوسيطة الثانية:

$ ./example4.py 
> /code/example4.py(7)<module>()
-> filename_path = util.get_path(filename)
(Pdb) b util.get_path, not filename.startswith('/')
Breakpoint 1 at /code/util.py:1
(Pdb) c
> /code/util.py(3)get_path()
-> import os
(Pdb) a
filename = './example4.py'
(Pdb) 

بعد إنشاء نقطة التوقف أعلاه وإدخال c لمتابعة التنفيذ ، يتوقف pdb عند تقييم التعبير إلى true. يقوم الأمر a (args) بطباعة قائمة وسيطات الوظيفة الحالية.

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

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

$ ./example4.py 
> /code/example4.py(7)<module>()
-> filename_path = util.get_path(filename)
(Pdb) b util:5, not head.startswith('/')
Breakpoint 1 at /code/util.py:5
(Pdb) c
> /code/util.py(5)get_path()
-> return head
(Pdb) p head
'.'
(Pdb) a
filename = './example4.py'
(Pdb) 

يمكنك أيضًا تعيين نقطة توقف مؤقتة باستخدام الأمر tbreak. تتم إزالته تلقائيًا عندما يتم ضربه لأول مرة. يستخدم نفس الحجج مثل ب.

استمرار التنفيذ

حتى الآن ، نظرنا في التنقل عبر الشفرة باستخدام n (التالي) و s (الخطوة) واستخدام نقاط التوقف مع b (فاصل) و c (متابعة).

هناك أيضًا أمر مرتبط: unt (until).

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

دعونا نلقي نظرة أولية على بنية ووصف unt:
وصف بناء جملة الأمر
unt unt (il) [lineno] بدون لينينو ، استمر في التنفيذ حتى يتم الوصول إلى السطر الذي يحتوي على رقم أكبر من الرقم الحالي. باستخدام lineno ، استمر في التنفيذ حتى يتم الوصول إلى سطر برقم أكبر أو يساوي ذلك. في كلتا الحالتين ، توقف أيضًا عند عودة الإطار الحالي.

اعتمادًا على ما إذا كنت تمرر خط وسيطة رقم السطر أم لا ، يمكن أن يتصرف unt بطريقتين:

• بدون لينينو ، استمر في التنفيذ حتى يتم الوصول إلى السطر الذي يحتوي على رقم أكبر من الرقم الحالي. هذا مشابه لـ n (next). إنها طريقة بديلة للتنفيذ و “التنقّل” للشفرة. الفرق بين n و unt هو أن unt يتوقف فقط عند الوصول إلى خط برقم أكبر من الرقم الحالي. سيتوقف n عند السطر التالي المنفذ منطقيًا.
  
• باستخدام lineno ، استمر في التنفيذ حتى يتم الوصول إلى سطر برقم أكبر أو يساوي ذلك. هذا مثل c (متابعة) مع وسيطة رقم سطر.
  

في كلتا الحالتين ، unt يتوقف عند عودة الإطار الحالي (الوظيفة) ، تمامًا مثل n (التالي) و s (الخطوة).

استخدم unt عندما تريد متابعة التنفيذ والتوقف أكثر لأسفل في ملف المصدر الحالي. يمكنك معاملته على أنه مزيج من n (التالي) و b (فاصل) ، اعتمادًا على ما إذا كنت تمرر وسيطة رقم سطر أم لا.

في المثال أدناه ، توجد وظيفة ذات حلقة. هنا ، تريد متابعة تنفيذ الكود والتوقف بعد الحلقة ، دون المرور عبر كل تكرار للحلقة أو تعيين نقطة توقف:

إليك مثال المصدر على سبيل المثال example4unt.py:

#!/usr/bin/env python3

import os


def get_path(fname):
    """Return file's path or empty string if no path."""
    import pdb; pdb.set_trace()
    head, tail = os.path.split(fname)
    for char in tail:
        pass  # Check filename char
    return head


filename = __file__
filename_path = get_path(filename)
print(f'path = {filename_path}')

وإخراج وحدة التحكم باستخدام unt:

$ ./example4unt.py 
> /code/example4unt.py(9)get_path()
-> head, tail = os.path.split(fname)
(Pdb) ll
  6     def get_path(fname):
  7         """Return file's path or empty string if no path."""
  8         import pdb; pdb.set_trace()
  9  ->     head, tail = os.path.split(fname)
 10         for char in tail:
 11             pass  # Check filename char
 12         return head
(Pdb) unt
> /code/example4unt.py(10)get_path()
-> for char in tail:
(Pdb) 
> /code/example4unt.py(11)get_path()
-> pass  # Check filename char
(Pdb) 
> /code/example4unt.py(12)get_path()
-> return head
(Pdb) p char, tail
('y', 'example4unt.py')

تم استخدام الأمر ll أولاً لطباعة مصدر الوظيفة ، متبوعًا بـ unt. يتذكر pdb آخر أمر تم إدخاله ، لذلك قمت فقط بالضغط على Enter لتكرار الأمر unt. استمر هذا التنفيذ من خلال الكود حتى تم الوصول إلى سطر مصدر أكبر من السطر الحالي.

لاحظ في إخراج وحدة التحكم أعلاه أن pdb توقف مرة واحدة فقط في السطرين 10 و 11. نظرًا لاستخدام unt ، تم إيقاف التنفيذ فقط في التكرار الأول للحلقة. ومع ذلك ، تم تنفيذ كل تكرار للحلقة. يمكن التحقق من ذلك في آخر سطر من الإخراج. قيمة “y” لمتغير char تساوي الحرف الأخير في قيمة “example4unt.py”.

عرض التعبيرات

على غرار تعبيرات الطباعة باستخدام p و pp ، يمكنك استخدام عرض الأمر [تعبير] لإخبار pdb بعرض قيمة التعبير تلقائيًا ، إذا تغيرت ، عند توقف التنفيذ. استخدم الأمر undisplay [التعبير] لمسح تعبير العرض.

فيما يلي بناء الجملة والوصف لكلا الأمرين:
وصف بناء جملة الأمر
display display [التعبير] يعرض قيمة التعبير إذا تغير ، في كل مرة يتوقف التنفيذ في الإطار الحالي. بدون تعبير ، قم بسرد كل تعبيرات العرض للإطار الحالي.
undisplay undisplay [التعبير] لا تعرض أي تعبير في الإطار الحالي. بدون تعبير ، امسح كل تعبيرات العرض للإطار الحالي.

يوجد أدناه مثال ، example4display.py ، يوضح استخدامه مع حلقة:

$ ./example4display.py 
> /code/example4display.py(9)get_path()
-> head, tail = os.path.split(fname)
(Pdb) ll
  6     def get_path(fname):
  7         """Return file's path or empty string if no path."""
  8         import pdb; pdb.set_trace()
  9  ->     head, tail = os.path.split(fname)
 10         for char in tail:
 11             pass  # Check filename char
 12         return head
(Pdb) b 11
Breakpoint 1 at /code/example4display.py:11
(Pdb) c
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
(Pdb) display char
display char: 'e'
(Pdb) c
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
display char: 'x'  [old: 'e']
(Pdb) 
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
display char: 'a'  [old: 'x']
(Pdb) 
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
display char: 'm'  [old: 'a']

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

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

$ ./example4display.py 
> /code/example4display.py(9)get_path()
-> head, tail = os.path.split(fname)
(Pdb) ll
  6     def get_path(fname):
  7         """Return file's path or empty string if no path."""
  8         import pdb; pdb.set_trace()
  9  ->     head, tail = os.path.split(fname)
 10         for char in tail:
 11             pass  # Check filename char
 12         return head
(Pdb) b 11
Breakpoint 1 at /code/example4display.py:11
(Pdb) c
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
(Pdb) display char
display char: 'e'
(Pdb) display fname
display fname: './example4display.py'
(Pdb) display head
display head: '.'
(Pdb) display tail
display tail: 'example4display.py'
(Pdb) c
> /code/example4display.py(11)get_path()
-> pass  # Check filename char
display char: 'x'  [old: 'e']
(Pdb) display
Currently displaying:
char: 'x'
fname: './example4display.py'
head: '.'
tail: 'example4display.py'

معرف المتصل بيثون

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

إليك مصدر example5.py للنص البرمجي الرئيسي:

#!/usr/bin/env python3

import fileutil


def get_file_info(full_fname):
    file_path = fileutil.get_path(full_fname)
    return file_path


filename = __file__
filename_path = get_file_info(filename)
print(f'path = {filename_path}')

إليك ملف وحدة الأداة المساعدة fileutil.py:

def get_path(fname):
    """Return file's path or empty string if no path."""
    import os
    import pdb; pdb.set_trace()
    head, tail = os.path.split(fname)
    return head

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

كيف تجد من هو المتصل؟

استخدم الأمر w (حيث) لطباعة تتبع مكدس ، مع وجود أحدث إطار في الأسفل:

$ ./example5.py 
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) w
  /code/example5.py(12)<module>()
-> filename_path = get_file_info(filename)
  /code/example5.py(7)get_file_info()
-> file_path = fileutil.get_path(full_fname)
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) 

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

نظرًا لأن أحدث إطار موجود في الأسفل ، ابدأ من هناك واقرأ من الأسفل إلى الأعلى. انظر إلى الأسطر التي تبدأ بـ -> ، لكن تخطي المثال الأول حيث تم استخدام pdb.set_trace () لإدخال pdb في الدالة get_path (). في هذا المثال ، سطر المصدر الذي يسمى الدالة get_path () هو:

-> file_path = fileutil.get_path(full_fname)

السطر الموجود أعلى كل -> يحتوي على اسم الملف ورقم السطر (بين قوسين) واسم الوظيفة الموجود بها سطر المصدر. لذلك يكون المتصل هو:

/code/example5.py(7)get_file_info()
-> file_path = fileutil.get_path(full_fname)

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

الآن نحن نعرف كيفية العثور على المتصل.

ولكن ماذا عن هذا التتبع المكدس وإطار الأشياء؟

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

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

راجع مقالة مكدس المكالمات هذه على ويكيبيديا للحصول على التفاصيل.

لفهم أفضل والاستفادة بشكل أكبر من pdb ، دعنا نلقي نظرة عن كثب على المساعدة الخاصة بـ w:

(Pdb) h w
w(here)
        Print a stack trace, with the most recent frame at the bottom.
        An arrow indicates the "current frame", which determines the
        context of most commands. 'bt' is an alias for this command.

ماذا يعني pdb ب “الإطار الحالي”؟

فكر في الإطار الحالي على أنه الوظيفة الحالية حيث توقف pdb عن التنفيذ. بمعنى آخر ، الإطار الحالي هو المكان الذي يتم فيه إيقاف التطبيق مؤقتًا حاليًا ويتم استخدامه كـ “إطار” مرجعي لأوامر pdb مثل p (طباعة).

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

عندما يقوم pdb بطباعة تتبع مكدس ، يشير السهم> إلى الإطار الحالي.

كيف هذا مفيد؟

يمكنك استخدام الأمرين u (أعلى) و د (أسفل) لتغيير الإطار الحالي. بالاقتران مع p ، يتيح لك ذلك فحص المتغيرات والحالة في التطبيق الخاص بك في أي نقطة على طول مكدس الاستدعاءات في أي إطار.

فيما يلي بناء الجملة والوصف لكلا الأمرين:

وصف بناء جملة الأمر
u u (p) [عدد] نقل عدد الإطارات الحالي (المستوى الافتراضي) إلى أعلى في تتبع المكدس (إلى إطار أقدم).
d d (خاص) [عدد] نقل مستويات عدد الإطارات الحالية (المستوى الافتراضي) لأسفل في تتبع المكدس (إلى إطار أحدث).

دعونا نلقي نظرة على مثال باستخدام الأمرين u و d. في هذا السيناريو ، نريد فحص المتغير full_fname المحلي للدالة get_file_info () في example5.py. للقيام بذلك ، يتعين علينا تغيير الإطار الحالي إلى مستوى أعلى باستخدام الأمر u:

$ ./example5.py 
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) w
  /code/example5.py(12)<module>()
-> filename_path = get_file_info(filename)
  /code/example5.py(7)get_file_info()
-> file_path = fileutil.get_path(full_fname)
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) u
> /code/example5.py(7)get_file_info()
-> file_path = fileutil.get_path(full_fname)
(Pdb) p full_fname
'./example5.py'
(Pdb) d
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) p fname
'./example5.py'
(Pdb) 

الاستدعاء إلى pdb.set_trace () موجود في fileutil.py في الوظيفة get_path () ، لذلك يتم تعيين الإطار الحالي هناك في البداية. يمكنك رؤيته في السطر الأول من الإخراج أعلاه:

> /code/fileutil.py(5)get_path()

للوصول إلى المتغير المحلي full_fname وطباعته في الوظيفة get_file_info () في example5.py ، تم استخدام الأمر u للانتقال إلى مستوى واحد للأعلى:

(Pdb) u
> /code/example5.py(7)get_file_info()
-> file_path = fileutil.get_path(full_fname)

لاحظ في إخراج u أعلاه أن pdb طبع السهم> في بداية السطر الأول. يتيح لك هذا pdb معرفة أنه تم تغيير الإطار وأن موقع المصدر هذا هو الآن الإطار الحالي. المتغير full_fname يمكن الوصول إليه الآن. أيضًا ، من المهم إدراك أن سطر المصدر الذي يبدأ بـ -> في السطر الثاني قد تم تنفيذه. منذ أن تم نقل الإطار لأعلى المكدس ، تم استدعاء fileutil.get_path (). باستخدام u ، نقلنا المكدس (بمعنى ما ، إلى الوراء في الوقت المناسب) إلى الوظيفة example5.get_file_info () حيث تم استدعاء fileutil.get_path ().

متابعة للمثال ، بعد طباعة full_fname ، تم نقل الإطار الحالي إلى موقعه الأصلي باستخدام d ، وتمت طباعة المتغير المحلي fname في get_path ().

إذا أردنا ذلك ، كان بإمكاننا تحريك إطارات متعددة مرة واحدة بتمرير وسيطة العد إلى u أو d. على سبيل المثال ، كان بإمكاننا الانتقال إلى مستوى الوحدة النمطية في example5.py عن طريق إدخال u 2:

$ ./example5.py 
> /code/fileutil.py(5)get_path()
-> head, tail = os.path.split(fname)
(Pdb) u 2
> /code/example5.py(12)<module>()
-> filename_path = get_file_info(filename)
(Pdb) p filename
'./example5.py'
(Pdb) 

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

أوامر pdb الأساسية

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

ما عليك سوى إدخال h أو مساعدة <topic> للحصول على قائمة بجميع الأوامر أو المساعدة لأمر أو موضوع معين.

للإشارة بسرعة ، إليك قائمة بالأوامر الأساسية:
وصف الأمر
p طباعة قيمة التعبير.
ص ب جميلة – طباعة قيمة التعبير.
n تابع التنفيذ حتى يتم الوصول إلى السطر التالي في الوظيفة الحالية أو يعود.
قم بتنفيذ السطر الحالي وتوقف عند أول مناسبة ممكنة (إما في وظيفة تسمى أو في الوظيفة الحالية).
ج مواصلة التنفيذ والتوقف فقط عند مواجهة نقطة توقف.
استمر في التنفيذ حتى يتم الوصول إلى السطر الذي يحتوي على رقم أكبر من الرقم الحالي. باستخدام وسيطة رقم سطر ، استمر في التنفيذ حتى يتم الوصول إلى سطر برقم أكبر أو يساوي ذلك.
l سرد التعليمات البرمجية المصدر للملف الحالي. بدون وسيطات ، قم بإدراج 11 سطراً حول السطر الحالي أو تابع القائمة السابقة.
ll قائمة التعليمات البرمجية المصدر بالكامل للوظيفة الحالية أو الإطار.
ب دون أي حجج ، قم بإدراج جميع الفواصل. باستخدام وسيطة رقم السطر ، قم بتعيين نقطة توقف عند هذا السطر في الملف الحالي.
w اطبع تتبع مكدس ، بحيث يكون أحدث إطار في الأسفل. يشير السهم إلى الإطار الحالي ، والذي يحدد سياق معظم الأوامر.
u انقل مستويات عدد الإطارات الحالية (المستوى الافتراضي) لأعلى في تتبع المكدس (إلى إطار أقدم).
d انقل مستويات عدد الإطارات الحالية (المستوى الافتراضي) لأسفل في تتبع المكدس (إلى إطار أحدث).
h راجع قائمة بالأوامر المتوفرة.
h <topic> إظهار التعليمات لأمر أو موضوع.
h pdb إظهار وثائق pdb الكاملة.
q قم بإنهاء مصحح الأخطاء والإنهاء.

تصحيح أخطاء بايثون باستخدام PDB: الخاتمة

في هذا البرنامج التعليمي ، غطينا بعض الاستخدامات الأساسية والشائعة لـ pdb:

• تعبيرات الطباعة
  
• يتخطى الكود مع n (التالي) و s (خطوة)
  
• باستخدام نقاط التوقف
  
• استمرار التنفيذ مع unt (حتى)
  
• عرض التعبيرات
  
• العثور على متصل دالة
  

آمل أن تكون مفيدة لك. إذا كنت مهتمًا بمعرفة المزيد ، فراجع:

• وثائق pdb الكاملة في موجه pdb بالقرب منك: (Pdb) h pdb
  
• مستندات pdb من Python
  

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

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

The post تصحيح أخطاء Python باستخدام Pdb appeared first on فيلم تعلم البرمجيات للطالب العربي.

• عزيزي سانتا كلوز البيثوني …
  
• الوظائف العودية في بايثون
  
• الحفاظ على الدولة
  
• هياكل البيانات العودية في بايثون
  
• التكرار الساذج هو ساذج
  
• تفاصيل مزعجة
  
• زعنفة
  
• المراجع
  

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

– سيمور بابيرت ، Mindstorms

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

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

عزيزي سانتا كلوز البيثوني …

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

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

خوارزمية التسليم الحالي التكراري المطبقة في Python:

houses = ["Eric's house", "Kenny's house", "Kyle's house", "Stan's house"]

def deliver_presents_iteratively():
    for house in houses:
        print("Delivering presents to", house)

>>> deliver_presents_iteratively()
Delivering presents to Eric's house
Delivering presents to Kenny's house
Delivering presents to Kyle's house
Delivering presents to Stan's house

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

1. تعيين قزم وإعطاء كل العمل له
2. قم بتعيين الألقاب والمسؤوليات إلى الجان بناءً على عدد المنازل المسؤولة عنها:
   > 1 هو مدير ويمكنه تعيين اثنين من الجان وتقسيم عمله بينهما
   = 1 هو عامل وعليه تسليم الهدايا إلى المنزل المخصص له

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

الخوارزمية الخاصة بالتسليم الحالي التكراري المطبقة في Python:

houses = ["Eric's house", "Kenny's house", "Kyle's house", "Stan's house"]

# Each function call represents an elf doing his work 
def deliver_presents_recursively(houses):
    # Worker elf doing his work
    if len(houses) == 1:
        house = houses[0]
        print("Delivering presents to", house)

    # Manager elf doing his work
    else:
        mid = len(houses) // 2
        first_half = houses[:mid]
        second_half = houses[mid:]

        # Divides his work among two elves
        deliver_presents_recursively(first_half)
        deliver_presents_recursively(second_half)