Follow PEP 8 style guide: PEP 8 is the official style guide for Python code. Following PEP 8 can make your code more readable and easier to maintain.
def calculate_area(radius):
"""
Calculates the area of a circle with given radius.
"""
return 3.14 * radius ** 2
def calculateArea(r):
return 3.14 * r ** 2
Use descriptive names: Use descriptive and meaningful names for variables, functions, classes, and modules. This makes your code more understandable to others.
def calculate_salary(employee):
"""
Calculates the salary for the given employee.
"""
hourly_rate = employee.hourly_rate
hours_worked = employee.hours_worked
salary = hourly_rate * hours_worked
return salary
def calc(employee):
hr = employee.hr
hw = employee.hw
sal = hr * hw
return sal
Write docstrings: Write docstrings for all functions, classes, and modules. Docstrings describe what the code does and how to use it.
def find_largest_number(numbers):
"""
Returns the largest number from a list of numbers.
Args:
numbers: list of integers
Returns:
largest number in the list
"""
return max(numbers)
def largest(numbers):
return max(numbers)
Avoid global variables: Avoid using global variables as they can cause unexpected behaviour and make your code harder to understand and test.
def calculate_tax(amount):
tax_rate = 0.10
tax = amount * tax_rate
return tax
tax_rate = 0.10
def calculate_tax(amount):
tax = amount * tax_rate
return tax
Use list comprehensions: Use list comprehensions instead of loops to create lists. List comprehensions are more concise and readable.
numbers = [1, 2, 3, 4, 5]
squares = [num ** 2 for num in numbers]
numbers = [1, 2, 3, 4, 5]
squares = []
for num in numbers:
squares.append(num ** 2)
Use context managers: Use context managers to properly manage resources such as files, sockets, and database connections.
with open('file.txt', 'r') as f:
data = f.read()
f = open('file.txt', 'r')
data = f.read()
f.close()
Avoid unnecessary complexity: Keep your code simple and easy to understand. Avoid unnecessary complexity and don't over-engineer solutions.
def calculate_average(numbers):
return sum(numbers) / len(numbers)
def calculate_average(numbers):
total = 0
for num in numbers:
total += num
average = total / len(numbers)
return average
Write unit tests: Write unit tests for your code to ensure that it works as expected and to catch any bugs or errors early.
def test_calculate_area():
assert calculate_area(5) == 78.5
assert calculate_area(0) == 0
assert calculate_area(-5) == 78.5
def calculate_area(radius):
return 3.14 * radius ** 2
Use virtual environments: Use virtual environments to isolate your Python environment and avoid dependency conflicts.
$ python3 -m venv venv
$ source venv/bin/activate
(myenv) $ pip install requests
$ pip install requests
Optimize code: Optimize your code for speed and efficiency. This includes using built-in functions and libraries, avoiding unnecessary computation, and using appropriate data structures.
def sum_squares(numbers):
return sum(num**2 for num in numbers)
def sum_squares(numbers):
squares = [num**2 for num in numbers]
return sum(squares)
In the above example, the good code uses a generator expression to compute the squares of the numbers and sum them up in a single step, while the bad code first creates a list of squares and then sums them up. The good code is more efficient as it avoids creating an unnecessary list in memory.
