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- \nHow to structure and organise functions<\/a>.<\/li>\n
- \nHow to work with a function signature<\/a>, including parameter order<\/a>,
*args<\/code> and **kwargs<\/code><\/a>, and the special syntax introduced by *<\/code> and \/<\/code><\/a>.<\/li>\n- \nBest practices to document a function<\/a>.<\/li>\n
- \nWhat anonymous functions are<\/a>, how to define them with the keyword
lambda<\/code>, and when to use them<\/a>.<\/li>\n- \nWhat it means for functions to be objects<\/a> and how to leverage that in your code.<\/li>\n
- \nHow closures seem to defy a fundamental rule of scoping in Python<\/a>.<\/li>\n
- \nHow to leverage closures to create the decorator pattern<\/a>.<\/li>\n
- \nWhat the keyword
yield<\/code> is and what generator functions are<\/a>.<\/li>\n- \nWhat the keyword
async<\/code> is and what asynchronous functions are<\/a>.<\/li>\n- \nHow partial function application allows you to create new functions from existing functions<\/a>.<\/li>\n
- \nHow the term “function” is overloaded<\/a> and how you can create your own objects that behave like functions<\/a>.<\/li>\n<\/ul>\n
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\nWhat goes into a function and what doesn't<\/a><\/h2>\nDo 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 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":"functools.Placeholder","date_published":"2025-08-22T21:21:00+02:00","id":"https:\/\/mathspp.com\/blog\/how-to-use-functools-placeholder","url":"https:\/\/mathspp.com\/blog\/how-to-use-functools-placeholder","content_html":"Learn how to use functools.Placeholder<\/code>, new in Python 3.14, with real-life examples.<\/p>\n\nBy reading this article you will understand what functools.Placeholder<\/code> is for and how to use it effectively.<\/p>\nPartial function application<\/a><\/h2>\nThe new Placeholder<\/code>, added in Python 3.14, only makes sense in the context of functools.partial<\/code>, so in order to understand Placeholder<\/code> you will need to understand how functools.partial<\/code> works and how to use it<\/a>.<\/p>\nIn a nutshell, partial<\/code> allows you to perform partial function application, by “freezing” arguments to functions.<\/p>\nHow to pass arguments to functools.partial<\/code><\/a><\/h2>\nUp until Python 3.13, you could use partial<\/code> to freeze arguments in two types of ways:<\/p>\n- you could pass positional arguments to
partial<\/code>, which would be passed in the same order to the function being used with partial<\/code>; or<\/li>\n- you could pass keyword arguments to
partial<\/code>, which would be passed with the same name to the function being used with partial<\/code>.<\/li>\n<\/ol>Using keyword arguments to skip the first argument<\/a><\/h2>\nThe method 2. is especially useful if you're trying to freeze an argument that is not the first one.\nFor example, if you use the built-in help<\/code> on the built-in int<\/code>, you can see this signature:<\/p>\nint(x, base=10) -> integer<\/code><\/pre>\nIf you want to convert a binary string to an integer, you can set base=2<\/code>:<\/p>\nprint(int(\"101\", 2)) # 5<\/code><\/pre>\nNow, suppose you want to create a function from_binary<\/code> by “freezing” the argument 2<\/code> in the built-in int<\/code>.\nWriting<\/p>\nfrom_binary = partial(int, 2)<\/code><\/pre>\nwon't work, since in partial(int, 2)<\/code>, the value 2<\/code> is seen as the argument x<\/code> from the signature above.\nHowever, you can pass the base as a keyword argument, skipping the first argument x<\/code> from the signature of the built-in int<\/code>:<\/p>\nfrom functools import partial\n\nfrom_binary = partial(int, base=2)\n\nprint(from_binary(\"101\")) # 5<\/code><\/pre>\nBut this doesn't always work.<\/p>\n
When keyword arguments don't work<\/a><\/h2>\nConsider the following function that uses the string methods maketrans<\/code> and translate<\/code><\/a> to strip punctuation from a string:<\/p>\nimport string\n\n_table = str.maketrans(\"\", \"\", string.punctuation)\ndef remove_punctuation(string):\n return string.translate(_table)\n\nprint(remove_punctuation(\"Hello, world!\")) # Hello world<\/code><\/pre>\nThe function remove_punctuation<\/code> is a thin wrapper around the string method str.translate<\/code>, which is the function doing all the work.\nIn fact, if you look at str.translate<\/code> as a function, you always pass _table<\/code> as the second argument; what changes is the first argument:<\/p>\nprint(str.translate(\"Hello, world!\", _table)) # Hello world\nprint(str.translate(\"What?!\", _table)) # What<\/code><\/pre>\nThis may lead you to wanting to use partial<\/code> to freeze the value _table<\/code> on the function str.translate<\/code>, so you use the built-in help<\/code> to check the signature of str.translate<\/code>:<\/p>\ntranslate(self, table, \/) unbound builtins.str method<\/code><\/pre>\nYou can see that the first argument is self<\/code>, the string you are trying to translate, and then table<\/code> is the translation table (that str.maketrans<\/code> built magically for you).\nBut you can also see the forward slash \/<\/code>, which means that self<\/code> and table<\/code> are positional-only arguments that cannot be passed in as keyword arguments!<\/p>\nAs such,...<\/p>","summary":"Learn how to use `functools.Placeholder`, new in Python 3.14, with a real-life example.","date_modified":"2025-08-22T23:09:02+02:00","tags":["python","programming","fp"],"image":"\/user\/pages\/02.blog\/functools-placeholder\/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":"
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
- learn to recognise when a decorator must be used;<\/li>\n
- learn to identify the functionality that should be extracted into a decorator;<\/li>\n
- use an analogy to understand what a decorator is;<\/li>\n
- implement two simple decorators as initial examples;<\/li>\n
- learn the full anatomy of a general decorator;<\/li>\n
- understand why
functools.wraps<\/code> should be used when defining decorators;<\/li>\n- add arguments to your decorators to make them more useful;<\/li>\n
- handle the multiple usage patterns that decorators need to handle, inspired by the way the standard library does it;<\/li>\n
- see that, sometimes, classes can also be used as decorators; and<\/li>\n
- learn that classes can also be decorated.<\/li>\n<\/ul>\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\nA function that did too much<\/a><\/h2>\nThe 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>\nAs an example, consider how you might have implemented the mathematical operation factorial before it was introduced in the module 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>\nIf 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
_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>\nThis 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
Factoring out the orthogonal behaviour<\/a><\/h2>\nInstead 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":"functools.partial","date_published":"2024-01-03T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/functools-partial","url":"https:\/\/mathspp.com\/blog\/functools-partial","content_html":"
This article teaches you how to use functools.partial<\/code>, how it works, and when to use it, with clear examples.<\/p>\n\nWhat is functools.partial<\/code>?<\/a><\/h2>\nfunctools.partial<\/code> is a tool from the standard module functools<\/code> that allows you to curry positional and keyword arguments in functions.\nIn a certain way, it's as if partial<\/code> creates a specialised version of the function you pass it in, with certain arguments frozen.<\/p>\nFor example, the built-in int<\/code> converts objects to integers:<\/p>\n>>> int(\"14\")\n14\n>>> int(14.5)\n14<\/code><\/pre>\nMaybe you didn't know that the built-in int<\/code> also accepts a second argument that specifies the base from which the number must be converted:<\/p>\n>>> bin(99) # 99 in binary is 1100011\n'0b1100011'\n>>> int(\"1100011\", base=2)\n99\n\n>>> hex(99) # 99 in hexadecimal is 63\n'0x63'\n>>> int(\"63\", base=16)\n99<\/code><\/pre>\nBy using functools.partial<\/code>, you can create specialised versions of int<\/code> where the parameter base<\/code> was fixed to a certain base:<\/p>\n# `partial` lives inside the module `functools`:\n>>> from functools import partial\n\n>>> from_bin = partial(int, base=2)\n>>> from_bin(\"1100011\")\n99\n\n>>> from_hex = partial(int, base=16)\n>>> from_hex(\"63\")\n99<\/code><\/pre>\nThe two examples above show that the first argument to partial<\/code> is the function whose argument(s) we want to freeze.\nThen, we can provide as many positional or keyword arguments as needed.\nIn our case, we just specified the parameter base<\/code> as a keyword parameter.\nHere's how you could read both examples of partial<\/code>:<\/p>\npartial(int, base=2)<\/code> - create a new version of int<\/code> where the parameter base<\/code> is always set to 2<\/code>; and<\/li>\npartial(int, base=16)<\/code> – create a new version of int<\/code> where the parameter base<\/code> is always set to 16<\/code>.<\/li>\n<\/ul>How to use functools.partial<\/code><\/a><\/h2>\nThe example above showed briefly how partial<\/code> works and this section will go over the most important details.\nFor demonstration purposes, let us create a function with a couple of parameters:<\/p>\ndef foo(a, b, *, c, d=10):\n print(a, b, c, d)<\/code><\/pre>\nThe function foo<\/code> above has 4 parameters, of which c<\/code> and d<\/code> are keyword-only and d<\/code> has a default value of 10<\/code>.<\/p>\nfunctools.partial<\/code> and positional arguments<\/a><\/h3>\npartial<\/code> can be given positional parameters, which will be passed in, in order, to the function that is the first argument to partial<\/code>.\nWhen you call the new function, the other positional arguments you pass in are appended to the ones you already specified.\nSo, bar = partial(foo, 1)<\/code> is a function that has 3 parameters and that corresponds to foo(1, b, *, c, d=10)<\/code>.\nSimilarly, baz = partial(foo, 1, 2)<\/code> is a function that has 2 parameters and that corresponds to foo(1, 2, *, c, d=10)<\/code>.<\/p>\n>>> bar = partial(foo, 1)\n>>> bar(20, c=30, d=40)\n1 20 30 40\n\n>>> baz = partial(foo, 1, 2)\n>>> baz(c=30, d=40)\n1 2 30 40<\/code><\/pre>\nNotice that partial<\/code> doesn't do any type of validation whatsoever regarding the number of arguments you pass in.\nThis means that a call to partial<\/code> might succeed but then produce a function that is unusable.<\/p>\nThe example...<\/p>","summary":"This article teaches you how to use `functools.partial`, how it works, and when to use it, with clear examples.","date_modified":"2026-01-28T20:06:35+01:00","tags":["fp","modules","programming","python"],"image":"\/user\/pages\/02.blog\/functools-partial\/thumbnail.webp"},{"title":"The power of reduce | Pydon't \ud83d\udc0d","date_published":"2021-06-08T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/pydonts\/the-power-of-reduce","url":"https:\/\/mathspp.com\/blog\/pydonts\/the-power-of-reduce","content_html":"
In this Pydon't we will take a look at the reduce<\/code> function,\nwhich used to be a built-in function and is currently\nin the functools<\/code> module.<\/p>\n\n![\"A](\"\/user\/pages\/02.blog\/02.pydonts\/the-power-of-reduce\/thumbnail.svg?decoding=auto&fetchpriority=auto\")
<\/p>\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>\nIntroduction<\/a><\/h2>\nIn this Pydon't I'll talk about reduce<\/code>, a function that used\nto be a built-in function and that was moved to the functools<\/code>\nmodule with Python 3.<\/p>\nThroughout all of the Pydon'ts I have been focusing only\non Python features that you can use without having to import\nanything, so in that regard this Pydon't will be a little bit different.<\/p>\n
In this Pydon't, you will:<\/p>\n
- see how
reduce<\/code> works;<\/li>\n- learn about the relationship between
reduce<\/code> and for<\/code> loops;<\/li>\n- notice that
reduce<\/code> hides in a handful of other built-in functions we all know and love;<\/li>\n- learn about a neat use-case for
reduce<\/code>;<\/li>\n<\/ul>\nYou 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\nHow reduce<\/code> works<\/a><\/h2>\nreduce<\/code> is a tool that is typically associated with functional programming,\nwhich is a programming paradigm that I feel sometimes is underappreciated.\nIn a short sentence, reduce<\/code> takes an iterable and a binary function\n(a function that takes two arguments),\nand then uses that binary function to boil the iterable down to a single value.<\/p>\nThis might sound weird or complicated, so the best thing I can do is to show\nyou a simplified implementation of reduce:<\/p>\n
def reduce(function, iterable, initial_value):\n result = initial_value\n for value in iterable:\n result = function(result, value)\n return result<\/code><\/pre>\nIf you look at it, there really isn't much going on inside that for<\/code> loop:\nwe just keep updating the result<\/code> variable with the argument function<\/code>\nand the consecutive values in the iterable<\/code> argument.<\/p>\nBut I can make this even easier to understand for you.\nAnd, in order to do that, I just have to point out a bunch of reduce<\/code>\nuse cases that you use all the time!\nPerhaps the simplest one, and the one that shows up more often, is the sum<\/code> built-in:<\/p>\n>>> sum(range(10))\n45\n>>> from functools import reduce; import operator\n>>> reduce(operator.add, range(10))\n45<\/code><\/pre>\nThe operator.add<\/code> there is just a way to programmatically refer to the built-in\naddition with +<\/code> in Python.<\/p>\nFrom the