Learn Python, Microsoft 365 and Google Workspace
Syntax:
The syntax of a lambda is
lambda arguments:express
Example #1:
Following code is used to write the function to add 10 in given number.
def add_ten(x)
return x + 10
above function can be written by the lamdba function in python.
add_ten = lamdba x: x + 10
print(add_ten(5) # 15
Example #2: multiple two numbers
use of lambda function to multiple two numbers
mul = lambda a, b : a * b
print(mul(2,4)) # 8
Example #3:
lambda x, y : x + y
_(6,8) # 14
Note: In the interactive interpreter, the single underscore(_) is bound to the last expression evalued.
Example #4: Immediately invoked function expression
(lambda x, y : x + y)(6,8) # 14
The lambda function above is defined and then immediately called with two arguments (6,8). it retuns the value 14, which is the sum of the arguments.
Example #5:
def multiply(lambda(x,y):
retun x*y
result = (lambda x,y : multiply(x,y))(5,3)
print(result) # Output: 15
mult = lambda x,y : multiply(x,y)
result = mult(6,2)
print(result) # Output: 12
map, filter, and reduce.Example #6: use of lambda in map() function
numbers = [1,2,3,4,5,6,7,8,9,10]
squared_numbers = map(lambda x : x **2 ,numbers)
print(list(squared_numbers))
map applies a function to all items in an iterable:
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x ** 2, numbers))
print(squares) # Output: [1, 4, 9, 16]
numbers = [1,2,3,4,5,6,7,8,9,10] # list
even_numbers= list(filter(lambda x : x % 2 == 0,numbers))
print(even_numbers)
filter filters items in an iterable based on a function that returns True or False:
numbers = [1, 2, 3, 4]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers) # Output: [2, 4]
See also:
*args and **kwargsArbitrary Positional Arguments (*args)
These allow a function to take any number of positional arguments. Inside the function, *args collects all the positional arguments as a tuple.
Example:
def greet(*names):
for name in names:
print(f"Hello, {name}!")
greet("Ali", "Hamza", "Ahmad")
Output:
Hello, Ali!
Hello, Hamza!
Hello, Ahmad!
In this example, the greet function can take any number of names. The *names collects them into a tuple (names), which can be iterated over.
**kwargs)These allow a function to accept any number of keyword arguments (arguments passed as key-value pairs). Inside the function, **kwargs collects these as a dictionary.
Example:
def print_info(**info):
for key, value in info.items():
print(f"{key}: {value}")
print_info(name="Ali", age=25, city="Multan")
Output:
name: Ali
age: 25
city: Multan
In this case, the function accepts any number of keyword arguments and collects them into a dictionary (info), which you can then work with inside the function.
You can also use both *args and **kwargs in the same function to handle a combination of positional and keyword arguments.
Example:
def display_data(*args, **kwargs):
print("Positional arguments:", args)
print("Keyword arguments:", kwargs)
display_data(1, 2, 3, name="Ali", age=25)
Output:
Positional arguments: (1, 2, 3)
Keyword arguments: {'name': 'Ali', 'age': 25}
Key Points:
*args collects all positional arguments into a tuple.**kwargs collects all keyword arguments into a dictionary.*args and **kwargs together to handle any type of arguments passed to a function.In Python, the nonlocal keyword is used to declare that a variable inside a nested function refers to a variable in the nearest enclosing scope that is not global. This allows you to modify a variable from an outer (but not global) scope within a nested function.
Here’s an example to illustrate how nonlocal works:
def outer_function():
x = 10 # This is the enclosing variable
def inner_function():
nonlocal x # Declare that we want to use the outer variable x
x += 5 # Modify the outer variable
print("Inner x:", x)
inner_function()
print("Outer x:", x)
outer_function()
Inner x: 15
Outer x: 15
outer_function defines a variable x.inner_function modifies x using the nonlocal keyword.inner_function is called, it updates x, and both the inner and outer prints show the updated value.nonlocal:If you don’t use nonlocal, Python will treat the variable as a new local variable in the inner function, which can lead to unexpected behavior or errors.
Answer Key (True/False):
def my_func():
global x
x = 10
x = 5
my_func()
print(x)
- A) `5`
- B) `10`
- C) `None`
- D) `Error`
def outer():
x = 1
def inner():
print(x)
return inner
func = outer()
func()
NoneError1Function objectdef outer():
x = 5
def inner():
nonlocal x
x = 10
inner()
return x
print(outer())
510NoneErrorWhat is the output of the following code? [Python Quiz #2]
def foo(x):
if x == 1:
return 1
else:
return x * foo(x - 1)
print(foo(5))
Watch this video for answer: https://www.youtube.com/shorts/k50czTu7vao
For more details, see Appendix A
def calculate_sum(n):
if n == 0:
return 0
else:
return n + calculate_sum(n-1)
print(calculate_sum(4))
Watch the video for the answer: https://youtube.com/shorts/LQEfGgJYlT4?si=MDvSvVHiBc6hCJ0W
def add(a,b,*parm):
total = 0
print(a+b)
for n in parm:
total += n
return total
print(add(1, 2))
Watch this video for answer: https://youtube.com/shorts/k4KVCxU5oMg
def add(*args):
print(type(args))
add(1, 2,8,9)
Watch this video for answer: https://youtube.com/shorts/VQT4Cllpf9M
def f(a, b, *args):
return len(args)
print(f(1, 2, 3, 4, 5))
235Nonedef display_data(**kwargs):
print(type(kwargs))
display_data(name="Ali", age=25)
Watch this video for answer: https://youtu.be/5IWmz7iWqUE?si=Wx0OeTwME3XEiL-h
What is the output of the following code? [Python Quiz #98]
def outer_function(message):
def inner_function():
print(message)
return inner_function
my_function = outer_function("Hello, world!")
my_function()
def apply_function(func, x):
return func(x)
def square(x):
return x * x
result = apply_function(square, 5)
print(result)
def add_one(x): return x + 1
def compose(f, g): def composed_function(x): return f(g(x)) return composed_function
result = compose(add_one, square)(5) print(result)
* A. 26
* B. 36
* C. 25
* D. 11
### Partial Application
23. **What is partial application in Python?**
* A. Applying a function to some of its arguments
* B. Creating a new function with fewer arguments
* C. Applying a function multiple times
* D. All of the above
24. **What is the output of the following code?**
```python
from functools import partial
def add(x, y):
return x + y
add_5 = partial(add, 5)
result = add_5(3)
print(result)
Watch this video for the answer:
#10 Python supports the creation of anonymous functions at runtime, using a construct called
Python YouTube Playlist: https://www.youtube.com/playlist?list=PLKYRx0Ibk7Vi-CC7ik98qT0VKK0F7ikja
a) pi b) anonymous c) lambda d) none of the mentioned
What is the syntax for defining a lambda function in Python? A) lambda x: x + 1 B) def x(lambda): return x + 1 C) func x = lambda: x + 1 D) x lambda x + 1 Answer: A) lambda x: x + 1
Related video https://youtu.be/Z8Zeen4WwJQ
What is the output of the following code? f = lambda x, y: x * y print(f(3, 4))
related video: https://youtu.be/Z8Zeen4WwJQ
A) 12 B) 7 C) ‘34’ D) None Answer: A) 12
Related video: https://youtu.be/Z8Zeen4WwJQ
What is the output of the following code? g = lambda x: x ** 2 print(g(5)) A) 25 B) 5 C) ‘5’ D) None Answer: A) 25 related video https://youtu.be/Z8Zeen4WwJQ
Answer key (Mutiple Choice):
Answer Key (Fill in the Blanks):
Write a function add(*args) that takes a variable number of arguments and returns the sum of all the arguments. The function should handle any number of arguments, including zero arguments. If no arguments are passed, the function should return 0.
Function Signature:
def add(*args):
Input:
Output:
0.Sample Input:
add(1, 2, 3)
Sample Output:
6
In the example, the function foo(x) is a recursive function that calculates the factorial of x.
The code:
def foo(x):
if x == 1:
return 1
else:
return x * foo(x - 1)
print(foo(5))
Step-by-Step Explanation:
if x == 1: return 1. This stops the recursion. Without this base case, the function would keep calling itself indefinitely, leading to a “stack overflow” or “maximum recursion depth exceeded” error.x is not equal to 1, the function returns x * foo(x - 1). This is the recursive step, which calls foo again with x - 1.Example with foo(5):
Let’s break down the flow when you call foo(5):
foo(5) checks if x == 1. Since x = 5, the base case is not satisfied, so the function returns 5 * foo(4).foo(4). Again, x == 1 is false, so the function returns 4 * foo(3).foo(3) is evaluated. It returns 3 * foo(2).foo(2) returns 2 * foo(1).foo(1) hits the base case and returns 1.Now, the recursive calls start to resolve from the deepest level:
foo(2) returns 2 * 1 = 2foo(3) returns 3 * 2 = 6foo(4) returns 4 * 6 = 24foo(5) returns 5 * 24 = 120foo(5) is 120, which is the factorial of 5. Hence, print(foo(5)) will output 120.This is a classic example of recursion being used to calculate the factorial of a number. The function continues to break down the problem (finding factorial of smaller numbers) until it hits the simplest case (x == 1), after which it multiplies the results together to get the final answer.