name ::= lc_letter (lc_letter | "_")*

lc_letter ::= "a"..."z"

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

letter ::=
lowercase | uppercase

lowercase ::=
"a"..."z"

uppercase ::=
"A"..."Z"

digit ::=
"0"..."9"

stringliteral ::=
[stringprefix](shortstring | longstring)

stringprefix ::=
"r" | "u" | "ur" | "R" | "U" | "UR" | "Ur" | "uR"

shortstring ::=
"'" shortstringitem* "'"
| '"' shortstringitem* '"'

longstring ::=
"'''" longstringitem* "'''"
| '"""' longstringitem* '"""'

shortstringitem ::=
shortstringchar | escapeseq

longstringitem ::=
longstringchar | escapeseq

shortstringchar ::=


longstringchar ::=


escapeseq ::=
""

longinteger ::=
integer ("l" | "L")

integer ::=
decimalinteger | octinteger | hexinteger

decimalinteger ::=
nonzerodigit digit* | "0"

octinteger ::=
"0" octdigit+

hexinteger ::=
"0" ("x" | "X") hexdigit+

nonzerodigit ::=
"1"..."9"

octdigit ::=
"0"..."7"

hexdigit ::=
digit | "a"..."f" | "A"..."F"

floatnumber ::=
pointfloat | exponentfloat

pointfloat ::=
[intpart] fraction | intpart "."

exponentfloat ::=
(intpart | pointfloat)
exponent

intpart ::=
digit+

fraction ::=
"." digit+

exponent ::=
("e" | "E") ["+" | "-"] digit+

imagnumber ::= (floatnumber | intpart) ("j" | "J")

atom ::=
identifier | literal | enclosure

enclosure ::=
parenth_form | list_display
| generator_expression | dict_display
| string_conversion

literal ::=
stringliteral | integer | longinteger
| floatnumber | imagnumber

parenth_form ::=
"(" [expression_list] ")"

test ::=
and_test ( "or" and_test )*
| lambda_form

testlist ::=
test ( "," test )* [ "," ]

list_display ::=
"[" [listmaker] "]"

listmaker ::=
expression ( list_for
| ( "," expression )* [","] )

list_iter ::=
list_for | list_if

list_for ::=
"for" expression_list "in" testlist
[list_iter]

list_if ::=
"if" test [list_iter]

generator_expression ::=
"(" test genexpr_for ")"

genexpr_for ::=
"for" expression_list "in" test
[genexpr_iter]

genexpr_iter ::=
genexpr_for | genexpr_if

genexpr_if ::=
"if" test [genexpr_iter]

dict_display ::=
"{" [key_datum_list] "}"

key_datum_list ::=
key_datum ("," key_datum)* [","]

key_datum ::=
expression ":" expression

string_conversion ::=
"`" expression_list "`"

primary ::=
atom | attributeref
| subscription | slicing | call

attributeref ::=
primary "." identifier

subscription ::=
primary "[" expression_list "]"

slicing ::=
simple_slicing | extended_slicing

simple_slicing ::=
primary "[" short_slice "]"

extended_slicing ::=
primary "[" slice_list "]"

slice_list ::=
slice_item ("," slice_item)* [","]

slice_item ::=
expression | proper_slice | ellipsis

proper_slice ::=
short_slice | long_slice

short_slice ::=
[lower_bound] ":" [upper_bound]

long_slice ::=
short_slice ":" [stride]

lower_bound ::=
expression

upper_bound ::=
expression

stride ::=
expression

ellipsis ::=
"..."

call ::=
primary "(" [argument_list [","]] ")"
primary "(" [argument_list [","] |
test genexpr_for ] ")"

argument_list ::=
positional_arguments ["," keyword_arguments]
["," "*" expression]
["," "**" expression]
| keyword_arguments ["," "*" expression]
["," "**" expression]
| "*" expression ["," "**" expression]
| "**" expression

positional_arguments ::=
expression ("," expression)*

keyword_arguments ::=
keyword_item ("," keyword_item)*

keyword_item ::=
identifier "=" expression

power ::=
primary ["**" u_expr]

u_expr ::=
power | "-" u_expr
| "+" u_expr | "~" u_expr

m_expr ::=
u_expr | m_expr "*" u_expr
| m_expr "//" u_expr
| m_expr "/" u_expr
| m_expr "\%" u_expr

a_expr ::=
m_expr | a_expr "+" m_expr
| a_expr "-" m_expr
39

shift_expr ::=
a_expr
| shift_expr ( "<<" | ">>" ) a_expr

and_expr ::=
shift_expr | and_expr ";SPMamp;" shift_expr

xor_expr ::=
and_expr | xor_expr " extasciicircum" and_expr

or_expr ::=
xor_expr | or_expr "|" xor_expr

comparison ::=
or_expr ( comp_operator or_expr )*

comp_operator ::=
"<" | ">" | "==" | ">=" | "<=" | "" | "!="
| "is" ["not"] | ["not"] "in"

expression ::=
or_test | lambda_form

or_test ::=
and_test | or_test "or" and_test

and_test ::=
not_test | and_test "and" not_test

not_test ::=
comparison | "not" not_test

lambda_form ::=
"lambda" [parameter_list]: expression

expression_list ::=
expression ( "," expression )* [","]

simple_stmt ::= expression_stmt
| assert_stmt
| assignment_stmt
| augmented_assignment_stmt
| pass_stmt
| del_stmt
| print_stmt
| return_stmt
| yield_stmt
| raise_stmt
| break_stmt
| continue_stmt
| import_stmt
| global_stmt
| exec_stmt

expression_stmt ::=
expression_list

assert_stmt ::=
"assert" expression ["," expression]

assignment_stmt ::=
(target_list "=")+ expression_list

target_list ::=
target ("," target)* [","]

target ::=
identifier
| "(" target_list ")"
| "[" target_list "]"
| attributeref
| subscription
| slicing

augmented_assignment_stmt ::=
target augop expression_list

augop ::=
"+=" | "-=" | "*=" | "/=" | "\%=" | "**="
45
| ">>=" | "<<=" | "&=" | " extasciicircum=" | "|="

pass_stmt ::=
"pass"

del_stmt ::=
"del" target_list

print_stmt ::=
"print" ( optionalexpression ("," expression)* optional","
| ">code>" expression
optional("," expression)+ optional"," )

return_stmt ::=
"return" [expression_list]

yield_stmt ::=
"yield" expression_list

raise_stmt ::=
"raise" [expression ["," expression
["," expression]]]

break_stmt ::=
"break"

continue_stmt ::=
"continue"

import_stmt ::=
"import" module ["as" name]
( "," module ["as" name] )*
| "from" module "import" identifier
["as" name]
( "," identifier ["as" name] )*
| "from" module "import" "(" identifier
["as" name]
( "," identifier ["as" name] )* [","] ")"
| "from" module "import" "*"

module ::=
(identifier ".")* identifier

global_stmt ::=
"global" identifier ("," identifier)*

exec_stmt ::=
"exec" expression
["in" expression ["," expression]]

compound_stmt ::=
if_stmt
| while_stmt
| for_stmt
| try_stmt
| funcdef
| classdef

suite ::=
stmt_list NEWLINE
| NEWLINE INDENT statement+ DEDENT

statement ::=
stmt_list NEWLINE | compound_stmt

stmt_list ::=
simple_stmt (";" simple_stmt)* [";"]

if_stmt ::=
"if" expression ":" suite
( "elif" expression ":" suite )*
["else" ":" suite]

while_stmt ::=
"while" expression ":" suite
["else" ":" suite]

for_stmt ::=
"for" target_list "in" expression_list
":" suite
["else" ":" suite]

try_stmt ::=
try_exc_stmt | try_fin_stmt

try_exc_stmt ::=
"try" ":" suite
("except" [expression
["," target]] ":" suite)+
["else" ":" suite]

try_fin_stmt ::=
"try" ":" suite
"finally" ":" suite

funcdef ::=
[decorators] "def" funcname "(" [parameter_list] ")"
":" suite

decorators ::=
decorator+

decorator ::=
"@" dotted_name ["(" [argument_list [","]] ")"] NEWLINE

dotted_name ::=
identifier ("." identifier)*

parameter_list ::=
(defparameter ",")*
(~~"*" identifier [, "**" identifier]
| "**" identifier
| defparameter [","] )

defparameter ::=
parameter ["=" expression]

sublist ::=
parameter ("," parameter)* [","]

parameter ::=
identifier | "(" sublist ")"

funcname ::=
identifier

classdef ::=
"class" classname [inheritance] ":"
suite

inheritance ::=
"(" expression_list ")"

classname ::=
identifier

file_input ::=
(NEWLINE | statement)*

interactive_input ::=
[stmt_list] NEWLINE | compound_stmt NEWLINE

eval_input ::=
expression_list NEWLINE*

input_input ::=
expression_list NEWLINE