5 Suggestions for Writing Higher Python Capabilities – KDnuggets

All of us write features when coding in Python. However will we essentially write good features? Effectively, let’s discover out.

Capabilities in Python allow you to write modular code. When you may have a process it’s essential carry out at a number of locations, you may wrap the logic of the duty right into a Python operate. And you may name the operate each time it’s essential carry out that particular process. So simple as it appears to get began with Python features, writing maintainable and performant features is just not so easy.

And that’s why we’ll discover just a few practices that’ll aid you write cleaner and easy-to-maintain Python features. Let’s get began…

1. Write Capabilities That Do Solely One Factor

When writing features in Python, it is usually tempting to place all associated duties right into a single operate. Whereas this can assist you code issues up shortly, it’ll solely make your code a ache to keep up within the close to future. Not solely will this make understanding what a operate does tougher but in addition results in different points corresponding to too many parameters (extra on that later!).

As an excellent observe, it’s best to all the time attempt to make your operate do just one factor—one process—and try this nicely. However typically, for a single process, you could have to work by way of a sequence of subtasks. So how do you resolve if and the way the operate needs to be refactored?

Relying on what the operate is making an attempt to do and the way complicated the duty is, you may work out the separation of considerations between subtasks. After which determine an appropriate degree at which you’ll refactor the operate into a number of features—every specializing in a selected subtask.

Refactor features | Picture by Creator

Right here’s an instance. Take a look at the operate analyze_and_report_sales:

# fn. to investigate gross sales information, calculate gross sales metrics, and write it to a file
def analyze_and_report_sales(information, report_filename):
	total_sales = sum(merchandise['price'] * merchandise['quantity'] for merchandise in information)
	average_sales = total_sales / len(information)
    
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Total Sales: {total_sales}n")
    	    report_file.write(f"Average Sales: {average_sales}n")
    
	return total_sales, average_sales

It is fairly simple to see that it may be refactored into two features: one calculating the gross sales metrics and one other on writing the gross sales metrics to a file like so:

# refactored into two funcs: one to calculate metrics and one other to write down gross sales report
def calculate_sales_metrics(information):
	total_sales = sum(merchandise['price'] * merchandise['quantity'] for merchandise in information)
	average_sales = total_sales / len(information)
	return total_sales, average_sales

def write_sales_report(report_filename, total_sales, average_sales):
	with open(report_filename, 'w') as report_file:
    	    report_file.write(f"Total Sales: {total_sales}n")
    	    report_file.write(f"Average Sales: {average_sales}n")

Now it’s simpler to debug any considerations with the calculation of gross sales metrics and file operations individually. And right here’s a pattern operate name:

information = [{'price': 100, 'quantity': 2}, {'price': 200, 'quantity': 1}]
total_sales, average_sales = calculate_sales_metrics(information)
write_sales_report('sales_report.txt', total_sales, average_sales)

You must be capable to see the ‘sales_report.txt’ file in your working listing with the gross sales metrics. This can be a easy instance to get began, however that is useful particularly whenever you’re engaged on extra complicated features.

2. Add Kind Hints to Enhance Maintainability

Python is a dynamically typed language. So you don’t want to declare varieties for the variables you create. However you may add kind hints to specify the anticipated information kind for variables. Whenever you outline the operate, you may add the anticipated information varieties for the parameters and the return values.

As a result of Python doesn’t implement varieties at runtime, including kind hints has no impact at runtime. However there nonetheless are advantages to utilizing kind hints, particularly on the maintainability entrance:

• Including kind hints to Python features serves as inline documentation and provides a greater concept of what the operate does and what values it consumes and returns.
• Whenever you add kind hints to your features, you may configure your IDE to leverage these kind hints. So that you’ll get useful warnings when you attempt to go an argument of invalid kind in a number of operate calls, implement features whose return values don’t match the anticipated kind, and the like. So you may reduce errors upfront.
• You’ll be able to optionally use static kind checkers like mypy to catch errors earlier slightly than letting kind mismatches introduce refined bugs which are troublesome to debug.

Right here’s a operate that processes order particulars:

# fn. to course of orders
def process_orders(orders):
	total_quantity = sum(order['quantity'] for order in orders)
	total_value = sum(order['quantity'] * order['price'] for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

Now let’s add kind hints to the operate like so:

# modified with kind hints
from typing import Checklist, Dict

def process_orders(orders: Checklist[Dict[str, float | int]]) -> Dict[str, float | int]:
	total_quantity = sum(order['quantity'] for order in orders)
	total_value = sum(order['quantity'] * order['price'] for order in orders)
	return {
    	'total_quantity': total_quantity,
    	'total_value': total_value
	}

With the modified model, you get to know that the operate takes in a listing of dictionaries. The keys of the dictionary ought to all be strings and the values can both be integers or floating level values. The operate additionally returns a dictionary. Let’s take a pattern operate name:

# Pattern information
orders = [
	{'price': 100.0, 'quantity': 2},
	{'price': 50.0, 'quantity': 5},
	{'price': 150.0, 'quantity': 1}
]

# Pattern operate name
outcome = process_orders(orders)
print(outcome)

This is the output:

{'total_quantity': 8, 'total_value': 600.0}

On this instance, kind hints assist us get a greater concept of how the operate works. Going ahead, we’ll add kind hints for all the higher variations of Python features we write.

3. Settle for Solely the Arguments You Truly Want

In case you are a newbie or have simply began your first dev position, it’s essential to consider the completely different parameters when defining the operate signature. It is fairly frequent to introduce extra parameters within the operate signature that the operate by no means truly processes.

Guaranteeing that the operate takes in solely the arguments which are truly vital retains operate calls cleaner and extra maintainable on the whole. On a associated observe, too many parameters within the operate signature additionally make it a ache to keep up. So how do you go about defining easy-to-maintain features with the precise variety of parameters?

If you end up writing a operate signature with a rising variety of parameters, step one is to take away all unused parameters from the signature. If there are too many parameters even after this step, return to tip #1: break down the duty into a number of subtasks and refactor the operate into a number of smaller features. This may assist maintain the variety of parameters in examine.

Hold num_params in examine | Picture by Creator

It’s time for a easy instance. Right here the operate definition to calculate pupil grades comprises the teacher parameter that’s by no means used:

# takes in an arg that is by no means used!
def process_student_grades(student_id, grades, course_name, teacher'):
	average_grade = sum(grades) / len(grades)
	return f"Student {student_id} achieved an average grade of {average_grade:.2f} in {course_name}."

You’ll be able to rewrite the operate with out the teacher parameter like so:

# higher model!
def process_student_grades(student_id: int, grades: record, course_name: str) -> str:
	average_grade = sum(grades) / len(grades)
	return f"Student {student_id} achieved an average grade of {average_grade:.2f} in {course_name}."

# Utilization
student_id = 12345
grades = [85, 90, 75, 88, 92]
course_name = "Mathematics"
outcome = process_student_grades(student_id, grades, course_name)
print(outcome)

This is the output of the operate name:

Pupil 12345 achieved a mean grade of 86.00 in Arithmetic.

4. Implement Key phrase-Solely Arguments to Reduce Errors

In observe, most Python features absorb a number of arguments. You’ll be able to go in arguments to Python features as positional arguments, key phrase arguments, or a mixture of each. Learn Python Perform Arguments: A Definitive Information for a fast evaluate of operate arguments.

Some arguments are naturally positional. However typically having operate calls containing solely positional arguments could be complicated. That is very true when the operate takes in a number of arguments of the identical information kind, some required and a few non-obligatory.

Should you recall, with positional arguments, the arguments are handed to the parameters within the operate signature within the identical order during which they seem within the operate name. So change so as of arguments can introduce refined bugs kind errors.

It’s usually useful to make non-obligatory arguments keyword-only. This additionally makes including non-obligatory parameters a lot simpler—with out breaking present calls.

Right here’s an instance. The process_payment operate takes in an non-obligatory description string:

# instance fn. for processing transaction
def process_payment(transaction_id: int, quantity: float, forex: str, description: str = None):
	print(f"Processing transaction {transaction_id}...")
	print(f"Amount: {amount} {currency}")
	if description:
    		print(f"Description: {description}")

Say you wish to make the non-obligatory description a keyword-only argument. Right here’s how you are able to do it:

# implement keyword-only arguments to attenuate errors
# make the non-obligatory `description` arg keyword-only
def process_payment(transaction_id: int, quantity: float, forex: str, *, description: str = None):
	print(f"Processing transaction {transaction_id}:")
	print(f"Amount: {amount} {currency}")
	if description:
    		print(f"Description: {description}")

Let’s take a pattern operate name:

process_payment(1234, 100.0, 'USD', description='Cost for companies')

This outputs:

Processing transaction 1234...
Quantity: 100.0 USD
Description: Cost for companies

Now attempt passing in all arguments as positional:

# throws error as we attempt to go in additional positional args than allowed!
process_payment(5678, 150.0, 'EUR', 'Bill cost') 

You’ll get an error as proven:

Traceback (most up-to-date name final):
  File "/home/balapriya/better-fns/tip4.py", line 9, in 
	process_payment(1234, 150.0, 'EUR', 'Bill cost')
TypeError: process_payment() takes 3 positional arguments however 4 got

5. Don’t Return Lists From Capabilities; Use Mills As an alternative

It is fairly frequent to write down Python features that generate sequences corresponding to a listing of values. However as a lot as doable, it’s best to keep away from returning lists from Python features. As an alternative you may rewrite them as generator features. Mills use lazy analysis; in order that they yield parts of the sequence on demand slightly than computing all of the values forward of time. Learn Getting Began with Python Mills for an introduction to how turbines work in Python.

For example, take the next operate that generates the Fibonacci sequence as much as a sure higher restrict:

# returns a listing of Fibonacci numbers
def generate_fibonacci_numbers_list(restrict):
	fibonacci_numbers = [0, 1]
	whereas fibonacci_numbers[-1] + fibonacci_numbers[-2] 

It’s a recursive implementation that’s computationally costly and populating the record and returning it appears extra verbose than vital. Right here’s an improved model of the operate that makes use of turbines:

# use turbines as an alternative
from typing import Generator

def generate_fibonacci_numbers(restrict: int) -> Generator[int, None, None]:
	a, b = 0, 1
	whereas a 

On this case, the operate returns a generator object which you’ll then loop by way of to get the weather of the sequence:

restrict = 100
fibonacci_numbers_generator = generate_fibonacci_numbers(restrict)
for num in fibonacci_numbers_generator:
	print(num)

Right here’s the output:

0
1
1
2
3
5
8
13
21
34
55
89

As you may see, utilizing turbines could be far more environment friendly particularly for big enter sizes. Additionally, you may chain a number of turbines collectively, so you may create environment friendly information processing pipelines with turbines.

Wrapping Up

And that’s a wrap. You could find all of the code on GitHub. Right here’s a evaluate of the completely different suggestions we went over:

• Write features that do just one factor
• Add kind hints to enhance maintainability
• Settle for solely the arguments you really need
• Implement keyword-only arguments to attenuate errors
• Do not return lists from features; use turbines as an alternative

I hope you discovered them useful! Should you aren’t already, check out these practices when writing Python features. Completely satisfied coding!
 
 

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, information science, and content material creation. Her areas of curiosity and experience embrace DevOps, information science, and pure language processing. She enjoys studying, writing, coding, and occasional! Presently, she’s engaged on studying and sharing her data with the developer neighborhood by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.