6.2.1. ثابت‌های توکار¶

کلیدواژه‌های True، False و None نام‌های ثابت‌های توکار هستند. توکن ... نام ثابت Ellipsis است.

ارزیابی این اتم‌ها مقدار متناظر را به دست می‌دهد.

>>> False = 123
  File "<input>", line 1
   False = 123
   ^^^^^
SyntaxError: cannot assign to False

به‌طور رسمی، نحوه (سینتکس) ثابت‌های توکار به این صورت است:

builtin_constant: 'True' | 'False' | 'None' | '...'

6.2.2. شناسه‌ها (نام‌ها)¶

یک شناسه که به‌عنوان یک اتم (atom) ظاهر می‌شود، یک نام است. بخش نام‌ها (شناسه‌ها و کلیدواژه‌ها) را برای تعریف واژگانی و بخش نام‌گذاری و مقیدسازی را برای مستندات نام‌گذاری و پیوند ببینید.

هنگامی که نام به یک شیء مقید شده باشد، ارزیابی اتم، آن شیء را حاصل می‌کند. هنگامی که نامی مقید نشده باشد، تلاش برای ارزیابی آن، استثنای NameError را پرتاب می‌کند.

6.2.3. مقادیر لفظی¶

لفظی (literal) نمایشی متنی از یک مقدار است. پایتون از مقادیر لفظی عددی، رشته‌ای و بایتی پشتیبانی می‌کند. اف‌استرینگ‌ها و رشته‌های قالبی به‌عنوان مقادیر لفظی رشته‌ای در نظر گرفته می‌شوند.

مقادیر لفظی عددی از یک توکن NUMBER تشکیل شده‌اند که یک عدد صحیح، عدد ممیز شناور یا عدد موهومی را مشخص می‌کند. برای جزئیات، بخش مقادیر لفظی عددی را در مستندات تحلیل واژگانی ببینید.

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

توجه داشته باشید که اعداد منفی و مختلط، مانند -3 یا 3+4.2j، از نظر سینتکسی لفظی نیستند، بلکه عملیات حسابی یک‌عملوندی یا دوعملوندی هستند که شامل عملگر - یا + می‌شوند.

ارزیابی یک لفظی، شیء‌ای از نوع داده‌شده (int، float، complex، str، bytes، یا Template) با مقدار داده‌شده را به دست می‌دهد. در مورد مقادیر لفظی ممیز شناور و موهومی، ممکن است مقدار تقریبی باشد.

دستور زبان صوری برای مقادیر لفظی چنین است:

literal: strings | NUMBER

>>> x = 7
>>> y = 7
>>> x is y
True

>>> x = 123456789
>>> y = 123456789
>>> x is y
False

>>> x = 7
>>> x is 7
<input>:1: SyntaxWarning: "is" with 'int' literal. Did you mean "=="?
True

>>> "hello" 'world'
"helloworld"

>>> greeting = "Hello"
>>> space = " "
>>> name = "Blaise"
>>> print(greeting + space + name)   # not: print(greeting space name)
Hello Blaise

>>> "Hello" r', ' f"{name}!"
"Hello, Blaise!"

re.compile("[A-Za-z_]"       # letter or underscore
           "[A-Za-z0-9_]*"   # letter, digit or underscore
          )

>>> t"Hello" t"{name}!"
Template(strings=('Hello', '!'), interpolations=(...))

strings: (STRING | fstring)+ | tstring+

6.2.4. گروه‌های پرانتزگذاری‌شده¶

یک گروه پرانتزدار عبارتی است که در پرانتز محصور شده است. این گروه به همان مقداری ارزیابی می‌شود که عبارت درون آن ارزیابی می‌شود.

گروه‌ها برای لغو یا شفاف‌سازی تقدم عملگر، به همان روش نمادگذاری ریاضی استفاده می‌شوند. برای مثال:

>>> 3 << 2 | 4
12
>>> 3 << (2 | 4)   # Override precedence of the | (bitwise OR)
192
>>> (3 << 2) | 4   # Same as without parentheses (but more clear)
12

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

به‌طور رسمی، نحوه (سینتکس) گروه‌ها به این صورت است:

group: '(' assignment_expression ')'

6.2.5. نمایش‌های ظروف¶

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

برای نمونه، یک نمایش فهرست (list display) مجموعه‌ای از عبارت‌ها است که در داخل کروشه‌ها قرار گرفته‌اند:

>>> ["one", "two", "three"]
['one', 'two', 'three']
>>> [1 + 2, 2 + 3]
[3, 5]

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

>>> []  # empty list
[]
>>> ()  # empty tuple
()
>>> {}  # empty dictionary
{}

اگر سری خالی نباشد، پس از آیتم‌ها می‌توان از یک ویرگول اضافی استفاده کرد که هیچ تأثیری ندارد:

>>> ["one", "two", "three",]  # note comma after "three"
['one', 'two', 'three']

>>> [
...     'one',
...     'two',
...     'three',
... ]
['one', 'two', 'three']

در زمان ران‌تایم، هنگامی که یک نمایش ارزیابی می‌شود، آیتم‌های فهرست‌شده از چپ به راست ارزیابی شده و در ظرف جدیدی از نوع مناسب قرار می‌گیرند.

برای نمایش‌های تاپل، فهرست و مجموعه (اما نه دیکشنری)، هر آیتمی در نمایش می‌تواند پیشوندی با یک ستاره (*) داشته باشد. این موضوع نشان‌دهنده‌ی iterable unpacking است. در زمان ران‌تایم، عبارتِ پیشوندگرفته با ستاره باید به یک پیمایش‌پذیر ارزیابی شود که محتویات آن در محل بازکردن بسته در ظرف درج می‌شوند. برای مثال:

>>> numbers = (1, 2)
>>> [*numbers, 'word', *numbers]
[1, 2, 'word', 1, 2]

نمایش‌های دیکشنری از مکانیسم مشابه‌ای به نام بازکردن بسته‌ی دیکشنری استفاده می‌کنند که با دو ستاره (**) مشخص می‌شود. برای جزئیات بیشتر نمایش‌های دیکشنری را ببینید.

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

>>> ["one", "two", "three"]
['one', 'two', 'three']
>>> ["one"]  # One-element list
['one']
>>> []       # empty list
[]

list: '[' [flexible_expression_list] ']'

>>> {"one", "two", "three"}
{'one', 'three', 'two'}
>>> {"one"}  # One-element set
{'one'}

set: '{' flexible_expression_list '}'

>>> (1, 2)
(1, 2)
>>> ()  # an empty tuple
()

>>> ('single',)  # single-element tuple
('single',)
>>> ('single')   # no comma: single string
'single'

tuple:
   | '(' flexible_expression (',' flexible_expression)+ [','] ')'
   | '(' flexible_expression ',' ')'
   | '(' ')'

>>> {1: 'one', 2: 'two'}
{1: 'one', 2: 'two'}

>>> {
...     1: 'this will be overridden',
...     2: 'two',
...     1: 'also overridden',
...     1: 'one',
... }
{1: 'one', 2: 'two'}

>>> defaults = {'color': 'blue', 'count': 8}
>>> overrides = {'color': 'yellow'}
>>> {**defaults, **overrides}
{'color': 'yellow', 'count': 8}

dict:                   '{' [double_starred_kvpairs] '}'
double_starred_kvpairs: ','.double_starred_kvpair+ [',']
double_starred_kvpair:  '**' or_expr | kvpair
kvpair:                 expression ':' expression

6.2.6. درک‌ها¶

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

در ساده‌ترین شکل، یک درک‌کننده شامل یک عبارت واحد است که پس از آن یک بند for قرار دارد. بند for دارای همان نحو (سینتکس) سرآیند یک دستور for است، بدون اینکه دو‌نقطه در انتهای آن قرار گیرد.

برای مثال، فهرستی از ده مربع اول به‌صورت زیر است:

>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

در زمان اجرا، یک درک فهرستی یک فهرست جدید ایجاد می‌کند. عبارت پس از in باید به یک پیمایش‌پذیر ارزیابی شود. برای هر عنصر از این پیمایش‌پذیر، عنصر به هدف بند for مانند یک دستور for متصل می‌شود، سپس عبارت قبل از for با هدف در محدوده ارزیابی می‌شود و نتیجه به فهرست جدید اضافه می‌شود. بنابراین، مثال بالا تقریباً معادل تعریف و فراخوانی تابع زیر است:

def make_list_of_squares(iterable):
    result = []
    for x in iterable:
        result.append(x**2)
    return result

make_list_of_squares(range(10))

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

>>> {x.lower() for x in ['a', 'A', 'b', 'C']}
{'c', 'a', 'b'}

در زمان اجرا، این کار تقریباً معادل فراخوانی این تابع است:

def make_lowercase_set(iterable):
    result = set(iterable)
    for x in iterable:
        result.append(x.lower())
    return result

make_lowercase_set(['a', 'A', 'b', 'C'])

درک‌های دیکشنری به جای یک عبارت، با یک جفت کلید-مقدار جدا شده با دو‌نقطه شروع می‌شوند. برای مثال:

>>> {func.__name__: func for func in [print, hex, any]}
{'print': <built-in function print>,
 'hex': <built-in function hex>,
 'any': <built-in function any>}

در زمان اجرا، این تقریباً معادل موارد زیر است:

def make_dict_mapping_names_to_functions(iterable):
    result = {}
    for func in iterable:
        result[func.__name__] = func
    return result

iterable([print, hex, any])

مانند سایر انواع نمایش‌های دیکشنری، ممکن است یک کلید چندین بار مشخص شود. مقادیر قبلی توسط مقادیری که بعدها ارزیابی می‌شوند، بازنویسی می‌شوند.

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

>>> tuple(x**2 for x in range(10))
(0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

>>> [name for name in vars(math) if name.startswith('f')]
['fabs', 'factorial', 'floor', 'fma', 'fmod', 'frexp', 'fsum']

def get_math_f_names(iterable):
    result = []
    for name in iterable:
        if name.startswith('f'):
           result.append(name)
    return result

get_math_f_names(vars(math))

>>> import array
>>> import math
>>> [
...     name
...     for module in [array, math]
...     for name in vars(module)
...     if name.startswith('a')
... ]
['array', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh']

def get_a_names(iterable):
    result = []
    for module in iterable:
        for name in vars(module):
            if name.startswith('a'):
                result.append(name)
    return result

get_a_names([array, math])

>>> x = 'old value'
>>> [x**2 for x in range(10)]  # این `x` نسبت به درک محلی است
>>> x
'old value'

>>> students = ['Petr', 'Blaise', 'Jarka']
>>> teachers = ['Salim', 'Bartosz']
>>> lists_of_people = [students, teachers]
>>> [*people for people in lists_of_people]
['Petr', 'Blaise', 'Jarka', 'Salim', 'Bartosz']

def flatten_names(lists_of_people):
    result = []
    for people in lists_of_people:
        result.extend(people)
    return result

>>> system_defaults = {'color': 'blue', 'count': 8}
>>> user_defaults = {'color': 'yellow'}
>>> overrides = {'count': 5}

>>> configuration_sets = [system_defaults, user_defaults, overrides]

>>> {**d for d in configuration_sets}
{'color': 'yellow', 'count': 5}

listcomp:      '[' comprehension ']'
setcomp:       '{' comprehension '}'
comprehension: flexible_expression for_if_clause+

dictcomp:
    | '{' kvpair for_if_clause+ '}'
    | '{' '**' expression for_if_clause+ '}'

for_if_clause:
    | ['async'] 'for' target_list 'in' or_test ('if' or_test)*

6.2.7. عبارت‌های تولیدگر¶

سینتکس عبارت‌های تولیدگر (generator expressions) همانند درک‌های فهرستی است، با این تفاوت که آن‌ها به جای کروشه در پرانتز قرار می‌گیرند. برای مثال:

>>> iterator = (x ** 2 for x in range(10))
>>> iterator
<generator object <genexpr> at ...>

در ران‌تایم، یک عبارت تولیدگر به یک generator iterator ارزیابی می‌شود که همان مقادیرِ درک فهرستی متناظر را تولید می‌کند:

>>> list(iterator)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

بنابراین، مثال بالا تقریباً معادل تعریف و فراخوانی تابع تولیدگر زیر است:

def make_generator_of_squares(iterator):
    for x in iterator:
        yield x ** 2

make_generator_of_squares(iter(range(10)))

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

# The parentheses after `sum` are part of the call syntax:
>>> sum(x ** 2 for x in range(10))
285

# The generator needs its own parentheses if it's not the only argument:
>>> sum((x ** 2 for x in range(10)), start=1000)
1285

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

>>> (x ** 2 for x in nonexistent_iterable)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_iterable' is not defined

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

>>> (x ** 2 for x in None)
Traceback (most recent call last):
  ...
TypeError: 'NoneType' object is not iterable

تمام عبارت‌های دیگر به‌صورت تنبل ارزیابی می‌شوند، به همان شیوه‌ی تولیدگرهای معمولی (یعنی زمانی که از پیمایش‌گر خواسته شود مقداری را yield کند):

>>> iterator = (nonexistent_value for x in range(10))
>>> iterator
<generator object <genexpr> at ...>
>>> list(iterator)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_value' is not defined

>>> iterator = (x * y for x in range(10) for y in nonexistent_iterable)
>>> iterator
<generator object <genexpr> at ...>
>>> list(iterator)
Traceback (most recent call last):
  ...
NameError: name 'nonexistent_iterable' is not defined

برای جلوگیری از اخلال در عملکرد مورد انتظار خود عبارت تولیدگر، عبارت‌های yield و yield from در محدوده تودرتوی ضمنی ممنوع هستند.

اگر یک عبارت تولیدگر شامل بندهای async for یا عبارات await باشد، به آن عبارت تولیدگر ناهمگام (asynchronous generator expression) گفته می‌شود. یک عبارت تولیدگر ناهمگام یک شیء تولیدگر ناهمگام جدید برمی‌گرداند که یک پیمایش‌گر ناهمگام است (به پیمایش‌گرهای ناهمگام مراجعه کنید).

دستور زبان صوری عبارت‌های تولیدگر:

generator_expression: "(" comprehension ")"

6.2.8. عبارت‌های yield¶

yield_atom:       "(" yield_expression ")"
yield_from:       "yield" "from" expression
yield_expression: "yield" yield_list | yield_from

عبارت yield هنگام تعریف یک تابع تولیدگر یا یک تابع تولیدگر ناهمگام استفاده می‌شود و بنابراین فقط می‌تواند در بدنه‌ی تعریف یک تابع استفاده شود. استفاده از عبارت yield در بدنه‌ی یک تابع، آن تابع را به یک تابع تولیدگر تبدیل می‌کند، و استفاده از آن در بدنه‌ی یک تابع async def، آن تابع هم‌روال را به یک تابع تولیدگر ناهمگام تبدیل می‌کند. برای مثال:

def gen():  # defines a generator function
    yield 123

async def agen(): # defines an asynchronous generator function
    yield 123

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

توابع تولیدگر در ادامه توضیح داده شده‌اند، در حالی که توابع تولیدگر ناهمگام به‌طور جداگانه در بخش توابع تولیدگر ناهمگام توضیح داده شده‌اند.

هنگامی که یک تابع تولیدگر فراخوانی می‌شود، یک پیمایش‌گر برمی‌گرداند که به‌عنوان تولیدگر شناخته می‌شود. سپس آن تولیدگر اجرای تابع تولیدگر را کنترل می‌کند. اجرا زمانی آغاز می‌شود که یکی از متدهای تولیدگر فراخوانی شود. در آن هنگام، اجرا به نخستین عبارت yield می‌رسد، جایی که دوباره معلق می‌شود و مقدار yield_list را به فراخواننده‌ی تولیدگر برمی‌گرداند، یا اگر yield_list حذف شده باشد، None را برمی‌گرداند. منظور از معلق بودن این است که تمام وضعیت محلی حفظ می‌شود، از جمله انتساب‌های کنونی متغیرهای محلی، اشاره‌گر دستور، پشته‌ی ارزیابی داخلی، و وضعیت هرگونه مدیریت استثنا. هنگامی که اجرا با فراخوانی یکی از متدهای تولیدگر از سر گرفته می‌شود، تابع می‌تواند دقیقاً به‌گونه‌ای پیش برود که گویی عبارت yield تنها یک فراخوانی خارجی دیگر باشد. مقدار عبارت yield پس از آنکه اجرا از سر گرفته شد، به متدی بستگی دارد که اجرا را از سر گرفته است. اگر از __next__() استفاده شود (معمولاً از طریق for یا تابع توکار next())، نتیجه None است. در غیر این صورت، اگر از send() استفاده شود، نتیجه مقداری خواهد بود که به آن متد ارسال شده است.

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

عبارت‌های yield در هر جای یک ساختار try مجاز هستند. اگر تولیدگر پیش از نهایی شدن (با رسیدن تعداد ارجاع‌ها به صفر یا زباله‌روبی شدن) از سر گرفته نشود، متد close() پیمایش‌گر تولیدگر فراخوانی می‌شود تا امکان اجرای هر بند finally در انتظار فراهم شود.

هنگامی که از yield from <expr> استفاده می‌شود، عبارت ارائه‌شده باید پیمایش‌پذیر باشد. مقادیری که با پیمایش آن پیمایش‌پذیر تولید می‌شوند، مستقیماً به فراخواننده‌ی متدهای تولیدگر فعلی ارسال می‌شوند. هر مقداری که با send() ارسال شود و هر استثنایی که با throw() ارسال شود، در صورتی که پیمایش‌گر زیرین متدهای مناسب را داشته باشد، به آن ارسال می‌شود. در غیر این صورت، send() استثناهای AttributeError یا TypeError را پرتاب می‌کند، در حالی که throw() فقط استثنای ارسال‌شده را بلافاصله پرتاب می‌کند.

هنگامی که پیمایش‌گر زیربنایی به پایان می‌رسد، ویژگی value از نمونه‌ی پرتاب‌شده‌ی StopIteration به مقدار عبارت yield تبدیل می‌شود. این ویژگی می‌تواند یا هنگام پرتاب StopIteration به‌صراحت تنظیم شود، یا وقتی زیرپیمایش‌گر یک تولیدگر باشد به‌طور خودکار (با برگرداندن یک مقدار از زیرتولیدگر) تنظیم شود.

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

>>> def echo(value=None):
...     print("Execution starts when 'next()' is called for the first time.")
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception as e:
...                 value = e
...     finally:
...         print("Don't forget to clean up when 'close()' is called.")
...
>>> generator = echo(1)
>>> print(next(generator))
Execution starts when 'next()' is called for the first time.
1
>>> print(next(generator))
None
>>> print(generator.send(2))
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.

6.3.1. ارجاع‌های ویژگی¶

ارجاع به ویژگی یک عبارت اصلی است که پس از آن یک نقطه و یک نام می‌آید:

attributeref: primary "." identifier

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

این تولید را می‌توان با بازنویسی متد __getattribute__() یا متد __getattr__() سفارشی‌سازی کرد. متد __getattribute__() ابتدا فراخوانی می‌شود و یا مقداری را برمی‌گرداند یا در صورت در دسترس نبودن ویژگی، AttributeError را پرتاب می‌کند.

اگر یک AttributeError پرتاب شود و شیء متد __getattr__() داشته باشد، آن متد به‌عنوان جایگزین فراخوانی می‌شود.

6.3.2. زیرنویسی‌ها و اسلایس کردن‌ها¶

سینتکس زیرنویسی (subscription) معمولاً برای انتخاب یک عنصر از یک ظرف استفاده می‌شود -- برای مثال، برای دریافت یک مقدار از یک dict:

>>> digits_by_name = {'one': 1, 'two': 2}
>>> digits_by_name['two']  # Subscripting a dictionary using the key 'two'
2

در سینتکس زیرنویسی (subscription)، پس از شیء مورد زیرنویسی — یک اولیه — یک زیرنویس (subscript) در کروشه‌های مربع قرار می‌گیرد. در ساده‌ترین حالت، زیرنویس یک عبارت واحد است.

بسته به نوع شیءای که زیرنویس بر آن اعمال می‌شود، زیرنویس گاهی کلید (برای نگاشت‌ها)، اندیس (برای دنباله‌ها)، یا آرگومان نوع (برای انواع عام) نامیده می‌شود. از نظر سینتکسی، همه این‌ها معادل هستند:

>>> colors = ['red', 'blue', 'green', 'black']
>>> colors[3]  # Subscripting a list using the index 3
'black'

>>> list[str]  # Parameterizing the list type using the type argument str
list[str]

در ران‌تایم، مفسر عبارت اصلی و زیرنویس را ارزیابی می‌کند و __getitem__() یا __class_getitem__() آن را که متد ویژه است، با زیرنویس به‌عنوان آرگومان فراخوانی می‌کند. برای جزئیات بیشتر درباره‌ی این‌که کدام‌یک از این متدها فراخوانی می‌شود، __class_getitem__ در برابر __getitem__ را ببینید.

برای نشان دادن چگونگی کار زیرنویسی، می‌توانیم یک شیء سفارشی تعریف کنیم که __getitem__() را پیاده‌سازی می‌کند و مقدار زیرنویس را چاپ می‌کند:

>>> class SubscriptionDemo:
...     def __getitem__(self, key):
...         print(f'subscripted with: {key!r}')
...
>>> demo = SubscriptionDemo()
>>> demo[1]
subscripted with: 1
>>> demo['a' * 3]
subscripted with: 'aaa'

برای جزئیات مربوط به نحوه‌ی مدیریت زیرنویسی توسط انواع توکار، مستندات __getitem__() را ببینید.

از زیرنویسی‌ها نیز می‌توان به‌عنوان هدف در دستورهای انتساب یا حذف استفاده کرد. در این موارد، مفسر به‌ترتیب به‌جای __getitem__()، متد ویژه __setitem__() یا __delitem__() شیء مورد زیرنویسی را فراخوانی می‌کند.

>>> colors = ['red', 'blue', 'green', 'black']
>>> colors[3] = 'white'  # Setting item at index
>>> colors
['red', 'blue', 'green', 'white']
>>> del colors[3]  # Deleting item at index 3
>>> colors
['red', 'blue', 'green']

همه‌ی شکل‌های پیشرفته‌ی زیرنویس که در بخش‌های بعدی مستند شده‌اند، برای انتساب و حذف نیز قابل استفاده‌اند.

>>> number_names = ['zero', 'one', 'two', 'three', 'four', 'five']
>>> number_names[1:3]
['one', 'two']
>>> number_names[1:]
['one', 'two', 'three', 'four', 'five']
>>> number_names[:3]
['zero', 'one', 'two']
>>> number_names[:]
['zero', 'one', 'two', 'three', 'four', 'five']
>>> number_names[::2]
['zero', 'two', 'four']
>>> number_names[:-3]
['zero', 'one', 'two']
>>> del number_names[4:]
>>> number_names
['zero', 'one', 'two', 'three']

# continuing with the SubscriptionDemo instance defined above:
>>> demo[2:3]
subscripted with: slice(2, 3, None)
>>> demo[::'spam']
subscripted with: slice(None, None, 'spam')

# continuing with the SubscriptionDemo instance defined above:
>>> demo[1, 2, 3]
subscripted with: (1, 2, 3)
>>> demo[1:2, 3]
subscripted with: (slice(1, 2, None), 3)

>>> demo['spam',]
subscripted with: ('spam',)

# continuing with the SubscriptionDemo instance defined above:
>>> demo[*range(10)]
subscripted with: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

>>> demo['a', 'b', *range(3), 'c']
subscripted with: ('a', 'b', 0, 1, 2, 'c')

subscription:     primary '[' subscript ']'
subscript:        single_subscript | tuple_subscript
single_subscript: proper_slice | assignment_expression
proper_slice:     [expression] ":" [expression] [ ":" [expression] ]
tuple_subscript:  ','.(single_subscript | starred_expression)+ [',']

6.3.3. فراخوانی‌ها¶

یک فراخوانی، یک شیء فراخوانی‌پذیر (برای مثال، یک تابع) را با دنباله‌ای از آرگومان‌ها که ممکن است خالی باشد فراخوانی می‌کند:

call:                 primary "(" [argument_list [","] | comprehension] ")"
argument_list:        positional_arguments ["," starred_and_keywords]
                        ["," keywords_arguments]
                      | starred_and_keywords ["," keywords_arguments]
                      | keywords_arguments
positional_arguments: positional_item ("," positional_item)*
positional_item:      assignment_expression | "*" expression
starred_and_keywords: ("*" expression | keyword_item)
                      ("," "*" expression | "," keyword_item)*
keywords_arguments:   (keyword_item | "**" expression)
                      ("," keyword_item | "," "**" expression)*
keyword_item:         identifier "=" expression

ممکن است یک ویرگول پایانی اختیاری پس از آرگومان‌های جایگاهی و کلیدواژه‌ای وجود داشته باشد، اما بر معناشناسی تأثیری نمی‌گذارد.

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

اگر آرگومان‌های کلیدواژه‌ای وجود داشته باشند، آن‌ها ابتدا به آرگومان‌های جایگاهی تبدیل می‌شوند، به شرح زیر. نخست، فهرستی از جایگاه‌های پر نشده برای پارامترهای صوری ایجاد می‌شود. اگر N آرگومان جایگاهی وجود داشته باشد، آن‌ها در N جایگاه نخست قرار می‌گیرند. سپس، برای هر آرگومان کلیدواژه‌ای، از شناسه برای تعیین جایگاه متناظر استفاده می‌شود (اگر شناسه با نام نخستین پارامتر صوری یکسان باشد، نخستین جایگاه استفاده می‌شود، و به همین ترتیب). اگر جایگاه از قبل پر شده باشد، استثنای TypeError پرتاب می‌شود. در غیر این صورت، آرگومان در جایگاه قرار می‌گیرد و آن را پر می‌کند (حتی اگر عبارت None باشد، جایگاه را پر می‌کند). هنگامی که همه‌ی آرگومان‌ها پردازش شدند، جایگاه‌هایی که هنوز پر نشده‌اند با مقدار پیش‌فرض متناظر از تعریف تابع پر می‌شوند. (مقادیر پیش‌فرض یک بار، هنگام تعریف تابع محاسبه می‌شوند؛ بنابراین، یک شیء تغییرپذیر مانند فهرست یا دیکشنری که به‌عنوان مقدار پیش‌فرض استفاده شود، بین همه‌ی فراخوانی‌هایی که برای جایگاه متناظر مقدار آرگومان مشخص نمی‌کنند، مشترک خواهد بود؛ معمولاً باید از این کار اجتناب شود.) اگر جایگاه‌های پر نشده‌ای وجود داشته باشند که هیچ مقدار پیش‌فرضی برای آن‌ها مشخص نشده باشد، استثنای TypeError پرتاب می‌شود. در غیر این صورت، فهرست جایگاه‌های پر شده به‌عنوان فهرست آرگومان‌ها برای فراخوانی استفاده می‌شود.

اگر آرگومان‌های جایگاهی بیشتری نسبت به جایگاه‌های پارامتر صوری وجود داشته باشد، استثنای TypeError پرتاب می‌شود، مگر اینکه یک پارامتر صوری با استفاده از سینتکس *identifier وجود داشته باشد؛ در این حالت، آن پارامتر صوری یک تاپل شامل آرگومان‌های جایگاهی مازاد را دریافت می‌کند (یا یک تاپل خالی اگر هیچ آرگومان جایگاهی مازادی وجود نداشته باشد).

اگر آرگومان کلیدواژه‌ای وجود داشته باشد که با نام یک پارامتر صوری مطابقت نداشته باشد، یک استثنای TypeError پرتاب می‌شود، مگر اینکه یک پارامتر صوری با استفاده از سینتکس **identifier وجود داشته باشد؛ در این حالت، آن پارامتر صوری یک دیکشنری حاوی آرگومان‌های کلیدواژه‌ای اضافی دریافت می‌کند (با استفاده از کلیدواژه‌ها به‌عنوان کلیدها و مقادیر آرگومان‌ها به‌عنوان مقادیر متناظر)، یا اگر آرگومان کلیدواژه‌ای اضافی وجود نداشته باشد، یک دیکشنری خالی (جدید) دریافت می‌کند.

اگر سینتکس *expression در فراخوانی تابع آمده باشد، expression باید به یک پیمایش‌پذیر ارزیابی شود. با عناصر این پیمایش‌پذیرها چنان رفتار می‌شود که گویی آرگومان‌های جایگاهی اضافی هستند. برای فراخوانی f(x1, x2, *y, x3, x4)، اگر y به یک دنباله y1، ...، yM ارزیابی شود، این معادل یک فراخوانی با M+۴ آرگومان جایگاهی x1، x2، y1، ...، yM، x3، x4 است.

پیامد این موضوع آن است که اگرچه سینتکس *expression ممکن است بعد از آرگومان‌های کلیدواژه‌ای صریح ظاهر شود، اما قبل از آرگومان‌های کلیدواژه‌ای (و هر آرگومان **expression — در زیر ببینید) پردازش می‌شود. بنابراین:

>>> def f(a, b):
...     print(a, b)
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

استفاده همزمان از آرگومان‌های کلیدواژه‌ای و سینتکس *expression در یک فراخوانی غیرمعمول است، بنابراین در عمل این سردرگمی اغلب پیش نمی‌آید.

اگر سینتکس **expression در فراخوانی تابع وجود داشته باشد، expression باید به یک نگاشت ارزیابی شود؛ محتوای آن به‌عنوان آرگومان‌های کلیدواژه‌ای اضافی در نظر گرفته می‌شود. اگر به پارامتری که با یک کلید مطابقت دارد، از قبل مقداری داده شده باشد (با یک آرگومان کلیدواژه‌ای صریح، یا از واگشایی دیگری)، استثنای TypeError پرتاب می‌شود.

هنگامی که از **expression استفاده می‌شود، هر کلید در این نگاشت باید یک رشته باشد. هر مقدار از این نگاشت به اولین پارامتر رسمی واجد شرایط برای انتساب کلیدواژه‌ای که نام آن برابر با کلید است، اختصاص می‌یابد. کلید لازم نیست یک شناسه پایتون باشد (برای مثال "max-temp °F" قابل قبول است، اگرچه با هیچ پارامتر رسمی‌ای که بتوان آن را اعلان کرد مطابقت نخواهد داشت). اگر هیچ مطابقتی با یک پارامتر رسمی وجود نداشته باشد، جفت کلید-مقدار توسط پارامتر ** جمع‌آوری می‌شود، در صورتی که چنین پارامتری وجود داشته باشد، و در غیر این صورت، استثنای TypeError پرتاب می‌شود.

نمی‌توان از پارامترهای صوری با سینتکس *identifier یا **identifier به‌عنوان جایگاه‌های آرگومان‌های جایگاهی یا نام‌های آرگومان‌های کلیدواژه‌ای استفاده کرد.

یک فراخوانی همیشه مقداری را برمی‌گرداند، که ممکن است None باشد، مگر آنکه استثنایی را پرتاب کند. نحوه محاسبه این مقدار به نوع شیء فراخوانی‌پذیر بستگی دارد.

اگر این‌طور باشد---

یک تابع تعریف‌شده توسط کاربر:

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

یک تابع یا متد توکار:

نتیجه به مفسر بستگی دارد؛ برای توضیحات توابع و متدهای توکار به توابع توکار مراجعه کنید.

یک شیء کلاس:

یک نمونه جدید از آن کلاس بازگردانده می‌شود.

یک متد نمونه‌ی کلاس:

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

یک نمونه از کلاس:

کلاس باید یک متد __call__() تعریف کند؛ در این صورت اثر آن همانند حالتی است که گویی آن متد فراخوانی‌شده باشد.

6.10.1. مقایسه‌های مقدار¶

عملگرهای <، >، ==، >=، <= و != مقادیر دو شیء را مقایسه می‌کنند. لازم نیست این دو شیء نوع یکسانی داشته باشند.

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

از آنجا که همه انواع (مستقیم یا غیرمستقیم) زیرنوع‌هایی از object هستند، رفتار مقایسه پیش‌فرض را از object به ارث می‌برند. انواع می‌توانند رفتار مقایسه خود را با پیاده‌سازی متدهای مقایسه غنی (rich comparison methods) مانند __lt__() سفارشی‌سازی کنند، همان‌طور که در سفارشی‌سازی پایه توضیح داده شده است.

رفتار پیش‌فرض برای مقایسه برابری (== و !=) بر اساس هویت اشیء است. بنابراین، مقایسه برابری نمونه‌هایی با هویت یکسان منجر به برابری می‌شود، و مقایسه برابری نمونه‌هایی با هویت‌های متفاوت منجر به نابرابری می‌شود. انگیزه این رفتار پیش‌فرض، این خواست است که همه اشیء باید بازتابی باشند (یعنی x is y دلالت بر x == y دارد).

مقایسه ترتیبی پیش‌فرض (<، >، <= و >=) ارائه نمی‌شود؛ تلاش برای آن باعث پرتاب TypeError می‌شود. انگیزه‌ای برای این رفتار پیش‌فرض، نبود یک ناوردا مشابه با برابری است.

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

فهرست زیر رفتار مقایسه‌ای مهم‌ترین انواع توکار را توضیح می‌دهد.

• اعداد انواع عددی توکار (انواع عددی --- int، float، complex) و انواع کتابخانه استاندارد fractions.Fraction و decimal.Decimal را می‌توان در داخل یک نوع و بین انواع مختلف مقایسه کرد، با این محدودیت که اعداد مختلط از مقایسه ترتیبی پشتیبانی نمی‌کنند. در محدوده انواع درگیر، این اعداد از نظر ریاضی (الگوریتمی) به‌درستی و بدون از دست رفتن دقت مقایسه می‌شوند.

  مقادیر غیرعدد (not-a-number) یعنی float('NaN') و decimal.Decimal('NaN') خاص هستند. هر مقایسه ترتیبی یک عدد با یک مقدار غیرعدد، نادرست است. یک پیامد غیرشهودی این است که مقادیر غیرعدد با خودشان برابر نیستند. برای مثال، اگر x = float('NaN') باشد، 3 < x، x < 3 و x == x همگی نادرست هستند، در حالی که x != x درست است. این رفتار با IEEE 754 سازگار است.

• None و NotImplemented تک‌نمونه هستند. PEP 8 توصیه می‌کند که مقایسه برای تک‌نمونه‌ها باید همیشه با is یا is not انجام شود و هرگز از عملگرهای برابری استفاده نشود.

• دنباله‌های دودویی (نمونه‌های bytes یا bytearray) را می‌توان درون نوعشان و بین انواعشان مقایسه کرد. این دنباله‌ها با استفاده از مقادیر عددی عناصرشان به‌صورت واژه‌نامه‌ای مقایسه می‌شوند.

• رشته‌ها (نمونه‌های str) با استفاده از نقاط کد عددی یونیکدِ نویسه‌هایشان (نتیجه‌ی تابع توکار ord()) به‌صورت واژگانی مقایسه می‌شوند. [3]

  رشته‌ها و دنباله‌های دودویی را نمی‌توان به‌صورت مستقیم مقایسه کرد.

• دنباله‌ها (نمونه‌هایی از tuple، list یا range) فقط می‌توانند در محدوده هر یک از نوع‌های خودشان مقایسه شوند، با این محدودیت که بازه‌ها از مقایسه ترتیبی پشتیبانی نمی‌کنند. مقایسه برابری میان این نوع‌ها منجر به نابرابری می‌شود و مقایسه ترتیبی میان این نوع‌ها TypeError را پرتاب می‌کند.

  دنباله‌ها به‌صورت لغت‌نامه‌ای با مقایسه‌ی عناصر متناظر مقایسه می‌شوند. ظروف توکار معمولاً فرض می‌کنند اشیاء یکسان با خودشان برابر هستند. این امر به آن‌ها اجازه می‌دهد آزمون‌های برابری برای اشیاء یکسان را دور بزنند تا کارایی بهبود یابد و ناورداهای داخلی خود را حفظ کنند.

  مقایسه واژگانی بین مجموعه‌های توکار به‌صورت زیر عمل می‌کند:

  • برای این که دو مجموعه برابر مقایسه شوند، باید از یک نوع باشند، طول یکسانی داشته باشند، و هر جفت از عناصر متناظر باید با هم برابر باشند (برای مثال، [1,2] == (1,2) نادرست است زیرا نوع آن‌ها یکسان نیست).

  • مجموعه‌هایی که از مقایسه‌ی ترتیبی پشتیبانی می‌کنند، به همان ترتیب اولین عنصر نابرااسلایسان مرتب می‌شوند (برای مثال، [1,2,x] <= [1,2,y] همان مقدار x <= y را دارد). اگر عنصر متناظر وجود نداشته باشد، مجموعه‌ی کوتاه‌تر در ترتیب مقدم است (برای مثال، [1,2] < [1,2,3] درست است).

• نگاشت‌ها (نمونه‌های dict) اگر و فقط اگر جفت‌های (key, value) برابر داشته باشند، برابر مقایسه می‌شوند. مقایسه‌ی برابری کلیدها و مقدارها، بازتابی‌بودن را الزامی می‌کند.

  مقایسه‌های ترتیبی (<، >، <= و >=) استثنای TypeError را پرتاب می‌کنند.

• مجموعه‌ها (نمونه‌هایی از set یا frozenset) را می‌توان در درون نوع خود و میان نوع‌هایشان مقایسه کرد.

  آن‌ها عملگرهای مقایسه‌ای ترتیبی را به‌معنای آزمون‌های زیرمجموعه و ابرمجموعه تعریف می‌کنند. این روابط ترتیب‌های کامل را تعریف نمی‌کنند (برای مثال، دو مجموعه‌ی {1,2} و {2,3} نه برابرند، نه زیرمجموعه‌ی یکدیگرند و نه ابرمجموعه‌ی یکدیگرند). بر همین اساس، مجموعه‌ها آرگومان‌های مناسبی برای توابعی که به ترتیب کامل وابسته‌اند نیستند (برای مثال، min()، max() و sorted() در صورت دریافت فهرستی از مجموعه‌ها به‌عنوان ورودی، نتایج تعریف‌نشده تولید می‌کنند).

  مقایسه‌ی مجموعه‌ها، خاصیت بازتابی عناصر آن‌ها را اعمال می‌کند.

• بیشتر انواع توکار دیگر متدهای مقایسه‌ای پیاده‌سازی‌شده ندارند، بنابراین رفتار مقایسه‌ای پیش‌فرض را به ارث می‌برند.

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

• مقایسه برابری باید بازتابی باشد. به عبارت دیگر، اشیاء یکسان باید در مقایسه برابر باشند:

  x is y دلالت بر x == y دارد

• مقایسه باید متقارن باشد. به عبارت دیگر، عبارت‌های زیر باید نتیجه‌ی یکسانی داشته باشند:

  x == y و y == x

  x != y و y != x

  x < y و y > x

  x <= y و y >= x

• مقایسه باید ترایا باشد. مثال‌های زیر (غیرجامع) این موضوع را نشان می‌دهند:

  x > y and y > z دلالت بر x > z دارد

  x < y and y <= z دلالت بر x < z دارد

• مقایسه معکوس باید منجر به نقض بولی شود. به عبارت دیگر، عبارت‌های زیر باید نتیجه یکسانی داشته باشند:

  x == y و not x != y

  x < y و not x >= y (برای ترتیب کامل)

  x > y و not x <= y (برای ترتیب کامل)

  دو عبارت آخر در مورد مجموعه‌های کاملاً مرتب صدق می‌کنند (برای مثال برای دنباله‌ها، اما نه برای مجموعه‌ها یا نگاشت‌ها). همچنین دکوراتور @total_ordering را ببینید.

• نتیجه‌ی hash() باید با برابری سازگار باشد. اشیایی که برابر هستند باید یا مقدار هش یکسانی داشته باشند، یا به‌عنوان هش‌ناپذیر (unhashable) علامت‌گذاری شوند.

پایتون این قوانین سازگاری را اعمال نمی‌کند. در واقع، مقدارهای غیرعدد (not-a-number) نمونه‌ای از پیروی نکردن از این قوانین هستند.

6.10.2. عملیات آزمون عضویت¶

عملگرهای in و not in عضویت را آزمایش می‌کنند. x in s اگر x عضوی از s باشد به‌صورت True ارزیابی می‌شود و در غیر این صورت به‌صورت False ارزیابی می‌شود. x not in s نقیض x in s را برمی‌گرداند. همه دنباله‌های توکار و انواع مجموعه‌ای، و همچنین دیکشنری، از این پشتیبانی می‌کنند؛ برای دیکشنری، in آزمایش می‌کند که دیکشنری دارای کلید داده‌شده‌ای است یا نه. برای انواع ظرف مانند فهرست، تاپل، مجموعه، frozenset، دیکشنری یا collections.deque، عبارت x in y معادل any(x is e or x == e for e in y) است.

برای انواع رشته و بایت، x in y اگر و فقط اگر x زیررشته‌ای از y باشد، True است. یک آزمون معادل y.find(x) != -1 است. رشته‌های خالی همیشه زیررشته‌ای از هر رشته دیگری در نظر گرفته می‌شوند، بنابراین "" in "abc" مقدار True را برمی‌گرداند.

برای کلاس‌های تعریف‌شده توسط کاربر که متد __contains__() را تعریف می‌کنند، اگر y.__contains__(x) یک مقدار درست برگرداند، x in y مقدار True را برمی‌گرداند و در غیر این صورت False را برمی‌گرداند.

برای کلاس‌های تعریف‌شده توسط کاربر که __contains__() را تعریف نمی‌کنند اما __iter__() را تعریف می‌کنند، x in y برابر True است اگر در حین پیمایش روی y، مقداری z تولید شود که عبارت x is z or x == z برای آن درست باشد. اگر در حین پیمایش استثنایی پرتاب شود، گویی in آن استثنا را پرتاب کرده است.

در نهایت، پروتکل پیمایش به‌سبک قدیمی آزموده می‌شود: اگر کلاسی __getitem__() را تعریف کند، x in y اگر و تنها در صورتی True است که یک اندیس عدد صحیح نامنفی i وجود داشته باشد، به‌طوری که x is y[i] or x == y[i] برقرار باشد و هیچ اندیس عدد صحیح کوچک‌تری استثنا IndexError را پرتاب نکند. (اگر هر استثنا دیگری پرتاب شود، گویی in آن استثنا را پرتاب کرده است).

عملگر not in به‌گونه‌ای تعریف شده است که مقدار درستی معکوسِ in را داشته باشد.

6.10.3. مقایسه‌های هویت¶

عملگرهای is و is not هویت یک شیء را می‌سنجند: x is y اگر و تنها اگر x و y یک شیء یکسان باشند، درست است. هویت یک شیء با استفاده از تابع id() تعیین می‌شود. x is not y مقدار درستی معکوس را برمی‌گرداند. [4]

6.15.1. بازکردن بسته‌ی پیمایش‌پذیر¶

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

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