راهنمای تکنیک های جدیدتر فرمت رشته پایتون

در آموزش قبلی در این مجموعه مقدماتی، اولین نگاهی به نحوه قالب بندی رشته های خود با رشته های f پایتون داشتید. در پایان این آموزش با این تکنیک بیشتر آشنا خواهید شد.

از آنجایی که رشته های f نسبتا در زبان پایتون جدید هستند، برای شما خوب است که با تکنیک دوم و کمی قدیمی تر نیز آشنا شوید. احتمالا در کدهای قدیمی پایتون با آن مواجه خواهید شد.

در این آموزش با موارد زیر آشنا خواهید شد:

1. متد string .format()
2. رشته قالب بندی شده تحت اللفظی یا f-string

شما با جزئیات این تکنیک های قالب بندی آشنا خواهید شد و آنها را به جعبه ابزار قالب بندی رشته پایتون خود اضافه خواهید کرد.

ممکن است متوجه شوید که روش های مختلفی برای قالب بندی رشته ها در پایتون وجود دارد که با یکی از مانتراهای خاص پایتون مطابقت دارد:

باید یک و ترجیحا فقط یک راه واضح برای انجام آن وجود داشته باشد. —تیم پیترز، ذن پایتون

تکنیک های مختلف قالب بندی رشته در طول سال هایی که پایتون وجود داشته و رشد کرده است، به طور تاریخی توسعه یافته است. تکنیک های قدیمی تر برای اطمینان از سازگاری با عقب نگه داشته می شوند و برخی حتی موارد استفاده خاصی دارند.

اگر در حال شروع کار با پایتون هستید و به دنبال یک راه واحد برای قالب بندی رشته های خود هستید، از رشته های f پایتون استفاده کنید. اگر با کدهای فرمت رشته ای عجیب و غریب مواجه شده اید و می خواهید بیشتر بدانید، یا نیاز به کار با نسخه های قدیمی پایتون دارید، ایده خوبی است که در مورد تکنیک های دیگر نیز بیاموزید.

متد ()format رشته پایتون

روش Python string .format() در نسخه 2.6 معرفی شد. از بسیاری جهات شبیه عملگر مدول رشته است، اما .format() از نظر تطبیق پذیری بسیار فراتر از آن است. شکل کلی فراخوانی Python .format() در زیر نشان داده شده است:

<template>.format(<positional_argument(s)>, <keyword_argument(s)>)

توجه داشته باشید که این یک روش است، نه یک عملگر. شما متد را در <template> فراخوانی می کنید، که رشته ای حاوی فیلدهای جایگزین است. <positional_arguments> و <keyword_arguments> به متد مقادیری را مشخص می کند که به جای فیلدهای جایگزینی در <template> درج می شوند. رشته قالب بندی شده به دست آمده، مقدار بازگشتی متد است.

در رشته <الگو>، فیلدهای جایگزین در پرانتز های فرفری ({}) محصور شده اند. هر چیزی که در پرانتز های فرفری وجود نداشته باشد، متن تحت اللفظی است که مستقیما از الگو به خروجی کپی می شود. اگر نیاز به اضافه کردن یک کاراکتر پرانتز فرفری تحت اللفظی، مانند { یا }، در رشته الگو دارید، می توانید با دو برابر کردن آن از این کاراکتر فرار کنید:

>>> '{{ {0} }}'.format('foo')
'{ foo }'

اکنون بریس های فرفری در خروجی شما گنجانده شده است.

متد ()format.string: آرگومان ها

بیایید با یک مثال سریع شروع کنیم تا قبل از اینکه به جزئیات بیشتر در مورد نحوه استفاده از این متد در پایتون برای قالب بندی رشته ها بپردازید، با شما آشنا شویم. با استفاده از تکنیک قالب بندی قدیمی تر با عملگر مدول رشته، خواندن کد کمی سخت خواهد بود:

>>> print('%d %s cost $%.2f' % (6, 'bananas', 1.74))
6 bananas cost $1.74

در مثال بالا، از عملگر مدول رشته برای قالب بندی رشته استفاده کردید. برای خوانایی بهتر، می توانید از روش string .format() پایتون برای به دست آوردن همان نتیجه استفاده کنید:

>>> print('{0} {1} cost ${2}'.format(6, 'bananas', 1.74))
6 bananas cost $1.74

در این مثال، <template> رشته '{0} {1} cost $ {2}' است. فیلدهای جایگزینی {0}، {1} و {2} هستند که حاوی اعدادی هستند که با آرگومان های موقعیتی مبتنی بر صفر 6، "موز" و 1.74 مطابقت دارند. هر آرگومان موقعیتی به جای فیلد جایگزین مربوطه در الگو درج می شود:

مثال بعدی از آرگومان های کلیدی به جای پارامترهای موقعیتی برای تولید همان نتیجه استفاده می کند:

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

در این حالت، فیلدهای جایگزینی {quantity}، {item} و {price} هستند. این فیلدها کلمات کلیدی را مشخص می کنند که با آرگومان های کلمه کلیدی مقدار=6 ، ماده='موز' و قیمت=1.74 مطابقت دارند. هر مقدار کلمه کلیدی به جای فیلد جایگزینی مربوطه در الگو درج می شود:

در آموزش بعدی این مجموعه مقدماتی، که توابع و انتقال آرگومان را بررسی می کند، در مورد آرگومان های موقعیتی و کلمات کلیدی بیشتر خواهید آموخت. در حال حاضر، دو بخش زیر به شما نشان می دهد که چگونه از آنها با متد Python .format() استفاده می شود.

آرگومان های موقعیتی

آرگومان های موقعیتی به جای فیلدهای جایگزینی شماره گذاری شده در الگو درج می شوند. مانند نمایه سازی فهرست، شماره گذاری فیلدهای جایگزین بر اساس صفر است. اولین آرگومان موقعیتی 0 ، دومی 1 و غیره شماره گذاری شده است:

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

توجه داشته باشید که فیلدهای جایگزین لازم نیست به ترتیب عددی در الگو ظاهر شوند. آنها را می توان به هر ترتیبی مشخص کرد و می توانند بیش از یک بار ظاهر شوند:

>>> '{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):
  File "<pyshell#26>", line 1, in <module>
    '{3}'.format('foo', 'bar', 'baz')
IndexError: tuple index out of range

این یک استثنای IndexError را ایجاد می کند.

با شروع با پایتون 3.1، می توانید اعداد موجود در فیلدهای جایگزین را حذف کنید، در این صورت مترجم ترتیب متوالی را به خود می گیرد. این به عنوان شماره گذاری خودکار فیلد نامیده می شود:

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

هنگامی که شماره گذاری خودکار فیلدها را مشخص می کنید، باید حداقل به تعداد فیلدهای جایگزین آرگومان ارائه دهید:

>>> '{}{}{}{}'.format('foo','bar','baz')
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    '{}{}{}{}'.format('foo','bar','baz')
IndexError: tuple index out of range

در این مورد، چهار فیلد جایگزین در الگو وجود دارد اما فقط سه آرگومان وجود دارد، بنابراین یک استثنای IndexError رخ می دهد. از سوی دیگر، اگر تعداد آرگومان ها بیشتر از فیلدهای جایگزین باشد، اشکالی ندارد. آرگومان های اضافی به سادگی استفاده نمی شوند:

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

در اینجا، استدلال "باز" نادیده گرفته می شود.

توجه داشته باشید که نمی توانید این دو تکنیک را با هم مخلوط کنید:

>>> '{1}{}{0}'.format('foo','bar','baz')
Traceback (most recent call last):
  File "<pyshell#28>", line 1, in <module>
    '{1}{}{0}'.format('foo','bar','baz')
ValueError: cannot switch from manual field specification to automatic field
 numbering

هنگامی که از پایتون برای قالب بندی رشته ها با آرگومان های موقعیتی استفاده می کنید، باید بین شماره گذاری فیلد جایگزینی خودکار یا صریح یکی را انتخاب کنید.

آرگومان های کلمات کلیدی

آرگومان های کلمه کلیدی به جای فیلدهای جایگزینی کلمات کلیدی با همین نام در رشته الگو درج می شوند:

>>> '{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):
  File "<stdin>", line 1, in <module>
KeyError: 'w'

در اینجا، شما فیلد جایگزینی {w} را مشخص می کنید، اما هیچ آرگومان کلمه کلیدی متناظری به نام w وجود ندارد. پایتون یک استثنای KeyError را ایجاد می کند.

در حالی که شما باید آرگومان های موقعیتی را به ترتیب متوالی مشخص کنید، اما می توانید آرگومان های کلیدی را به هر ترتیب دلخواه مشخص کنید:

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

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

شما می توانید آرگومان های موقعیتی و کلمه کلیدی را در یک فراخوانی Python .format() مشخص کنید. فقط توجه داشته باشید که اگر این کار را انجام دهید، تمام آرگومان های موقعیتی باید قبل از هر یک از آرگومان های کلمه کلیدی ظاهر شوند:

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

در واقع، این الزام که تمام آرگومان های موقعیتی قبل از هر آرگومان کلمه کلیدی ظاهر شوند، فقط برای روش های فرمت پایتون اعمال نمی شود. این به طور کلی در مورد هر تابع یا فراخوانی متد صادق است. در آموزش بعدی این مجموعه که توابع و فراخوانی های تابع را بررسی می کند، در مورد این موضوع بیشتر خواهید آموخت.

در تمام مثال هایی که تاکنون نشان داده شده است، مقادیری که به متد Python .format() ارسال کرده اید، مقادیر تحت اللفظی بوده اند، اما می توانید متغیرها را نیز مشخص کنید:

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

در این حالت، متغیرهای x و y را به عنوان مقادیر پارامتر موقعیتی و z را به عنوان مقدار پارامتر کلمه کلیدی ارسال می کنید.

متد ()format.string: فیلدهای جایگزینی ساده

همانطور که دیدید، وقتی متد .format() پایتون را فراخوانی می کنید، رشته <template> شامل فیلدهای جایگزین است. اینها نشان می دهند که در کجای الگو آرگومان ها را در متد وارد کنید. یک میدان جایگزینی از سه جزء تشکیل شده است:

{[<نام>][!<تبدیل>][:<format_spec>]}

این مؤلفه ها به شرح زیر تفسیر می شوند:

<name>

<conversion>

<format_spec>

هر جزء اختیاری است و ممکن است حذف شود. بیایید نگاهی عمیق تر به هر جزء بیندازیم.

مؤلفه <name>

مؤلفه <name> اولین بخش از یک فیلد جایگزین است:

{[<name>][!<conversion>][:<format_spec>]}

<name> نشان می دهد که کدام آرگومان از لیست آرگومان در رشته فرمت پایتون در مکان داده شده درج شده است. این یا یک عدد برای یک آرگومان موقعیتی یا یک کلمه کلیدی برای آرگومان کلمه کلیدی است. در مثال زیر، اجزای <name> فیلدهای جایگزینی به ترتیب 0، 1 و baz هستند:

>>> x, y, z = 1, 2, 3
>>> '{0}, {1}, {baz}'.format(x, y, baz=z)
'1, 2, 3'

اگر یک آرگومان یک لیست است، می توانید از شاخص هایی با <نام> برای دسترسی به عناصر لیست استفاده کنید:

>>> a = ['foo', 'bar', 'baz']
>>> '{0[0]}, {0[2]}'.format(a)
'foo, baz'
>>> '{my_list[0]}, {my_list[2]}'.format(my_list=a)
'foo, baz'

به طور مشابه، می توانید از یک مرجع کلیدی با <name> استفاده کنید، اگر آرگومان مربوطه یک فرهنگ لغت باشد:

>>> d = {'key1': 'foo', 'key2': 'bar'}
>>> d['key1']
'foo'
>>> '{0[key1]}'.format(d)
'foo'
>>> d['key2']
'bar'
>>> '{my_dict[key2]}'.format(my_dict=d)
'bar'

همچنین می توانید ویژگی های شی را از داخل یک فیلد جایگزین ارجاع دهید. در آموزش قبلی در این مجموعه، یاد گرفتید که تقریبا هر مورد از داده ها در پایتون یک شی است. اشیاء ممکن است دارای ویژگی هایی باشند که با استفاده از نماد نقطه ای قابل دسترسی هستند:

obj.attr

در اینجا، obj یک شی با یک ویژگی به نام attr است. شما از نماد نقطه برای دسترسی به ویژگی شی استفاده می کنید. بیایید مثالی را ببینیم. اعداد مختلط در پایتون دارای ویژگی هایی به نام های .real و .imag هستند که بخش های واقعی و خیالی عدد را نشان می دهند. با استفاده از نماد نقطه ای نیز می توانید به این موارد دسترسی داشته باشید:

>>> z = 3+5j
>>> type(z)
<class 'complex'>
>>> z.real
3.0
>>> z.imag
5.0

چندین آموزش آینده در این مجموعه در مورد برنامه نویسی شی گرا وجود دارد که در آن چیزهای بیشتری در مورد ویژگی های شی مانند این یاد خواهید گرفت.

ارتباط ویژگی های شی در این زمینه این است که می توانید آنها را در فیلد جایگزینی Python .format() مشخص کنید:

>>> z
(3+5j)
>>> 'real = {0.real}, imag = {0.imag}'.format(z)
'real = 3.0, imag = 5.0'

همانطور که می بینید، در پایتون قالب بندی اجزای اشیاء پیچیده با استفاده از متد .format() نسبتا ساده است.

مؤلفه <تبدیل>

مؤلفه <تبدیل> قسمت میانی یک فیلد جایگزینی است:

{[<نام>][!<تبدیل>][:<format_spec>]}

پایتون می تواند یک شی را به عنوان یک رشته با استفاده از سه تابع داخلی مختلف قالب بندی کند:

str()

repr()

ascii()

به طور پیش فرض، متد Python .format() از str() استفاده می کند، اما در برخی موارد، ممکن است بخواهید .format() را مجبور به استفاده از یکی از دو مورد دیگر کنید. می توانید این کار را با مؤلفه <تبدیل> یک فیلد جایگزین انجام دهید. مقادیر ممکن برای <تبدیل> در جدول زیر نشان داده شده است:

!s

!r

!a

مثال های زیر پایتون را مجبور می کند تا تبدیل رشته را به ترتیب با استفاده از str()، repr() و ascii() انجام دهد:

>>> '{0!s}'.format(42)
'42'
>>> '{0!r}'.format(42)
'42'
>>> '{0!a}'.format(42)
'42'

در بسیاری از موارد، بدون توجه به اینکه از کدام تابع تبدیل استفاده می کنید، نتیجه یکسان است، همانطور که در مثال بالا مشاهده می کنید. همانطور که گفته شد، شما اغلب به مؤلفه <تبدیل> نیاز نخواهید داشت، بنابراین زمان زیادی را برای آن در اینجا صرف نخواهید کرد. با این حال، موقعیت هایی وجود دارد که تفاوت ایجاد می کند، بنابراین خوب است بدانید که در صورت نیاز این توانایی را دارید که یک تابع تبدیل خاص را مجبور کنید.

مؤلفه <format_spec>

جزء <format_spec> آخرین قسمت یک فیلد جایگزینی است:

{[<نام>][!<conversion>][:<format_spec>]}

<format_spec> نشان دهنده عملکرد متد Python .format() است. این شامل اطلاعاتی است که کنترل خوبی بر نحوه قالب بندی مقادیر قبل از درج در رشته الگو اعمال می کند. شکل کلی این است:

:[[<fill>]<align>][<sign>][#][0][<width>][<group>][.<prec>][<type>]

ده جزء فرعی <format_spec> به ترتیب نشان داده شده مشخص شده است. آنها قالب بندی را همانطور که در جدول زیر توضیح داده شده است کنترل می کنند:

:

<fill>

<align>

<sign>

#

0

<width>

<group>

.<prec>

<type>

این توابع مشابه اجزایی هستند که در مشخص کننده تبدیل اپراتور مدول رشته پیدا خواهید کرد، اما تا حدودی با قابلیت بیشتر. قابلیت های آنها را به طور کامل در بخش های بعدی خواهید دید.

مؤلفه فرعی <type>

بیایید با <type> شروع کنیم که قسمت پایانی <format_spec> است. زیر مؤلفه <type> نوع ارائه را مشخص می کند، که نوع تبدیلی است که بر روی مقدار مربوطه برای تولید خروجی انجام می شود. مقادیر احتمالی در زیر نشان داده شده است:

b

c

d

e or E

f or F

g or G

o

s

x or X

%

اینها مانند انواع تبدیل مورد استفاده با عملگر مدول رشته هستند و در بسیاری از موارد، عملکرد یکسانی دارند. مثال های زیر شباهت را نشان می دهد:

>>> '%d' % 42
'42'
>>> '{:d}'.format(42)
'42'

>>> '%f' % 2.1
'2.100000'
>>> '{:f}'.format(2.1)
'2.100000'

>>> '%s' % 'foobar'
'foobar'
>>> '{:s}'.format('foobar')
'foobar'

>>> '%x' % 31
'1f'
>>> '{:x}'.format(31)
'1f'

با این حال، تفاوت های جزئی بین برخی از انواع ارائه Python .format() و انواع تبدیل عملگر مدول رشته وجود دارد:

در مرحله بعد، چندین مثال را مشاهده خواهید کرد که این تفاوت ها را نشان می دهد، و همچنین برخی از ویژگی های اضافه شده انواع ارائه متد Python .format() را مشاهده خواهید کرد. اولین نوع ارائه ای که خواهید دید b است که تبدیل عدد صحیح باینری را مشخص می کند:

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

اپراتور modulo به هیچ وجه از نوع تبدیل باینری پشتیبانی نمی کند:

>>> '%b' % 257
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: unsupported format character 'b' (0x62) at index 1

با این حال، عملگر مدول امکان تبدیل عدد صحیح اعشاری را با هر یک از انواع d، i و u فراهم می کند. فقط نوع ارائه d تبدیل عدد صحیح اعشاری را با متد Python .format() نشان می دهد. انواع ارائه i و u پشتیبانی نمی شوند و واقعا ضروری نیستند.

مورد بعدی تبدیل تک کاراکتر است. عملگر مدول اجازه می دهد تا یک عدد صحیح یا یک کاراکتر با نوع تبدیل c داشته باشد:

>>> '%c' % 35
'#'
>>> '%c' % '#'
'#'

از سوی دیگر، متد .format() پایتون مستلزم آن است که مقدار مربوط به نوع ارائه c یک عدد صحیح باشد:

>>> '{:c}'.format(35)
'#'
>>> '{:c}'.format('#')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'c' for object of type 'str'

هنگامی که می خواهید مقداری از نوع دیگری را ارسال کنید، یک ValueError دریافت خواهید کرد.

هم برای عملگر مدول رشته و هم برای روش .format() پایتون، نوع تبدیل g بسته به بزرگی توان و مقدار مشخص شده برای <prec> خروجی ممیز شناور یا نمایی را انتخاب می کند:

>>> '{:g}'.format(3.14159)
'3.14159'

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

قوانین دقیق حاکم بر انتخاب با .format() کمی پیچیده تر از عملگر مدول است. به طور کلی، می توانید اعتماد کنید که انتخاب منطقی خواهد بود.

G با g یکسان است به جز زمانی که خروجی نمایی باشد ، در این صورت "E" با حروف بزرگ خواهد بود:

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

نتیجه مانند مثال قبلی است، اما این بار با حرف بزرگ "E".

>>> x = 1e300 * 1e300
>>> x
inf

>>> '{:g}'.format(x)
'inf'
>>> '{:g}'.format(x * 0)
'nan'

>>> '{:G}'.format(x)
'INF'
>>> '{:G}'.format(x * 0)
'NAN'

رفتار مشابهی را با انواع ارائه های f و F نیز مشاهده خواهید کرد:

>>> '{:f}'.format(x)
'inf'
>>> '{:F}'.format(x)
'INF'

>>> '{:f}'.format(x * 0)
'nan'
>>> '{:F}'.format(x * 0)
'NAN'

برای اطلاعات بیشتر در مورد نمایش ممیز شناور، inf و NaN، به صفحه ویکی پدیا در IEEE 754-1985 مراجعه کنید.

عملگر مدول از انواع تبدیل r و a به ترتیب توسط repr() و ascii() پشتیبانی می کند. متد .format() پایتون از انواع r و a presentation پشتیبانی نمی کند، اما می توانید همین کار را با کامپوننت های تبدیل !r و !a در قسمت جایگزینی انجام دهید.

در نهایت، می توانید از نوع تبدیل ٪ با عملگر modulo برای وارد کردن کاراکتر '٪' تحت اللفظی در خروجی استفاده کنید:

>>> '%f%%' % 65.0
'65.000000%'

برای درج یک کاراکتر "٪" تحت اللفظی در خروجی متد Python .format() به چیز خاصی نیاز ندارید، بنابراین نوع ٪ presentation هدف متفاوتی را برای درصد خروجی دنبال می کند. مقدار مشخص شده را در 100 ضرب می کند و علامت درصد را اضافه می کند:

>>> '{:%}'.format(0.65)
'65.000000%'

بخش های باقیمانده <format_spec> نشان می دهد که چگونه نوع ارائه انتخاب شده قالب بندی می شود، تقریبا مانند عرض و مشخص کننده های دقیق اپراتور مدول رشته و پرچم های تبدیل. این موارد در بخش های بعدی به طور کامل توضیح داده شده است.

اجزای فرعی <fill> و <align>

<پر کردن> و <تراز کردن> نحوه بالشتک کردن و قرار دادن خروجی قالب بندی شده در عرض فیلد مشخص شده را کنترل می کنند. این اجزای فرعی تنها زمانی معنا دارند که مقدار فیلد قالب بندی شده کل عرض فیلد را اشغال نکند، که تنها در صورتی می تواند اتفاق بیفتد که حداقل عرض فیلد با <width> مشخص شده باشد. اگر <width> مشخص نشده باشد، <fill> و <align> به طور موثر نادیده گرفته می شوند. بعدا در این آموزش <width> را پوشش خواهید داد.

در اینجا مقادیر ممکن برای زیر مؤلفه <align> آمده است:

<

>

^

=

مقداری که از علامت کمتر از (<) استفاده می کند نشان می دهد که خروجی به سمت چپ توجیه شده است:

>>> '{0:<8s}'.format('foo')
'foo     '
>>> '{0:<8d}'.format(123)
'123     '

این رفتار پیش فرض برای مقادیر رشته است.

مقداری که از علامت بزرگتر از (>) استفاده می کند نشان می دهد که خروجی باید به سمت راست توجیه شود:

>>> '{0:>8s}'.format('foo')
'     foo'
>>> '{0:>8d}'.format(123)
'     123'

این رفتار پیش فرض برای مقادیر عددی است.

مقداری که از نشانگر (^) استفاده می کند نشان می دهد که خروجی باید در فیلد خروجی متمرکز شود:

>>> '{0:^8s}'.format('foo')
'  foo   '
>>> '{0:^8d}'.format(123)
'  123   '

در نهایت، می توانید با استفاده از علامت equals (=) برای زیرمؤلفه <align> مقداری را مشخص کنید. این فقط برای مقادیر عددی معنی دارد و فقط زمانی که علامتی در خروجی گنجانده شده باشد.

هنگامی که خروجی عددی شامل یک علامت است، معمولا همانطور که در بالا نشان داده شده است، مستقیما در سمت چپ رقم اول عدد قرار می گیرد. اگر <align> روی علامت برابر (=) تنظیم شود، علامت در لبه سمت چپ فیلد خروجی ظاهر می شود و بالشتک بین علامت و عدد قرار می گیرد:

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

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

در بخش بعدی کامپوننت <sign> را با جزئیات پوشش خواهید داد.

<fill> مشخص می کند که چگونه فضای اضافی را پر کنید زمانی که مقدار قالب بندی شده به طور کامل عرض خروجی را پر نمی کند. این می تواند هر شخصیتی به جز پرانتز های مجعد ({}) باشد. (اگر واقعا احساس می کنید مجبور هستید یک مزرعه را با بریس های مجعد بپوشانید، فقط باید راه دیگری پیدا کنید!)

چند نمونه از استفاده از <fill> در زیر نشان داده شده است:

>>> '{0:->8s}'.format('foo')
'-----foo'

>>> '{0:#<8d}'.format(123)
'123#####'

>>> '{0:*^8s}'.format('foo')
'**foo***'

اگر مقداری را برای <fill> مشخص کنید، باید مقداری برای <align> نیز اضافه کنید.

کامپوننت فرعی <sign>

می توانید کنترل کنید که آیا یک علامت در خروجی عددی با مؤلفه <sign> ظاهر می شود یا خیر. به عنوان مثال، در زیر علامت مثبت (+) مشخص شده در <format_spec> نشان می دهد که مقدار باید همیشه با علامت پیشرو نمایش داده شود:

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

در اینجا، شما از علامت مثبت (+) استفاده می کنید، بنابراین همیشه یک علامت برای مقادیر مثبت و منفی گنجانده می شود. اگر از علامت منفی (-) استفاده کنید، فقط مقادیر عددی منفی شامل یک علامت پیشرو می شوند و مقادیر مثبت شامل علامت پیشرو نمی شوند:

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

هنگامی که از یک فاصله واحد (' ') استفاده می کنید، به این معنی است که یک علامت برای مقادیر منفی و یک کاراکتر فضای ASCII برای مقادیر مثبت گنجانده شده است:

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

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

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

از آنجایی که کاراکتر فاصله کاراکتر fill پیش فرض است، تنها در صورتی متوجه تأثیر آن خواهید شد که یک کاراکتر جایگزین <fill> مشخص شده باشد.

در نهایت، از بالا به یاد بیاورید که وقتی علامت برابر (=) را برای <align> مشخص می کنید و یک مشخص کننده <نشانه> را اضافه می کنید، بالشتک بین علامت و مقدار می رود، نه در سمت چپ نشانه.

کامپوننت فرعی #

هنگامی که یک کاراکتر هش (#) را در <format_spec> مشخص می کنید، پایتون یک فرم خروجی جایگزین را برای انواع خاصی از ارائه انتخاب می کند. این مشابه پرچم تبدیل # برای عملگر مدول رشته است. برای انواع ارائه باینری، اکتال و هگزادسیمال، کاراکتر هش (#) باعث گنجاندن یک نشانگر پایه صریح در سمت چپ مقدار می شود:

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

همانطور که می بینید، نشانگر پایه می تواند 0b، 0o یا 0x باشد.

برای انواع ارائه ممیز شناور یا نمایی ، کاراکتر هش خروجی را مجبور می کند که حاوی یک نقطه اعشار باشد ، حتی اگر خروجی از یک عدد کامل تشکیل شده باشد:

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

برای هر نوع ارائه ای غیر از موارد نشان داده شده در بالا، کاراکتر هش (#) هیچ تاثیری ندارد.

جزء فرعی 0

اگر خروجی کوچکتر از عرض فیلد مشخص شده باشد و رقم صفر (0) را در <format_spec> مشخص کنید، مقادیر به جای کاراکترهای فضای ASCII در سمت چپ با صفر پوشانده می شوند:

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

همانطور که در بالا نشان داده شده است، معمولا از این برای مقادیر عددی استفاده می کنید. با این حال، برای مقادیر رشته نیز کار می کند:

>>> '{0:>06s}'.format('foo')
'000foo'

اگر هر دو <fill> و <align> را مشخص کنید، <fill> 0 را لغو می کند:

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

<fill> و 0 اساسا یک چیز را کنترل می کنند، بنابراین واقعا نیازی به مشخص کردن هر دو نیست. در واقع، 0 واقعا اضافی است و احتمالا به عنوان یک راحتی برای توسعه دهندگانی که با پرچم تبدیل 0 مشابه اپراتور مدول رشته آشنا هستند، گنجانده شده است.

کامپوننت فرعی <width>

<width> حداقل عرض فیلد خروجی را مشخص می کند:

>>> '{0:8s}'.format('foo')
'foo     '
>>> '{0:8d}'.format(123)
'     123'

توجه داشته باشید که این حداقل عرض فیلد است. فرض کنید مقداری را مشخص می کنید که طولانی تر از حداقل باشد:

>>> '{0:2s}'.format('foobar')
'foobar'

در این مورد، <width> به طور موثر نادیده گرفته می شود.

زیرمؤلفه <group>

<group> به شما امکان می دهد یک کاراکتر جداکننده گروه بندی را در خروجی عددی قرار دهید. برای انواع ارائه اعشاری و ممیز شناور، <group> ممکن است به عنوان یک کاراکتر کاما (،) یا یک کاراکتر زیرخط (_) مشخص شود. سپس آن کاراکتر هر گروه سه رقمی را در خروجی جدا می کند:

>>> '{0:,d}'.format(1234567)
'1,234,567'
>>> '{0:_d}'.format(1234567)
'1_234_567'

>>> '{0:,.2f}'.format(1234567.89)
'1,234,567.89'
>>> '{0:_.2f}'.format(1234567.89)
'1_234_567.89'

یک مقدار <گروه> با استفاده از زیرخط (_) نیز ممکن است با انواع ارائه باینری، اکتال و هگزادسیمال مشخص شود. در این حالت، هر گروه چهار رقمی با یک کاراکتر زیرخط در خروجی از هم جدا می شود:

>>> '{0:_b}'.format(0b111010100001)
'1110_1010_0001'
>>> '{0:#_b}'.format(0b111010100001)
'0b1110_1010_0001'

>>> '{0:_x}'.format(0xae123fcc8ab2)
'ae12_3fcc_8ab2'
>>> '{0:#_x}'.format(0xae123fcc8ab2)
'0xae12_3fcc_8ab2'

اگر سعی کنید <group> را با هر نوع ارائه ای غیر از موارد ذکر شده در بالا مشخص کنید، کد شما یک استثنا ایجاد می کند.

زیرمؤلفه .<prec>

.<prec> تعداد ارقام بعد از نقطه اعشار را برای انواع ارائه ممیز شناور مشخص می کند:

>>> '{0:8.2f}'.format(1234.5678)
' 1234.57'
>>> '{0:8.4f}'.format(1.23)
'  1.2300'

>>> '{0:8.2e}'.format(1234.5678)
'1.23e+03'
>>> '{0:8.4e}'.format(1.23)
'1.2300e+00'

برای انواع رشته ها، .<prec> حداکثر عرض خروجی تبدیل شده را مشخص می کند:

>>> '{:.4s}'.format('foobar')
'foob'

اگر خروجی طولانی تر از مقدار مشخص شده باشد، کوتاه می شود.

متد ()format.format: فیلدهای جایگزینی تو در تو

به یاد بیاورید که می توانید <عرض> یا <prec> را با یک ستاره با عملگر مدول رشته مشخص کنید:

>>> w = 10
>>> p = 2
>>> '%*.*f' % (w, p, 123.456)  # Width is 10, precision is 2
'    123.46'

سپس مقادیر مرتبط از لیست آرگومان گرفته می شوند. این اجازه می دهد تا <width> و <prec> به صورت پویا در زمان اجرا ارزیابی شوند، همانطور که در مثال بالا نشان داده شده است. متد .format() پایتون قابلیت مشابهی را با استفاده از فیلدهای جایگزینی تو در تو فراهم می کند.

در داخل یک فیلد جایگزین، می توانید مجموعه ای از پرانتز های فرفری ({}) را مشخص کنید که حاوی نام یا عددی است که به یکی از آرگومان های موقعیتی یا کلمه کلیدی متد اشاره دارد. سپس آن بخش از فیلد جایگزینی در زمان اجرا ارزیابی می شود و با استفاده از آرگومان مربوطه جایگزین می شود. شما می توانید همان اثر را به عنوان مثال عملگر مدول رشته بالا با فیلدهای جایگزینی تو در تو انجام دهید:

>>> w = 10
>>> p = 2
>>> '{2:{0}.{1}f}'.format(w, p, 123.456)
'    123.46'

در اینجا، مؤلفه <نام> فیلد جایگزینی 2 است که سومین پارامتر موقعیتی را نشان می دهد که مقدار آن 123.456 است. این مقداری است که باید قالب بندی شود. فیلدهای جایگزینی تودرتو {0} و {1} با پارامترهای موقعیتی اول و دوم، w و p مطابقت دارند. اینها مکان های <عرض> و <prec> را در <format_spec> اشغال می کنند و اجازه می دهند عرض و دقت میدان در زمان اجرا ارزیابی شود.

می توانید از آرگومان های کلمات کلیدی با فیلدهای جایگزینی تو در تو نیز استفاده کنید. این مثال از نظر عملکردی معادل مثال قبلی است:

>>> w = 10
>>> p = 2
>>> '{val:{wid}.{pr}f}'.format(wid=w, pr=p, val=123.456)
'    123.46'

در هر صورت، مقادیر w و p در زمان اجرا ارزیابی می شوند و برای اصلاح <format_spec> استفاده می شوند. نتیجه به طور موثر مشابه این است:

>>> '{0:10.2f}'.format(123.456)
'    123.46'

عملگر مدول رشته فقط اجازه می دهد <عرض> و <prec> در زمان اجرا به این روش ارزیابی شود. در مقابل، با متد .format() پایتون می توانید هر بخشی از <format_spec> را با استفاده از فیلدهای جایگزین تو در تو مشخص کنید.

در مثال زیر، نوع ارائه <نوع> توسط یک فیلد جایگزینی تو در تو مشخص شده و به صورت پویا تعیین می شود:

>>> bin(10), oct(10), hex(10)
('0b1010', '0o12', '0xa')
>>> for t in ('b', 'o', 'x'):
...     print('{0:#{type}}'.format(10, type=t))
...
0b1010
0o12
0xa

در اینجا، کاراکتر گروه بندی <group> تودرتو است:

>>> '{0:{grp}d}'.format(123456789, grp='_')
'123_456_789'
>>> '{0:{grp}d}'.format(123456789, grp=',')
'123,456,789'

وای! این یک ماجراجویی بود. مشخصات رشته الگو عملا به خودی خود یک زبان است!

همانطور که می بینید، قالب بندی رشته را می توان با استفاده از متد .format() پایتون بسیار دقیق تنظیم کرد. در مرحله بعد، یک تکنیک دیگر برای قالب بندی رشته و خروجی خواهید دید که تمام مزایای format().را ارائه می دهد، اما با نحو مستقیم تر.

رشته فرمت شده پایتون لیترال (f-String)

در نسخه 3.6، یک نحو قالب بندی رشته جدید پایتون معرفی شد که رشته قالب بندی شده تحت اللفظی نامیده می شود. اینها همچنین به طور غیررسمی f-strings نامیده می شوند، اصطلاحی که در ابتدا در PEP 498 ابداع شد، جایی که برای اولین بار پیشنهاد شدند.

نحو رشته f

یک رشته f بسیار شبیه یک رشته معمولی پایتون است با این تفاوت که با کاراکتر f پیش بینی می شود:

>>> f'foo bar baz'
'foo bar baz'

همچنین می توانید از حرف بزرگ F استفاده کنید:

>>> s = F'qux quux'
>>> s
'qux quux'

اثر دقیقا یکسان است. درست مانند هر نوع رشته دیگری، می توانید از نقل قول های تکی، دوتایی یا سه گانه برای تعریف رشته f استفاده کنید:

>>> f'foo'
'foo'
>>> f"bar"
'bar'
>>> f'''baz'''
'baz'

جادوی f-strings این است که می توانید عبارات پایتون را مستقیما در داخل آنها جاسازی کنید. هر بخشی از رشته f که در پرانتز های مجعد ({}) محصور شده است، به عنوان یک عبارت در نظر گرفته می شود. عبارت ارزیابی می شود و به نمایش رشته تبدیل می شود و نتیجه در رشته اصلی در آن مکان درون یابی می شود:

>>> s = 'bar'
>>> print(f'foo.{s}.baz')
foo.bar.baz

مترجم با باقیمانده رشته f - هر چیزی که داخل بریس های مجعد نباشد - درست مانند یک رشته معمولی رفتار می کند. به عنوان مثال، دنباله های فرار همانطور که انتظار می رود پردازش می شوند:

>>> s = 'bar'
>>> print(f'foo\n{s}\nbaz')
foo
bar
baz

در اینجا مثالی از قبل با استفاده از f-string آورده شده است:

>>> quantity = 6
>>> item = 'bananas'
>>> price = 1.74
>>> print(f'{quantity} {item} cost ${price}')
6 bananas cost $1.74

این معادل موارد زیر است:

>>> quantity = 6
>>> item = 'bananas'
>>> price = 1.74
>>> print('{0} {1} cost ${2}'.format(quantity, item, price))
6 bananas cost $1.74

عبارات تعبیه شده در رشته های f می توانند تقریبا به طور دلخواه پیچیده باشند. مثال های زیر برخی از احتمالات را نشان می دهد:

• متغیرهای:

  >>> quantity, item, price = 6, 'bananas', 1.74
  '6 bananas cost $1.74'
  

• عبارات حسابی:

  >>> quantity, item, price = 6, 'bananas', 1.74
  Price per item is $0.29
  
  >>> x = 6
  6 cubed is 216
  

• اشیاء از انواع کامپوزیت:

  >>> a = ['foo', 'bar', 'baz']
  >>> d = {'foo': 1, 'bar': 2}
  
  a = ['foo', 'bar', 'baz'] | d = {'foo': 1, 'bar': 2}
  

• نمایه سازی، برش دادن و مراجع کلیدی:

  >>> a = ['foo', 'bar', 'baz']
  >>> d = {'foo': 1, 'bar': 2}
  
  First item in list a = foo
  
  Last two items in list a = ['bar', 'baz']
  
  List a reversed = ['baz', 'bar', 'foo']
  
  Dict value for key 'bar' is 2
  

• فراخوانی های تابع و متد:

  >>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
  List a has 5 items
  
  >>> s = 'foobar'
  '--- FOOBAR ---'
  
  >>> d = {'foo': 1, 'bar': 2}
  Dict value for key 'bar' is 2
  

• عبارات شرطی:

  >>> x = 3
  >>> y = 7
  The larger of 3 and 7 is 7
  
  >>> age = 13
  'I am a minor.'
  

• ویژگی های شی:

  >>> z = 3+5j
  >>> z
  (3+5j)
  
  real = 3.0, imag = 5.0
  

برای قرار دادن یک مهاربند فرفری تحت اللفظی در یک رشته f، با دو برابر کردن آن از آن فرار کنید، همانطور که در یک رشته الگو برای متد .format() پایتون انجام می دهید:

>>> z = 'foobar'
>>> f'{{ {z[::-1]} }}'
'{ raboof }'

می توانید یک رشته f را با 'r' یا 'R' پیشوند کنید تا نشان دهد که یک f-string خام است. در این صورت، دنباله های بک اسلش دست نخورده باقی می مانند، درست مانند یک رشته معمولی:

>>> z = 'bar'
>>> print(f'foo\n{z}\nbaz')
foo
bar
baz
>>> print(rf'foo\n{z}\nbaz')
foo\nbar\nbaz
>>> print(fr'foo\n{z}\nbaz')
foo\nbar\nbaz

توجه داشته باشید که می توانید ابتدا 'r' و سپس 'f' یا بالعکس را مشخص کنید.

محدودیت های عبارت رشته f

چند محدودیت جزئی برای بیان f-string وجود دارد. اینها خیلی محدود کننده نیستند، اما باید بدانید که چه هستند. اول، یک عبارت f-string نمی تواند خالی باشد:

>>> f'foo{}bar'
  File "<stdin>", line 1
SyntaxError: f-string: empty expression not allowed

مشخص نیست که چرا می خواهید این کار را انجام دهید. اما اگر احساس می کنید مجبور به تلاش هستید، فقط بدانید که کار نخواهد کرد.

علاوه بر این، یک عبارت f-string نمی تواند حاوی یک کاراکتر اسلش معکوس (\) باشد. در میان چیزهای دیگر، این بدان معناست که شما نمی توانید از دنباله فرار اسلش معکوس در عبارت f-string استفاده کنید:

>>> print(f'foo{\n}bar')
  File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash
>>> print(f'foo{\'}bar')
  File "<stdin>", line 1
SyntaxError: f-string expression part cannot include a backslash

شما می توانید با ایجاد یک متغیر موقت که شامل دنباله فرار مورد نظر برای درج است، این محدودیت را دور بزنید:

>>> nl = '\n'
>>> print(f'foo{nl}bar')
foo
bar
>>> quote = '\''
>>> print(f'foo{quote}bar')
foo'bar

در نهایت، عبارتی در یک رشته f که دارای نقل قول سه گانه است نمی تواند حاوی نظرات باشد:

>>> z = 'bar'

>>> print(f'''foo{
... z
... }baz''')
foobarbaz

>>> print(f'''foo{
... z    # Comment
... }''')
  File "<stdin>", line 3
SyntaxError: f-string expression part cannot include '#'

با این حال، توجه داشته باشید که رشته f چند خطی ممکن است حاوی خطوط جدید تعبیه شده باشد.

قالب بندی رشته f

مانند متد .format() پایتون، f-strings از اصلاح کننده های گسترده ای پشتیبانی می کنند که ظاهر نهایی رشته خروجی را کنترل می کنند. خبرهای خوب بیشتری نیز وجود دارد. اگر به متد Python .format() تسلط دارید، از قبل می دانید که چگونه از پایتون برای فرمت f-strings استفاده کنید!

عبارات در رشته های f را می توان با یک <تبدیل> یا <format_spec> تغییر داد، درست مانند فیلدهای جایگزینی که در قالب .format() استفاده می شود. نحو یکسان است. در واقع، در هر دو مورد، پایتون فیلد جایگزینی را با استفاده از عملکرد داخلی یکسان قالب بندی می کند. در مثال زیر، !r به عنوان یک مؤلفه <conversion> در رشته قالب .format() مشخص شده است:

>>> s = 'foo'
>>> '{0!r}'.format(s)
"'foo'"

این تبدیل را مجبور می کند که توسط repr() انجام شود. به جای آن می توانید اساسا همان کد را با استفاده از f-string دریافت کنید:

>>> s = 'foo'
>>> f'{s!r}'
"'foo'"

تمام کامپوننت های <format_spec> که با .format() کار می کنند با f-strings نیز کار می کنند:

>>> n = 123
>>> '{:=+8}'.format(n)
'+    123'
>>> f'{n:=+8}'
'+    123'

>>> s = 'foo'
>>> '{0:*^8}'.format(s)
'**foo***'
>>> f'{s:*^8}'
'**foo***'

>>> n = 0b111010100001
>>> '{0:#_b}'.format(n)
'0b1110_1010_0001'
>>> f'{n:#_b}'
'0b1110_1010_0001'

تودرتو نیز مانند فیلدهای جایگزینی تو در تو با متد .format() پایتون کار می کند:

>>> a = ['foo', 'bar', 'baz', 'qux', 'quux']
>>> w = 4
>>> f'{len(a):0{w}d}'
'0005'

>>> n = 123456789
>>> sep = '_'
>>> f'{(n * n):{sep}d}'
'15_241_578_750_190_521'

این بدان معناست که قالب بندی موارد را می توان در زمان اجرا ارزیابی کرد.

f-strings و متد .format() پایتون، کم و بیش، دو روش متفاوت برای انجام یک کار هستند، که f-strings یک خلاصه نویسی مختصر تر است. عبارات زیر اساسا یکسان هستند:

f'{<expr>!<conversion>:<format_spec>}'

'{0!<conversion>:<format_spec>}'.format(<expr>)

اگر می خواهید f-strings را بیشتر بررسی کنید، f-Strings پایتون 3: سینتکس قالب بندی رشته بهبود یافته (دوره) را بررسی کنید.

نتیجه

در این آموزش، شما به دو تکنیک اضافی تسلط دارید که می توانید در پایتون برای قالب بندی داده های رشته ای استفاده کنید. اکنون باید تمام ابزارهایی را که برای آماده سازی داده های رشته ای برای خروجی یا نمایش نیاز دارید، داشته باشید!

ممکن است از خود بپرسید که از کدام تکنیک قالب بندی پایتون باید استفاده کنید. تحت چه شرایطی .format() را به جای f-string انتخاب می کنید؟ برای برخی ملاحظات به بهترین شیوه های قالب بندی رشته پایتون مراجعه کنید.

در آموزش بعدی، می خواهید در مورد توابع در پایتون بیشتر بیاموزید. در طول این مجموعه آموزشی، نمونه های زیادی از توابع داخلی پایتون را دیده اید. در پایتون، مانند اکثر زبان های برنامه نویسی، می توانید توابع سفارشی تعریف شده توسط کاربر را نیز تعریف کنید. اگر نمی توانید صبر کنید تا یاد بگیرید چگونه، به آموزش بعدی ادامه دهید!