<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 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

coding

Maximize Your Python Search Capabilities with Huntela

coding

Supercharging Python Classes with Magic Methods

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