آشنایی غیررسمی با پایتون

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

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

چند مثال:

>>> # 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."

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

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

۳.۱.۱. اعداد

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

>>> 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. در ادامهٔ آموزش بیشتر دربارهٔ انواع عددی خواهیم دید.

تقسیم (/) همیشه یک 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).

۳.۱.۲. متن

پایتون می‌تواند متن (نمایش‌داده‌شده با نوع str، به‌اصطلاح «رشته‌ها») را مانند اعداد دستکاری کند. این شامل نویسه‌هایی مانند "!"، کلماتی مانند "rabbit"، نام‌هایی مانند "Paris"، جملاتی مانند "Got your back." و غیره می‌شود. آن‌ها را می‌توان درون نقل‌قول‌های تکی ('...') یا نقل‌قول‌های دوتایی ("...") با نتیجهٔ یکسان قرار داد [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'

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

>>> '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() با حذف نقل‌قول‌های محصورکننده و با چاپ نویسه‌های فرار و ویژه، خروجی خواناتری تولید می‌کند:

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

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

>>> print('C:\this\name')  # here \t means tab, \n means newline
C:      his
ame
>>> print(r'C:\this\name')  # note the r before the quote
C:\this\name

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

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

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

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

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

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

ردیف اول اعداد موقعیت اندیس‌های ۰ تا ۶ را در رشته نشان می‌دهد؛ ردیف دوم اندیس‌های منفی متناظر را. برش از i تا j شامل همهٔ نویسه‌های بین لبه‌های برچسب‌خورده با i و j است.

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

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

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

۳.۱.۳. لیست‌ها

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

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

۳.۲. گام‌های نخست به سوی برنامه‌نویسی

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

>>> # 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، هر مقدار صحیح غیرصفر درست است؛ صفر نادرست است. شرط می‌تواند یک رشته یا لیست، در واقع هر دنباله‌ای نیز باشد؛ هر چیزی با طول غیرصفر درست است، دنباله‌های خالی نادرست هستند. آزمون استفاده‌شده در مثال یک مقایسهٔ ساده است. عملگرهای مقایسهٔ استاندارد مانند C نوشته می‌شوند: < (کمتر از)، > (بیشتر از)، == (مساوی)، <= (کمتر یا مساوی)، >= (بیشتر یا مساوی) و != (نامساوی).
• بدنهٔ حلقه تورفتگی دارد: تورفتگی روش پایتون برای گروه‌بندی دستورها است. در اعلان تعاملی، باید برای هر خط تورفته یک tab یا فاصله(ها) تایپ کنید. در عمل، ورودی‌های پیچیده‌تر را برای پایتون با یک ویرایشگر متن آماده خواهید کرد؛ همهٔ ویرایشگرهای متن مناسب دارای تسهیلات تورفتگی خودکار هستند. وقتی یک دستور مرکب به‌صورت تعاملی وارد می‌شود، باید با یک خط خالی دنبال شود تا اتمام آن مشخص گردد (چون تجزیه‌گر نمی‌تواند حدس بزند که آخرین خط را چه زمانی تایپ کرده‌اید). توجه کنید که هر خط درون یک بلوک پایه باید به همان میزان تورفته باشد.
• تابع 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,