from collections import ChainMap 

prio_1 = {"param_1": "foo"} 
prio_2 = {"param_1": "foobar", "param_2": "bar"} 

combined = ChainMap(prio_1, prio_2) 

print(combined["param_1"]) # outputs 'foo' 
print(combined["param_2"]) # outputs 'bar'

The param_1 from the prio_1 dictionary is dominant, so it isn’t overwritten by the key-value pair from prio_2 dict. prio_2 dict just adds the param_2 because it is not yet in the ChainMap.

The nice thing is that no information is lost, the ChainMap object contains both dictionaries.

You can use it for example in a situation where you want to chain arguments from argparse, os.environ and default parameters. See here

The post Python3: ChainMap appeared first on Creatronix.

Given the hypothetical example where we define a function which multiplies integer:

def multiply(a, b): 
    return a * b 

print(multiply("I", "You"))

It is possible to pass strings to the function which will produce am error at runtime

TypeError: can't multiply sequence by non-int of type 'str'

Type Hints

Since Python 3.5 you have the possibility to add type hints so that type checks can be performed _before_ run time:

def multiply(a: int, b: int) -> int: 
    return a * b

You can also have type hints with default parameter values. They just look a bit weird 🙂

def __init__(self, wp_url: str, posts_per_page: int=20): 
    self.wp_api_url = wp_url + "/wp-json/wp/v2" 
    self.posts_per_page = posts_per_page

You can import more types from the typing module e.g. List

from typing import List 

def get_categories(self) -> List: 
    query_string = "/categories?per_page=20" 
    categories = requests.get(self.wp_api_url + query_string) 
    return categories.json()

Union

If a function returns different object types we can use the union type

from typing import Union, Optional 

def get_foo_or_bar(id: int) -> Union[Foo, Bar]
    pass
def get_foo_or_none(id: int) -> Union[Foo, None]
    pass
def get_foo_or_none(id: int) -> Optional[Foo]
    pass

Type Checking

With mypy there is tool to lint your python code before execution:

$ python3 pip install mypy 
$ mypy <my_python_file>

IDE support

An IDE like PyCharm is already capable of checking types with type hints

A good tutorial on medium

The post Python Type Checking appeared first on Creatronix.

if isinstance(duration, (int, long)):
    duration = timedelta(seconds=duration)

Looking quite plausible, isn’t it? But lo and behold: it doesn’t work under Python 3.x. Dang!

The reason: Python 2 has two integer types: int and long. In Python 3 there is only int, which makes it necessary to distinguish between these two major versions. I’ve found a nice page which deals with this issue. Here is what You must do to make it work in both Python 2 and 3:

import sys
if sys.version_info < (3,):
    integer_types = (int, long,)
else:
    integer_types = (int,)

isinstance(1, integer_types)

The post Python 3 – there shall be just int appeared first on Creatronix.