This article serves as a complete reference for all the non-trivial things you should know about Python functions.<\/p>\n\n
Functions are the basic building block of any Python program you write, and yet, many developers don't leverage their full potential.\nYou will fix that by reading this article.<\/p>\n
Knowing how to use the keyword Bookmark this reference for later or download the “Pydon'ts – write elegant Python code”<\/a> ebook for free.\nThe ebook contains this chapter and many others, including hundreds of tips to help you write better Python code.\nDownload the ebook “Pydon'ts – write elegant Python code” here<\/a>.<\/p>\n<\/div>\n\n Do not overcrowd your functions with logic for four or five different things.\nA function should do a single thing, and it should do it well, and the name of the function should clearly tell you what your function does.<\/p>\n If you are unsure about whether some piece of code should be a single function or multiple functions, it's best to err on the side of too many functions.\nThat is because a function is a modular piece of code, and the smaller your functions are, the easier it is to compose them together to create more complex behaviours.<\/p>\n Consider the function This article teaches the decorator pattern in Python, why it exists, how to use it, and when to use it to write efficient and idiomatic Python code.<\/p>\n\n The decorator pattern is a functional pattern that Python developers leverage to write more modular and composable functions.\nIn this Pydon't, you will learn exactly why the decorator pattern matters, how to use it, and when to use it.\nYou will also learn how to implement your custom decorators and more advanced use cases of decorators.<\/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 The decorator pattern is a pattern that lets you complement a function with behaviour that is useful but that is orthogonal to the original objective of the function.\nThis pattern is relevant because you do not want to overcrowd your functions<\/a>, and at the same time it allows you to define this useful behaviour in a way that is reusable by other functions.<\/p>\n As an example, consider how you might have implemented the mathematical operation factorial before it was introduced in the module If you are calling this function a lot with a few large integers as arguments, you may want to cache the results you compute.\nFor this effect, you may want to use a dictionary that maps inputs to outputs:<\/p>\n This solution is far from ideal, since you introduced a function cache that is only loosely coupled to the function it's relevant for, while also introducing code in the function that is not really relevant for the original objective of the function.<\/p>\n Instead of baking caching into the function, which is a poor one-time solution for something I might want to do with several functions, I can write a higher-order function that adds caching to any function I want.\nLet me walk you through this transformation.<\/p>\n Instead of slapping...<\/p>","summary":"This article teaches the decorator pattern in Python, why it exists, how to use it, and when to use it to write efficient and idiomatic Python code.","date_modified":"2025-11-14T12:33:53+01:00","tags":["fp","programming","python"],"image":"\/user\/pages\/02.blog\/02.pydonts\/decorators\/thumbnail.webp"},{"title":"Overloading arithmetic operators with dunder methods | Pydon't \ud83d\udc0d","date_published":"2023-07-31T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/overloading-arithmetic-operators-with-dunder-methods","url":"https:\/\/mathspp.com\/blog\/pydonts\/overloading-arithmetic-operators-with-dunder-methods","content_html":" This article shows you how to overload the arithmetic operators in Python with dunder methods.<\/p>\n\n Python lets you override the arithmetic operators like In this Pydon't, you will learn:<\/p>\n We will start by explaining how dunder methods work and we will give a couple of examples by implementing the unary operators.\nThen, we introduce the mechanics behind the binary arithmetic operators, basing the examples on the binary operator After we introduce all the concepts and mechanics that Python uses to handle binary arithmetic operators, we will provide an example of a class that implements all the arithmetic dunder methods that have been mentioned above.<\/p>\n\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 The example we will be using throughout this article will be that of a Let us go ahead and start!<\/p>\n This is the starting vector for our class Running this code will show this output:<\/p>\n This starting vector also shows two dunder methods that we are using right off the bat:<\/p>\n This shows that dunder methods are not<\/strong> magical.\nThey look funny because of the...<\/p>","summary":"This article shows you how to overload the arithmetic operators in Python with dunder methods.","date_modified":"2025-11-14T12:33:53+01:00","tags":["arithmetic","dunder methods","programming","python"],"image":"\/user\/pages\/02.blog\/02.pydonts\/overloading-arithmetic-operators-with-dunder-methods\/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":" 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>\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 A property is an attribute that is computed dynamically.\nThat's it.\nAnd you will understand what this means in a jiffy!<\/p>\n This is a class However, there is an issue with the implementation.\nCan you see what is the issue with this implementation?<\/p>\n I'll give you a hint:<\/p>\n When you implement How do we fix this?\nWell, we could provide methods that the user can use to set the first and last names of the This works:<\/p>\n However, we had to add two methods that look pretty much the same...\nAnd this would get worse if we introduced an attribute for middle names, for example...\nEssentially, this isn't a very Pythonic solution – it isn't very elegant.\n(Or, at least, we can do better!)<\/p>\n There is another alternative...\nInstead of updating This also works:<\/p>\n But this isn't very elegant,...<\/p>","summary":"Learn how to use properties to add dynamic behaviour to your attributes.","date_modified":"2025-11-14T12:33:53+01:00","tags":["oop","programming","python"],"image":"\/user\/pages\/02.blog\/02.pydonts\/properties\/thumbnail.webp"},{"title":"Dunder methods | Pydon't \ud83d\udc0d","date_published":"2022-07-09T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/dunder-methods","url":"https:\/\/mathspp.com\/blog\/pydonts\/dunder-methods","content_html":" This is an introduction to dunder methods in Python,\nto help you understand what they are and what they are for.<\/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 Python is a language that has a rich set of built-in functions and operators that work really well with the built-in types.\nFor example, the operator But what is it that defines that def<\/code> is just the first step towards knowing how to define and use functions in Python.\nAs such, this Pydon't covers everything else there is to learn:<\/p>\n*args<\/code> and **kwargs<\/code><\/a>, and the special syntax introduced by *<\/code> and \/<\/code><\/a>.<\/li>\nlambda<\/code>, and when to use them<\/a>.<\/li>\nyield<\/code> is and what generator functions are<\/a>.<\/li>\nasync<\/code> is and what asynchronous functions are<\/a>.<\/li>\nWhat goes into a function and what doesn't<\/a><\/h2>\n
process_order<\/code> defined below, an exaggerated example that breaks these best practices to make the point clearer.\nWhile it is not incredibly long, it does too many things:<\/p>\ndef process_order(order):\n # Validate the order:\n for item, quantity, price in order:\n if quantity <= 0:\n raise ValueError(f\"Cannot buy 0 or less of {item}.\")\n if price <= 0:\n raise ValueError(f\"Price must be positive.\")\n\n # Write the receipt:\n total = 0\n with open(\"receipt.txt\", \"w\") as f:\n for item, quantity, price in order:\n # This week, yoghurts and batteries are on sale.\n if \"yoghurt\" in item:\n price *= 0.8\n elif \"batteries\" in item:\n price *= 0.5\n # Write this line of the receipt:\n partial...<\/code><\/pre>","summary":"This article is a complete reference for all things related to functions in Python","date_modified":"2025-11-14T12:17:33+01:00","tags":["fp","programming","python"],"image":"\/user\/pages\/02.blog\/02.pydonts\/functions-a-complete-reference\/thumbnail.webp"},{"title":"Decorators | Pydon't \ud83d\udc0d","date_published":"2025-01-21T18:11:00+01:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/decorators","url":"https:\/\/mathspp.com\/blog\/pydonts\/decorators","content_html":"functools.wraps<\/code> should be used when defining decorators;<\/li>\nA function that did too much<\/a><\/h2>\n
math<\/code>:<\/p>\n# In modern Python: from math import factorial\ndef factorial(n):\n r = 1\n while n > 1:\n r *= n\n n -= 1\n return r<\/code><\/pre>\n_factorial_cache = {}\n\ndef factorial(n):\n if n not in _factorial_cache:\n _n = n\n r = 1\n while _n > 1:\n r *= _n\n _n -= 1\n _factorial_cache[n] = r\n\n return _factorial_cache[n]<\/code><\/pre>\nFactoring out the orthogonal behaviour<\/a><\/h2>\n
Introduction<\/a><\/h2>\n
+<\/code> for addition or *<\/code> for multiplication through dunder methods<\/a>.\nDunder methods<\/a> are special methods whose name starts and ends with a double underscore (hence, “dunder”), and some dunder methods<\/a> are specific to arithmetic operations.<\/p>\n-p<\/code>);<\/li>\n+p<\/code>);<\/li>\nabs(p)<\/code>); and<\/li>\n~<\/code>).<\/li>\n<\/ul><\/li>\n+<\/code>);<\/li>\n-<\/code>);<\/li>\n*<\/code>);<\/li>\n\/<\/code>);<\/li>\n\/\/<\/code>);<\/li>\n%<\/code>);<\/li>\ndivmod<\/code>); and<\/li>\npow<\/code>).<\/li>\n<\/ul><\/li>\n<<<\/code>);<\/li>\n>><\/code>);<\/li>\n&<\/code>);<\/li>\n|<\/code>);<\/li>\n^<\/code>);<\/li>\n<\/ul><\/li>\nNotImplemented<\/code> is and how it differs from NotImplementedError<\/code>; and<\/li>\n+<\/code>.<\/p>\nThe example we will be using<\/a><\/h2>\n
Vector<\/code>.\nA Vector<\/code> will be a class for geometrical vectors, like vectors in 2D, or 3D, and it will provide operations to deal with vectors.\nFor example, by the end of this article, you will have an implementation of Vector<\/code> that lets you do things like these:<\/p>\n>>> from vector import Vector\n>>> v = Vector(3, 2)\n>>> v + Vector(4, 10)\nVector(7, 12)\n>>> 3 * v\n(9, 6)\n>>> -v\n(-3, -2)<\/code><\/pre>\nVector<\/code>:<\/p>\n# vector.py\nclass Vector:\n def __init__(self, *coordinates):\n self.coordinates = coordinates\n\n def __repr__(self):\n return f\"Vector{self.coordinates}\"\n\nif __name__ == \"__main__\":\n print(Vector(3, 2))<\/code><\/pre>\nVector(3, 2)<\/code><\/pre>\n__init__<\/code><\/a> to initialise our Vector<\/code> instance; and<\/li>\n__repr__<\/code><\/a> to provide a string representation of our Vector<\/code> objects.<\/li>\n<\/ol>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>\nproperty<\/code> doesn't have to be used as a decorator;<\/li>\nproperty<\/code> in the standard library.<\/li>\n<\/ul>What is a property?<\/a><\/h2>\n
The problem<\/a><\/h3>\n
Person<\/code> with three vanilla attributes:<\/p>\nclass Person:\n def __init__(self, first, last):\n self.first = first\n self.last = last\n self.name = f\"{self.first} {self.last}\"\n\njohn = Person(\"John\", \"Doe\")<\/code><\/pre>\n>>> john = Person(\"John\", \"Doe\")\n>>> john.name\n'John Doe'\n>>> john.last = \"Smith\"\n>>> john.name\n## ?<\/code><\/pre>\nname<\/code> as a regular attribute, it can go out of sync when you change the attributes upon which name<\/code> depended on.<\/p>\nPerson<\/code> instance, and those methods could keep name<\/code> in sync:<\/p>\nclass Person:\n def __init__(self, first, last):\n self.first = first\n self.last = last\n self.name = f\"{self.first} {self.last}\"\n\n def set_first(self, first):\n self.first = first\n self.name = f\"{self.first} {self.last}\"\n\n def set_last(self, last):\n self.last = last\n self.name = f\"{self.first} {self.last}\"\n\njohn = Person(\"John\", \"Doe\")<\/code><\/pre>\n>>> john = Person(\"John\", \"Doe\")\n>>> john.name\n'John Doe'\n>>> john.set_first(\"Charles\")\n>>> john.name\n'Charles Doe'<\/code><\/pre>\nname<\/code> when the other attributes are changed, we could add a method that computes the name of the user on demand:<\/p>\nclass Person:\n def __init__(self, first, last):\n self.first = first\n self.last = last\n\n def get_name(self):\n return f\"{self.first} {self.last}\"<\/code><\/pre>\n>>> john = Person(\"John\", \"Doe\")\n>>> john.get_name()\n'John Doe'\n>>> john.first = \"Charles\"\n>>> john.get_name()\n'Charles Doe'<\/code><\/pre>\nIntroduction<\/a><\/h2>\n
+<\/code> works on numbers, as addition, but it also works on strings, lists, and tuples, as concatenation:<\/p>\n>>> 1 + 2.3\n3.3\n>>> [1, 2, 3] + [4, 5, 6]\n[1, 2, 3, 4, 5, 6]<\/code><\/pre>\n+<\/code> is addition for numbers (integers and floats)\nand concatenation for lists, tuples, strings?\nWhat if I wanted