درس ۰۶: سینتکس یا دستور نحو زبان پایتون¶

سطرها¶

مفسر پایتون و همچنین کاربر، کدهای درون هر ماژول را در قالب تعدادی سطر می‌بینند؛ سطرهای فیزیکی (Physical Lines) و منطقی (Logical Lines). سطرهای فیزیکی در واقع همان سطرهایی است که توسط ویرایشگرهای متن شماره‌گذاری می‌شوند و به راحتی توسط کاربر قابل تشخیص هستند ولی سطرهای منطقی برداشت مفسر از اجزای برنامه است؛ هر سطر منطقی بیانگر یک دستور (Statement) پایتون است. برای نمونه دستور print در نسخه 2x پایتون را در نظر بگیرید:

1
2

msg = "Welcome!"
print msg

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

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

1

msg = "Welcome!"; print msg

در این حالت می‌بایست سطرهای منطقی (یا همان دستور‌ها)، توسط کاراکتر ; (Semicolon) از یکدیگر جدا گردند.

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

1
2
3

msg = "Python Programming \
Language."  # This is a message.
print msg

در نمونه کد بالا: دو سطر فیزیکی نخست از دید مفسر به شکل تنها یک سطر منطقی دیده می‌شود. در پایتون برای شکستن یک دستور در چند سطر فیزیکی از کاراکتر \ (Backslash) استفاده می‌گردد. البته توجه داشته باشید که از \ نمی‌توان برای شکستن سطر توضیح (Comment) استفاده کرد و همچنین نمی‌توان پس از آن هیچ توضیحی درج کرد.

برای خوانایی بیشتر بهتر است دستور‌های طولانی شکسته شوند. دستورهایی که شامل { }، [ ] و ( ) هستند را می‌توان بدون استفاده از \ شکست و در قالب چند سطر فیزیکی نوشت:

1
2
3
4

month_names = ['Januari', 'Februari', 'Maart',      # These are the
               'April',   'Mei',      'Juni',       # Dutch names
               'Juli',    'Augustus', 'September',  # for the months
               'Oktober', 'November', 'December']   # of the year

که در این حالت برخلاف استفاده از \ می‌توان پس از شکستن سطرها، توضیح نیز اضافه کرد.

«سطرهای خالی» (Blank lines): سطری که تنها حاوی فضای خالی (Spaceها یا Tabها) باشد، توسط مفسر نادیده گرفته می‌شود و به بایت‌کد ترجمه نمی‌گردد. از این سطرها می‌توان برای خوانایی بیشتر کدها بهره گرفت - مانند سطر سوم در نمونه کد پایین:

1
2
3
4

def power(a, b):
    return a ** b

print power(2, 3)

مستند‌سازی¶

هر چند اساس طراحی زبان پایتون بر خوانایی بالای کد است ولی «مستندسازی» (Documentation) برنامه یعنی استفاده از امکاناتی همچون ارایه توضیح در کدها می‌تواند به درک و خوانایی هر چه بهتر کدهای برنامه برای مراجعات آینده برنامه‌نویس و افراد دیگری که می‌خواهند بر روی توسعه آن فعال باشند یا از آن استفاده کنند نیز بسیار مفید خواهد بود. در این بخش به بررسی دو امکان درج Comment و Docstring برای مستند‌سازی برنامه می‌پردازیم.

1
2
3
4
5
6
7
8
9

# A comment, this is so you can read your program later.
# Anything after the # is ignored by python.

print "I could have code like this."   # and the comment after is ignored

# You can also use a comment to "disable" or comment out a piece of code:
# print "This won't run."

print "This will run."

1
2
3
4
5
6
7

def complex(real=0.0, imag=0.0):
    """Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)
    """

>>> complex.__doc__
'Form a complex number.\n\n    Keyword arguments:\n    real -- the real part (default 0.0)\n    imag -- the imaginary part (default 0.0)\n    '

>>> print(complex.__doc__)
Form a complex number.

    Keyword arguments:
    real -- the real part (default 0.0)
    imag -- the imaginary part (default 0.0)

>>>

#!/usr/bin/env python
#-*- coding: utf-8 -*-

"""
Module docstring.
"""

import [...]
[...]

تورفتگی¶

بلاک‌بندی در زبان پایتون توسط «تورفتگی» (Indentation) سطرها مشخص می‌گردد؛ این عمل در زبان‌هایی مانند C توسط آکولاد { } انجام می‌شود. تورفتگی در واقع عبارت است از میزان فضای خالی (Spaceها و Tabها) هر دستور از ابتدای سطر فیزیکی خود. نکته مهم این است که تمام دستورهای موجود در یک بلاک می‌بایست به یک میزان فاصله نسبت به سرآیند خود تورفتگی داشته باشند:

1
2
3
4
5
6

// C

if (x > y) {
x = 1;
y = 2;
}

1
2
3
4
5

# Python

if x > y:
    x = 1
    y = 2

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

روش رایج ایجاد تورفتگی استفاده از کلید Space است و سعی کنید هرگز به صورت ترکیبی از کلیدهای Sapce و Tab استفاده نکنید هر چند که در نسخه 3x پایتون امکان استفاده ترکیبی از این دو کلید وجود ندارد! اگر مایل به استفاده از کلید Tab هستید باید به صورت یکدست تمام تورفتگی‌های برنامه خود را فقط با استفاده از آن ایجاد نمایید.

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

1
2
3
4

def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

در دستورهایی به مانند پایین نیز ایجاد تراز آرگومان‌ها هم حالت مناسبی است:

1
2

foo = long_function_name(var_one, var_two,
                         var_three, var_four)

دستور¶

«دستور» (Statement) واحدی از کد است که شامل کلمه‌های کلیدی بوده، اجرا می‌گردد و کاری را به انجام می‌رساند. در پایتون دو نوع دستور وجود دارد:

دستورهای ساده (Simple Statements): دستورهایی هستند که تنها در یک سطر منطقی پیاده‌سازی می‌شوند. مانند دستور import، دستور pass، دستور انتساب، فراخوانی تابع و...

دستورهای مرکب (Compound Statements): گروهی از دستورها هستند که می‌توانند یک بخشی (مانند: دستور def - تعریف تابع) یا چند بخشی (مانند: دستور شرط if / elif / else) باشند؛ هر بخش (Clause) نیز شامل یک سرآیند (Header) و یک بدنه (Suite) است. هر سرآیند با یک کلمه کلیدی آغاز می‌شود و با یک : (Colon) نیز پایان می‌پذیرد. بدنه پس از سرآیند و با رعایت سطح تورفتگی بیشتر نسبت به آن نوشته می‌شود:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

def binary_search(seq, key):
    lo = 0
    hi = len(seq) - 1
    while hi >= lo:
        mid = lo + (hi - lo) // 2
        if seq[mid] < key:
            lo = mid + 1
        elif seq[mid] > key:
            hi = mid - 1
        else:
            return mid
    return False

شناسه¶

«شناسه» (Identifier) نامی است نمادین که به دلخواه کاربر تعیین و از آن برای شناسایی (identify) متغیر‌ها، توابع، کلاس‌ها، ماژول‌ها یا دیگر اشیا پایتون از یکدیگر استفاده می‌شود. انتخاب شناسه در پایتون نکاتی دارد که می‌بایست از سوی کاربر در نظر گرفته شود:

• تنها با یکی از حروف بزرگ یا کوچک الفبا انگلیسی (A..Z یا a..z) یا کاراکتر _ (Underscore) شروع شود.
• در ادامه می‌تواند هیچ یا چند حرف الفبا انگلیسی (کوچک و بزرگ)، کاراکتر _ و عدد (9..0) - با هر ترتیبی - آورده شود.
• هیچ محدودیتی در طول شناسه وجود ندارد و می‌تواند از یک تا هر تعداد کاراکتر باشد.

با یک نگاه حرفه‌ای‌تر، ساختار لغوی (Lexical) شناسه به شکل پایین بیان می‌شود [اسناد پایتون]:

identifier  ::= (letter|"_") (letter | digit | "_")*

letter      ::= lowercase | uppercase
lowercase   ::= "a"..."z"
uppercase   ::= "A"..."Z"
digit       ::= "0"..."9"

برای نمونه - چند شناسه درست:

a    _p    __var    MyClass    get_length    getLength    var2    var_2    S01E16

برای نمونه - چند شناسه نادرست:

[email protected]    get.length    2_var    6    $var    4pi

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

• شناسه خصوصی (Private) ماژول: اگر شناسه‌ای با یک کاراکتر _ آغاز شود (و نه پایان پذیرد) توسط مفسر پایتون در این نقش ارزیابی می‌گردد. مانند: name_ (و نه: _name_ یا _name)
• شناسه خصوصی کلاس: اگر شناسه‌ای با دو کاراکتر _ آغاز شود (و نه پایان پذیرد) توسط مفسر پایتون در این نقش ارزیابی می‌گردد. مانند: name__ (و نه: __name__ یا __name)

جدا از این مورد، در پایتون صفت‌ها (Attributes) و متدهای خاصی وجود دارد که از پیش تعریف گشته‌اند و برای مفسر مفهوم مشخصی دارند. شناسه این صفت‌ها و متدها با دو کاراکتر _ آغاز می‌شود و همینطور پایان می‌پذیرد؛ درست به مانند صفت‌های __class__ و __doc__ که پیش از این استفاده کردیم.

بنابراین به هنگام استفاده از کاراکتر _ در شناسه (به خصوص در ابتدای آن) باید آگاهی کافی داشته باشیم. [به موارد اشاره شده در آینده پرداخته خواهد شد.]

برای شناسه‌های تک حرفی توجه داشته باشید که از انتخاب حروف l (اِل کوچک) و I (آی بزرگ) اجتناب کنید زیرا این دو حرف در برخی فونت‌ها شبیه هم هستند و البته همینطور حرف O (اُ بزرگ) که می‌تواند شبیه به صفر باشد.

>>> # Python 3.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not
class               from                or
continue            global              pass

>>> # Python 2.x

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

>>> # Python 3.x

>>> import keyword

>>> keyword.iskeyword(a)
False

>>> keyword.iskeyword("def")
True

>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

>>> # Python 3.x
>>> import keyword
>>> len(keyword.kwlist)
33

>>> # Python 2.x
>>> import keyword
>>> len(keyword.kwlist)
31

متغیر¶

یک «متغیر» (Variable) در بیشتر زبان‌های برنامه‌نویسی به مانند C بیانگر محلی در حافظه می‌باشد که مقداری در آن قرار گرفته است. برای نمونه سه دستور پایین را در نظر بگیرید:

int a = 1;

a = 2;

int b = a;

در نمونه کد بالا: دستور ;int a = 1 بیان می‌کند که محلی از حافظه به نام a برای نگهداری اعداد صحیح (integers) در نظر گرفته شود و مقدار 1 در آن قرار بگیرد؛ از این پس متغیر a معرف این نقطه از حافظه می‌باشد (درست به مانند یک جعبه) که اکنون حاوی مقدار 1 است (شکل پایین - یک). در ادامه دستور ;a = 2 موجب می‌شود مقدار پیشین متغیر a حذف (از جعبه خارج) و مقدار جدید یعنی 2 در آن قرار داده شود (شکل پایین - دو). توجه داشته باشید که در این دسته زبان‌ها، نوع (type) توسط متغیر تعیین می‌گردد و تلاش برای قرار دادن نوع داده دیگری به غیر از int در متغیر a (به مانند 3.7 یا "string") موجب بروز خطا در زمان کامپایل می‌گردد. دستور سوم:‌ ;int b = a در ابتدا موجب ایجاد یک محل جدید در حافظه با نام b و از نوع همان اعداد صحیح می‌شود و سپس مقدار درون متغیر a را درون آن کپی می‌کند؛ اکنون دو محل برای نگهداری نوع داده int در حافظه موجود است که هر دو حاوی مقدار 2 می‌باشند (شکل پایین - سه).

ولی در پایتون:

یک متغیر چیزی نیست جز یک نام که به یک شی مشخص در حافظه ارجاع (یا اشاره) دارد. تعریف متغیر در پایتون بسیار ساده است و تنها با انتساب (Assign) شی به یک نام ایجاد می‌گردد. نمادِ =، عملگر (Operator) انتساب در پایتون است. در تعریف متغیر پایتون برخلاف آنچه در زبان C مشاهده کردیم ;int a،‌ نیازی به تعیین نوع برای آن نیست چرا که نوع (type) از روی شی تعیین می‌گردد و یک متغیر در طول زمان اجرا می‌تواند به شی‌هایی از انواع متفاوت ارجاع داشته باشد. برای نمونه سه دستور پایین را در نظر بگیرید:

a = 1

a = 2

b = a

مفسر با رسیدن به دستور a = 1، سه گام پایین را انجام می‌دهد:

1. یک شی از نوع اعداد صحیح و مقدار 1 را در جایی از حافظه ایجاد می‌کند. چرا اعداد صحیح؟ نوع توسط شی تعیین می‌گردد و 1 عددی است صحیح!.
2. متغیرِ (یا همان نامِ) a را در جایی دیگر از حافظه ایجاد می‌کند (البته در صورتی که قبلا ایجاد نشده باشد).
3. یک پیوند از متغیر a به شی 1 برقرار می‌کند. به این پیوند «ارجاع» (Reference) گفته می‌شود که به صورت یک اشاره‌گر (Pointer) در حافظه پیاده‌سازی می‌گردد.

انتساب شی دیگری (که می‌تواند از هر نوع دیگری باشد) به یک متغیر موجود؛ موجب حذف ارجاع قبلی آن و ارجاع به شی جدید می‌شود. دستور a = 2 موجب ایجاد شی 2، حذف ارجاع متغیر a به شی 1 و ایجاد ارجاعی جدید از متغیر a به شی 2 می‌شود. هر متغیر نامی است برای اشاره به یک شی؛ دستور b = a نیز می‌گوید: یک متغیر جدید با نام b ایجاد گردد و به همان شی‌ای ارجاع داشته باشد که متغیر a ارجاع دارد.

ولی اکنون که ارجاعی به شی 1 وجود ندارد، با آن چه می‌شود؟

هر شی شامل یک «شمارنده ارجاع» (Reference Counter) نیز هست؛ به این صورت که در هر لحظه تعداد ارجاع‌ها به آن شی را نشان می‌دهد و با هر ارجاع جدید به شی، یک واحد به آن اضافه می‌شود و با حذف هر ارجاع نیز یک واحد کاهش می‌یابد. چنانچه مقدار آن به صفر برسد، شی آن توسط تکنیک ”Garbage Collection“ پاک می‌گردد و مقدار حافظه‌ای که توسط شی مصرف شده بود آزاد می‌گردد. برای مشاهده تعداد ارجاع‌ها به یک شی می‌توان از تابع ()getrefcount درون ماژول sys استفاده کرد [اسناد پایتون].

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

>>> import sys

>>> a = 1
>>> sys.getrefcount(1)
760

>>> a = 2
>>> sys.getrefcount(1)
759
>>> sys.getrefcount(2)
96

>>> b = a
>>> sys.getrefcount(2)
97

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

>>> a = b = c = "python"

>>> a
'python'
>>> b
'python'
>>> c
'python'

>>> a, b, c, d = 1, 4.5, "python", 2

>>> a
1
>>> b
4.5
>>> c
'python'
>>> d
2

>>> a = 1
>>> b = 2

>>> a, b = b, a

>>> a
2
>>> b
1

1

final int HOURS = 24;

1
2
3
4

# File: constant.py
# Path: /home/saeid/Documents/MyModule

HOURS = 24

>>> import sys
>>> sys.path.append('/home/saeid/Documents/MyModule')

>>> import constant
>>> constant.HOURS
24

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# File: constant.py
# Path: /home/saeid/Documents/MyModule

class _const:

    class ConstError(TypeError): pass

    def __setattr__(self, name, value):
        if name in self.__dict__:
            raise self.ConstError("Can't rebind const(%s)" % name)
        self.__dict__[name] = value

import sys
sys.modules[__name__] = _const()

>>> import sys
>>> sys.path.append('/home/saeid/Documents/MyModule')

>>> import constant
>>> constant.HOURS = 24
>>> constant.HOURS
24
>>> constant.HOURS = 23
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/home/saeid/Documents/MyModule/constant.py", line 10, in __setattr__
    raise self.ConstError("Can't rebind const(%s)" % name)
constant.ConstError: Can't rebind const(HOURS)
>>> constant.HOURS
24

عملگر‌ها¶

«عملگر» (Operator) به نمادی گفته می‌شود که عمل مشخصی را بر روی اشیا به انجام می‌رساند؛ به مانند عملگر انتساب = که پیش از این بررسی شد. همچنین به اشیایی که عملگر‌ بر روی آن‌ها عملی را به انجام می‌رساند «عملوند» (Operand) گفته می‌شود. عملگرها دارای انواع مختلفی هستند که در ادامه بررسی خواهیم کرد.

۱. عملگرهای حسابی (Arithmetic Operators): + - * ** / // %

• + جمع (Addition): مقدار عملوندهای دو طرف خود را با یکدیگر جمع می‌کند. 2 + 1 حاصل: 3

• - تفریق (Subtraction): مقدار عملوند سمت راست را از مقدار عملوند سمت چپ خود منها می‌کند: 4 - 7 حاصل: 3

• * ضرب (Multiplication): مقدار عملوندهای دو طرف خود را در یکدیگر ضرب می‌کند: 2 * 5 حاصل: 10

• ** توان (Exponent): مقدار عملوند سمت چپ را به توان مقدار عملوند سمت راست خود می‌رساند. 3 ** 2 حاصل: 8

• / تقسیم (Division): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و خارج قسمت را برمی‌گرداند:

  >>> # Python 3.x              >>> # Python 2.x
  
  >>> 7 / 3                     >>> 7 / 3
  2.3333333333333335            2
  >>> 12 / 3                    >>> 12 / 3
  4.0                           4
  >>> 6.0 / 2                   >>> 6.0 / 2
  3.0                           3.0
  

  همانطور که در نمونه کد بالا مشاهده می‌‌شود؛ در نسخه‌های 3x حاصل هر تقسیمی همواره به صورت عدد اعشاری محاسبه می‌گردد ولی در نسخه‌های 2x حاصل تقسیم دو عدد صحیح به همان صورت عدد صحیح محاسبه و از مقدار اعشار (در صورت وجود) صرف نظر می‌گردد. می‌توان به صورت پایین این ویژگی را به نسخه‌های 2x اضافه کرد [اسناد پایتون]:

  >>> # Python 2.x
  >>> from __future__ import division
  >>> 7 / 3
  2.3333333333333335
  >>> 12 / 3
  4.0
  

• // تقسیم گردشده پایین (Floor Division): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و خارج قسمت را با حذف مقدار اعشاری (در صورت وجود) برمی‌گرداند. حاصل این عملگر برای اعداد صحیح به صورت یک عدد صحیح محاسبه می‌گردد، به نتایج نمونه کد پایین توجه نمایید:

  >>> # Python 3.x              >>> # Python 2.x
  
  >>> 7 // 3                    >>> 7 // 3
  2                             2
  >>> 12 // 3                   >>> 12 // 3
  4                             4
  >>> 6.0 // 2                  >>> 6.0 // 2
  3.0                           3.0
  >>> 7.0 // 3                  >>> 7.0 // 3
  2.0                           2.0
  

• % باقی‌ مانده (Modulus): مقدار عملوند سمت چپ را بر مقدار عملوند سمت راست خود تقسیم می‌کند و باقی‌ مانده را برمی‌گرداند. 3 % 7 حاصل: 1

۲. عملگرهای مقایسه‌ (Comparison Operators): == =! <> < > =< =>

• == برابر (Equal): چنانچه مقدار عملوندهای دو طرف برابر باشند، True را برمی‌گرداند. 1 == 3 : False
• =! نابرابر (Not Equal): چنانچه مقدار عملوندهای دو طرف برابر نباشند، True را برمی‌گرداند. 1 =! 3 : True
• <> نابرابر (Not Equal): عملکرد آن همانند =! است ولی فقط در نسخه 2x پایتون قابل استفاده است. 1 <> 3 : True
• < بزرگتر از (Greater Than): چنانچه مقدار عملوند سمت چپ بزرگتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 < 3 : False
• > کوچکتر از (Less Than): چنانچه مقدار عملوند سمت چپ کوچکتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 > 3 : True
• =< برابر یا بزرگتر از (Greater Than or Equal): چنانچه مقدار عملوند سمت چپ برابر یا بزرگتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 =< 7 : True
• => برابر یا کوچکتر از (Less Than or Equal): چنانچه مقدار عملوند سمت چپ برابر یا کوچکتر از مقدار عملوند سمت راست آن باشد، True را برمی‌گرداند. 5 => 7 : False

۳. عملگرهای انتساب (Assignment Operators):

• = عملوند سمت راست را به عملوند سمت چپ خود نسبت می‌دهد. چنانچه یک عبارت محاسباتی در سمت راست باشد، حاصل آن را به عملوند سمت چپ نسبت می‌دهد:

  >>> a = 3
  
  >>> b = 2
  
  >>> c = a + b
  >>> c
  5
  

• =+ =- =* =** =/ =// =% عملگرهای ترکیبی (انتساب حسابی): این عملگرها ابتدا عمل مربوط به عملگر حسابی را بر روی مقدار عملوندهای دو طرف خود به انجام می‌رسانند و سپس حاصل را به عملوند سمت چپ نسبت می‌دهند:

  >>> a += b
  >>> a
  5
  

  >>> a -= b
  >>> a
  1
  

  >>> a *= b
  >>> a
  6
  

  >>> a **= b
  >>> a
  9
  

  >>> # Python 3.x                  >>> # Python 2.x
  >>> a /= b                        >>> a /= b
  >>> a                             >>> a
  1.5                               1
  

۴. عملگرهای بیتی (Bitwise Operators): & | ^ ~ >> <<

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

>>> a = 0b0011
>>> a
3
>>> b = 0b0010
>>> b
2

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

>>> bin(10)
'0b1010'

>>> type(bin(10))
<class 'str'>

>>> 0b1010
10

• &: معادل AND بیتی است - تنها بیت‌هایی از خروجی آن 1 خواهند بود که هر دو بیت متناظر از عملوندهای آن 1 باشند:

  >>> a & b                  0000 0011
  2                          0000 0010
                      (AND) -----------
                             0000 0010  = 2
  

• |: معادل OR بیتی است - تنها بیت‌هایی از خروجی آن 0 خواهند بود که هر دو بیت متناظر از عملوندهای آن 0 باشند:

  >>> a | b                  0000 0011
  3                          0000 0010
                       (OR) -----------
                             0000 0011  = 3
  

• ^: معادل XOR بیتی است - تنها بیت‌هایی از خروجی آن 1 خواهند بود که هر دو بیت متناظر از عملوندهای آن مخالف یکدیگر باشند:

  >>> a ^ b                  0000 0011
  1                          0000 0010
                      (XOR) -----------
                             0000 0001  = 1
  

• ~ معادل NOT بیتی و تک عملوندی است - هر یک از بیت‌های عملوند خود را از 0 به 1 و برعکس تبدیل می‌کند:

  >>> ~ a                    0000 0011
  -4                  (NOT) -----------
                             1111 1100
  

  یک شیوه برای نمایش اعداد علامت دار دودویی، همین عمل یعنی برعکس کردن بیت‌ها (0 به 1 و 1 به 0) است که به آن نمایش «مکمل یک» (One's Complement) اعداد دودویی گفته می‌شود. ولی مفسر پایتون به صورت پیش‌فرض اعداد علامت دار را به شیوه رایج‌تر دیگری ارزیابی می‌کند که به نام نمایش «مکمل دو» (Two's Complement) شناخته می‌شود؛ در این روش پس از برعکس شدن بیت‌ها، حاصل با عدد 1 جمع می‌شود. بنابراین در نمونه کد بالا حاصل NOT عدد a برابر 11111100 می‌شود که نمایش عدد 4 - در پایه دو به شیوه مکمل دو است:

  n = 3                       0000 0011
  3 = 0000 0011        (NOT) -----------
                              1111 1100  = -3 (in One’s Complement)
                                         = -4 (in Two’s Complement)
  

  Two’s Complement
  
  n = 4                       0000 0100
  4 = 0000 0100        (NOT) -----------
                              1111 1011
                                      1
                       ( + ) -----------
                              1111 1100  = -4
  

  می‌توان مقدار a ~ را برابر حاصل عبارت 1 - a- در نظر گرفت. بنابراین:

  >>> ~ a + 1
  -3
  

• >> شیفت چپ (Left Shift): بیت‌های عملوند سمت چپ را به مقدار عملوند سمت راست خود به سمت چپ جابه‌جا می‌کند - مکان‌های رد شده با صفر مقداردهی می‌شوند:

  >>> a << 3                  0000 0011
  24                   (LSH) -----------
                              0001 1000  = 24
  

• << شیفت راست (Right Shift): بیت‌های عملوند سمت چپ را به مقدار عملوند سمت راست خود به سمت راست جابه‌جا می‌کند - مکان‌های رد شده با صفر مقداردهی می‌شوند:

  >>> a = 88                  0101 1000
  >>> a >> 3           (RSH) -----------
  11                          0000 1011  = 11
  

• =& =| =^ =>> =<< عملگرهای ترکیبی (انتساب بیتی): این عملگرها ابتدا عمل مربوط به عملگر بیتی را بر روی عملوندهای دو طرف خود به انجام می‌رسانند و سپس حاصل را به عملوند سمت چپ نسبت می‌دهند.

۵. عملگرهای منطقی (Logical Operators):

این عملگرها عبارتند از not or and که در دستورات شرطی کاربرد دارند. عملگرهای منطقی عملوند‌های خود را بر اساس ارزش‌‌های True (درست) و False (نادرست) مورد ارزیابی قرار می‌دهند و نتایج خود را بر اساس جدول پایین برمی‌گردانند. عملگر not تک عملوندی است.

a	b	a and b	a or b	not a	not b
True	False	False	True	False	True
False	True	False	True	True	False
False	False	False	False	True	True
True	True	True	True	False	False

عملگر and تنها زمانی که هر دو عملوند آن ارزش True داشته باشند، True را بر می‌گرداند. عملگر or تنها زمانی که هر دو عملوند آن ارزش False داشته باشند، False را برمی‌گرداند. عملگر not نیز ارزش عملود خود را برعکس می‌کند (True به False و False به True).

۶. عملگرهای عضویت (Membership Operators):

شامل دو عملگر in و not in می‌باشد که از آن‌ها برای بررسی وجود یک مقدار در میان اعضای یک دنباله (sequence مانند: رشته، لیست و...) استفاده می‌شود.

• in: اگر مقدار عملوند سمت چپ خود را در عملوند سمت راست بیابد، True و در غیر این صورت False را بر می‌گرداند.
• not in: اگر مقدار عملوند سمت چپ خود را در عملوند سمت راست نیابد، True و در غیر این صورت False را بر می‌گرداند.

>>> "py" in "python"
True
>>> 1 in [1, 2, 3]
True
>>> "s" not in "python"
True
>>> 3 not in [1, 2, 3]
False

۷. عملگرهای هویت (Identity Operators):

شامل دو عملگر is و is not است که از آن‌ها برای بررسی یکی بودن دو شی استفاده می‌شود.

• is: اگر هر دو عملوند به یک شی ارجاع داشته باشند، True و در غیر این صورت False را بر می‌گرداند.
• is not: اگر هر دو عملوند به یک شی ارجاع نداشته باشند، True و در غیر این صورت False را بر می‌گرداند.

>>> a = 3

>>> a is 3
True

اولویت‌ها

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

( )               # پرانتز
**
~
-       +         # منفی و مثبت
*       /       //      %
-       +         # بعلاوه و منها
<<      >>
&       ^       |
==      !=      <>
<       <=      >       >=
=       **=     /=      //=      %=      *=      -=      +=
is      is not
in      in not
not     and     or

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

>>> # Python 3.x

>>> 4 + 2 - 3 + 2 * 5
13
>>> 4 + ((2 - 3) + 2) * 5
9
>>> 9 / 3 * 2
6.0
>>> 3 * 2 / 9
0.6666666666666666
>>> (5 - 3) ** (7 - 3)
16
>>> 4 + 3 ** 2 - 9 / 3 * 3
4.0
>>> 4 * 2 == 5 + 3
True

عملگر‌ شیرماهی (Walrus Operator)¶

از نسخه 3.8 پایتون یک عملگر جدید به نام Assignment Expressions یا Walrus Operator به سینتکس پایتون اضافه شده است. [PEP 572]. نمایش این عملگر به شکل =: (شبیه دو چشم و عاج یک شیرماهی! [تصویر]) می‌باشد و به ما این امکان را می‌دهد که عملیات انتساب و بازگرداندن مقدار را به صورت همزمان به انجام برسانیم. به نمونه کد زیر توجه نمایید:

>>> walrus = False
>>> print(walrus)
False

>>> print(walrus := True)  # Python >= 3.8
True

>>> walrus
True

دو نمونه کد بالا عملکرد یکسانی دارند با این تفاوت که در نمونه دوم تنها با استفاده یک سطر کد، متغیر walrus با انتساب مقدار True ایجاد و سپس به تابع print ارسال می‌گردد.

😊 امیدوارم مفید بوده باشه

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