# truncate the sequence to the length of the shortest input sequence
zip(seq_1, seq_2, ...) # -> zip object (tuple generator)
# LIST COMPREHENSIONS
var = [expression for element in sequence if condition] # create list from pre-existing list (instead of map, filter, reduce) applying any manipulations
# expression can be lambda, if is optional
var = [expression if condition else statement for element in sequence] # list comprehension with IF-ELSE
var = [expression_1 for element in [expression_2 for element in sequence]] # nested list comprehension
var = [(exp_1, exp_2) for item_1 in seq_1 for item_2 in seq_2] # -> [(..., ...), (..., ...), ...]
```
## Tuple
```py
# TUPLES CANNOT BE MODIFIED
tuple = (69, 420, 69, 'abc') # tuple assignment
tuple = (44,) # single element tuples need a comma
# break, continue, return in block while do not perform else block
# code here
```
### `for`
```py
for index in sequence: # sequence can be a list, set, tuple, etc ..
# code here
else:
# executed only if for reaches the end of the loop
# break, continue, return in block for do not perform else block
# code here
for index in range (start, end, step):
# code here
for key, value in dict.items ():
# code here
```
### `break` & `continue`
`break`: causes the loop to exit immediately without executing subsequent iterations
`continue`: skip the remaining iteration statements and continue the loop
### `range`
```py
range(start, end, step) # generate sequence num integers (does not include num stops) with possible step
list(range(start, end, step)) # return sequence of integers in a list
```
### `enumerate`
```py
enumerate(iterable) # iterable of item & index pairs
list(enumerate(iterable)) # returns list of tuples [(1, iterable [0]), (2, iterable [1]), (3, iterable [2])]
```
### `zip`
```py
list_1 = [1, 2, 3, 4, 5]
list_2 = ['a', 'b', 'c', 'd', 'e']
zip(list_1, list_2) # return zip object
list(zip(list_1, list_2)) # returns list of tuples by merging list [(list_1 [0], list_2 [0]), (list_1 [1], list_2 [1]), ...]
```
### `shuffle` & `randint`
```py
from random import shuffle, randint
shuffle(iterable) # shuffle the list
randint(start, end) # returns a random integer between start and end
```
### `in`
```py
item in iterable # check for the presence of item in iterable (returns True or False)
```
## Functions
### Function Definition
```py
def function_name (parameters):
"" "DOCSTRING" ""
# code here
return expression # if return id missing the function returns None
```
### Specify Type Parameters In Functions
- parameters before `/` can only be *positional*
- parameters between `/` and `*` can be *positional* or *keyworded*
- parameters after `*` can only be *keyworded*
```py
def func (a, b, /, c, d, *, e, f):
# code here
```
### Docstring Style
```py
"""function description
Args:
argument: Type - description of the parameter
Returns:
Type - description of <expr>
Raises:
Exception: Cause of the exception
"""
```
### *args **kwargs
`*args` allows the function to accept a variable number of parameters (parameters stored in a tuple)
`**kwargs` allows the function to accept a variable number of key-value parameters (parameters stored in a dictionary)
When used in combination `*args` always goes before`**kwargs` (in def function and in function call)
```py
def func(*args, **kwargs):
# code here
```
### Function with default parameters
```py
def function(parameter1 = value1, parameter2 = value3): # default values in case of omitted use of arguments in the call
# code here
return expression
function(parameter2 = value2, parameter1 = value1) # arguments passed with keyword to enforce the order of reference
```
### Global And Local Variables
```py
# global scope
def external_func():
# enclosing local scope
def internal_func():
# local scope
```
**LEGB Rule**:
- **L** - **Local**: Names assigned in any way within a function (`def` or `lambda`), and not declared global in that function.
- **E** - **Enclosing function locals**: Names in the local scope of any and all enclosing functions (`def` or `lambda`), from inner to outer.
- **G** - **Global** (module): Names assigned at the top-level of a module file, or declared global in a def within the file.
- **B** - **Built-in** (Python): Names preassigned in the built-in names module : `open`, `range`, `SyntaxError`,...
`Note`: variables declared inside a function are not usable outside
```py
def function():
# global statement makes a variable global
# actions on global variable within the function also have an effect outside
global variable
```
### Iterables, Iterators & Generators
**Iterable**: object implementing `__iter __()`, sequences and objects supporting `__getitem__` with index `0`
**Iterator**: object implementing `__next__` and `__iter__` (**iterator protocol**), when entirely consumed by `next()` it becomes unusable. Returns `StopIteration` when `next()` has returned all elements.
**Generator Function**: function with keyword `yield` (if present also `return` causes `StopIteration`), returns a generator that produces the values one at a time.
**Generator Factory**: generator returning function (may not contain `yield`).
Operation `iter()`:
- calls `__iter__()`
- in the absence of it python uses `__getitem__()` (if present) to create an iterator that tries to retrieve the items in order, starting from the index `0`
- on failure it returns `TypeError`
**Note**: `abc.Iterable` does not check for the presence of `__getitem__` to decide if a sub-object is a member therefore the best test for iterability is to use `iter()` and handle exceptions.
### `next()` & `iter()`
```py
next(iterable) # next item of the iterable or error StopIteration
iter(object) # get an iterator from an object
# call callable_onj.next () with no arguments as long as it returns non-sentinel values
iter(callable_obj, sentinel)
```
### Customs Generators
Used to generate a sequence of values to be used once (they are not stored)
```py
def custom_generator(parameters):
while condition: # or for loop
yield variable # returns the value without terminating the function, values passed to the caller without storing in a variable
# generator implementation
for item in custom_generator(parameters):
# code here
```
### Termination Generator And Exception Handling
```py
# raise exception at the suspension point and return generator value
# if the generator terminates without returning values it raises StopIteration
# if an exception is not handled it is propagated to the caller
The main function of `yield from` is to open a bidirectional channel between the external caller (* client *) and the internal * subgenerator * so that values and exceptions can pass between the two.
2. exhausted subgenerator returns value to `yield from <expr>` (`return <result>` statement)
3. delegating generator returns `<expr>` to client
- Any values that the subgenerator yields are passed directly to the caller of the delegating generator (i.e., the client code).
- Any values sent to the delegating generator using `send()` are passed directly to the subgenerator.
- If the sent value is `None`, the subgenerator's `__next__()` method is called.
- If the sent value is not `None`, the subgenerator's `send()` method is called.
- If the call raises `StopIteration`, the delegating generator is resumed.
- Any other exception is propagated to the delegating generator.
-`return <expr>` in a generator (or subgenerator) causes `StopIteration(<expr>)` to be raised upon exit from the generator.
- The value of the `yield from` expression is the first argument to the `StopIteration` exception raised by the subgenerator when it terminates.
- Exceptions other than `GeneratorExit` thrown into the delegating generator are passed to the `throw()` method of the subgenerator.
- If the call raises `StopIteration`, the delegating generator is resumed.
- Any other exception is propagated to the delegating generator.
- If a `GeneratorExit` exception is thrown into the delegating generator, or the `close()` method of the delegating generator is called, then the `close()` method of the subgenerator is called if it has one.
- If this call results in an exception, it is propagated to the delegating generator.
- Otherwise, `GeneratorExit` is raised in the delegating generator
```py
def sub_gen():
sent_input = yield
# result of sub_gen() returned to delegating_gen()
# result of yield from <expr>
return result
def delegating_gen(var):
var = yield from sub_gen() # get values from sub_gen
The `__slots__` attribute implements the **Flyweight Design Pattern**: it saves the instance attributes in a tuple and can be used to decrease the cost in memory by inserting only the instance variables into it (suppress the instance dictionary).
**Default**: attributes saved in a dictionary (`object .__ dict__`)
**Usage**: `__slots_ = [attributes]`
`__slots__` is not inherited by subclasses, it prevents dynamically adding attributes.
### Inner Classes
```py
class Class:
def __init__(self, parameters):
...
class InnerClass:
def __init__(self, parameters):
...
def method(self):
...
object_1 = Class(arguments) # create 'external' class
object_2 = Class.InnerClass(arguments) # inner class created as object of the 'external' class
```
### Special Methods
Special methods are defined by the use of double underscores; they allow the use of specific functions (possibly adapted) on the objects defined by the class.
```py
class Class():
def __init__(self, parameters):
instructions
# used by str() and print() method
# handle requests for impersonation as a string
def __str__ (self):
return expression # return required
def __len__ (self):
return expression # must return as len requires a length / size
def __del__ (self): # delete the class instance
instruction # any instructions that occur on deletion
object = Class()
len(object) # special function applied to an object
del object # delete object
```
#### Special Methods List
**Note**: if the operator cannot be applied, returns `NotImplemented`
# called when the instance is "called" as a function
# x (arg1, arg2, arg3) is short for x .__ call __ (arg1, arg2, arg3)
__call__(self, args)
# string object representation for the developer
__repr__(self)
# string object representation for user (used by print)
__str__(self)
# specify formatting for format ), str.format() [format_spec = format-mini-language]
__format__(format_spec)
# returns unique (integer) value for objects that have equal value
# __EQ__ MUST EXIST IN THE CLASS, usually hash((self.param_1, self.param_2, ...))
__hash__(self)
# makes object iterable:
# - returning self (in the iterator)
# - returning an iterator (in the iterable)
# - using yield (in the __iter__ generator)
__iter__(self)
# returns next available element, StopIteration otherwise (iterator scrolls)
__next__()
# returns truth value
__bool__()
# returns item associated with key of a sequence (self [key])
# IndexError if key is not appropriate
__getitem__(self, key)
# item assignment operation in sequence (self [key] = value)
# IndexError if key is not appropriate
__setitem__(self, key, value)
# operation deleting item in sequence (del self [key])
# IndexError if key is not appropriate
__delitem__(self, key)
# called by dict.__getitem__() to implement self [key] if key is not in the dictionary
__missing__(self, key)
# implement container iteration
__iter__(self)
# implement membership test
__contains__(self, item)
# implementation issublass (instance, class)
__instancecheck__(self, instance)
# implementation issubclass (subclass, class)
__subclasscheck__(self, subclass)
# implement attribute access (obj.name)
# called if AttributeError happens or if called by __getattribute __()
__getattr__(self, name)
# implement value assignment to attribute (obj.name = value)
__setattr__(self, name, value)
```
**Note**: Itearbility is tricky.
To make an object directly iterable (`for i in object`) `__iter__()` and `__next__()` are needed.
To make an iterable through an index (`for i in range(len(object)): object[i]`) `__getitem()__` is needed.
Some of the mixin methods, such as `__iter__()`, `__reversed__()` and `index()`, make repeated calls to the underlying `__getitem__()` method.
Consequently, if `__getitem__()` is implemented with constant access speed, the mixin methods will have linear performance;
however, if the underlying method is linear (as it would be with a linked list), the mixins will have quadratic performance and will likely need to be overridden.
### Inheritance
```py
class Parent ():
def __init __ (self, parameters):
...
def method_1(self):
...
def method_2(self):
...
class Child(Parent): # parent class in parentheses to inherit variables and methods
**Note**: python does not support method overloading
```py
# DUCKTYPING
# Working with objects regardless of their type, as long as they implement certain protocols
class Class1:
def method_1(self):
...
class Class2:
def method_1(self):
...
# since python is a dynamic language it doesn't matter what type (class) the object passed is
# the function invokes the object method passed regardless of the object class
def polymorph_method(object):
object.method_1()
# DEPENDENCY INJECTION WITH DUCKTYPING
class Class:
def __init__(self, object):
self.dependency = object
def method_1(self): # the function invokes the method of the object passed
self.dependency.method_1()
```
### Operator Overloading
**Operators fundamental rule**: *always* return an object, if operation fails return `NotImplemented`
Limitations of operator overloading:
- no overloading of built-in types
- no creation of new operators
- no overloading operators `is`, `and`, `or`, `not`
### Astrazione
The **interfaces** are abstract classes with *all* abstract methods, they are used to indicate which methods such as child classes *must* have. Interfaces have *only* a list of abstract methods.
**abstract classes** have *at least* one abstract method; child classes that inherit from an abstract class *must* implement abstract methods. Abstract classes *cannot* be instantiated.
Virtual subclasses are used to include third-party classes as subclasses of a class of their own. They are recognized as belonging to the parent class without however having to implement their methods.
The `@Class.register` or `Class.register(subclass)` decorators are used to mark subclasses.
```py
from abc import abstractmethod, ABC
class Abstract(ABC): # abstract class MUST INHERIT from parent class ABC
def __init__(self, parameters):
...
def parent_method (self):
...
@abstractmethod # abstract method MUST be marked with @abstractmethod decorator
def abstract_method (self):
pass
# abstract method MUST be overridden (can be non-empty)
def parent_method (self): # override method (child class with homonymous method to parent class)
...
def abstract_method (self): # implementation of abstract method inherited from abstract class (NECESSARY) by override
...
```
## Exception Handling
```py
# CHECK ASERATIONS
assert condition, 'error message' # if the assertion is false show an error message
# particular errors are objects of a particular class of exceptions which in turn is a child of the base exception class (exception)
class CustomExceptionError(Exception): # MUST somehow inherit from class exception (even in later inheritance steps)
pass # or instructions
# try block contains code that might cause an exception
# code inside try and after the error it is not executed
try:
...
raise CustomExceptionError ("message") # raise the exception
# except takes control of error handling without passing through the interpreter
# block executed if an error occurs in try
# except error specified by class
except ExceptionClass:
# Default error message is not shown
# the program does not stop
# except on generic errors
except:
# code here
# block executed if exception does not occur
else:
# code here
# block executed in all cases, cleanup code goes here
finally:
# code here
```
## File
### Opening A File
Text file opening mode:
-`w`: write, overwrite the contents of the file
-`r`: read, read file contents
-`a`: append, add content to the file
-`w +`: write & read
-`r +`: write & read & append
-`a +`: append & read
-`x`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
Open binary file mode:
-`wb`: write, overwrites the contents of the file
-`rb`: read, read file contents
-`ab`: append, add content to the file
-`w + b`: write & read
-`r + b`: write & read & append
-`a + b`: append & read
-`xb`: exclusive creation, if the file already exists -> `FileExistError` (extended write mode)
**Note**: Linux and MacOSX use `UTF-8` everywhere while windows uses `cp1252`, `cp850`,`mbcs`, `UTF-8`. Don't rely on default encoding and use **explicitly**`UTF-8`.
```py
object = open('filename', mode = 'r', encoding = 'utf-8') # encoding MUST BE utf-8 for compatibility
# filename can be the absolute path to the file location (default: file created in the source code folder)
# double slash to avoid \ escaping
with open('filename') as file:
instructions_to_file # block use filename to indicate file
# CLOSE A FILE
object.close()
# WRITE TO A FILE
object.write(string) # write single string to file
object.writelines(* strings) # write multiple strings to file
# READING FROM A FILE
object.read() # return ALL the contents of the file (including escape sequence) and place the "cursor" at the end of the file
object.seek(0) # returns 0 (zero) and places the cursor at the beginning of the file
object.readlines() # return list of file lines (ATTENTION: keep everything in memory, be careful with large files)
object.readline() # returns single line file
# CHECK FILE EXISTENCE
import os, sys
if os.path.isfile('filepath'): # check file existence (TRUE if it exists)
# code here
else:
# code here
sys.exit() # exits the program and does not execute the next cosice
```
## COPY
**SHALLOW COPY**: copies the "container" and references to the content
**DEEP COPY**: copies the "container" and contents (no reference)
