Which of the following is a semantic error?

The problem with semantic errors in Python is that the program you wrote is not the program you wanted to write. The meaning of the program (its semantics) is wrong. Identifying semantic errors can be tricky because it requires you to work backward by looking at the output of the program and trying to figure out what it is doing.

Why Semantic Errors are Hard to Identify

- String concatenation instead of arithmetic addition
```
num1 = input('Enter a number:')
num2 = input('Enter another number:')
sum = num1+num2
print('The sum of', num1, 'and', num2, 'is', sum)
```
This program runs and produces a result, but it is not the result intended. This is because the program contains a semantic (logic) error. The error is that the program performs string concatenation instead of integer addition. To solve this, the program must perform the necessary integer conversions before calculating the sum.

Fix:
```
sum = int(num1)+int(num2)
```

- Order of operations
```
x = int(input('Enter a number'))
y = float(input('Enter a number'))
z = x+y/2
print('Average:', z)
```
This program runs and produces a result, but it is not the result intended. This is because the program contains an error in arithmetic order of operations. 

Fix: 
```
z = (x+y)/2
```

Common Semantic Errors

A semantic error, also known as a logic error, occurs when a program runs successfully without any errors, but the outcome of the code is not what the programmer had intended. 

University of Michigan - Ann Arbor

- Syntax Errors
- Semantic Errors
- Runtime Errors

Error Types

https://runestone.academy/runestone/books/published/fopp/index.html

Runestone: Foundations of Python Programming

A violation of Python syntax that causes a program to fail. A syntax error means that the code does not follow the correct structure and rules of the language.

Syntax Errors

Semantic Errors

Runtime errors occur when the syntax of a program is correct, but a statement within the program prevents the interpreter from executing the code. These are also known as exceptions. For example, dividing by zero, performing type conversions on values that can not be converted, or performing operations on the wrong data type will all lead to runtime errors.

Runtime Errors

In Python, all exceptions must be instances of a class that derives from BaseException. In a try statement with an except clause that mentions a particular class, that clause also handles any exception classes derived from that class (but not exception classes from which it is derived). Two exception classes that are not related via subclassing are never equivalent, even if they have the same name.

The built-in exceptions listed below can be generated by the interpreter or built-in functions. Except where mentioned, they have an “associated value” indicating the detailed cause of the error. This may be a string or a tuple of several items of information (e.g., an error code and a string explaining the code). The associated value is usually passed as arguments to the exception class’s constructor.

User code can raise built-in exceptions. This can be used to test an exception handler or to report an error condition “just like” the situation in which the interpreter raises the same exception; but beware that there is nothing to prevent user code from raising an inappropriate error.

The built-in exception classes can be subclassed to define new exceptions; programmers are encouraged to derive new exceptions from the Exception class or one of its subclasses, and not from BaseException. More information on defining exceptions is available in the Python Tutorial under User-defined Exceptions.

Built-In Exceptions

Many problems in your program will lead to an error message.

Most common error messages:
- SyntaxError
- TypeError
- NameError
- ValueError

Less common error messages:
- AttributeError
- TimeLimitError
- IndexError
- IndentationError
- ExternalError
- UnboundLocalError
- ImportError
- ZeroDivisionError
- KeyError
- IOError

Learn Before

Related

Learn After