Python Tutorial

In this article, we are discussing the pass function as a parameter in python. Functions can take multiple arguments. These arguments can be objects, variables (of the same or different data types), and functions. Python functions are the first elegant gadgets.

Within the following instance, a feature is assigned to a variable. This project no longer names a function. This takes the feature object pointed to by "shout" and creates a second call, "yell," pointing to it.

Facts may be exceeded to features as arguments. Arguments are unique after the characteristic call-in parentheses. You could add as many arguments as possible; separate them with commas.

The following example has a function with one argument (fname). At the same time, the function is referred to as passing the name used in the characteristic to print the overall call.

Example 1: Right here, we give an instance of the pass function as a parameter in python. The example is given below -

def my_function(fname):
print(fname + " Id")
my_function("Emil")
my_function("Phone")

Result: We assemble the above program, and after compilation, we run the program. Then the result is given below -

Email Id
Phone Id

Example 2: Right here, we give another instance of the pass function as a parameter in python. The example is given below -

def shout(text): 
    return text.upper()     
print(shout('Hello World'))  
yell = shout    
print(yell('Hello Coders'))

Result: We assemble the above program, and after compilation, we run the program. Then the result is given below -

HELLO WORLD
HELLO CODERS

Wrapper Function: A wrapper function or decorator allows you to wrap another function and extend it without permanently changing the behavior of the wrapped function. In the decorator, the function is taken as an argument of another function and called inside the wrapper function.

Example 1: Right here, we give an instance of a wrapper function as a parameter in python. The example is given below -

def hello_decorator(func): 
    def inner1(): 
        print ("Hello coders, it is before the function execution") 
        func () 
        print ("It is after the function execution")  
    return inner1  
def function_to_be_used(): 
    print ("It is inside of this function") 
function_to_be_used = hello_decorator(function_to_be_used) 
function_to_be_used()

Result: We assemble the above program, and after compilation, we run the program. Then the result is given below -

Hello coders, it is before the function execution
It is inside of this function
It is after the function execution

Lambda wrapper function: In Python, a nameless function approach that the character has no call. As you recognize, the def keyword defines ordinary functions, and the lambda keyword is used to create anonymous functions. This characteristic will have a variety of arguments but evaluates and returns the simplest expression.

A lambda function also can have every other character as an argument. The subsequent example suggests a primary Lambda characteristic surpassed every other Lambda function as a controversy.

Example 1: Right here, we give an instance of the lambda wrapper function as a parameter in python. The example is given below -

square = lambda a:a * a
cube = lambda func:func**3
print ("The square of 4 is:"+str (square (4)))
print ("\nThe cube of "+str (square (4)) +" is :" +str (cube (square (4))))

Result: We assemble the above program, and after compilation, we run the program. Then the result is given below -

The square of 4 is:16
The cube of 16 is: 4096

Higher order function: Since functions are objects, we can pass them as arguments to other features. Capabilities that take other features as arguments are also referred to as better-order functions. The subsequent instance creates a Greet feature that takes a feature as an issue.

Example 1: Right here, we give an instance of a higher order function as a parameter in python. The example is given below -

def shout(text): 
    return text.upper() 
def whisper(text): 
    return text.lower() 
def greet(function): 
    greeting = function ("Hello, we are created by a higher order function passed as an argument.") 
    print(greeting)
greet(shout) 
greet(whisper)

Result: We assemble the above program and run the program after compilation. Then the result is given below -

HELLO, WE ARE CREATED BY A HIGHER ORDER FUNCTION PASSED AS AN ARGUMENT.
hello, we are created by a higher order function passed as an argument.

Conclusion: In Python, you can pass function objects to other functions. Functions can be propagated in Python. Python has built-in functions requiring you to specify the function as one or more arguments so you can call it later.

Next Topic#

← prev next →