<h4>Learn how this module can help you get richer search results, more easily, than Python’s built-in “filter” method</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bs9ox6xXQXHYFkU8gw4l-A.jpeg"></figure>Originally published on my <a href="http://tomisin.dev/blog">blog</a>.
For the umpteenth time, you are having to implement a search functionality in your Python application. As a no-brainer, you turn to Python’s filter method.
Half the time, the filter method rightly serves you just fine.
But, as you increase the requirements of your “search” function, you realise that you need to put substantial effort into improving the robustness of the filter function’s results.
For instance, you’re looking to return more “interesting” (<a href="https://redis.com/blog/what-is-fuzzy-matching/">fuzzy</a>) results, say your application gives users a list of songs matching their search input, and you want the result to include songs which closely match the input, permitting spelling errors, <a href="https://pypi.org/project/huntela/">Huntela</a> is made for you.
<h3>What is Huntela</h3>
<a href="https://pypi.org/project/huntela/">Huntela</a> is a module that contains several methods that could help you get robust search results. A simple illustration
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; huntela.fuzzy_search(term='app', items=['app', 'apps', 'phone']) [ {'confidence': 1, 'index': 0, 'value': 'app'}, {'confidence': 0.8, 'index': 1, 'value': 'apps'} ]</pre>
Right off the bat, we notice some…
<h3>Advantages of Huntela over Python’s filter Method</h3>
<ol>
<li>
Fuzzy Matching: The fuzzy_search function uses a character comparison method that includes close matches in its results, allowing for fuzzy matching and increased flexibility in searching for similar or related terms.</li>
<li>
Confidence Values: The fuzzy_search function returns results with a confidence score that indicates the level of similarity between the search term and the matched item, providing a more precise indication of how well the search term matches the desired results.</li>
<li>
Index Values: The fuzzy_search function method also returns the index of each matching item in the original list, which can be useful for further processing.</li>
<li>
Lots of Utility Search Functions: Now, guess what! The same juiciness of the result of the fuzzy_search function applies to several other search functions the module provides. These include binary_search, search_for_least_frequent_items, search_for_most_frequent_items.</li>
<li>
Consistent Interfaces: The fuzzy_search method returns a list of Result objects representing the search results, which provide additional information such as the confidence value and index.</li>
</ol>
<h3>Ready to give Huntela a try?</h3>
Open up your favourite command line, and type in:
<pre>pip install huntela</pre>
<h3>Practical Examples With the Huntela Library</h3>
<h4>Autocorrect &amp; Text Suggestion Feature</h4>
You are tasked with returning words which closely match a user’s input. This would be a great use-case for <a href="https://pypi.org/project/huntela/">Huntela</a>.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; user_input = input("Type in a word: ") # hellu &gt;&gt;&gt; &gt;&gt;&gt; vocab = ["hello", "run", "jump", ...] &gt;&gt;&gt; results = huntela.fuzzy_search(user_input, vocab) [ {"confidence": 0.8, "index": 0, "value": "hello"} ] &gt;&gt;&gt; print(f"Did you mean: '{results[0]['value']}'?") Did you mean 'hello'?</pre>
<h4>Improving User Search Experience in a Shopping Site</h4>
Suppose you are assigned to fetch products from an e-commerce platform that closely resemble the user’s input in a search query. You can achieve this by using the fuzzy_search function of the <a href="https://pypi.org/project/huntela/">Huntela</a> module.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; user_input = input("What would you like to buy? ") # t-shirt &gt;&gt;&gt; &gt;&gt;&gt; store = [ {"name": "Headphones", "price": 59.99}, {"name": "Shirt", "price": 19.99} ] &gt;&gt;&gt; results = huntela.fuzzy_search(user_input, store, key='name') [ {"confidence": 0.8, "index": 1, "value": "Shirt"} ]</pre>
<h4>Searching for a specific value in a sorted list</h4>
Suppose you have a sorted list of integers, and you want to find if a specific value exists in the list. You can use binary search to do this efficiently.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; results = huntela.binary_search(term=5, items=[1, 3, 4, 5, 7, 9, 11]) [ {"confidence": 1, "index": 3, "value": 5} ]</pre>
<h4>Analytics</h4>
You could also use this function to analyze large datasets and find the most and least frequent values. For example, you could use this function to find the most common search queries on a website or the most popular products purchased by customers.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; site_visitor_ids = [101, 102, 103, 101, 105, 103, 101, 102, 104] &gt;&gt;&gt; &gt;&gt;&gt; most_frequent = huntela.search_for_most_frequent_items(2, user_ids) [ {'confidence': 1, 'index': [0, 3, 6], 'value': 101}, {'confidence': 1, 'index': [1, 7], 'value': 102}, {'confidence': 1, 'index': [2, 5], 'value': 103} ]</pre>
<h3>Conclusion</h3>
If you’re looking to get more robust and flexible search results than Python’s built-in filter method can provide, <a href="https://pypi.org/project/huntela/">Huntela</a> is definitely worth a try.
With its fuzzy matching, confidence values, and index values, <a href="https://pypi.org/project/huntela/">Huntela</a> can help you implement features like autocorrect and text suggestion, improve user search experiences in an e-commerce platform, and efficiently search sorted lists.
Additionally, <a href="https://pypi.org/project/huntela/">Huntela’s</a> other search functions like searching for most and least frequent items provide valuable utility for analysing large datasets. The module is easy to use and consistent in its interfaces, making it a powerful alternative to the filter method.
So why not give it a try and see how it can enhance your Python search capabilities?
<h4>Ready to give Huntela a try?</h4>
Open up your favourite command line, and type in:
<pre>pip install huntela</pre>
If you found this article helpful, clap, share and subscribe.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5e95a80f166c" width="1" height="1" alt="">

Learn how this module can help you get richer search results, more easily, than Python’s built-in “filter” method

Maximize Your Python Search Capabilities with Huntela

<h4>Learn how Django models could implement soft delete, without modifying the interfaces and contracts of models and querysets.</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0jvWLbXENhbH5Q2b"><figcaption>Photo by <a href="https://unsplash.com/fr/@markuswinkler?utm_source=medium&amp;utm_medium=referral">Markus Winkler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure>Originally published on my <a href="https://tomisin.dev/blog">blog</a>.
In contemporary architecture, or by design requirements, we often have the need to keep certain records even after they’ve been “deleted” by the user — that’s where soft deletion comes in.
In this article, we would learn how to implement soft delete, while our application maintains its Django-ness (for lack of a better word), and we can still maintain the same interface with our model objects in the same way as we would, if we had hard deletion in place.
<h3>What is Soft Delete</h3>
Soft delete is the process of deleting records in such a way that it is still present in the database while made unavailable to the user. It involves using a flag to mark the record as unavailable, rather than deleting the record from the database.
<h3>Benefits of Soft Delete</h3>
<ol>
<li>Records are easier to restore.</li>
<li>Soft delete operations are faster because we run an UPDATE command in the database. For hard delete, we will run a DELETE command which is generally slower, especially when there are related records across tables.</li>
<li>It keeps are related records in-place.</li>
<li>It is the safer option, in cases where users may need to retrieve deleted information.</li>
</ol>
<h3>Cons of Soft Delete</h3>
<ol>
<li>Added complexity of filtering out records that have been flagged as deleted.</li>
<li>Unique constraints need to be refactored to include the column representing the delete flag, so records which have been soft deleted could be recreated.</li>
<li>In some cases, records might need some unique implementations when soft deleted. For example, when soft deleting card information or payment methods, we might need to clear some sensitive fields like PAN or CVV.</li>
</ol>
Some of these fetch queries will start to look like
<pre>SELECT * FROM users WHERE is_deleted=false;</pre>
Unique constraints would also start to look this, with soft deletion in place:
<pre>CREATE UNIQUE INDEX "users_unique" ON users(is_deleted, email) WHERE is_deleted=false;</pre>
<h3>Implementing Soft Delete in Django</h3>
When implementing soft delete in Django, the first thing that’s required is a base model. This would reduce the complexity and help eliminate the aforementioned cons, as we wouldn’t need to duplicate the soft delete logic in all our models. All we would need to do, is to extend from this BaseModel.
<pre>class BaseModel(models.Model): class Meta: abstract = True # common fields go here</pre>
The first thing we want to add to our base model, is the delete flag. The is_deleted field will inform us about the availability of the record.
<pre>class BaseModel(models.Model): # ...omitted for brevity... is_deleted = models.BooleanField(default=False)</pre>
Next, we override the delete method of the model. So, we can change the default behaviour of our model’s delete from hard deletion to soft deletion.
<pre>class BaseModel(models.Model): # ...omitted for brevity... def delete(self): """Mark the record as deleted instead of deleting it""" self.is_deleted = True self.save()</pre>
With this piece of code in place, we could soft delete records as we would normally hard delete records, and maintain a Django-ic codebase.
<pre>class User(BaseModel): class Meta: unique_together = ['email', 'is_deleted'] name = models.CharField(max_length=24) email = models.EmailField() new_user = User(name="Bolaji", email="user.test@example.com") new_user.save() new_user.delete() print(new_user.is_deleted) # True</pre>
Now that we can soft delete easily, we have to make sure that our query results never actually include any deleted record. We do so by creating a custom manager which filters out the deleted.
<pre>from django.db.models import Manager, QuerySet class AppManager(Manager): def get_queryset(self): return QuerySet(self.model, using=self._db).exclude(is_deleted=True) class BaseModel(model.Model): # ...omitted for brevity... objects = AppManager()</pre>
With this in place, we can replace the default objects field of our Model with our AppManager. This would ensure that when we query using the familiar syntax, we are getting expected
<pre>class User(BaseModel): # ...omitted for brevity... user.objects.filter(...) user.objects.all() # excludes records flagged as deleted.</pre>
Wowza! Now, you can soft delete records while maintaining Django-ic code. Or, maybe there’s one more thing.
It’s possible to invoke delete on a queryset, instead of invoking it on an object. We have already catered for the latter my having a custom delete method in our BaseModel. To cater for the former scenario, we can make a custom queryset class.
<pre>from django.db.models import Manager, QuerySet class AppQuerySet(QuerySet): def delete(self): self.update(is_deleted=True) class AppManager(Manager): def get_queryset(self): return AppQuerySet(self.model, using=self._db).exclude(is_deleted=True)</pre>
Putting this altogether, we have:
<pre>from django.db.models import Manager, QuerySet class AppQuerySet(QuerySet): def delete(self): self.update(is_deleted=True) class AppManager(Manager): def get_queryset(self): return AppQuerySet(self.model, using=self._db).exclude(is_deleted=True) class BaseModel(models.Model): class Meta: abstract = True is_deleted = models.BooleanField(default=False) def delete(self): self.status = DELETED self.save() # Sample model class Post(BaseModel): content = models.CharField(max_length=140)</pre>
Finally, you have soft delete implemented, and you didn’t have to change your contract. Thanks for reading, buddy!
Leave a clap, share this article and do subscribe, if you found this article helpful.
<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=5c0f95da7f0d" width="1" height="1" alt="">

Learn how Django models could implement soft delete, without modifying the interfaces and contracts of models and querysets.

Implementing Soft Delete in Django: An Intuitive Guide

<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>

 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.

<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>

 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
 >.

<h3>What Are Decorators in Python?</h3>

 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:

<pre>def greet_someone(name: str): return f&quot;Hello and welcome, {name}!&quot;</pre>

 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.

<pre>@translate def greet_someone(name: str): return f&quot;Hello and welcome, {name}!&quot;</pre>
<h3>How to write a Decorator in Python</h3>
Let us code the translate decorator.
By definition, we know that a decorator in Python is a callable which
<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>

 First, let’s define a function which takes in another function as a parameter.

<pre>def translate(original_func): ...</pre>
Next, we are going to make the translate decorator return a new method.
<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>

 Now, let’s see how our @translate decorated method stacks up against the other
 original method.

<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>

 Now, that we have seen our decorator at work, let’s modify the decorator to be
 an actual translator


 For the sake of this tutorial example, we are using a library called
 googletrans. So, let’s go ahead and install the library:

<pre>pip install googletrans</pre>

<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>

 We see the following output, correctly translated to the app’s language
 of french.

<pre>Bonjour et bienvenue Pierre !</pre>

 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.


 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”.

<h4>Passing Parameters to Decorators</h4>

 For a decorator to accept parameters in Python, we would have to wrap our
 decorator inside another function which would take these parameter(s).


 Let’s go back and modify our @translate decorator to take in a language
 parameter, and then translate our text to the specified language.

<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>

 Now, we get the output of our function translated into the language of our
 choosing and specification — in this case Portuguese “pt”.

<pre>Olá e bem-vindo, Pierre!</pre>
<h4>Nesting Decorators</h4>

 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.

In other words,
<pre>@first_decorator @second_decorator @third_decorator def my_function(): print(&quot;Hello&quot;)</pre>
Could be expressed as
<pre>first_decorator(second_decorator(third_decorator(my_function)))</pre>
<h3>Use-cases for Decorators in Python</h3>
<ol>
 <li>
 Reusing impossible to use code: Decorators could serve as
 an adapter, modifying certain parameters to fit certain methods.
 </li>
 <li>
 Logging, analytics, monitoring: We could use decorators
 monitor how long a function takes to perform, and log this for analytical
 purposes.
 </li>
 <li>
 Avoiding repetitions: 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>

 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.

Thank you!
<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>

 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
 >.

<h3>Why Are Interfaces so Vital in Software Engineering?</h3>

 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.

Cool, right?

 Now, at some point in time, we Python-istas 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. Well, not quite so.

<h3>How Would Interfaces Be Implemented in Python</h3>

 An interface would be implemented in Python as an
 abstract class.

<h4>What Is an Abstract Class</h4>

 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.


 The key characteristic of interfaces,
 is that they enforce the implementation of certain methods in
 classes,
 and by definition of abstract classes, this, is catered for.

<h4>Declaring an Abstract Class in Python</h4>

 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).

We could define an abstract class in any one of two ways:
<pre>from abc import ABC, ABCMeta </pre>
<pre># using the abc.ABCMeta as a metaclass class HumanInterface(metaclass=ABCMeta): pass</pre>
<pre># inheriting the abc.ABC class class HumanInterface(ABC): pass</pre>

 The latter is preferred as a shorthand to declaring an abstract class, as ABC is a class which already has ABCMeta as its metaclass, thus it makes room easier for the developer to
 add another metaclass declaration.

Now, let’s add our first interface methods to our HumanInterface.
<pre>
from abc import ABC, abstractmethod

class HumanInterface(ABC):
 @abstractmethod
 def greet(self):
 pass
</pre>

 We have our interface set in, it is time for a concrete implementation to test
 that our interface method will be enforced.

<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>

 The Python interpreter throws an error we expect from an interface’s concrete
 implementation.

<pre>
TypeError: Can’t instantiate abstract class Hispanic with abstract methods greet</pre
>

 Let us take a look at what happens when we implement the greet method in our
 Hispanic class.

<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>

 Pretty neat, right?!


 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.


 In the next <a href="https://tomisin.dev/blog">article</a>, we will be
 comparing and contrasting abstract class and interfaces.


 If you found this article useful or learnt something in this article, please
 clap, share and subscribe.

<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>
<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>

 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 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.

<blockquote>
 Magic methods simply refer to
 special methods that begin and end with double underscores.
 They are also called “dunder” methods.
</blockquote>

 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.


 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.


 But, before diving into the special methods for each native type, let us get
 familiar with basic methods common across all variables.

<h3>Understanding Magic Methods in Python</h3>
<h4>Instantiation Functions</h4>

 __new__(self, *args, **kwargs) is the first step of instance creation. It’s
 called first and is responsible for returning a new instance
 of your class. Use this method if you want to control the way new instances
 are created.


 __init__(self, *args, **kwargs) this class method is called whenever we want
 to initialise a new instance. Thus,
 it is called right after an instance has been created
 by the __new__ method. The __init__ method in Python does not return anything.


 __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.

<h4>Presentation Functions</h4>

 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.


 __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.


 __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.


 __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;.

<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>

 __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.

__sizeof__(self) helps identity the size of an object in bytes.
<h4>Equality Signs</h4>

 These functions are invoked when the interpreter encounters an equality sign
 between two variables. These include:


 __eq__(self, x) when we compare if two variables are equal in value, the
 interpreter triggers this method to get a result.


 __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.


 __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.


 __lt__(self, x) intuitively, this stands for “less than” and is called when
 the greater than arithmetic symbol &lt; is in between two variables.


 __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.

<h3>Magic Methods for Native Types</h3>
<h4>Numbers</h4>

 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.


 __add__(self, x) this method is invoked by the Python interpreter when the “+”
 sign is encountered between two variables.


 __mul__(self, x) for the multiplication arithmetic operation, this special is
 invoked implicitly by the interpreter.


 __sub__(self, x) to give our object the ability to get subtracted from, we can
 add this method.


 Real World Example #1: A More Pythonic Temperature Class First, let’s define a simple class that holds the temperature for a
 particular room.

<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>

 When we try to add a value to an instance of our temperature class, we get
 an error.

<pre>&gt;&gt;&gt; Temperature(30, 'C') + 1</pre>
<pre>TypeError: unsupported operand type(s) for +: 'Temperature' and 'int'</pre>

 Now, let’s extend the class and give it the ability to perform arithmetic
 operations by implementing the __add__ method.

<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>

 Now, let’s see the result after we add a custom __add__ method to our
 temperature class.

<pre>&gt;&gt;&gt; Temperature(30, 'C') + 6 &lt;Temperature: 36°C&gt;</pre>
<pre>&gt;&gt;&gt; Temperature(30, 'C') + Temperature(35.6, 'F') &lt;Temperature: 38°C&gt;</pre>
<pre>&gt;&gt;&gt; Temperature(34, 'C') + Temperature(66, 'C') &lt;Temperature: 100°C&gt;</pre>
<h4>Iterables: Lists, Tuples, Strings, Sets</h4>

 __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"])


 __delitem__(self, key) when an item is deleted from an iterable via del
 keyword, this method gets triggered (for example del my_dict[x])


 __getitem__(self, key) this method is invoked by the interpreter when the
 accessor syntax is used on a variable (for example: my_variable[x])


 __iter__(self) the iter method is used in generator expressions, to yield one
 item of the array at a time.


 __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.


 __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 immutable.

<h4>Real-life Example #2: A More Pythonic Approach to the Scrabble Game</h4>

 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.

<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>

 Tiles 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.

<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>
Tiles could then be declared and used in the game like this:
<pre>tile_a = Tile('A', 1) tile_q = Tile('Q', 10)</pre>
<pre>print(tile_a) # A (1)</pre>
<pre>print(tile_q) # Q (10)</pre>
<pre>print(tile_q &gt; tile_a) # True</pre>

 Cells 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.

<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>

 Board 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,
 we will be making this a <a href="https://en.wikipedia.org/wiki/Singleton_pattern"
 >Singleton</a
 > class.

<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>

 Move 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.

<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>

 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.

<pre>move_one = Move([ [tile_a, cell_1], [tile_c, cell_2], [tile_e, cell3] ]) print(move_one) # ACE = 5</pre>
<pre>move_two = Move([ [tile_z, cell_1], [tile_o, cell_2], [tile_o, cell3] ]) print(move_two) # ZOO = 12</pre>
<pre>print(move_one &gt; move_two) # False</pre>
<pre>print(move_one &lt; move_two) # True</pre>
<h3>Conclusion</h3>

 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.

<pre>Want to Connect?</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 />

 <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.

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>

 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 functions.

<blockquote>
 Type Hints — 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>

 In technical term, Python has dynamic type checking, 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.


 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.

<h3>Type Hints Syntax</h3>

 Python supports type annotation for the basic variable types supported by the
 language str, int, float, bool and None. It also comes with a
 typing library batteries included; this typing libraries provides us with
 means to use more special types.

<h4>Annotating Variables</h4>

 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.

<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>

 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.

<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>

 Now, that we are all warmed up and familiar with the type annotation syntax,
 let us get familiar with more complex types.

<h4>Any</h4>

 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.

<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>

 Literals are used to indicate to type checkers that the value a variable or
 function holds, is equal to one of the values specified.

<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>

 In the example above, gender will be one of the values in the GENDER literal
 declaration — “male”, “female” or “non-conforming”.

<h4>Union</h4>

 Sometimes, a variable may have properties cutting across two type
 declarations. A variable might also be of two types.

<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>

 Dictionaries being one of the simplest forms of Data Structure in Python, are
 among the most used variable types in the language.


 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 what goes where gets hectic as you scale.

<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>

 NoReturn type is similar to void in other programming languages. It is used to
 declare that a function does not have any return.

<pre>
# type_hints_tutorials.py
from typing import NoReturn


def say_greeting() -> NoReturn:
 print("Hello World!")
</pre>
<h4>Final</h4>

 This is a typing construct used to indicate that a variable is not to be
 re-assigned or overridden in a subclass.

<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>

 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.

You can use mypy in two ways:
<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>

 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.

<h4>2. Enable static type-checking</h4>

 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.

<h4>3. Use tuples for fixed length arrays</h4>

 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.

<h4>4. Function return types</h4>

 Functions should do one thing and one thing only, thus they should have a
 single deterministic type.

<pre>Want to Connect?</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 />

 <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.

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

Improving Your Python Projects With Type Hints

Python is an interpreted high-level general-purpose programming language.

coding

Maximize Your Python Search Capabilities with Huntela

database

Implementing Soft Delete in Django: An Intuitive Guide

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

clean-code