What a function is

What exactly is a function, and how is it different from a few ordinary lines?

A function is a few lines of code with a name. Having a name is what makes the difference: code without one is just a spot in your file, while code with one can be called from anywhere in the program and you no longer need to know what goes on inside.

def display_name(user):
    name = user["name"].strip()
    if name == "":
        return "guest"
    return name

Two separate things are happening here and beginners usually mix them up. The first line is the definition: it says such a thing exists and this is its job. It does not run, it is only registered. The call is somewhere else, when you write display_name(user_a), and only then do those five lines run.

So a function that is defined but never called anywhere does nothing at all and reports no error either. That is one of the most common reasons behind "my code does not run", especially when someone moves code inside a function and forgets to call it at the bottom of the file.

And the best definition of a function is not that it reduces repetition; it is that it gives a name to a thought. When you write display_name, the person reading your code no longer has to read four lines to understand what is happening. A good name removes four lines of explanation, and that is the largest thing a function gives you.

What is the difference between a parameter and an argument?

These two words look at one thing from two sides, which is exactly why they get mixed up. A parameter is the name you write when defining the function, the user on the first line of the example above. An argument is the real value you send when calling it, the user_a.

A parameter is a blank and an argument is what fills the blank. To be more precise: the parameter belongs to the definition and there is only one of it, while the argument belongs to each call and can differ every time. A function with one parameter may be called fifty times across a program with fifty different arguments.

Knowing this distinction is useful in practice rather than in vocabulary. When you see an error saying the function wanted two inputs and got one, it is talking about the number of arguments, not about the definition. Which means the definition is fine and the mistake is on the very line where you called it. That single diagnosis narrows the search from a whole file to one small line.

One habit that makes life easier: name your parameters so that they say what they expect. def send(to, subject, body) reads without any explanation, while def send(a, b, c) forces you back inside the function every time, which is precisely what the function was meant to save you from.

What does return mean, and why does print not replace it?

This is where the largest number of beginners get stuck, and the root of it is a simple misunderstanding: print shows something on the screen, while return hands a value back to whoever called the function. Those are not the same job at all.

def double(n):
    print(n * 2)

result = double(5)
print(result)

The screen shows 10 first and then None. The ten was printed by the function itself, but result is empty, because this function returned nothing. A function with no return hands back None in Python, and the equivalent in other languages.

def double(n):
    return n * 2

result = double(5)
print(result)

Now nothing is printed inside the function and result is ten, which is to say something you can use in the next calculation. The practical difference is this: a function that prints looks correct when you test it by hand, and breaks the moment you want to use its result. Which is also why this bug is usually found late.

One more point that gets said less often: return ends the function immediately. Any line written after it inside that same function does not run. This is not a restriction, it is a tool: in the first example on this page, return "guest" means the last line is never even evaluated. This is called an early return and it rescues code from nested conditions.

A real refactor: three repetitions, one function

Suppose you have written these same four lines in three places in a program, differing only by one variable:

name = user_a["name"].strip()
if name == "":
    name = "guest"
print(name)

name = user_b["name"].strip()
if name == "":
    name = "guest"
print(name)

The right way to extract a function has three steps, and the second is the one usually skipped. First, find the repetition. Second, and more importantly, find what differs between the three copies; that thing is your parameter. Third, write a function that takes that difference as an input.

def display_name(user):
    name = user["name"].strip()
    if name == "":
        return "guest"
    return name

print(display_name(user_a))
print(display_name(user_b))

What has actually been gained is not a few saved lines. It is that the word guest is now written in exactly one place. Tomorrow, when you decide to write something else instead, you change one line and you are done.

And what used to happen with the previous version? You would change two of the three places and not see the third. The program would raise no error either; one page of your site would simply show the old word for months and nobody would notice. Repeated code is dangerous for that reason, not because it is ugly.

Four lines of code that are called 181 times

The example above is made up. This one is not. The infographic library of this very site has a function whose job is one thing only: take a four language array, pull out the text for the page's language, and fall back to Persian if that language is missing.

function rgb_dg_t( $value, string $lang ): string {
    if ( is_array( $value ) ) {
        return (string) ( $value[ $lang ] ?? $value['fa'] ?? '' );
    }
    return (string) $value;
}

On the day this lesson was checked, that function was called 181 times across the four files of the diagram library. Every title, every label, every note under every figure you see in this learning section passes through those four lines.

Now look at that ?? 'fa' in the middle of the third line. It is a decision: if the translation of a label has not been written yet, show the Persian text rather than an empty figure. That decision is written in one place and takes effect at 181 points. If we change our mind tomorrow and would rather show nothing than Persian, one word changes.

And the other side of the same coin, which should be said plainly: one mistake in those four lines also breaks 181 places at once. A function this central has to be read more carefully than the code calling it, for exactly that reason. Concentration buys you benefit and risk together, and they are made of the same material.

When not to write a function, and where we duplicated code on purpose

You hear the rule "never repeat yourself" a lot, and like every absolute rule it stops working somewhere. A function that forces you to scroll to the top of the file and back in order to understand four lines takes more time from you than it saves.

Three signs a function was not needed: it is called from one place and probably always will be; its name is effectively the code inside it, like a function named add_one that adds one; and writing it takes six parameters. The last is the most important: a large number of parameters usually means the function does more than one job. The simple test is to try saying what it does in one short phrase; if you had to say "and", you have two functions.

Now the opposite case, from this site. We have two separate plugins and both have to show a price in toman with a thousands separator and Persian digits. The code for that is nearly identical in both, yet they are two separate functions with two different names, one in the ranking plugin and one in the hosting plugin.

That duplication is not a mistake, it is a decision. Each plugin has to work on its own, even when the other one is switched off. If one used the other's function, deactivating a plugin would break pages belonging to the other. The price we pay for that independence is real and we do not hide it: any change to how a price is displayed has to be made in two places, and we have to remember that it is two. We say this so that you know there is not always a third way; sometimes you have to choose between two costs and then write that choice down somewhere so the next person does not think you forgot.