<h4>A look at the semantic flow of decorators in Python.</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*7kUMDvh1qFy4flm2"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@rpnickson?utm_source=medium&amp;utm_medium=referral"
      >Roberto Nickson</a
    >
    on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Decorators are a very widely known design pattern in software engineering, in
  which the behaviours of single methods and classes are modified by a wrapping
  function.
</p>
<p>
  Semantically put, a decorator is invoked to replace an existing definition of
  a method, with a whole new method.
</p>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/1*F4eLRzGw6esfOWIlaLDXjg.jpeg"
  />
  <figcaption>The semantic flow of decorators in Python</figcaption>
</figure>
<p>
  As we will see in this article, decorators could be a good tool to use when
  dealing with older codebases which we need to tailor to suit new needs, fresh
  requirements, etc. Even more so, when we are working with the
  <a href="https://en.wikipedia.org/wiki/Single-responsibility_principle"
    >Single Responsibility Principle</a
  >
  and
  <a href="https://en.wikipedia.org/wiki/Open%E2%80%93closed_principle"
    >Open-Closed Principle</a
  >.
</p>
<h3>What Are Decorators in Python?</h3>
<p>
  A decorator in Python is any callable that is used to modify the behaviour of
  any method or class. Take for instance, we have this legacy method in
  our project:
</p>
<pre>def greet_someone(name: str):<br />    return f&quot;Hello and welcome, {name}!&quot;</pre>
<p>
  Now, say we want to add translations to our project, and we want this method
  in particular to render the greeting in a specified language, we could make
  this happen with the simple addition of a decorator.
</p>
<pre>@translate<br />def greet_someone(name: str):<br />    return f&quot;Hello and welcome, {name}!&quot;</pre>
<h3>How to write a Decorator in Python</h3>
<p>Let us code the translate decorator.</p>
<p>By definition, we know that a decorator in Python is a callable which</p>
<ol>
  <li>Takes in the original method as a parameter.</li>
  <li>
    Returns a new method, which would replace the previous (while still bound to
    the name of the original method)
  </li>
</ol>
<p>
  First, let’s define a function which takes in another function as a parameter.
</p>
<pre>def translate(original_func):<br />    ...</pre>
<p>Next, we are going to make the translate decorator return a new method.</p>
<pre>
def translate(original_func):

    # args, kwargs are the parameters of the original_func
    def replacement_function(*args, **kwargs):
        return &quot;This is from the new function&quot;
    
    return replacement_function
</pre>
<p>
  Now, let’s see how our @translate decorated method stacks up against the other
  original method.
</p>
<pre>
def greet_someone(name: str):
    return f&quot;Hello and welcome, {name}!&quot;

    print(greet_someone(&quot;Tom&quot;))
    # &quot;Hello and welcome, Tom!&quot;

@translate
def greet_someone(name: str):
    return f&quot;Hello and welcome, {name}!&quot;

print(greet_someone(&quot;Alex&quot;))
# &quot;This if from the new function&quot;
</pre>
<p>
  Now, that we have seen our decorator at work, let’s modify the decorator to be
  an actual translator
</p>
<p>
  For the sake of this tutorial example, we are using a library called
  googletrans. So, let’s go ahead and install the library:
</p>
<pre>pip install googletrans</pre>
<p></p>
<pre>
# script.py
from googletrans import Translator

translator = Translator()

APP_LANGUAGE = 'fr'

def translate(func):
    def replacement_func(*args, **kwargs):
        result = func(*args, **kwargs)
        return translator.translate(result, dest=APP_LANGUAGE).text

    return replacement_func

@translate
def greet_someone(name: str):
    return f"Hello and welcome, {name}!"

print(greet_someone("Pierre"))
</pre>
<p>
  We see the following output, correctly translated to the app’s language
  of french.
</p>
<pre>Bonjour et bienvenue Pierre !</pre>
<p>
  Now, we have a neat way to transform all the functions returning texts in our
  project, to the app’s own language, by simply adding only one line of coding.
</p>
<p>
  One might wonder, what if I want to pass a parameter to the decorator itself?
  To make it more flexible and translate the text to more than just “french”.
</p>
<h4><strong>Passing Parameters to Decorators</strong></h4>
<p>
  For a decorator to accept parameters in Python, we would have to wrap our
  decorator inside another function which would take these parameter(s).
</p>
<p>
  Let’s go back and modify our @translate decorator to take in a language
  parameter, and then translate our text to the specified language.
</p>
<pre>
# script_2.py
from googletrans import Translator

translator = Translator()

APP_LANGUAGE = 'fr'


def translate(output_language):
    def inner(func):
        def replacement_func(*args, **kwargs):
            result = func(*args, **kwargs)
            return translator.translate(result, dest=output_language).text

        return replacement_func

    return inner


@translate("pt")
def greet_someone(name: str):
    return f"Hello and welcome, {name}!"

print(greet_someone("Pierre"))
</pre>
<p>
  Now, we get the output of our function translated into the language of our
  choosing and specification — in this case Portuguese “pt”.
</p>
<pre>Olá e bem-vindo, Pierre!</pre>
<h4>Nesting Decorators</h4>
<p>
  Decorators could be nested. When decorators are nested, the result could be
  expressed as wrapping the functions in the order out-to-in, from
  top-to-bottom.
</p>
<p>In other words,</p>
<pre>@first_decorator<br />@second_decorator<br />@third_decorator<br />def my_function():<br />    print(&quot;Hello&quot;)</pre>
<p>Could be expressed as</p>
<pre>first_decorator(second_decorator(third_decorator(my_function)))</pre>
<h3>Use-cases for Decorators in Python</h3>
<ol>
  <li>
    <strong>Reusing impossible to use code</strong>: Decorators could serve as
    an adapter, modifying certain parameters to fit certain methods.
  </li>
  <li>
    <strong>Logging, analytics, monitoring</strong>: We could use decorators
    monitor how long a function takes to perform, and log this for analytical
    purposes.
  </li>
  <li>
    <strong>Avoiding repetitions</strong>: The DRY (don’t repeat yourself)
    principle is one which fits into decorators pretty nicely. Once you find
    yourself writing the same piece of code in more than one function, you
    should consider encapsulating this into a decorator.
  </li>
</ol>
<p>
  In conclusion, decorators are to functions, what encapsulation are to classes.
  We can leverage on decorators, to declutter our functions, and make them more
  reusable.
</p>
<p>Thank you!</p>
<img
  alt=""
  height="1"
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=b6d7adbd1ea1"
  width="1"
/>

A look at the semantic flow of decorators in Python. Photo by Roberto Nickson on Unsplash Decorators are a very widely known design pattern in software engineering, in which the behaviours of single methods and classes are modified by a wrapping function. Semantically put, a decorator is invoked to replace an existing definition of a method, with a whole new method. The semantic flow of decorators in Python As we will see in this article, decorators could be a good tool to use when dealing with older codeba

Understanding Decorators in Python

<h4>
  Python has no native implementation of interfaces — but that’s where abstract
  classes and abstract methods come into play.
</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*39A3ujujxJZGu-VT"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@cdr6934?utm_source=medium&amp;utm_medium=referral"
      >Chris Ried</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Interfaces are so vital in software engineering, that one of the
  <a
    href="https://www.freecodecamp.org/news/solid-principles-explained-in-plain-english/"
    >SOLID Principles</a
  >
  (the bedrock of quality software design) is solely dedicated to it — <a
    href="https://en.wikipedia.org/wiki/Interface_segregation_principle#:~:text=In%20the%20field%20of%20software,are%20of%20interest%20to%20them."
    >Interface Segregation Principle</a
  >.
</p>
<h3>Why Are Interfaces so Vital in Software Engineering?</h3>
<p>
  Imagine you have a utility class which has a method which you will use
  seventeen times throughout your application. What happens when you change the
  parameters of a method in the utility class, or the output the method returns?
  You would have to refactor all the seventeen references to fit the new
  signature of the method. But, with an interface, the class itself will become
  invalid once there’s a mismatch with the interface’s contract — the class must
  stick with the interface, and have a different method, if it needs to change
  the signature. This way, all the seventeen references of the class are pretty
  much safe in the way they call the utility method.
</p>
<p>Cool, right?</p>
<p>
  Now, at some point in time, we Python-<em>istas</em> have needed a way to
  enforce implementations of certain methods in our classes, and you are
  probably reading this article because you have discovered that there are no
  native implementations of interfaces in Python. <em>Well, not quite so.</em>
</p>
<h3>How Would Interfaces Be Implemented in Python</h3>
<p>
  An <strong>interface</strong> would be implemented in Python as an
  <strong>abstract class</strong>.
</p>
<h4>What Is an Abstract Class</h4>
<p>
  An abstract class is a class which contains one or more abstract methods. An
  abstract method is a method that is declared but has no concrete
  implementation — the implementation is to be done by a derived class.
</p>
<p>
  <strong>The key characteristic of interfaces,</strong>
  <strong
    >is that they enforce the implementation of certain methods in
    classes,</strong
  >
  and by definition of abstract classes, <em>this,</em> is catered for.
</p>
<h4>Declaring an Abstract Class in Python</h4>
<p>
  Python provides an abstract base class module called abc. This module contains
  a helper class called abc.ABC (on which we base our abstract classes), and an
  abc.abstractmethod decorator (with which we mark the methods and properties,
  we want implemented by concrete classes).
</p>
<p>We could define an abstract class in any one of two ways:</p>
<pre>from abc import ABC, ABCMeta<br></pre>
<pre># using the abc.ABCMeta as a metaclass<br>class HumanInterface(metaclass=ABCMeta):<br>    pass</pre>
<pre># inheriting the abc.ABC class<br>class HumanInterface(ABC):<br>    pass</pre>
<p>
  <em
    >The latter is preferred as a shorthand to declaring an abstract class, as </em
  ><em>ABC<br />is a class which already has </em
  ><em
    >ABCMeta as its metaclass, thus it makes room easier for the developer to
    add another metaclass declaration.</em
  >
</p>
<p>Now, let’s add our first interface methods to our HumanInterface.</p>
<pre>
from abc import ABC, abstractmethod

class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass
</pre>
<p>
  We have our interface set in, it is time for a concrete implementation to test
  that our interface method will be enforced.
</p>
<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass

      
class Hispanic(HumanInterface):
    def sing(self):
        pass
    

if __name__ == '__main__':
    Hispanic();
</pre>
<p>
  The Python interpreter throws an error we expect from an interface’s concrete
  implementation.
</p>
<pre>
TypeError: Can’t instantiate abstract class Hispanic with abstract methods greet</pre
>
<p>
  Let us take a look at what happens when we implement the greet method in our
  Hispanic class.
</p>
<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass
    
    @abstractmethod
    def exercise(self):
        pass
    
    @abstractmethod
    def introduce_self(self):
        pass
      
      
class Hispanic(HumanInterface):
    def greet(self):
        print("Hola! Como estas?")
        
    def exercise(self):
        print("Comenzando el entrenamiento")
        
    def introduce_self(self):
        print("Me llamo Sam")

        
if __name__ == '__main__':
    Hispanic().greet()
    # Hola! Como estas?
</pre>
<p>
  <strong><em>Pretty neat, right?!</em></strong>
</p>
<p>
  Perhaps, the team behind the Python programming language were well aware of
  the fact that interfaces could be written in Python using abstract classes
  and methods.
</p>
<p>
  In the next <a href="https://tomisin.dev/blog">article</a>, we will be
  comparing and contrasting abstract class and interfaces.
</p>
<p>
  If you found this article useful or learnt something in this article, please
  clap, share and subscribe.
</p>
<p><a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a></p>
<img
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=6d3658d248c"
  width="1"
  height="1"
  alt=""
/>

Python has no native implementation of interfaces — but that’s where abstract classes and abstract methods come into play. Photo by Chris Ried on Unsplash Interfaces are so vital in software engineering, that one of the SOLID Principles (the bedrock of quality software design) is solely dedicated to it — Interface Segregation Principle . Why Are Interfaces so Vital in Software Engineering? Imagine you have a utility class which has a method which you will use seventeen times throughout your application. Wha

How to Implement an Interface in Python

<h4>
  Learn about the methods behind common Python syntaxes and how to make your
  objects work with these syntaxes.
</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*JtpVKGm7V6kD98u1"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@juliusdrost?utm_source=medium&amp;utm_medium=referral"
      >Julius Drost</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Perhaps, you have noticed it is possible to use certain built-in methods (ex.
  len(my_list_or_my_string)), and syntaxes (ex. my_list_or_my_string[:3],
  my_fancy_dict['some_key']) on some native types such as list, dict. Maybe you
  have been curious as to why it is not possible (yet) to use these same
  syntaxes on some of the classes you have written.
</p>
<p>
  Variables of native types (list, dict, int, str) have unique behaviours and
  respond to certain syntaxes because they have some special methods defined in
  their respective classes — these methods are called Magic Methods.
</p>
<blockquote>
  Magic methods simply refer to
  <strong>special methods that begin and end with double underscores</strong>.
  They are also called “dunder” methods.
</blockquote>
<p>
  Magic methods are not designed to be invoked directly, they are invoked
  internally from the class on a certain action or when peculiar syntax is
  encountered.
</p>
<p>
  In this article, we would be exploring which magic methods exist for the
  common native types and how we can also make our objects exhibit behaviours
  popular with common native types.
</p>
<p>
  But, before diving into the special methods for each native type, let us get
  familiar with basic methods common across all variables.
</p>
<h3>Understanding Magic Methods in Python</h3>
<h4>Instantiation Functions</h4>
<p>
  __new__(self, *args, **kwargs) is the first step of instance creation. It’s
  called first and is responsible for <strong>returning</strong> a new instance
  of your class. Use this method if you want to control the way new instances
  are created.
</p>
<p>
  __init__(self, *args, **kwargs) this class method is called whenever we want
  to initialise a new instance. Thus,
  <strong
    ><em>it is called right after an instance has been created</em></strong
  >
  by the __new__ method. The __init__ method in Python does not return anything.
</p>
<p>
  __call__(self, *args, **kwargs) it is sometimes possible to invoke an object
  the same way we invoke functions. This is made possible by the
  __call__ method.
</p>
<h4>Presentation Functions</h4>
<p>
  Objects will be pretty anonymous without the help of inbuilt functions which
  help identity them and format them in a way that is not only meaningful but
  also useful during development and testing.
</p>
<p>
  __dir__(self) when a user wants to know the attributes of an object, they
  likely call the dir(...) function on the object. The interpreter then invokes
  the __dir__ method of that object.
</p>
<p>
  __len__(self) is applicable when you have an object which contains a number of
  elements. Herewith we can invoke the method len(my_object) on the object.
</p>
<p>
  __repr__(self) this method gets invoked when the interpreter wants to identify
  an object unambiguously for the sake of debugging and development. The value
  of this is typically wrapped inside angular brackets &lt; . . . &gt;.
</p>
<pre>
class MyObject(object):
    name = 'Tom'

print(MyObject)
# <__main__.MyObject object at 0x10321eb50>


class MyObjectWithRepr(object):
    name = 'Tom'

    def __repr__(self):
        return f'<MyObject: {self.name}'

print(MyObjectWithRepr)
# <MyObjectWithRepr: Tom>
</pre>
<p>
  __str__(self) has the goal of making an object human-readable. If this method
  is used alongside __repr__ in a class, the value of __str__ method takes
  precedence.
</p>
<p>__sizeof__(self) helps identity the size of an object in bytes.</p>
<h4>Equality Signs</h4>
<p>
  These functions are invoked when the interpreter encounters an equality sign
  between two variables. These include:
</p>
<p>
  __eq__(self, x) when we compare if two variables are equal in value, the
  interpreter triggers this method to get a result.
</p>
<p>
  __gt__(self, x) intuitively, this stands for “greater than” and is called when
  the greater than arithmetic symbol &gt; is in between two variables. It is
  typically used between two numeric variables, but can also be used to compare
  variables other types.
</p>
<p>
  __ge__(self, x) this stands for “greater than or equals” and is called when
  the greater than or equals arithmetic symbol &gt;= is in between two
  variables.
</p>
<p>
  __lt__(self, x) intuitively, this stands for “less than” and is called when
  the greater than arithmetic symbol &lt; is in between two variables.
</p>
<p>
  __le__(self, x) this stands for “lesser than or equals” and is called when the
  greater than or equals arithmetic symbol &lt;= is in between two variables.
</p>
<h3>Magic Methods for Native Types</h3>
<h4>Numbers</h4>
<p>
  The most distinct characteristic of numbers are their arithmetic operations.
  We can make our objects exhibit the same behaviours numbers do and respond to
  arithmetic symbols as do numbers, by simply implementing one or two of the
  special methods enlisted below.
</p>
<p>
  __add__(self, x) this method is invoked by the Python interpreter when the “+”
  sign is encountered between two variables.
</p>
<p>
  __mul__(self, x) for the multiplication arithmetic operation, this special is
  invoked implicitly by the interpreter.
</p>
<p>
  __sub__(self, x) to give our object the ability to get subtracted from, we can
  add this method.
</p>
<p>
  <strong>Real World Example #1: A More Pythonic Temperature Class<br /></strong
  >First, let’s define a simple class that holds the temperature for a
  particular room.
</p>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*Ra7o-PI0c3DmcW9C"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@matteofusco?utm_source=medium&amp;utm_medium=referral"
      >Matteo Fusco</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<pre>
from typing import Literal, Union


UNIT_TYPE = Literal['C', 'F']
VALUE_TYPE = Union[int, float]


class BaseTemperature(object):
    def __init__(self, value: VALUE_TYPE, unit: UNIT_TYPE, **kwargs):
        self.value = value
        self.unit = unit
        
    def __repr__(self) -> str:
        return f'<Temperature: {self.value}°{self.unit}>'

    def convert_to_celcius(self):
        self.value = (self.value - 32) * (5 / 9)
        self.unit = 'C'
    
        return self.value

    def convert_to_fahrenheit(self):
        self.value = (self.value * 9/5) + 32
        self.unit = 'F'

        return self.value

    def convert_unit(self, unit: UNIT_TYPE) -> VALUE_TYPE:
        if unit == self.unit:
            return self.value

        (
            self.convert_to_celcius() if self.unit == 'F' else
            self.convert_to_fahrenheit()
        )

        return self.value
</pre>
<p>
  When we try to add a value to an instance of our temperature class, we get
  an error.
</p>
<pre>&gt;&gt;&gt; Temperature(30, 'C') + 1</pre>
<pre>TypeError: unsupported operand type(s) for +: 'Temperature' and 'int'</pre>
<p>
  Now, let’s extend the class and give it the ability to perform arithmetic
  operations by implementing the __add__ method.
</p>
<pre>
class Temperature(BaseTemperature):
    def __add__(self, another_temperature: Union[int, float, 'Temperature']):
        if type(another_temperature) in {int, float}:
            return Temperature(
                value=self.value + another_temperature,
                unit=self.unit
            )

        another_temperature.convert_unit(self.unit)

        return Temperature(
            value=self.value + another_temperature.value,
            unit=self.unit
        )
</pre>
<p>
  Now, let’s see the result after we add a custom __add__ method to our
  temperature class.
</p>
<pre>&gt;&gt;&gt; Temperature(30, 'C') + 6<br>&lt;Temperature: 36°C&gt;</pre>
<pre>&gt;&gt;&gt; Temperature(30, 'C') + Temperature(35.6, 'F')<br>&lt;Temperature: 38°C&gt;</pre>
<pre>&gt;&gt;&gt; Temperature(34, 'C') + Temperature(66, 'C')<br>&lt;Temperature: 100°C&gt;</pre>
<h4><strong>Iterables: Lists, Tuples, Strings, Sets</strong></h4>
<p>
  __contains__(self, x) this is used when the in keyword is used to check if an
  element exists in an iterable (for example: x in ["a", "b"])
</p>
<p>
  __delitem__(self, key) when an item is deleted from an iterable via del
  keyword, this method gets triggered (for example del my_dict[x])
</p>
<p>
  __getitem__(self, key) this method is invoked by the interpreter when the
  accessor syntax is used on a variable (for example: my_variable[x])
</p>
<p>
  __iter__(self) the iter method is used in generator expressions, to yield one
  item of the array at a time.
</p>
<p>
  __next__(self) could be used along with __iter__ for make any object iterable.
  Once the pair of __iter__ and __next__ are present in any class, the object
  will respond to for i in my_object syntax.
</p>
<p>
  __setitem__(self, key, newvalue) this method is used by the interpreter to set
  the element at any given position. You would notice that str and tuples do not
  support item assignment, as they are <strong>immutable</strong>.
</p>
<h4>Real-life Example #2: A More Pythonic Approach to the Scrabble Game</h4>
<p>
  Let us bring to life all we have learnt in this article by conceptualising a
  simplified Scrabble game. Our Scrabble game will utilise a number of magic
  methods to make it interact with the interpreter in a more friendly way.
</p>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*Klyi2BIM4NERfj3B"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@brett_jordan?utm_source=medium&amp;utm_medium=referral"
      >Brett Jordan</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  <strong>Tiles<br /></strong>There is no game of Scrabble without letter tiles
  to play. A Scrabble tile contains a letter in the alphabet and a number
  denoting the points the player scores by playing it in a turn. In a game of
  Scrabble, players often make the comparison between tiles to play the ones
  which will score them the most points, so let’s support that in our design.
</p>
<pre>
class ScrabbleTile(object):
    letter: str
    points: int

    def __init__(self, letter: str, points: int):
        self.letter = letter
        self.points = points

    def __repr__(self):
        return f"{self.letter} ({self.points})"
      
    def __ge__(self, other: ScrabbleTile):
        return self.points >= other.points

    def __gt__(self, other: ScrabbleTile):
        return self.points > other.points
    
    def __le__(self, other: ScrabbleTile):
        return self.points <= other.points
    
    def __lt__(self, other: ScrabbleTile):
        return self.points < other.points
</pre>
<p>Tiles could then be declared and used in the game like this:</p>
<pre>tile_a = Tile('A', 1)<br>tile_q = Tile('Q', 10)</pre>
<pre>print(tile_a)<br># A (1)</pre>
<pre>print(tile_q)<br># Q (10)</pre>
<pre>print(tile_q &gt; tile_a)<br># True</pre>
<p>
  <strong>Cells<br /></strong>Next, we will be defining the squares on the
  Scrabble board. We know there are 255 squares in a board. Some of these cells
  have award special points to players who play a turn on them. Our cells will
  be keeping the following data: row, column, letter_multiplier,
  word_multiplier. Since we also have one instance of cells during an entire
  game, we should make this a Singleton to prevent multiple creations of a
  single cell on the board.
</p>
<pre>
class ScrabbleCell(object):
    _instance: 'ScrabbleCell' = None

    column: int
    content: Union[None, ScrabbleTile]
    letter_multiplier: int
    row: str
    word_multiplier: int

    def __init__(self, row: int, column: int, letter_multiplier: int, word_multiplier: int):
        self.row = row
        self.column = column
        self.content = None
        self.letter_multiplier = letter_multiplier
        self.word_multiplier = word_multiplier

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)

        return cls._instance

    def __repr__(self):
        return f"{self.row} {self.column} -- {self.content}"
</pre>
<p>
  <strong>Board<br /></strong>Finally, we are going to be defining our board.
  The board will have all the moves played since the start of the game. We would
  require one board for an entire game session,
  <strong>we will be making this a </strong
  ><a href="https://en.wikipedia.org/wiki/Singleton_pattern"
    ><strong>Singleton</strong></a
  ><strong> class.</strong>
</p>
<pre>
import string


class Board(object):
    _instance: 'Board' = None
    _board: List[List[ScrabbleCell]]

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)

        return cls._instance

    def __init__(self):
        self._board = [
            [ScrabbleCell(row, column) for column in range(15)]
            for row in string.ascii_uppercase[:15]
        ]
        
    def __getitem__(self, key):
        return self._board[key]
</pre>
<p>
  <strong>Move<br /></strong>When a Scrabble player makes a move, they place
  several tiles vertically or horizontally to form a word. To represent this in
  code, we could keep an array of tiles and the cells they are played on.
  Players also constantly weigh up potential moves to determine which would give
  them the highest points.
</p>
<pre>
class Move(object):
    tiles: List[ScrabbleTile]
    cells: List[ScrabbleCell]
    points: int

    def __init__(self, placements: List[Tuple[ScrabbleTile, ScrabbleCell]]):
        self.tiles = []
        self.cells = []
        self.points = 0

        word_multiplier = 1

        for tile, cell in placements:
            self.tiles.append(tile)
            self.cells.append(cell)
            
            if cell.word_multiplier > 1 and cell.content is None:
                word_multiplier = cell.word_multiplier

            self.points += (tile.points * cell.letter_multiplier)

    def __repr__(self):
        return f'{"".join([tile.letter for tile in self.tiles])} = {self.points}'
    
    def __ge__(self, other: Move):
        return self.points >= other.points

    def __gt__(self, other: Move):
        return self.points > other.points
    
    def __le__(self, other: Move):
        return self.points <= other.points
    
    def __lt__(self, other: Move):
        return self.points < other.points
</pre>
<p>
  Now, when a player wants to compare two moves to see which would be more
  advantageous, we can elegantly compare moves like we do with native numbers,
  strings, et al.
</p>
<pre>move_one = Move([<br>    [tile_a, cell_1], [tile_c, cell_2], [tile_e, cell3]<br>])<br>print(move_one)<br># ACE = 5</pre>
<pre>move_two = Move([<br>    [tile_z, cell_1], [tile_o, cell_2], [tile_o, cell3]<br>])<br>print(move_two)<br># ZOO = 12</pre>
<pre>print(move_one &gt; move_two)<br># False</pre>
<pre>print(move_one &lt; move_two)<br># True</pre>
<h3>Conclusion</h3>
<p>
  Large Python projects will certainly be a lot more intuitive to work with, if
  most of their components accept and respond to a lot of the syntax we are
  accustomed to with native types — we see this in the Django ORM, with being
  able to iterate over a QueryDict.
</p>
<pre><strong>Want to Connect?</strong></pre>
<pre><a href="https://tomisin.dev/subscribe">Get weekly articles and coding tricks on only the topics you care about by subscribing to my channel.</a></pre>
<img
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=c413c9d72927"
  width="1"
  height="1"
  alt=""
/>
<hr />
<p>
  <a
    href="https://betterprogramming.pub/transforming-your-objects-into-real-python-objects-using-magic-methods-c413c9d72927"
    >Supercharging Python Classes with Magic Methods</a
  >
  was originally published in
  <a href="https://betterprogramming.pub/">Better Programming</a> on Medium,
  where people are continuing the conversation by highlighting and responding to
  this story.
</p>

Learn about the methods behind common Python syntaxes and how to make your objects work with these syntaxes. Photo by Julius Drost on Unsplash Perhaps, you have noticed it is possible to use certain built-in methods (ex. len(my_list_or_my_string)), and syntaxes (ex. my_list_or_my_string[:3], my_fancy_dict['some_key']) on some native types such as list, dict. Maybe you have been curious as to why it is not possible (yet) to use these same syntaxes on some of the classes you have written. Variables of native

Supercharging Python Classes with Magic Methods

<h4>Know how to use static type checking and type annotation best practices</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*D2pTs4JZKVeT55C9"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@artturijalli?utm_source=medium&amp;utm_medium=referral"
      >Artturi Jalli</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Type-checking is one of the foremost features of any modern-day programming
  language; it’s the reason TypeScript was born. Type-checking not only makes a
  codebase easier to extend and work with in general, but it also detects many
  programming errors quickly, reliably and automatically.
</p>
<p>
  First introduced in Python 3.5, <strong>Type Hints</strong> are the primary
  way Python developers annotate types to variables and functions.
</p>
<blockquote>
  <strong>Type Hints — </strong>like the name suggests, do not enforce any type
  checks at the interpreter level. They are designed to be used by developers,
  IDEs, linters, type checkers, etc.
</blockquote>
<p>
  In technical term, <strong>Python has dynamic type checking</strong>, hence
  the types are known at runtime and not compile time (as is the case in static
  type checked languages like C#). Although, it is worth mentioning that the
  Python community has hacked together a
  <a href="http://mypy-lang.org/">variant</a> of the Python interpreter which
  enforces static type checking.
</p>
<p>
  In this article, we will explore how to incorporate Python’s type checking
  into our codebase in ways which would reduce friction in integrating with
  units of the projects.
</p>
<h3>Type Hints Syntax</h3>
<p>
  Python supports type annotation for the basic variable types supported by the
  language str, int, float, bool<strong> </strong>and None. It also comes with a
  typing library batteries included; this typing libraries provides us with
  means to use more special types.
</p>
<h4>Annotating Variables</h4>
<p>
  To indicate the type of a variable in Python, just add a colon-space followed
  by the type (str, int, List[],etc.), right after the variable name.
</p>
<pre>
# type_hints_tutorial.py

from typing import List

name: str = 'Tommy'
age: int = 24
height_in_meters: float = 1.7
colleagues: List[str] = ['Alicia', 'John']
</pre>
<h4>Annotating Functions</h4>
<p>
  The syntax for variable annotation of variables also works for the function
  parameters. However, to indicate the return type, we add an arrow “-&gt;”
  followed by its type.
</p>
<pre>
# type_hints_tutorial.py

from typing import Dict, List

def convert_celcius_to_fahrenheit(celcius_temp: float) -> float:
    return (celcius_temp * 9/5) + 32
  
def send_email(
    subject: str,
    body: str,
    recipients: List[str],
    cache: Dict[str, str]
) -> bool:
  
    # skipped for brevity

    return True # or False
</pre>
<h3>Using Special Types</h3>
<p>
  Now, that we are all warmed up and familiar with the type annotation syntax,
  let us get familiar with more complex types.
</p>
<h4>Any</h4>
<p>
  A variable of type Any is unconstrained. So, such variables are compatible
  with all other types (int, str, List, etc), and all other types are compatible
  with these.
</p>
<pre>
# type_hints_tutorial.py
from typing import Any

result: Any = "SUCCESS"
  
# also works because variables of type Any are compatible other types
result = 10

state: str = "PENDING"

# works because all other types are compatible with type Any.
state = result
</pre>
<h4>Literal</h4>
<p>
  Literals are used to indicate to type checkers that the value a variable or
  function holds, is equal to one of the values specified.
</p>
<pre>
# type_hints_tutorial.py

from typing import Literal


GENDER = Literal["male", "female", "non-conforming"]

def create_user(
    first_name: str,
    last_name: str,
    gender: GENDER,
) -> Dict[str, str]:
    return {
        "first_name": first_name,
        "last_name": last_name,
        "gender": gender
    }

create_user("John", "Bond", "male")
</pre>
<p>
  In the example above, gender will be one of the values in the GENDER literal
  declaration — “male”, “female” or “non-conforming”.
</p>
<h4>Union</h4>
<p>
  Sometimes, a variable may have properties cutting across two type
  declarations. A variable might also be of two types.
</p>
<pre>
# type_hints_tutorials.py

from typing import Union


def get_room_temperature() -> Union[int, float]:
    return 20.8  # 20 also works
</pre>
<h4>TypedDict</h4>
<p>
  Dictionaries being one of the simplest forms of Data Structure in Python, are
  among the most used variable types in the language.
</p>
<p>
  Using a TypedDict could greatly improve the readability of the code especially
  in a large project where there are lots of declarations in lots of places;
  keeping track of <em>what</em> goes <em>where </em>gets hectic as you scale.
</p>
<pre>
# type_hints_tutorials.py
from typing import TypedDict, Union


class Card(TypedDict):
    rank: Union[str, int]
    suit: str

# The Card class now has behaviours of both TypedDict and dict classes

# Card can be used to annotate a variable
ace_of_spade: Card = {'rank': 'A', 'suit': '♤'}

# or can be instantiated
ace_of_spade = Card(rank='A', suit='♤')
</pre>
<h4>NoReturn</h4>
<p>
  NoReturn type is similar to void in other programming languages. It is used to
  declare that a function does not have any return.
</p>
<pre>
# type_hints_tutorials.py
from typing import NoReturn


def say_greeting() -> NoReturn:
    print("Hello World!")
</pre>
<h4>Final</h4>
<p>
  This is a typing construct used to indicate that a variable is not to be
  re-assigned or overridden in a subclass.
</p>
<pre>
# type_hints_tutorials.py
from typing import Final


MIN_NAME_LENGTH: Final = 2

# error flagged by type-checker
MIN_NAME_LENGTH += 1


class Validator(object):
    MIN_NAME_LENGTH: Final[int] = 4


class UserValidator(Validator):
    # this line will be flagged by the interpreter
    MIN_NAME_LENGTH = 3
</pre>
<h3>Using Static Type Checking in Python</h3>
<p>
  Python’s interpreter my default does not enforce type-checking. However, a
  variation of the Python interpreter — mypy, has been created to enforce
  type-checking on the interpreter level.
</p>
<p>You can use mypy in two ways:</p>
<ol>
  <li>Download the mypy command line and use it to run your Python scripts.</li>
  <li>Install the mypy extensions available on VSCode and PyCharm.</li>
</ol>
<h3>Type Annotation Best Practices</h3>
<h4>1. Use of Any</h4>
<p>
  The Any type should only be used when the exact type of the return variable or
  the function parameter is not known to us; this could be when using a third
  party library which does not have type annotations, or using a module without
  type annotations.
</p>
<h4>2. Enable static type-checking</h4>
<p>
  Type checking’s benefits of preventing errors and guiding the developer will
  not be felt as much if it is dynamic. If you are not a fan of the mypy command
  line, you can also install it as a VSCode or PyCharm extension.
</p>
<h4>3. Use tuples for fixed length arrays</h4>
<p>
  Tuples serve a double use as a record. So, when you have a known number of
  items in the array especially when they are not all of the same type, the
  variable is better suited for a tuple type.
</p>
<h4>4. Function return types</h4>
<p>
  Functions should do one thing and one thing only, thus they should have a
  single deterministic type.
</p>
<pre><strong>Want to Connect?</strong></pre>
<pre>Get weekly articles and coding tricks by <a href="https://tomisin.dev/subscribe">subscribing to my newsletter</a>.</pre>
<img
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=63cbdb16d97c"
  width="1"
  height="1"
  alt=""
/>
<hr />
<p>
  <a
    href="https://betterprogramming.pub/improving-your-python-projects-with-type-hints-63cbdb16d97c"
    >Improving Your Python Projects With Type Hints</a
  >
  was originally published in
  <a href="https://betterprogramming.pub/">Better Programming</a> on Medium,
  where people are continuing the conversation by highlighting and responding to
  this story.
</p>

Know how to use static type checking and type annotation best practices Photo by Artturi Jalli on Unsplash Type-checking is one of the foremost features of any modern-day programming language; it’s the reason TypeScript was born. Type-checking not only makes a codebase easier to extend and work with in general, but it also detects many programming errors quickly, reliably and automatically. First introduced in Python 3.5, Type Hints are the primary way Python developers annotate types to variables and funct

clean-code

Understanding Decorators in Python

data-science

How to Implement an Interface in Python

Get one coding trick and an article delivered every week at no extra cost

coding

Supercharging Python Classes with Magic Methods

data-science

Improving Your Python Projects With Type Hints