Blog

def Function in Python

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.

March 17, 2026

Python Lambda Functions

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:

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:

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:

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

March 17, 2026

Python Built-in Functions
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.
March 17, 2026
Python Functions
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.
March 16, 2026
Control Statements in Python
In Python, control statements are used to alter the flow of execution in a program. They help make decisions, repeat actions, or skip parts of code based on certain conditions.

In Python, there are mainly three types of Control Statements:
1. Conditional Statements
2. Loop Statements
3. Jump Statements
Conditional Statements

As the name suggests, conditional statements (also known as decision-making statements) are used to make decisions in code. These statements evaluate the Boolean expression and control the flow of the program on the basis of the result of the condition specified.

There are primarily three types of decision-making statements in Python – if, if…else, and if…elif…else.

1) if Statement

The if statement helps us check if a given condition is true. In case, the specified condition evaluates to True, the associated block of code is executed.

Let us see an example of Python if statement.

Example
```
# simple example of python if  
  
x = 10  
  
# if statement  
if x > 5:  
  # inside if block  
  print("x is greater than 5")  
```
Output:
```
x is greater than 5
```
Explanation:

In the above example, we are given a variable x initialized with the value 10. We have used the if conditional statement to check if the value of x is greater than 5 (x > 5). Inside the if block, we have printed some statement.

Since the condition x > 5 is True, i.e., 10 > 5, therefore, the code inside the if-block is the executed and the specified statement is printed.

2) if…else Statement

The if-else statement is an extension of the basic if statement. In if-else, there is an alternative code block that is executed if the given condition is false. This way we can ensure that one of the two possible action is always carried out on the basis of the result of the condition.

Let us take a look at the following example of Python if…else statement.

Example
```
# simple example of python if-else  
  
x = 3  
  
# if-else statement  
if x > 5:  
  # inside if block  
  print("x is greater than 5")  
else:  
  # inside else block  
  print("x is less than or equal to 5")  
```
Output:
```
x is less than or equal to 5
```
Explanation:

In the above example, we are given a variable x initialized with the value 3. We have used the if-else conditional statement to check if the value of x is greater than 5 (x > 5). Inside the if block, we have printed some statement. Similarly, in the else block, we have added another statement for execution.

Since the condition x > 5 is False, i.e., 3 is not greater than 5, therefore, the code inside the else-block is the executed and the specified statement is printed.

3) if…elif…else Statement

The if-elif-else statement allows us to check multiple conditions sequentially. The conditions are evaluated one by one; if once a condition is true, the block corresponding to it is executed, and the remaining conditions are ignored. The else block executes only when none of the conditions are true.

We will now see an example of Python if…elif…else statement.

Example
```
# simple example of python if-elif-else  
  
x = 5  
  
# if-elif-else statement  
if x < 5:  
  # inside if block  
  print("x is less than 5")  
elif x > 5:  
  # inside elif block  
  print("x is greater than 5")  
else:  
  # inside else block  
  print("x is equal to 5")  
```
Output:
```
x is equal to 5
```
Explanation:

In the above example, we are given a variable x initialized with the value 5. We have used the if-elif-else conditional statement to check if the value of x is less than, greater than or equal to 5. Inside the if block, we have printed some statement. Similarly, in the elif and else block, we have added some more statements for execution.

Since the condition x < 5 and x > 5 is False therefore, the code inside the if and elif blocks are ignored and the statement from the else block is printed.

Loop Statements

Loop statements are the statements used for repeating a set of instructions multiple times for given condition. These statements allow us to automate repetitive tasks like counting, processing data, or checking conditions.

With the help of loops, we are not required to write the same code over and over again, making our program much cleaner, and easier to maintain.

In Python, we have two types of loops – for and while.

1) for Loop

Python for loop is used to iterate over a given sequence (like list, tuple, string or range). It allows us to repeat a block of code for each element in the sequence.

Here is an example of Python for.

Example
```
# simple example of python for  
  
beverages = ['tea', 'coffee', 'water', 'juice', 'milk']  
  
# iterating over the list using for loop  
for beverage in beverages:  
    print(beverage)  
```
Output:
```
tea
coffee
water
juice
milk
```
Explanation:

In this example, we are given a list consisting of some items. We then used the for loop to iterate through the elements of given list and printed them. As a result, each element is printed in order.

2) while Loop

Python while loop is used to repeatedly execute a block of code as long as a given condition remains True. It is useful when the number of iterations is unknown beforehand.

We will now see an example of Python while.

Example
```
# simple example of python while  
  
# initializing counter  
count = 1  
# looping with while loop  
while count <= 5:  
  # inside while loop  
  print(count, "Learn Python")  
  # incrementing by 1  
  count += 1  
```
Output:
```
1 Learn Python
2 Learn Python
3 Learn Python
4 Learn Python
5 Learn Python
```
Explanation:

Here, we have initialized a variable with the value 5 and created a while loop that executes a block of code as long as the initialized variable is less than and equals to 5. This code block includes a print statement and increments the variable value by 1.

As a result, we entered the while loop as the condition is true. For each iteration, a statement is printed and the value of the variable is incremented by 1. Once counter reaches 6, the condition counter <= 5 becomes False, causing the loop to terminate.

Jump Statements

Jump statements, also known as loop control statements, are used to transfer the control of the program to the specific statements. In other words, jump statements transfer the execution control to the other part of the program. There are three types of jump statements in Python – break, continue and pass.

1) break Statement

The break statement helps us stop a loop immediately, even if the condition has not been fully met. When we use break, the control exits the loop and moves to the code after it. We usually use it when we have found what we are looking for or when continuing the loop is no longer needed.

Let us see an example of Python break.

Example
```
# simple example of python break  
  
# using for loop  
for number in range(1, 10):  
  # checking if the current number is 6  
  if number == 6:  
    print("Found it!")  
    # using break to terminate the loop  
    break  
  print(f"Checking {number}")  
```
Output:
```
Checking 1
Checking 2
Checking 3
Checking 4
Checking 5
Found it!
```
Explanation:

In the above example, we have used the for loop to iterate over a numbers in a given range. Inside this loop, we have added a condition checking if the number in the current iteration is equal to 6 and used the break keyword to terminate the next iterations.

As a result, the numbers are iterated for the given range. When the number becomes 6, the loop terminates due to the break statement.

2) continue Statement

Python continue statement allow us to skip the current iteration of a loop and jump straight to the next one. We generally use it when we want to ignore specific cases in a loop without stopping the entire loop. It lets us control the flow more precisely by skipping only the unwanted part.

Example
```
# simple example of python continue  
  
names = ['John', '', 'Michael', 'Sachin', '', '', 'Irfan']  
  
# using for loop  
for name in names:  
  # if there is an empty string in the list  
  if name == "":  
    # using the continue statement to skip the current iteration  
    continue  
  print(f"Hello, {name}!")  
```
Output:
```
Hello, John!
Hello, Michael!
Hello, Sachin!
Hello, Irfan!
```
Explanation:

Here, we are given a list consisting of some names and empty strings. We have used the for loop to iterate over this list. We have also used the continue keyword to skip the current iteration if the current list element is an empty string.

As a result, the elements with empty strings are skipped and the names from the list are printed.

3) pass Statement

We can write placeholder code using the pass statement. It does nothing when executed; however it is useful to create a syntactically correct block that we plan to fill in later. Python pass is generally used while defining a loop, function, or condition where we have not written any logic yet.

Let us see a simple example of Python pass.

Example
```
# simple example of python pass  
  
# using for loop  
for i in range(1, 6):  
  if i == 3:  
    # using pass keyword  
    pass  
  else:  
    print(i)  
```
Output:
```
1
2
4
5
```
Explanation:

In the above example, we have used the for loop to iterate over a specific range. Inside this loop, we have used the pass statement as the placeholder inside if-else block.

Conclusion

In this tutorial, we have learned about control statements in Python with the help of examples. We discussed that there are mainly three types of control statements used in Python that includes decision-making, loop, and jump statements.

Decision-making statements helps us make decisions in code. These statements includes if, if-else, and if-elif-else statements. Whereas the loop statements helps us repeat a block of code for multiple times using the for and while loop. The jump statements like break, continue and pass helps us transfer the control of the program to the particular statements.
March 16, 2026

Difference Between For Loop and While Loop in Python

In Python, the for loop and while loop are two of the basic operations used to repeat a specified action multiple times. Both loops do share similarities; however, they have distinct mechanics and applications. We generally use the for loop in case the number of iterations is known in advance, and we use the while loop for an unknown number of iterations.

What is a For Loop in Python?

The Python for loop is a programming mechanism used for iterating over a sequence until a given condition is met.

The for loop in Python allows us to iterate over iterable objects, such as tuples, lists, dictionaries, and strings, until it reaches the termination of the sequence or the condition is fulfilled. The for loop proceeds to the next step after each iteration is completed.

For Loop Syntax in Python

It has the following syntax:

for var_name in sequence:

Parameter(s):

var_name: A name of a variable assigned to each element in the given sequence
sequence = Sequence refers to iterable elements such as lists, tuples, dictionaries, and strings
The loop executes once for each item in the iterable.
The indented block under the loop runs on every iteration.

Examples of Python For Loop

We will now look at some examples of Python ‘for’ loop:

Basic Example of a For Loop in Python

In this example, we will see a basic example of Python For Loop:

Let us see through a simple example to understand how the For Loop works:

Example

#let's  print numbers in a for loop using Range()  
for i in range(1,7): #Here we have used for loop  
    print (i)

Output:

Explanation:

In the above example, we used a for loop with the range() function to print numbers ranging from 1 to 6.

Another Example: Use of range() with For Loop

We will now take a look at an example to understand the working of the ‘for’ loop with the range() function.

Example

#receiving the input from the users  
row = int(input("Enter number of rows: "))  
#using the range function in a For Loop  
for i in range(1, row + 1):  
    # Print spaces  
    for j in range(row - i): #nested loop used  
        print("  ", end="")  
      
    # Print stars  
    for stars in range(2 * i - 1):    
        print("* ", end="")  
      
    print()

Output:

Enter number of rows: 5
*
* * *
* * * * *
* * * * * * *
* * * * * * * * *

Explanation:

The above code is an example of a Nested loop, where we have printed star patterns using a Nested For Loop.

What is the While Loop?

Python is used to repeatedly execute a block of code as long as a given condition remains True. It is useful when the number of iterations is unknown beforehand.

Syntax:

while condition:    

    # code block

condition: A Boolean expression that is evaluated before each iteration.
The code block inside the loop is executed only if the condition is true.
If the condition never becomes False, the loop will run infinitely, potentially causing an infinite loop.

Examples of Python While Loop

We will now look at some examples of Python while loops:

Basic Example of While Loop

In this example, we will see how the While loop functions in Python.

Example

# initializing a counter variable    
counter = 0    
# using the while loop to iterate the counter up to 5    
while counter < 5:    
  # printing the counter value and some statement    
  print(counter, "Hello")    
  # incrementing the counter value    
  counter += 1

Output:

0 Hello
1 Hello
2 Hello
3 Hello
4 Hello

Explanation:

In the above example, we have initialized a variable counter with the value 0. Then, we enter a while loop that executes the block of code as long as the counter is less than 5. Within the loop, we have printed the current value of the counter, followed by “Hello”. After each iteration, the counter is incremented by 1. Once the counter reaches 5, the condition counter < 5 becomes False, causing the loop to terminate.

Another Example: Use of the While loop with ‘else’

In this example, we will see how to use the While loop with the ‘else’ statement

Example

# initializing counter    
i = 1    
    
# iterate using the While loop    
while i <= 3:    
    print(i)    
    i += 1    
    # else block    
else:    
    print("Loop completed successfully!")

Output:

1
2
3
Loop completed successfully!

Explanation:

In this example, we have created a counter with an initial value of 1. We have then used the While loop with the ‘else’ statement to iterate under a specified condition. Inside this loop, we printed the counter value and increment it by 1. This loop iterates until the condition remains True. Under the ‘else’ block, we have printed a statement that runs when the condition becomes False.

Key differences between For Loop and While Loop

There are several differences between the for loop and the while loop in Python. Some main differences are as follows:

Feature	for Loop	while Loop
Definition	Iterates over a sequence (like a list, string, or range).	Repeats a block of code as long as a condition is True.
Usage	When the number of iterations is known or a sequence is available.	When the number of iterations is unknown or depends on a condition.
Syntax	for variable in iterable: # code block	while condition: # code block
Loop Control	Controlled by an iterable (e.g., list, tuple, range).	Controlled by a condition that must eventually become false.
Loop Variable	Automatically updates with each iteration.	Needs to be manually updated inside the loop.
Risk of Infinite Loop	Low, since it depends on an iterable.	Higher, if the condition is never made false.
Common Use Cases	Iterating over items in a list, string, dictionary, etc.	Waiting for user input, checking sensor data, or running until a condition.
Structure Simplicity	More concise when working with sequences.	More flexible for complex or dynamic conditions.
Termination	Ends automatically when the iterable is exhausted.	Ends only when the condition becomes false.

March 16, 2026

Difference Between break and continue in Python

In Python, the break and continue statements determine the flow of program execution. These statement control when the program continues the process and when it breaks execution.

The break Statement

The break Statement is used to abruptly stop the flow of the program, hence forcing the program to break out of the continuous or infinite loop.

Syntax:

 #block of code  

break

Example: break Statement

Let’s see an example where we will use the break statement.

Example

# Here we will iterate from number 1 to 10  
for num in range(1, 11):    
    if num % 2 == 0:    
        break  # using the break statement to abruptly stop the functioning of the program   
    print(num)

Output:

Explanation

In the above example, we used the break statement, which immediately stopped the flow of the program after the first iteration, and the output printed was only 1. It means as soon as the 1 is iterated, the break statement does its job.

The continue Statement

The continue statement in Python is used to skip the rest of the code inside a loop for the current iteration and proceed to the next iteration immediately.

We use the continue statement in some conditions where we want some situations to be completely ignored without affecting anything or breaking out of the entire loop. The Python continue statement in Python can be used in for and while loops to improve code efficiency and readability.

Syntax:

# jump statement    

continue;

Example: continue Statement

Let’s take the same example to see what will happen if we use the continue statement.

Example

# Here we will iterate from number 1 to 10  
for num in range(1, 11):    
    if num % 2 == 0:    
        continue  # it skips the rest of the loop for even numbers    
    print(num)

Output:

Explanation

In the above example, the continue statement is executed for every number known as num, which causes the program to skip the print(num) function and move on to the next iteration.

break Vs. continue Statement

Let’s quickly recap the difference between break and continue, which will help us remember the key points.

break Statement	continue Statement
The Break Statement in Python is used to abruptly stop the flow of the program.	The continue statement in Python is used to skip the rest of the code inside a loop for the current iteration.
It is commonly used inside switch blocks and is also valid in for, while, and do-while loops.	It is not applicable in switch statements but can be used in for, while, and do-while loops.
Once the break is executed, control moves directly outside the loop or switch structure.	When continue is executed, control jumps to the next cycle of the loop.
Syntax: break;	Syntax: continue;
It can be combined with labeled statements to exit outer loops in nested structures.	It does not support labeled usage for controlling outer loop flow.
Any remaining loop iterations are completely skipped after the break is triggered.	Remaining iterations still run, except the iteration in which continue appears.

Conclusion

Break and Continue statement acts like a steering wheel that controls the flow of the program by deciding whether to continue the process or break it abruptly.

They both use the syntax of their name, such as break and continue, respectively, followed by the colon(;). We used examples and output with their explanation to understand the working of these statements in the program. Lastly, we recapped the tutorial by making the tabular differences of Break and Continue.

March 16, 2026

Python Pass Statement
In Python, the pass Statement acts as a null operator or placeholder. It is applied when a statement is required syntactically, which means that the statement will be visible in the code but will be ignored; hence, it returns nothing.

Syntax of the Pass Statement

The following below is the syntax of the pass statement in Python:

Syntax:
```
 def func_name():  

    pass
```
Simple Python Pass Statement Example

Let us see a simple example to understand how Python’s pass statement works:

Example
```
# a function to send greetings  
def greeting():  
    # using pass statement  
    pass # this acts as a placeholder  
  
# calling the function  
greeting()  
```
Explanation:

Here, we have defined a function greeting() and used the pass statement to represent the placeholder.

Since this function is empty and returns nothing due to the pass statement, there will be no output when we call this function.

Using Pass Statement in Conditional Statements

The Pass statement in Conditional statements – if, else, elif, is used when we want to leave a space or placeholder for any particular condition.

Example
```
n=5  
if n>5:  
    pass # this works as a placeholder  
  
else:  
    print("The defined number n is 5 or less than 5")  
```
Output:
```
The defined number n is 5 or less than 5
```
Explanation:

In this example, we used the pass statement in the if-block of the if-else statement. Here, the pass statement is a placeholder indicating that a piece of code can be added in the if-block in the future.

Using Pass Statement in Loops

Pass statements in Loops – for, while, are used to symbolize that no action is performed and required during iteration.

Example
```
for i in range(10):  
    if i == 5:  
        pass #It will give nothing when i=5  
    else:  
        print(i)   
```
Output:
```
0
1
2
3
4
6
7
8
9
```
Explanation:

When the Pass Statement is used in the ‘if’ condition, it will print every number in the range of 0 to 10 except 5.

Using Pass Statement in Classes:

A pass statement in a Class is used to define an empty class and also as a placeholder for methods that can be used later.

Example
```
class Learn Python:  
    pass   
class Employees:  
    def __init__(self,first_name,last_name):  
        self.ft_name=ft_name #ft_name means first name  
        self.lt_name=lt_name #lt_name means last name  
    def ft_name(ft_name):  
        pass #placeholder for first name  
    def l_name(l_name):  
        pass #placeholder for last name  
```
Explanation:

The Learn Python class has no methods or attributes; here, the pass statement is used to describe an empty class.
In the Employees class, the first and last name methods are defined, but they produce nothing, as indicated by the pass keyword.

Conclusion

A pass statement is a prominent way to be used as a placeholder, which does not give any output. It can be used in conditional statements, loops, functions, and classes, which provides coders with a way to define the structure of the code without executing any functionality temporarily.
March 16, 2026
Python Break Statement
In Python, the break is a keyword used to prematurely exit a loop, before the loop iterates through all the elements or met its condition. When we execute the break statement, the program immediately terminates the loop, shifting the control to the next line of code after the loop. The break is commonly used in the cases where we need to exit the loop for a given condition.

Syntax of the Python Break Statement:

The syntax of the break statement in Python is given below:
```
 # jump statement  

break;
```
When executed, break causes the loop to terminate and proceeds to the next line of code. In the case of nested loops, break affects only the innermost loop.

Simple Python Break Statement Example

Here is a simple example to demonstrate how the break statement works in Python.

Example
```
# Loop through numbers from 1 to 10    
for num in range(1, 11):    
    if num == 6:  
        break  # breaking the loop at 6  
    print(num)  
```
Output:
```
1
2
3
4
5
```
In this example, we loop through the numbers from 1 to 10. We have used the if-statement to execute the break statement when num = 6.

As a result, the number from 1 to 5 is printed and the loop terminates when it reaches 6.

Flowchart of the break Statement in Python

The following is the flowchart of the Python break statement:

Step 1: Start the loop

Step 2: Check the loop condition

Step 3: If the loop condition is False, exit the loop.

Step 4: If the loop condition is True, proceed to the loop body.

Step 5: Inside the loop, evaluate a condition to decide whether to break.

Step 6: If the break condition is True, execute the break statement – immediately exit the loop.

Step 7: If the break condition is False, continue executing the loop body.

Step 8: After completing the current iteration – Go to the next iteration.

Step 9: Repeat steps 2-8 until the loop ends naturally or via break

Different Examples of the break Statement

Let us now see some more examples showing the use of the break statement in Python.

Example 1: Break Statement with for Loop

In Python, a ‘for’ loop is used to iterates over a given sequence (e.g., list, tuple, string or range), and executes a block of code for each item in the sequence. We can use the break statement within the ‘for’ loop in order to terminate the loop before it iterates over all elements, on the basis of a specified condition.

We will take a look an example show how to find an element from a list using the for-loop and the break statement.

Example
```
# given list  
fruit_basket = ['apple', 'mango', 'banana', 'orange', 'kiwi', 'watermelon', 'blueberries']  
  
# using the for loop to iterate through the list  
for index, fruit in enumerate(fruit_basket):  
    # if the fruit is equal to kiwi, then break the loop  
    if fruit == 'kiwi':  
        print("Fruit found!")  
        break   # break statement  
  
# printing the index of the located element  
print("Located at index =", index) 
```
Output:
```
Fruit found!
Located at index = 4
```
Explanation:

In the above example, we are given a list consisting of some fruits. We used the ‘for’ loop to iterate through the list. We used the enumerate() function to add a counter to the list. Inside the loop, we used the ‘if’ statement to check if the current element is ‘kiwi’. We then break the loop using the ‘break’ statement. At last, we printed the index value of the located element.

Example 2: Break Statement with While Loop

In Python, a ‘while’ loop repeatedly executes a code block as long as a particular condition is True. We can use the break statement within a while loop in order to exit the loop on the basis of dynamic conditions that may not be known in advance.

Let us see an example to understand how to use the break statement with the while loop.

Example
```
# initializing the counter  
count = 1  
  
# usign the while loop  
while True:  
  
    print("Count:", count)  
    # if the counter's value is 5, then break the loop  
    if count == 5:  
        print("Condition met! Exiting loop.")  
        break # using the break statement  
    # incrementing the counter by 1  
    count += 1  
```
Output:
```
Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Condition met! Exiting loop.
```
Explanation:

In this example, we initialize a variable, ‘count’ with 1 and used the ‘while’ loop that will run infinitely until the condition is True. Inside the ‘while’ loop, we printed the current value of the ‘count’ variable. We used the ‘if’ conditional statement to check if count’s value is 5 and used the ‘break’ statement to break the loop. At last, we incremented the value of the variable by 1.

Example 3: Break Statement with Nested Loop

In Python, nested loops are the loops within loops. It allow us to perform more complex iterations, like looping over multi-dimensional data structures. While using the break statement within nested loops, it is important to understand its scope.
- Innermost Loop Exit: A break statement will only exit the loop in which it is directly placed.
- Exiting Multiple Loops: In order to exit multiple levels of nested loops, we need to use additional strategies like adding flags, or encapsulating loops within functions.
Here is an example of using the break statement in nested loops to search for a number in a 2D list:

Example
```
# given 2D list  
matrix = [  
    [10, 15, 20],  
    [25, 30, 35],  
    [40, 45, 50]  
]  
# element to be searched  
target = 30  
  
found = False  # Flag to track if the number is found  
  
# using the for nested loop  
for row in matrix:  
    for num in row:  
        # if the current element is equal to the target value, set flag to True and break the loop        
        if num == target:  
            print(f"Number {target} found! Exiting loops.")  
            found = True  
            break  # using break statement  
    # exiting the outer loop  
    if found:  
        break  
```
Output:
```
Number 30 found! Exiting loops.
```
Explanation:

In this example, we are given a 2D list and a value to be searched in the list. We initialized a flag as False and used the nested ‘for’ loop to traverse the elements of the 2D list. We then used the ‘if’ statement to check for the target value in the list and used the ‘break’ statement to break the inner loop, once found. Then we again used the ‘break’ statement to exit the outer loop.

Conclusion

Python provides the break statement which helps programmers execute loop termination based on specific conditions. The break statement functions best at preventing waste in for loops and while loops and nested loops to enhance their speed. Multiple conditions exist for using break in nested loops because the exit command affects only the innermost loop thus requiring supplementary logic to terminate outer loops. The controlled use of break improves program efficiency by making the expression best suited for search operations and data processing and real-time monitoring needs.
March 16, 2026
Python Continue Statement
The continue statement in Python is used to skip the rest of the code inside a loop for the current iteration and proceed to the next iteration immediately. It is useful when some specified conditions need to be ignored without terminating or breaking out of the entire loop. The continue statement in Python is used in for and while loops to improve code efficiency and readability.

Syntax of the Continue Statement:

The syntax of the Python Continue statement is as follows:
```
# jump statement  

continue;
```
When the continue statement is executed in Python, it enables the loop to skip the rest of the code in the current iteration and immediately advances to the next iteration. In the case of nested loops, the continue statement only affects the innermost loop.

Simple Python Continue Statement Example

Let’s see a simple example to understand how the continue statement works:

Example
```
# Loop through numbers from 1 to 10  
for num in range(1, 11):  
    if num % 2 == 0:  
        continue  # Skip the rest of the loop for even numbers  
    print(num)  
```
Output:
```
1
3
5
7
9
```
Explanation:

In the above example, the continue statement is executed for every number known as num, which causes the program to skip the print(num) function and move on to the next iteration.

Flowchart of the continue Statement in Python

The following is the flowchart of the Python continue statement:

Explanation of the Flowchart of Python Continue Statement:

Step 1: Initially, the loop starts.

Step 2: The condition of the loop is checked.

Step 3: If the ‘continue’ condition is achieved:
- It skips the remaining elements in the loop.
- Then, it jumps to the next iteration.
Step 4: Otherwise, the remaining loop body is executed.

Step 5: The entire process gets repeated until the loop terminates.

Different Examples of the continue Statement

Let us now see some more examples showing the use of the continue statement in Python.

Example 1: Skipping Specific Values

Let us take an example to demonstrate how to skip specific value in Python using continue statement.

Example
```
# here we are iterating through the characters in the string  
for char in "Python Programming":    
  # skipping the character 'o'    
  if char == 'o':    
    continue    
  # printing the characters    
  print(char, end='')    
```
Output:
```
Pythn Prgramming
```
Explanation:

Here, the letter ‘o’ is skipped whenever it appears in the string.

Example 2: Skipping Iterations in a while Loop

Let us take an example to demonstrate how to skip iterations in while loop using the continue statement.

Example
```
# initializing value of x as 0  
x = 0  
# using the while loop  
while x < 10:  
  # incrementing the value of x upto 10  
  x += 1  
  if x == 5:  
    continue  # Skip printing when x is 5  
  # printing the value of x  
  print(x)  
```
Output:
```
1
2
3
4
6
7
8
9
10
```
Explanation:

When x equals 5, the continue statement prevents print(x) from executing, and the loop proceeds with the next iteration.

Example 3: Skipping Negative Numbers in a List

Let us take an example to demonstrate how to skip negative numbers in a list using the continue statement.

Example
```
# list of numbers  
numbers = [10, -3, 5, -8, 7]  
  
# iterating through the elements of the list  
for num in numbers:  
  # skipping a number less than 0  
  if num < 0:  
    continue  
  # printing the numbers  
  print(num)  
```
Output:
```
10
5
7
```
Explanation:

In this example, negative numbers are skipped, and only positive numbers are printed.

Example 4: Skipping Certain Words in a Sentence

Let us take an example to demonstrate how to skip certain words in a sentence using the continue statement.

Example
```
# given sentence  
sentence = "Python learn from a Learn Python App"  
# list of words to skip  
words_to_skip = ["from", "a"]  
  
# using for-loop  
for word in sentence.split():  
    if word in words_to_skip:  
        continue    # continue statement to skip the words from given list  
    print(word, end=' ')  
```
Output:
```
Python learn Python App
```
Explanation:

Here, the words “from” and “a” are skipped while printing the rest of the sentence.

Example 5: Skipping Multiples of 3 in a Range

Let us take an example to demonstrate how to skip multiples of 3 in a range using the continue statement.

Example
```
# for loop to iterate through 1 to 20  
for num in range(1, 20):  
  # skipping the multiples of 3   
  if num % 3 == 0:  
    continue  
  # printing the numbers  
  print(num, end=' ')  
```
Output:
```
1 2 4 5 7 8 10 11 13 14 16 17 19
```
Explanation:

This example skips numbers that are multiples of 3 while printing the rest.

Example 6: Skipping Empty Strings in a List

Let us take an example to demonstrate how to skip empty strings in a list using the continue statement.

Example
```
# here is the list of words    
words = ["apple", "", "banana", "cherry", ""]    
    
# using a for-loop to iterate through the words in the list    
for word in words:    
  # skipping the empty string from the list    
  if word == "":    
    continue    
  # printing the words from the list    
  print(word)    
```
Output:
```
apple
banana
cherry
```
Advantages of Python Continue Statement

There are several advantages of using the Continue Statement in Python. Let’s see some of them:
- Skipping Unwanted Iterations: If there’s a need to omit some value(s) in the loop, repeating sequences while the remainder of the iterations are still executed, the loop can be used.
- Avoiding Nested if Conditions: Unwanted nested if statements are easily removed, and code is made less complex with a single continue statement. Controlling the flow of a program with continue is airy.
- Efficient Filtering: In most cases where data is being processed through lists or iterations, unwanted values can be bypassed via continue.
- Performance: The term continues, in regard to loops of computation or operation, moves the remaining parts of the loop of calculation to the next iteration; thus, in cases where particular operations are not needed, continuing assists in bringing forth suitable efficiency when it comes to value or return.
- Specific Conditions: If there’s a request to omit an operation on certain conditions without getting out of the loop, continuing is the best option available.
Conclusion

The use of a specific loop iteration can be skipped by utilizing the “continue” statement in Python without exiting the iteration process. This comes in handy when certain conditions should be left out while processing other elements that form a sequence. The code structure becomes simple and makes comprehending the loops easier, which ultimately increases the efficiency of the program.
March 16, 2026

Blog

def Function in Python

What is the ‘def’ Keyword?

def keyword Syntax:

Defining a Simple Function using the def Keyword

Example

Understanding the Function Parameters and Arguments

Positional Arguments

Example

Default Arguments

Example

Keyword Arguments

Example

Arbitrary Arguments

Example

Return Values

Example

Returning Multiple Values

Example

Scope and Lifetime of Variables

Example

Lambda Functions

Lambda Function Syntax:

Parameters:

Python Lambda Function Example

Example

Recursive Functions

Example

Nested Functions

Example

Decorators

Example

Best Practices for Using Functions

Understanding the Use of the def Keyword in Classes

Python Def Keyword Example in Classes

Example

Difference Between lambda and def Keyword

Conclusion

Python Lambda Functions

Python Lambda Function Syntax

Parameters:

Simple Lambda Function Example in Python

Example

Lambda Function Example with Multiple Arguments in Python

Example

Lambda with Condition Checking

Example

Lambda with List Comprehension

Example

Lambda with if-else

Lambda Function Example using if-else statement in Python

Example

Lambda with Multiple Statements

Example

Using lambda with filter()

Python Lambda Function Example using filter() Function

Example

Using lambda with map()

Example

Using lambda with reduce()

Python Lambda Function Example using reduce() Function

Example

Difference Between lambda and def Keyword

Conclusion

Python Built-in Functions

Python abs() Function

Python abs() Function Example

Python all() Function

Python all() Function Example

Python bin() Function

Python bin() Function Example

Python bool() Function

Python bool() Function Example

Python bytes()

Python bytes() Function Example

Python callable() Function

Python callable() Function Example

Python compile() Function

Python compile() Function Example

Python exec() Function