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

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

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

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

چند مثال:

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

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

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

3.1.1. اعداد

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

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5  # division always returns a floating-point number
1.6

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

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

>>> 17 / 3  # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3  # floor division discards the fractional part
5
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # floored quotient * divisor + remainder
17

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

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

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

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

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

>>> n  # try to access an undefined variable
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'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

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

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"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  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \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

>>>

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

>>># 3 times 'un', followed by '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'  # can't concatenate a variable and a string literal
  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]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

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

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

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

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

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

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

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'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]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

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

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

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

>>> 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

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

اف‌استرینگ‌ها

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

سینتکس رشته قالب

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

printf-style String Formatting

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

3.1.3. فهرست‌ها

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

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

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

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

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

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

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

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

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

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

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

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
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']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> 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. قدم‌های اول به سوی برنامه‌نویسی

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

>>> # Fibonacci series:
>>> # the sum of two elements defines the next
>>> 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,

پانویس‌ها