Learn how objects are automatically iterable if you implement integer indexing.<\/p>\n\n
An iterable<\/strong> in Python is any object you can traverse through with a This article will show you how you can create your own iterable objects through the implementation of integer indexing.<\/p>\n To make an object that can be indexed you need to implement the method As an example, you'll implement a class If your object accepts integer indices, then it is automatically<\/em> an iterable.\nIn fact, you can already iterate over the sequence you created above by simply using it in a You might ask yourself “how does Python inspect To illustrate this point, you can define a class Since What's interesting is that you can see explicitly that Python tried to index the object Dip your toes in metaprogramming and learn about This is the written version of my PyCon Italy 2025 talk<\/a>, which serves as a trial run for myself and as supporting material for folks who attended the talk, or who couldn't attend but are interested in reading about it.<\/p>\n Are you comfortable with the short REPL session from above?\nDon't you think it's weird you try to create an instance of the class Isn't it funky how the class that we get depends on your context?\nIn this particular case, on your operating system?<\/p>\n I was using the module The plan for this talk is to<\/p>\n To get things rolling, we will start off by trying to emulate the instantiating pattern exhibited by So, we want to build a hierarchy that looks like this:<\/p>\n And the point is that, when you instantiate the class Now, when trying to solve this problem, you might start by writing this code:<\/p>\n And now you're thinking “What the hell do I write in Today I learned how to allow my custom objects to be unpacked into keyword arguments like '**kwargs'.<\/p>\n\n If you have a dictionary, you can use the This can also be used to unpack a dictionary into keyword arguments:<\/p>\n If you want to be able to use the syntax The method The dunder method The dunder method<\/a> The dunder methods The dunder method The return statement includes The dunder method For example, if we create a class Usually, the dunder method This snippet of code shows that It is relevant to note that Python will call In the snippet below, we create the class This may look a bit weird but it's actually a pattern that is...<\/p>","summary":"The dunder method __new__ is used to customise object creation and is a core stepping stone in understanding metaprogramming in Python.","date_modified":"2025-07-23T16:49:02+02:00","tags":["dunder methods","metaprogramming","oop","programming","python"],"image":"\/user\/pages\/02.blog\/customising-object-creation-with-__new__\/thumbnail.webp"},{"title":"Case-insensitive string class","date_published":"2024-07-24T12:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/case-insensitive-string-class","url":"https:\/\/mathspp.com\/blog\/case-insensitive-string-class","content_html":" This article shows how you can create a case-insensitive string class using some basic meta programming with the dunder method In this article we want to implement a case-insensitive string class, that we will call Here are two examples of what we're looking for:<\/p>\n To compare two strings in a case-insensitive way, we need to use the string method This implementation of If we didn't do this in the final implementation shown here we would hit an infinite recursion loop.<\/p>\n To make sure that all comparisons are case-insensitive, we also need to take care of the comparison operators Strings have dozens of methods, like For example, as it stands, if we use a method like This can be achieved if we reimplement every single string method by hand but there is a shorter way.\nTo do this, we define two decorators:<\/p>\n This article shows how to implement the set built-in at the expense of a dictionary.<\/p>\n\n A set is a built-in container data type in Python that provides fast lookup and insertion.\nIn exchange for that speed, sets are unordered, only hold unique elements, and its elements must be hashable.\nThese characteristics are similar to those of dictionary keys1<\/a><\/sup> and this shows that a set can actually be implemented as a dictionary with no values.\nIn this article we will explore this relationship between sets and dictionaries by implementing our own set class.<\/p>\n If you are more interested in learning about how to best use sets (and frozensets) in your code, you can learn how and when to use sets in this article<\/a>.<\/p>\n When I talk about a “dictionary with no values” what I really mean is that the values that we assign to the dictionary keys don't matter.\nIn our implementation of sets we will always use Notice how we're using the class method In for<\/code> loop.\nIterables<\/strong> are typically containers and iterating over the iterable object allows you to access the elements of the container.<\/p>\nIndexing with
__getitem__<\/code><\/a><\/h2>\n__getitem__<\/code>.<\/p>\nArithmeticSequence<\/code> that represents an arithmetic sequence<\/strong>, like \\(5, 8, 11, 14, 17, 20\\)<\/span>.\nAn arithmetic sequence is defined by its first number (\\(5\\)<\/span>), the step between numbers (\\(3\\)<\/span>), and the total number of elements (\\(6\\)<\/span>).\nThe sequence \\(5, 8, 11, 14, 17, 20\\)<\/span> is seq = ArithmeticSequence(5, 3, 6)<\/code> and seq[3]<\/code> should be \\(14\\)<\/span>.\nUsing some arithmetic, you can implement indexing in __getitem__<\/code> directly:<\/p>\nclass ArithmeticSequence:\n def __init__(self, start: int, step: int, total: int) -> None:\n self.start = start\n self.step = step\n self.total = total\n\n def __getitem__(self, index: int) -> int:\n if not 0 <= index < self.total:\n raise IndexError(f\"Invalid index {index}.\")\n\n return self.start + index * self.step\n\nseq = ArithmeticSequence(5, 3, 6)\nprint(seq[3]) # 14<\/code><\/pre>\nTurning an indexable object into an iterable<\/a><\/h2>\n
for<\/code> loop:<\/p>\nfor value in seq:\n print(value, end=\", \")\n# 5, 8, 11, 14, 17, 20,<\/code><\/pre>\nHow Python distinguishes iterables from non-iterables<\/a><\/h2>\n
__getitem__<\/code> to see it uses numeric indices?”\nIt doesn't!\nIf your object implements __getitem__<\/code> and you try to use it as an iterable, Python will try<\/em> to iterate over it.\nIt either works or it doesn't!<\/p>\nDictWrapper<\/code> that wraps a dictionary and implements __getitem__<\/code> by just grabbing the corresponding item out of a dictionary:<\/p>\nclass DictWrapper:\n def __init__(self, values):\n self.values = values\n\n def __getitem__(self, index):\n return self.values[index]<\/code><\/pre>\nDictWrapper<\/code> implements __getitem__<\/code>, if an instance of DictWrapper<\/code> just happens<\/em> to have some integer keys (starting at 0<\/code>) then you'll be able to iterate partially over the dictionary:<\/p>\nd1 = DictWrapper({0: \"hey\", 1: \"bye\", \"key\": \"value\"})\n\nfor value in d1:\n print(value)<\/code><\/pre>\nhey\nbye\nTraceback (most recent call last):\n File \"<python-input-25>\", line 3, in <module>\n for value in d1:\n ^^\n File \"<python-input-18>\", line 6, in __getitem__\n return self.values[index]\n ~~~~~~~~~~~^^^^^^^\nKeyError: 2<\/code><\/pre>\nd<\/code> with the key 2<\/code> and it didn't work.\nIn the ArithmeticSequence<\/code> above, you didn't get an error because you raised IndexError<\/code> when you reached the end and that's how Python understood the iteration was done.\nIn this case, since you get a KeyError<\/code>, Python doesn't understand what's going on and just...<\/p>","summary":"Learn how objects are automatically iterable if you implement integer indexing.","date_modified":"2026-04-03T15:09:51+02:00","tags":["python","programming","dunder methods"],"image":"\/user\/pages\/02.blog\/indexable-iterables\/thumbnail.webp"},{"title":"Dipping my toes in metaprogramming","date_published":"2025-05-30T11:48:00+02:00","id":"https:\/\/mathspp.com\/blog\/dipping-my-toes-in-metaprogramming","url":"https:\/\/mathspp.com\/blog\/dipping-my-toes-in-metaprogramming","content_html":"__init__<\/code>'s big brother, the dunder method __new__<\/code>.<\/p>\n\nCold opening<\/a><\/h2>\n
>>> from pathlib import Path\n>>> Path(\".\")\nPosixPath('.')\n>>> type(Path(\".\")) == Path\nFalse<\/code><\/pre>\nPath<\/code> but instead you get an instance of the class PosixPath<\/code>?\nI mean, in your computer you might even get something different: an instance of the class WindowsPath<\/code>.<\/p>\nOutline for this talk<\/a><\/h2>\n
pathlib<\/code> one day and I thought that this was weird, so today I will show you how this works.\nSadly for you, but thankfully for me, this is not going to be a hardcore metaprogramming talk.\nAfter all, it is called “Dipping<\/em> my toes in metaprogramming”, not “Drowing in metaprogramming”.\nWhat this talk is, is an introduction to a very useful metaprogramming tool, that sits right on the fence between crazy, esoteric metaprogramming and general Python knowledge that is likely to help you out sooner or later.<\/p>\nParity<\/a><\/h2>\n
Path<\/code>, but with different classes.\nWe will create a class Number<\/code>, that takes integers, and that produces one of its subclasses:<\/p>\nOddNumber<\/code>, if the integer was odd; or<\/li>\nEvenNumber<\/code>, if the integer was even.<\/li>\n<\/ul>class Number:\n ...\n\nclass EvenNumber(Number): ...\nclass OddNumber(Number): ...<\/code><\/pre>\nNumber<\/code>, you get an instance of EvenNumber<\/code> or OddNumber<\/code>, depending on the parity of the argument:<\/p>\nprint(type(Number(2))) # <class '__main__.EvenNumber'><\/code><\/pre>\nclass Number:\n def __init__(self, value):\n ...\n\nclass EvenNumber(Number): ...\nclass OddNumber(Number): ...<\/code><\/pre>\nNumber.__init__<\/code>?”.\nBut, the truth is...\nInside Number.__init__<\/code> it's already too late for whatever you need to do!\nThe argument self<\/code> is already a reference to an object whose type is Number<\/code> and you can't “hot-swap”...<\/p>","summary":"Dip your toes in metaprogramming and learn about `__init__`'s big brother, the dunder method `__new__`.","date_modified":"2025-07-23T16:49:02+02:00","tags":["dunder methods","metaprogramming","programming","python"],"image":"\/user\/pages\/02.blog\/dipping-my-toes-in-metaprogramming\/thumbnail.webp"},{"title":"TIL #109 \u2013 Unpacking kwargs with custom objects","date_published":"2025-01-05T14:34:00+01:00","id":"https:\/\/mathspp.com\/blog\/til\/unpacking-kwargs-with-custom-objects","url":"https:\/\/mathspp.com\/blog\/til\/unpacking-kwargs-with-custom-objects","content_html":"Unpacking kwargs with custom objects<\/a><\/h2>\n
**<\/code> syntax to unpack its keys and values.\nFor example, you can use that to merge two dictionaries:<\/p>\nd_en = {1: \"one\", 2: \"two\"}\nd_pt = {2: \"dois\", 3: \"tr\u00eas\"}\nd = {**d_en, **d_pt}\nprint(d) # {1: 'one', 2: 'dois', 3: 'tr\u00eas'}<\/code><\/pre>\ndef foo(first, middle, last):\n return f\"{first} {middle} {last}\"\n\nname_bits = {\n \"last\": \"Potter\",\n \"middle\": \"James\",\n \"first\": \"Harry\",\n}\n\nprint(foo(**name_bits)) # Harry James Potter<\/code><\/pre>\n**<\/code> to unpack your own classes into keyword value pairs, your class must implement the method keys<\/code> and the dunder method __getitem__<\/code><\/a>.<\/p>\nkeys<\/code> must return an iterable with the keys your object is aware of and the dunder method __getitem__<\/code> must be able to return the values associated with the given keys:<\/p>\nclass HarryPotter: # A bit of a silly example!\n def keys(self):\n return [\"first\", \"middle\", \"last\"]\n\n def __getitem__(self, key):\n if key == \"first\":\n return \"Harry\"\n elif key == \"middle\":\n return \"James\"\n elif key == \"last\":\n return \"Potter\"\n else:\n raise KeyError()\n\nprint(foo(**HarryPotter())) # Harry James Potter<\/code><\/pre>","summary":"Today I learned how to allow my custom objects to be unpacked into keyword arguments like '**kwargs'.","date_modified":"2025-10-20T22:34:56+02:00","tags":["dunder methods","python","programming"],"image":"\/user\/pages\/02.blog\/04.til\/109.unpacking-kwargs-with-custom-objects\/thumbnail.webp"},{"title":"Customising object creation with __new__","date_published":"2024-07-24T16:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/customising-object-creation-with-__new__","url":"https:\/\/mathspp.com\/blog\/customising-object-creation-with-__new__","content_html":"__new__<\/code> is used to customise object creation and is a core stepping stone in understanding metaprogramming in Python.<\/p>\n\n__new__<\/code> is a static method that creates new instances of your class and, therefore, can be used to customise that process.<\/p>\n__init__<\/code> and __new__<\/code> can look quite similar at first sight.\nThe dunder method __init__<\/code><\/a> will initialise<\/em> your instance of your class, but that instance must be created before it can be initialised, and that's the job of the dunder method __new__<\/code>.<\/p>\nArguments of the dunder method
__new__<\/code><\/a><\/h2>\n__new__<\/code> accepts, as arguments, the class we are trying to create an instance of and all of the arguments passed to the class constructor, as shown in the snippet below:<\/p>\nclass C:\n def __new__(cls, *args, **kwargs):\n print(cls, args, kwargs)\n return super().__new__(cls)\n\nC() # <class '__main__.C'> () {}\nC(73, True, a=15) # <class '__main__.C'> (73, True) {'a': 15}<\/code><\/pre>\nsuper().__new__(cls)<\/code>, which is the typical way in which the object we want to create is brought to life.<\/p>\nThe return value of the dunder method
__new__<\/code><\/a><\/h2>\n__new__<\/code> can return any object whatsoever and the return value of the dunder method __new__<\/code> is the result we get when we instantiate the class.<\/p>\nC<\/code> whose dunder method __new__<\/code> returns 73, then whenever we try to instantiate the class C<\/code> we get the number 73:<\/p>\nclass C:\n def __new__(cls):\n return 73\n\nc = C()\nprint(c) # 73\nprint(type(c)) # int<\/code><\/pre>\n__new__<\/code> will return an instance of the class it's in.\nWhen that is the case, Python will automatically call the dunder method __init__<\/code> on the object that was returned and it will pass along the arguments that were specified in the class constructor.\nSo, if __init__<\/code> gets called, it will receive the same arguments that __new__<\/code> received.<\/p>\n__init__<\/code> only gets called when the return value is an instance of the class where the method __new__<\/code> is defined:<\/p>\nclass C:\n def __new__(cls, *, return_73):\n if return_73:\n return 73\n else:\n return super().__new__(cls)\n\n def __init__(self, *args, **kwargs):\n print(\"__init__!\")\n\nx = C(return_73=True)\nprint(x) # 73\ny = C(return_73=False) # __init__!\nprint(y) # <__main__.C object at 0x4ac5a507510><\/code><\/pre>\n__init__<\/code> on the object returned even if it's an instance of a subclass<\/em> of the class where the method __new__<\/code> is running!<\/p>\nC<\/code> and its subclass D<\/code>.\nC<\/code> defines the dunder method __new__<\/code> and both classes define their respective dunder methods __init__<\/code>.\nWhen we create an instance of C<\/code>, we actually get an instance of D<\/code> and the dunder method D.__init__<\/code> gets called automatically:<\/p>\nclass C:\n def __new__(cls):\n return super().__new__(D)\n\n def __init__(self):\n print(\"C.__init__\")\n\nclass D(C):\n def __init__(self):\n print(\"D.__init__\")\n\nd = C() # D.__init__\nprint(type(d)) # <class '__main__.D'><\/code><\/pre>\n__new__<\/code>.<\/p>\n\nCIStr<\/code>, such that the comparisons between an instance of CIStr<\/code> and a regular string, or between two CIStr<\/code> instances, are done in a case-insensitive way.<\/p>\n>>> CIStr(\"Hello\") == \"heLLO\"\nTrue\n>>> \"heLLO\" == CIStr(\"Hello\")\nTrue<\/code><\/pre>\nCase-insensitive equality comparison<\/a><\/h2>\n
casefold<\/code><\/a>.\nSo, when we implement our class CIStr<\/code>, its __eq__<\/code> and __ne__<\/code> methods should use casefold<\/code> on both string values before comparing them:<\/p>\nclass CIStr(str):\n def __eq__(self, other):\n return self.casefold() == other.casefold()\n\n def __ne__(self, other):\n return str.__ne__(self.casefold(), other.casefold())\n\nprint(CIStr(\"hello\") == \"HELlo\") # True<\/code><\/pre>\n__eq__<\/code> works because self.casefold()<\/code> will produce a standard string, which is then compared to other.casefold()<\/code> through the default dunder method __eq__<\/code>, not the one we defined here.\nIf we end up changing the CIStr<\/code> string methods to also return case-insensitive strings, then we may need to be more explicit about the fact that we want to use str.__eq__<\/code> after casefolding both strings:<\/p>\nclass CIStr(str):\n def __eq__(self, other):\n return str.__eq__(self.casefold(), other.casefold())\n\nprint(CIStr(\"hello\") == \"HELlo\") # True<\/code><\/pre>\nAll case-insensitive comparisons<\/a><\/h2>\n
<<\/code>, <=<\/code>, ><\/code>, and >=<\/code>.\nWe could think of using functools.total_ordering<\/code> but that will not work because str<\/code> already defines the comparison dunder methods and we need to override their default behaviour:<\/p>\nclass CIStr(str):\n def __eq__(self, other):\n return str.__eq__(self.casefold(), other.casefold())\n\n def __ne__(self, other):\n return str.__ne__(self.casefold(), other.casefold())\n\n def __lt__(self, other): # <\n return str.__lt__(self.casefold(), other.casefold())\n\n def __le__(self, other): # <=\n return str.__le__(self.casefold(), other.casefold())\n\n def __gt__(self, other): # <=\n return str.__gt__(self.casefold(), other.casefold())\n\n def __ge__(self, other): # <=\n return str.__ge__(self.casefold(), other.casefold())\n\nprint(CIStr(\"hello\") == \"HELlo\") # True\nprint(CIStr(\"Hello\") > \"abracadabra\") # True (H comes after A)<\/code><\/pre>\nPatch string methods to accept and return case-insensitive strings<\/a><\/h2>\n
upper<\/code>, startswith<\/code>, and split<\/code>.\nWhat if wanted those methods to work with case-insensitive strings and<\/em> return case-insensitive strings automatically?<\/p>\nupper<\/code> on a case-insensitive string, we no longer get a case-insensitive string back.\nBut we can fix this.\nWe can patch every single string method so that:<\/p>\npatch_string_methods<\/code>) that will wrap CIStr<\/code> which will traverse the string methods, looking for all of the methods that are not dunder...<\/li><\/ol>","summary":"This article shows how you can create a case-insensitive string class using some basic meta programming with the dunder method __new__.","date_modified":"2025-07-23T16:49:02+02:00","tags":["dunder methods","oop","programming","python"],"image":"\/user\/pages\/02.blog\/case-insensitive-string-class\/thumbnail.webp"},{"title":"Sets as dictionaries with no values","date_published":"2024-05-08T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/sets-as-dictionaries-with-no-values","url":"https:\/\/mathspp.com\/blog\/sets-as-dictionaries-with-no-values","content_html":"The internal representation of the set values<\/a><\/h2>\n
None<\/code> but you can use whatever you want.\nWith that said, we can start by implementing __init__<\/code> and __repr__<\/code> so that we can start instantiating our sets and printing them:<\/p>\nclass set_:\n \"\"\"Implementing a set as a dictionary with no values.\"\"\"\n\n def __init__(self, iterable=None):\n self.values = {} if iterable is None else dict.fromkeys(iterable)\n\n def __repr__(self):\n if not self.values:\n return \"set_()\"\n return \"{\" + \", \".join(map(repr, self.values.keys())) + \"}\"\n\nif __name__ == \"__main__\":\n s = set_(range(10))\n print(s) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\n s = set_()\n print(s) # set_()<\/code><\/pre>\ndict.fromkeys<\/code> to create a dictionary where all keys map to the value None<\/code> inside the dunder method __init__<\/code>:<\/p>\n>>> dict.fromkeys(range(3))\n{0: None, 1: None, 2: None}<\/code><\/pre>\n