# What should you absolutely never do when using Python?

In this article, we will learn what should never do when working with Python.

## Use Class Variables Carefully

In Python, class variables are used as dictionaries and are referred to as Method Resolution Order (MRO). Furthermore, if a class lacks one attribute, then that class lacks a property. That is, if you modify what is in a class, other classes should not change as well.

## Improper Indentation

In Python, indentation is everything. Python utilizes indentation online, unlike Java, C++, and other programming languages, which use curly brackets to construct code blocks. Many properties are affected by indentation. Some Python indentation problems are more difficult to detect than others. As a result, because many Python features rely on indentation, one should always maintain a consistent indentation style. Thus, in Python, indentation is quite crucial.

It is preferable to give 4 spaces or a tab for indentation.

## Case sensitiveness

Python is Case sensitive. This signifies that the variables "number" and "Number" are distinct. And because this is one of the most typical mistakes that Python newbies make.

### Example

number = 5
print(Number)


### Output

Traceback (most recent call last):
File "main.py", line 2, in
print(Number)
NameError: name 'Number' is not defined


## Modifying And Iterating a List

Too frequently, software engineers commit the common error of deleting an item from a list while iterating over it. However, Python uses unique programming paradigms to overcome this.

When utilized correctly, paradigms can simplify and then streamline the code, ensuring that no important item is accidentally deleted and iterated.

## Variable Binding

This is a topic that learners struggle to grasp and appreciate. Python supports late binding. Python developers are frequently perplexed about how Python binds variables. It binds its variable's enclosures or in the surrounding global scope, so the values of variables used in closures are looked up when the inner function is called.

## Misusing “_ _ del _ _”

The “_ _ del _ _” method can only be used in certain circumstances and not all of the time. Otherwise, an "AttributeError" exception will be thrown. When the command “_ _ del _ _” is called, a name in the code is set to "None." Instead, use "atexit.register()" to start registered handlers before closing the interpreter.

## Misusing __init__

Constructors are represented in Python by a function called __init__. When an object is formed, the __init__ method is called, which allocates memory and initializes the class's attributes. Attempting to explicitly return a value from the init method can thus generate several errors and cause difficulties in the code.

## Function Calls with Default Arguments

For beginners, functions with default arguments are a fantastic feature in Python. Arguments are difficult to utilize. Because Python evaluates the expression in default arguments every time a function is declared, you must generate default arguments dynamically. As a result, one must take care of this.

## Misusing Expressions

In Python, you may make a function parameter optional by assigning it a default value. However, when you mute the default value, this behavior can be perplexing.

To prevent using expressions incorrectly, provide a proper value for the optional argument because the default value for a function argument is only considered once- once the function is declared.

## Name Clashing

Python has a wide range of library modules, so it's not shocking that it has a lot to offer software developers. However, if you opt to avoid such wealth, you risk having a name clash. Clashing occurs when the name of one of your modules gets confused with a module having the same name in Python's standard library.

As a result, you may import another library, which may interfere with your standard library version of a module. As a result, avoid choosing names that are similar to those in the Python standard library modules. We can always request a name change by filing a Python Enhancement Proposal (PEP).

## Creating Circular Module Dependencies

Because Python understands not to re-import something, having circular module dependencies may appear safe at first. However, you may get an AttributeError exception at some point, which is undesirable. What is the solution? Change a module with a ().

## Not using Comments and Doc Strings

Comments are an essential component of programming. Comments improve the readability and self-explanation of code. What happens if you don't utilize comments or docstrings? It can be terrifying! Code can quickly grow from 10 lines to 10,000 lines, making debugging difficult. Thus, using comments and docstrings can be really beneficial.

Making mistakes is a natural aspect of both life and programming. And mistakes can happen, but knowing what mistakes can happen and how to fix them is critical.

## Not Specifying Parameters Correctly

"As one might expect, the except statement does not take into account the list of exceptions," argues Rory Barak, a tech blogger. "Instead, the syntax exception connects the exceptions to the specified optional second parameter." Following that, the 'IndexError' exception is not detected by the except statement and is not correctly given as a parameter."

"One option is to define the first parameter as a tuple including all necessary exceptions while utilizing the keyword 'the'.

## Conclusion

By avoiding these typical Python blunders, you can ensure that your code not only makes logical but also works in the long run. Always double-check your coding and correct anything that appears to be incorrect. The last thing you want is to end up with code riddled with errors.