دليل لأدوات تنسيق السلاسل الحديثة في بايثون

في بايثون الحديثة، تتوفر لديك f-strings ودالة .format() لمعالجة مهام استيفاء وتنسيق السلاسل النصية. تساعدك هذه الأدوات على تضمين المتغيرات والتعبيرات مباشرةً في السلاسل النصية، والتحكم في محاذاة النص، واستخدام مُحدِّدات تنسيق مخصصة لتعديل كيفية ظهور القيم. يمكنك تطبيق هذه التقنيات لإنشاء شيفرة برمجية بايثون منظمة وسهلة القراءة.

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

التعرف على استيفاء السلسلة وتنسيقها في بايثون

لقد طورت بايثون على مر السنين أدوات مختلفة لاستيفاء وتنسيق السلاسل. إذا كنت مبتدئًا في بايثون وتبحث عن طريقة سريعة لتنسيق سلاسلك، فعليك استخدام f-strings من بايثون.

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

في هذا الدرس، ستتعلم كيفية تنسيق سلاسلك باستخدام دالة f-strings ودالة .format(). ستبدأ باستخدام دالة f-strings كبداية، وهي شائعة الاستخدام في أكواد بايثون الحديثة.

استخدام F-Strings لاستيفاء السلاسل

تحتوي بايثون على أداة تنسيق سلاسل نصية تُسمى f-strings، وهي اختصار لـ “سلاسل نصية مُنسّقة”. و هي سلاسل نصية يُمكن إنشاؤها بإضافة حرف f أو F قبلها. تتيح لك هذه السلاسل استيفاء وتنسيق السلاسل النصية عن طريق إدراج متغيرات أو تعبيرات مباشرة في السلسلة.

إنشاء حرفيات F-Strings

ستلقي هنا نظرة على كيفية إنشاء F-Strings عن طريق إضافة الحرف f أو F إلى السلسلة الحرفية:

👇
>>> f"Hello, Pythonista!"
'Hello, Pythonista!'

   👇
>>> F"Hello, Pythonista!"
'Hello, Pythonista!'

استخدام أيٍّ من الحرفين f أو F له نفس التأثير. مع ذلك، من الشائع استخدام حرف f صغير لإنشاء f-strings.

تمامًا كما هو الحال مع الأحرف النصية العادية، يمكنك استخدام علامات اقتباس مفردة أو مزدوجة أو ثلاثية لتحديد f-strings:

👇
>>> f'Single-line f-string with single quotes'
'Single-line f-string with single quotes'

    👇
>>> f"Single-line f-string with double quotes"
'Single-line f-string with single quotes'
     👇
>>> f'''Multiline triple-quoted f-string
... with single quotes'''
'Multiline triple-quoted f-string\nwith single quotes'

     👇
>>> f"""Multiline triple-quoted f-string
... with double quotes"""
'Multiline triple-quoted f-string\nwith double quotes'

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

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

استيفاء المتغيرات في f-strings

يتم تقييم المتغير الذي تُدخله في حقل الاستبدال وتحويله إلى نصه. تُضاف النتيجة إلى النص الأصلي في موقع حقل الاستبدال.

>>> site = "pyarabic"

                   👇
>>> f"Welcome to {site}!"
'Welcome to pyarabic!'

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

تذكر أيضًا أن بايثون يسترجع قيمة site عند تشغيل السلسلة النصية، لذا إذا لم يُعرَّف site في ذلك الوقت، فستحصل على استثناء NameError. لذلك، تُعدّ f-strings مناسبةً لاستيفاء السلاسل النصية بدقة.

الآن بعد أن تعلمت كيفية تضمين متغير في f-strings، يمكنك النظر في تضمين تعبيرات بايثون في حرفيات f-strings.

تضمين التعبيرات في f-strings

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

فيما يلي مثال يستخدم عملية حسابية:

>>> quantity = 6
>>> item = "bananas"
>>> price = 1.74

>>> f"{quantity} {item} cost ${price * quantity}"
'6 bananas cost $10.44'

يمكن أن تكون التعبيرات التي تُضمّنها في f-strings معقدةً للغاية. توضح الأمثلة أدناه بعض الاحتمالات.

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

>>> fruits = ["apple", "mango", "grape"]
>>> numbers = {"one": 1, "two": 2}

                                     👇
>>> f"First fruit in the list is '{fruits[0]}'"
"First fruit in the list is 'apple'"

                                           👇
>>> f"Last two fruits in the list are {fruits[-2:]}"
"Last two fruits in the list are ['mango', 'grape']"

                                            👇
>>> f"Dict value for key 'one' is {numbers['one']}"
"Dict value for key 'one' is 1"

في هذا المثال، تُشغِّل أول تعبيرين مُضمَّنين عمليات الفهرسة والتقطيع في قائمة. ويُشغِّل التعبير الأخير بحثًا عن مفتاح القاموس.

لتضمين الأقواس المتعرجة في f-strings، يجب عليك الهروب منها عن طريق مضاعفتها:

>>> lang = "Python"

     👇         👇
>>> f"{{ {lang} }}"
'{ Python }'

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

استخدام التابع .format() لاستيفاء السلسلة

في كثير من النواحي، تُشبه دالة .format() في بايثون دالة معامل modulo للسلاسل النصية القديمة، إلا أن .format() تتفوق عليها بكثير من حيث تعدد استخداماتها. الشكل العام لاستدعاء .format() موضح أدناه:

template_string.format(*args, **kwargs)

عادةً ما تُستدعى هذه الطريقة على قالب سلسلة نصية، وهو عبارة عن سلسلة نصية تحتوي على حقول بديلة. تتيح لك الوسيطتان *args و**kwargs تحديد القيم المراد إدراجها في القالب. تُرجع هذه الطريقة السلسلة النصية الناتجة.

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

الحجج الموضعية مع تحديد الحقل اليدوي

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

👇  👇        👇
>>> print("{0} {1} cost ${2}".format(6, "bananas", 1.74 * 6))
6 bananas cost $10.44

في هذا المثال، template_string هي السلسلة النصية "{0} {1} cost ${2}"، والتي تتضمن ثلاثة حقول بديلة. تحتوي حقول الاستبدال {0} و{1} و{2} على أرقام تتوافق مع وسيطات الموضع الصفرية 6 و"bananas" و1.74 * 6. يتم إدراج كل وسيط موضعي في القالب وفقًا لفهرسه.

تُدرج وسيطات .format() في قالب السلسلة النصية في الموضع المقابل. تُدرج الوسيطة الأولى في حقل الاستبدال ذي الفهرس 0، وتُدرج الوسيطة الثانية في حقل الاستبدال ذي الفهرس 1، وهكذا.

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

وهنا مثال للعبة:

>>> "{2}.{1}.{0}/{0}{0}.{1}{1}.{2}{2}".format("foo", "bar", "baz")
'baz.bar.foo/foofoo.barbar.bazbaz'

عند تحديد رقم حقل بديل خارج النطاق، ستظهر لك رسالة خطأ. في المثال التالي، تُرقّم وسيطات الموضع 0 و1 و2، ولكنك حددت {3} في القالب:

>>> "{3}".format("foo", "bar", "baz")
Traceback (most recent call last):
    ...
IndexError: Replacement index 3 out of range for positional args tuple

يؤدي هذا الاستدعاء إلى .format() إلى إثارة استثناء IndexError لأن الفهرس 3 خارج النطاق.

الحجج الموضعية مع ترقيم الحقول التلقائي

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

👇 👇       👇
>>> "{} {} cost ${}".format(6, "bananas", 1.74 * 6)
'6 bananas cost $10.44'

في هذا المثال، قمتَ بإزالة الفهارس من قالبك. في هذه الحالة، يُدرج بايثون جميع المُدخلات في حقل الاستبدال بنفس الترتيب الذي استخدمته في استدعاء دالة .format().

عند تحديد ترقيم الحقول التلقائي، يجب عليك توفير عدد من الوسائط يساوي على الأقل عدد الحقول البديلة.

فيما يلي مثال بسيط يحتوي على أربعة حقول استبدال وثلاثة وسيطات فقط:

>>> "{} {} {} {}".format("foo", "bar", "baz")
Traceback (most recent call last):
    ...
IndexError: Replacement index 3 out of range for positional args tuple

في هذا المثال، لديك أربعة حقول بديلة في القالب، ولكن لديك ثلاثة وسيطات فقط في استدعاء .format(). لذا، ستحصل على استثناء IndexError.

أخيرًا، لا بأس إذا تجاوز عدد الوسائط حقول الاستبدال. لا تُستخدم الوسائط الزائدة.

>>> "{} {}".format("foo", "bar", "baz")
'foo bar'

هنا، يتجاهل بايثون وسيطة “baz” ويبني السلسلة النهائية باستخدام “foo” و”bar” فقط.

لاحظ أنه لا يمكنك مزج هاتين التقنيتين:

>>> "{0} {} {2}".format("foo", "bar", "baz")
Traceback (most recent call last):
    ...
ValueError: cannot switch from manual field specification
    to automatic field numbering

عند استخدام بايثون لتنسيق السلاسل باستخدام الوسائط الموضعية، يجب عليك الاختيار بين ترقيم الحقل البديل التلقائي أو الصريح.

حجج الكلمات الرئيسية والحقول المسماة

يمكنك أيضًا استخدام وسيطات الكلمات الأساسية بدلاً من الوسيطة الموضعية لإنتاج نفس النتيجة:

>>> "{quantity} {item} cost ${cost}".format(
...     quantity=6,
...     item="bananas",
...     cost=1.74 * 6,
... )
'6 bananas cost $1.74'

في هذه الحالة، حقول الاستبدال هي  {quantity} و{item} و {cost}. تحدد هذه الحقول الكلمات المفتاحية المقابلة لمعاملات الكلمات المفتاحية:  quantity=6، و item="bananas"، وcost=1.74 * 6. تُدرج قيمة كل كلمة مفتاحية في القالب بدلاً من حقل الاستبدال المقابل لها بالاسم.

يتم إدراج وسيطات الكلمات الرئيسية في سلسلة القالب بدلاً من حقول استبدال الكلمات الرئيسية التي تحمل نفس الاسم:

>>> "{x} {y} {z}".format(x="foo", y="bar", z="baz")
'foo bar baz'

في هذا المثال، تحل قيم كلمات المفتاح x وy وz محل حقول الاستبدال {x} و{y} و{z} على التوالي.

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

👇
>>> "{x} {y} {w}".format(x="foo", y="bar", z="baz")
Traceback (most recent call last):
    ...
KeyError: 'w'

في هذا المثال، قمت بتحديد حقل الاستبدال {w}، ولكن لم يتم تسمية وسيطة الكلمة الأساسية المقابلة w في الاستدعاء إلى .format()، لذلك قام بايثون بإثارة استثناء KeyError.

يمكنك تحديد وسيطات الكلمات الرئيسية بأي ترتيب عشوائي:

>>> "{x} {y} {z}".format(y="bar", z="baz", x="foo")
'foo bar baz'

>>> "{y} {z} {x}".format(x="foo", y="bar", z="baz")
'bar baz foo'

في المثال الأول، تكون حقول الاستبدال مرتبة أبجديًا، بينما الوسائط مختلفة. أما في المثال الثاني، فالأمر معكوس.

يمكنك تحديد وسيطات الموضع والكلمات المفتاحية في استدعاء واحد لـ .format() . في هذه الحالة، يجب أن تظهر جميع وسيطات الموضع قبل أيٍّ من وسيطات الكلمات المفتاحية:

>>> "{0} {x} {1}".format("foo", "bar", x="baz")
'foo baz bar'

>>> "{0} {x} {1}".format("foo", x="baz", "bar")
  File "<input>", line 1
    "{0} {x} {1}".format("foo", x="baz", "bar")
                                              ^
SyntaxError: positional argument follows keyword argument

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

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

>>> x = "foo"
>>> y = "bar"
>>> z = "baz"

             👇
>>> "{0} {1} {s}".format(x, y, s=z)
'foo bar baz'

في هذا المثال، يمكنك تمرير المتغيرين x وy كحجج موضعية وz كحجة كلمة أساسية.

إجراء الاستيفاء المنسق: مكونات حقل الاستبدال

الآن بعد أن تعرفت على أساسيات كيفية استيفاء القيم في سلاسل النصوص الخاصة بك باستخدام f-strings أو .format()، فأنت جاهز لتعلم التنسيق.

عند استدعاء دالة .format() في بايثون، تحتوي سلسلة القالب على حقول بديلة. يتكون حقل الاستبدال من ثلاثة مكونات.

فيما يلي تدوين BNF لقواعد بناء الحقول البديلة:

replacement_field ::= "{"
                           [field_name]
                           ["!" conversion]
                           [":" format_spec]
                      "}"

يتم تفسير المكونات الثلاثة كما هو موضح في الجدول أدناه:

كل مكون اختياري ويمكن حذفه. يمكن أن يكون مكون field_name اسمًا أو فهرسًا كما تعلمت.

تحتوي f-strings أيضًا على حقول استبدال. تركيبها النحوي مشابه:

replacement_field ::= "{"
                            f_expression
                            ["="]
                            ["!" conversion]
                            [":" format_spec]
                      "}"

كما هو موضح هنا، تحتوي f-strings على ما يصل إلى أربعة مكونات. التفسير هو نفسه في الغالب مع دالة .format(). مع ذلك، في سلسلة f، يمكن لمكون f_expression أن يحتوي على متغير أو تعبير. علامة التساوي (=) اختيارية، وتتيح لك إنشاء سلاسل ذاتية التوثيق.

حتى هذه النقطة، قمتَ ببرمجة أمثلة توضح كيفية استخدام مكون f_expression في f-strings ومكون field_name في .format(). في الأقسام التالية، ستتعرف على المكونين الآخرين، اللذين يعملان بشكل مشابه في f-strings و.format().

مكون conversion

يُعرّف مُكوِّن conversion الدالة المُستخدمة لتحويل قيمة الإدخال إلى سلسلة نصية. يُمكن لبايثون إجراء هذا التحويل باستخدام دوال مُدمجة مثل:

• توفر str() تمثيلًا سهل الاستخدام للسلسلة.
• توفر repr() تمثيلًا نصيًا سهل الاستخدام للمطورين.

افتراضيًا، يستخدم كلٌّ من f-strings والتابع .format() الدالة str(). مع ذلك، في بعض الحالات، قد تحتاج إلى استخدام repr(). يمكنك القيام بذلك باستخدام مُكوِّن conversion لحقل الاستبدال.

تظهر القيم الممكنة لل conversion في الجدول أدناه:

لتوضيح الفرق بين هاتين القيمتين، ضع في اعتبارك فئة Person  التالية:

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

    def __str__(self):
        return f"I'm {self.name}, and I'm {self.age} years old."

    def __repr__(self):
        return f"{type(self).__name__}(name='{self.name}', age={self.age})"

تطبق هذه الفئة الطرق الخاصة  .__str__() و  .__repr__()، والتي تدعم داخليًا الدالتين str() و repr() المضمنتين.

الآن فكر في كيفية عمل هذه الفئة في سياق f-strings والتابع .format():

>>> from person import Person

>>> jane = Person("Jane", 25)

           👇
>>> f"{jane!s}"
"I'm Jane, and I'm 25 years old."
           👇
>>> f"{jane!r}"
"Person(name='Jane', age=25)"

          👇
>>> "{jane!s}".format(jane=jane)
"I'm Jane, and I'm 25 years old."
          👇
>>> "{jane!r}".format(jane=jane)
"Person(name='Jane', age=25)"

عند استخدام قيمة !s لمكون conversion، ستحصل على تمثيل نصي سهل الاستخدام للكائن المُقحم. وبالمثل، عند استخدام قيمة !r، ستحصل على تمثيل نصي سهل الاستخدام للمطورين.

مكون  format_spec

مُكوِّن format_spec هو الجزء الأخير من حقل الاستبدال. يُمثل هذا المُكوِّن جوهر وظيفة تنسيق السلاسل النصية في بايثون. يحتوي على معلومات تُتيح التحكم الدقيق في كيفية تنسيق قيم الإدخال قبل إدراجها في سلسلة القالب.

يظهر أدناه تدوين BNF الذي يصف بناء جملة هذا المكون:

format_spec ::= [[fill]align][sign]["z"]["#"]["0"][width]
                [grouping_option]["." precision][type]

يتم إدراج مكونات format_spec بالترتيب في الجدول التالي:

في القسم التالي، ستتعلم كيفية عمل هذه المكونات عمليًا وكيف يمكنك استخدامها لتنسيق السلاسل الخاصة بك إما باستخدام أحرف f-string أو باستخدام التابع .format().

محددات التنسيق ومكوناتها

عمليًا، عند إنشاء مُحدِّدات تنسيق لتنسيق القيم التي تُدخِلها في سلاسلك النصية، يمكنك استخدام مكونات مختلفة وفقًا لاحتياجاتك الخاصة. في الأقسام التالية، ستتعرف على مكونات مُحدِّدات التنسيق وكيفية استخدامها.

المكون type

للبدء، ستبدأ بمكوّن type، وهو الجزء الأخير من format_spec. يُحدد هذا المكوّن  type العرض، وهو نوع التحويل المُطبّق على القيمة المُقابلة لإنتاج المُخرَج.

يتم وصف القيم المحتملة للtype أدناه:

أول نوع عرض لديك هو b، والذي يشير إلى تحويل الأعداد الصحيحة الثنائية:

👇
>>> f"{257:b}"
'100000001'

      👇
>>> "{:b}".format(257)
'100000001'

في هذه الأمثلة، يمكنك استخدام نوع التحويل b لتمثيل الرقم العشري 257 كرقم ثنائي.

يسمح لك نوع العرض c بتحويل عدد صحيح إدخال إلى حرف Unicode المرتبط به:

👇
>>> f"{42:c}"
'*'

      👇
>>> "{:c}".format(42)
'*'

>>> chr(42)
'*'

كما هو موضح أعلاه، يمكنك تحويل قيمة عدد صحيح مُحدد إلى حرف Unicode مُرتبط به باستخدام نوع العرض c. يُرجى ملاحظة أنه يمكنك استخدام الدالة chr() المُدمجة لتأكيد التحويل.

يختار نوع التحويل g إما الإخراج ذي النقطة العائمة أو الأسي، اعتمادًا على حجم الأس:

👇
>>> f"{3.14159:g}"
'3.14159'
                      👇
>>> f"{-123456789.8765:g}"
'-1.23457e+08'

      👇
>>> "{:g}".format(3.14159)
'3.14159'
      👇
>>> "{:g}".format(-123456789.8765)
'-1.23457e+08'

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

نوع التحويل G مماثل لـ g باستثناء عندما يكون الإخراج أسي، وفي هذه الحالة سيتم عرض “E” بأحرف كبيرة:

👇
>>> f"{-123456789.8765:G}"
'-1.23457E+08'
      👇
>>> "{:G}".format(-123456789.8765)
'-1.23457E+08'

النتيجة هي نفسها كما في المثال السابق، ولكن هذه المرة بالحرف الكبير “E”.

ستجد بعض الحالات الأخرى التي ستلاحظ فيها فرقًا بين نوعي العرض g وG. على سبيل المثال، في بعض الحالات، قد تؤدي عملية الفاصلة العائمة إلى قيمة لا نهائية تقريبًا. يُمثل هذا الرقم في بايثون بصيغة سلسلة نصية “inf”.

قد تُنتج عملية الفاصلة العائمة أيضًا قيمةً لا يُمكن تمثيلها كرقم. يُمثل بايثون هذه القيمة بالسلسلة “NaN”، والتي تعني “ليس رقمًا”.

عند تمرير هذه القيم إلى f-strings أو التابع .format()، ينتج نوع العرض g إخراجًا بأحرف صغيرة، وينتج G إخراجًا بأحرف كبيرة:

>>> infinite = float("inf")
>>> infinite
inf
>>> not_a_number = infinite * 0
>>> not_a_number
nan

>>> f"{infinite:g}"
'inf'
>>> f"{not_a_number:g}"
'nan'
>>> f"{infinite:G}"
'INF'
>>> f"{not_a_number:G}"
'NAN'

>>> "{:g}".format(infinite)
'inf'
>>> "{:g}".format(not_a_number)
'nan'
>>> "{:G}".format(infinite)
'INF'
>>> "{:G}".format(not_a_number)
'NAN'

ستلاحظ سلوكًا مشابهًا مع نوعي العرض f وF. لمزيد من المعلومات حول تمثيل الفاصلة العائمة، وinf، وNaN، تفضل بزيارة صفحة ويكيبيديا حول IEEE 754.

مكون width

يحدد مكون width الحد الأدنى لعرض حقل الإخراج:

👇
>>> f"{'Hi':8s}"
'Hi      '
>>> f"{123:8d}"
'     123'

       👇
>>> "{0:8s}".format("Hi")
'Hi      '
>>> "{0:8d}".format(123)
'     123'

لاحظ أن هذا هو الحد الأدنى لعرض الحقل. لنفترض أنك حددت قيمة أطول من الحد الأدنى:

👇
>>> "{0:2s}".format("Pythonista")
'Pythonista'

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

مكونات  align و fill

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

فيما يلي القيم المحتملة للمكون الفرعي align:

يشير مُحدد التنسيق الذي يستخدم علامة الأقل من (<) إلى أن الإخراج سيكون محاذيًا لليسار:

👇
>>> f"{'Hi':<8s}"
'Hi      '
>>> f"{123:<8d}"
'123     '

       👇
>>> "{0:<8s}".format("Hi")
'Hi      '
>>> "{0:<8d}".format(123)
'123     '

محاذاة القيمة إلى اليسار هو السلوك الافتراضي مع السلاسل مثل “Hi”.

يشير مُحدد التنسيق الذي يستخدم علامة أكبر من (>) إلى أن الإخراج سيكون محاذيًا لليمين:

👇
>>> f"{'Hi':>8s}"
'      Hi'
>>> f"{123:>8d}"
'     123'

       👇
>>> "{0:>8s}".format("Hi")
'      Hi'
>>> "{0:>8d}".format(123)
'     123'

المحاذاة إلى اليمين هو السلوك الافتراضي للقيم الرقمية مثل 123.

يشير مُحدد التنسيق الذي يستخدم علامة الإدراج (^) إلى أن الإخراج سيكون متمركزًا في حقل الإخراج:

👇
>>> f"{'Hi':^8s}"
'   Hi   '
>>> f"{123:^8d}"
'  123   '

       👇
>>> "{0:^8s}".format("Hi")
'   Hi   '
>>> "{0:^8d}".format(123)
'  123   '

باستخدام حرف الإقحام، يمكنك وضع قيمة الإدخال في منتصف حقل الإخراج.

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

👇
>>> f"{123:+8d}"
'    +123'
           👇
>>> f"{-123:+8d}"
'    -123'

       👇
>>> "{0:+8d}".format(123)
'    +123'
       👇
>>> "{0:+8d}".format(-123)
'    -123'

في هذه الأمثلة، استخدمت مكون  sign، والذي ستتعرف عليه بالتفصيل في القسم التالي.

إذا قمت بتعيين محاذاة إلى علامة التساوي (=)، فستظهر العلامة على يسار حقل الإخراج:

👇
>>> f"{123:=+8d}"
'+    123'
>>> f"{-123:=+8d}"
'-    123'

       👇
>>> "{0:=+8d}".format(123)
'+    123'
>>> "{0:=+8d}".format(-123)
'-    123'

كما ترى، تظهر العلامة الآن على اليسار ويتم إضافة الحشو بين العلامة والرقم.

يتيح لك مكون  fill استبدال المساحة الزائدة عندما لا تملأ قيمة الإدخال عرض المخرجات بالكامل. يمكن استخدام أي حرف باستثناء الأقواس المعقوفة ({}).

تظهر أدناه بعض الأمثلة لاستخدام  fill:

👇
>>> f"{'Hi':->8s}"
'------Hi'
          👇
>>> f"{123:#<8d}"
'123#####'
           👇
>>> f"{'Hi':*^8s}"
'***Hi***'

       👇
>>> "{0:->8s}".format("Hi")
'------Hi'
       👇
>>> "{0:#<8d}".format(123)
'123#####'
       👇
>>> "{0:*^8s}".format("Hi")
'***Hi***'

ضع في اعتبارك أنه إذا قمت بتحديد قيمة لل fill، فيجب عليك أيضًا تضمين قيمة لل align.

مكون sign

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

👇
>>> f"{123:+6d}"
'  +123'
>>> f"{-123:+6d}"
'  -123'

       👇
>>> "{0:+6d}".format(123)
'  +123'
>>> "{0:+6d}".format(-123)
'  -123'

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

إذا استخدمت علامة الطرح (-)، فإن القيم الرقمية السالبة فقط ستتضمن علامة بادئة:

👇
>>> f"{123:-6d}"
'   123'
>>> f"{-123:-6d}"
'  -123'

       👇
>>> '{0:-6d}'.format(123)
'   123'
>>> '{0:-6d}'.format(-123)
'  -123'

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

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

👇
>>> f"{123:*> 6d}"
'** 123'
>>> f"{-123:*> 6d}"
'**-123'

         👇
>>> "{0:*> 6d}".format(123)
'** 123'
>>> "{0:*> 6d}".format(-123)
'**-123'

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

المكون #

عند تضمين رمز التجزئة (#) في مكون format_spec، سيختار بايثون نموذج إخراج بديل لأنواع عرض معينة. بالنسبة لأنواع العرض الثنائية (b)، والثمانية (o)، والسادسة عشرية (x)، يؤدي رمز التجزئة إلى تضمين مؤشر أساسي صريح على يسار القيمة:

>>> value = 16

                       👇
>>> f"{value:b}, {value:#b}"
'10000, 0b10000'
>>> f"{value:o}, {value:#o}"
'20, 0o20'
>>> f"{value:x}, {value:#x}"
'10, 0x10'

              👇
>>> "{0:b}, {0:#b}".format(value)
'10000, 0b10000'
>>> "{0:o}, {0:#o}".format(value)
'20, 0o20'
>>> "{0:x}, {0:#x}".format(value)
'10, 0x10'

المؤشرات الأساسية هي 0b و0o و0x للتمثيلات الثنائية والثمانية والسادسة عشرية على التوالي.

بالنسبة لأنواع العرض ذات النقطة العائمة (f أو F) والأسية (e أو E)، فإن حرف التجزئة يجبر المخرجات على احتواء نقطة عشرية، حتى لو كان الإدخال يتكون من عدد صحيح:

👇
>>> f"{123:.0f}, {123:#.0f}"
'123, 123.'
>>> f"{123:.0e}, {123:#.0e}"
'1e+02, 1.e+02'

                👇
>>> "{0:.0f}, {0:#.0f}".format(123)
'123, 123.'
>>> "{0:.0e}, {0:#.0e}".format(123)
'1e+02, 1.e+02'

بالنسبة لأي نوع عرض آخر غير تلك المذكورة أعلاه، ليس لعلامة التجزئة (#) أي تأثير.

المكون 0

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

👇
>>> f"{123:05d}"
'00123'
>>> f"{12.3:08.1f}"
'000012.3'

       👇
>>> "{0:05d}".format(123)
'00123'
>>> "{0:08.1f}".format(12.3)
'000012.3'

عادةً ما تستخدم المكوّن 0 للقيم الرقمية، كما هو موضح أعلاه. ومع ذلك، فهو يعمل أيضًا مع القيم النصية:

👇
>>> f"{'Hi':>06s}"
'0000Hi'

        👇
>>> "{0:>06s}".format("Hi")
'0000Hi'

إذا قمت بتحديد كل من fill وalign، فإن fill تتجاوز المكون 0:

>>> f"{123:*>05d}"
'**123'

>>> "{0:*>05d}".format(123)
'**123'

يتحكم مكونا  fill و 0 في نفس الشيء، لذا لا حاجة لتحديدهما في الوقت نفسه. عمليًا، يُعدّ  0 زائدًا عن الحاجة، وربما أُضيف لتسهيل الأمر على المطورين الذين يعرفون علم التحويل  0 المشابه لمشغل وحدة السلسلة.

إنشاء مواصفات التنسيق بشكل ديناميكي

داخل مُحدِّد التنسيق، يُمكنك تضمين أزواج من الأقواس المعقوفة ({}) التي تُتيح لك توفير قيم باستخدام المتغيرات. سيتم تقييم هذا الجزء من حقل الاستبدال أثناء التشغيل واستبداله بالقيمة المُقابلة:

>>> width = 10
>>> precision = 2

                  👇      👇
>>> f"{123.4567:{width}.{precision}f}"
'    123.46'

        👇  👇
>>> "{2:{0}.{1}f}".format(width, precision, 123.4567)
'    123.46'

هنا، قمتَ بدمج زوجين من الأقواس المعقوفة في السلسلة النصية. تُدرج نسخة f-string قيم العرض والدقة مباشرةً في الأقواس المتداخلة. في نسخة .format()، تحتوي الأقواس المتداخلة على الفهرسين 0 و1، واللذين يُطابقان أول معاملين للتابع.

يمكنك أيضًا استخدام وسيطات الكلمات المفتاحية في استدعاء دالة .format(). المثال التالي مكافئ وظيفيًا للمثال السابق:

👇      👇
>>> "{number:{width}.{precision}f}".format(
...     width=width, precision=precision, number=123.4567
... )
'    123.46'

كما يمكنك أن ترى، هذا التحديث لمثال .format() أكثر قابلية للقراءة ووصفًا من المثال السابق.

الآن، أنت تعرف كيفية استيفاء السلاسل النصية وتنسيقها في بايثون. لقد تعلمت كيفية استخدام أدوات بايثون الحديثة، مثل f-strings ودالة .format()، للتعامل بفعالية مع استيفاء السلاسل النصية وتنسيقها.