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

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'