+, -, *, /, %, **

/ always returns a float; the // operator performs a floor division.

+, *

mylist = [1, 2, 3, 4]

Lists can contain items of different types (other lists as well). Can be indexed and sliced.

mylist[1] = 0

Items can be assigned (lists are mutable) and added to the list (with the .append() method).

t3 = 1, 2, 'three'
t1 = 1, # Only one element
t0 = () # Empty tuple

Tuples are immutable collections of heterogenous elements. Can be indexed and unpacked.

items = set('one', 'two', 'three')
empty = set()

Sets are unordered collections of unique elements (duplicates are removed). Sets support union, intersection, difference and symmetric difference operations.

Set comprehension is available.

people = {'Wolf': 45, 'Gunnar': 23, 'Agamennonis': 60}

Dictionaries collect key, value pairs. Each item can be accessed by its key (a key can be any immutable type, and must by unique).

Dictionaries support the del statement.

The method keys() returns the keys, the method values() returns the values and the method items() returns both.

if <condition>:
    ...
elif <condition>:
    ...
else:
    ...

The if ... else construct allows to evaluate a condition and, if it evaluates to True, execute the corresponding block of code; otherwise, the else block of code is executed.

Note: There can be zero or more elif statements, and the else one is optional.

match <expression>:
    case <pattern1.a | pattern2.b>:
        ...
    case <pattern2>:
        ...
    case _:
        ...

The match statement compares an expression against a set of patterns; if a pattern matches, the code associated to the matching case is executed. _ is used as a wildcard pattern (it always matches).

Patterns can mix literals and variables, which will be binded and later used in the block of code.

case <pattern> if <condition>

Patterns supports an optional if clause (which condition must evaluate to True for the pattern to match).

Note: patterns can be seen as something similar to what is put on the left hand side of an assignement.

while <condition>:
    ...

While loops do something until the condition evaluates to True.

for <var> in <sequence>:
    ...

The for loop iterates over the items of any sequence. The range() function comes in handy to generate a sequence of numbers.

The break statement interrupts the current (enclosing) loop. The continue statement skips to the next iteration.

The else clause can be also associated with for and while loops. It is executed after the last iteration of the loop in the loop is not preamturely interrupted.

It is possible to assign a default values to a parameter; if the call to the function omits to specify those arguments, the default values are used. Parameters with default values must follow the list of required paramenters.

Functions can be called using keyword arguments, in the form of keyword = value. Keyword arguments must follow positional arguments.

*<name> and/or **<name> are special catch-all parameters. In the *<name> form, <name> will receive a tuple containg all the positional arguments beyong the formal parameters list. Likewise, in the **<name> form <name> will receive a dictionary with all the keyword parameters beyond the list of formal parameters. If both *<name> and **<name> are present, that must be the order in which the would appear.

The * operator unpacks the elements from a list or a tuple. The ** does the same but on dictionaries.

lambda x, y: x + y

The lamba keyword creates an anonymous function, which is limited to a single expression.

f'Hello, my name is {name}'

Formatted strings allow to insert Python expressions inside {}. Optional fomatting specifier can follow the expression (es: :.3f).

'Total amount of noise is {:2.2%}'.format(noise)

str.format() allows detailed formatting directives inside the {} placeholders.

f = open('myfile', 'r')
...
f.close()

The open() method returns a file object. The arguments represent the file name and the mode the file is to be opened for; an optional encoding=... argument can be passed to the the function. The modes available for opening the file are: r, w, a (append), r+ (read and write). Appending a b to the mode force the file to be opened in binary mode (the default would be text mode).

with open('myfile', 'r') as f:
    ...

The with keyword is a convenient shortcut way to deal with file objects.

File content can be read as bytes (.read()), lines (.readline()) or as a whole (.readlines()).

Content can be written to a file with the .write() method, which accepts a string or a byte object.

The methods .tell() and .seek() can be used to report the current position in the file, and to move to a specific position respectively.

class MyObject:

  # A class variable
  prop = 'custom'

  def __init__(self, label):
    # An instance variable
    self.label = label

Class variables are defined at class level, and are shared between all instances of the class. Instance variables are defined inside class methods (usually inside the __init__() method), and are local to a specific instance.

class MyClass(BaseClass):
    ...

Classes support inheritance; all attributes and methods of the base class are available (just call BaseClass.method() or super().method()). The derived class can override base class methods.

Multiple inheritance is also supported.

All class attributes and methods are public. If something needs to be treated as private, it's name should be prefixed with _.

• os: for operating system interaction
• shutils: for daily files and directories management

• glob: make lists of files using wildcards

• sys: store command line arguments, handle input/output/error channels and manage program exit status
• argparse: process command line arguments

• re: regular expression tools

• math: floating-point math functions
• random: random selections
• statistics: basic statistical functions

• urllib.request: retrieve data from an URL
• smtplib: send emails

• datetime: manipulate dates and times

• zlib: handle compressed data archives

• timeit: tools to evaluate performance of blocks of code

• doctest: validate tests embedded in docstrings
• unittest: tools for test driven developmentk

• pprint: print objects in a readable way
• textwrap: format paragraphs of text

• struct: work with variable lenght binary records

• threading: tools for multi-threaded applications

• logging: logging system

• array: lists with only homogeneous data
• collection: alternative container datatypes

• decimal: decimal floating-point arithmetic