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

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

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

اعداد

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

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

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

>>> 5 ** 2  # 5 به توان ۲
25
>>> 2 ** 7  # 2 به توان ۷
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 نیز پشتیبانی می‌کند. پایتون همچنین پشتیبانی داخلی از اعداد مختلط (complex numbers) دارد و از پسوند j یا J برای نشان دادن بخش فرضی استفاده می‌کند (مثلاً 3+5j).

متن

پایتون می‌تواند با متن (با نوع str که به اصطلاح "رشته‌ها" یا strings نامیده می‌شود) مانند اعداد کار کند. این شامل کاراکترها، کلمات، اسامی، جملات و غیره است. رشته‌ها را می‌توان با علامت نقل قول تکی ('...') یا دوتایی ("...") محصور کرد که نتیجه یکسانی دارند [۲]:

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

>>> s = 'First line.\\nSecond line.'  # \\n یعنی خط جدید
>>> s
'First line.\\nSecond line.'
>>> print(s)
First line.
Second line.

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

>>> print('C:\\this\\name')
C:      his
ame
>>> print(r'C:\\this\\name')
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 * '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'
'Python'

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

>>> word = 'Python'
>>> word[0]
'P'
>>> word[5]
'n'

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

>>> word[-1]
'n'
>>> word[-2]
'o'
>>> word[-6]
'P'

توجه کنید که از آنجا که -0 برابر ۰ است، اندیس‌های منفی از -۱ شروع می‌شوند.

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

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

یک راه برای به یاد آوردن نحو عملکرد برش‌ها این است که اندیس‌ها را به عنوان اشاره‌کننده بین کاراکترها در نظر بگیرید:

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

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

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

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

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

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

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

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

همچنین ببینید:

• Text Sequence Type -- str: رشته‌ها نمونه‌هایی از انواع توالی هستند و از عملیات مشترک این انواع پشتیبانی می‌کنند.
• String Methods: رشته‌ها از تعداد زیادی متد برای تبدیلات پایه و جستجو پشتیبانی می‌کنند.
• f-strings: لیترال‌های رشته‌ای با عبارات تعبیه شده.
• Format string syntax: اطلاعات درباره قالب‌بندی رشته با str.format().
• printf-style String Formatting: عملیات قالب‌بندی قدیمی هنگامی که رشته‌ها عملوند سمت چپ عملگر % هستند.

لیست‌ها

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

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

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

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

برخلاف رشته‌ها که تغییرناپذیر هستند، لیست‌ها نوع تغییرپذیر (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"]

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

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