Everyday Tips and Tricks You Need to Know!

Nikita Prasad

Follow

11 min read

·

Jul 26, 2024

--

30

Listen

Share

Hey, Data Enthusiasts! Want to learn “WHY” and “HOW” of ML, Gen-AI, Data Science & Analytics and much more? It’s all here.

We’re almost halfway into 2024, the tech industry is moving faster than ever, due to the rise of Generative AI and Large Language Models.

Bonus: Read about the trending Technology behind Generative AI!, here.👈🏻

As a data enthusiast and python developer you should be knowing these cool tips and trick to stay relevant in todays competitive market, where lakhs of tech-people were laid off.

First thing to note here is that,

Why Python?

Python is an extremely powerful general purpose programming language, highly suitable for Data Science related tasks — utilizing it’s extensive libraries and awesome frameworks like SciKit-Learn, TensorFlow, PyTorch, etc., due to it’s easy-to-understand syntax.

This means having Python under your belt can provide you with flexibility to create large variety of applications, for example, automation tasks or building chatbots to interact with open-source LLMs, especially if you’re a beginner. As it’s quite straightforward and quick to learn as compared to other programming languages.

So, that being said let’s get into the coding, and explore,

How to write better Python codes?

I’ll be discussing 10 tips that can surely transform and elevate your coding practices.

If you find these tips helpful, do not forget to clap 👏🏻 and comment🖋️ down your thoughts!

1. Using “Generators” to Save Memory

Let’s say, you need to analyze a `large_file` that cannot fits into your RAM. To tackle this problem efficiently, you can create a `process_large_file` generator function, to read the large file line by line.

Generators not only helps in processing the large data into batches, but are also memory-efficient, as you don’t need to store the whole data in memory.

def process_large_file(file_path):
    """
    Generator function to read a large file line by line.
    """
    with open(file_path, 'r') as file:
        for line in file:
            yield line  

# Specify the path to your large file
log_file_path = 'path/to/your/large_file.txt'

# Use the generator to process the large file line by line
for line in process_large_file(log_file_path):
    print(line.strip())  # .strip() removes any extra whitespace or newline characters

The above code displays the line by line output which is written in your `large_file.txt` file.

Even Keras Framework uses generator to leverage multi-processing (to load and process data in batches) in parallel to reduce training time.

2. Using “.setdefault()” in Dictionaries

Suppose, you’re managing an inventory system, and want to keep track of stock-levels of various products. When a new product is added to the system, to ensure that it has default stock level if it hasn’t been set yet.

You can use setdefault() function to streamline this process by inserting key with a specified default value if the key is not already present in a dictionary.

# Initial inventory
inventory: dict[str, int] = {"jeans": 500, "top": 600}     
              
# Add more products with default stock levels if they are not already present
products_to_add: list[str] = ["skirt", "shirt", "tee"]

for product in products_to_add:
    inventory.setdefault(product, 500)

# Print the final updated inventory
print("Final updated inventory:", inventory)

"""
# Output:
Final updated inventory: {'jeans': 500, 'top': 600, 'skirt': 500, 'shirt': 500, 'tee': 500}
"""

This way you can avoid the need for explicit checks and assignments, making code more concise and readable.

⏸️ Quick Pause:

Read about the breakthroughs in Generative AI, Data Science, Data Analytics, and much more directly into your Inbox, Subscribe HERE👈🏻

3. Using Dictionaries to avoid “if-elif” hell

Suppose you have several functions, that you want to call depending upon the user input.

Well, the most common way of solving this problem is to use if-elif conditions, but that approach can become very long and complex, while dealing with hundreds of functions.

The alternative approach would be to create a dictionary, that contains the key — you want to check against the functions to be run as value.

from collections.abc import Callable

# Function 1 
def first():
  print("Calling First Function...")


# Function 2
def second():
  print("Calling Second Function...")


# Function 3
def third():
  print("Calling Third Function...")


# Function Default
def default():
  print("Calling Default Function...")

# User Input
options: int = int(input("Enter an option :", ))

# Dictionary to hold options as key and functions as values  
funcs_dict : dict[int, Callable[[], None]] = {1: first, 2: second, 3: third}

# Checking if the key exist and incase it doesn't then deafult function will run
final_result = funcs_dict.get(options, default)
final_result()

When you run the program, you can see the following results on your screen.

"""
# Output:
# When Option send was 0
Enter an option :0
Calling Default Function...

# When Option send was 1
Enter an option :1
Calling First Function...

# and so on...
"""

Note: If user asks for anything random, it’ll run the `default()` function.

4. Using “Counter” from Collections Module

Trust me on this, while working with the large text data, the most common task in text analysis includes identifying key terms, for which you’ll need to determine the frequency of each word in the particular document or whole corpus depending upon the problem statement.

Counter provides a simple and efficient way to count elements in an iterable, abstracting the complexity of writing custom counting logic.

Let’s implement this,

from collections import Counter
import re

# Read the text file
with open("sample_text.txt", "r") as file:
  text = file.read()

# Clean and Tokenize the text
cleaned_text: str = re.sub(r'[^\w\s]', '', text.lower().split())

# Use Counter() to count the words
word_counts: Counter = Counter(cleaned_text)

# Printing second highest most common word 
most_commmon = counter.most_common(2) # passed in Number will denotes how many common numbers we want (counting starts from 1-n)
print("Second Most Common Word is: ", most_commmon[0]) # print in zeroth index element from 2 most common ones

"""
# Output:
Second Most Common Number is: ('data', 82)
"""

Note: Additionally, you can also perform arithmetic operations, easily convert Counter object to other data structure like dictionaries, and utilize it’s useful methods like element(), most_common(), etc.

5. Using “Memoization” to Optimize Code

Memoization is a technique used in dynamic programming to improve the time complexity of recursive algorithms, by reusing the expensive function calls when the same input occur again.

The classic example of this is the Rabbit Problem, popularly known as the Fibonacci Series.

import time

def memo_fibonacci(num: int, dictionary: dict[int, int]):
    if num in dictionary:
        return dictionary[num]
    else:
        dictionary[num] = memo_fibonacci(num-1, dictionary) + memo_fibonacci(num-2, dictionary)
        return dictionary[num]

# Catching using a Dictionary
dictionary: dict[int, int] = {0: 1, 1: 1}

# Elapsed time
start_time: float = time.time()
# Calling the function
result: int = memo_fibonacci(48, dictionary)
end_time: float = time.time()
# Calculating the elapsed time
elapsed_time: float = end_time - start_time


print(f"Result: {result}") # Result: 7778742049
print(f"Elapsed time: {elapsed_time:.6f} seconds") # Elapsed time: 0.000133 seconds

Note: Certainly, this significantly reduces the time complexity. But remember that it comes with the space-time tradeoff, as you maintain a cache to store the results, that you need to take-care off.

6. Using “@decorators” to avoid Repetitiveness

Let’s say you’re building a python project and you want to time, how long a function takes to run. Surely as above, you can use time functionality for that function but what if you’ve tens or may be hundreds of functions?

It would take forever to write ‘start-time’ and ‘end-time’, instead we can create a function `elapsed_time` to do the same for us. We’ll only have to add `@elapsed_time` over the function that we want to time.

What are the `@decorators` ?

Decorators are unique python functionality that wrap round your existing function to allow you to modify or enhance functions without changing the core logic, before or after a function executes.

Python sees, the @ symbol, and understand that this function under it needs to be passed into a function called `elapsed_time`, then the function runs in `elapsed _time` with the extra lines of code wrapped round it, to time any number of functions.

import time

def elapsed_time(func):
    def wrapper():
        start_time: float = time.time()
        
        func()
        
        end_time: float = time.time() - start_time
        print(f"{func.__name__}() took {end_time:.6f} seconds")
        
    return wrapper

@elapsed_time
def some_code():
    # Simulating running code..
    time.sleep(0.00002)

# Calling the function
some_code() # some_code() took 0.000009 seconds

They’re widely used for logging, timing, enforcing access control and more.

Note: But, it is recommended to don’t over do it though, because they can also obfuscate, what you're code is actually doing.

7. Using `dataclass` for Clean Data Structures

It’s really tedious to write the __init__ method repeatedly in regular classes that’s designed to hold only the data values, due to the rise of potential errors.

However, featured in Python 3.7, the dataclasses module is a more efficient way to store data that will be passed between different parts of a program.

Notice, in just few lines we can create less error prone data classes, without the need of writing a constructor and several other already implemented method manually.

from dataclasses import dataclass

@dataclass
class Employee:
    id_: int
    name: str
    salary: float

e1 = Employee(id_=1, name='Tusk', salary=69999.99)
print(e1) # Employees(id_=1, name='Tusk', salary=69999.99)

Here, the output is also equivalent to the standard Python class implemented using __repr__.

Note: We can also, customize the representation of our Employee class:

from dataclasses import dataclass

@dataclass
class Employee:
    id_: int
    name: str
    salary: float

    def __repr__(self):
        return f"Employee(id_={self.id_}, name={self.name}, salary={self.salary})"

    def __str__(self):
       return f"{self.name} earns ${self.salary}."

e1 = Employee(id_=1, name='Tusk', salary=69999.99)
print(repr(e1))  # Employee(id_=1, name=Tusk, salary=69999.99)
print(str(e1))   # Tusk earns $69999.99.

Note:

— The __repr__ method provides an unambiguous representation of the Employee object.

— The __str__ method provides a more readable and concise description of the Employee object.

Start using dataclass if you aren’t, to reduce the boilerplate code, making your code much more readable and maintainable.

8. Using “match” for Clean Input Handling

Hot off since Python 3.10, the structural pattern matching has been added as match patterns with associated case statements.

Let’s say we have a class “Point”, that represents a point in the 2D coordinate system. Now, we’ll create a function “where_is” to handle the cases that a user inputs to find the point in the 2D plane.

A `match` statement takes an expression and compares its value to the successive patterns case block/s.

from dataclasses import dataclass

# Defining a class using dataclass
@dataclass
class Point:
    x: int
    y: int

# Match statements to handle different cases
def where_is(point):
    match point:
        case Point(x=0, y=0):
            return ("Origin")
        case Point(x=0, y=y):
            return (f"Y={y}")
        case Point(x=x, y=0):
            return (f"X={x}")
        case Point(x, y):
            return("Somewhere else")
        # To catch anything else that the user inputs
        case _:
            return("Not a point")

# Examples
print(where_is(Point(0, 0)))   # Output: Origin
print(where_is(Point(0, 10)))  # Output: Y=10
print(where_is(Point(10, 0)))  # Output: X=10
print(where_is(Point(10, 10)))  # Output: Somewhere else
print(where_is("Not a point"))  # Output: Not a point

Using match-case statements you can handle all the possible cases, ensuring exhaustive pattern matching.

9(A). Using “all” Operator instead “and”

Imagine you’re building a user profile system, and want to validate that all required fields in a form are filled out by the user (I don’t know why would you not mark *required in the form instead,🤷🏻‍♀️but let’s just concentrate here👇).

Well, you can use all function that will return True, if and only if all elements in the provided iterable are True, instead of and conditions.

# User input from a registration form 
form_data: dict[str, str] = {"name" : "Nikita", 
             "email": "analyticalnikita@gmail.com",
             "phone": "123478911"}

# List of reuired fields
required_fields: list[str] = ["name", "email", "phone"]

# Using all operator
if all(field in form_data for field in required_fields):
    print("All required fields are filled out.")
else:
    print("Some required fields are missing or empty.")

"""
# Output:
All required fields are filled out.
"""

9(B). Using “any” Operator instead “or”

The any function returns True, if any element provided in the iterable is True.

For instance, you have to restrict some permissions to certain users, based upon certain criteria for that you can use any, instead of or condition.

# List of permissions to the user
user_permission: list[str] = ["read", "execute"]

# Check if user has at least one of the required permissions
required_permissions: list[str] = ["write", "read", "admin"]
    
# Using "all" operator
if any(permission in user_permission for permission in required_permissions):
    print(f"Since you have required permissions. Access is allowed.")
else:
    print("You're a standard user. Not allowed the access.")

"""
# Output:
Since you have required permissions. Access is allowed.
"""

These are some examples that shows how any and all can be used to simplify conditions that would otherwise require multiple or or and statements, respectively.

Last but not the least, every programmer’s all-time (hey, if not yours, then stick with me to learn these😉).

10. Using the Comprehensions for Shorter Syntax

Comprehension is the powerful toolkit python provide you with for all the iterable datatypes. This gives a concise way to avoid multiple-line loops using single line, depending upon the situation.

Let’s explore them one-by-one:

10(A). List Comprehensions

Here, I’m using a nested-if statements example, to show you the power of list comprehension

# Nested-if using List Comprehension
fruits: list[str] = ["apple", "orange", "avacado", "kiwi", "banana"]
basket: list[str] = ["apple", "avacado", "apricot", "kiwi"]

[i for i in fruits if i in basket if i.startswith("a")] # ['apple', 'avacado']

Similarly, you can also apply nested-for loops, until it make your comprehension hard-to-read.

10(B). Tuple Comprehensions

As such tuple comprehensions doesn’t exist in Python. Instead you can use generator expressions to create tuples.

# Generator expression converted to a tuple
tuple(i**2 for i in range(10))

# (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)

10(C). Dictionary Comprehensions

Let say you’ve a list `apple_names` and you want to print the new list that contains the length of each elements of the list `apple_names`.

Surely, you can use list comprehension here. But do you know, you can actually use this notation to create a dictionary, it’s called, well yes, the dictionary comprehension.

# Creating a list of apple names
apple_names: list[str] = ["apple", "pineapple", "green apple"]

# Creating a dictionary with apple names as keys and their lengths as values
print({apple_name: len(apple_name) for apple_name in apple_names})

# {"apple": 5, "pineapple": 9, "green apple": 11} 

Alternatively, it’s more readable than using loops or dict constructor to create a dictionary.

10(D). Set Comprehensions

You can also use filtering based on certain conditions, in comprehensions.

# Creating a set with condition
print({i**2 for i in range(1, 11) if i > 5})

# {64, 36, 100, 49, 81}

Note: While comprehensions are expressive, this doesn’t means they’re suitable for all the cases, especially involving too complex logic.

Conclusion

Remember, you don’t write codes for computers but for the team you’re working with. So, writing better codes is really important, for others to understand your production-level codes.

Find the full scope of codes here. Star⭐ the GitHub repository.

By adopting these tips, you not only write efficient code but also boost your productivity.

Additionally, to take your coding skills to next level, understand Python Namespaces and Scopes to better Optimize Your Code, here.👈🏻

Before you go… If you have any questions/suggestions/thoughts, do drop me a line below. 🖋️

And, if you enjoy this read Clap 50 👏 times and, do not forget to follow for future updates.

👉 SUBSCRIBE to my newsletter, Epochs of Data Insights, and receive bi-weekly in-depth Data, AI & ML tips and insights, right in your inbox!

That’s it from me. Will talk soon! 🙋🏻‍♀️

— Nikita Prasad