3. معرفی غیررسمی پایتون

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

می‌توانید از دکمهٔ "Copy" استفاده کنید (این دکمه هنگام قرار گرفتن نشانگر روی یک مثال کد یا لمس کردن آن، در گوشهٔ بالا-راست ظاهر می‌شود) که اعلان‌ها را حذف می‌کند و خروجی را کنار می‌گذارد، تا خط‌های ورودی را کپی کرده و در مفسر خود جای‌گذاری کنید.

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

چند مثال:

# این توضیح اول است
spam = 1  # و این توضیح دوم است
          # ... و حالا سومی!
text = "# این یکی توضیح نیست چرا که داخل گیومه است.."

3.1. استفاده از پایتون به‌عنوان ماشین‌حساب

بیایید چند دستور سادهٔ پایتون را امتحان کنیم. مفسر را اجرا کنید و منتظر اعلان اصلی، یعنی >>>، بمانید. (نباید زمان زیادی طول بکشد.)

3.1.1. اعداد

مفسر مانند یک ماشین‌حساب ساده عمل می‌کند: می‌توانید یک عبارت را در آن تایپ کنید و مقدار آن را نمایش خواهد داد. نحو عبارت‌ها ساده است: عملگرهای +، -، * و / را می‌توان برای انجام محاسبات استفاده کرد؛ پرانتزها (()) نیز برای گروه‌بندی استفاده می‌شوند. برای مثال:

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # تقسیم همیشه یک عدد ممیز شناور برمی‌گرداند
1.6

اعداد صحیح (برای مثال 2، 4، 20) دارای نوع int هستند و اعدادی که بخش اعشاری دارند (برای مثال 5.0، 1.6) دارای نوع float هستند. در ادامهٔ این آموزش دربارهٔ انواع عددی بیشتر خواهیم دید.

تقسیم (/) همیشه یک مقدار اعشاری برمی‌گرداند. برای انجام floor division و دریافت یک نتیجهٔ صحیح می‌توانید از عملگر // استفاده کنید؛ برای محاسبهٔ باقی‌مانده می‌توانید از % استفاده کنید:

>>> 17 / 3  # تقسیم معمولی یک عدد اعشاری برمی‌گرداند
5.666666666666667
>>>
>>> 17 // 3  # تقسیم صحیح، بخش اعشاری را حذف می‌کند
5
>>> 17 % 3  # عملگر % باقی‌ماندهٔ تقسیم را برمی‌گرداند
2
>>> 5 * 3 + 2  # خارج‌قسمتِ تقسیم صحیح × مقسوم‌علیه + باقی‌مانده
17

در پایتون، امکان استفاده از عملگر ** برای محاسبهٔ توان‌ها وجود دارد [1]:

>>> 5 ** 2  #۵ به توان ۲
25
>>> 2 ** 7  # ۲ به توان ۷
128

علامت مساوی (=) برای اختصاص دادن یک مقدار به یک متغیر استفاده می‌شود. پس از آن، پیش از اعلان تعاملی بعدی هیچ نتیجه‌ای نمایش داده نمی‌شود:

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

اگر یک متغیر «تعریف» نشده باشد (مقداری به آن اختصاص داده نشده باشد)، تلاش برای استفاده از آن باعث ایجاد خطا خواهد شد:

>>> n  # تلاش برای استفاده از یک متغیر که تعریف نشده است
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

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

>>> 4 * 3.75 - 1
14.0

در حالت تعاملی، آخرین عبارتی که چاپ شده است به متغیر _ اختصاص داده می‌شود. این یعنی هنگامی که از پایتون به‌عنوان یک ماشین‌حساب رومیزی استفاده می‌کنید، ادامه دادن محاسبات تا حدی آسان‌تر می‌شود، برای مثال:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

این متغیر باید توسط کاربر فقط برای خواندن در نظر گرفته شود. به‌صورت صریح مقداری به آن اختصاص ندهید --- با این کار یک متغیر محلی مستقل با همان نام ایجاد می‌کنید که متغیر داخلی را با رفتار ویژهٔ آن پنهان می‌کند.

علاوه بر int و float، پایتون از انواع دیگر اعداد نیز پشتیبانی می‌کند، مانند Decimal و Fraction. پایتون همچنین پشتیبانی داخلی از اعداد مختلط دارد و از پسوند j یا J برای مشخص کردن بخش موهومی استفاده می‌کند (برای مثال 3+5j).

3.1.2. متن

پایتون می‌تواند متن (که توسط نوع str نمایش داده می‌شود و به آن «رشته» گفته می‌شود) را نیز مانند اعداد پردازش کند. این شامل نویسه‌های "!"، واژه‌های "rabbit"، نام‌ها "Paris"، جمله‌های "Got your back."، و مواردی مانند "Yay! :)" است. این موارد را می‌توان درون نقل‌قول تکی ('...') یا نقل‌قول دوتایی ("...") قرار داد و نتیجه یکسان خواهد بود [2].

>>> 'spam eggs'  # علامت نقل‌قول تکی
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # علامت نقل‌قول دوتایی
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # رقم‌ها و عددهایی که داخل علامت نقل‌وقول قرار می‌گیرند نیز رشته هستند
'1975'

برای قرار دادن یک نقل‌قول درون یک نقل‌قول، باید آن را با قرار دادن \ پیش از آن، «escape» کنیم. همچنین می‌توانیم از نوع دیگر علامت‌های نقل‌قول استفاده کنیم:

>>> 'doesn\'t'  # برای خنثی کردن علامت نقل‌قول تکی، از \' استفاده کنید...
"doesn't"
>>> "doesn't"  # ...یا به‌جای آن از علامت نقل‌وقول دوتایی استفاده کنید
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

در پوستهٔ پایتون، تعریف رشته و رشتهٔ خروجی ممکن است متفاوت به نظر برسند. تابع print() خروجی خواناتری تولید می‌کند، زیرا نقل‌قول‌های احاطه‌کننده را حذف می‌کند و نویسه‌های escape‌شده و ویژه را چاپ می‌کند:

>>> s = 'First line.\nSecond line.'  # \n نشان‌دهندهٔ رفتن به خط بعد است
>>> s  # بدون print()، نویسه‌های ویژه در رشته نمایش داده می‌شوند
'First line.\nSecond line.'
>>> print(s)  # با print()، نویسه‌های ویژه تفسیر می‌شوند، بنابراین \n یک خط جدید ایجاد می‌کند
First line.
Second line.

اگر نمی‌خواهید نویسه‌هایی که با \ پیش از آن‌ها آمده است به‌عنوان نویسه‌های ویژه تفسیر شوند، می‌توانید با افزودن r پیش از اولین علامت نقل‌قول، از رشته‌های خام استفاده کنید:

>>> print('C:\this\name')  # در اینجا \t نشان‌دهندهٔ تب و \n نشان‌دهندهٔ خط جدید است
C:      his
ame
>>> print(r'C:\this\name')  # به حرف r قبل از علامت نقل‌وقول توجه کنید
C:\this\name

یک نکتهٔ ظریف دربارهٔ رشته‌های خام وجود دارد: یک رشتهٔ خام نمی‌تواند با تعداد فردی از نویسه‌های \ پایان یابد؛ برای اطلاعات بیشتر و راه‌حل‌های جایگزین، به ورودی پرسش‌های متداول مراجعه کنید.

رشته‌های متنی می‌توانند چندین خط را دربر بگیرند. یک روش استفاده از نقل‌قول‌های سه‌تایی است: """...""" یا '''...'''. نویسه‌های پایان خط به‌صورت خودکار در رشته قرار می‌گیرند، اما می‌توان با افزودن یک \ در انتهای خط از این کار جلوگیری کرد. در مثال زیر، خط جدید ابتدایی در رشته قرار نمی‌گیرد:

>>> print("""\
... Usage: thingy [OPTIONS]
...      -h                        Display this usage message
...      -H hostname               Hostname to connect to
... """)
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

>>>

رشته‌ها را می‌توان با عملگر + به یکدیگر متصل (چسباند) کرد و با * تکرار کرد:

>>># سه بار رشتهٔ «un»، به دنبال آن رشتهٔ «ium»
>>> 3 * 'un' + 'ium'
'unununium'

دو یا چند رشتهٔ متنی (یعنی مواردی که بین علامت‌های نقل‌قول قرار گرفته‌اند) که در کنار یکدیگر قرار دارند، به‌صورت خودکار به هم متصل می‌شوند.

>>> 'Py' 'thon'
'Python'

این قابلیت به‌ویژه زمانی مفید است که بخواهید رشته‌های طولانی را شکسته و در چند خط بنویسید:

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

البته این فقط برای دو رشتهٔ متنی ثابت کار می‌کند، نه برای متغیرها یا عبارت‌ها:

>>> prefix = 'Py'
>>> prefix 'thon'  # نمی‌توان یک متغیر و یک رشتهٔ متنی را به هم الحاق کرد
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

اگر می‌خواهید متغیرها یا یک متغیر و یک رشتهٔ متنی ثابت را به هم متصل کنید، از + استفاده کنید:

>>> prefix + 'thon'
'Python'

رشته‌ها را می‌توان اندیس‌‌گذاری (اندیس‌گذاری) کرد؛ به‌طوری که اولین نویسه دارای اندیس 0 است. نوع جداگانه‌ای برای نویسه وجود ندارد؛ یک نویسه در واقع فقط رشته‌ای با اندازهٔ یک است:

>>> word = 'Python'
>>> word[0]  # نویسه در موقعیت ۰
'P'
>>> word[5]  # نویسه در موقعیت ۵
'n'

اندیس‌‌ها همچنین می‌توانند اعداد منفی باشند تا شمارش از سمت راست آغاز شود:

>>> word[-1]  # نویسه آخر
'n'
>>> word[-2]  # نویسه یکی مانده به آخر
'o'
>>> word[-6]
'P'

توجه کنید که چون ‎-0 همان 0 است، اندیس‌‌های منفی از ‎-1 شروع می‌شوند.

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

>>> word[0:2]  # نویسه‌ها از موقعیت ۰ تا قبل از موقعیت ۲
'Py'
>>> word[2:5]  # نویسه‌ها از موقعیت ۲ تا قبل از موقعیت ۵
'tho'

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

>>> word[:2]   # نویسه‌ها از ابتدای رشته تا قبل از موقعیت ۲
'Py'
>>> word[4:]   # نویسه‌ها از موقعیت ۴ به بعد تا انتهای رشته
'on'
>>> word[-2:]  # نویسه‌ها از دومین نویسهٔ آخر به بعد تا انتهای رشته
'on'

توجه کنید که نقطهٔ شروع همیشه شامل می‌شود و نقطهٔ پایان همیشه حذف می‌شود. این موضوع تضمین می‌کند که s[:i] + s[i:] همیشه برابر با s باشد:

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

یک روش برای به خاطر سپردن نحوهٔ کار برش‌ها این است که تصور کنید اندیس‌‌ها به بین نویسه‌ها اشاره می‌کنند، به‌طوری که لبهٔ سمت چپ اولین نویسه شمارهٔ 0 دارد. سپس لبهٔ سمت راست آخرین نویسهٔ یک رشته با n نویسه، دارای اندیس n است؛ برای مثال:

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

ردیف اول اعداد، موقعیت اندیس‌‌های 0...6 در رشته را نشان می‌دهد؛ ردیف دوم اندیس‌‌های منفی متناظر را نشان می‌دهد. برش از i تا j شامل تمام نویسه‌هایی است که بین لبه‌های مشخص‌شده با i و j قرار دارند.

برای اندیس‌‌های غیرمنفی، طول یک برش برابر با تفاوت بین اندیس‌‌ها است، به شرطی که هر دو در محدوده باشند. برای مثال، طول word[1:3] برابر با 2 است.

تلاش برای استفاده از اندیسی که بیش از حد بزرگ است، باعث ایجاد خطا خواهد شد:

>>> word[42]  # این کلمه فقط ۶ نویسه دارد
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

بااین‌حال، اندیس‌‌های برش خارج از محدوده هنگام استفاده برای برش‌دهی به‌صورت مناسبی مدیریت می‌شوند:

>>> word[4:42]
'on'
>>> word[42:]
''

رشته‌های پایتون قابل تغییر نیستند --- آن‌ها immutable هستند. بنابراین، اختصاص دادن مقدار به یک موقعیت اندیس‌‌گذاری‌شده در رشته باعث ایجاد خطا می‌شود:

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

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

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

تابع داخلی len() طول یک رشته را برمی‌گرداند:

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

همچنین ملاحظه نمائید

Text Sequence Type --- str

رشته‌ها نمونه‌هایی از انواع دنباله‌ای (sequence types) هستند و از عملیات مشترکی که این نوع‌ها پشتیبانی می‌کنند، پشتیبانی می‌کنند.

String Methods

رشته‌ها تعداد زیادی متد برای تبدیل‌های پایه و جست‌وجو ارائه می‌دهند.

f-strings

رشته‌های متنی ثابتی که شامل عبارت‌های جاسازی‌شده هستند.

Format string syntax

اطلاعات دربارهٔ قالب‌بندی رشته‌ها با str.format().

printf-style String Formatting

عملیات قالب‌بندی قدیمی که زمانی فراخوانی می‌شوند که رشته‌ها عملوند سمت چپ عملگر % باشند، در اینجا با جزئیات بیشتری توضیح داده شده‌اند.

3.1.3. فهرست‌ها

پایتون تعدادی نوع دادهٔ مرکب دارد که برای گروه‌بندی مقدارهای دیگر استفاده می‌شوند. انعطاف‌پذیرترین آن‌ها فهرست (list) است که می‌توان آن را به‌صورت فهرستی از مقدارهای جداشده با ویرگول (آیتم‌ها) در میان کروشه‌ها نوشت. فهرست‌ها ممکن است شامل آیتم‌هایی از نوع‌های مختلف باشند، اما معمولاً همهٔ آیتم‌ها یک نوع یکسان دارند.

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

مانند رشته‌ها (و تمام نوع‌های داخلی دیگر sequence)، فهرست‌ها را می‌توان اندیس‌‌گذاری و برش داد:

>>> squares[0]  # اندیس‌گذاری، عنصر را برمی‌گرداند
1
>>> squares[-1]
25
>>> squares[-3:]  # برش‌زدن، یک فهرست جدید برمی‌گرداند
[9, 16, 25]

فهرست‌ها همچنین از عملیاتی مانند الحاق پشتیبانی می‌کنند:

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

برخلاف رشته‌ها که immutable هستند، فهرست‌ها یک نوع mutable هستند؛ یعنی امکان تغییر محتوای آن‌ها وجود دارد:

>>> cubes = [1, 8, 27, 65, 125]  # یک چیزی اینجا اشتباه است
>>> 4 ** 3  # توان سومِ ۴ برابر ۶۴ است، نه ۶۵!
64
>>> cubes[3] = 64  # جایگزین کردن مقدار اشتباه
>>> cubes
[1, 8, 27, 64, 125]

همچنین می‌توانید با استفاده از متد list.append() آیتم‌های جدیدی را به انتهای فهرست اضافه کنید (در ادامه دربارهٔ متدها بیشتر خواهیم دید):

>>> cubes.append(216)  # توان سوم ۶ را اضافه کنید
>>> cubes.append(7 ** 3)  # و همچنین توان سوم ۷
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

انتساب ساده در پایتون هرگز داده‌ها را کپی نمی‌کند. هنگامی که یک فهرست را به یک متغیر اختصاص می‌دهید، متغیر به فهرست موجود اشاره می‌کند. هر تغییری که از طریق یک متغیر در فهرست ایجاد کنید، از طریق تمام متغیرهای دیگری که به آن اشاره می‌کنند نیز دیده خواهد شد.:

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # هر دو به یک شیء اشاره می‌کنند
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

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

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

انتساب به برش‌ها نیز امکان‌پذیر است و حتی می‌تواند اندازهٔ فهرست را تغییر دهد یا آن را به‌طور کامل خالی کند:

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # جایگزین کردن بعضی از مقادیر
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # حالا آن‌ها را حذف می‌کنیم
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # خالی کردن فهرست با جایگزین کردن همهٔ عناصر آن با یک فهرست خالی
>>> letters[:] = []
>>> letters
[]

تابع داخلی len() برای فهرست‌ها نیز کاربرد دارد:

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

امکان تو در تو کردن فهرست‌ها وجود دارد (ایجاد فهرست‌هایی که شامل فهرست‌های دیگر هستند)، برای مثال:

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. قدم‌های اول به سوی برنامه‌نویسی

البته، می‌توانیم از پایتون برای کارهای پیچیده‌تری از جمع کردن دو و دو استفاده کنیم. برای نمونه، می‌توانیم یک زیررشتهٔ ابتدایی از دنبالهٔ فیبوناچی را به شکل زیر بنویسیم:

>>> # سری فیبوناچی:
>>> # جمع دو عنصر، عنصر بعدی را تعیین میکند
>>> a, b = 0, 1
>>> while a < 10:
...     print(a)
...     a, b = b, a+b
...
0
1
1
2
3
5
8

این مثال چندین قابلیت جدید را معرفی می‌کند.

  • خط اول شامل یک انتساب چندگانه است: متغیرهای a و b به‌صورت هم‌زمان مقدارهای جدید 0 و 1 را دریافت می‌کنند. در خط آخر نیز دوباره از این ویژگی استفاده شده است و نشان می‌دهد که تمام عبارت‌های سمت راست ابتدا ارزیابی می‌شوند، پیش از آنکه هر یک از انتساب‌ها انجام شود. عبارت‌های سمت راست از چپ به راست ارزیابی می‌شوند.

  • حلقهٔ while تا زمانی اجرا می‌شود که شرط (در اینجا: a < 10) درست باقی بماند. در پایتون، مانند C، هر مقدار صحیح غیرصفر درست (true) است؛ صفر نادرست (false) است. شرط همچنین می‌تواند یک مقدار رشته‌ای یا فهرست باشد، در واقع هر دنباله‌ای؛ هر چیزی که طول غیرصفر داشته باشد درست است و دنباله‌های خالی نادرست هستند. آزمایشی که در مثال استفاده شده است یک مقایسهٔ ساده است. عملگرهای استاندارد مقایسه مانند C نوشته می‌شوند: < (کوچک‌تر از)، > (بزرگ‌تر از)، == (برابر با)، <= (کوچک‌تر یا برابر با)، >= (بزرگ‌تر یا برابر با) و != (نابرابر با).

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

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

    >>> i = 256*256
>>> print('The value of i is', i)
The value of i is 65536

    آرگومان کلیدواژه‌ای end می‌تواند برای جلوگیری از ایجاد خط جدید پس از خروجی، یا پایان دادن خروجی با یک رشتهٔ متفاوت استفاده شود:

    >>> a, b = 0, 1
>>> while a < 1000:
...     print(a, end=',')
...     a, b = b, a+b
...
0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

پانویس‌ها