Notes for "Python in a Nutshell"

Introduction to Python

• Wrap C/C++ libraries into Python via Cython and CFFI.

• Python implementations for production quality:

  • CPython (Classic Python)

    • Implemented in C
    • Python Software Foundation License V2, compatible with GPL, proprietary, free, BSD/Apache/MIT.

  • Jython: on JVM

  • IronPython: support for .NET

  • PyPy: generate native machine code “just in time” when running the program. Thus it has substantial advantages in speed and memory management.

  • Pyston

• IPython

  • It enhances the standard CPython with more powerful and convenient interactive use.
  • Abbreviated function call syntax.
  • magics
  • shell escapes
  • Use ? to query object’s documentation.
  • IPython Notebook now renamed as the Jupyter Notebook.

• Anaconda distribution

  • It includes enormous number of preconfigured and tested modules.
  • It contains all the dependencies.

• Nuitka: a compiler which converts Python to C++.

The Python Language

Lexical structure

• Python statements don’t need ; to terminate.

• line continuation symbol: \.

• Blocks are defined via indentation. Use white space to indent instead of TAB.

• Language structure

  • Tokens

    • Identifiers: specify the name of a variable, function, class, module etc.
    • Keywords
    • Operators
    • Delimiters
    • Literals

  • Statements

    • Simple statements
    • Compound statements (as a block)

Data types

• Numbers

  • Integers

    • Decimal literal (no prefix): 1, 2, 3
    • Binary literal (0b prefix): 0b01001
    • Octal literal (0o prefix): 0o13
    • Hexadecimal literal (0x prefix): 0x17

  • Floating point numbers

  • Complex numbers: use $j$ as the imaginary unit.

• Sequences

  • Iterable concept (an abstract higher level than sequences)

    • All sequence types in Python are iterables, which represent linear data structure as the concepts commonly used in C++ generic programming.
    • An iterable is bounded, due to the limited computer memory.

  • Except string type, sequences in Python are neither simple arrays as in C, nor template-based containers which can include only one type of data as in C++. They are generic containers which can include any type of data.

  • Strings

    • A string in Python is a sequence of byte objects.

    • A string is an immutable sequence.

    • Triple-quoted string: a whole paragraph of strings can be directly quoted without the need of a line-continuation symbol \. This is the so-called "here-document" in Bash.

    • Raw string

      • Starts with r or R.
      • Escape characters are not interpreted.

  • Tuples

    • A tuple is an immutable ordered sequence of items.
    • Tuple literal with only one item needs a trailing comma.
    • Use parentheses to wrap a tuple literal.

    ()                    # Empty tuple literal
    (1,)                  # Singleton tuple literal
    (1, 'good', 3)        # Normal tuple literal
    tuple()               # Create an empty tuple.
    tuple(iterable)       # Create a tuple from an iterable.
    tuple('hello')        # Create a tuple from a string sequence, which is also an iterable.
    

  • Lists

    • A list is a mutable ordered sequence of items.
    • A singleton list literal does not need a trailing comma.
    • Use brackets to wrap a list literal.

    [2, 'a', 5]           # Normal list literal
    [100]                 # Singleton list literal
    []                    # Empty list literal
    list()                # Create an empty list.
    list(iterable)        # Create a list from an iterable.
    list('hello')         # Create a list from a string sequence, which is also an iterable.
    

• Sets

  • Unordered collections of unique items. This is consistent with the set concept in mathematics.

  • Two types of sets in Python

    • set (non-frozen set)

      • Mutable
      • Not hashable
      • frozenset can be an element of a set.

    • frozenset

      • Immutable
      • Hashable
      • frozenset can be an element of a frozenset.

  • Use braces to wrap a set literal.

    {5, 6, 'hello'}
    {10}
    # {}: Empty set literal is invalid.
    set()                       # Create an empty set from an iterable.
    set(iterable)               # Create a set from an iterable.
    frozenset()                 # Create an empty frozenset from an iterable.
    frozenset(iterable)         # Create a frozenset from an iterable.
    

• Dictionaries

  • The concept of mapping

    • Key-value pair
    • Mutable
    • Unordered

  • A collection of key/value pairs.

  • Keys in a dictionary

    • Can be different types
    • Hashable (therefore, a frozenset can be the data structure for keys in a dictionary.)

  • Values in a dictionary

    • Can be different types

    {'name':'Mary', 'gender':60}    # Normal dictionary literal
    {}                              # Empty dictionary literal
    dict()                          # Empty dictionary
    dict(name='Mary', gender=60)
    dict([('name', 'Mary'), ('gender', 60)])    # Dictionary constructed from a list of tuples.
    dict.fromkeys(iterable, value)
    

• None: a null object.

• Callables: functions

  • Built-in functions
  • User-defined functions
  • Types: which can be considered as the constructor of a class.
  • Methods

• Boolean

Sequence operations

Sequences in general

• len:to get the length of any container.

• max

• min

• sum

• +: the operators for concatenation of two sequences.

• S * n: a sequence multiplied by an integer, then the result sequence is the concatenation of n copies of S.

• x in S: test if the element x is in the sequence S.

• Sequence slicing

  • S[i:j]: N.B. the element S[j] is excluded.
  • S[i:j:k]: i is the starting index, j is the pass-the-end index, k is the stride.

Lists

x = [1, 2, 3, 4]
del x[1]                # Delete the 2nd element from x.
x[2:3] = []             # Delete the 3rd element from x.
x[2:2] = ['a','b']      # Insert a list ['a', 'b'] before the 2nd element.

Set operations

• Test membership: k in S

• Set methods

  • S.copy(): shallow copy of a set.

  • Common set operations

    • S1.intersection(S2)
    • S1.union(S2)
    • S1.difference(S2)
    • S1.symmetric_difference(S2): $\{x \vert x \notin S1 \cap S2\}$
    • S1.issubset(S2)
    • S1.issuperset(S2)

Dictionary operations

• Test membership: k in D

• Indexing a dictionary

  • Use key as the index

  d = {'1': 'hello', '2':'world'}
  d['1']
  d['2']
  

• Dictionary methods

  • D.copy(): shall copy of a dictionary.
  • D.get(k): get the value corresponding to the key k.
  • D.items(): returns an iterable of type dict_items.
  • D.keys(): returns an iterable of type dict_keys.
  • D.values(): returns an iterable of type dict_values.

Control flow statements

if statement

if predicate:
   statement
elif predicate:
   statement
...
else:
   statement

while statement

while expression:
   statement
   ...

for statement

# General form.
for element in iterable:
    statement
    ...
    
# Accept multiple values by unpacking the assignment.
for key, value in dict_items:
    statement
    ...

The usage of iterator in a for loop

# The equivalent formulation of the for loop using iterator.
# iter returns the iteration before the first item in the linear data.
current_iter = iter(iterable)
while True:
    # N.B. next first move the iterator to the next, then returns the object the iterator points to. When the iterator passes then end of the linear data, an exception StopIteration is raised.
    try: current_object = next(current_iter)
    except StopIteration: break
    
    print(current_object)

The usage of range in a for loop

range(start, stop, stride): the generated range does not include stop.

In v3, range returns an object similar to xrange in v2. Therefore, to obtain a normal list, the list function should be called:

# Generate a normal list from a range.
list(range(1, 11))

List comprehension

It is used for generating a list by iterating through a list and performing some operations if some condition is satisfied.

my_list = list(range(1, 11))
print([x + 1 for x in my_list])
print([x + 1 for x in my_list if x >= 5])
my_list_of_sublists = [list(range(1, 6)), list(range(5, 11)), list(range(10, 16))]
print([x + 1 for sublist in my_list_of_sublists for x in sublist])

Set comprehension

Similar as the list comprehension, but use bracket to wrap the resulting set.

Dictionary comprehension

Similar as the set comprehension, but the returned element should be a pair.

Functions

• Functions are objects in Python.

def function_name(parameters):
    function body
    ...

Parameters

• The names of parameters exist in the function's local namespace.

• Types of parameters

  • Positional parameters: mandatory parameters.

  • Named parameters: optional parameters.

    • Declaration in the function signature: identifier = expression
    • The default value assigned to a named parameter is only initialized once in a Python program.
    • If the default value assigned to a named parameter is a mutable, its value can be changed inside the function body.

  • Special forms

    • *args: it is used to collect any extra positional arguments into a tuple.
    • **kwds: it is used to collect any extras named arguments into a dictionary.

  • Keyword-only parameters (V3)

    • When the function is called, keyword-only parameters must appear in the form of "identifier = expression", otherwise they should not appear.
    • They come between *args and **kwds. If there is no *args, a * should be used as a placeholder.
    • They can be specified in the parameter list with or without a default value. Then, the former is mandatory parameters and the latter is an optional parameters.

Attributes of function objects

• __name__: identifier stringed the function name.
• __defaults__: a tuple of the optional parameters, if there are any.
• __doc__: docstring of the function. Use triple-quotation for the docstring.

Namespaces

• global: it is used to declare a name to be used is in the global name space.
• nonlocal (v3 only): it is used to declare a name to be searched in the lexical scope.
• Nested function can access values from outer local variables, which is known as a closure. In this way, a function can be dynamically constructed depending on some variables.

Lambda expressions

It is useful for creating a simple function on-the-fly.

lambda parameters: expression

Recursion

Python dose not implement the tail-recursion as in List or Scheme.