Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
16 views

What Are Python Functions

A Python function is a collection of statements that perform a specific task and can be reused. Functions allow code to be broken into smaller, reusable pieces to perform operations on input arguments and return outputs. There are several types of arguments that can be passed to functions, including default arguments, keyword arguments, required arguments, and variable-length arguments. Functions help improve code organization, reusability, and structure in Python programs.

Uploaded by

murugesans.cs
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
16 views

What Are Python Functions

A Python function is a collection of statements that perform a specific task and can be reused. Functions allow code to be broken into smaller, reusable pieces to perform operations on input arguments and return outputs. There are several types of arguments that can be passed to functions, including default arguments, keyword arguments, required arguments, and variable-length arguments. Functions help improve code organization, reusability, and structure in Python programs.

Uploaded by

murugesans.cs
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

What are Python Functions?

A collection of related assertions that carry out a mathematical, analytical, or evaluative


operation is known as a function. An assortment of proclamations called Python Capabilities
returns the specific errand. Python functions are necessary for intermediate-level programming
and are easy to define. Function names meet the same standards as variable names do. The
objective is to define a function and group-specific frequently performed actions. Instead of
repeatedly creating the same code block for various input variables, we can call the function and
reuse the code it contains with different variables.

Client-characterized and worked-in capabilities are the two primary classes of capabilities in
Python. It aids in maintaining the program's uniqueness, conciseness, and structure.

Advantages of Python Functions


Pause We can stop a program from repeatedly using the same code block by including functions.

 Once defined, Python functions can be called multiple times and from any location in a
program.
 Our Python program can be broken up into numerous, easy-to-follow functions if it is
significant.
 The ability to return as many outputs as we want using a variety of arguments is one of
Python's most significant achievements.

 HThe start of a capability header is shown by a catchphrase called def.


 function_name is the function's name, which we can use to distinguish it from other
functions. We will utilize this name to call the capability later in the program. Name
functions in Python must adhere to the same guidelines as naming variables.
 Using parameters, we provide the defined function with arguments. Notwithstanding,
they are discretionary.
 A colon (:) marks the function header's end.
 We can utilize a documentation string called docstring in the short structure to make
sense of the reason for the capability.
 Several valid Python statements make up the function's body. The entire code block's
indentation depth-typically four spaces-must be the same.
 A return expression can get a value from a defined function.

 owever, Python programs have always incurred overhead when calling functions.
# Example Python Code for calling a function
# Defining a function
def a_function( string ):
"This prints the value of length of string"
return len(string)

# Calling the function we defined


print( "Length of the string Functions is: ", a_function( "Functions" ) )

print( "Length of the string Python is: ", a_function( "Python" ) )

 def square( item_list ):


 '''''''This function will find the square of items in the list'''
 squares = [ ]
 for l in item_list:
 squares.append( l**2 )
 return squares

 # calling the defined function
 my_list = [17, 52, 8];
 my_result = square( my_list )

 print( "Squares of the list are: ", my_result )

Function Arguments
The following are the types of arguments that we can use to call a function:

1. Default arguments
2. Keyword arguments
3. Required arguments
4. Variable-length arguments

1) Default Arguments

A default contention is a boundary that takes as information a default esteem, assuming that no
worth is provided for the contention when the capability is called. The following example
demonstrates default arguments.

 def function( n1, n2 = 20 ):


 print("number 1 is: ", n1)
 print("number 2 is: ", n2)


 # Calling the function and passing only one argument
 print( "Passing only one argument" )
 function(30)

 # Now giving two arguments to the function
 print( "Passing two arguments" )
 function(50,30)

2) Keyword Arguments

Keyword arguments are linked to the arguments of a called function. While summoning a
capability with watchword contentions, the client might tell whose boundary esteem it is by
looking at the boundary name.

 def function( n1, n2 ):


 print("number 1 is: ", n1)
 print("number 2 is: ", n2)

 # Calling function and passing arguments without using keyword
 print( "Without using keyword" )
 function( 50, 30)

 # Calling function and passing arguments using keyword
 print( "With using keyword" )
 function( n2 = 50, n1 = 30)

3) Required Arguments

Required arguments are those supplied to a function during its call in a predetermined positional
sequence. The number of arguments required in the method call must be the same as those
provided in the function's definition.

We should send two contentions to the capability() all put together; it will return a language
structure blunder, as seen beneath.

 def function( n1, n2 ):


 print("number 1 is: ", n1)
 print("number 2 is: ", n2)


# Calling function and passing two arguments out of order, we need num1 to be 20 and num2 to
be 30
 print( "Passing out of order arguments" )
 function( 30, 20 )

 # Calling function and passing only one argument
 print( "Passing only one argument" )
 try:
 function( 30 )
 except:
 print( "Function needs two positional arguments" )

4) Variable-Length Arguments

We can involve unique characters in Python capabilities to pass many contentions. However, we
need a capability. This can be accomplished with one of two types of characters:

"args" and "kwargs" refer to arguments not based on keywords.

 def function( *args_list ):


 ans = []
 for l in args_list:
 ans.append( l.upper() )
 return ans
 # Passing args arguments
 object = function('Python', 'Functions', 'tutorial')
 print( object )

 # defining a function
 def function( **kargs_list ):
 ans = []
 for key, value in kargs_list.items():
 ans.append([key, value])
 return ans

def printinfo( arg1, *vartuple ):


"This prints a variable passed arguments"
print "Output is: "
print arg1
for var in vartuple:
print var
return;

# Now you can call printinfo function


printinfo( 10 )
printinfo( 70, 60, 50 )

def sum( arg1, arg2 ):


# Add both the parameters and return them."
total = arg1 + arg2
print "Inside the function : ", total
return total;

# Now you can call sum function


total = sum( 10, 20 );
print "Outside the function : ", total

 def square( num ):


 return num**2

 # Calling function and passing arguments.
 print( "With return statement" )
 print( square( 52 ) )

 def word():
 string = 'Python functions tutorial'
 x=5
 def number():
 print( string )
 print( x )

 number()
 word()

You might also like