Learn the fundamental principles behind OOP and how they connect to the syntax of Python.<\/p>\n\n
Welcome!\nThis article will teach you the core ideas behind object-oriented programming<\/strong>, commonly known as OOP<\/strong>.\nThis is the article I wish I read many years ago, when I was first learning about OOP in Python.<\/p>\n If you're new to OOP, this article will explain why OOP exists, how it works, and how to work with OOP in Python.\nIf you think you already know OOP, this article will change the way you think about programming and Python.<\/p>\n Let me tell you about a programming project I had to do in college where you had to write a library management service.\nWe were expected to work in pairs and I was paired with my good friend Tito.<\/p>\n Tito and I sat down and started going through the problem statement, figuring out what we needed to implement.\nWe got to a point where Tito turned to me and said:<\/p>\n “It's not obvious to me what's the best way to represent a book<\/em><\/strong> in our program.\nMaybe you can start implementing the search functionality and I'll think about this for a while.”<\/p>\n<\/blockquote>\n The search functionality<\/em> was a set of functions that the problem statement required us to implement:<\/p>\n I nodded, but then I thought about it for a second.\nIf I don't know anything<\/em> about how to work with books, there's no way I can implement these three functions.\nTito agreed with me and told me he'd provide me with these functions:<\/p>\n He told me to think of these functions as auxiliary functions that he would implement.\nI didn't have them yet<\/em>, but I could write my search functions trusting<\/em> he'd implement them correctly.<\/p>\n In OOP, you have entities with associated data (books with authors, titles, and genres) and a set of functions to operate on those entities (the functions Now, think about it for a second.\nCan you<\/em> implement the functions I worked on it for a bit, and eventually used a list comprehension<\/a> to define the function The function Something worth...<\/p>","summary":"Learn the fundamental principles behind OOP and how that connects to the Python syntax for class definition.","date_modified":"2026-09-29T18:25:53+02:00","tags":["python","programming","oop"],"image":"\/user\/pages\/02.blog\/why-oop-exists\/thumbnail.webp"},{"title":"TIL #127 \u2013 Dynamically changing the type","date_published":"2025-07-20T22:27:00+02:00","id":"https:\/\/mathspp.com\/blog\/til\/dynamically-changing-the-type","url":"https:\/\/mathspp.com\/blog\/til\/dynamically-changing-the-type","content_html":" Today I learned that you can dynamically change the type of an object in Python.<\/p>\n\n An object's type can be checked by using the built-in You can also access that information directly by checking the dunder attribute Apparently, for your own custom types, you can assign<\/em> to the dunder attribute For example, the variable Now, you can define the class I learned this in a cool lightning talk given at EuroPython 2025!<\/p>","summary":"Today I learned that you can dynamically change the type of an object in Python.","date_modified":"2025-10-20T22:34:56+02:00","tags":["oop","programming","python"],"image":"\/user\/pages\/02.blog\/04.til\/127.dynamically-changing-the-type\/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":" 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 Descriptors are not black magic and this article will show you that.\nIn fact, you use descriptors every day and you don't even know it.<\/p>\n\n (If you are new here and have no idea what a Pydon't is, you may want to read the\nPydon't Manifesto<\/a>.)<\/p>\n Descriptors are a piece of the Python world that many will declare as “obscure”, “dark magic”, or “too complex to bother learning”.\nI will show you that this is not<\/em> true.<\/p>\n While we can all agree that descriptors do not belong in an introductory course to Python, descriptors are far from black magic and with a couple of good examples you can understand how they work and what they are useful for.<\/p>\n In this Pydon't, you will<\/p>\n You can get all the Pydon'ts as a free ebook with over +400 pages and hundreds of tips<\/a>. Download the ebook “Pydon'ts – write elegant Python code” here<\/a>.<\/p>\n<\/div>\n\n Consider the implementation of the class This class doesn't do much (at least, for now...):<\/p>\n Now, suppose that you want to add the attributes This works as expected:<\/p>\n If you have an attentive eye, you will notice that the three properties are pretty much the same.\nThe only difference lies in the indices you use when slicing the parameter Descriptors, like properties, let you customise attribute lookup.\nHowever, descriptors give you more<\/em> freedom because you implement a descriptor as a class.\nThis is different from properties that are usually implemented via their getter, setter, and deleter methods.<\/p>\n Later, you will understand that descriptors give you more freedom because properties are<\/em> a specific descriptor.\nIn a way, properties provide a type of descriptor blueprint...<\/p>","summary":"Descriptors are not black magic and this article will show you that.","date_modified":"2025-11-14T12:33:53+01:00","tags":["dunder methods","oop","programming","python"],"image":"\/user\/pages\/02.blog\/02.pydonts\/describing-descriptors\/thumbnail.webp"},{"title":"Properties | Pydon't \ud83d\udc0d","date_published":"2023-05-14T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/properties","url":"https:\/\/mathspp.com\/blog\/pydonts\/properties","content_html":" Learn how to use properties to add dynamic behaviour to your attributes.<\/p>\n\n (If you are new here and have no idea what a Pydon't is, you may want to read the\nPydon't Manifesto<\/a>.)<\/p>\n Properties, defined via the In this Pydon't, you will<\/p>\nCode is about real-world things<\/a><\/h2>\n
\n
find_by_title(catalog, search_term)<\/code>: returns a sublist with the books whose title contains the given search term<\/li>\nfind_by_genre(catalog, genre)<\/code>: returns a sublist with the books of the given genre<\/li>\nfind_by_author(catalog, author)<\/code>: returns a sublist with the books written by the given author<\/li>\n<\/ul>book_title(book)<\/code>: returns the title of the given book<\/li>\nbook_genre(book)<\/code>: returns the genre of the given book<\/li>\nbook_author(book)<\/code>: returns the author of the given book<\/li>\n<\/ul>find_by_xxx<\/code>).<\/p>\n<\/div>\nfind_by_title<\/code>, find_by_genre<\/code>, and find_by_author<\/code>, using the auxiliary functions that Tito will implement?\nHow would you go about it?<\/p>\nfind_by_title<\/code>:<\/p>\ndef find_by_title(catalog, search_term):\n search_term = search_term.casefold()\n return [\n book\n for book in catalog\n if search_term in book_title(book).casefold()\n ]<\/code><\/pre>\nfind_by_title<\/code> goes through the list of books called catalog<\/code> with a loop and uses the auxiliary function book_title<\/code> to retrieve the title.\nIt then uses casefold<\/code> to perform a case-insensitive search<\/a>.<\/p>\nDynamically changing the type<\/a><\/h2>\n
type<\/code>:<\/p>\nprint(type(3)) # <class 'int'><\/code><\/pre>\n__class__<\/code>:<\/p>\nprint((3).__class__) # <class 'int'><\/code><\/pre>\n__class__<\/code> and dynamically change the type of an instance.<\/p>\nx<\/code> below holds an instance of the class A<\/code> that doesn't have any methods:<\/p>\nclass A:\n def __init__(self, value):\n self.value = value\n\nx = A(42)<\/code><\/pre>\nB<\/code> that defines a method, you can assign x.__class__<\/code> to it, and you can call that method:<\/p>\nclass B:\n def mult(self, x):\n return self.value * x\n\nx.__class__ = B\nprint(type(x)) # <class '__main__.B'> !?\nprint(x.mult(10)) # 420<\/code><\/pre>\n__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":"Describing Descriptors | Pydon't \ud83d\udc0d","date_published":"2023-06-13T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/describing-descriptors","url":"https:\/\/mathspp.com\/blog\/pydonts\/describing-descriptors","content_html":"Introduction<\/a><\/h2>\n
__get__<\/code>;<\/li>\n__set__<\/code>; and<\/li>\n__delete__<\/code>.<\/li>\n<\/ul><\/li>\n__set_name__<\/code> with descriptors;<\/li>\nproperty<\/code>;<\/li>\nstaticmethod<\/code>; and<\/li>\nclassmethod<\/code>.<\/li>\n<\/ul><\/li>\nThe problem that descriptors solve<\/a><\/h2>\n
Colour<\/code> below, which contains a hex<\/code> attribute for the hexadecimal representation of the colour:<\/p>\nclass Colour:\n def __init__(self, hex):\n self.hex = hex<\/code><\/pre>\n>>> colour = Colour(\"#f8f8f2\")\n>>> colour.hex\n'#f8f8f2'<\/code><\/pre>\nr<\/code>, g<\/code>, and b<\/code>, respectively for the red, green, and blue, components of the colour.\nThese attributes depend on the value of the hexadecimal representation of the colour, and you know all about properties<\/a>, so you understand that defining three properties is the way to go, here:<\/p>\nclass Colour:\n def __init__(self, hex_string):\n self.hex = hex_string\n\n @property\n def r(self):\n return int(self.hex[1:3], 16)\n\n @property\n def g(self):\n return int(self.hex[3:5], 16)\n\n @property\n def b(self):\n return int(self.hex[5:7], 16)<\/code><\/pre>\n>>> red = Colour(\"#ff0000\")\n>>> red.r\n255\n>>> red.g, red.b\n(0, 0)<\/code><\/pre>\nhex<\/code>.<\/p>\nIntroduction<\/a><\/h2>\n
property<\/code> built-in, are a Python feature that lets you add dynamic behaviour behind what is typically a static interface: an attribute.\nProperties also have other benefits and use cases, and we will cover them here.<\/p>\nproperty<\/code>;<\/li>\nproperty<\/code> to implement read-only attributes;<\/li>\n