Forem: Halc

Simplify Your Python Code with Clean Code Best Practices

Halc — Thu, 31 Jul 2025 01:45:42 +0000

When writing code, there are often many ways to do the same thing—but some ways are cleaner, simpler, and easier to understand than others. In this post, I’ll show you simple tips to write cleaner Python code, following some key clean code principles. The goal? Write Python that's easier to read, maintain, and reuse.

Let's dive in! 👇

✅ Use Ternary Operators

A ternary operator is a compact way to write if-else statements in a single line. This can be useful for simple decisions like checking if someone is an adult.

Instead of:


def is_adult(age):
    if age > 18:
        return True
    else:
        return False

You can write:


def is_adult(age):
    return True if age > 18 else False

But there's more! Since age > 18 already returns a Boolean (True or False), you can simplify it even further:


def is_adult(age):
    return age > 18

That’s clean, readable, and Pythonic! ✅

🔁 Use List Comprehensions Instead of Loops

List comprehensions are a cleaner way to create lists without using verbose loops.

Instead of:


squares = []
for i in range(10):
    squares.append(i * i)

Use:


squares = [i * i for i in range(10)]
It’s shorter, more readable, and avoids unnecessary lines.

❓ Use Meaningful Function and Variable Names

Your code should be self-explanatory. Avoid vague names like x, do_thing, or data1.

Bad:


def d(a):
    return a > 18

Good:


def is_adult(age):
    return age > 18

Meaningful names improve understanding without needing extra comments.

🙅‍♂️ Avoid Unnecessary else After return

If you return in an if, there's no need for an else.

Instead of:


def is_positive(n):
    if n > 0:
        return True
    else:
        return False

Just write:


def is_positive(n):
    return n > 0

Cleaner, right?

🧹 Remove Redundant return None

In Python, functions return None by default if there’s no return statement. Don’t write what’s already implicit.

Instead of:


def log_message(msg):
    print(msg)
    return None

Use:


def log_message(msg):
    print(msg)

📛 Use enumerate() Instead of Manual Indexing

Avoid using range(len(...)) when iterating through a list and needing the index.

Instead of:


for i in range(len(fruits)):
    print(i, fruits[i])

Use:

for i, fruit in enumerate(fruits):
    print(i, fruit)

✂️ Use join() Instead of Loops to Build Strings

Concatenating strings in a loop is inefficient and messy.

Instead of:


words = ['clean', 'code', 'rocks']
sentence = ''
for w in words:
    sentence += w + ' '

Use:


sentence = ' '.join(words)

⏪ Use Tuple Unpacking for Swapping Values

Swapping variables without a temp variable is a Python classic.

Instead of:


temp = a
a = b
b = temp

Use:

a, b = b, a

Shorter and instantly understandable.

📦 Bonus: Use Python's Built-in Functions

Python gives you powerful built-in tools. Don’t reinvent the wheel.

Example:


# Check if any number is negative
numbers = [1, 3, -2, 5]

if any(n < 0 for n in numbers):
    print("There's a negative number!")

Functions like any(), all(), sum(), map(), and filter() can help you write more elegant code.

Final Thoughts

Clean code is not about writing fewer lines, it's about writing better lines. Python is already expressive, so lean into that by simplifying logic, naming things clearly, and using the language's powerful features.

Choosing the Best Iteration Technique for Optimized Python Code

Halc — Fri, 14 Apr 2023 16:22:14 +0000

This article was originally created in Medium, check it here.

Python is a versatile language with multiple options to accomplish tasks. One of the most frequent tasks in programming is iterating through a collection of elements, and Python provides three popular ways to do this: using for loops, list comprehensions, and high-order functions. As Python developers, selecting the best method to guarantee best practices and optimal performance in our code is essential.

To compare the performance of these methods and discuss when to use each, we will explain the experiment in this article. So, let’s get started!
Experiment

To measure the performance of each process, we used the time library and the perf_counter() function. If you want to learn more about this function, you can check out the following link.

To ensure accurate results, we allocated four processor threads and 1GB of memory to the process using a container. Python will manage the jobs using the processor threads by default.

We chose a simple mathematical task of generating multiples to conduct our experiment. We ran the process 100 times, each time generating a different number of multiples of 2. For instance, if we generated the first 100 multiples of 2, the resulting sequence would be:

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198]

In the following results, we ran each process 10,000, 100,000, and 1,000,000 times, respectively. We executed each process separately to ensure accurate results and prevent memory overload that could interfere with the measurements.

We ran the process 102 times, removing the lowest and highest values to eliminate any results affected by system performance. Finally, we determined the minimum and maximum values for each step and calculated the mean of all values.

For loop

The for loop is a basic construct in Python for iterating over a sequence of elements. It has been around since the beginning of the language and is still widely used today. A for loop allows us to act on each element in a sequence one at a time. Here’s an example:

import time

def for_loop(rang: int, decimals: int) -> float:
    start_time_for_loop = time.perf_counter()
    my_list_for_loop = []
    n = 2
    for i in range(rang):
        n = i * n
        my_list_for_loop.append(n)
    return round(time.perf_counter() - start_time_for_loop, decimals)

For loops are easy to read and understand and great for simple iterations. However, for larger sequences, the performance of for loops can degrade due to the overhead of the loop construct.

List Comprehension

List comprehensions are a concise way of creating lists in Python. They are a syntactic shortcut for writing a for loop to create a list. Here’s an example:

import time


def comprehension_loop(rang: int, decimals: int) -> float:
    start_time_comprehension_loop = time.perf_counter()
    n = 2
    my_list_comprehension_loop = [n * i for i in range(rang)]
    return round(time.perf_counter() - start_time_comprehension_loop, decimals)

List comprehensions are generally faster than for loops for creating lists because they do not require the overhead of the loop construct. They are also more concise and easier to read than for loops, making them a great choice for simple iterations.

High-Order Functions

Python has several built-in high-order functions, including map, filter, and reduce. These functions take a function as an argument and apply it to every element in a sequence. Here’s an example using map:


import time


def high_order_func(rang: int, decimals: int) -> float:
    start_time_high_order_func = time.perf_counter()
    n = 2
    my_list_high_order_func = list(map(lambda i: i * n, range(rang)))

High-order functions can be faster than for loops and list comprehensions for complex operations because they are optimized for performance. They are also more concise and easier to read than for loops for complex operations, making them a great choice for complex iterations.

Results

Below are the results of the 100 tests in a range of 10,000 iterations. As seen in the graphs, we may encounter occasional peaks corresponding to longer processing times, which can be attributed to processor load caused by background processes. However, for the most part, the processing time remains relatively consistent with minimal variation.

CSV File	Mean	Min	Max
For loop	1.34	0.79	1.8
Comprehension list	0.91	0.7	1.3
Higher order functions	1.617	1.0	2.58

We can now begin to see how the tests will evolve based on the results of the following 100 tests, which were conducted over 100,000 iterations. As expected, the higher-order functions are starting to fall slightly behind the other two functions.

CSV File	Mean	Min	Max
For loop	12.66	10.25	14.23
Comprehension list	9.53	7.9	11.7
Higher order functions	15.59	13.26	17.87

However, there is still no clear difference between the three functions, and the execution times remain in the same range as the previous tests. This suggests that there may not be a significant performance advantage to using higher-order functions in this scenario.

Overall, these results provide valuable insights into the performance characteristics of the different functions. Further experimentation will be necessary to determine whether the observed trends hold up over larger datasets and longer execution times.

CSV File	Mean	Min	Max
For loop	103.61	98.1	130.59
Comprehension list	89.92	68.8	128.9
Higher order functions	141.2	133.86	172.17

The final test clearly shows a significant difference in performance between the three functions. Specifically, the higher-order functions perform much more slowly than the other two. This result provides us with a much clearer conclusion.

Discussion

When to use each

for loops are great for simple iterations over small sequences. They are easy to read and understand and do not require specialized knowledge.
List comprehensions are great for creating lists and performing simple operations on sequences. They are more concise than for loops and easier to read, making them an excellent choice for simple iterations.
High-order functions are efficient and faster than for loops and list comprehensions in complex sequence operations. They are also more concise and easier to read, making them suitable for elegant and efficient code.

Conclusion

In conclusion, the test results show that high-order functions are not as efficient and fast in simple operations on sequences. However, loops and list comprehensions are better options in these cases and are easier to read and understand. Therefore, it is essential to consider the complexity of the task before choosing an iteration technique. In summary, loops are good for simple iterations and small sequences, list comprehensions are ideal for creating simple lists and operations, while high-order functions are efficient and better suited for complex operations on large sequences.

For Loop VS List comprehension VS High order functions

Halc — Thu, 03 Mar 2022 14:59:37 +0000

Studying again the basic concepts of Python, a question that had always arisen came back to me, what is the difference in performance of each of the Loop options that we have within the language? (For Loop, List comprehension and High order functions), for this I had to understand how each one worked inside and find the best way to measure them, this is the reason why I began to investigate and test.

However, first I would like to explain what was the experiment that I carried out and how I came to think that this would be the best option.

Experiment

The experiment consisted of performing three functions in order to monitor the performance and not the process carried out by each of the iterables. At the beginning, a person from the community told me that the psutil module could help me by measuring the performance; however, this tool allows me to measure a complete process and it was very difficult and time-consuming to measure each of the functions separately, additionally we had a small detail and that is that these tests could not be done on large servers with a capacity of RAM and processors multicore, my machine was just a Macbook with 8 Gb of ram and a dual-core I5 core, a joke if we start to see the types of machines we have today.

With this in mind I decided to go for a basic mathematical iterative process that would start consuming enough resources that not too many processes would stall without affecting upcoming loops.

The solution was to iterate x number of times a number that was multiplied by the previous sequence and store everything in a list, something similar to fibonacci, but with much higher values provided that the list began to be much larger.

Hoping that the garbage collector would remove the variables in each iteration, I used the same names in all the calls and only changed the process, the code was as follows.

Code

def high_order_func(rang):
    start_time = time.time()
    n = 2
    my_list = map(lambda i: i * n, range(rang))
    my_list = list(my_list)
    end_time = time.time()

    how_much_time = end_time - start_time
    return how_much_time

def comprehension_loop(rang):
    start_time = time.time()
    n = 2
    my_list = [n * i for i in range(rang)]
    end_time = time.time()

    how_much_time = end_time - start_time
    return how_much_time

def loop(rang):
    start_time = time.time()
    my_list = []
    n = 2
    for i in range(rang):
        n = i * n
        my_list.append(n)
    end_time = time.time()

    how_much_time = end_time - start_time
    return how_much_time

if __name__ == '__main__':
    import time
    rang = 1000
    high_order_func = high_order_func(rang)
    comprehension_loop = comprehension_loop(rang)
    loop = loop(rang)

    print("loop ", str(loop), " sec")
    print("list comprehension ", str(comprehension_loop), " sec")
    print("Higher order funciton ", str(high_order_func), " sec")

Results

Each outcome is separated by its respective value of the rang variable and before you read on I would like you to try to guess which one is going to win and try to explain why you think this will happen.

Initially, it was tested with a small rang in order to see in small processes what the real difference was.

rang = 1000

Test 1

loop  0.009955167770385742  sec
list comprehension  0.02051258087158203  sec
Higher order funciton  8.821487426757812e-06  sec

Test 2

loop  8.0108642578125e-05  sec
list comprehension  5.507469177246094e-05  sec
Higher order funciton  0.0001220703125  sec

Test 3

loop  8.082389831542969e-05  sec
list comprehension  5.507469177246094e-05  sec
Higher order funciton  0.00012302398681640625  sec

At this point we can see that there is no clear difference between the three functions, let us remember that these values do not even take milliseconds yet, since at the end as you can see they have the scientific notation e-05 or e-06 which tries to say that they are They add that amount of zeros to the value at the beginning, so we can say that there is no winner since the values have a clear fluctuation of times but do not exceed e-05.

rang = 100000

Test 1

loop  0.008324146270751953  sec
list comprehension  0.007503986358642578  sec
Higher order funciton  0.012623071670532227  sec

Test 2

loop  0.009238958358764648  sec
list comprehension  0.007218837738037109  sec
Higher order funciton  0.015091180801391602  sec

Test 3

loop  0.00857686996459961  sec
list comprehension  0.007061004638671875  sec
Higher order funciton  0.013355016708374023  sec

This Output gives us an overview of how the tests are going to evolve from now on, since it shows us that the higher-order functions begin to slowly fall behind, however the other two remain quite similar in execution times.

rang = 100000000

Finally, the definitive test, since if I continued to increase the rang the machine began to throttle, which affected the tests beyond giving me a more realistic result than the one I was looking for.

Test 1

lloop  9.187693119049072  sec
list comprehension  9.024915933609009  sec
Higher order funciton  14.004309892654419  sec

Test 2

loop  9.79594111442566  sec
list comprehension  9.057484865188599  sec
Higher order funciton  15.923699855804443  sec

Test 3

loop  8.725109577178955  sec
list comprehension  8.681398868560791  sec
Higher order funciton  14.65591287612915  sec

In this last test we have a fairly clear difference and two winners that are close to being quite tied, since the higher order functions lagged far behind compared to the other two, but what happened here? What could have happened?

Conclusión

These results surprised me more than I expected, as at one point I thought I was doing double processing with these functions, however reading a bit of the [real python] article(https://realpython.com/python-map-function/) I understood that the map iterates over the first element creating an object with those values, but when passing it to the list it has to do a bigger process by operating all those bytes again, therefore, it makes them more expensive.

What do you think? Tell me in the comments your opinion about it, if this test seemed reliable or you think I had to take it from another point of view or something in my test is wrong.

I also invite you to read the following articles that allows you to understand some more things about loops.

List-comprehension: https://realpython.com/list-comprehension-python/
For Loops: https://realpython.com/python-for-loop/

XPATH for Scraping

Halc — Wed, 07 Apr 2021 01:49:02 +0000

Xpath use path syntax to search parts of a XML document but as well allows you to find data identifying matches in an HTML file, if I compares with something similar are regular expressions but in trees later you will understand, in this case we will learn how to search data in a Webpage or scrap any web page with this syntax from scratch.

Before starts, is important you learn something about web scraping, you can't scrap all web pages because all web pages have a rules (Legal reules for bots), almost all web pages need be scraped, as you imagine Google is a king of scraping, web scrapin is only one of the tools they use in their big algorithm.

Now ¿How can I recognice which rules have a webpages?
All web pages need to have a robots.txt file in their root directory, if you don't believe me try search after any URL the robots.txt, some examples:

Basically the robots.txt provides some rules to any bot which parts of your page are accesible and which will be disabled.

If you want learn more about how can you create a robots.txt you can see it in this Google tutorial.

NOTE

This tutorial search teach you or gives you a simple guide of basic web scraping with a global syntax no matter if you codes in python, javascript or any programing language.

Now, let's start!

In your browser is possible use Xpath inside the console using this expression.

$x('')

This expression allows you to start Xpath and start a HTML tree search, in this case we will be do inside the Web page.

Quotes to scrape Link

It is possible to see the tree structure of this page by viewing its HTML source code in the F12 browser console.

With the following it will return the information of the div with class = "container"

Now try

$x('/html/body/div')

Calling the tree in this way will be limited to bringing the information it finds and if we want to reach the branch that is class =" quote " we could arrive in this way.

$x('/html/body/div/div/div/div')

However, it will be unreliable and on many occasions it is very difficult to reach some of the children of the trees.

It is for this reason that we will begin to create filters to make sure what we are looking for what we want, we will start filtering by classes.

It is possible to filter the classes of each of the HTML tags that exist in the web page.

$ x ('//div[class = "container"]')

If you compare the expression with the previous ones you will notice that it has many changes, initially // that allows us skip all elements to be able to reach a specific tag in HTML in this case a div later with the squares brackets [] we can select a property of the tag either a class, an id, a src or any other by referencing it with an @ e.g. [@class], [@href], [@id]

$ x ('//div[@class="quote"]')

In the previous script we can identify that we arrive in a few words at the div tags with class quote, now we reduce it to a few words but we can be even more specific.

$ x ('//div[@class="quote"]/..')

The previous expression allows to bring the parent of a tag.

$ x ('/html/body/div/self::div')
$ x ('/html/body/div/.')

These two expressions allow to bring the current node, the . is only syntactic sugar or a way to simplify the self::<tag> this expresion refers to the axes later i will talk about it

Wildcards

There are some wildcards that we can use to indicate that we want any object in which we know its position but we do not know.

$x('/*')

With an asterisk (*) we can bring nodes of which we know their name but their position, in this case we will bring the HTML tag but without their nodes.

$x('//*')

Using the double slash as in the previous example, we are going to tell Xpath that we want all the nodes and it will bring us an array with the requested nodes.

$x('//span[@class="text"]/@*')

In this example it is possible to see something new at the end of the line, the first thing is that it is possible to call attributes outside the '[]' and with * you can bring all the attributes that have the text class spans.

Other examples can be

$x('/html/body//div/@*')

Let us now compare the following expressions.

$x('//span[@class="text"and@itemprop="text"] / node ()')
$x('//span[@class="text" and @itemprop="text"]/*')

The * is not going to help us if the node we are consulting does not have child nodes, however the expression node () identifies not only the child nodes that the queried node has but also everything that is not nodes.

$x('//small[@class="author" and starts-with(., "A")] / text()').map(x => x.wholeText)
$x('//small[@class="author" and contains(., "Ro")]/text ()').map(x => x.wholeText)

# The ends-with and matches expression only works with Xpath versions 2.0 of XPATH,
# current browsers only support up to version 1.1
$x('//small[@class="author" and ends-with(., "t")]/text ()').map(x => x.wholeText)
$x('//small[@class="author" and matches(., "A.*n")] / text ()'). map (x => x.wholeText)

AXES

The axes allow the nodes to be obtained in all directions, from the child that has this node, the ansesters that follow, even bringing both the ansesters as the node itself and the parents.

$x('/html/body/div/self::div')
$x('/html/body/div/child::div')
$x('/html/body/div/descendant::div')
$x('/html/body/div/descendant-or-self::div')

Challenge

From the WebPage http://books.toscrape.com/ obtain the titles and preciousness of each book, and within one of the books obtain the categories and their descriptions and if it is in stock, in the next chapter we will obtain the information with a script of all these books with Python.

Morse code in Raspberry PI

Halc — Sun, 16 Aug 2020 02:41:18 +0000

Morse code in Raspberry PI

I know this isn't the most awesome project in the RPI history, but this project is targeted for all the people how wants to start using their RPI in programming electronic components from scratch easily with their favorite language, you can transcript this project to another programming language but here we will use Python as a comfortable option some samples for the controllers GPIO for RPIO in the elinux wiki:

https://elinux.org/RPi_GPIO_Code_Samples

What you will need?

A Raspberry Pi with SD card and peripherals or ssh/serial connection(optional).
A led.
A protoboard.
220Ω Resistor.

Before anything, if you don't know what is morse code I will simplify the explanation as an encoded language used for the military forces principally to communicate messages for the aliases in the war.

A little example of a "hello world" in morse code.

For more info and the table with the letters and numbers encoded look this post in wikipedia.

Morse code is a telecommunications method which encodes text characters as standardized sequences of two different signal durations, called dots and dashes, or dits and dahs. Morse code is named after Samuel Morse, one of several developers of the code system. Morse's preliminary proposal for a telegraph code was replaced by an alphabet-based code developed by Alfred Vail, the engineer working with Morse; it was Vail's version that was used for commercial telegraphy in North America. Friedrich Gerke was another substantial developer; he simplified Vail's code to produce the code adopted in Europe, and most of the alphabetic part of the current international (ITU) "Morse" is copied from Gerke's revision.

View on Wikipedia>

First of all, we will prepare our RPI connection,

I prefer use my RPI connected via SSH or serial AND USE the neo vim editor in my shell, this is optional you can connect an HDMI and a keyboard but if you prefer this option like me, for the SSH connection you can see this post from RPI blog, or see this guide for the Serial connection.

After that we will set our cables, you can copy this schema.

in my case I used an RPI 4B but you can copy this connection in an RPI 3 or search the same configuration in another model with the following schema.

Now we will register those points and lines as a morse dictionary like this:

After that we will create another python file, call it as you prefer, in my case, I will call it main.py, and the first lines have the import of two libraries, the first is so important.

import RPi.GPIO as GPIO
import time

RPI.GPIO is the controller of the pins of the Raspberry Pi.
time is a controller to keep our LED in the state on or off.
Now we will import the dictionary from the morse conventions.py file:

from morse_coded_letters import letters

Now set the pin number that will send the signal to the led.

PIN = 7

GPIO.setmode(GPIO.BOARD)
GPIO.setup(PIN, GPIO.OUT)

The GPIO.setmode allow us to call the pins in Board mode, you can set this in BCM mode (Basically a code for each pin) or board mode (basically a number for each pin), please see more information in the following URL.

Note: if you follow the schema and prefer use the mode BSM change the pin constant for the number 4 if you follow the above schema.

word = str(input("Write a word: "))
word = list(word.upper())

After that, we will get a word and transform it into a list of characters.

def led_control(time_sleep):
    GPIO.output(PIN, GPIO.HIGH)
    time.sleep(time_sleep)
    GPIO.output(PIN, GPIO.LOW)
    time.sleep(0.5)

We will define a function to handle our led and the time and it will receive a number, this will be a time in seconds that the led will wait ON.

for letter in word:
    time.sleep(2)
    bin_letter = letters[letter]
    print(bin_letter)
    for codes in bin_letter:
        if codes == "-":
            led_control(0.5)
        elif codes == ".":
            led_control(0.2)
        elif codes == "/":
            time.sleep(1)

Now, this is the core function of our microprogram.

First of all, browse all positions in our list word then search the letter in the dictionary and identify the binary convention, for each ´-´ the led will keep ON 0.5 sec's and 0.2 sec's for each point´.´.
**NOTE: We will handle the space with a ´/´.

GPIO.cleanup()

Finally, close the connection with cleanup for turn OFF the led.

NOTE: If you prefer a binary code e.g. For a P you can see a code like this • - - • but translated to binary you can see this code 0 1 1 0.

- = 1
• = 0

If you understand this convention we can create a python file called morse_binary_conventions.py with the dictionary with all conventions.
For more examples see this gist

https://gist.github.com/halcolo/eafa6b8574bfda953bcc307fbe33060c#file-morse_binary_conventions-py
and you have the code for the handler:
https://gist.github.com/halcolo/eafa6b8574bfda953bcc307fbe33060c#file-morse_code_binary_handler-py

If you want see the complete source code see my GIST in Github.

Forem: Halc

Simplify Your Python Code with Clean Code Best Practices

✅ Use Ternary Operators

🔁 Use List Comprehensions Instead of Loops

❓ Use Meaningful Function and Variable Names

🙅‍♂️ Avoid Unnecessary else After return

🧹 Remove Redundant return None

📛 Use enumerate() Instead of Manual Indexing

✂️ Use join() Instead of Loops to Build Strings

⏪ Use Tuple Unpacking for Swapping Values

📦 Bonus: Use Python's Built-in Functions

Final Thoughts

Choosing the Best Iteration Technique for Optimized Python Code

For loop

List Comprehension

High-Order Functions

Results

Discussion

Conclusion

For Loop VS List comprehension VS High order functions

Experiment

Code

Results

rang = 1000

rang = 100000

rang = 100000000

Conclusión

XPATH for Scraping

NOTE

Now, let's start!

Wildcards

AXES

Challenge

Other links.

Morse code in Raspberry PI

Morse code in Raspberry PI