Category: Python Functions

due to its simplicity. One basic building block in Python is the def statement, which is used to define functions. In any programming language, the concept of functions is a basic requirement because they allow encapsulation of code into reusable units.

To put it simply, a function can be described as a block of code that is written to perform a specific task. Functions increase the ability of applications to be modular as well as increase the chances of the application code being reused. Apart from the built-in functions print(), len(), and range(), Python also supports user-defined functions created with the def statement.

What is the ‘def’ Keyword?

In Python, we create functions using the keyword ‘def’. A function is defined in a specific format, which is:

def keyword Syntax:

It has the following syntax:

def function_name(parameters):    
   """docstring"""    
   # Function body    
   # ...    
   return [expression]       

In this syntax,

• def: This is a reserved word in Python used to define a function.
• function_name: The name of the function. Like variable names, function names should be meaningful and descriptive. Function names can be written in letters with the first letter in the name in lowercase, and other words concatenated by underscores.
• Parameters: This is the part that defines the function name. Function names should be self-describable and must use the same criteria as the variable name, which is lowercase, separated by underscores.
• docstring: Optional. It describes the arguments of the given function. These are the boxes that will be given the value when and if this function is called.
• Function body: This section of the code performs the task of the function. It carries out action whenever the given function is executed.
• Return: optional. This is the statement that ends the function and can give a user something in return. If a function has been defined like this, that function will give a return value of None to every case without a return statement.

Defining a Simple Function using the def Keyword

For starters, let’s outline a standard function that provides a simple greeting as output:

Example

def greet():    
    """This function greets the user."""    
    print("Hello, welcome to Python programming!")    
# Calling the function    
greet()       

Output:

Hello, welcome to Python programming!

Explanation:

In this case, we created a function, greet, which accepts no input. The body has a single print statement that outputs a greeting message. To run the function, we simply call it with its name followed by parentheses ().

Understanding the Function Parameters and Arguments

Functions are able to accept parameters, which are values passed to the function through the method call. The function may change its behavior using the parameter that is provided to it.

Positional Arguments

Positional arguments are the most frequently used type of argument. They are sent to the function in the order they were defined.

Example

def greet(name):    
    """This function greets the user by name."""    
    print(f"Hello, {name}! Welcome to Python programming.")    
# Calling the function with an argument    
greet("Alice")    

Output:

Hello, Alice! Welcome to Python programming.

Explanation:

In this example, the greet function has one input, a name. When we invoke the function, we use the value of “Alice,” which is assigned to the name input.

Default Arguments

Parameters can be set with default values using default arguments, which enable the user to omit specific details if they choose to.

Example

def greet(name="Guest"):    
    """This function greets the user by name, defaulting to 'Guest'."""    
    print(f"Hello, {name}! Welcome to Python programming.")    
# Calling the function without an argument    
greet()    

Output:

Hello, Guest! Welcome to Python programming.

Explanation:

In this case, the name parameter has a default value of “Guest”. Therefore, if during the function call no argument is supplied, the given default value is assigned to the name variable.

Keyword Arguments

As a prominent feature of Python, keyword arguments enable the user to indicate argument names and values, thus enhancing the clarity of the function call and allowing arguments to be supplied in any sequence.

Example

def greet(name, message):    
    """This function greets the user with a custom message."""    
    print(f"Hello, {name}! {message}")    
# Calling the function with keyword arguments    
greet(message="How are you today?", name="Alice")    

Output:

Hello, Alice! How are you today?

Explanation:

In this illustration, keyword arguments are utilized to provide the name and message parameters out of their conventional sequence.

Arbitrary Arguments

If you want to write a function that can receive unlimited arguments, you can easily do this by using *args for the positional arguments and **kwargs for the keyword arguments.

Example

def greet(*names):    
    """This function greets multiple users."""    
    for name in names:    
        print(f"Hello, {name}! Welcome to Python programming.")    
# Calling the function with multiple arguments    
greet("Alice", "Bob", "Charlie")    

Output:

Hello, Alice! Welcome to Python programming.
Hello, Bob! Welcome to Python programming.
Hello, Charlie! Welcome to Python programming.

Explanation:

In this instance, the greet function accepts any number of positional arguments, which are received in a tuple named names.

Return Values

The calling program is able to receive values from the function through the return statement. Any value returned through the statement can be utilized in subsequent calculations or can be stored in a variable.

Example

def add(a, b):    
    """This function returns the sum of two numbers."""    
    return a + b    
# Calling the function and storing the result    
result = add(3, 5)    
print(f"The sum is {result}")    

Output:

The sum is 8

Explanation:

In this case, the add function comprises two parameters: a and b, and returns their sum. This returned value is kept in the result variable, which is then printed out.

Returning Multiple Values

By separating them with commas, a function can return multiple values. These values will be returned to the program as a tuple.

Example

def calculate(a, b):    
    """This function returns the sum and difference of two numbers."""    
    return a + b, a - b    
# Calling the function and unpacking the result    
sum_result, diff_result = calculate(10, 4)    
print(f"Sum: {sum_result}, Difference: {diff_result}")

Output:

Sum: 14, Difference: 6

Explanation:

The calculate function in this particular example returns both the sum and difference of two integers. The values returned are then packed into sum_result and diff_result.

Scope and Lifetime of Variables

This is very vaguely defined within programming and sometimes causes errors; It is the area or region within the code where it can be accessed. In Python, variables that are defined inside a function are local to that function, and outside variables cannot interact with it. The same goes for the rest. However, variables defined outside of any function are global and can be accessed throughout the program.

Example

x = 10  # Global variable    
def my_function():    
    y = 5  # Local variable    
    print(f"Inside function: x = {x}, y = {y}")    
my_function()    
print(f"Outside function: x = {x}")    
# print(f"Outside function: y = {y}")  # This will raise an error    

Output:

Inside function: x = 10, y = 5
Outside function: x = 10

Explanation:

In this specific example, x is a global variable, whereas y is a local variable defined in the scope of the function named my_function. If you try to access y from outside of the function’s scope, it will lead to an error.

Lambda Functions

Just like how the def keyword is used for declaring functions, Lambda Functions are concise, anonymous functions, which means they are functions without a name. They are used for streamlining and simplifying short tasks. It contributes to improving the readability of the program.

We can use a Lambda function along with:

• Condition checking
• List Comprehension
• if-else
• Multiple statements
• Filter() function
• Map() function
• Reduce() function

Lambda Function Syntax:

Following is the syntax of the Lambda function in Python:

Lambda arguments: expression  

Parameters:

• Lambda is the keyword that defines a function.
• Arguments are the input parameters, which are a list separated by commas.
• Expression is the entity that gets evaluated and returned.

Let’s see a practical use case of a Lambda function through examples:

Python Lambda Function Example

Below is an example of adding 10 to the argument x:

Example

#using a lambda function  
  
n = lambda x : x + 10  
  
#printing the output, and 10 is the value of x  
  
print(n(10))  

Output:

#value of n

20

Explanation:

In this example, ‘x’ is the input argument to the lambda function, and x + 10 is the expression being evaluated. We passed the value of x and printed the resulting output.

Recursive Functions

In Python, functions have the ability to call other functions, or themselves in certain instances, which is referred to as recursion. Recursive functions are highly effective for problems that can be divided into similar sub-problems. One of the most commonly known examples of a recursive function is finding a factorial number.

Example

def factorial(n):    
    """This function calculates the factorial of a number using recursion."""    
    if n == 1:    
        return 1    
    else:    
        return n * factorial(n - 1)    
# Calling the recursive function    
result = factorial(5)    
print(f"The factorial of 5 is {result}")    

Output:

The factorial of 5 is 120

Explanation:

In this case, the factorial function recursively calls itself with n – 1 until it reaches the base case of n == 1. Recursive functions always need a base case to prevent infinite recursion that may ultimately cause a stack overflow.

Nested Functions

Nested functions are functions defined within another function, which is a feature provided by Python. Such inner functions are scoped to the enclosing outer function and are helpful when the inner function works with specific details of the outer function.

Example

def outer_function(x):    
    """This function contains a nested function."""    
    def inner_function(y):    
        return y * 2    
    return inner_function(x)    
# Calling the outer function    
result = outer_function(10)    
print(f"The result is {result}")   

Output:

The result is 20

Explanation:

In this case, outer_function contains inner_function, which multiplies the value x by 2. The new function cannot be used in outer_function, ensuring that its scope is limited.

Decorators

Decorators make it possible to augment a function’s capabilities in Python without changing its actual code. A decorator is a function that accepts another function as an argument, creating a wrapper function with extended or modified functionality.

Example

def my_decorator(func):    
    """This is a simple decorator."""    
    def wrapper():    
        print("Something is happening before the function is called.")    
        func()    
        print("Something is happening after the function is called.")    
    return wrapper    
@my_decorator    
def say_hello():    
    print("Hello!")    
# Calling the decorated function    
say_hello()    

Output:

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

Explanation:

In this instance, the function say_hello receives my_decorator using the @ form. Now, say_hello will function in such a way that the logic in the decorator is executed before and after the function itself is run.

Best Practices for Using Functions

• Descriptive Names: Create function names that accurately explain the task being performed by the function.
• Single Responsibility: Each function is meant to accomplish one task. This principle enhances the modifiability of code.
• Docstrings: Use docstrings to specify details about the function, such as general operations performed, parameters used, and values returned.
• Avoid Global Variables: Functions should make almost no use of global variables to avoid problems with side effects.
• Keep Functions Short: Functions should be short and specific. If the function contains too much information, consider making it into several smaller functions.

Understanding the Use of the def Keyword in Classes

In Python, the def keyword serves multiple uses. Apart from defining functions, the def keyword can also be used to define methods inside a class. A method is said to be a function associated with an object and is called with the help of an instance of the class.

Using the def keyword inside a class, we can define methods that can access and modify the attributes of the class and its instances.

Python Def Keyword Example in Classes

Let us consider the following example illustrating the same:

Example

# defining the Student class    
class Student:    
    # defining a constructor to initialize the Student's name, class, and roll number    
    def __init__(self, name, class_, roll):    
        self.name = name  # Setting the name attribute    
        self.class_ = class_    # Setting the class_ attribute    
        self.roll = roll    # Setting the roll attribute    
       
    # defining a method to print a greeting message    
    def greet(self):    
        print(f"Name - {self.name}, Class - {self.class_} and Roll Number - {self.roll}.")    
    
# Creating an instance of the Student class    
student1 = Student("Denis", "XI", "6")    
# Calling the greet method to display the greeting message    
student1.greet()    

Output:

Name - Denis, Class - XI and Roll Number - 6.

Explanation:

In this example, we have defined a class as Student. Within this class, we have defined the constructor using the def keyword to initialize the different attributes of the class. We have then used the def keyword to define the greet() method to print a greeting message. We have then created an instance of the Student class and called the greet() method to display the greeting message for the object.

Difference Between lambda and def Keyword

There are several differences between the lambda and def keywords in Python. Some of the main differences are as follows:

Lambda function	def function
It consists of a single expression with a lambda	It consists of multiple lines of code.
It is Anonymous, which means without a name	It must have a name
It has only a single expression statement.	It can consist of many statements.
It is best for temporary and short functions.	It is good for complex and reusable logic in the code.

Conclusion

We learnt about the def function in depth. The def keyword, which is a reserved keyword in Python, is used to define a function. We studied the function. Functions are able to accept parameters, which are values passed to the function through the method call. There are two types of arguments: *args allows passing a variable number of positional arguments, and **kwargs: This keyword allows passing a variable number of keyword arguments. Then, we studied Lambda functions and the differences between them and the def function.

In Python, Lambda Functions are concise, anonymous functions, which means they are functions without a name. They are used for streamlining and simplifying short tasks. It contributes in improving the readability of the program.

Python Lambda Function Syntax

Following is the syntax of the Lambda function in Python:

lambda arguments : expression  

Parameters:

• Lambda is the keyword that defines a function.
• Arguments are the input parameters, which are a list separated by commas.
• Expression is the entity that gets evaluated and returned.

Let’s see a practical use case of a Lambda function through examples:

Simple Lambda Function Example in Python

Below is an example of adding 10 to the argument x:

Example

#using lambda function  
  
n = lambda x : x + 10  
  
#printing the output, and 10 is the value of x  
  
print(n(10))  

Output:

#value of n

20

Explanation:

In this example, ‘x’ is the input argument to the lambda function, and x + 10 is the expression being evaluated. We passed the value of x and printed the resulting output.

Let’s see another example to understand even more clearly:

Lambda Function Example with Multiple Arguments in Python

Below is an example of multiplying arguments:

Example

#here x,y represent agruments  
#x*y is an expression  
  
n = lambda x, y : x * y  
  
#printing the output n and (2,10) are the values of x and y respectively  
   
print(n(2, 10))  

Output:

20

Explanation:

The above example demonstrates the multiplication of two input arguments using a lambda function. ‘lambda x,y: x*y’ defines an anonymous (lambda) function that takes two arguments x and y, then returns the product (x*y)

Lambda with Condition Checking

Conditional statements, like if statements, can be used with lambda functions. Let’s see an example of using conditional if statements with a lambda function:

Example

# Lambda function to check if a number is Zero, Even, or Odd  
  
n = lambda x: "Zero" if x == 0 else "Even" if x % 2 == 0 else "Odd"  
  
# Value of x and printing n  
  
print(n(5))  
  
print(n(8))     
  
print(n(0))  

Output:

Odd
Even
Zero

Explanation:

In the above example, we used an if condition with a lambda function. The x is the argument passed to the lambda function, and in the expression, we have conditions to find whether the number is odd, even or zero.

• If x == 0, it returns “Zero”
• Else if x % 2 == 0, it returns “Even”, otherwise it returns “Odd”

Lambda with List Comprehension

List Comprehension is used to create a new list concisely, and combining it with Lambda functions allows us to get the output more efficiently. Let’s look at an example of Lambda function combined with List Comprehension:

Example

#using Lambda functions with List Comprehension  
  
n = [lambda a = x: a * 10 for x in range(1, 6)]  
  
#for loop  
  
for i in n:  
    print(i())  

Output:

10
20
30
40
50

Explanation:

In the above example, we used list comprehension in Lambda functions.

• lambda a = x: a * 10 creates a function that multiplies a by 10
• for x in range(1,6) determines the value from 1 to 5.

Lambda with if-else

We can use if-else conditional statements, which allow us to handle decision-making in the function.

Lambda Function Example using if-else statement in Python

Let’s see an example with an if-else conditional statement:

Example

# Lambda function to check whether the number is Even or Odd  
  
n = lambda a: "Even" if a % 2 == 0 else "Odd"  
  
# Value of x and printing n  
  
print(a(10))  
  
print(a(3))     
  
print(a(0))  

Output:

Even
Odd
Even

Explanation:

In the above example, we used an if-else conditional statement to determine whether the number is odd or even. ‘x’ is the input argument to the lambda function, and if-else statements represent the expression.

The expression “Even” if x % 2 == 0 else “Odd” checks if the number is divisible by 2.

• If yes, it returns “Even”
• Otherwise, it returns “Odd”

Lambda with Multiple Statements

We can perform multiple operations in lambda functions using tuples, logical operators, and comma-separated expressions. However, multiple statements are not allowed. We must look at an example to understand this topic:

Example

# Addition, Multiplication, Division and Modulus  
  
calculation = lambda a, b: (a + b, a * b, a / b, a % b)  
  
ans = calculation(3, 4)  
print(ans)  

Output:

(7, 12, 0.75, 3)

Explanation:

In the above example, we have performed multiple operations, such as Addition, Multiplication, Division, and Modulus. a and b are the input arguments to the lambda function, and the arithmetic operations inside the tuple are the expressions being evaluated and returned.

Using lambda with filter()

In Python, the filter() function accepts a function and a list as arguments. This provides an efficient method for filtering out elements where the condition evaluates to True.

Python Lambda Function Example using filter() Function

Let’s see an example of using a lambda with the filter() function:

Example

#Filtering even numbers from a list  
  
num = [1, 2, 3, 4, 5, 6]  
  
is_even = filter(lambda a: a % 2 == 0, num)  
  
print(list(is_even))  

Output:

[2, 4, 6]

Explanation:

In the above example, we have created a list named ‘num’. The ‘a’ is the input argument to the lambda function, and ‘a % 2 == 0’ is the expression which checks if the number is even.

The filter() function applies this condition and filters out the numbers that are completely divisible by two.

Using lambda with map()

In Python, the map() function accepts a function and a list as arguments, and it returns a new list after modifying the items that were returned by that function. We must now look at an example to understand the map() function:

Example

# Square each number in a list  
  
num = [1, 2, 3, 4]  
  
#using the map() function  
square = map(lambda x: x ** 2, num)  
  
#printing the square  
  
print(list(square))  

Output:

[1, 4, 9, 16]

Explanation:

In the above example, we have created a list named num. ‘x’ is the input argument to the lambda function, and ‘x ** 2’ is the expression that calculates the square of the number. The map() function applies this condition and creates a new list with the square of the numbers in the old list.

Using lambda with reduce()

In Python, the reduce() function accepts a function and an iterable (such as a list) as arguments, and it returns a single reduced value by repeatedly applying the function to the items. To use reduce(), we need to import it from the functools module.

Python Lambda Function Example using reduce() Function

Let’s understand using lambda with reduce() with an example:

Example

#importing reduce from functools  
  
from functools import reduce  
  
#given input list  
num_list = [2, 0, 2, 6]  
  
#using lambda with reduce()  
number = reduce(lambda x, y: x * 10 + y, num_list)  
  
print(number)    

Output:

2026

Explanation:

In the above example, we have created a list named num_list. ‘x’ and ‘y’ are the input arguments to the lambda function, and ‘x * 10 + y’ is the expression.

It iterates over each item:

• It starts with the first two elements: x=2, y=0, then 2*10 + 0 = 20
• Now x=20 and y=2, then 20*10 + 2 = 202
• In this step, x= 202 and y=5, let’s calculate 202*10 + 5 = 2025

Hence, we combined the elements of the list.

Difference Between lambda and def Keyword

There are several differences between the lambda and def keywords in Python. Some of the main differences are as follows:

lambda function	def function
It consists of a single expression with a lambda	It consists of multiple lines of code.
It is Anonymous, which means without a name	It must have a name
It has only a single expression statement.	It can consist of many statements.
It is best for temporary and short functions.	It is good for complex and reusable logic in the code.

Conclusion

Lambda Functions are concise, anonymous functions; they are used for streamlining and simplifying short tasks, and they contribute in improving the readability of the program. We can use Lambda function with:

• Condition checking
• List Comprehension
• if-else
• Multiple statements
• Filter() function
• Map() function
• Reduce() function

The Python built-in functions are defined as the functions whose functionality is pre-defined in Python. The Python interpreter has several functions that are always present for use. These functions are known as Built-in Functions. There are several built-in functions in Python, which are listed below:

Python abs() Function

The Python abs() function is used to return the absolute value of a number. It takes only one argument, a number whose absolute value is to be returned. The argument can be an integer or a floating-point number. If the argument is a complex number, then abs() returns its magnitude.

Python abs() Function Example

Let’s take an example to demonstrate the abs() function in Python.

#  integer number       
integer = -20    
print('Absolute value of -40 is:', abs(integer))    
    
#  floating number    
floating = -20.83    
print('Absolute value of -40.83 is:', abs(floating))    

Output:

Absolute value of -20 is: 20
Absolute value of -20.83 is: 20.83

Python all() Function

The Python all() function accepts an iterable object (such as a list, dictionary, etc.). It returns true if all items in the passed iterable are true. Otherwise, it returns False. If the iterable object is empty, the all() function returns True.

Python all() Function Example

Let’s take an example to demonstrate the all() function in Python.

# all values true    
k = [1, 3, 4, 6]    
print(all(k))    
    
# all values false    
k = [0, False]    
print(all(k))    
    
# one false value    
k = [1, 3, 7, 0]    
print(all(k))    
    
# one true value    
k = [0, False, 5]    
print(all(k))    
    
# empty iterable    
k = []    
print(all(k))    

Output:

True
False
False
False
True

Python bin() Function

The Python bin() function is used to return the binary representation of a specified integer. A result always starts with the prefix 0b.

Python bin() Function Example

Let us take an example to illustrate the bin() function in Python.

x =  10  
y =  bin(x)  
print (y)  

Output:

0b1010

Python bool() Function

The Python bool() converts a value to a Boolean (True or False) using the standard truth testing procedure.

Python bool() Function Example

Let us take an example to illustrate the bool() function in Python.

test1 = []  
print(test1,'is',bool(test1))  
test1 = [0]  
print(test1,'is',bool(test1))  
test1 = 0.0  
print(test1,'is',bool(test1))  
test1 = None  
print(test1,'is',bool(test1))  
test1 = True  
print(test1,'is',bool(test1))  
test1 = 'Easy string'  
print(test1,'is',bool(test1))  

Output:

[] is False
[0] is True
0.0 is False
None is False
True is True
Easy string is True

Python bytes()

The Python bytes() in Python is used for returning a bytes object. It is an immutable version of the bytearray() function.

It can create an empty bytes object of the specified size.

Python bytes() Function Example

Let us take an example to illustrate the bytes() function in Python.

string = "Hello World."  
array = bytes(string, 'utf-8')  
print(array)  

Output:

b ' Hello World.'

Python callable() Function

A Python callable() function is a built-in function that checks and returns true if the object passed appears to be callable, otherwise false.

Python callable() Function Example

Let us take an example to illustrate the callable() function in Python.

x = 8  
print(callable(x))  

Output:

False

Python compile() Function

The Python compile() function takes source code as input and returns a code object, which can later be executed by the exec() function.

Python compile() Function Example

Let us take an example to illustrate the compile() function in Python.

# compile string source to code    
code_str = 'x=5\ny=10\nprint("sum =",x+y)'    
code = compile(code_str, 'sum.py', 'exec')    
print(type(code))    
exec(code)    
exec(x)    

Output:

<class 'code'>
sum = 15

Python exec() Function

The Python exec() function is used for the dynamic execution of a Python program, which can either be a string or object code, and it accepts large blocks of code, unlike the eval() function, which only accepts a single expression.

Python exec() Function Example

Let us take an example to illustrate the exec() function in Python.

x = 8  
exec('print(x==8)')  
exec('print(x+4)')  

Output:

True
12

Python sum() Function

As the name says, the Python sum() function is used to get the sum of numbers in an iterable, i.e., a list.

Python sum() Function Example

Let us take an example to illustrate the sum() function in Python.

s = sum([1, 2,4 ])  
print(s)  
  
s = sum([1, 2, 4], 10)  
print(s)  

Output:

7
17

Python any() Function

The Python any() function returns true if any item in an iterable is true. Otherwise, it returns False.

Python any() Function Example

Let us take an example to illustrate the any() function in Python.

l = [4, 3, 2, 0]                              
print(any(l))                                   
  
l = [0, False]  
print(any(l))  
  
l = [0, False, 5]  
print(any(l))  
  
l = []  
print(any(l))  

Output:

True
False
True
False

Python ascii() Function

The Python ascii() function returns a string containing a printable representation of an object and escapes the non-ASCII characters in the string using \x, \u, or \U escapes.

Python ascii() Function Example

Let us take an example to demonstrate the ascii() function in Python.

normalText = 'Python is interesting'    
print(ascii(normalText))    
    
otherText = 'Python is interesting'    
print(ascii(otherText))    
   
print('Pyth\xf6n is interesting') 

Output:

'Python is interesting'
'Pyth\xf6n is interesting'
Python is interesting

Python bytearray() Function

The Python bytearray() returns a bytearray object and can convert objects into bytearray objects, or create an empty bytearray object of the specified size.

Python bytearray() Function Example

Let us take an example to illustrate the bytearray() function in Python.

string = "Python is a programming language."  
  
# string with encoding 'utf-8'  
arr = bytearray(string, 'utf-8')  
print(arr)  

Output:

bytearray(b'Python is a programming language.')

Python eval() Function

The Python eval() function parses the expression passed to it and runs the Python expression(code) within the program.

Python eval() Function Example

Let us take an example to illustrate the eval() function in Python.

x = 8  
print(eval('x + 1'))  

Output:

9

Python float() Function

The Python float() function returns a floating-point number from a number or string.

Python float() Example Function

Let us take an example to illustrate the float() function in Python.

# for integers  
print(float(9))  
  
# for floats  
print(float(8.19))  
  
# for string floats  
print(float("-24.27"))  
  
# for string floats with whitespaces  
print(float("     -17.19\n"))  
  
# string float error  
print(float("xyz"))  

Output:

9.0
8.19
-24.27
-17.19
ValueError: could not convert string to float: 'xyz'

Python format() Function

The Python format() function returns a formatted representation of the given value.

Python format() Function Example

Let us take an example to illustrate the format() function in Python.

# d, f and b are a type  
  
# integer  
print(format(123, "d"))  
  
# float arguments  
print(format(123.4567898, "f"))  
  
# binary format  
print(format(12, "b"))  

Output:

123
123.456790
1100

Python frozenset()

The Python frozenset() function returns an immutable frozenset object initialized with elements from the given iterable.

Python frozenset() Function Example

Let’s take an example to demonstrate the frozenset() function in Python.

# tuple of letters  
letters = ('m', 'r', 'o', 't', 's')  
  
fSet = frozenset(letters)  
print('Frozen set is:', fSet)  
print('Empty frozen set is:', frozenset())  

Output:

Frozen set is: frozenset({'o', 'm', 's', 'r', 't'})
Empty frozen set is: frozenset()

Python getattr() Function

The Python getattr() function returns the value of a named attribute of an object. If it is not found, it returns the default value.

Python getattr() Function Example

Let us take an example to illustrate the getattr() function in Python.

class Details:  
    age = 22  
    name = "Phill"  
  
details = Details()  
print('The age is:', getattr(details, "age"))  
print('The age is:', details.age)  

Output:

The age is: 22
The age is: 22

Python globals() Function

The Python globals() function returns the dictionary of the current global symbol table.

A Symbol table is defined as a data structure that contains all the necessary information about the program. It includes variable names, methods, classes, etc.

Python globals() Function Example

Let us take an example to illustrate the globals() function in Python.

age = 22  
  
globals()['age'] = 22  
print('The age is:', age)  

Output:

The age is: 22

Python iter() Function

The Python iter() function is used to return an iterator object. It creates an object that can be iterated over one element at a time.

Python iter() Function Example

Let us take an example to illustrate the iter() function in Python.

# list of numbers  
list = [1,2,3,4,5]  
  
listIter = iter(list)  
  
# prints '1'  
print(next(listIter))  
  
# prints '2'  
print(next(listIter))  
  
# prints '3'  
print(next(listIter))  
  
# prints '4'  
print(next(listIter))  
  
# prints '5'  
print(next(listIter))  

Output:

1
2
3
4
5

Python len() Function

The Python len() function is used to return the length (the number of items) of an object.

Python len() Function Example

Let us take an example to illustrate the len() function in Python.

strA = 'Python'  

print(len(strA)) 

Output:

6

Python list() Function

The Python list() creates a list in Python.

Python list() Function Example

Let us take an example to illustrate the list() function in Python.

# empty list  
print(list())  
  
# string  
String = 'abcde'       
print(list(String))  
  
# tuple  
Tuple = (1,2,3,4,5)  
print(list(Tuple))  
# list  
List = [1,2,3,4,5]  
print(list(List))  

Output:

[]
['a', 'b', 'c', 'd', 'e']
[1,2,3,4,5]
[1,2,3,4,5]

Python locals() Function

The Python locals() method updates and returns the dictionary of the current local symbol table.

A Symbol table is defined as a data structure that contains all the necessary information about the program. It includes variable names, methods, classes, etc.

Python locals() Function Example

Let us take an example to illustrate the locals() function in Python.

def localsAbsent():  
    return locals()  
  
def localsPresent():  
    present = True  
    return locals()  
  
print('localsNotPresent:', localsAbsent())  
print('localsPresent:', localsPresent())  

Output:

localsAbsent: {}
localsPresent: {'present': True}

Python map() Function

The Python map() function is used to return a list of results after applying a given function to each item of an iterable(list, tuple, etc.).

Python map() Function Example

Let us take an example to illustrate the map() function in Python.

def calculateAddition(n):  
  return n+n  
  
numbers = (1, 2, 3, 4)  
result = map(calculateAddition, numbers)  
print(result)  
  
# converting map object to set  
numbersAddition = set(result)  
print(numbersAddition)  

Output:

<map object at 0x7fb04a6bec18>
{8, 2, 4, 6}

Python memoryview() Function

The Python memoryview() function returns a memoryview object of the given argument.

Python memoryview() Function Example

Let us take an example to illustrate the memoryview() function in Python.

#A random bytearray  
randomByteArray = bytearray('ABC', 'utf-8')  
  
mv = memoryview(randomByteArray)  
  
# access the memory view's zeroth index  
print(mv[0])  
  
# It create byte from memory view  
print(bytes(mv[0:2]))  
  
# It create list from memory view  
print(list(mv[0:3]))  

Output:

65
b'AB'
[65, 66, 67]

Python object()

The Python object() returns an empty object. It is a base for all the classes and holds the built-in properties and methods that are default for all the classes.

Python object() Function Example

Let us take an example to illustrate the object() function in Python.

python = object()  
  
print(type(python))  
print(dir(python))  

Output:

<class 'object'>
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__ne__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
'__str__', '__subclasshook__']

Python open() Function

The Python open() function opens the file and returns a corresponding file object.

Python open() Function Example

Let us take an example to illustrate the open() function in Python.

# opens python.text file of the current directory  
f = open("python.txt")  
# specifying full path  
f = open("C:/Python33/README.txt")  

Output:

Since the mode is omitted, the file is opened in 'r' mode; opens for reading.

Python chr() Function

The Python chr() function is used to get a string representing a character that points to a Unicode code point. For example, chr(97) returns the string ‘a’. This function takes an integer argument and throws an error if it exceeds the specified range. The standard range of the argument is from 0 to 1,114,111.

Python chr() Function Example

Let us take an example to illustrate the chr() function in Python.

# Calling function  
result = chr(102) # It returns string representation of a char  
result2 = chr(112)  
# Displaying result  
print(result)  
print(result2)  
# Verify, is it string type?  
print("is it string type:", type(result) is str)  

Output:

ValueError: chr() arg not in range(0x110000)

Python complex() Function

Python’s complex() function is used to convert numbers or strings into a complex number. This method takes two optional parameters and returns a complex number. The first parameter is called the real part, and the second is the imaginary part.

Python complex() Function Example

Let us take an example to illustrate the complex() function in Python.

# Python complex() function example  
# Calling function  
a = complex(1) # Passing single parameter  
b = complex(1,2) # Passing both parameters  
# Displaying result  
print(a)  
print(b)  

Output:

(1.5+0j)
(1.5+2.2j)

Python delattr() Function

The Python delattr() function is used to delete an attribute from a class. It takes two parameters: the first is an object of the class, and the second is an attribute that we want to delete. After deleting the attribute, it is no longer available in the class and throws an error if you try to call it using the class object.

Python delattr() Function Example

Let us take an example to illustrate the delattr() function in Python.

class Student:  
    id = 101  
    name = "Pranshu"  
    email = "[email protected]"  
# Declaring function  
    def getinfo(self):  
        print(self.id, self.name, self.email)  
s = Student()  
s.getinfo()  
delattr(Student,'course') # Removing attribute which is not available  
s.getinfo() # error: throws an error  

Output:

101 Pranshu [email protected]
AttributeError: course

Python dir() Function

Python dir() function returns the list of names in the current local scope. If the object on which the method is called has a method named __dir__(), this method will be called and must return the list of attributes. It takes a single object type argument.

Python dir() Function Example

Let us take an example to illustrate the dir() function in Python.

# Calling function  
att = dir()  
# Displaying result  
print(att)  

Output:

['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__spec__']

Python divmod() Function

The Python divmod() function is used to get the remainder and quotient of two numbers. This function takes two numeric arguments and returns a tuple. Both arguments are required and numeric.

Python divmod() Function Example

Let us take an example to illustrate the divmod() function in Python.

# Python divmod() function example  
# Calling function  
result = divmod(10,2)  
# Displaying result  
print(result)  

Output:

(5, 0)

Python enumerate() Function

The Python enumerate() function returns an enumerated object. It takes two parameters: the first is a sequence of elements, and the second is the start index of the sequence. We can get the elements in sequence either through a loop or the next() method.

Python enumerate() Function Example

Let us take an example to illustrate the enumerate() function in Python.

# Calling function  
result = enumerate([1,2,3])  
# Displaying result  
print(result)  
print(list(result))  

Output:

<enumerate object at 0x7ff641093d80>
[(0, 1), (1, 2), (2, 3)]

Python dict() Function

The Python dict() function is a constructor that creates a dictionary. Python dictionary provides three different constructors to create a dictionary:

• If no argument is passed, it creates an empty dictionary.
• If a positional argument is given, a dictionary is created with the same key-value pairs. Otherwise, pass an iterable object.
• If keyword arguments are given, the keyword arguments and their values are added to the dictionary created from the positional argument.

Python dict() Function Example

Let us take an example to demonstrate the dict() function in Python.

# Calling function  
result = dict() # returns an empty dictionary  
result2 = dict(a=1,b=2)  
# Displaying result  
print(result)  
print(result2)  

Output:

{}
{'a': 1, 'b': 2}

Python filter() Function

The Python filter() function is used to get filtered elements. This function takes two arguments: the first is a function, and the second is an iterable. The filter function returns a sequence of those elements of an iterable object for which the function returns a true value.

The first argument can be none if the function is not available and returns only elements that are true.

Python filter() Function Example

Let us take an example to illustrate the filter() function in Python.

# Python filter() function example  
def filterdata(x):  
    if x>5:  
        return x  
# Calling function  
result = filter(filterdata,(1,2,6))  
# Displaying result  
print(list(result))  

Output:

[6]

Python hash() Function

The Python hash() function is used to get the hash value of an object. Python calculates the hash value by using the hash algorithm. The hash values are integers and used to compare dictionary keys during a dictionary lookup. We can hash only the types that are given below:

Hashable types: * bool * int * long * float * string * Unicode * tuple * code object.

Python hash() Function Example

Let us take an example to illustrate the hash() function in Python.

# Calling function  
result = hash(21) # integer value  
result2 = hash(22.2) # decimal value  
# Displaying result  
print(result)  
print(result2)  

Output:

21
461168601842737174

Python help() Function

Python’s help() function is used to get help related to the object passed during the call. It takes an optional parameter and returns help information. If no argument is given, it shows the Python help console. It internally calls Python’s help function.

Python help() Function Example

Let us take an example to illustrate the help() function in Python.

# Calling function  
info = help() # No argument  
# Displaying result  
print(info)  

Output:

Welcome to Python 3.5's help utility!

Python min() Function

The Python min() function is used to get the smallest element from the collection. This function takes two arguments: the first is a collection of elements, and the second is a key, and returns the smallest element from the collection.

Python min() Function Example

Let us take an example to illustrate the min() function in Python.

# Calling function    
small = min(2225,325,2025) # returns smallest element    
small2 = min(1000.25,2025.35,5625.36,10052.50)    
# Displaying result    
print(small)    
print(small2  

Output:

325
1000.25

Python set() Function

In Python, a set is a built-in class, and the Python set() function is a constructor of this class. It is used to create a new set using elements passed during the call. It takes an iterable object as an argument and returns a new set object.

Python set() Function Example

Let us take an example to illustrate the set() function in Python.

# Calling function    
result = set() # empty set    
result2 = set('12')    
result3 = set('TpointTech')    
# Displaying result    
print(result)    
print(result2)    
print(result3)    

Output:

set()
{'2', '1'}
{'i', 't', 'h', 'e', 'p', 'o', 'c', 'n', 'T'}

Python hex() Function

Python’s hex() function is used to generate the hex value of an integer argument. It takes an integer argument and returns an integer converted into a hexadecimal string. In case we want to get a hexadecimal value of a float, then use float.hex() function.

Python hex() Function Example

Let us take an example to illustrate the hex() function in Python.

# Calling function  
result = hex(1)   
# integer value  
result2 = hex(342)   
# Displaying result  
print(result)  
print(result2)  

Output:

0x1
0x156

Python id() Function

Python’s id() function returns the identity of an object. This is an integer that is guaranteed to be unique. This function takes an argument as an object and returns a unique integer number that represents identity. Two objects with non-overlapping lifetimes may have the same id() value.

Python id() Function Example

Let us take an example to illustrate the id() function in Python.

# Calling function    
val = id("TpointTech") # string object    
val2 = id(1200) # integer object    
val3 = id([25,336,95,236,92,3225]) # List object    
# Displaying result    
print(val)    
print(val2)    
print(val3)    

Output:

136794813706224
136794813580496
136794813641408

Python setattr() Function

The Python setattr() function is used to set a value to the object’s attribute. It takes three arguments, i.e., an object, a string, and an arbitrary value, and returns none. It is helpful when we want to add a new attribute to an object and set a value to it.

Python setattr() Function Example

Let us take an example to illustrate the setattr() function in Python.

class Student:    
    id = 0    
    name = ""    
        
    def __init__(self, id, name):    
        self.id = id    
        self.name = name    
            
student = Student(102,"Sohan")    
print(student.id)    
print(student.name)    
#print(student.email) product error    
setattr(student, 'email','[email protected]') # adding new attribute    
print(student.email)    

Output:

102
Sohan

[email protected]

Python hasattr() Function

In Python, the hasattr() function is a built-in function used to check whether an object has a specified attribute. It returns True if the attribute exists and False if it does not exist.

Python hasattr() Function Example

Let us take an example to illustrate the hasattr() function in Python.

class Car:  
    brand = "Ford"  
    model = "Mustang"  
  
my_car = Car()  
  
# It checks if the car's brand attribute exists in the Car class  
print(hasattr(Car, "brand"))  
  
# It checks if the car's model attribute exists in the my_car object  
print(hasattr(my_car, "model"))  
  
# It checks for an attribute that does not exist  
print(hasattr(my_car, "year"))  

Output:

True
True
False

Python slice() Function

The Python slice() function is used to get a slice of elements from a collection of elements. Python provides two overloaded slice functions. The first function takes a single argument, while the second function takes three arguments and returns a slice object. This slice object can be used to get a subsection of the collection.

Python slice() Function Example

Let us take an example to illustrate the slice() function in Python.

# Calling function  
result = slice(5) # returns slice object  
result2 = slice(0,5,3) # returns slice object  
# Displaying result  
print(result)  
print(result2)  

Output:

slice(None, 5, None)
slice(0, 5, 3)

Python sorted() Function

The Python sorted() function is used to sort elements. By default, it sorts elements in an ascending order, but it can also be sorted in descending order. It takes four arguments and returns a collection in sorted order. In the case of a dictionary, it sorts only keys, not values.

Python sorted() Function Example

Let us take an example to illustrate the sorted() function in Python.

str = "Python App" # declaring string    
# Calling function    
sorted1 = sorted(str) # sorting string    
# Displaying result    
print(sorted1)

Output:

[' ', 'A', 'P', 'h', 'n', 'o', 'p', 't', 'y']

Python next() Function

Python next() function is used to fetch the next item from the collection. It takes two arguments, i.e., an iterator and a default value, and returns an element.

This method calls on the iterator and throws an error if no item is present. To avoid the error, we can set a default value.

Python next() Function Example

Let us take an example to demonstrate the bin() function in Python.

number = iter([256, 32, 82]) # Creating iterator    
# Calling function    
item = next(number)     
# Displaying result    
print(item)    
# second item    
item = next(number)    
print(item)    
# third item    
item = next(number)    
print(item)    

Output:

256
32
82

Python input() Function

The Python input() function is used to get input from the user. It prompts for the user input and reads a line. After reading the data, it converts it into a string and returns it. It throws an EOFError if EOF is read.

Python input() Function Example

Let us take an example to illustrate the input() function in Python.

# Calling function    
val = input("Enter a value: ")    
# Displaying result    
print("You entered:",val)    

Output:

Enter a value: 45
You entered: 45

Python int() Function

The Python int() function is used to get an integer value. It returns an expression converted into an integer number. If the argument is a floating-point number, the conversion truncates the number. If the argument is outside the integer range, then it converts the number into a long type.

If the number is not a number or if a base is given, the number must be a string.

Python int() Function Example

Let us take an example to illustrate the int() function in Python.

# Calling function  
val = int(10) # integer value  
val2 = int(10.52) # float value  
val3 = int('10') # string value  
# Displaying result  
print("integer values :",val, val2, val3)  

Output:

integer values : 10 10 10

Python isinstance() Function

The Python isinstance() function is used to check whether the given object is an instance of that class. If the object belongs to the class, it returns true. Otherwise returns False. It also returns true if the class is a subclass.

The isinstance() function takes two arguments, i.e., object and classinfo, and then it returns either True or False.

Python isinstance() Function Example

Let us take an example to illustrate the isinstance() function in Python.

class Student:  
    id = 101  
    name = "John"  
    def __init__(self, id, name):  
        self.id=id  
        self.name=name  
  
student = Student(1010,"John")  
lst = [12,34,5,6,767]  
# Calling function   
print(isinstance(student, Student)) # isinstance of Student class  
print(isinstance(lst, Student))  

Output:

True
False

Python oct() Function

The Python oct() function is used to get the octal value of an integer number. This method takes an argument and returns an integer converted into an octal string. It throws an error, TypeError, if the argument type is other than an integer.

Python oct() Function Example

Let us take an example to illustrate the oct() function in Python.

# Calling function  
val = oct(10)  
# Displaying result  
print("Octal value of 10:",val)  

Output:

Octal value of 10: 0o12

Python ord() Function

The Python ord() function returns an integer representing the Unicode code point for the given Unicode character.

Python ord() Function Example

Let us take an example to illustrate the ord() function in Python.

# Code point of an integer  
print(ord('8'))  
  
# Code point of an alphabet   
print(ord('R'))  
  
# Code point of a character  
print(ord('&'))  

Output:

56
82
38

Python pow() Function

The Python pow() function is used to compute the power of a number. It returns x to the power of y. If the third argument(z) is given, it returns x to the power of y modulus z, i.e., (x, y) % z.

Python pow() Function Example

Let us take an example to illustrate the pow() function in Python.

# positive x, positive y (x**y)  
print(pow(4, 2))  
  
# negative x, positive y  
print(pow(-4, 2))  
  
# positive x, negative y (x**-y)  
print(pow(4, -2))  
  
# negative x, negative y  
print(pow(-4, -2))  

Output:

16
16
0.0625
0.0625

Python print() Function

The Python print() function prints the given object to the screen or other standard output devices.

Python print() Function Example

Let us take an example to illustrate the print() function in Python.

print("Python is programming language.")  
  
x = 7  
# Two objects passed  
print("x =", x)  
  
y = x  
# Three objects passed  
print('x =', x, '= y')  

Output:

Python is programming language.
x = 7
x = 7 = y

Python range() Function

The Python range() function returns an immutable sequence of numbers starting from 0 by default, increments by 1 (by default), and ends at a specified number.

Python range() Function Example

Let us take an example to illustrate the range() function in Python.

# empty range  
print(list(range(0)))  
  
# using the range(stop)  
print(list(range(4)))  
  
# using the range(start, stop)  
print(list(range(1,7 )))  

Output:

[]
[0, 1, 2, 3]
[1, 2, 3, 4, 5, 6]

Python reversed() Function

The Python reversed() function returns the reversed iterator of the given sequence.

Python reversed() Function Example

Let us take an example to illustrate the reversed() function in Python.

# for string  
String = 'Java'  
print(list(reversed(String)))  
  
# for tuple  
Tuple = ('J', 'a', 'v', 'a')  
print(list(reversed(Tuple)))  
  
# for range  
Range = range(8, 12)  
print(list(reversed(Range)))  
  
# for list  
List = [1, 2, 7, 5]  
print(list(reversed(List))) 

Output:

['a', 'v', 'a', 'J']
['a', 'v', 'a', 'J']
[11, 10, 9, 8]
[5, 7, 2, 1]

Python round() Function

The Python round() function rounds off the digits of a number and returns the floating-point number.

Python round() Function Example

Let us take an example to illustrate the round() function in Python.

#  for integers  
print(round(10))  
  
#  for floating point  
print(round(10.8))  
  
#  even choice  
print(round(6.6))  

Output:

10
11
7

Python issubclass() Function

The Python issubclass() function returns true if the object argument(first argument) is a subclass of the second class(second argument).

Python issubclass() Function Example

Let us take an example to illustrate the issubclass() function in Python.

class Rectangle:  
  def __init__(rectangleType):  
    print('Rectangle is a ', rectangleType)  
  
class Square(Rectangle):  
  def __init__(self):  
    Rectangle.__init__('square')  
      
print(issubclass(Square, Rectangle))  
print(issubclass(Square, list))  
print(issubclass(Square, (list, Rectangle)))  
print(issubclass(Rectangle, (list, Rectangle)))  

Output:

True
False
True
True

Python str() Function

The Python str() converts a specified value into a string.

Python str() Function Example

Let us take an example to illustrate the str() function in Python.

str('4')  

Output:

'4'

Python tuple() Function

The Python tuple() function is used to create a tuple object.

Python tuple() Function Example

Let us take an example to illustrate the tuple() function in Python.

t1 = tuple()  
print('t1=', t1)  
  
# creating a tuple from a list  
t2 = tuple([1, 6, 9])  
print('t2=', t2)  
  
# creating a tuple from a string  
t1 = tuple('Java')  
print('t1=',t1)  
  
# creating a tuple from a dictionary  
t1 = tuple({4: 'four', 5: 'five'})  
print('t1=',t1)  

Output:

t1= ()
t2= (1, 6, 9)
t1= ('J', 'a', 'v', 'a')
t1= (4, 5)

Python type()

The Python type() returns the type of the specified object if a single argument is passed to the type() built-in function. If three arguments are passed, then it returns a new type object.

Python type() Function Example

Let us take an example to illustrate the type() function in Python.

List = [4, 5]  
print(type(List))  
  
Dict = {4: 'four', 5: 'five'}  
print(type(Dict))  
  
class Python:  
    a = 0  
  
InstanceOfPython = Python()  
print(type(InstanceOfPython))  

Output:

<class 'list'>
<class 'dict'>
<class '__main__.Python'>

Python vars() function

The Python vars() function returns the __dict__ attribute of the given object.

Python vars() Function Example

Let us take an example to illustrate the vars() function in Python.

class Python:  
  def __init__(self, x = 7, y = 9):  
    self.x = x  
    self.y = y  
    
InstanceOfPython = Python()  
print(vars(InstanceOfPython))  

Output:

{'y': 9, 'x': 7}

Python zip() Function

The Python zip() Function returns a zip object, which maps a similar index of multiple containers. It takes iterables (can be zero or more), makes it an iterator that aggregates the elements based on the iterables passed, and returns an iterator of tuples.

Python zip() Function Example

Let us take an example to illustrate the zip() function in Python.

numList = [4,5, 6]  
strList = ['four', 'five', 'six']  
  
# No iterables are passed  
result = zip()  
  
# Converting itertor to list  
resultList = list(result)  
print(resultList)  
  
# Two iterables are passed  
result = zip(numList, strList)  
  
# Converting itertor to set  
resultSet = set(result)  
print(resultSet)  

Output:

[]
{(5, 'five'), (4, 'four'), (6, 'six')}

Total Number of Built-in Functions in Python

There are a variety of Built-in functions in Python. In the latest 3.11 version of Python, there are more than 70+ built-in functions.

We can check out all the built-in functions available in Python using the following code:

Python Example to Find Total Number of Built-in Functions

Let us take an example to illustrate the how to find the total number of built-in functions in Python.

import builtins  

print(dir(builtins))  

Output:

['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '__IPYTHON__', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'display', 'divmod', 'enumerate', 'eval', 'exec', 'execfile', 'filter', 'float', 'format', 'frozenset', 'get_iPython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'runfile', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']

Conclusion

In this tutorial, we covered everything about Python Built-in Functions. We learnt about various types of built-in functions in Python, like abs(), bin(), all(), bool(), compile(), sum(), ascii(), float(), etc. The Python built-in functions are defined as the functions whose functionality is pre-defined in Python. The Python interpreter has several functions that are always present for use. We studied each of these functions in detail with examples and their outputs. In conclusion, Python built-in functions are a vast topic and are necessary for efficient and time-saving coding.

In Python, a function is a block of statements that performs a particular task. The main idea is to group tasks that we often do repeatedly into a single function. This way we can simply call the function whenever needed and reuse the code efficiently without writing the same code multiple times for different inputs.

Advantages of Using Functions in Python

The following are some of the key benefits of using Python Functions

• Functions help in the reusability of code.
• It also reduces the code length.
• It improves the readability of code.

Declaration of Python Function

The declaration of the function in Python is done in the following way:

Types of Functions in Python

The following are the types of functions used in Python:

• Built-in Functions: Python standard functions that can be used anytime.
• User-defined Functions: Functions created by the users on the basis of their requirements.

Creating a Function in Python

In Python, a function is defined using the def keyword. Any type of functionalities and properties as per our need can be added to the functions.

Here is an example showing how to write a function in Python:

# Simple example to write a function  
  
# using def keyword to define a function  
def welcome():  
  print("Hello, Users! Welcome to Learn Python App!!")  

Explanation:

In this example, we have used the def keyword to define a function. Here, the function name is welcome(). Inside this function, we have added a block of code to print a welcome message for the users.

Calling a Function in Python

Once we create the function in Python, we can call it by using the name of that function followed by a parenthesis. This parenthesis encloses the arguments, if any, of that specified function.

Here is an example showing how to call a Python function:

Example

# Simple example to write a function  
  
# using def keyword to define a function  
def welcome():  
  print("Hello, Users! Welcome to Learn Python App!!")  
  
# calling of the defined function  
welcome()  

Output:

Hello, Users! Welcome to Learn Python App!!

Explanation:

In this example, we called the defined function welcome() by using the name of the function followed by parenthesis. We have not specified any arguments, as the function itself does not require any parameters in this case.

Python Function Arguments

Function Arguments in Python are the values passed into a function when it is called. These values are used by the function in order to perform its operations.

Here is an example of Python Function Arguments:

Example

# Simple example to write a function  
  
# using def keyword to define a function  
def welcome(name): # <--- parameter  
  print(f"Hello, {name}! Welcome to Learn Python App!!")  
  
# calling of the defined function  
welcome("John") # <--- argument  

Output:

Hello, John! Welcome to Learn Python App!!

Explanation:

In this example, we defined a function welcome(name), where ‘name’ is the string parameter enclosed within the parenthesis. Inside this function, we printed a welcome statement. We then called the function by passing an argument to it.

Let us see another example:

Example

# Simple Python Program to add two numbers  
  
# defining a function to add two numbers  
def addition(num1, num2): # <- 2 parameters (num1, num2)  
  # storing the sum of the numbers  
  sum = num1 + num2  
  # printing the result  
  print(num1, "+", num2, "=", sum)  
  
# calling the function  
addition(18, 15)  # <- passing 18 and 15 as arguments to the function  

Output:

18 + 15 = 33

Explanation:

In the above example, we have defined a function addition() having two parameters – num1 and num2. Inside this function, we stored the sum of the numbers and printed it.

Outside the function, we called the function by passing the values – 18 and 15 as arguments.

Types of Python Function Arguments

There are several types of function arguments:

• Positional Arguments
• Keyword Arguments
• Default Arguments
• Arbitrary Arguments (Variable-length arguments *args and **kwargs)

Python Return Statement

In Python, the return statement is used in order to return a value from the function.

Let us take a look at the following example:

Example

# defining a function  
def squareOf(num):  
  res = num ** 2  
  return res  # using return statement  
  
# function call  
sqr = squareOf(13)  
  
# printing the result  
print("Square of 13:", sqr)  

Output:

Square of 13: 169

Explanation:

In the above example, we created a function called squareOf(). This function accepts a number as an argument and returns the square of that number.

Therefore, when we pass 13 to the function, it returns its square, i.e. 169. We store this returned value in a variable and print it for display.

Note: The return statement also indicates that the function has ended. Any code written after the return statement does not execute.

Python Pass Statement

The pass statement acts as a placeholder for future code. This way, we can prevent errors from empty code blocks. It is generally used where the code is planned but has yet to be written.

Let us see an example:

Example

# defining a function  
def function_name():  
  pass  # using pass as placeholder  
  
# calling the function  
function_name()  

Explanation:

In this example, we have used the pass statement in the function. This pass statement, here, acts as the placeholder for the future code block. If we call the function, it will not return any error.

Conclusion

Functions are the building blocks of any programming language. They are used in Python to build clean, reusable, and efficient code. Whether you want to use the inbuilt functions or create your customized functions, they allow developers to organize the logic into a single block, making the code readable, user-friendly, and easier to debug or extend. From simple parameter handling to advanced concepts like recursion, anonymous (lambda) functions, nested functions, and variable-length arguments (*args and **kwargs), functions are essential to writing scalable and maintainable Python programs. Having command over Python functions will help you to enhance your problem-solving skills.