DEPARTMENT OF MASTERS OF BUSINESS ADMINISTRATION
IV SEMESTER
Machine Learning
Mini Project
SUBMITTED BY
Akshata T B
4GW23BA006
DEPARTMENT OF MBA
GSSSIETW, MYSURU
SUBMITTED TO
Ms. Ankitha J
ASSISTANT PROFESSOR
DEPARTMENT OF MBA
GSSSIETW, MYSURU
DATE:
STUDENT SIGNATURE FACULTY SIGNATURE
A Python error correction - Introduction
Python is one the most widely used programming languages in the world today. Its clean
syntax, extensive library support, and versatility have made it a preferred choice for
beginners, professionals and organizations alike. Python is used across domains such as
data science, machine learning, web development, automation, artificial intelligence and
scientific research. While python is often praised for being simple to read and write
compared to many other programming languages, it is not immune to programming errors.
These errors, whether small or large, can disrupt program execution and lead to incorrect
results or application crashes.
In the processes of writing and executing Python programs, errors are a natural and
inevitable part of development. They occur when the code does not conform to the rules of
the language or when the program attempts an invalid operation. For example, forgetting a
colon at the end of an if statement, dividing a number by zero or attempting to use a variable
that has not yet been defined are all common mistakes that result in errors. These issues
can occur for a variety of reasons, such as typographical mistakes, understanding of python
syntax, incorrect logic or unexpected input from the user.
Errors in programming can generally be divided into three broad categories: syntax errors,
runtime error and logical errors.
Syntax errors occur when the Python interpreter is unable to parse the code because it
violates the grammar rules of the language. These are often caught before the program
runs and are usually easy to correct once identified.
Runtime errors, also known as exceptions, occur while the program is running. These
can be caused by invalid operations such as dividing by zero, accessing a non-existent
list index, or attempting to open a file that does not exist.
Logical errors are the most subtle type because they do not produce an immediate error
message. Instead, the program runs successfully but produces incorrect or unintended
results due to mistakes in the program’s logic.
Understanding these error types and learning how to identify, analyze, and correct them is
an essential skill for any programmer. The ability to debug code effectively is often what
distinguishes a skilled programmer from a beginner. Debugging not only helps in resolving
the immediate problem but also deepens one’s understanding of how Python works,
thereby reducing the likelihood of similar mistakes in the future.
The mini-project titled “A Python Error Correction” aims to explore this critical aspect of
programming by focusing on the identification and correction of common Python errors.
The project will present examples of incorrect Python code that produce specific errors,
explain the reason for each error, and then provide the corrected version of the code along
with an explanation of why the correction works. This approach offers a practical and
hands-on method for learning, which is particularly beneficial for students and beginners
in programming.
In academic and professional settings, understanding error correction is vital. In an
academic environment, students often lose marks in assignments and examinations because
of avoidable mistakes in syntax or logic. In a professional environment, software with
unhandled errors can lead to system crashes, data loss, or security vulnerabilities. By
systematically studying how to identify and fix Python errors, one not only improves their
code quality but also develops problem-solving skills that are transferable to other
programming languages and technical domains.
Furthermore, Python provides developers with useful tools and features for debugging. The
error messages generated by Python are generally informative, indicating the type of error
and the line number where it occurred. These messages serve as a starting point for the
debugging process. In addition, Python offers built-in functions and modules such as print
() statements for tracing variable values, and the pdb (Python Debugger) module for more
advanced debugging tasks. The mini-project will highlight how these tools can be
effectively used in conjunction with systematic thinking to resolve issues.
The scope of “A Python Error Correction” is not limited to just fixing the error at hand but
also to understanding why the error occurred in the first place. This understanding is crucial
because many programming errors are symptoms of deeper issues in code design or logic.
For instance, an Index Error may not only be due to accessing a list element that does not
exist but could also indicate that the logic controlling the loop iteration is flawed.
Therefore, fixing errors is as much about preventing future mistakes as it is about solving
the immediate problem.
The significance of error correction in Python extends beyond just producing error-free
code. In real-world projects, debugging often consumes a substantial portion of
development time. Studies have shown that developers spend as much as 50–75% of their
time on testing and debugging activities. Therefore, improving error detection and
correction skills directly contributes to greater productivity and efficiency in software
development. Additionally, in collaborative projects where multiple programmers work on
the same codebase, writing clean, well-documented, and error-free code is essential for
smooth teamwork and maintainability.
This mini-project will also provide before-and-after examples for each error discussed.
This format helps in clearly visualizing the change that corrects the problem, making it
easier for learners to remember and apply the correction in future scenarios. The errors will
be chosen to represent different aspects of Python programming, such as variable handling,
data structures, arithmetic operations, control statements, and file handling. Each example
will include a short explanation of the error, the Python interpreter’s error message, and
the corrected code with an explanation of the fix.
In conclusion, “A Python Error Correction” serves as both a learning exercise and a
reference for common Python programming errors. By working through concrete
examples, learners will develop a stronger understanding of Python’s syntax, semantics,
and execution flow. More importantly, they will acquire the critical thinking and analytical
skills necessary to debug effectively — skills that will benefit them in all areas of software
development. This foundation will not only help in academic success but also prepare
learners for real-world programming challenges, where error correction is
an everyday task.
Objectives
The mini-project titled “A Python Error Correction” is designed to address one of the most
essential skills in programming: the ability to identify, understand, and correct errors in
Python programs. The objectives outlined in this document aim to provide clarity on the
scope, goals, and intended outcomes of this project. These objectives are intended to guide
both the learning process and the preparation of the project report, ensuring that the work
remains focused and meaningful.
1. To Develop an Understanding of Python Errors
One of the key objectives is to help learners develop a clear understanding of the
different types of errors that can occur in Python. This includes syntax errors, runtime
errors, and logical errors. By categorizing and explaining these errors, students can
better recognize them when they occur in their own code. Understanding the causes
behind these errors enables programmers to apply the correct solutions rather than
relying on trial and error.
2. To Demonstrate Common Python Errors with Practical Examples
This project aims to identify and present some of the most common Python
programming errors encountered by beginners and even experienced coders. For each
error, an example of incorrect code will be provided, followed by the exact error
message displayed by the Python interpreter. These examples will help learners relate
to real-world scenarios and recognize patterns in the types of mistakes made.
3. To Provide Corrected Code and Detailed Explanations
Another objective is to show the corrected version of the code for each identified error.
The correction process will be explained step-by-step to ensure that learners understand
why the fix works. This approach promotes active learning, as students will not only
memorize corrections but also comprehend the reasoning behind them.
4. To Strengthen Debugging Skills
Debugging is a critical programming skill that involves more than simply finding and
fixing mistakes. It requires logical thinking, problem analysis, and the ability to test
different solutions systematically. Through this project, learners will gain practical
exposure to debugging techniques, such as reading and interpreting error messages,
using Python's built-in debugging tools, and employing print statements to trace
program flow.
5. To Encourage Best Coding Practices
The process of error correction often reveals opportunities to write cleaner, more
efficient, and more readable code. An important objective of this project is to encourage
students to adopt best practices, such as proper variable naming, consistent indentation,
modular programming, and adequate commenting. By focusing on these practices, the
frequency of errors can be reduced, and program maintainability can be improved.
6. To Build Confidence in Problem-Solving
Many beginners feel discouraged when faced with repeated errors in their programs.
This project aims to boost learner confidence by demonstrating that errors are a normal
and manageable part of the coding process. By working through examples and
corrections, students will gain the assurance that they can troubleshoot problems
independently.
7. To Prepare a Reference for Future Use
The examples and explanations compiled in this project will serve as a valuable
reference guide for learners in the future. Having a personal collection of common
errors, their causes, and their solutions will allow students to quickly resolve similar
issues when they arise in subsequent projects.
8. To Bridge Academic Learning and Practical Application
This project also seeks to connect theoretical knowledge gained in programming
courses with real-world problem-solving scenarios. By applying classroom concepts to
actual error situations, learners can deepen their understanding and enhance their ability
to apply knowledge in practical settings.
In conclusion, the objectives of “A Python Error Correction” extend beyond simply fixing
mistakes in code. They encompass a comprehensive approach to learning, problem-
solving, and developing good programming habits. By achieving these objectives, learners
will not only improve their Python programming skills but also build a solid foundation
for tackling errors in any programming language they may encounter in the future.
Before and After Example
This section of the mini-project illustrates some of the most common Python errors,
showing the incorrect version of the code (Before) alongside the corrected version (After).
Each example includes the actual error message generated by Python and an explanation
of why the correction resolves the issue.
Example 1: Syntax Error – Missing Colon
Before: x = 5
if x > 3
print ("X is greater than 3")
Error Message:
Syntax Error: expected ':'
After: x=5
if x > 3:
print ("X is greater than 3")
Explanation: In Python, control statements such as if, for, and while require a colon at the
end of the condition or loop declaration. Adding the colon resolves the syntax error.
Example 2: Name Error – Undefined Variable
Before: print(total)
Error Message:
Name Error: name 'total' is not defined
After: total = 100
print(total)
Explanation: The variable 'total' was used before being defined. Defining it before usage
resolves the error.
Example 3: Type Error – Unsupported Operand Types
Before: num = "10"
result = num + 5
Error Message:
Type Error: can only concatenate str (not "int") to str
After: num = "10"
result = int(num) + 5
Explanation: The variable 'num' is a string and cannot be directly added to an integer.
Converting it to an integer resolves the issue.
Example 4: Index Error – List Index Out of Range
Before: items = [1, 2, 3]
Print (items [5])
Error Message:
Index Error: list index out of range
After: items = [1, 2, 3]
Print (items [2])
Explanation: The list 'items' has only three elements, indexed from 0 to 2. Trying to access
index 5 causes an Index Error. Using a valid index fixes the problem.
These examples demonstrate the importance of carefully reading error messages,
understanding their meaning, and applying the correct fixes. By following the before-and-
after approach, learners can easily visualize the changes needed to resolve errors.
Error Explanation
This section provides detailed explanations of common Python errors encountered during
programming. Each explanation includes the nature of the error, its common causes, and
approaches to fix it.
1. Syntax Error
Nature: A Syntax Error occurs when Python code violates the grammar rules of the
language. It is detected during the parsing stage before the program runs.
Common Causes:
- Missing punctuation such as colons or parentheses.
- Incorrect indentation.
- Misspelled keywords.
Fix: Carefully read the error message and correct the syntax according to Python rules.
Proper indentation and punctuation are essential.
2. Name Error
Nature: This error happens when a variable or function name is not found in the local or
global scope.
Common Causes:
- Using a variable before defining it.
- Misspelling a variable or function name.
Fix: Ensure variables are defined before they are used, and check for typographical errors.
3. Type Error
Nature: Occurs when an operation or function is applied to an object of inappropriate type.
Common Causes:
- Adding strings to integers without conversion.
- Passing an incorrect type of argument to a function.
Fix: Convert variables to the correct type before performing operations. Use functions like
int (), str (), and float () for conversions.
4. Index Error
Nature: Happens when attempting to access an index that is out of range for a list, tuple, or
string.
Common Causes:
- Using an index number greater than the highest available index.
Fix: Check the length of the list or string before accessing. Ensure loops and indices are
within valid ranges.
5. Zero Division Error
Nature: Raised when a division or modulo operation is performed with zero as the divisor.
Common Causes:
- Mathematical miscalculations leading to zero in the denominator.
Fix: Validate input values before division and handle special cases where the denominator
is zero.
Understanding the cause of each error type and knowing how to resolve it is fundamental
for efficient programming. Effective error handling not only fixes current issues but also
helps in writing cleaner and more maintainable code in future projects.
Conclusion
In this mini project, we explored the essential process of identifying and correcting
common Python programming errors. Errors are an inevitable part of coding, and
understanding their types—syntax, runtime, and logical errors—enables programmers to
develop more robust and efficient code. Through practical examples demonstrating before-
and-after scenarios, this project highlighted the importance of careful debugging and error
analysis in the software development lifecycle.
Correcting errors not only resolves immediate issues but also deepens one’s grasp of
Python’s syntax and semantics, fostering better programming habits. The skills developed
through this project, such as reading error messages, logical thinking, and systematic
problem-solving, are vital for both beginners and experienced programmers alike.
Furthermore, adopting best practices during coding helps reduce the frequency of errors
and improves code readability and maintainability.
Overall, this project reinforces that encountering errors is a natural and valuable learning
experience. By developing effective error correction techniques, learners can enhance their
programming proficiency and prepare themselves for real-world challenges in software
development.