DEV Community

Vasanthakumari N
Vasanthakumari N

Posted on

Python Day 8: Pure Functions, Impure Functions, Local and Global Variables

Pure Functions

A pure function is a function that:

  1. Always produces the same output for the same input.
  2. Does not modify external data.

Example:


total = 10000

def roaming_with_friends(amount):
    return total - amount

def eat_outside(amount):
    return total - amount

def spend_for_shopping(amount):
    return total - amount

remaining_amount = spend_for_shopping(1200)
print(remaining_amount)  # 8800

remaining_amount = eat_outside(300)
print(remaining_amount)  # 9700
Enter fullscreen mode Exit fullscreen mode
Output:

8800
9700
Enter fullscreen mode Exit fullscreen mode

How does it work?

  • Initially, total = 10000.
  • Shopping: 10000 - 1200 = 8800.
  • Eating outside: 10000 - 300 = 9700.
  • The original value of total remains 10000.

In this example, the functions read the global variable but do not modify it. Each calculation starts with the original value.

Impure Functions

An impure function depends on or modifies external data, or produces side effects.

Example:

total = 10000

def roaming_with_friends(amount):
    return total - amount

def eat_outside(amount):
    return total - amount

def spend_for_shopping(amount):
    return total - amount

total = spend_for_shopping(1200)
print(total)  # 8800

total = eat_outside(300)
print(total)  # 8500

total = eat_outside(200)
print(total)  # 8300
Enter fullscreen mode Exit fullscreen mode
Output:

8800
8500
8300
Enter fullscreen mode Exit fullscreen mode

How does it work?

  • Initially, total = 10000.
  • Shopping: 10000 - 1200 = 8800.
  • Eating outside: 8800 - 300 = 8500.
  • Eating outside again: 8500 - 200 = 8300.

Here, the global variable total is updated after every calculation. Therefore, the next calculation uses the previously updated value.

This example demonstrates how functions can depend on external state.

Local Variables

A local variable is a variable declared inside a function.

It can be accessed only within that function.

Example:

def eat(amount):
    total = 500
    return total - amount

print(eat(100))
Enter fullscreen mode Exit fullscreen mode
Output:

400
Enter fullscreen mode Exit fullscreen mode

Here:

  • amount is a parameter and acts as a local variable.
  • total is also a local variable.
  • Both belong to the function eat().

We cannot directly access these local variables outside the function.

Global Variables

A global variable is declared outside a function.

It can be accessed inside functions in the same module.

Example:

total = 100000

def eat(amount):
    return total - amount

print(eat(500))

Enter fullscreen mode Exit fullscreen mode
Output:

99500
Enter fullscreen mode Exit fullscreen mode

Here, total is a global variable because it is declared outside the function.

The function can read its value without using the global keyword.

Global Keyword in Python

The global keyword is used when we want to assign a new value to a global variable from inside a function.

Example:

total = 10000

def shopping(amount):
    global total
    total = total - amount

shopping(1200)
print(total)
Enter fullscreen mode Exit fullscreen mode
Output:

8800
Enter fullscreen mode Exit fullscreen mode

Here:

  • total is declared globally.
  • The global total statement tells Python that we want to modify the global variable.
  • After calling the function, the global value becomes 8800.

Important: We do not need the global keyword just to read a global variable. It is needed when assigning to that global variable inside a function

Local and Global Variables Together

Let's understand which variables are local and which are global.

total = 100

def check(no1):
    print(total - no1)

print(total)
check(10)
Enter fullscreen mode Exit fullscreen mode
Output:

100
90
Enter fullscreen mode Exit fullscreen mode

Here:

  • total is a global variable.
  • no1 is a local parameter of the check() function.
  • The function can access the global variable total.
  • The variable no1 is available only inside check().

If we try:

print(no1)

Python raises a NameError because no1 is not defined outside the function.

Remember: Calling one function inside another function does not change whether a variable is local or global. Its scope depends on where it is defined.

Current Time Example – Impure Function

from datetime import datetime

def display_time():
    now = datetime.now()
    t = now.strftime("%H:%M:%S")
    print("Current Time =", t)

display_time()

Enter fullscreen mode Exit fullscreen mode
Output:

Current Time = 11:45:30
Enter fullscreen mode Exit fullscreen mode

The output changes depending on when we call the function.

Even though there are no arguments, the function depends on the current system time and prints the result.

Therefore, it is an impure function.

Top comments (0)