Using Python’s Four Programming Styles

my_list = [1, 2, 3, 4, 5]

1. Employing a functional coding approach
​
Everything is treated as a math equation in the functional coding paradigm. A local function or a lambda expression are the two most frequent approaches to compute the sum of my list. In Python 3.6, this is how you’d accomplish it with a local function:

import functools my_list = [1, 2, 3, 4, 5] def add_it(x, y): return (x + y) sum = functools.reduce(add_it, my_list) print(sum)

The functions package gives access to higher-order functions for data manipulation. You don’t always utilize it to do functional programming in Python. Here’s an example of how to use my list and a lambda function:

square = lambda x: x**2 double = lambda x: x + x print(list(map(square, my_list))) print(list(map(double, my_list)))

​As you’ll see, a lambda expression is more straightforward than a procedural method (or, at the very least, it is shorter). The functools.reduce() way is also available as a lambda function:​

import functools my_list = [1, 2, 3, 4, 5] sum = functools.reduce(lambda x, y: x + y, my_list) print(sum)

2. Making use of imperative coding 

​In imperative programming, you concentrate on the behavior of a program. To attain a goal, programs update state information as needed. Here’s an example of how to use my list:

sum = 0 for x in my_list: sum += x print(sum)

In contrast to the previous instances, the total value varies with each loop iteration. As a result, the sum is now in a state. When a variable contains a form, something must maintain it, implying that the variable is linked to a particular processor. Imperative coding works well for small applications, but it runs too slowly for big data science applications to produce optimal results.

3. Object-oriented programming style
​
Object-oriented coding is about making code more reusable and easy to comprehend in an application. Object-encapsulation orientations allow developers to approach code like a black box. It’s easier to extend the functionality of existing programs when you use object-oriented features like an inheritance. The object-oriented version of my list example is as follows:

class ChangeList(object): def __init__(self, any_list): self.any_list = any_list def do_add(self): self.sum = sum(self.any_list) create_sum = ChangeList(my_list) create_sum.do_add() print(create_sum.sum)

In this situation, create sum is a ChangeList instance. The user is unconcerned about the inner workings of ChangeList. All that counts is that you can use a list to construct a model and then use the do add() method to output the sum of the list components. The overall application is easier to grasp because the inner workings are hidden.

4. Making use of procedural coding
​
Procedure calls are used in the procedural approach to generate modularized code. This method simplifies your application code by splitting it into manageable chunks that a developer may easily view. Even though procedural coding is a more traditional application development method, it’s still a feasible option for tasks that can complete in steps. Using my list, here’s an example of procedural coding:

def do_add(any_list): sum = 0 for x in any_list: sum += x return sum print(do_add(my_list))

In this situation, using a function, do add(), simplifies the total code. Although the execution is still systematic, the code has been divided into chunks, making it easier to understand. However, this code suffers from the same drawbacks as the imperative paradigm. The use of state restricts execution alternatives, implying that this approach may not efficiently use hardware when dealing with complicated problems.

Four Programming Styles.

Deciding on a code style
​
Developers will disagree over code styles; everyone has an opinion about which is the best. (I’ve arranged the four classes in my preferred order.)

Python is unique because it allows you to select the programming paradigm that best suits your needs in each particular case. You can mix and switch paradigms even within a Python application as long as you remember to keep packages to inputs and outputs (keeping the code modular). There are no limitations prohibiting you from mixing and matching styles as you see fit. Python does not halt in the middle of processing your application and reporting a style fault when you combine techniques.

If you’re unsure which coding style will work best for a specific task, experiment with a few to see which one solves the problem the quickest and with the least amount of code. You might realize that a single style isn’t enough to solve the problem, and you’d like to combine numerous types into one application.

Finally, after you’ve discovered an effective solution to an issue, make sure to document it so that you—or another programmer—can continue working on it without reinventing the wheel. This is especially true when combining programming techniques, as increased flexibility can sometimes lead to a loss of clarity.

In picking the ideal Python programming style, today’s problem solving can become tomorrow’s time-saving template if done correctly.