{"id":913,"date":"2024-09-15T16:11:06","date_gmt":"2024-09-15T16:11:06","guid":{"rendered":"https:\/\/www.zframez.com\/articles\/?p=913"},"modified":"2024-10-26T04:39:52","modified_gmt":"2024-10-26T04:39:52","slug":"chapter-10-python-functions-variable-scopes-and-lambda-expressions","status":"publish","type":"post","link":"https:\/\/www.zframez.com\/articles\/python-tutorials\/chapter-10-python-functions-variable-scopes-and-lambda-expressions","title":{"rendered":"Chapter 10: Python Functions, Variable Scopes, and Lambda Expressions"},"content":{"rendered":"\n
\n \n \u25c0 Previous<\/a>\n <\/span>\n \n \n Python Tutorials<\/a>\n <\/span>\n \n \n Next \u25b6<\/a>\n <\/span>\n<\/div>\n\n\n\n

Understanding Functions, Variable Scopes, and Lambda Functions in Python<\/strong><\/h1>\n\n\n\n

In this chapter, we\u2019ll go through functions, one of the core building blocks in Python. Functions allow you to organize code, reuse logic, and make your programs cleaner and more efficient. In this chapter, we\u2019ll explore how to define functions with and without return statements, understand the differences between local and global variables, and how Python handles variable scopes. We\u2019ll also go over more advanced topics like default arguments, keyword arguments, and passing a variable number of arguments. To wrap things up, we\u2019ll take a look at lambda functions, which are anonymous functions that can be used in situations where you need simple one-liner functions. By the end of this chapter, you\u2019ll have a solid grasp of how to use functions effectively in Python.<\/p>\n\n\n\n

Functions in Python<\/strong><\/h2>\n\n\n\n

Example 1: Defining a Function Without a Return Statement<\/strong>:<\/p>\n\n\n\n

def table(a):\n    b = 1\n    while b <= 5:\n        print(\"%d * %d = %d\" % (a, b, b * a))\n        b += 1\n        \ntable(5)\n<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25<\/pre>\n\n\n\n
Explanation<\/strong>:
This function, table(a)<\/code>, takes a single parameter \u201ca<\/strong><\/code>\u201d and prints the multiplication table for \u201ca<\/strong>\"<\/code> from 1 to 5. It does not return any value because it directly prints the result inside the loop. The loop runs as long as \u201cb<\/strong>\"<\/code> is less than or equal to 5, and on each iteration, it prints the result of a * b<\/code>.<\/strong><\/p>\n\n\n\n
Example 2: Defining a Function with a Return Statement<\/strong>:<\/p>\n\n\n\n
def average(a, b, c):\n    d = (a + b + c) \/ 3\n    return d\n\nresult = average(10, 20, 30)\nprint(result)\n\n#Output :<\/strong> 20.0 <\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
Here, the function average(a, b, c)<\/code> calculates the average of three numbers. It returns the result, which is captured in the variable result<\/strong><\/code>. The function uses the return<\/code> <\/strong>statement to pass back the value of \u201cd<\/strong>\"<\/code>, making it available outside the function. The key difference from the previous example is that this function returns a value rather than just printing the result.<\/p>\n\n\n\n
Variable Scope in Python: Local and Global Variables<\/strong><\/h2>\n\n\n\n
Local Variables<\/strong> : Variables declared inside a function are local variables<\/strong>, which means they only exist within the function and cannot be accessed outside it.<\/p>\n\n\n\n
def average(a, b, c):\n    d = (a + b + c) \/ 3\n    return d\n\nresult = average(10, 20, 30)\nprint(d)  # This will cause an error\n\n#Output : NameError: name 'd' is not defined<\/code><\/pre>\n\n\n\n
In this code, \u201cd<\/strong>\"<\/code> is a local variable inside the average()<\/code> function. Trying to print \u201cd<\/strong>\"<\/code> outside the function causes a NameError<\/code> because the variable \u201cd<\/strong>\"<\/code> does not exist outside the scope of the function. This illustrates the concept of local variables being confined to the function where they are defined.<\/p>\n\n\n\n
Global Variables<\/strong> : Global variables are defined outside any function and can be accessed within functions unless explicitly overridden.<\/p>\n\n\n\n
a = 10\n\ndef average(b, c):\n    print(\"a is\", a)\n    d = (a + b + c) \/ 3\n    return d\n\nprint(average(20, 30))\n\n#Output :\na is 10\n20.0<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
Here, the variable \u201ca<\/strong>\"<\/code> is declared globally. When the function average()<\/code> is called, it can access the global variable \u201ca<\/strong>\"<\/code> without needing to pass it as an argument. The global variable \u201ca<\/strong>\"<\/code> is used within the function, and no local variable \u201ca\"<\/code> is created.<\/p>\n\n\n\n
Local Variable with Same Name as Global<\/strong> :<\/p>\n\n\n\n
a = 10\n\ndef average(b, c):\n    a = 40\n    d = (a + b + c) \/ 3\n    print(\"local variable 'a' is\", a)\n    \naverage(20, 30)\nprint(\"global variable 'a' is still\", a)\n\n#Output:\nlocal variable 'a' is 40\nglobal variable 'a' is still 10\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
In this example, even though there is a global variable \u201ca<\/strong>\"<\/code>, the function average()<\/code> declares a new local variable \u201ca<\/strong>\"<\/code> with the value 40. This local variable is used inside the function, and the global \u201ca<\/strong>\"<\/code> remains unchanged. Python prioritizes local variables over global ones within a function when the names are the same.<\/p>\n\n\n\n
Using \u201cglobal\"<\/code> to Modify Global Variables<\/strong> :<\/p>\n\n\n\n
a = 10\n\ndef average(b, c):\n    global a\n    print(\"variable 'a' inside function is\", a)\n    d = (a + b + c) \/ 3\n    a = 40  # This modifies the global variable 'a'\n    print(\"average is\", d)\n\naverage(20, 30)\nprint(\"global variable 'a' is now\", a)\n\n#Output :\nvariable 'a' inside function is 10\naverage is 20.0\nglobal variable 'a' is now 40<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
Using the \u201cglobal\"<\/code> keyword, the function average()<\/code> can modify the global variable \u201ca<\/strong>\"<\/code>. Without \u201cglobal\"<\/code>, the assignment a = 40<\/code> would create a local variable \u201ca<\/strong>\"<\/code>, but here it modifies the global \u201ca<\/strong>\"<\/code> directly. This is useful when you need to change the value of a global variable within a function.<\/p>\n\n\n\n
Call by Object Reference<\/strong><\/h2>\n\n\n\n
When passing a mutable object like a list to a function, changes made to the object inside the function are reflected outside the function as well.<\/p>\n\n\n\n
def add_to_list(x, y):\n    x.append(y)\n\na = []\nadd_to_list(a, 10)\nadd_to_list(a, 20)\nadd_to_list(a, 30)\nprint(a)\n\n#Output:\n[10, 20, 30]\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
In this example, the function add_to_list(x, y)<\/code> modifies the list x<\/code> by appending the value y<\/code>. Since lists are mutable, the changes made to x<\/code> inside the function affect the list a<\/code> outside the function. This behavior is known as call by object reference<\/strong> in Python.<\/p>\n\n\n\n
Default Argument Values<\/strong><\/h2>\n\n\n\n
def average(a, b, c=30):\n    print((a + b + c) \/ 3)\n\naverage(10, 20)\naverage(10, 20, 60)\n\n#Output :\n20.0\n30.0<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
In this function, the third parameter \u201cc\"<\/code> has a default value of 30. When the function is called with only two arguments (10<\/code> and 20<\/code>), it uses the default value of \u201cc\"<\/code> as 30. However, when the function is called with three arguments (10, 20, 60<\/code>), it overrides the default value with 60.<\/p>\n\n\n\n
Keyword Arguments<\/strong><\/h2>\n\n\n\n
def repeat(string, count):\n    a = 1\n    while a < count:\n        print(string)\n        a += 1\n\nrepeat(count=3, string=\"python\")\n\n#Output :\npython\npython\npython\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
Python allows you to pass arguments by specifying the parameter name. This flexibility is called keyword arguments<\/strong>, allowing you to pass values in any order by specifying the parameter name. In this example, the repeat()<\/code> function is called using count=3<\/code> and string=\"python\"<\/code>.<\/p>\n\n\n\n
Variable Number of Arguments<\/strong><\/h2>\n\n\n\n
def sum(a, b, *c):\n    result = a + b\n    for tmp in c:\n        result += tmp\n    print(result)\n\nsum(10, 20)\nsum(10, 20, 30)\nsum(10, 20, 30, 40)\n\n#Output:\n30\n60\n100\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
In Python, the *c<\/code> in the function definition allows the function to accept an arbitrary number of additional arguments. These extra arguments are collected into a tuple and can be accessed inside the function. In this example, the sum()<\/code> function sums all the arguments passed to it, regardless of how many there are.<\/p>\n\n\n\n
Lambda Functions in Python<\/strong><\/h2>\n\n\n\n
Lambda functions are anonymous functions that can take any number of arguments but have only one expression. They are commonly used for short, simple functions.<\/p>\n\n\n\n
cube = lambda x: x ** 3\nprint(cube(5))  # 125\n\neven = lambda x: True if x % 2 == 0 else False\nprint(even(10))  # True\n\nsum = lambda x, y: x + y\nprint(sum(10, 5))  # 15\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:
Lambda functions are useful for writing small, one-liner functions. In the examples above, cube<\/code> calculates the cube of a number, even<\/code> checks if a number is even, and sum<\/code> adds two numbers. Lambda functions don\u2019t require the use of the def<\/code> keyword and are often used when a function object is needed temporarily.<\/p>\n\n\n\n
Using Lambda Functions with filter()<\/code>, map()<\/code>, and reduce()<\/code><\/strong><\/h2>\n\n\n\n
a = [1, 2, 3, 4, 5]\n\n# Using map with lambda\ncube = lambda x: x ** 3\nprint(list(map(cube, a)))  # [1, 8, 27, 64, 125]\n\n# Using filter with lambda\neven = lambda x: x % 2 == 0\nprint(list(filter(even, a)))  # [2, 4]\n\n# Using reduce with lambda\nfrom functools import reduce\nsum = lambda x, y: x + y\nprint(reduce(sum, a))  # 15\n<\/code><\/pre>\n\n\n\n
Explanation<\/strong>:<\/p>\n\n\n\n