1. comment ::= "#" #(char end_of_line).

        # This is a comment

2. object ::= numeric | string | list | dictionary | tuple.
3. numeric ::= integer | long | float | octal | hex | complex.
4. integer ::= digit #(digit).
5. long ::= integer ("l" | "L").

        123L

        9999999999l

6. exponential ::= integer O("." integer) ("e" | "E") O(sign) integer.

        6e10

        9.9E-20

7. float ::= integer "." integer | exponential.

        123.0

        4E90

8. sign ::= "+" | "-".
9. octal ::= "0" N("0",7").

        0176

10. hex ::= ("0x" | "0X") N(hexadecimal).

        0x4af

11. complex ::= O((integer | float) sign) (integer | float) ("j" | "J").

        1+2j

        3J

        5.5-1.1j

12. string ::= (single_quote | double_quotes | triple_quotes) #(char) O(raw_string) (single_quote | double_quotes | triple_quotes).
13. single_quote ::= "\".
14. double_quotes ::= "\"".
15. triple_quotes ::= "\"\"\"".

        This is a string.

        "This is also a string."

        """This is a

        triple-quoted string."""

Notice the last line: Pythons triple-quoted string constant form. Python collects all the lines in the quoted block and concatenates them in a single multiline string, putting an end-of-line character ("\012") between each line. Note that "\012" is an octal integer.

16. raw_string ::= "\newline" | "\n" | "\\" | "\" | "\"" | "\a" | "\b" | "\e" | "\000" | "\v" | "\t" | "\r" | "\f" | "\0" octal_value | "\x" hex_value.
17. list ::= "[" #(object) "]".

        []                          #an empty list

        [1, 2, 3]

        [a, [b, c] ]     #nesting

You can think of Python lists as arrays of pointers in C because lists only store references to other objects, not the copy of the objects. For example:

        L1 = [hi, hello, yo]

        L2 = L1

In this case, if you make any changes to L1, it will also effect L2 because L2 is a reference of L1 (in another word, L2 is pointing to L1).

18. dictionary ::= "{" #(object colon object "}".

        {}                                                #an empty dictionary

        {a: 1, b: 2}

        {rose: {red: 1, black: 2} }     #nesting

Note that Pyhon dictionary is implemented as hash tables. Like lists, dictionaries only store object references (not copies).

19. tuple ::= "(" ) L(object) ")" | L(object).

where L(x) ::= empty | x "," | x "," x #("," x).

        ()                            #an empty tuple

        (0,)                         #a one-item tuple (not an expression)

        (a, (b, c) )       #nesting

Notice the second line here. If you really want a one-item tuple, you need to put a comma after the single item, before the closing parenthesis, to tell Python that it is not a simple expression.

In some cases, Python allows us to omit the parentheses for a tuple where it is not syntactically ambiguous. For example:

        T1 = 1, 2, 3, 4        #an example of an assignment statement

Although, the parentheses are optional, it is easier to use them every time than to figure out when they are optional.

Note that tuples work exactly the same way as lists, however, they cannot grow or shrink like lists.

20. operator ::= arithmetic | relational | boolean | string_op | bitwise_op.
21. arithmetic ::= "+" | "-" | "*" | "/" | "**" | "%".

** computes an exponential number.

% computes a division remainder.

        2**3 = 8     #same as 2³

        5%2 = 1

22. relational ::= "<" | ">" | "<=" | ">=" | "==" | "<>" | "!=".
23. boolean ::= "and" | "or" | "not".
24. string_op ::= "+" | "*" | "%".

+ is used to concatenate strings.

* is used to repeat strings.

% is used to format strings.

        'I am a ' + 'student'                                # 'I am a student'

        'Hello' * 3                                             #same as HelloHelloHello

        '%d %s %d you %' (99, 'beer', 4)        # 99 beer 4 you

25. bitwise_op ::= "|" | "^" | "&" | "<<" | ">>" | "~".
26. variable_name ::= (underscore | letter) #(underscore | letter | digit).

Variable names must start with an underscore or letter, and be followed by any number of underscores, letters, or digits. Python variable names are case-sensitive (names z and Z are two different variables). For example:

_flag                # a legal name

flag                 # a legal name

4_flag             # not a legal name

flag$               # not a legal name

@!#               # not a legal name

Names that you define cannot be the same as reserved words.

27. reserved_word ::= "and" | "assert" | "break" | "class" | "continue" | "def" | "del" | "elif" | "else" | "except" | "exec" | "finally" | "for" | "from" | "global" | "if" | "import" | "in" | "is" | "lambda" | "not" | "or" | "pass" | "print" | "raise" | "return" | "try" | "while".

 

1. statement ::= assignment_statement | expression_statement | print_statement | if_statement | loop_statement.
2. assignment_statement ::= variable_name O("=" variable_name) "=" object.

Assignment statement stores references to objects in variable names or data structure slots.

        hello = 'Hello World'                #Basic form

        today, tomorrow = 13, 14        #Tuple assignment

        lunch = dinner = 'junk food'     #Multiple-target

In the second line, name today is assigned to integer 13, and name tomorrow is bound to integer 14. In the last line, names lunch and dinner are both assigned a reference to the string junk food.

3. expression_statement ::= basic_expression | function_call | method_call | interactive_print | compound_expression | range_test.
4. basic_expression ::= (variable_name | object) operator (variable_name | object).

        1 + 1

        'Hello' + 'World'

        a == b

5. function_call ::= function_name "(" L(variable_name | object) ")".

        play()

        len(d3,d4)

6. method_call ::= object "." method_name "(" L(variable_name | object) ")".

        x.run()

        L.append(L)

7. compound_expression ::= basic_expression N(operator basic_expression) | range_test.

        tom < dan and dan == john

8. range_test ::= (variable_name | object) "<" (variable_name | object) "<" (variable_name | object).

        A < B < C         #tests whether B is between A and C

9. print_statement ::= "print" O(space (variable_name | object | basic_expression) #(comma ("+" | "*") (variable_name | object | basic_expression) ) ).

        >>> print "What sup world"

        "What sup world"

        >>> print "How", "are", "you?"

        "How are you"

        >>> print "a" + "b"

        ab

10. if_statement ::= "if" test_condition colon end_of_line block #(elif_clause) O(else_clause).

Here is a general form of an if statement:

        if <test1>:

                <statements1>

        elif <test2>:         #any number of elif

                <statements2>

        else:                    #optional else

                <statements3>

For example:

        >>> x = 0

        >>> if x == 1:

       ...          print true

       ... elif x == 0:

       ...          print false

       ... else:

       ...          print x

       ...

        false

11. test_condition ::= relational_expression | boolean_expression.
12. block ::= N(indent statement).
13. indent ::= N(space | tab).
14. elif_clause ::= "elif" test_condition colon end_of_line block.
15. else_clause ::= "else" colon end_of_line block.
16. relational_expression ::= (variable_name | object) relational (variable_name | object).

        A > B

        C != D

17. boolean_expression ::= (variable_name | object) boolean (variable_name | object).

        A and B

        C or D

18. loop_statement ::= while_statement | for_statement.
19. while_statement ::= "while" test_condition colon end_of_line block O(else_clause).

Here is a general form of a while statement:

        while <test>:

                <statements1>

        else: #optional

                <statements2>

For example:

        >>> x = 0; y =10

        >>> while x < y:

       ...          print x,

       ...          x = x +1

       ...

        0 1 2 3 4 5 6 7 8 9

20. for_statement ::= "for" variable_name "in" object colon end_of_line block O(else_clause).

Here is a general form of a for statement:

for <target> in <object>:

        <statements1>

else: #optional

        <statements2>

For example:

>>> total = 0

>>> for x in [1, 2, 3, 4, 5]:

...         total = total + x

...

>>> total

15