{"id":2650,"date":"2026-10-20T10:53:21","date_gmt":"2026-10-20T10:53:21","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2650"},"modified":"2026-10-21T10:21:27","modified_gmt":"2026-10-21T10:21:27","slug":"python-functions-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-functions\/python-functions-tutorial\/","title":{"rendered":"Python Functions"},"content":{"rendered":"

Python Functions Tutorial With Examples<\/b><\/strong><\/h1>\n

Suppose you need to find the average of marks in ten places in your program. You could copy the same four lines ten times. Then the day you find a mistake in the formula, you have to fix it in ten places, and you will miss one. A function solves this. You write the lines once, give them a name, and call that name wherever you need them.<\/p>\n

A function is a named block of code that does one job. It runs only when you call it, it can take values in, and it can send a value back. Functions make a program shorter, easier to read and easier to test. Every real Python program, from a small script to a web application, is built from them.<\/p>\n

In this tutorial, we explain the three types of functions in Python: built in, user defined and anonymous. We then show how to create and call a function, and go through the four kinds of arguments, which are default, required, keyword and variable length, including *args<\/code> and **kwargs<\/code>. We cover lambda functions in detail, and add return values, docstrings, scope, the mutable default trap and recursion. Every example was run on Python 3.13, with its real output.<\/p>\n

Introduction to Functions in Python<\/h2>\n

A function is a group of statements that runs only when it is called. It can take inputs, called parameters, and it can return a result. You use functions to reuse code, to break a large problem into small parts, and to give a clear name to each step.<\/p>\n

    \n
  • Reuse.<\/strong> Write the code once, call it many times.<\/li>\n
  • Clarity.<\/strong> A name such as calculate_tax<\/code> tells the reader what the code does, without reading every line.<\/li>\n
  • Easy fixes.<\/strong> If something is wrong, you fix it in one place.<\/li>\n
  • Testing.<\/strong> A small function with one job is simple to test on its own.<\/li>\n<\/ul>\n

    Types of Functions in Python<\/h2>\n
    \n\n\n\n\n\n\n\n
    Types of functions<\/caption>\n
    Type<\/th>\nWhat it is<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
    Built in<\/th>\nReady made, comes with Python<\/td>\nprint, min, len, sum<\/td>\n<\/tr>\n
    User defined<\/th>\nWritten by you, with def<\/td>\ndef multi(x, y)<\/td>\n<\/tr>\n
    Anonymous<\/th>\nA small function with no name, made with lambda<\/td>\nlambda b: b + 30<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n

    Built In Functions in Python<\/h3>\n

    Python ships with many functions you can use at once. You have already used print<\/code>. Here are a few more.<\/p>\n

    \n
    python<\/div>\n
    print(min(4, 9, 2), max(4, 9, 2), len(\"Python\"), bool(0), bool(\"hi\"))\r\nprint(sum([1, 2, 3]), abs(-7), sorted([3, 1, 2]), type(5))<\/pre>\n
    output<\/div>\n
    2 9 6 False True\r\n6 7 [1, 2, 3] <class 'int'><\/pre>\n<\/div>\n
    The function bool<\/code> turns a value into True or False. Zero and empty values give False, and most other values give True.<\/p>\n
    User Defined Functions in Python<\/h3>\n
    A user defined function is one you write yourself with the def<\/code> keyword. It is the type you will write most often, and the rest of this tutorial is mostly about it.<\/p>\n
    Anonymous Functions in Python<\/h3>\n
    An anonymous function has no name and is made with the lambda<\/code> keyword instead of def<\/code>. It is limited to one expression, and it is covered in its own section below.<\/p>\n
    How to Create a Function in Python?<\/h2>\n
    Use the def<\/code> keyword, then the function name, round brackets with any parameters, and a colon. The lines that belong to the function are indented under it. Write a space after def, because deftest<\/code> is a syntax error.<\/p>\n
    Calling a Function<\/h3>\n
    Defining a function does not run it. Nothing prints until you call it. To call a function, write its name followed by round brackets.<\/p>\n
    \n
    python<\/div>\n
    def test():\r\n    print(\"Python\")\r\n    return\r\n\r\ntest()<\/pre>\n
    output<\/div>\n
    Python<\/pre>\n<\/div>\n
    What a Function Returns<\/h3>\n
    A function that has no return line, or only a bare return<\/code>, gives back a special value called None<\/code>. You can see it by printing the result of the call:<\/p>\n
    \n
    python<\/div>\n
    def test():\r\n    print(\"Python\")\r\n    return\r\n\r\nprint(test())<\/pre>\n
    output<\/div>\n
    Python\r\nNone<\/pre>\n<\/div>\n
    The word Python is printed by the function itself. The word None is the value it returned. To get a useful value back, return it:<\/p>\n
    \n
    python<\/div>\n
    def multi(x, y):\r\n    return x * y\r\n\r\nresult = multi(12, 5)\r\nprint(result)<\/pre>\n
    output<\/div>\n
    60<\/pre>\n<\/div>\n
    Parameters and Arguments<\/h3>\n
    These two words are often mixed up. A parameter is the name in the function definition. An argument is the value you pass when you call it.<\/p>\n
    \n
    python<\/div>\n
    def greet(name):          # name is a parameter\r\n    return \"Hello, \" + name\r\n\r\nprint(greet(\"Mithun\"))   # \"Mithun\" is an argument<\/pre>\n
    output<\/div>\n
    Hello, Mithun<\/pre>\n<\/div>\n
    Python Function Arguments<\/h2>\n
    Python has four ways to pass arguments. Each one solves a different problem.<\/p>\n
    \n\n\n\n\n\n\n\n\n
    Types of arguments<\/caption>\n
    Type<\/th>\nWhat it does<\/th>\n<\/tr>\n<\/thead>\n
    Default<\/th>\nThe parameter has a value, used when the caller leaves it out<\/td>\n<\/tr>\n
    Required<\/th>\nThe caller must pass it, in the right position<\/td>\n<\/tr>\n
    Keyword<\/th>\nThe caller passes it by name, in any order<\/td>\n<\/tr>\n
    Variable length<\/th>\nThe function accepts any number of arguments, with *args or **kwargs<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Default Argument<\/h3>\n
    Give a parameter a value with the equals sign. If the caller does not pass one, the default is used. Parameters with defaults must come after the ones without.<\/p>\n
    \n
    python<\/div>\n
    def multi_default(x, y=5):\r\n    return x * y\r\n\r\nprint(multi_default(x=1))\r\nprint(multi_default(x=1, y=3))\r\nprint(multi_default(4))<\/pre>\n
    output<\/div>\n
    5\r\n3\r\n20<\/pre>\n<\/div>\n
    The first call uses the default y of 5. The second passes y as 3. The third passes only x, as a plain value, so y is again 5.<\/p>\n
    Required Arguments<\/h3>\n
    A parameter with no default is required. The caller must pass it, and the values are matched by position, so the first value goes to the first parameter.<\/p>\n
    \n
    python<\/div>\n
    def multi(x, y):\r\n    return x * y\r\n\r\nprint(multi(12, 5))<\/pre>\n
    output<\/div>\n
    60<\/pre>\n<\/div>\n
    If you leave one out, Python raises an error that names the missing one:<\/p>\n
    \n
    python<\/div>\n
    def multi(x, y):\r\n    return x * y\r\n\r\ntry:\r\n    multi(12)\r\nexcept TypeError as e:\r\n    print(\"TypeError:\", e)<\/pre>\n
    output<\/div>\n
    TypeError: multi() missing 1 required positional argument: 'y'<\/pre>\n<\/div>\n
    Keyword Arguments<\/h3>\n
    You can pass arguments by name. Then the order does not matter, because Python matches each value to its parameter by the name.<\/p>\n
    \n
    python<\/div>\n
    def multi(x, y):\r\n    return x * y\r\n\r\nprint(multi(5, 10))\r\nprint(multi(x=5, y=10))\r\nprint(multi(y=10, x=5))<\/pre>\n
    output<\/div>\n
    50\r\n50\r\n50<\/pre>\n<\/div>\n
    Order matters only with plain values. For a function that divides, the swap changes the answer:<\/p>\n
    \n
    python<\/div>\n
    def divide(a, b):\r\n    return a \/ b\r\n\r\nprint(divide(10, 2), divide(b=10, a=2))<\/pre>\n
    output<\/div>\n
    5.0 0.2<\/pre>\n<\/div>\n
    In the second call, a is 2 and b is 10, so the answer is 0.2, even though b was written first. Keyword arguments make calls easier to read, especially when a function has many parameters.<\/p>\n
    Variable Number of Arguments: *args<\/h3>\n
    Sometimes you do not know how many values will be passed. Put a star before a parameter name, usually args<\/code>, and Python collects all the extra values into a tuple.<\/p>\n
    \n
    python<\/div>\n
    def show(*args):\r\n    for i in args:\r\n        print(i)\r\n\r\nshow(\"Variable\", \"Number\", \"of\", \"arguments\")<\/pre>\n
    output<\/div>\n
    Variable\r\nNumber\r\nof\r\narguments<\/pre>\n<\/div>\n
    The loop prints each item on its own line. Here is a more useful case, a sum of any number of values, and a check of what args<\/code> really is:<\/p>\n
    \n
    python<\/div>\n
    def total(*numbers):\r\n    return sum(numbers)\r\n\r\ndef what_type(*args):\r\n    return type(args)\r\n\r\nprint(total(1, 2, 3), total(10, 20, 30, 40), total())\r\nprint(what_type(1, 2, 3))<\/pre>\n
    output<\/div>\n
    6 100 0\r\n<class 'tuple'><\/pre>\n<\/div>\n
    Inside the function, args<\/code> is a tuple. Calling it with no values gives an empty tuple, so the total is 0.<\/p>\n
    Variable Number of Keyword Arguments: **kwargs<\/h3>\n
    Two stars collect extra named arguments into a dictionary. You will see this form in many libraries.<\/p>\n
    \n
    python<\/div>\n
    def profile(**details):\r\n    for key, value in details.items():\r\n        print(key, \"=\", value)\r\n\r\nprofile(name=\"Asha\", city=\"Kolkata\", age=28)<\/pre>\n
    output<\/div>\n
    name = Asha\r\ncity = Kolkata\r\nage = 28<\/pre>\n<\/div>\n
    Putting It All Together<\/h3>\n
    When a function uses all four, they must come in this order: required, default, *args<\/code>, **kwargs<\/code>.<\/p>\n
    \n
    python<\/div>\n
    def order(a, b=2, *args, **kwargs):\r\n    print(a, b, args, kwargs)\r\n\r\norder(1)\r\norder(1, 3, 4, 5, x=6)<\/pre>\n
    output<\/div>\n
    1 2 () {}\r\n1 3 (4, 5) {'x': 6}<\/pre>\n<\/div>\n
    Returning More Than One Value<\/h3>\n
    A function can return several values at once, separated by commas. Python packs them into a tuple, and you can unpack them into separate names.<\/p>\n
    \n
    python<\/div>\n
    def min_max(values):\r\n    return min(values), max(values)\r\n\r\nlow, high = min_max([4, 9, 2, 7])\r\nprint(low, high, min_max([4, 9, 2, 7]))<\/pre>\n
    output<\/div>\n
    2 9 (2, 9)<\/pre>\n<\/div>\n
    Anonymous (Lambda) Functions in Python<\/h2>\n
    A lambda function is a small function with no name. It can take any number of arguments, but it has only one expression, and the result of that expression is returned automatically, with no return<\/code> keyword.<\/p>\n
    \n
    python<\/div>\n
    lambda arguments: expression<\/pre>\n<\/div>\n
    \n
    python<\/div>\n
    x = lambda b: b + 30\r\nprint(x(5))\r\n\r\navg = lambda x, y: (x + y) \/ 2\r\nprint(avg(5, 7))<\/pre>\n
    output<\/div>\n
    35\r\n6.0<\/pre>\n<\/div>\n
    Why Use Lambda Functions?<\/h3>\n
    A lambda is best when you need a tiny function for a short time, usually as an argument to another function. It saves you from writing a full def<\/code> for something used once. Here are three common uses, with sorted<\/code>, map<\/code> and filter<\/code>.<\/p>\n
    \n
    python<\/div>\n
    names = [\"Zoya\", \"amit\", \"Bina\", \"chetan\"]\r\nprint(sorted(names, key=lambda s: s.lower()))\r\nprint(list(map(lambda n: n ** 2, [1, 2, 3, 4])))\r\nprint(list(filter(lambda n: n % 2 == 0, [1, 2, 3, 4, 5, 6])))<\/pre>\n
    output<\/div>\n
    ['amit', 'Bina', 'chetan', 'Zoya']\r\n[1, 4, 9, 16]\r\n[2, 4, 6]<\/pre>\n<\/div>\n
    The first line sorts the names without caring about capital letters. The second squares every number. The third keeps only the even numbers. If the logic needs more than one line, write a normal def<\/code> function instead.<\/p>\n
    A Lambda Inside Another Function<\/h3>\n
    A function can build and return a lambda. This is how you make a family of related functions.<\/p>\n
    \n
    python<\/div>\n
    def func1(a):\r\n    return lambda b: b * a\r\n\r\ndouble = func1(2)\r\ntriple = func1(3)\r\nprint(double(11), triple(11))<\/pre>\n
    output<\/div>\n
    22 33<\/pre>\n<\/div>\n
    Calling func1<\/code> with 2 gives back a new function that multiplies by 2, and we store it in double<\/code>. Calling it with 3 gives one that multiplies by 3.<\/p>\n