Jaakko's Blog

Python 3.5 introduced type hinting which I think is an awesome addition to the language. However, as the PEP 484 outlined there is no type checking happening at the runtime, and the primary rationale of the PEP seems to be adding a standard language for type annotations to enable static analysis. Still, the PEP says that type hinting opens Python potentially for runtime type checking while it emphasizes that Python will remain a dynamic language.

I think type checking at the runtime could work well; I have been programming recently in the PHP land, and I like PHP’s type hinting. However, you can turn on strict types on/off in PHP, which you (still?) don’t have in Python. Nevertheless, type hinting makes development easier even if you don’t have type checking at the runtime thanks to easier code completion in IDEs and making static analysis more powerful.

I think mypy type checker is a very useful tool. You can run it to check whether you have any type related bugs in your code. I think integrating it into your build pipeline is not a bad idea, and you might be able to catch some nasty bugs with it. Below a very short introduction to mypy:

Consider the following:

class A: def __init__(self, i: int): self.i = i def should_return_int(self, string: str)->int: return str(self.i) + string

If you have ran the code on mypy, you would get the following:

typehints.py: note: In member "__init__" of class "A": typehints.py:2: error: The return type of "__init__" must be None typehints.py: note: In member "should_return_int" of class "A": typehints.py:6: error: Incompatible return value type (got "str", expected "int")

Type hinting also makes it easier to deal with abstract classes (and inheritance in general):

import abc class AbstractClass(abc.ABC): @abc.abstractmethod def some_getter_method(self)->str: pass @abc.abstractmethod def some_setter_method(self, name: str): pass class ConcreteClass(AbstractClass): def some_getter_method(self) -> str: return self.name def some_setter_method(self, name: str): self.name = name def expects_abstract_class(argument: AbstractClass)->str: return argument.some_getter_method() concrete_instance = ConcreteClass() concrete_instance.some_setter_method("John Doe") expects_abstract_class(concrete_instance) expects_abstract_class(object())

Running the code on mypy would yield the following warning:

I'm working with a Django application and we are using Django CMS. The users are able to add HTML through Django's admin. I wanted to version our images, as we are developing locally, then deploying to a test server so that the client can see and accept all the work we have done, and finally we have a production environment. We wanted all of these three environments to have versioned static images, so that when we are developing locally, the static files are server from own machine. The test and live environments also needed to have their own versionings.

This was what I wanted to have: Local: <img src="/static/imgs/img.jpg"> Test: <img src="https://s3-eu-west-1.amazonaws.com/test-bucket/static/imgs/img.jpg"> Production: <img src="https://s3-eu-west-1.amazonaws.com/production-bucket/static/imgs/img.jpg">

As I mentioned above, we are using Django CMS, and the urls were being hardcoded directly there. To achieve the desired behaviour I decided to create a custom template tag, and have Django re-render the CMS pages.

I created a super-simple context processor and added that into TEMPLATE_CONTEXT_PROCESSORS:

def cms_tag(request): return {"cms_images": settings.STATIC_URL} TEMPLATE_CONTEXT_PROCESSORS += ("path.to.cms_tag",)

Next, I created the following function:

import traceback from django.template import Template def render_django_cms_templates(isntance, placeholder, rendered_content, original_context): try: t = Template(rendered_content) rendered_content = t.render(original_context) except: import traceback rendered_content = "<p> {} </p>".format(traceback.format_exc()) return rendered_content CMS_PLUGIN_PROCESSORS = ('path.to.render_django_cms_templates',)

Now we can write the urls in the following way, and the path is correct in all of the three environments: <img src="{{cms_images}}imgs/img.jpg">

Let's have a look on Pythons collections module that is in Python's standard library. According to the docs, collections module "implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers".

One of the most useful bits of collecions is the defaultdict which is a very useful dict subclass that makes your life a lot easier. Say you are going through a list of people and their hometowns, and you are interested in finding out what kind of home towns each name has (very interesting!).

Using a normal dictionary you might do something along the following lines:

people = [ ('Jane', "Austin",), ('Jane', "SF",), ('Jane', 'Dallas',), ('Mark', "Chicago",), ('David', "St. Louis",), ('David', "Miami") ] normal_dict = {} for name, home_city in people: if name not in normal_dict: normal_dict[name] = [home_city] else: normal_dict[name].append(home_city) print(normal_dict) # {'David': ['St. Louis', 'Miami'], 'Mark': ['Chicago'], 'Jane': ['Austin', 'SF', 'Dallas']} assert('chicken' not in normal_dict)

With defaultdict from collections module you could do it the following way:

import collections l = collections.defaultdict(list) for name, home_city in people: l[name].append(home_city) print(l) # defaultdict(<class 'list'>, {'Jane': ['Austin', 'SF', 'Dallas'], 'David': ['St. Louis', 'Miami'], 'Mark': ['Chicago']}) print(l['chicken']) # []

If you used a normal dictionary and tried appending to a key that does not exist in the dictionary, Python would raise a KeyError, but when defaultdict does not find the key it creates the key automatically. You can also use defaultdict with sets and ints.

Let's assume we have a common stock that's traded in a stock exchange. A share has obviously a price, and also the number of shares is known. Thus we can easily calculate the market capitalization of a given company by multiplying its share price by the number of shares. We can also calculate share price if we know the market capitalization and the number of shares. And you get the number of shares by diving the market capitalization by the share price. You get it. Simple stuff.

Let's extend Python dictionary to create an object that automatically calculates the third value using two of the values.

Using @property decorator allows you to use property values like you would use normal attributes. This means that if you decorate a method with the @property decorator, you can set, get and delete its values much like normal attribute values.