Python 3.4 Grammar

Top level symbols:

single_input
file_input
eval_input

	NEWLINE
\|	simple_stmt
\|	compound_stmt NEWLINE

file_input ::=

( NEWLINE | stmt )* ENDMARKER

eval_input ::=

testlist ( NEWLINE )* ENDMARKER

decorator ::=

@ dotted_name ( ( ( argslist )? ) )? NEWLINE

decorators ::=

( decorator )+

decorated ::=

decorators ( classdef | funcdef )

funcdef ::=

def NAME parameters ( -> test )? : suite

parameters ::=

( ( typedargslist )? )

typedargslist ::=

tfpdef ( = test )? ( , tfpdef ( = test )? )* ( , ( other_typedargs )? )?

other_typedargs ::=

	* ( tfpdef )? ( , tfpdef ( = test )? )* ( , ** tfpdef )?
\|	** tfpdef

tfpdef ::=

NAME ( : test )?

varargslist ::=

vfpdef ( = test )? ( , vfpdef ( = test )? )* ( , ( other_varargs )? )?

other_varargs ::=

	* ( vfpdef )? ( , vfpdef ( = test )? )* ( , ** vfpdef )?
\|	** vfpdef

vfpdef ::=

NAME

stmt ::=

simple_stmt | compound_stmt

simple_stmt ::=

small_stmt ( ; small_stmt )* ( ; )? NEWLINE

small_stmt ::=

expr_stmt ::=

testlist_star_expr ( augassign ( yield_expr | testlist ) | ( = ( yield_expr | testlist_star_expr ) )* )

testlist_star_expr ::=

( test | star_expr ) ( , ( test | star_expr ) )* ( , )?

augassign ::=

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

del_stmt ::=

del exprlist

pass_stmt ::=

pass

flow_stmt ::=

break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt

break_stmt ::=

break

continue_stmt ::=

continue

return_stmt ::=

return ( testlist )?

yield_stmt ::=

yield_expr

raise_stmt ::=

raise ( test ( from test )? )?

import_stmt ::=

import_name | import_from

import_name ::=

import dotted_as_names

import_from ::=

import_as_name ::=

NAME ( as NAME )?

dotted_as_name ::=

dotted_name ( as NAME )?

import_as_names ::=

import_as_name ( , import_as_name )* ( , )?

dotted_as_names ::=

dotted_as_name ( , dotted_as_name )*

dotted_name ::=

NAME ( . NAME )*

global_stmt ::=

global NAME ( , NAME )*

nonlocal_stmt ::=

nonlocal NAME ( , NAME )*

assert_stmt ::=

assert test ( , test )?

compound_stmt ::=

if_stmt ::=

if test : suite ( elif test : suite )* ( else : suite )?

while_stmt ::=

while test : suite ( else : suite )?

for_stmt ::=

for exprlist in testlist : suite ( else : suite )?

try_stmt ::=

try : suite ( ( except_clause : suite )+ ( else : suite )? ( finally : suite )? | finally : suite )

with_stmt ::=

with with_item ( , with_item )* : suite

with_item ::=

test ( as expr )?

except_clause ::=

except ( test ( as NAME )? )?

suite ::=

	simple_stmt
\|	NEWLINE INDENT ( stmt )+ DEDENT

test ::=

	or_test ( if or_test else test )?
\|	lambdef

test_nocond ::=

or_test | lambdef_nocond

lambdef ::=

lambda ( varargslist )? : test

lambdef_nocond ::=

lambda ( varargslist )? : test_nocond

or_test ::=

and_test ( or and_test )*

and_test ::=

not_test ( and not_test )*

not_test ::=

	not not_test
\|	comparison

comparison ::=

expr ( comp_op expr )*

comp_op ::=

< | > | == | >= | <= | <> | != | in | not in | is | is not

star_expr ::=

* expr

expr ::=

xor_expr ( | xor_expr )*

xor_expr ::=

and_expr ( ^ and_expr )*

and_expr ::=

shift_expr ( & shift_expr )*

shift_expr ::=

arith_expr ( ( << | >> ) arith_expr )*

arith_expr ::=

term ( ( + | - ) term )*

term ::=

factor ( ( * | / | % | // ) factor )*

factor ::=

	( + \| - \| ~ ) factor
\|	power

power ::=

atom ( trailer )* ( ** factor )?

atom ::=

	( ( yield_expr \| testlist_comp )? )
\|	[ ( testlist_comp )? ]
\|	{ ( dictorsetmaker )? }
\|	NAME
\|	NUMBER
\|	( STRING )+
\|	...
\|	None
\|	True
\|	False

testlist_comp ::=

( test | star_expr ) ( comp_for | ( , ( test | star_expr ) )* ( , )? )

trailer ::=

	( ( argslist )? )
\|	[ subscriptlist ]
\|	. NAME

subscriptlist ::=

subscript ( , subscript )* ( , )?

subscript ::=

	test
\|	( test )? : ( test )? ( sliceop )?

sliceop ::=

: ( test )?

exprlist ::=

( expr | star_expr ) ( , ( expr | star_expr ) )* ( , )?

testlist ::=

test ( , test )* ( , )?

dictorsetmaker ::=

	( test : test ( comp_for \| ( , test : test )* ( , )? ) )
\|	test ( comp_for \| ( , test )* ( , )? )

classdef ::=

class NAME ( ( ( argslist )? ) )? : suite

argslist ::=

( argument , )* ( argument ( , )? | other_args )

other_args ::=

	* test ( , argument )* ( , ** test )?
\|	** test

argument ::=

	test ( comp_for )?
\|	test = test

comp_iter ::=

comp_for | comp_if

comp_for ::=

for exprlist in or_test ( comp_iter )?

comp_if ::=

if test_nocond ( comp_iter )?

yield_expr ::=

yield ( yield_arg )?

yield_arg ::=

	from test
\|	testlist