7 Errors that are actually featured

Photo by Author | Ideogram

The data in the data and machine learning purposes has become a basic tool for many data professionals because it is easy for people to use. The language of programming has become primarily gold standard in the data community.

If you are already familiar with, you often face incorrect information whenever you produce the wrong syntax or violate the rules of Azar. This is to emphasize in the design philosophy of Azgar to emphasize that mistakes need to be clearly revealed, following the principle that it is It is easy to apologize with permission (EAFP), which allows you to process the first code before knowing whether there is an error or not.

Some of the errors are not insects, but are features that help users improve their skills. If we want to deliberately use them as a guide for our work, it is important to understand these mistakes. This article for learning purposes, this article will detect seven different errors that are features.

Let’s enter it.

1. The syntax of the syntax

The syntax error is raised when the incorrect code of syntax is encountered in the Parsar of the Azgar, which does not follow the logic of Azigar. Any false code will be shown as an error, which takes fundamental status for the design features. Let’s see the error in the code.

The aforementioned code will increase syntax error as below.

 Cell In(6), line 1
    if True print("hello")
            ^
SyntaxError: invalid syntax

The error shows that we are not following the syntax. The syntax error design is deliberately because it is a feature of an aggression that mainly indicates that any deviation from quality needs to be determined. It will not run a code that does not follow the language grammar and does not try to guess what we want to do.

The syntax error ensures that we always have a clear and unclear code. It also helps with mutual cooperation, because regardless of where you play the language of Azgar, the quality remains permanent.

2. Index error

Everyone who uses uses is many times when we use our work -sequitative items such as lists or tuppy. We will need to use indexing methods to access data within these continuity objects.

Well, what happens when we access with the index out of the limit? Ezar will throw a message of error. Let’s see what happens using the original code.

lst = (1, 2, 3)
print(lst(5))

The aforementioned code will throw the following error:

IndexError                                Traceback (most recent call last)
Cell In(2), line 2
      1 lst = (1, 2, 3)
----> 2 print(lst(5))

IndexError: list index out of range

The error is shown as an index error, which informs you that the index is out of range. The error is deliberately, as it shows that the silent recruitment does not allow (a case where out -of -data access automatically enhances the structure with the values ​​of the place holder).

If this was to happen, behavior introduces precise worms that cause more problems in the more complex pipeline. For example, when the index is beyond the limit, the loop will break the loop in the order of Azar, which does not contain any mistakes of the index.

3. Key error

As we know, the keys to the values ​​stored within the dictionary object make maps. Like the index error, an important error for the dictionary object occurs when the search fails because the key is not present in the dictionary. Let’s see how it works in Azigar’s code.

d = {'a': 1}
print(d('b'))

The above code will increase the following error:

KeyError                                  Traceback (most recent call last)
Cell In(3), line 2
      1 d = {'a': 1}
----> 2 print(d('b'))

KeyError: 'b'

The key error has been raised because no ‘B’ is in a key dictionary. It is through the design that Azigar clearly raises this error, why we do not want to use the values ​​of the placeholder for the key to the key.

Using this key error, we can estimate whether the key is available, rather than guessing any syntax or logic errors while accessing the dictionary. Error is also useful when trying/except Santics to create a new key in the dictionary. If it does not exist.

4. Name error

The name error is a mistake that happens when we say a variable that has not been explained before. There is a similar case that is called a Bound Local error, a sub -class of the name error, where we have a fun function that tries to access the local variable before praising it. Let’s see the error in the code below.

The error is shown in the output.

NameError                                 Traceback (most recent call last)
Cell In(5), line 1
----> 1 print(x)

NameError: name 'x' is not defined

The code increases an error because we have not yet explained the ‘X’ variable. Let’s see the code for non -bound local error.

def foo():
    x = x + 1  

foo()

The error is shown in the output.

Cell In(4), line 2, in foo()
      1 def foo():
----> 2     x = x + 1

UnboundLocalError: cannot access local variable 'x' where it is not associated with a value

Both errors were made here because we need to follow the Scoping Rule of the Azgar, which states that we cannot use mistaken variables that are not yet present. Error users allow immediately to catch typos or insects, rather than create a quiet variable that will disturb our work.

5. Type of error

The type of error is a mistake that is raised when we perform a special operation on an item but with the wrong object type. Let’s show the type of error with the codes below.

The error has been picked up as shown in the output below.

TypeError                                 Traceback (most recent call last)
Cell In(7), line 1
----> 1 next((1, 2, 3))

TypeError: 'list' object is not an iterator

The kind of error is because we cannot transmit a repetitive object in the next function.

Azgar is designed to use items only in his desired methods. That is why, this error helps consumers to prevent precise worms and ensures that the function works according to purpose.

6. The value of the value

Unlike the type of error, if the function gets the right type of argument but an inappropriate value is found, the value error is increased. Let’s show it with a codes.

The error is shown in the results below.

ValueError                                Traceback (most recent call last)
Cell In(8), line 1
----> 1 int("abc")

ValueError: invalid literal for int() with base 10: 'abc'

You can see that the value of the value is because we pass a string value which is not a valid number. The function gets the right type but not a reasonable price, so the gesture indicates that this is a mistake. This is the design of Azigar, which shows that the error is being done instead of neglecting it or putting the price of a place holder, as it will bother our work.

7.

When a claim statement is used and the condition is not met or wrong, a claim is wrong. This is a feature that is useful for debugging and implementing any assumptions in your work. Let’s see the error with the codes below.

assert 2 + 2 == 5, "It's not right"

You will find the following error.

AssertionError                            Traceback (most recent call last)
Cell In(13), line 1
----> 1 assert 2 + 2 == 5, "It's not right"

AssertionError: It's not right

Code 2 + 2 == 5 When we use the claim statement, a wrong price arises, which makes the claim error. When you look up, we can always add details about the error.

Claim error helps users provide flexibility in development, as we can set up a failure catching system that allows it to be easily debugged. By choosing the terms under which the claim error is lifted, we take more control over how the error should be treated.

Conclusion

Many data professionals use agglore. The language of programming sometimes gives rise to mistakes that are really featured, and so we have to keep our eyes open and inspect our tracebackstack.

I hope it has helped!

Cornelius Yodha Vijaya Data Science is Assistant Manager and Data Writer. Elijan, working in Indonesia for a full time, likes to share indicators of data and data through social media and written media. CorneLius writes on various types of AI and machine learning titles.