6.5. Immutability and Pure Functions in Python

Immutability refers to objects whose state cannot be modified after creation. Immutable types in Python include:

● int ● float ● str ● tuple ● frozenset

Using immutable data structures prevents unintended side effects.

Immutability means that once an object is created, it cannot change. For example, a tuple is immutable; you cannot alter its contents after you define it. This characteristic is crucial in functional programming because it helps to prevent side effects. If a function uses an immutable object, you can be confident its behavior won't accidentally alter that object, leading to more predictable and reliable programs.

Think of immutability like a sealed jar of pickles. Once the jar is sealed, you cannot change the contents. If you try to shake the jar, it won’t alter the pickles inside—it’s contained. Similarly, immutable objects can't be changed after they've been created, making your code more predictable.

A pure function is a function that:

● Has no side effects. ● Returns the same output for the same input.

Example:

def add(a, b): return a + b

This function does not alter any global state or modify its input.

A pure function ensures that the output depends only on its inputs and does not affect or rely on any external state. For instance, in the example provided, the add function only takes two arguments and returns their sum without changing anything outside of its scope. This makes functions easy to understand, test, and debug since each function behaves consistently, given the same input.

Imagine a vending machine that only gives you a snack based on the button you press. If you press button A, you always receive snack A, no matter how many times you press it. This is like a pure function: it consistently provides the same result without changing anything else.

Impure Example:

c = 10

def add_impure(a): return a + c # Depends on global variable

An impure function can have unpredictable behavior because its output may depend on some external state (like the global variable c). This means that if c changes, the result of the add_impure function will also change without any change to its input arguments. Such functions are harder to test and debug since their behavior can change unexpectedly based on external factors.

Think of an impure function like a restaurant dish that changes based on the chef's mood. If on a particular day the chef feels creative, the dish may taste different even if you order the same one. This unpredictability makes it hard to know what you'll actually get each time.

Benefits:

● Easier to test and debug. ● Facilitates parallel processing. ● Increases code clarity.

Using immutability and pure functions enhances software development. Testing becomes simpler because you can run functions independently, knowing they won't alter shared states. This isolation also allows multiple functions to run simultaneously without interfering with each other (ideal for parallel processing). Finally, the clarity of pure functions makes collaboration easier, as they serve as clear building blocks without hidden dependencies.

Imagine working on a group project. If each member completes their tasks independently without affecting others, you can easily integrate everyone's work. This is similar to how pure functions operate: they can be developed, tested, and utilized in isolation, facilitating smoother collaboration and clearer outcomes.

--