G2Labs Grzegorz Grzęda

July 13, 2023

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. This approach can result in cleaner, more readable code that is easier to test and reason about.

In this blog post, we will explore how to embrace functional programming concepts in Python to write clean and maintainable code. We will also provide extensive examples in both C and Python to demonstrate these concepts.

Immutable Data Structures

In functional programming, immutable data structures are used to prevent accidental modification of data. This helps in avoiding unexpected side effects and makes the code easier to reason about. Let’s consider an example of immutable data structures in C and Python.

Example in C:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Immutable Stack Implementation in C
struct Node {
    int data;
    struct Node* next;
};

struct Node* push(struct Node* node, int data) {
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = data;
    new_node->next = node;
    return new_node;
}

Example in Python:

1
2

# Immutable List Implementation in Python
immutable_list = (1, 2, 3, 4, 5)

Higher-Order Functions

Higher-order functions are functions that can take other functions as arguments or return functions as results. They enable composition and abstraction, leading to more reusable and modular code. Let’s demonstrate higher-order functions in C and Python.

Example in C:

1
2
3
4
5
6
7
8

// Higher-Order Function in C
int apply_operation(int (*operation)(int), int value) {
    return operation(value);
}

int double_value(int value) {
    return value * 2;
}

Example in Python:

1
2
3
4
5
6

# Higher-Order Function in Python
def apply_operation(operation, value):
    return operation(value)

def double_value(value):
    return value * 2

Pure Functions

Pure functions are functions that have no side effects and always return the same output for the same input. They rely only on their input parameters and do not modify external state. This makes them easier to reason about and test. Let’s see how pure functions can be implemented in C and Python.

Example in C:

1
2
3
4

// Pure Function in C
int add(int a, int b) {
    return a + b;
}

Example in Python:

1
2
3

# Pure Function in Python
def add(a, b):
    return a + b

Recursion

Recursion is a powerful technique in functional programming for solving problems by breaking them down into smaller, simpler subproblems. It can lead to elegant and expressive solutions. Here’s an example of recursion in C and Python.

Example in C:

1
2
3
4
5
6
7
8

// Recursion Example in C
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}

Example in Python:

1
2
3
4
5
6

# Recursion Example in Python
def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)

Conclusion

Embracing functional programming concepts in Python can lead to cleaner and more maintainable code. By leveraging immutable data structures, higher-order functions, pure functions, and recursion, developers can write code that is easier to reason about, test, and maintain.

In this blog post, we have explored these concepts with extensive examples in both C and Python. By understanding and applying these concepts, developers can take advantage of the benefits of functional programming in their Python projects.

Happy coding!

➡️ Understanding the MQTT Protocol: Intermediate Concepts for C and Python Developers

⬅️ Getting Started with MQTT: A Guide for Intermediate C and Python Programmers

Go back to Posts.