a_expr
	m_expr | a_expr "+" m_expr | a_expr "-" m_expr

and_expr
	shift_expr | and_expr "&" shift_expr

and_test
	not_test | and_test "and" not_test

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

assert_stmt
	"assert" expression ["," expression]

assignment_stmt
	(target_list "=")+ (expression_list | yield_expression)

atom     
	identifier | literal | enclosure

attributeref
	primary "." identifier

augmented_assignment_stmt
	augtarget augop (expression_list | yield_expression)

augop                    
	"+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
	| ">>=" | "<<=" | "&=" | "^=" | "|="

augtarget                
	identifier | attributeref | subscription | slicing

bindigit      
	"0" | "1"

bininteger    
	"0" ("b" | "B") bindigit+

break_stmt
	"break"

bytesescapeseq
	"\" <any ASCII character>

bytesliteral  
	bytesprefix(shortbytes | longbytes)

bytesprefix   
	"b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"

call                
	primary "(" [argument_list [","] | comprehension] ")"

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

classname  
	identifier

comp_for     
	"for" target_list "in" or_test [comp_iter]

comp_if      
	"if" expression_nocond [comp_iter]

comp_iter    
	comp_for | comp_if

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

comparison   
	or_expr ( comp_operator or_expr )*

compound_stmt
	if_stmt
	| while_stmt
	| for_stmt
	| try_stmt
	| with_stmt
	| funcdef
	| classdef

comprehension
	expression comp_for

conditional_expression
	or_test ["if" or_test "else" expression]

continue_stmt
	"continue"

decimalinteger
	nonzerodigit digit* | "0"+

decorator     
	"@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE

decorators    
	decorator+

defparameter  
	parameter ["=" expression]

del_stmt
	"del" target_list

dict_comprehension
	expression ":" expression comp_for

dict_display      
	"{" [key_datum_list | dict_comprehension] "}"

digit         
	"0"..."9"

dotted_name   
	identifier ("." identifier)*

enclosure
	parenth_form | list_display | dict_display | set_display
	| generator_expression | yield_atom

eval_input
	expression_list NEWLINE*

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

exponentfloat
	(intpart | pointfloat) exponent

expression            
	conditional_expression | lambda_form

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

expression_nocond     
	or_test | lambda_form_nocond

expression_stmt
	expression_list

feature         
	identifier

file_input
	(NEWLINE | statement)*

floatnumber  
	pointfloat | exponentfloat

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

fraction     
	"." digit+

funcdef       
	[decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite

funcname      
	identifier

future_statement
	"from" "__future__" "import" feature ["as" name]
	("," feature ["as" name])*
	| "from" "__future__" "import" "(" feature ["as" name]
	("," feature ["as" name])* [","] ")"

generator_expression
	"(" expression comp_for ")"

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

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

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

id_continue 
	<all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>

id_start    
	<all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>

identifier  
	xid_start xid_continue*

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

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

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

inheritance
	"(" [parameter_list] ")"

integer       
	decimalinteger | octinteger | hexinteger | bininteger

interactive_input
	[stmt_list] NEWLINE | compound_stmt NEWLINE

intpart      
	digit+

key_datum         
	expression ":" expression

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

keyword_arguments   
	keyword_item ("," keyword_item)*

keyword_item        
	identifier "=" expression

lambda_form       
	"lambda" [parameter_list]: expression

lambda_form_nocond
	"lambda" [parameter_list]: expression_nocond

list_display
	"[" [expression_list | comprehension] "]"

literal
	stringliteral | bytesliteral
	| integer | floatnumber | imagnumber

longbytes     
	"'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'

longbyteschar 
	<any ASCII character except "\">

longbytesitem 
	longbyteschar | bytesescapeseq

longstring     
	"'''" longstringitem* "'''" | '"""' longstringitem* '"""'

longstringchar 
	<any source character except "\">

longstringitem 
	longstringchar | stringescapeseq

lower_bound 
	expression

m_expr
	u_expr | m_expr "*" u_expr | m_expr "//" u_expr | m_expr "/" u_expr
	| m_expr "%" u_expr

module         
	(identifier ".")* identifier

name
	identifier

nonlocal_stmt
	"nonlocal" identifier ("," identifier)*

nonzerodigit  
	"1"..."9"

not_test
	comparison | "not" not_test

octdigit      
	"0"..."7"

octinteger    
	"0" ("o" | "O") octdigit+

or_expr 
	xor_expr | or_expr "|" xor_expr

or_test 
	and_test | or_test "or" and_test

parameter     
	identifier [":" expression]

parameter_list
	(defparameter ",")*
	( "*" [parameter] ("," defparameter)* ["," "**" parameter]
	| "**" parameter
	| defparameter [","] )

parenth_form
	"(" [expression_list] ")"

pass_stmt
	"pass"

pointfloat   
	[intpart] fraction | intpart "."

positional_arguments
	expression ("," expression)*

power
	primary ["**" u_expr]

primary
	atom | attributeref | subscription | slicing | call

proper_slice
	[lower_bound] ":" [upper_bound] [ ":" [stride] ]

raise_stmt
	"raise" [expression ["from" expression]]

relative_module
	"."* module | "."+

return_stmt
	"return" [expression_list]

set_display
	"{" (expression_list | comprehension) "}"

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

shortbytes    
	"'" shortbytesitem* "'" | '"' shortbytesitem* '"'

shortbyteschar
	<any ASCII character except "\" or newline or the quote>

shortbytesitem
	shortbyteschar | bytesescapeseq

shortstring    
	"'" shortstringitem* "'" | '"' shortstringitem* '"'

shortstringchar
	<any source character except "\" or newline or the quote>

shortstringitem
	shortstringchar | stringescapeseq

simple_stmt
	expression_stmt
	| assert_stmt
	| assignment_stmt
	| augmented_assignment_stmt
	| pass_stmt
	| del_stmt
	| return_stmt
	| yield_stmt
	| raise_stmt
	| break_stmt
	| continue_stmt
	| import_stmt
	| global_stmt
	| nonlocal_stmt

slice_item  
	expression | proper_slice

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

slicing     
	primary "[" slice_list "]"

statement    
	stmt_list NEWLINE | compound_stmt

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

stride      
	expression

stringescapeseq
	"\" <any source character>

stringliteral  
	[stringprefix](shortstring | longstring)

stringprefix   
	"r" | "u" | "R" | "U"

subscription
	primary "[" expression_list "]"

suite        
	stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT

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

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

try1_stmt
	"try" ":" suite
	("except" [expression ["as" target]] ":" suite)+
	["else" ":" suite]
	["finally" ":" suite]

try2_stmt
	"try" ":" suite
	"finally" ":" suite

try_stmt 
	try1_stmt | try2_stmt

u_expr
	power | "-" u_expr | "+" u_expr | "~" u_expr

upper_bound 
	expression

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

with_item
	expression ["as" target]

with_stmt
	"with" with_item ("," with_item)* ":" suite

xid_continue
	<all characters in id_continue whose NFKC normalization is in "id_continue*">

xid_start   
	<all characters in id_start whose NFKC normalization is in "id_start xid_continue*">

xor_expr
	and_expr | xor_expr "^" and_expr

yield_atom      
	"(" yield_expression ")"

yield_expression
	"yield" [expression_list | "from" expression]

yield_stmt
	yield_expression