گره‌های ریشه¶

class ast.Module(body, type_ignores)¶

یک ماژول پایتون، مانند ورودی پرونده. نوع گره‌ای که توسط ast.parse() در حالت پیش‌فرض "exec" تولید می‌شود.

body یک list از دستورها ماژول است.

type_ignores یک list از کامنت‌ها نادیده‌گرفتن نوع ماژول است؛ برای جزئیات بیشتر ast.parse() را ببینید.

>>> print(ast.dump(ast.parse('x = 1'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1))])

class ast.Expression(body)¶

یک ورودی عبارت پایتون. نوع گره‌ای که توسط ast.parse() هنگامی که mode برابر "eval" باشد، تولید می‌شود.

body یک گره واحد است، یکی از انواع عبارت.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))

class ast.Interactive(body)¶

یک ورودی تعاملی واحد، مانند حالت تعاملی. نوع گره تولیدشده توسط ast.parse() هنگامی که mode برابر "single" است.

body یک list از گره‌های دستور است.

>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))
Interactive(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1)),
        Assign(
            targets=[
                Name(id='y', ctx=Store())],
            value=Constant(value=2))])

class ast.FunctionType(argtypes, returns)¶

بازنمایی‌ای از کامنت‌های نوع به سبک قدیمی برای توابع، زیرا نسخه‌های پایتون پیش از 3.5 از حاشیه‌نویسی‌های PEP 484 پشتیبانی نمی‌کردند. نوع گره تولیدشده توسط ast.parse() هنگامی که mode برابر "func_type" باشد.

چنین کامنت‌های نوعی به این شکل خواهند بود:

def sum_two_number(a, b):
    # type: (int, int) -> int
    return a + b

argtypes یک list از گره‌های عبارت است.

returns یک گره عبارت است.

>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))
FunctionType(
    argtypes=[
        Name(id='int'),
        Name(id='str')],
    returns=Subscript(
        value=Name(id='List'),
        slice=Name(id='int')))

اضافه شده در نسخه‌ی 3.8.

مقادیر لفظی¶

class ast.Constant(value, kind)¶

یک مقدار ثابت. ویژگی value در لفظی Constant شامل شیء پایتونی بازنمایی‌شده توسط آن است. مقادیر بازنمایی‌شده می‌توانند نمونه‌هایی از str، bytes، int، float، complex و bool، و ثابت‌های None و Ellipsis باشند.

ویژگی kind یک رشته اختیاری است. برای مقادیر لفظی رشته‌ای با پیشوند u، kind روی 'u' تنظیم می‌شود. برای همه‌ی ثابت‌های دیگر، kind برابر None است.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))
>>> print(ast.dump(ast.parse("u'hello'", mode='eval'), indent=4))
Expression(
    body=Constant(value='hello', kind='u'))

class ast.FormattedValue(value, conversion, format_spec)¶

گره‌ای که نشان‌دهنده‌ی یک فیلد قالب‌بندی منفرد در یک اف‌استرینگ است. اگر رشته شامل یک فیلد قالب‌بندی منفرد و هیچ چیز دیگری باشد، گره می‌تواند جداگانه باشد؛ در غیر این صورت در JoinedStr ظاهر می‌شود.

• value هر گره عبارتی است (مانند یک لفظی، یک متغیر، یا یک فراخوانی تابع).

• conversion یک عدد صحیح است:

  • -1: بدون قالب‌بندی

  • ۹۷ (ord('a')): !a قالب‌بندی ASCII

  • ۱۱۴ (ord('r')): قالب‌بندی !r با repr()

  • ۱۱۵ (ord('s')): !s قالب‌بندی string

• format_spec یک گره JoinedStr است که قالب‌بندی مقدار را نشان می‌دهد، یا اگر قالبی مشخص نشده باشد، None است. هر دو conversion و format_spec را می‌توان همزمان تنظیم کرد.

class ast.JoinedStr(values)¶

یک اف‌استرینگ، شامل مجموعه‌ای از گره‌های FormattedValue و Constant.

>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))
Expression(
    body=JoinedStr(
        values=[
            Constant(value='sin('),
            FormattedValue(
                value=Name(id='a'),
                conversion=-1),
            Constant(value=') is '),
            FormattedValue(
                value=Call(
                    func=Name(id='sin'),
                    args=[
                        Name(id='a')]),
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='.3')]))]))

class ast.TemplateStr(values, /)¶

اضافه شده در نسخه‌ی 3.14.

گره‌ای که یک لفظی رشته‌ی الگویی (template string literal) را نشان می‌دهد و شامل دنباله‌ای از گره‌های Interpolation و Constant است. این گره‌ها می‌توانند به هر ترتیبی باشند و نیازی نیست به‌صورت یک‌درمیان باشند.

>>> expr = ast.parse('t"{name} finished {place:ordinal}"', mode='eval')
>>> print(ast.dump(expr, indent=4))
Expression(
    body=TemplateStr(
        values=[
            Interpolation(
                value=Name(id='name'),
                str='name',
                conversion=-1),
            Constant(value=' finished '),
            Interpolation(
                value=Name(id='place'),
                str='place',
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='ordinal')]))]))

class ast.Interpolation(value, str, conversion, format_spec=None)¶

اضافه شده در نسخه‌ی 3.14.

گره‌ای که نشان‌دهنده‌ی یک فیلد درون‌یابی (interpolation field) در یک لفظی رشته‌ی الگو است.

• value می‌تواند هر گره‌ی عبارت باشد (مانند یک لفظی، یک متغیر، یا یک فراخوانی تابع). این همان معنای FormattedValue.value را دارد.

• str یک ثابت است که حاوی متن عبارت درون‌یابی است.

  اگر str روی None تنظیم شود، هنگام فراخوانی ast.unparse() از value برای تولید کد استفاده می‌شود. در این حالت دیگر تضمین نمی‌شود که کد تولیدشده با کد اصلی یکسان باشد و این برای تولید کد در نظر گرفته شده است.

• conversion یک عدد صحیح است:

  • -1: بدون تبدیل

  • ۹۷ (ord('a')): تبدیل !a به ASCII

  • ۱۱۴ (ord('r')): تبدیل !r به repr()

  • ۱۱۵ (ord('s')): تبدیل string با !s

  این همان معنای FormattedValue.conversion را دارد.

• format_spec یک گره JoinedStr است که قالب‌بندی مقدار را نشان می‌دهد، یا اگر هیچ قالبی مشخص نشده باشد، None است. می‌توان هر دو conversion و format_spec را همزمان تنظیم کرد. این همان معنای FormattedValue.format_spec را دارد.

class ast.List(elts, ctx)¶

class ast.Tuple(elts, ctx)¶

یک فهرست یا تاپل. elts شامل فهرستی از گره‌های نشان‌دهنده عناصر است. اگر ظرف هدف انتساب باشد (یعنی (x,y)=something)، ctx Store است و در غیر این صورت Load است.

>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))
Expression(
    body=List(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)]))
>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))
Expression(
    body=Tuple(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)]))

class ast.Set(elts)¶

یک مجموعه. elts شامل فهرستی از گره‌هایی است که عناصر مجموعه را نشان می‌دهند.

>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))
Expression(
    body=Set(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)]))

class ast.Dict(keys, values)¶

یک دیکشنری. keys و values فهرست‌هایی از گره‌ها را نگه می‌دارند که به‌ترتیب نشان‌دهنده‌ی کلیدها و مقدارها هستند و ترتیب آن‌ها با یکدیگر مطابقت دارد (آنچه هنگام فراخوانی dictionary.keys() و dictionary.values() بازگردانده می‌شود).

هنگام انجام واگشایی دیکشنری با استفاده از مقادیر لفظی دیکشنری، عبارت مورد واگشایی در فهرست values قرار می‌گیرد و یک None در موقعیت متناظر در keys قرار می‌گیرد.

>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))
Expression(
    body=Dict(
        keys=[
            Constant(value='a'),
            None],
        values=[
            Constant(value=1),
            Name(id='d')]))

متغیرها¶

class ast.Name(id, ctx)¶

نام یک متغیر. id نام را به‌عنوان یک رشته نگه می‌دارد، و ctx یکی از انواع زیر است.

class ast.Load¶

class ast.Store¶

class ast.Del¶

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

>>> print(ast.dump(ast.parse('a'), indent=4))
Module(
    body=[
        Expr(
            value=Name(id='a'))])

>>> print(ast.dump(ast.parse('a = 1'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='a', ctx=Store())],
            value=Constant(value=1))])

>>> print(ast.dump(ast.parse('del a'), indent=4))
Module(
    body=[
        Delete(
            targets=[
                Name(id='a', ctx=Del())])])

class ast.Starred(value, ctx)¶

یک ارجاع به متغیر *var. value متغیر را نگه می‌دارد، که معمولاً یک گره Name است. هنگام ساخت یک گره Call با *args باید از این نوع استفاده شود.

>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Tuple(
                    elts=[
                        Name(id='a', ctx=Store()),
                        Starred(
                            value=Name(id='b', ctx=Store()),
                            ctx=Store())],
                    ctx=Store())],
            value=Name(id='it'))])

عبارات¶

class ast.Expr(value)¶

هنگامی که یک عبارت، مانند فراخوانی تابع، به‌تنهایی به‌عنوان یک دستور ظاهر می‌شود و مقدار بازگشتی آن استفاده یا ذخیره نمی‌شود، در این ظرف قرار می‌گیرد. value یکی از گره‌های دیگر در این بخش را نگه می‌دارد: یک گره Constant، یک گره Name، یک گره Lambda، یک گره Yield یا یک گره YieldFrom.

>>> print(ast.dump(ast.parse('-a'), indent=4))
Module(
    body=[
        Expr(
            value=UnaryOp(
                op=USub(),
                operand=Name(id='a')))])

class ast.UnaryOp(op, operand)¶

یک عملیات یک‌عملوندی. op عملگر است و operand هر گره‌ی عبارت است.

class ast.UAdd¶

class ast.USub¶

class ast.Not¶

class ast.Invert¶

توکن‌های عملگر یک‌عملوندی. Not همان کلیدواژه not است، Invert همان عملگر ~ است.

>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))
Expression(
    body=UnaryOp(
        op=Not(),
        operand=Name(id='x')))

class ast.BinOp(left, op, right)¶

یک عملیات دودویی (مانند جمع یا تقسیم). op عملگر است و left و right گره‌های عبارت دلخواه هستند.

>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))
Expression(
    body=BinOp(
        left=Name(id='x'),
        op=Add(),
        right=Name(id='y')))

class ast.Add¶

class ast.Sub¶

class ast.Mult¶

class ast.Div¶

class ast.FloorDiv¶

class ast.Mod¶

class ast.Pow¶

class ast.LShift¶

class ast.RShift¶

class ast.BitOr¶

class ast.BitXor¶

class ast.BitAnd¶

class ast.MatMult¶

توکن‌های عملگر دودویی.

class ast.BoolOp(op, values)¶

یک عملیات بولی، 'or' یا 'and'. op Or یا And است. values مقادیر درگیر هستند. عملیات‌های متوالی با همان عملگر، مانند a or b or c، در یک گره با چند مقدار ادغام می‌شوند.

این شامل not نمی‌شود، که یک UnaryOp است.

>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))
Expression(
    body=BoolOp(
        op=Or(),
        values=[
            Name(id='x'),
            Name(id='y')]))

class ast.And¶

class ast.Or¶

توکن‌های عملگر بولی.

class ast.Compare(left, ops, comparators)¶

مقایسه‌ی دو یا چند مقدار. left نخستین مقدار در مقایسه است، ops فهرست عملگرها است، و comparators فهرست مقادیر پس از نخستین عنصر در مقایسه است.

>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))
Expression(
    body=Compare(
        left=Constant(value=1),
        ops=[
            LtE(),
            Lt()],
        comparators=[
            Name(id='a'),
            Constant(value=10)]))

class ast.Eq¶

class ast.NotEq¶

class ast.Lt¶

class ast.LtE¶

class ast.Gt¶

class ast.GtE¶

class ast.Is¶

class ast.IsNot¶

class ast.In¶

class ast.NotIn¶

توکن‌های عملگر مقایسه‌ای.

class ast.Call(func, args, keywords)¶

یک فراخوانی تابع. func تابع است، که اغلب یک شیء Name یا Attribute خواهد بود. از میان آرگومان‌ها:

• args فهرستی از آرگومان‌های ارسال‌شده به‌صورت جایگاهی را در خود نگه می‌دارد.

• keywords شامل فهرستی از اشیاء keyword است که آرگومان‌های ارسال‌شده با کلیدواژه را نشان می‌دهند.

آرگومان‌های args و keywords اختیاری هستند و پیش‌فرض آن‌ها فهرست‌های خالی است.

>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))
Expression(
    body=Call(
        func=Name(id='func'),
        args=[
            Name(id='a'),
            Starred(
                value=Name(id='d'))],
        keywords=[
            keyword(
                arg='b',
                value=Name(id='c')),
            keyword(
                value=Name(id='e'))]))

class ast.keyword(arg, value)¶

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

class ast.IfExp(test, body, orelse)¶

یک عبارت مانند a if b else c. هر فیلد یک گره را نگه می‌دارد، بنابراین در مثال زیر، هر سه، گره‌های Name هستند.

>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))
Expression(
    body=IfExp(
        test=Name(id='b'),
        body=Name(id='a'),
        orelse=Name(id='c')))

class ast.Attribute(value, attr, ctx)¶

دسترسی به ویژگی، مثلاً d.keys. value یک گره است، معمولاً یک Name. attr یک رشته‌ی ساده است که نام ویژگی را مشخص می‌کند، و ctx بسته به نوع عمل انجام‌شده روی ویژگی، Load، Store یا Del است.

>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))
Expression(
    body=Attribute(
        value=Name(id='snake'),
        attr='colour'))

class ast.NamedExpr(target, value)¶

یک عبارت نام‌دار. این گره AST توسط عملگر عبارت انتساب (که به عملگر walrus نیز شناخته می‌شود) تولید می‌شود. برخلاف گره Assign که در آن اولین آرگومان می‌تواند چندین گره باشد، در این حالت هر دو target و value باید گره‌های تکی باشند.

>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))
Expression(
    body=NamedExpr(
        target=Name(id='x', ctx=Store()),
        value=Constant(value=4)))

اضافه شده در نسخه‌ی 3.8.

دستورها¶

class ast.Assign(targets, value, type_comment)¶

یک انتساب. targets فهرستی از گره‌ها است، و value یک گره واحد است.

گره‌های متعدد در targets نشان‌دهنده‌ی انتساب یک مقدار یکسان به هر یک هستند. واگشایی با قرار دادن یک Tuple یا List درون targets نمایش داده می‌شود.

type_comment¶

type_comment یک رشته اختیاری حاوی حاشیه‌نویسی نوع به‌صورت کامنت است.

>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # Multiple assignment
Module(
    body=[
        Assign(
            targets=[
                Name(id='a', ctx=Store()),
                Name(id='b', ctx=Store())],
            value=Constant(value=1))])

>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # Unpacking
Module(
    body=[
        Assign(
            targets=[
                Tuple(
                    elts=[
                        Name(id='a', ctx=Store()),
                        Name(id='b', ctx=Store())],
                    ctx=Store())],
            value=Name(id='c'))])

class ast.AnnAssign(target, annotation, value, simple)¶

یک انتساب با حاشیه‌نویسی نوع. target یک گره واحد است و می‌تواند یک Name، یک Attribute یا یک Subscript باشد. annotation حاشیه‌نویسی است، مانند یک گره Constant یا Name. value یک گره واحد اختیاری است.

simple همیشه یا ۰ است (نشان‌دهنده‌ی یک هدف «پیچیده») یا ۱ (نشان‌دهنده‌ی یک هدف «ساده»). یک هدف «ساده» فقط شامل یک گره Name است که بین پرانتز قرار ندارد؛ تمام اهداف دیگر پیچیده محسوب می‌شوند. تنها اهداف ساده در دیکشنری __annotations__ ماژول‌ها و کلاس‌ها ظاهر می‌شوند.

>>> print(ast.dump(ast.parse('c: int'), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='c', ctx=Store()),
            annotation=Name(id='int'),
            simple=1)])

>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # Annotation with parenthesis
Module(
    body=[
        AnnAssign(
            target=Name(id='a', ctx=Store()),
            annotation=Name(id='int'),
            value=Constant(value=1),
            simple=0)])

>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # Attribute annotation
Module(
    body=[
        AnnAssign(
            target=Attribute(
                value=Name(id='a'),
                attr='b',
                ctx=Store()),
            annotation=Name(id='int'),
            simple=0)])

>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # Subscript annotation
Module(
    body=[
        AnnAssign(
            target=Subscript(
                value=Name(id='a'),
                slice=Constant(value=1),
                ctx=Store()),
            annotation=Name(id='int'),
            simple=0)])

class ast.AugAssign(target, op, value)¶

انتساب تقویتی، مانند a += 1. در مثال زیر، target یک گره Name برای x (با زمینه‌ی Store) است، op Add است، و value یک Constant با مقدار ۱ است.

ویژگی target نمی‌تواند از کلاس Tuple یا List باشد، برخلاف هدف‌های Assign.

>>> print(ast.dump(ast.parse('x += 2'), indent=4))
Module(
    body=[
        AugAssign(
            target=Name(id='x', ctx=Store()),
            op=Add(),
            value=Constant(value=2))])

class ast.Raise(exc, cause)¶

یک دستور raise. exc شیء استثنا است که پرتاب می‌شود، معمولاً یک Call یا Name، یا None برای یک raise مستقل. cause بخش اختیاری برای y در raise x from y است.

>>> print(ast.dump(ast.parse('raise x from y'), indent=4))
Module(
    body=[
        Raise(
            exc=Name(id='x'),
            cause=Name(id='y'))])

class ast.Assert(test, msg)¶

یک ادعا. test حاوی شرط است، مانند یک گره Compare. msg حاوی پیام شکست است.

>>> print(ast.dump(ast.parse('assert x,y'), indent=4))
Module(
    body=[
        Assert(
            test=Name(id='x'),
            msg=Name(id='y'))])

class ast.Delete(targets)¶

نشان‌دهنده‌ی یک دستور del است. targets فهرستی از گره‌ها است، مانند گره‌های Name، Attribute یا Subscript.

>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))
Module(
    body=[
        Delete(
            targets=[
                Name(id='x', ctx=Del()),
                Name(id='y', ctx=Del()),
                Name(id='z', ctx=Del())])])

class ast.Pass¶

یک دستور pass.

>>> print(ast.dump(ast.parse('pass'), indent=4))
Module(
    body=[
        Pass()])

class ast.TypeAlias(name, type_params, value)¶

یک نام مستعار نوع که از طریق دستور type ایجاد شده است. name نام این نام مستعار است، type_params فهرستی از پارامترهای نوع است، و value مقدار این نام مستعار نوع است.

>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            value=Name(id='int'))])

اضافه شده در نسخه‌ی 3.12.

دستورهای دیگر که فقط داخل توابع یا حلقه‌ها قابل استفاده هستند، در بخش‌های دیگر شرح داده شده‌اند.

کنترل جریان¶

class ast.If(test, body, orelse)¶

یک دستور if. test یک گره واحد را نگه می‌دارد، مانند یک گره Compare. body و orelse هر کدام فهرستی از گره‌ها را نگه می‌دارند.

بندهای elif بازنمایی خاصی در AST ندارند، بلکه به‌صورت گره‌های اضافی If در بخش orelse گره پیشین ظاهر می‌شوند.

>>> print(ast.dump(ast.parse("""
... if x:
...    ...
... elif y:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        If(
            test=Name(id='x'),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                If(
                    test=Name(id='y'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))],
                    orelse=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

class ast.For(target, iter, body, orelse, type_comment)¶

یک حلقه for. target متغیر(ها)یی را که حلقه به آن‌ها انتساب می‌دهد، به‌صورت یک گره از نوع Name، Tuple، List، Attribute یا Subscript نگه می‌دارد. iter آیتم مورد پیمایش حلقه را، باز هم به‌صورت یک گره نگه می‌دارد. body و orelse شامل فهرست‌هایی از گره‌ها برای اجرا هستند. گره‌های موجود در orelse در صورتی اجرا می‌شوند که حلقه به‌طور عادی پایان یابد، نه از طریق یک دستور break.

type_comment¶

type_comment یک رشته اختیاری حاوی حاشیه‌نویسی نوع به‌صورت کامنت است.

>>> print(ast.dump(ast.parse("""
... for x in y:
...     ...
... else:
...     ...
... """), indent=4))
Module(
    body=[
        For(
            target=Name(id='x', ctx=Store()),
            iter=Name(id='y'),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))])])

class ast.While(test, body, orelse)¶

یک حلقه‌ی while. test شرط را نگه می‌دارد، مانند یک گره‌ی Compare.

>>> print(ast.dump(ast.parse("""
... while x:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        While(
            test=Name(id='x'),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))])])

class ast.Break¶

class ast.Continue¶

دستورهای break و continue.

>>> print(ast.dump(ast.parse("""\
... for a in b:
...     if a > 5:
...         break
...     else:
...         continue
...
... """), indent=4))
Module(
    body=[
        For(
            target=Name(id='a', ctx=Store()),
            iter=Name(id='b'),
            body=[
                If(
                    test=Compare(
                        left=Name(id='a'),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=5)]),
                    body=[
                        Break()],
                    orelse=[
                        Continue()])])])

class ast.Try(body, handlers, orelse, finalbody)¶

بلوک‌های try. همه ویژگی‌ها فهرستی از گره‌ها برای اجرا هستند، به جز handlers که فهرستی از گره‌های ExceptHandler است.

>>> print(ast.dump(ast.parse("""
... try:
...    ...
... except Exception:
...    ...
... except OtherException as e:
...    ...
... else:
...    ...
... finally:
...    ...
... """), indent=4))
Module(
    body=[
        Try(
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            handlers=[
                ExceptHandler(
                    type=Name(id='Exception'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                ExceptHandler(
                    type=Name(id='OtherException'),
                    name='e',
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))],
            finalbody=[
                Expr(
                    value=Constant(value=Ellipsis))])])

class ast.TryStar(body, handlers, orelse, finalbody)¶

بلوک‌های try که پس از آن‌ها بندهای except* می‌آیند. ویژگی‌ها همان ویژگی‌های Try هستند، اما گره‌های ExceptHandler در handlers به‌عنوان بلوک‌های except* تفسیر می‌شوند، نه except.

>>> print(ast.dump(ast.parse("""
... try:
...    ...
... except* Exception:
...    ...
... """), indent=4))
Module(
    body=[
        TryStar(
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            handlers=[
                ExceptHandler(
                    type=Name(id='Exception'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.11.

class ast.ExceptHandler(type, name, body)¶

یک بند except واحد. type نوع استثنایی است که با آن مطابقت دارد و معمولاً یک گره Name است (یا None برای یک بند except: فراگیر). name یک رشته خام برای نامی است که استثنا را نگه می‌دارد، یا None اگر بند as foo نداشته باشد. body فهرستی از گره‌ها است.

>>> print(ast.dump(ast.parse("""\
... try:
...     a + 1
... except TypeError:
...     pass
... """), indent=4))
Module(
    body=[
        Try(
            body=[
                Expr(
                    value=BinOp(
                        left=Name(id='a'),
                        op=Add(),
                        right=Constant(value=1)))],
            handlers=[
                ExceptHandler(
                    type=Name(id='TypeError'),
                    body=[
                        Pass()])])])

class ast.With(items, body, type_comment)¶

یک بلوک with. items فهرستی از گره‌های withitem است که مدیران زمینه را نشان می‌دهند، و body بلوک تورفته‌ی درون زمینه است.

type_comment¶

type_comment یک رشته اختیاری حاوی حاشیه‌نویسی نوع به‌صورت کامنت است.

class ast.withitem(context_expr, optional_vars)¶

یک مدیر زمینه‌ی واحد در یک بلوک with. context_expr مدیر زمینه است و معمولاً یک گره Call است. optional_vars یک Name، Tuple یا List برای بخش as foo است، یا اگر از آن استفاده‌نشده باشد، None است.

>>> print(ast.dump(ast.parse("""\
... with a as b, c as d:
...    something(b, d)
... """), indent=4))
Module(
    body=[
        With(
            items=[
                withitem(
                    context_expr=Name(id='a'),
                    optional_vars=Name(id='b', ctx=Store())),
                withitem(
                    context_expr=Name(id='c'),
                    optional_vars=Name(id='d', ctx=Store()))],
            body=[
                Expr(
                    value=Call(
                        func=Name(id='something'),
                        args=[
                            Name(id='b'),
                            Name(id='d')]))])])

تطبیق الگو¶

class ast.Match(subject, cases)¶

یک دستور match. subject شامل موضوع تطبیق (شیءای که با حالت‌های مختلف تطبیق داده می‌شود) است و cases شامل یک پیمایش‌پذیر از گره‌های match_case برای حالت‌های مختلف است.

اضافه شده در نسخه‌ی 3.10.

class ast.match_case(pattern, guard, body)¶

یک الگوی case منفرد در یک دستور match. pattern شامل الگوی تطبیقی است که موضوع با آن تطبیق داده خواهد شد. توجه داشته باشید که گره‌های AST تولیدشده برای الگوها با گره‌های تولیدشده برای عبارات متفاوت هستند، حتی زمانی که سینتکس یکسانی دارند.

ویژگی guard شامل عبارتی است که اگر الگو با موضوع مطابقت داشته باشد، ارزیابی می‌شود.

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

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] if x>0:
...         ...
...     case tuple():
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchAs(name='x')]),
                    guard=Compare(
                        left=Name(id='x'),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=0)]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='tuple')),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchValue(value)¶

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

>>> print(ast.dump(ast.parse("""
... match x:
...     case "Relevant":
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchValue(
                        value=Constant(value='Relevant')),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchSingleton(value)¶

یک الگوی تطبیق لفظی که بر اساس هویت مقایسه می‌کند. value تک‌نمونه‌ای است که با آن مقایسه می‌شود: None، True یا False. این الگو در صورتی موفق می‌شود که موضوع تطبیق همان ثابت داده‌شده باشد.

>>> print(ast.dump(ast.parse("""
... match x:
...     case None:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSingleton(value=None),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchSequence(patterns)¶

یک الگوی تطبیق دنباله. patterns شامل الگوهایی است که در صورت دنباله بودن موضوع، با عناصر موضوع تطبیق داده می‌شوند. اگر یکی از زیرالگوها یک گره MatchStar باشد، با یک دنباله با طول متغیر تطبیق می‌یابد، در غیر این صورت با یک دنباله با طول ثابت تطبیق می‌یابد.

>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchValue(
                                value=Constant(value=1)),
                            MatchValue(
                                value=Constant(value=2))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchStar(name)¶

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

>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2, *rest]:
...         ...
...     case [*_]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchValue(
                                value=Constant(value=1)),
                            MatchValue(
                                value=Constant(value=2)),
                            MatchStar(name='rest')]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchStar()]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchMapping(keys, patterns, rest)¶

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

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

>>> print(ast.dump(ast.parse("""
... match x:
...     case {1: _, 2: _}:
...         ...
...     case {**rest}:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchMapping(
                        keys=[
                            Constant(value=1),
                            Constant(value=2)],
                        patterns=[
                            MatchAs(),
                            MatchAs()]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchMapping(rest='rest'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)¶

یک الگوی تطبیق کلاس. cls عبارتی است که کلاس اسمی مورد تطبیق را مشخص می‌کند. patterns دنباله‌ای از گره‌های الگو است که باید با دنباله‌ای از ویژگی‌های تطبیق الگو که کلاس آن را تعریف کرده است تطبیق داده شوند. kwd_attrs دنباله‌ای از ویژگی‌های اضافی برای تطبیق است (که به‌صورت آرگومان‌های کلیدواژه‌ای در الگوی کلاس مشخص می‌شوند)، kwd_patterns الگوهای متناظر هستند (که به‌صورت مقادیر کلیدواژه‌ای در الگوی کلاس مشخص می‌شوند).

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

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

>>> print(ast.dump(ast.parse("""
... match x:
...     case Point2D(0, 0):
...         ...
...     case Point3D(x=0, y=0, z=0):
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='Point2D'),
                        patterns=[
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='Point3D'),
                        kwd_attrs=[
                            'x',
                            'y',
                            'z'],
                        kwd_patterns=[
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchAs(pattern, name)¶

یک «الگوی as» (as-pattern) در تطبیق، یک الگوی ثبت‌کننده (capture pattern) یا یک الگوی wildcard (wildcard pattern). pattern شامل الگوی تطبیقی است که موضوع با آن تطبیق داده خواهد شد. اگر الگو None باشد، این گره بیانگر یک الگوی ثبت‌کننده (یعنی یک نام ساده) است و همیشه با موفقیت تطبیق داده خواهد شد.

ویژگی name شامل نامی است که در صورت موفقیت الگو مقید خواهد شد. اگر name برابر None باشد، pattern نیز باید None باشد و گره نشان‌دهنده‌ی الگوی وایلدکارد است.

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] as y:
...         ...
...     case _:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchAs(
                        pattern=MatchSequence(
                            patterns=[
                                MatchAs(name='x')]),
                        name='y'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchAs(),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

class ast.MatchOr(patterns)¶

یک «الگوی یا» (or-pattern) در تطبیق. یک الگوی یا هر یک از الگوهای فرعی خود را به‌نوبت با موضوع تطبیق می‌دهد، تا یکی موفق شود. سپس الگوی یا موفق تلقی می‌شود. اگر هیچ‌کدام از الگوهای فرعی موفق نشوند، الگوی یا شکست می‌خورد. ویژگی patterns شامل فهرستی از گره‌های الگوی تطبیق است که با موضوع تطبیق داده می‌شوند.

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] | (y):
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchOr(
                        patterns=[
                            MatchSequence(
                                patterns=[
                                    MatchAs(name='x')]),
                            MatchAs(name='y')]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

اضافه شده در نسخه‌ی 3.10.

حاشیه‌نویسی‌های نوع¶

class ast.TypeIgnore(lineno, tag)¶

یک کامنت # type: ignore در lineno قرار دارد. tag برچسب اختیاری است که با قالب # type: ignore <tag> مشخص می‌شود.

>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1))],
    type_ignores=[
        TypeIgnore(lineno=1, tag='')])
>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='x', ctx=Store()),
            annotation=Name(id='bool'),
            value=Constant(value=1),
            simple=1)],
    type_ignores=[
        TypeIgnore(lineno=1, tag='[assignment]')])

نکته

گره‌های TypeIgnore زمانی که پارامتر type_comments روی False (پیش‌فرض) تنظیم شده باشد، ایجاد نمی‌شوند. برای جزئیات بیشتر ast.parse() را ببینید.

اضافه شده در نسخه‌ی 3.8.

پارامترهای نوع¶

پارامترهای نوع می‌توانند در کلاس‌ها، توابع و نام‌های مستعار نوع وجود داشته باشند.

class ast.TypeVar(name, bound, default_value)¶

یک typing.TypeVar. name نام متغیر نوع است. bound کران یا محدودیت‌ها است، در صورت وجود. اگر bound یک Tuple باشد، بیانگر محدودیت‌ها است؛ در غیر این صورت بیانگر کران است. default_value مقدار پیش‌فرض است؛ اگر TypeVar مقدار پیش‌فرض نداشته باشد، این ویژگی روی None تنظیم خواهد شد.

>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                TypeVar(
                    name='T',
                    bound=Name(id='int'),
                    default_value=Name(id='bool'))],
            value=Subscript(
                value=Name(id='list'),
                slice=Name(id='T')))])

اضافه شده در نسخه‌ی 3.12.

تغییر یافته در نسخه‌ی 3.13: پارامتر default_value افزوده شد.

class ast.ParamSpec(name, default_value)¶

یک typing.ParamSpec. name نام مشخصه پارامتر است. default_value مقدار پیش‌فرض است؛ اگر ParamSpec پیش‌فرضی نداشته باشد، این ویژگی به None تنظیم می‌شود.

>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                ParamSpec(
                    name='P',
                    default_value=List(
                        elts=[
                            Name(id='int'),
                            Name(id='str')]))],
            value=Subscript(
                value=Name(id='Callable'),
                slice=Tuple(
                    elts=[
                        Name(id='P'),
                        Name(id='int')])))])

اضافه شده در نسخه‌ی 3.12.

تغییر یافته در نسخه‌ی 3.13: پارامتر default_value افزوده شد.

class ast.TypeVarTuple(name, default_value)¶

یک typing.TypeVarTuple است. name نام تاپل متغیر نوع است. default_value مقدار پیش‌فرض است؛ اگر TypeVarTuple پیش‌فرضی نداشته باشد، این ویژگی روی None تنظیم می‌شود.

>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                TypeVarTuple(name='Ts', default_value=Tuple())],
            value=Subscript(
                value=Name(id='tuple'),
                slice=Tuple(
                    elts=[
                        Starred(
                            value=Name(id='Ts'))])))])

اضافه شده در نسخه‌ی 3.12.

تغییر یافته در نسخه‌ی 3.13: پارامتر default_value افزوده شد.

تعاریف تابع و کلاس¶

class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)¶

تعریف یک تابع.

• name یک رشته خام از نام تابع است.

• args یک گره arguments است.

• body فهرست گره‌های درون تابع است.

• decorator_list فهرستی از دکوراتورهایی است که باید اعمال شوند و بیرونی‌ترین آن‌ها در ابتدا ذخیره شده است (یعنی اولین دکوراتور فهرست، در آخر اعمال می‌شود).

• returns حاشیه‌نویسی بازگشت (return annotation) است.

• type_params فهرستی از پارامترهای نوع است.

type_comment¶

type_comment یک رشته اختیاری حاوی حاشیه‌نویسی نوع به‌صورت کامنت است.

تغییر یافته در نسخه‌ی 3.12: type_params اضافه شد.

class ast.Lambda(args, body)¶

lambda یک تعریف حداقلی تابع است که می‌تواند درون یک عبارت استفاده شود. برخلاف FunctionDef، body تنها شامل یک گره است.

>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))
Module(
    body=[
        Expr(
            value=Lambda(
                args=arguments(
                    args=[
                        arg(arg='x'),
                        arg(arg='y')]),
                body=Constant(value=Ellipsis)))])

class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)¶

آرگومان‌های یک تابع.

• posonlyargs، args و kwonlyargs فهرست‌هایی از گره‌های arg هستند.

• vararg و kwarg گره‌های arg تکی هستند که به پارامترهای *args, **kwargs اشاره می‌کنند.

• kw_defaults فهرستی از مقادیر پیش‌فرض برای آرگومان‌های فقط کلیدواژه‌ای است. اگر یکی None باشد، آرگومان متناظر الزامی است.

• defaults فهرستی از مقادیر پیش‌فرض برای آرگومان‌هایی است که می‌توانند به‌صورت جایگاهی ارسال شوند. اگر تعداد مقادیر پیش‌فرض کمتر باشد، آن‌ها با آخرین n آرگومان متناظر هستند.

class ast.arg(arg, annotation, type_comment)¶

یک آرگومان منفرد در یک فهرست. arg یک رشته خام از نام آرگومان است؛ annotation حاشیه‌نویسی آن است، مانند یک گره Name.

type_comment¶

type_comment یک رشته اختیاری است که حاشیه‌نویسی نوع را به‌صورت یک کامنت دارد

>>> print(ast.dump(ast.parse("""\
... @decorator1
... @decorator2
... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':
...     pass
... """), indent=4))
Module(
    body=[
        FunctionDef(
            name='f',
            args=arguments(
                args=[
                    arg(
                        arg='a',
                        annotation=Constant(value='annotation')),
                    arg(arg='b'),
                    arg(arg='c')],
                vararg=arg(arg='d'),
                kwonlyargs=[
                    arg(arg='e'),
                    arg(arg='f')],
                kw_defaults=[
                    None,
                    Constant(value=3)],
                kwarg=arg(arg='g'),
                defaults=[
                    Constant(value=1),
                    Constant(value=2)]),
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1'),
                Name(id='decorator2')],
            returns=Constant(value='return annotation'))])

class ast.Return(value)¶

یک دستور return.

>>> print(ast.dump(ast.parse('return 4'), indent=4))
Module(
    body=[
        Return(
            value=Constant(value=4))])

class ast.Yield(value)¶

class ast.YieldFrom(value)¶

یک عبارت yield یا yield from. از آنجا که این‌ها عبارت هستند، در صورتی که مقدار بازگشتی آن‌ها استفاده نشود، باید در یک گره Expr قرار گیرند.

>>> print(ast.dump(ast.parse('yield x'), indent=4))
Module(
    body=[
        Expr(
            value=Yield(
                value=Name(id='x')))])

>>> print(ast.dump(ast.parse('yield from x'), indent=4))
Module(
    body=[
        Expr(
            value=YieldFrom(
                value=Name(id='x')))])

class ast.Global(names)¶

class ast.Nonlocal(names)¶

دستورهای global و nonlocal. names فهرستی از رشته‌های خام است.

>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))
Module(
    body=[
        Global(
            names=[
                'x',
                'y',
                'z'])])

>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))
Module(
    body=[
        Nonlocal(
            names=[
                'x',
                'y',
                'z'])])

class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)¶

تعریف یک کلاس.

• name یک رشته خام برای نام کلاس است

• bases فهرستی از گره‌ها برای کلاس‌های پایه‌ای است که به‌صراحت مشخص‌شده‌اند.

• keywords فهرستی از گره‌های keyword است، عمدتاً برای 'metaclass'. سایر کلیدواژه‌ها مطابق PEP 3115 به فراکلاس ارسال می‌شوند.

• body فهرستی از گره‌هایی است که کد درون تعریف کلاس را نشان می‌دهند.

• decorator_list فهرستی از گره‌ها است، همان‌طور که در FunctionDef وجود دارد.

• type_params فهرستی از پارامترهای نوع است.

>>> print(ast.dump(ast.parse("""\
... @decorator1
... @decorator2
... class Foo(base1, base2, metaclass=meta):
...     pass
... """), indent=4))
Module(
    body=[
        ClassDef(
            name='Foo',
            bases=[
                Name(id='base1'),
                Name(id='base2')],
            keywords=[
                keyword(
                    arg='metaclass',
                    value=Name(id='meta'))],
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1'),
                Name(id='decorator2')])])

تغییر یافته در نسخه‌ی 3.12: type_params اضافه شد.

ناهمگام و await¶

class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)¶

یک تعریف تابع async def. دارای همان فیلدهای FunctionDef است.

تغییر یافته در نسخه‌ی 3.12: type_params اضافه شد.

class ast.Await(value)¶

یک عبارت await. value مقداری است که برای آن انتظار می‌رود. فقط در بدنه‌ی یک AsyncFunctionDef معتبر است.

>>> print(ast.dump(ast.parse("""\
... async def f():
...     await other_func()
... """), indent=4))
Module(
    body=[
        AsyncFunctionDef(
            name='f',
            args=arguments(),
            body=[
                Expr(
                    value=Await(
                        value=Call(
                            func=Name(id='other_func'))))])])

class ast.AsyncFor(target, iter, body, orelse, type_comment)¶

class ast.AsyncWith(items, body, type_comment)¶

حلقه‌های async for و مدیران زمینه‌ی async with. آن‌ها به‌ترتیب همان فیلدهای For و With را دارند. فقط در بدنه‌ی یک AsyncFunctionDef معتبر هستند.