Anyone entering the realm of programming must understand how important it is to write code that is easy to read. Clear and understandable code does not promote teamwork. It also makes it easier to troubleshoot and manage software projects. In this article, we’ll explore five strategies to improve the readability of Python code, making programming more user-friendly.

Challenges and common difficulties encountered.

When writing code for beginners in programming, it’s common to face readability challenges. These can include using names that don’t explain their purpose, lacking comments to describe the code logic, having inconsistent indentation that hampers understanding the structure of the code, and dealing with long and complex code blocks called monolithic structures. These issues make it hard for others to grasp the code and hinder the coder’s ability to maintain and debug their work effectively. Resolving these readability challenges is crucial for creating a programming environment and ensuring software projects are sustainable in the long run.

Using Descriptive Variable Names:

When writing Python code, choosing descriptive names for your variables is crucial. Variables play a role in a program. Opting for meaningful names dramatically improves the code’s readability. When using abbreviations or single letters, it’s best to select names that accurately describe what the variables represent and what they do in the program. For example, rather than using something like “td” for distance, a more descriptive name such as “total distance” makes it easier to understand the purpose of that variable. This idea is also highlighted in Robert C. Martin’s well-known book “Clean Code,” where he stresses how critical descriptive names are in making code easier to read and maintain. Martin suggests that clear names act as self-labels, helping developers grasp the meaning of variables without requiring comments or explanations.

# Bad variable names
a = 10
b = 5
c = a + b
print(c)
# Improved variable names
Total_score = 10
bonus_points = 5
final_score = total_score + bonus_points
print(final_score)

In the improved version, the variable names total_score, bonus_points, and final_score convey their purpose, making the code much easier to understand.

Incorporating Well- commented code

When it comes to writing code, adding comments is essential. Comments help document the code and explain how it works. They give insight into the developer’s thinking process. Make complex algorithms or logic easier to understand for others. Good commenting means explaining why certain decisions were made, or specific methods were chosen. Making comments clear, relevant, and regularly updated is crucial so they stay valuable and informative. In Python’s style guide, PEP 8, suggests using comments and focusing on explaining the reasoning behind the code rather than just what it does. By including commented code, developers can enhance collaboration. Promote knowledge sharing within their team. Commented code also acts as a form of documentation for maintenance or improvements, helping developers grasp the details of the codebase as it evolves. According to Jason Cohen, founder of WP Engine and author of “Best Kept Secrets of Peer Code Review,” comments should not describe the code’s actions. Also, explain why it is done a certain way, aiding in understanding the choices made during implementation.

# Bad example: Lack of comments
def calculate_price(quantity, price_per_unit):
total_price = quantity * price_per_unit
return total_price
# Improved example: With comments
def calculate_price(quantity, price_per_unit):
# Calculate the total price based on quantity and price per unit
total_price = quantity * price_per_unit
return total_price

In the improved version, the comment clarifies the function’s purpose, making it easier for others to understand its functionality.

Ensuring indentation and formatting

Maintaining indentation and formatting is crucial in software development. It ensures that code remains easy to read, consistent, and collaborative. Python, known for its use of indentation to structure code blocks, highlights the importance of following a formatting style across a codebase. Coding standards, like PEP 8, underscore this importance. They provide guidance on the formatting of Python coding elements such as spacing and general coding style.

In “Clean Code,” Robert C. Martin stresses the importance of uniform formatting in enhancing code readability and sustainability. By adhering to a format, programmers can streamline the tasks of comprehending, altering, and troubleshooting code for their coworkers. Additionally, tools like AutoPep8 automate the enforcement of coding standards, making it simpler for teams to uphold practices.

Consistent indentation and formatting do not enhance code readability. Also, it contributes to a polished appearance for the entire codebase. An organized and neatly formatted collection of code reflects positively on individual developers and elevates the project’s overall image. stresses the importance of uniform formatting in enhancing code readability and sustainability. By adhering to a format, programmers can streamline the tasks of comprehending, altering, and troubleshooting code for both themselves and their coworkers. Adhering to practices and utilizing tools to uphold coding guidelines enables developers to build codebases that are not just user-friendly but also trustworthy and polished.

For example,

# Bad indentation
def greet(name):
print ("Hello, " + name + "!")
# Improved indentation
def greet(name):
print ("Hello, " + name + "!")

In the improved version, the code is properly indented, making the function’s structure clear.

Embracing Modularization and Functions

To create code that’s simple to understand and update, it is important to adopt modularization and focus on function-based programming. This Strategy, advocated by Robert C. Martin in his book “Clean Code: A Handbook of Agile Software Craftsmanship,”entails dividing tasks into functions to improve clarity and ease of upkeep.

By following this method, developers can improve code organization and clarity by structuring systems into components. Imagine a scenario where a sophisticated application is divided into modules, each handling functionalities like user authentication, data processing, and user interface rendering in a web application. This modular design simplifies development. It makes it easier to manage aspects of the codebase effectively.

Moreover, encapsulating functionality within functions allows developers to create components that are easily integrated into parts of the codebase. This practice promotes efficiency by minimizing redundancy and encouraging code reuse. Additionally, modularization simplifies — debugging tasks. When functionality modifications or fixes are needed, developers can focus on the module or function without sifting through extensive amounts of code. This targeted approach streamlines development efforts while reducing the chances of consequences. The use of modular design encourages teamwork among developers. By establishing divisions between modules and defined interfaces, team members can tackle various sections of the code simultaneously without interfering with each other’s work. This nurtures a cooperative development approach, resulting in improved project outcomes.

# Monolithic approach
def calculate_total_price(quantity, price_per_unit, tax_rate):
total_price = quantity * price_per_unit
total_price_with_tax = total_price * (1 + tax_rate)
return total_price_with_tax
# Modular approach
def calculate_subtotal(quantity, price_per_unit):
return quantity * price_per_unit
def calculate_total_price(subtotal, tax_rate):
return subtotal * (1 + tax_rate)

The modular approach divides the functionality into separate functions, making the code easier to understand and maintain.

Meaningful function name

The importance of choosing clear function names goes beyond using variable names. Function names make code readable by providing an overview of what each block of code does without the need to dig into the details. Let’s explore why having function names is crucial and how they enhance the readability of code. When naming functions, it’s vital to pick names that accurately describe their purpose or the task they perform. In his book “Clean Code in Python: Refactor Your Legacy Code Base,” Mariano Anaya, stresses the importance of selecting function names. According to Mariano, these names act as documentation for the code, helping developers grasp the intention behind each function without having to analyze its implementation details. This is especially beneficial when working on projects or collaborating with developers since clear and descriptive function names aid communication and reduce the mental effort needed to understand the codebase.

Moreover, Mariano suggests that meaningful function names contribute to creating self-code, which makes it simpler for developers to maintain and modify the code in the future. When functions are given meaningful names, it becomes easier for developers to pinpoint the function they need to use when adding new features or resolving issues. This ultimately streamlines the development process. It makes it more efficient.

For example:

# Bad function name
def xyz(a, b):
return a + b
# Improved function name
def calculate_sum(a, b):
return a + b

In the improved version, the function name calculate_sum communicates its purpose, enhancing the readability of the code.

Final Thoughts

Improving the readability of Python code is about more than aesthetics — it fosters teamwork, streamlines problem-solving, and ensures a project’s long-term success. By addressing readability challenges and using strategies like clear variable names, thorough comments, consistent formatting, modular functions, and meaningful function names, developers can make their code significantly more manageable and accessible.

Today, developers can also leverage artificial intelligence to improve coding readability. AI-powered tools, such as intelligent code linters and refactoring assistants, automatically detect inefficiencies, suggest improvements, and enforce best practices. These tools enhance individual coding quality, save valuable time, reduce maintenance burdens, and promote uniformity across team projects. AI-driven code completion tools, like GitHub Copilot, further improve productivity by generating clean, readable code snippets based on developer inputs.

As thought leaders like Robert C. Martin and Mariano Anaya emphasize, better readability isn’t just about writing but collaboration, scalability, and project sustainability. Combining fundamental best practices with AI-driven solutions empowers developers to create Python projects that are not only functional but also intuitive, sustainable, and future-ready.

Initially, ACC was designed to run on MS-DOS (Microsoft Disk Operating System), specifically on PCs with Intel 80386 processors or newer versions. MS-DOS, the dominant operating system in the 1980s, played a pivotal role in Microsoft’s rise in the software industry. However, its complexity made it less user-friendly than Apple’s Macintosh operating system, eventually leading to MS-DOS losing market appeal. This shift also contributed to the decline in the popularity of tools like ACC, relegating the language to obscurity over time.

Benefits and Limitations of ACC

Benefits

ACC offers several benefits that make it appealing for its time:

• Simplicity: The language uses straightforward commands, often comprised of just 1–3 letters, making it accessible for beginners.
• Speed and Size: ACC compilers were known for their small size and fast execution, providing efficiency on resource-constrained systems.
• Ease of Learning: Its intuitive structure meant even novice programmers could quickly pick up the basics, including simple tasks like printing text or color on a screen.

Limitations

However, ACC’s simplicity also results in several significant limitations:

• Lack of Advanced Functionality: ACC lacks the complexity needed for modern programming tasks, such as building sophisticated software applications or games.
• Limited Features: There’s no ability to handle advanced graphics, like sprites, which restricts its utility in areas beyond basic scripting.
• Overlapping Functionality: Languages like Batch offer nearly identical functionality, diminishing ACC’s unique value proposition.

Given these limitations, ACC became obsolete for most practical purposes as more versatile and robust programming languages emerged.

Current Usage and Relevance of ACC

Today, ACC has effectively fallen out of use in any mainstream capacity. Historically, it was part of the C programming language family — a group of languages stemming from the foundational “C” language itself. Early programmers mainly used ACC for tasks such as merging multiple object files.

While there are some mentions of ACC being used on HP-UX machines as a compiler, its application is now largely anecdotal or limited to historical discussions. Modern programming needs have vastly outpaced what ACC was designed to accomplish. Today, languages like Python, JavaScript, C++, and others dominate due to their adaptability, modern library support, and ability to handle complex tasks.

Example of ACC Code

Despite its simplicity, ACC’s coding structure offers a glimpse of how early programming languages functioned. Below are two examples demonstrating an IF statement and a loop in ACC:

IF Statement Example:

```
#include <iostream.h>
int main() {
int x, y;
cout << "Enter an integer: ";
cin >> x;
y = x * 2;
cout << "\n" << y << " is twice " << x << ".\n";
}
```

Loop Example:

```
x_inv = 1.0/x;
for (int j = 1; j < 5; j++)
a[j] = b[j] * x_inv;
```

These examples highlight ACC’s straightforward syntax and inherent limitations in handling advanced functionality.

Trends in ACC’s Legacy

ACC never experienced widespread popularity, even during its peak in the 1980s. Its decline coincided with the rise of user-friendly operating systems like Macintosh, which overshadowed MS-DOS and eliminated the ecosystem where ACC thrived. Furthermore, the rapid evolution of programming languages left little room for a simplistic tool like ACC in a world shifting towards more sophisticated and versatile solutions.

Final Thoughts

While ACC is historically significant as part of the early evolution of compilers and programming tools, it has little to no relevance in the modern technological landscape. Adopting modern solutions like Python or using advanced AI-powered programming assistants is essential for businesses and developers seeking cutting-edge tools. These tools embody the flexibility and functionality required to effectively tackle today’s complex programming challenges.

For those interested in archival programming history or understanding the early evolution of compilers, ACC serves as a fascinating case study of how technology evolves to meet users’ demands.

In definition terms, a Recursion is a process of a function that calls itself “directly” or “indirectly”. Or in other terms, a function that calls itself is recursive; hence where the term recursion came from is the act of using that function. As for the history of recursions, it is best to talk about what the word means. Recursions come from the Latin word ‘Recurere’ as in to run or hasten back, return, revert, or recur. Like most functions in Python or coding in general, recursions are a technique to help you reduce the length of your code and make your code easy to read or write.

In more basic terms, you can break down a code and make It into smaller parts or create more minor problems you can solve.

Examples

I know what you think. If Recursion is just a function to repeat itself on and on in a program, couldn’t the code continue and never stop creating the same code? Possibly creating an infinite code and wasting all your memory in your computer. Yes, you are correct, but that is why there is a Recursion error. For instance, as simple as code like:

Def function():
X = 10
function()

Based on that code, your computer can only interpret and act on that code so many times it has a limit, so it will just give you a “RecursionError”. The idea is that recursions help you demonstrate your problem in one or smaller issues so you can add one or more base conditions to stop your problem. A notable example of this is when you want to add numbers to each on a function like “f(n) = 1 + 2 + 3 + 4 +…. + n” n being a natural number that comes after the other as eight comes after 7, 16 comes after 15. 1027 comes after 1026. The code would look somewhat like this:

f(n) = 1 + 2 + 3 +………+ n

But except for going on and on, wasting your time writing code until you get to the number 127, you can write the code:

f(n) = 1 n=1
f(n) = n + f(n-1) n>1

In the code, the function acts on the last number that is interpreted, so except for writing 1 + 2 + 3 + 4… you find an easier and more efficient way to write it.

A base condition stops the code from going on and forever, basically a finish line or end goal for the code. For instance, a legend with a base case or condition would look something like: (this is an example from GeekforGeeks)

int fact(int n)
{
if (n < = 1) // base case
return 1;
else
return n*fact(n-1);
}

This return function would be your base condition, giving you an end goal of where you want to stop n such. This code seems super simple, but programmers use this tool more than you think. With such a simple task to add numbers on top of each other, it is best to know the Fibonacci sequence because it has the same idea as Recursion. The Fibonacci sequence is a type series that usually starts at 0 and 1, and you generate numbers based on the sum of the last two numbers, for instance,

0, 1, 1, 2, 3, 5, 8, 13, 21, …

Fibonacci

If we get into the Fibonacci sequence of a general idea of how recursions work, it is necessary that you also know how it works and how it solves problems. And when first learning how to use Recursion in Python or just coding in general, the Fibonacci sequence is an excellent illustration of that. A fitting example problem is the Towers of Hanoi(TOH). The Towers of Hanoi or “TOH” is a mathematical puzzle where you have 3 rods and disks, like this. The objective of the puzzle is to move the entire stack to another rod, but you cannot just lift all the disks at once and put them on another rod; there are rules.

The rules are:

1. One disk can be moved at a time.

2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack; i.e., a disk can only be moved if it is the uppermost disk on a stack.

3. No disk may be placed on top of a smaller disk.

The code in Python would look something like this:

# Recursive Python function to solve tower of Hanoi
def TowerOfHanoi(n , from rod, to_rod, aux_rod):
if n == 0:
return
TowerOfHanoi(n-1, from rod, aux_rod, to_rod)
print("Move disk",n,"from rod",from_rod,"to rod",to_rod)
TowerOfHanoi(n-1, aux_rod, to_rod, from_rod)
# Driver code
n = 4
TowerOfHanoi(n, 'A', 'C', 'B')
# A, C, and B are the name of the rods

Now you might have a better understanding of recursions, but you should be able to see now that there are plenty of problems when using recursions. You learned this simple idea as a child, but writing it as a code is much more complex. An informative video to illustrate this is on GeeksforGeeks.org.

You see that the code might be simple and very intuitive as it is, but it can take time to grasp and understand the idea behind it genuinely. There is a great chance you run into infinite conditions because that is what most programmers run into when using recursions. For instance, let us say you are cleaning your car, and it is your first time using a different soap brand; the instructions say, “rinse, wash and repeat”. If you follow those rules, you will be washing your car forever. But thankfully, there is that one instruction that tells you to repeat those steps until necessary, which gives you that termination condition that “return” or end goal for you not to be washing forever.

If it were a robot and you forgot to add in a return function or end goal, that robot would be working forever. That is why it might seem so minor, but it’s a common mistake that programmers run into. Realpython.com does an excellent job of explaining how a recursion work by breaking it down into the pattern it follows:

• One or more base cases are directly solvable without requiring further Recursion.
• Each recursive call moves the solution progressively closer to a base case.

Disadvantages

Having an infinite function problem (Recursion Error). But there is a lot more to it. For one, the memory space it takes, a lot of memory and time is taken through recursive calls, which makes it expensive to use.

There is also something called a related run time error. When a recursive call is made, a new stack frame is created(every stack needs memory). You must correctly include a return statement terminating the code to stop to avoid running out of memory.

Even though using the recursions function helps you break down the problem and make more minor problems, you may need to catch up in the code and lose track of stacking and actions the code is causing. Also, you will run into the challenge of debugging the code. Lastly, the reasoning behind recursions can be challenging to wrap your head around, but if your calls are not terminated, you can form an infinite loop.

When to use Recursions

Usually, when you find yourself in a situation where you have a problem, it is too big to deal with all at once. Recursions break down your program and make your problems into “smaller problems.” For instance, problems that can be solved with Recursion include: calculating the factorial of a number, finding the nth Fibonacci number, traversing and printing the elements of a binary tree, and more.

When you should not use Recursions

It would be best if you did not use recursions when you can quickly solve the same problem using an iterative approach. Recursions can be slow and consume a lot of memory as they involve function calls and stack frames.

What’s the difference between Loops and Recursions?

You should see a lot of similarities between Recursion and Loops; it is said that almost all recursive functions can be rewritten as loops and vice versa. A straight definition would be “recursions is a method of calling a function within the function, as for loops it’s a controlled structure that allows executing a block of code repeatedly within the program” — pediaa.com. It is commonly known that recursions are less understood because of the complex code that it has to break down into sub-problems(as you know), “a continuous loop of the problem” Georgiev says it perfectly.

A Recursion code might look like this:

Item Search(string desired, Scope scope) {
for each(Item item in scope.items)
if(item.name == desired)
return item:
return scope.Parent? Search(desired, scope.Parent) : null;
}
Vs. code with Loops would look like this:
Item Search(string desired, Scope scope) {
for(Scope cur = scope; cur != null; cur = cur.Parent)
for each(Item item in cur.items)
if(item.name == desired)
return item;
return null;
}

If you compare the two through real-life situations regarding speed and efficiency, loops have the upper hand. Recursion execution is slower, and Loops executes in a faster efficient way. Recursions also use a stacking method to store the local variables when the function is called (loops do not operate on this function). I have said this earlier in the paper, but in the case of memory and space complexity, loops beat recursions because of how much space is required for recursions. In terms of code readability, of course, this depends on the level of understanding a programmer has, but it is known that a code with recursions is more readable than a program with loops.

Takeaway on Recursion

There is a joke that goes on to understand. Recursion entirely means smiling at the joke that “to understand recursion, you must understand recursion.” If you know, you know, but I would like to say overall, this technique of not only being able to understand recursions fully and to be able to use this code function not only give a better and easier time as a programmer. But it will make you a better programmer and coder when you master this skill.

The recursive function is being used to this day, but programmers now might need to gain the critical knowledge that is behind all of it. Through all this, in the programming world, “everyone wants to work smarter, not harder,” and if one wants to do that, one might have to consider using recursions in their code.

A sorting algorithm is any series of steps that takes an unsorted data input and returns data organized in a specific pattern. For computer-related operations, this involves taking an input of a list or array and returning an organized list or array. Sorting primarily helps optimize data usability, as some data operations are more efficient when operating on a sorted list. This is apparent in searching, selecting, handling duplication, and analyzing data distribution. Given the usefulness of sorted data, sorting algorithms are a well-studied part of computer science. Let’s review different attributes sorting algorithms can have and present and analyze select algorithms. All algorithms will be presented in Python.

Attributes of Sorting Algorithms

As the number of entries N plugged into a sorting algorithm grows, so do the resources it utilizes. The primary resource usages for analyzing sorting algorithms are time and space complexity. As per the name, time complexity describes how long a sorting algorithm will take based on the magnitude of the number of operations performed. Similarly, space complexity describes how much space an algorithm needs in terms of N (the number of entries).

Introduction to Time Complexity of Sorting Algorithms

Evaluating sorting algorithms for time does not involve evaluating a specific runtime, as the number of entries and the resources available are unknown variables. Instead, it consists of quantifying the time the algorithms will take in terms of the number of entries. Algorithms are quantified in three different aspects: lower bound, or big Omega notation (denoted by an Omega); tightest bound, or big Theta notation (represented by a Theta); and upper bound, or big O notation (defined by O, meaning “order of”). These equate to a minimum, average, and maximum runtime. For most use cases, O, or maximum runtime, is the metric of time complexity considered. Thus, this paper will primarily consider the maximum runtime of sorting algorithms.

Elaboration on Time Complexity of Sorting Algorithms

The time complexity of an algorithm is quantified by how the time grows as the number of entries grows. There are several categories of time complexity in which algorithms can fit: constant time O(1), logarithmic time O(\log{n}), linear time O(n), quadratic time O(n²), and exponential time O(2^n). As these describe how an algorithm’s time increases as the number of entries increases, constant time means that the algorithm’s time is not dependent on the number of entries. This makes it the optimal runtime of a sorting algorithm, although it generally only appears as the Omega(n) runtime for pre-sorted data. However, as a general rule, the shorter the time, the better, although sometimes shorter time comes at the cost of higher space complexity.

Space Complexity of Sorting Algorithms

Similar to time complexity, the space complexity of a sorting algorithm is quantified by how much memory (that is, RAM or Random Access Memory) an algorithm takes to run in terms of the number of entries input. This, too, is highly dependent on the algorithm. Although it’s an important aspect to consider, generally, time complexity is weighed more heavily when considering algorithms.

Stable Sorting

A sorting algorithm is considered “stable” if, upon encountering equivalent values, it maintains the original order of these values when sorting. A sorting algorithm is thus considered “unstable” if it does not preserve the original order of equivalent values.

Evaluating Specific Sorting Algorithms

Given the attributes above of sorting algorithms, the following will evaluate common sorting algorithms for their time and space complexity.

Insertion Sort

# function - sorts list values from least to greatest
def sort_values_ascending(inputList):
i = 0
while i < len(inputList):
ii = i
smallValue = inputList[ii] + 1
smallValueIndex = 0
while ii < len(inputList):
if inputList[ii] < smallValue:
smallValue = inputList[ii]
smallValueIndex = ii
else:
ii += 1
inputList[smallValueIndex] = inputList[i]
inputList[i] = smallValue
i += 1
return inputList

This function sorts the input list from least to greatest and returns it. If inputList = [3, 2, 1, 4, 2], the function will return [1, 2, 2, 3, 4]. It accomplishes this by iterating through the sequence starting at the relative front until it finds the smallest number, then swapping the values of the smallest value and the value at the relative front of the list for each value, incrementing the location of the relative front by one for each full list read. This may be a very intuitive sort, but when analyzed for time complexity, it comes up somewhat short at O(n²) time complexity. The space complexity of insertion sort is only the array itself, as shown in the example above, and as mentioned by Coding Ninjas, as it updates the original array itself while iterating. However, its inability to scale well with the number of entries input makes it an unrealistic pick when dealing with an arbitrarily large number.

Bubble Sort

def bubble_sort(alist):
for i in range(len(alist) - 1, 0, -1):
no_swap = True
for j in range(0, i):
if alist[j + 1] < alist[j]:
alist[j], alist[j + 1] = alist[j + 1], alist[j]
no_swap = False
if no_swap:
return
alist = input('Enter the list of numbers: ').split()
alist = [int(x) for x in alist]
bubble_sort(alist)
print('Sorted list: ', end='')
print(alist)

As written above by Manish Bhojasia, bubble sort has a time complexity of O(n^n), which is worse than insertion sort. However, its best time complexity is linear, and the time complexity scales directly with how unsorted a list is, making it a highly situational sorting algorithm. The bubble sort sorting algorithm only has a space complexity of O(1), or a constant space complexity, as it swaps the values of the original dataset.

Merge Sort

# Python program for implementation of MergeSort
# Merges two subarrays of arr[].
# First subarray is arr[l..m]
# Second subarray is arr[m+1..r]
def merge(arr, l, m, r):
n1 = m - l + 1
n2 = r - m
# create temp arrays
L = [0] * (n1)
R = [0] * (n2)
# Copy data to temp arrays L[] and R[]
for i in range(0, n1):
L[i] = arr[l + i]
for j in range(0, n2):
R[j] = arr[m + 1 + j]
# Merge the temp arrays back into arr[l..r]
i = 0 # Initial index of first subarray
j = 0 # Initial index of second subarray
k = l # Initial index of merged subarray
while i < n1 and j < n2:
if L[i] <= R[j]:
arr[k] = L[i]
i += 1
else:
arr[k] = R[j]
j += 1
k += 1
# Copy the remaining elements of L[], if there
# are any
while i < n1:
arr[k] = L[i]
i += 1
k += 1
# Copy the remaining elements of R[], if there
# are any
while j < n2:
arr[k] = R[j]
j += 1
k += 1
# l is for left index and r is right index of the
# sub-array of arr to be sorted
def mergeSort(arr, l, r):
if l < r:
# Same as (l+r)//2, but avoids overflow for
# large l and h
m = l+(r-l)//2
# Sort first and second halves
mergeSort(arr, l, m)
mergeSort(arr, m+1, r)
merge(arr, l, m, r)
# Driver code to test above
arr = [12, 11, 13, 5, 6, 7]
n = len(arr)
print("Given array is")
for i in range(n):
print("%d" % arr[i],end=" ")
mergeSort(arr, 0, n-1)
print("\n\nSorted array is")
for i in range(n):
print("%d" % arr[i],end=" ")
# This code is contributed by Mohit Kumra

As written here by Mohit Kumra, Merge sort is one of the more versatile sorting algorithms. It takes a divide-and-conquer approach to sort, dividing the dataset into halves until it can no longer do so. It has a time complexity of O(n log n), which, as mentioned by Coding Ninjas, is equivalent to the best, worst, and average case scenario. It has a space complexity of O(n), which is minimal when considering the relatively.

Quick Sort

# Python program for implementation of Quicksort Sort
# This implementation utilizes pivot as the last element in the nums list
# It has a pointer to keep track of the elements smaller than the pivot
# At the very end of partition() function, the pointer is swapped with the pivot
# to come up with a "sorted" nums relative to the pivot
# Function to find the partition position
def partition(array, low, high):
# choose the rightmost element as pivot
pivot = array[high]
# pointer for greater element
i = low - 1
# traverse through all elements
# compare each element with pivot
for j in range(low, high):
if array[j] <= pivot:
# If element smaller than pivot is found
# swap it with the greater element pointed by i
i = i + 1
# Swapping element at i with element at j
(array[i], array[j]) = (array[j], array[i])
# Swap the pivot element with the greater element specified by i
(array[i + 1], array[high]) = (array[high], array[i + 1])
# Return the position from where partition is done
return i + 1
# function to perform quicksort
def quickSort(array, low, high):
if low < high:
# Find pivot element such that
# element smaller than pivot are on the left
# element greater than pivot are on the right
pi = partition(array, low, high)
# Recursive call on the left of pivot
quickSort(array, low, pi - 1)
# Recursive call on the right of pivot
quickSort(array, pi + 1, high)
data = [1, 7, 4, 1, 10, 9, -2]
print("Unsorted Array")
print(data)
size = len(data)
quickSort(data, 0, size - 1)
print('Sorted Array in Ascending Order:')
print(data)

As presented here by Geeks for Geeks, quick sort is another search algorithm with the divide and conquer method. It has a time complexity of O(log n) and a space complexity of O(n), making it similar to the Merge sort, with different use cases.

Which Algorithm?

A sorting algorithm only becomes essential when dealing with large amounts of data. As such, the built-in function should suffice for trivial purposes. However, when dealing with large amounts of data, one should consider how significant the time and space complexity is to them, based on their use case and resources available, and pick an algorithm appropriate to their use case.

Common Errors

A common error when making a sorting algorithm could be not checking whether or not it’s already been made, as sorting algorithms are a relatively well-studied topic. When programming a sorting algorithm, a possible error is not correctly incrementing one’s loop, thus creating an infinite loop. When using a sorting algorithm, an easy mistake would be picking one that is not well suited to one’s use case, i.e., just using the default sorting algorithm when another one is more appropriate. However, unless dealing with large amounts of data, the difference can be small enough that it doesn’t matter much — it entirely depends on the use case.

Takeaway

Sorting algorithms can be beneficial for making data more usable. Sorted data improves search efficiency, data selection, duplication handling, and data distribution analysis. This is especially relevant today, given the massive amounts of data produced. Many searching algorithms are available, and picking one that fits the job is essential when dealing with large amounts of data.

What is BeanShell?

BeanShell is a lightweight, embeddable Java source interpreter that includes features in object scripting. BeanShell is written in the Java Language. BeanShell is exceptional in the way it can execute standard Java syntax. It can extend the syntaxes with popular scripting techniques that include loose types, commands, and method closures like those found in Perl and JavaScript.

BeanShell History

During 1993, Patrick Niemeyer was heavily interested in the Tcl/Tk scripting. He was working at Southwestern Bell Technology Resources at the time. With the advice of a friend, Patrick picked up a coding language called Oak, which would later become Java. Patrick unknowingly became one of the first book writers for the language that went mainstream. The book was called “Exploring Java, O’Reilly & Associates.” Patrick also created Java’s first scripting language, BeanShell.

BeanShell was not ready to be released to the public until 1997. It didn’t do anything special before Java’s 1.1 updates, where it had helped create updates for Patrick’s book. Because BeanShell started to help code in Java, Patrick decided to “Polish it up and release it.”

Who Uses BeanShell and Trends of BeanShell’s Popularity.

Since its release, BeanShell has slowly accumulated more popularity. Though BeanShell has had its ups and downs in trending popularity, it has leveled out in growth. BeanShell is bundled in a bunch of programming software nowadays, so much so that it might be hard to find a Java scripting language that doesn’t include some aspect of BeanShell. Some notable bundles with BeanShell integrated into their product include Emacs as part of their JDE, NetBeans for Sun Microsystems, Forte for Java IDEs, and BEA’s WebLogic application server. With the logic of BeanShell being bundled in all these programs, it makes sense that BeanShell has found its home in many places. The most significant discrepancy between the people who use BeanShell recorded is very wild. Scientists from CERN in their super techy laboratories are recorded to have used BeanShell in their software. While at the other end of the spectrum, BeanShell is being used to teach nine-year-olds how to code. Another significant discrepancy includes BeanShell being integrated into “Large financial applications.” While on the other end of the spectrum, BeanShell can be embedded into remote floating Buoys.

Examples of Code

Loop:

BeanShell can support Java 1.5 for-loops for anything that covers arrays and collections. Even though BeanShell is not limited to Java 1.5

List foo = aRandomList();
for ( someElement : foo )
print( someElement );
for ( Object anotherElement: foo )
print( anotherElement );
int [] array = new int [] { 1, 2, 3 };
for( i : array )
print(i);
for( char c : "some string" )
print( c );

If-statement:

All the regular Java statements will work for BeanShell. BeanShell only really builds upon Java and improves the quality of life features. Even so, here is an example of a very simple if statement.

if ( something happening ) {
int x = 1;
y = x*5;
print(y)
}

For all variables, they are assigned a type. Like for instance, “JButton.” BeanShell can support these types, as is the norm in other programming languages like Java. For these types of assigned-type variables, assigning a different type to those variables will always result in an error message. This kind of situation is best suited for Bean Shell. One of BeanShell’s most prominent features is the ability to assign variables without declaring them first or assigning any type. This process would also classify these variables as dynamic. BeanShell will check those variables when the code is run at that time. Here are some examples where Java syntax is typed loosely.

// Loosely Typed Java syntax. 
// Use a hashtable
hashtable = new Hashtable();
date = new Date();
hashtable.put( "today", date );
// Print the current clock value
print( System.currentTimeMillis() );
// Loop
for (i=0; i<5; i++)
print(i);
// Pop up a frame with a button in it
button = new JButton( "My Button" );
frame = new JFrame( "My Frame" );
frame.getContentPane().add( button, "Center" );
frame.pack();
frame.setVisible(true);

Looking directly at the code from a glance, the difference between traditionally assigned and loosely typed Java syntax doesn’t seem like much. But it is amazing. The technique proves helpful when scripting is part of the development and testing process. It is beneficial when the software is interactable.

A “loose” variable can be assigned to a type, and then its type can be overwritten to another later. The opposite can also be true. There can be no variable, but BeanShell can hold the Java Primitive values like int and Boolean. BeanShell is also brilliant when it comes to assigning those primitive values. It knows the real types and will only allow the appropriate use of those values. This includes doing the correct “numeric promotion” akin to what Java usually does when used in an expression.

What is BeanShell used for?

BeanShell can interactively test Java code, find bugs in code, and find ways to improve upon the code through testing. Scripting Java allows it to be used in many applications.

Those applications include:

• Rapid Prototyping is a group of techniques that makes it easier to create a scale model of something — frequently done to create three-dimensional computer-aided design data (CAD). The data is then used to make 3D visual renders or printed with a 3D printer.
• User Scripting Extension is a program frequently written in JavaScript for modifying web pages to customize the browsing experience. A user script manager browser extension like Greasemonkey is standard to run smoothly on the Firefox internet browser.
• Rule Engines is a program that surveys data provided and then executes actions corresponding to the conditions matched in the provided data. Rule engines are used for many reasons. One reason is that its code is straightforward to read, even for people unfamiliar with coding. Another reason is that all rules are in one place for easy organization. Code maintenance is easy since rules can easily be updated.
• Testing BeanShell is easily testable with its debug() command. Allowing for easy revisions in code.
• Dynamic Deployment: BeanShell can deploy, redeploy, and un-deploy an application or module without restarting the server. This is very useful for developers since they can bring an application or module to life without wasting time restarting the server for the app or module. Whenever a redeployment usually happens, it breaks every session — forcing every client to restart their session.
• Embedded systems are a godsend of a feature. Embed BeanShell into systems makes it very flexible in what kind of code can be included. BeanShell can upgrade the system to be highly customizable without all the hardships of compiling Java classes and knowing Java syntax.
• Java education, BeanShell is very versatile, so much so that the difference between the super technical and the most simple developers ranges from high-energy physics laboratories at CERN to programming classrooms for nine-year-olds.

How does BeanShell work exactly?

BeanShell is very lightweight and embeddable. This means BeanShell can be called into Java applications to execute code dynamically. It can also be running at run-time or provide extensibility to the application. BeanShell can also manipulate Java applications. Allowing for work with Java objects and application programming interfaces dynamically. Thanks to BeanShell being written in Java and running in the same Virtual Machine as an application, references to live objects can freely pass into scripts and return them as results. BeanShell is a combination of dynamically interpreted Java, a scripting language, and a flexible environment. All in one.

What are some benefits of BeanShell?

The most significant benefits of BeanShell are as follows:

• BeanShell can execute the entirety of Java syntax dynamically. It can also run Java code written as only fragments. Even loosely typed Java is different from BeanShell. BeanShell has more convenient benefits, but these are the most prominent.
• Full transparent access to all Java objects as well as application programming interfaces.
• BeanShell can be run in four modes:
• Command Line
• Console
• Applet
• Remote Session Server
• Works well with secure environments. Does not need a class loader or bytecode generation for the most part.
• The BeanShell interpreter is a tiny file. BeanShell is around one hundred fifty kilobytes as a jar file.
• BeanShell is 100% Java and nothing else.
• BeanShell is 100% Free!!
• Java Evaluation Benefits
• BeanShell can dynamically evaluate entire Java source classes and isolate Java methods, statements, and expressions.
• Scripting Benefits
• Variables can be typed optionally.
• Scripted methods can have optionally typed arguments and can also return values.
• Scripted objects using method closures.
• Scripted interfaces that can also include event handlers.
• Convenience syntax for handling Properties, hash tables, and primitive wrapper types in JavaBean.
• Variables can be auto-allocated to emulate Java property files.
• An extensible set of utility and shell-like commands
• Dynamic classpath management useful for fine-grained class reloading
• Dynamic command loading along with user command path
• Sophisticated namespace and call stack management
• Detailed error reporting

BeanShell is one crazy helpful Java source interpreter. It is almost a necessity when coding with Java. A Java coder made beanShell for coding with Java. It has been around since the beginning! (although not released to the public until later) Many benefits and quality-of-life changes come with working with BeanShell that only a fool wouldn’t use!

What are files used for in Python?

Python files are similar to other files in that they are used for reading, writing, and accessing storage. Python files are a specific type of file with Python code that can be opened with Python interpreters like VCS, PyCharm, and many others. There’s also a use for other files inside Python files. Many functions inside Python interact with different types of files. Files can be referenced, edited, deleted, etc., inside Python. This gives the user creative freedom to write programs and many other programs with different purposes. A few examples would be a program that mass deletes files off your computer. This would be helpful if, for example, your computer had a lot of junk files on it, and you wanted to clean it in bulk. Writing a program that mass deletes certain files could be possible. Another example would be a program that can write new content into files. If you, for example, wanted to edit many files in bulk, you could write a Python program that would do just that. Many functions in Python take advantage of the ability to modify files on your computer.

How are they used in Python?

Here’s an example of opening files in Python:

Code:

A = open("sample.txt", r)
Print(A.read())

Whatever “sample.txt” had inside of it.

Explanation:

The first string defines the variable A to open the file called “sample.txt”. This creates a reference point for Python to call back to. The “r” at the end of the line stands for “read’, which means Python will read the contents of the file. The second string is telling Python to output text from the variable “A”, which we defined to be “sample.txt” earlier. This means that printing the variable “A” will print out the contents of “sample.txt”.

This function would be massively helpful in a big project, where much of the information is stored in separate files. With Python, people can quickly call back to other files to display the stored data.

Here’s an example of adding content to an existing file in Python:

Code:

A = open("sample.txt", "a")
A.write("Sample content")
A.close

The output would modify the file by adding the content inside the quotes to the end of the original file.

Explanation:

The first line defines the variable “A” to open the file called “sample.txt”. This also creates a reference point for Python to open the file. The “a” at the end of the line stands for “append”, meaning new content will be added to the end of the file. The following line references the original file with “A.write”, and the .write at the end specifies that the file will have new content written inside of it. The text inside the quotes would be added to the end of the file. The last line closes the reference.

This program would also be beneficial in a big project if new data needs to be added to existing files. An earlier expression could collect information from the user and have that information written into a file. The file could be edited multiple times throughout the program and store many user inputs.

Here is a video detailing some other ways to handle files in Python.

-Advanced Uses

There are some more advanced uses for files within Python. These uses are harder to implement but come with many benefits. These functions are much more diverse and customizable in their uses. One advanced use would be to output the contents of the file line by line. This function could display large amounts of info and even modify how the information is structured / how it looks.

Code:

File = open("sample.txt", "r")
List = file.readlines();
For line in list
Print(list)
File.close()

This program would output the contents of the file line by line. However, modifying the print command can change the output to look different.

Explanation:

The first line defines the variable “File” to open the sample text file with information inside it. The second line represents the variable “List” to the “readlines” command. This command reads the information in the sample file. The following line uses a for-loop. A for-loop repeats a command or function for every line. The for-loop causes Python to print out the information line for line. The last line will close the file.

This program is also useful when a lot of information needs to be displayed. This program is very similar to the previous one. The print functionality lets the user modify the output’s appearance when the command is run. Some example customizations could be adding specific phrases to the beginning or end of the printed lines. Another one could be numbering the lines. This program could be modified and integrated into a big project.

Another example of a more advanced function would be to mass delete files. A good use for this would be to clear out a large folder inside your computer without manually doing it. Clearing out files manually off your computer at a certain point becomes tedious, and Python allows you to automate the process and save time.

Code:

Import os
Path = r"C:\Parent\folder\SampleFolder\\"
For file_name in os.listdir(path):
File = path + file_name
If os.path.isfile(file)
Print('Deleting file:', file)
Os.remove(file)

This program would remove the files inside the specified folder. The output would show a list of files being deleted as it continues going through the folder.

Explanation:

This function requires the user to import a custom module. Modules are extensions of Python made by people who can extend and change how Python works. The “os” module allows users to manipulate their operating system with commands. The first line of the program declares the module for Python to interpret. The second line defines the variable “Path” to the specific file path the user wishes to delete. The third line establishes a for-loop to sift through every file in the directory that the user specified earlier. The fourth line combines the file path with the file name, determining what the program needs to look for. The fifth line uses an if-statement and tells Python to delete the file using the “os.remove” command.

This is the most advanced program that I’ve written about. As I’ve written earlier, this program would be beneficial if a user needed to delete folders with many files inside. Once a folder is filled with enough files, clearing them out manually becomes tedious and time-consuming. This program will automate the process and save you a lot of time. This can be taken further by automatically clearing folders repeatedly after a specific time. For example, you can set this program to clear out your temp folder once every month. The temp folder on your computer stores temporary information from your browser, software, etc., and fills up very quickly. Deleting the contents of the temp folder will free up space and possibly even make your computer run smoother.

Common Problems

There are common problems when working with Python. Specifically, with files, there are common mistakes that users can make. One common one would be clashing file names. When files have clashing names, it could cause Python to struggle with determining which one to operate on. Some ways to fix this would be to specify the file type within the program and possibly change the name of the file that the user would want to operate on. This only applies when the file names are the same.

Another common problem could be not closing the file after it’s been modified within the code. Closing the file is required at the end of the operation because it could interfere with the other functions. For example, if you want to read, append another one immediately. You’d have to close the file at the end of both operations because they might interfere with each other and cause errors. A fix for this would be to close the files after you have finished your operations.

The last common mistake I’ll write about is the file not found or “FileNotFoundError” that may pop up when working with files in Python. This error pops up when Python can’t identify or locate the file you directed. The fix for this is to ensure you have specified the correct file path for Python to look for. Sometimes, you may need to select the entire file path, starting with the drive’s name, the user, etc.

The other common errors the user may encounter are common Python errors. Things like syntax and logic errors. Syntax errors are usually misspelling errors, where an argument or command is misspelled, causing the program to stop working. These are generally fixed by proofreading the file and ensuring everything is spelled correctly. Logic errors are where the files don’t have errors, but the program outputs a response it shouldn’t. These happen when people mistype the function to do something other than what the user wants. For example, if someone wrote two minus two instead of two plus two. The output would be zero, even though the user would expect a result of four. Similarly to the last one, this error is usually fixed by proofreading the file.

Takeaway

Files are used to store information on computers. Many kinds of files hold different types of information. Files containing text, audio, images, videos, etc., are constantly used by your computer to display the information inside. These files store and modify data in almost every task computers perform. In Python, files also store information, typically some code or program that can be executed. Python also can modify, create, or change files within the code. This allows the user to automate tasks efficiently. Using these functions to automate simple tasks can save precious time writing code.

Due to this new rise of data, difficulties arise in handling and using the large volumes of data available today. Introducing the technical field of data science supports solving these new masses of data problems. From these solutions, data science helps organizations use the data to derive useful information and insights. ­­

What is Data Science?

Data science is the study and analysis of data. It involves using different tools and techniques to interpret and derive meaningful information, knowledge, and patterns within a large amount of data to build an understanding to make efficient decisions. The need for data science came about due to the massive production of data that forms each second of the day. Difficulties arise in handling the vast volumes of data that increase each day. Data science offers powerful, complex algorithms and technologies to solve the challenge of handling and evaluating this data. It involves the combination of mathematical, computational, and statistical disciplines.

In the modern world, data science has heavily grown involvement in businesses and organizations, solving company problems using knowledge from data. Data insights allow businesses to make effective decisions that will lead to the desired outcome for a business. An example of data-driven decision-making used in industries is customer prediction decisions in product marketing. By analyzing a system of data that includes information on customer behavior patterns, marketers can use this to predict customer desires, needs, future behaviors, and the overall likelihood of buying a product.

Data science is significant in the growth of businesses by modifying new strategies and operations for an increase in customer satisfaction with the use of the decisions and insights offered by data analysis.

Data Science Life Cycle

The process of data science in business project scenarios consists of a cycle of several steps. This cycle may vary for different companies but follows a similar process overall. Each step in the process is divided into different roles and responsibilities. The parts involved in the building and development of the project are business analyst, data analyst, data scientist, data engineer, data architect, and machine learning engineer. The following are the steps involved in the cycle of data projects:

• 1. Developing a business understanding of the problem the client is facing and what is needed to be achieved. This is the role of the business analyst. They are responsible for asking the required questions to gather details from the client, understand what is happening in the client’s business, and define the problem.
• 2. After recognizing the problem, the data collection process is done by the data analyst team. This step involves finding and reviewing all the various data sources (internal and external) available that address the problem that is being solved. Sources may include web server logs, social media posts, US Census datasets, etc. It is overall the process of gathering the data. To do this, data analysts need to have a proper way to source the data. The two tracks they source the data are web scraping and extracting data from third-party APIs.
• 3. Next is data preparation. This step is one of the most critical steps of the cycle that takes the most time compared to the others. It is the process referred to as data cleaning. It is formatting the data in sufficient structure and removing unnecessary functions. Data must be well organized and easy to understand to prepare for analysis. When data is found, it may not be in the best and most accurate format. It may need values, duplicate data, or incorrect data. With data cleaning, steps are made to identify and fix incorrect data.
• 4. Data modeling. It is the process of taking the prepared data and selecting a proper machine learning algorithm where the data set is formed into a model and visual representation. With the use of these tools, this is where the analysis of the data comes to play. The step gives the tools to understand the data better, bringing in insights, predictions, and outcomes from the data.

Programming plays a vital role in each data analysis project step. It plays a role in the stages of data collecting, data preparation, and data modeling. It is only easy to perform these tasks with the involvement and supporting tools of programming. In data collection, web scraping, the extraction of data from the web, is a process that lines of code can do. This is also the case for data cleaning and machine learning tasks. With various programming tools, the several functions in the life cycle of data science can and support be completed more efficiently. Over the past several years, Python has been the most used programming language for data analysis.

What is Python?

Python is an object-oriented, open-sourced, high-level programming language used for general-purpose programming. Python is mainly known for its simplicity; it has a cleaner and more readable syntax than other programming languages. Despite the simplicity of this programming language, Python is also powerful enough to handle complex applications. Because it is an object-oriented language, Python organizes code into objects that can interact and communicate with each other. Python can operate and be used in many ways. Web development, data analysis, artificial intelligence, and many more. Python is known for its increased productivity because there is no compilation step, and the edit-test-debug cycle is fast. Debugging Python programs is easy; a wrong input will raise an exception.

Why Python?

The factors considered before deciding which language is the best for data analysis are speed, availability of packages, and design goal. By using Python, one has access to a significant number of packages. Python’s simplicity and easy-to-understand syntax rules help build applications with a concise, readable codebase. A few lines of code can achieve many tasks to achieve design goals. Considering these factors using Python can lead to faster data project completion.

Python is a popular language used often in data science for this ease of understanding and accessibility to various libraries that include functions of prewritten chunks of code that programmers can reutilize and optimize a task. The extensive range of libraries and tools makes it easy and efficient for data scientists to work with large datasets, manipulate data, and visualize results.

Python Libraries for Data Analysis

Data scientists use Python’s NumPy and Pandas libraries, commonly used for data manipulation tasks. They use Python’s Matplatlib and Seaborn libraries for data visualization. These are the few libraries that data scientists use provided by Python that make their work easier.

Data scientists use Python’s NumPy because it can support multi-dimensional arrays. The arrays in the NumPy library are enhanced for numerical operations, making them operate much faster and more efficiently when working with larger data sets. The library also is popular for machine learning applications, as it makes machine learning algorithms much more efficient and straightforward. NumPy is also designed to be compatible with other Python libraries.

Data scientists also use a Python library named Panda. Panda is used because of its robust data manipulation, analysis, and modeling tools. This library makes it easy to clean and preprocess data and transform data into different formats. It also has tools that help data scientists explore data and spot patterns. These tools help with exploring data, visualization, and filtering. Panda also has a flexible data manipulation API. Which makes it easier to slice, index, and filter data. Having this flexible API, manipulating data sets, and performing advanced operations is easy.

Another library scientists use is Matplotlib, commonly used for data visualization. This library has a set of tools that can create high-quality visualizations of data. They use this library to create visualizations to help spot patterns and trends when exploring data. Not only does this library analyze data, but they also use it to make a visualization to present data they are trying to share with others. These visualizations include line charts and bar charts.

Seaborn is another Python library that data scientists use for visualization. The Seaborn library has a high-level interface for creating informative visualizations. This library has a more charming visualization style, making the charts and graphs quickly look good without customizing them. Seaborn has a variety of visualizations that can be used for data exploration. Like Matplotlib, Seaborn uses line charts and bar charts for visualization. Seaborn tools help with regression analysis and hypothesis testing. The library also uses the Jupyter Notebook environment to allow data scientists to explore data in real time and create interactive dashboards for presenting data.

Takeaway

As our world is continuously filled with numerous databases, data science’s primary goal is to help handle this available data, analyze it, and visualize it to solve problems and make insightful decisions and predictions. For this to happen, data scientists need efficient tools to deal with these large datasets. Python is a crucial tool that supports data science to accomplish its goal. Because of the vast number of available libraries and packages, data science programmers can access many tools in their toolboxes. When working on projects, Python helps make the job easier and become more effective. This allows data scientists to save time to focus on the main problem. With the collaboration of the computing power of Python and data analysts, we can form solutions to several data-related issues and improve decision-making.

The greatest enemy in programming to all programmers is getting errors, and everyone has experienced getting errors when they run the code. Even the well-experienced programmer is still facing an error. Programming is a tricky and delicate thing to do when you need to be more careful.

Why are we getting an error? Well, humans and computers speak in different languages, and we humans are practicing these various types of computing languages to command these machines to do work for us. So, there might be some misunderstanding when we are controlling them, like computers don’t understand what we are trying to do because we didn’t use the correct block of code or didn’t specify what to output.

Coding errors could be typos, flawed logic, or accidental oversight; even those little ones can manifest and impact the whole program, depending on the type of error. So, here are some common types of programming errors.

2. What are considered common programming errors?

In the good old days, way before our understanding of programming and coding as it is today, getting errors could be truly disastrous. Good thing for us that all modern coding approaches and debugging systems make it a lot easier for us to fix these errors whenever we get one. Seven common programming errors are encountered frequently in programming. They are Runtime errors, Logic errors, Compilation errors, Syntax errors, Interface errors, Interface errors, and Arithmetic errors.

2.1. Runtime errors

Runtime errors are coding errors that show themselves when a user tries to run the program. It got an error because something confused the program and caused it to crash. Runtime errors are also known as execution errors.

For example, user instruction could be in the wrong order, pointing to a step that hasn’t even been declared yet, or the user might have asked the computer to do something that doesn’t have to do with anything before that code. The simplest example here is telling the computer to divide by zero, which could result in an error. Another typical example that could happen is when users interact with a program unexpectedly. Runtime errors are the kind of error that can impact users from achieving what they want from the code. Here are some common mistakes that users made that led to getting runtime errors.

● Misspelled or incorrectly capitalized variable and function names.

● Attempts to perform operations, for example, math operations on the data in which data types are string values.

● Dividing by zero

● Try to use a type conversion function on a value that can’t be converted to an int

In the following program about multiplying tax to the subtotal that the user has input, an error has occurred saying, “NameError: name ‘subT123otal’ is not defined. Did you mean: ‘subtotal’?” meaning ‘subT123otal’ can’t be defined because it wasn’t declared at the top. So, in this case, the user misspelled the variable when he reused it.

The following link will explain more types of runtime error examples and how to fix them.

2.2. Logic errors

Logical errors can be extremely frustrating since everything is fine with the code. They are the most difficult to fix because the program runs without crashing but outputs the incorrect result. The programmer didn’t type the code as he intended, so the program output the result that the programmer didn’t want.

It is caused by a mistake in the program’s logic. It is the hardest to fix because you don’t get the error message, no syntax or runtime error to alert you that you did something wrong. You will have to find out by looking back at your code.

Sometimes it’s nothing wrong with the Python implementation of an algorithm, but the algorithm itself can be incorrect; however, most of the logic errors are caused by the carelessness of the programmer. Did you know a logical error caused by a miscalculation between American and English units caused NASA to lose a spaceship in 1999? These are some examples of mistakes that lead to logical errors:

● Programmers use the wrong variable name

● Indenting block to the wrong level

● Using integer division instead of floating-point division

● Using the wrong formula, which leads to the wrong result

Suppose you misspell an identifier name or use the wrong variable name. In that case, you may get the runtime error if that misspelled variable doesn’t exist else. You will get the logic error if the misused one already exists, but you won’t get the error message, making things tricky and hard to detect.

The example above calculates the average of the two numbers the user enters. Still, because of how the order of operation is typed, the division evaluates before the addition, which is different from what we want. It should be (x+y)/2. Since it doesn’t mean an error to a program, it didn’t show any error message.

2.3. Syntax errors

Syntax errors have their own specialized rules, and when these rules are not followed and the programmer runs the code, a syntax error prevents the program from running. Python will find this error and exit your program without running anything. They are analogous to spelling or grammar mistakes like in English: “Have you the movie? “Which doesn’t make sense and missing a verb. Some of the standard Python syntax errors are

● Leaving out the keyword

● Putting a keyword in the wrong location

● Leaving out symbols such as commas or semicolons, or brackets

● Using the wrong indentation

● Empty block

In the following example, when the interpreter encounters invalid syntax in the program, it will raise a Syntax error and provide an error message with helpful information to the programmer, unlike a compilation error. In this case, you can see in line 4 a comma is missing at the end.

If you try to run the code, you will get the following error message saying invalid syntax and provide you with possible solutions like “Perhaps you forgot a comma?”

The following YouTube link has more examples of those three programming error types mentioned above. One of them is an example of syntax error.

Syntax, Runtime, and Logical Errors in Python

Can you spot the error? There are two errors you must fix for that code to run. Click the link and watch the video to see what the errors are.

2.4. Compilation errors

This error usually occurs when the code is built, but the program is failed to compile. If the code doesn’t compile, the program can’t be executed. The same as Logic errors and compile-time errors are a source of frustration to developers, especially when they have just started learning the language. Unlike Logic errors, you do get the error messages, but they are unclear and don’t mean anything useful.

Long story short, Compilation is converting a high-level coding language into a low-level coding language that is easier to understand by the system. While doing that process, an error occurs when the compiler can’t translate the high-level code into the lower-level one. Causing this prevents the program from being launched or tested.

These are the ten most common mistake happened in Java compile time errors:

● Java source file name mismatch

● Improper casting

● Mismatch brackets

● Missing semicolons

● Method is undefined

● Variable already defined

● Variable not initialized

● Type mismatch: cannot convert

● Return type required

● Unreachable code

One of them is mismatched brackets which is the cause of stress for programmers. We know that every open bracket in the code requires a matching closed frame, but sometimes a programmer needs to remember the closing brackets after writing the code inside, which leads to compile time error. For example, the picture below shows the opening bracket is missing at println.

So, when it compiles, it reports the following error message, which hardly tells what’s the problem.

Then when we put the missing open brackets to fix the problem, the error message goes away.

2.5. Interface errors

Most of the time, the program follows standards. If inputting of your program doesn’t conform to standards, you might get an interface error. These errors occur when there is a disconnection between what the programmer meant to be used and how it is used. An interface error might happen when you have an API that needs that specific parameter to be set, but those parameters are not established.

Besides being handled correctly, interface errors will look like an error from your side, but it’s from the caller’s side. This can lead to frustration from both parties. That’s why having clear documents and recording these errors to pass back to the caller is the best way to handle this. In this way, it will keep support costs down and keep your client happy.

If you didn’t record these errors and pass them back to the caller, they would end up like runtime errors in your error message.

2.6. Resource errors

A program can force the computer it’s running to attempt to allocate more processor power, ram, disk space, etc., than it has, which leads the program to crash or be bugged. Usually, the computer your program is running will allocate a certain number of resources. Still, sometimes your code forces the computer to try and allocate more resources than it has, resulting in resource errors.

If you accidentally write a loop that your code can never exit, like the one in the picture, you will eventually run out of resources on your computer. The loop will keep going for a while until it runs out of memory. Eventually, your computer will run out of memory. This type of error is hard to capture because the computer you are using can be high quality than the server running your codes, so it’s hard to replicate with your computer.

In this code in the picture above, a is set to 1 and put in the while loop where a is less than 10. Print that line and multiply a with 1, which will never be more than 1, and it keeps looping forever without exit.

After a certain amount of time and an infinite loop, your computer will have fewer memories and, eventually, run out.

2.7. Arithmetic errors

Arithmetic errors are just like logic errors but with mathematics. For example, some division equations may require the program to divide by 0, which is mathematically impossible. It results in an error that prevents the software from running correctly. As mentioned, arithmetic errors can generate logic or sometimes even runtime errors when dividing by 0. To stop that, having functional tests that include edge cases like 0 or negative numbers is an excellent way to prevent these errors.

The above picture shows an example of how arithmetic errors happen. The program tries to divide five by 0, which is mathematically impossible, and the program was told to print the answer. It turned out with an error message saying, “ZeroDivisionError: division by zero.”

3. Conclusion

Ultimately, we can’t escape from errors as long as we continue with programming projects. At some point, it is better to know these types of mistakes in advance so that when they appear in the future, you might learn a thing or two about them and can identify what type of error itis, which saves you time looking through everything on the internet. These are the seven most common errors in programming languages and their examples.

Branching is what allows the computer to make decisions and act intelligently. In programming, branching is when a program is split into two parts. The correct path is chosen based on a set condition. There are two types of branching: conditional and unconditional. Conditional branching statements rely on a condition to be met before making the code jump, and unconditional branching statements execute without a condition check. Generally, the main conditional branching statements revolve around using if, else-if, and else to specify required conditions. This tutorial will focus mainly on conditional branching statements.

Another way to describe branching is as any time a decision must be made. It is a common process in programming to execute different statements when certain conditions are met, and conditionals allow this to be done. Conditionals will only execute code if the condition stated by the programmer is true or false. The syntax “if”, “elif”, and “else” are used to denote a condition set by the programmer. These can be used in various combinations to create ladders and can even be placed inside each other to set more specific conditions.

Understanding the logic behind branching statements can be challenging at first, but knowing if a programmer desires to write productive and efficient code is a dire concept. Python is a language created for readability, which makes interpreting and using branching statements relatively easy. Each of the three branching statements can work together in any order, with the caveat that an “if” block must always be present first in a branching ladder.

The “if” Statement

First, let’s look at the most basic Statement, the “if” Statement. In programming, the “if” Statement has practically the same meaning as the English word “if”. An “if” Statement introduces a condition that may or may not be met, just like its use in English.

If I go to the store, I will buy coconut flakes.

In this sentence, the word “if” introduces the condition of going to the store. The second half of the sentence states what will happen if the condition is met: buying coconut flakes. In programming, the “if” Statement is used the same way and will generally have the following structure:

if condition == true:
Block of code

It is important to note that two equality symbols are used for logical equality.

Here is what some simple code may look like using an “if” Statement. For reference, the written code asks the user to enter a number; if that number is negative, it will print a statement.

Code:

num = int(input())
if num < 0:
print('The number is negative')
Output with input as "-6":
The number is negative

The program will output nothing in this code if a positive number is an input. Remember that computers are literal machines, doing only what you tell them to do. If the number is positive, there is no condition telling what the computer should do with that number. This new condition can be set with an “else” statement. This is the second type of branching statement and can only be used if an “if’ statement was present beforehand.

It is also important to mention that spacing and colons are crucial when coding in python. A colon is to be always used after a branching statement is used, and proper spacing must always be used before the condition (pressing the “tab” key once). If a colon is not used or spacing isn’t used where required, your code will output an error message.

The “else” Statement

Next, consider another branching statement, the “else” Statement. The “else” Statement tells what the computer is to do if the condition is not met. The computer will read code in order from top to bottom (unless told otherwise), and when it comes to a branch, it will evaluate whether the condition for the first “if” Statement is met. An “else” statement also has a similar meaning and use to the English word, hinting at its purpose. The following structure illustrates how it is to be used.

if condition == true:
Block of Code
else:
Block of Code

When writing simple branches, the “else” Statement can be thought of as another “if” Statement that evaluates if the condition from before is false. However, this becomes inaccurate when combining this information with “elif” statements. With this structure in mind, the computer will only evaluate the “else” portion only if all other conditionals evaluate as “false”.

Now that we know what an “else” Statement is and how to use it, we can optimize our code from before slightly to tell the computer what to do if the number input is positive:

Code:

num = int(input())
if num < 0:
print('The number is negative')
else:
print('The number is positive')
Output with input as "-6":
The number is negative
Output with input as "5":
The number is positive

The “elif” Statement

Finally, the third branching statement, “elif,” can be discussed. The first two branching statements may seem sufficient. However, just an “if” and “else” is not enough when one desires to set multiple conditions. This is where the “elif” statement can be used. The “elif” statement can theoretically be used an infinite number of times to set however many conditions are desired.

The unabbreviated name of “elif” is “else-if”, which may hint at its use. But it is different from an “else” statement because it can have a set condition. The computer evaluates an “elif” statement if and only if the original “if” condition is false.

When “elif” is used, its condition is checked only if the first “if” Statement evaluates as “false”.

if condition == true:
(Code evaluates as false)
elif second condition == true:
Block of code executes

Since the first condition was evaluated as false, the code began executing the second if condition, which was true. This would cause the code under the elif statement to execute.

It is important to note that “if” and “elif” have different meanings in a program and are used for specific situations. An “if” Statement cannot be used interchangeably with an “elif” statement, and vice versa. Using “elif” statements is often quicker than simply stacking many “if” statements.

Here is a graphic to help explain the connection between the three branching statements:

Combining “if”, “else”, and “elif” Statements in a Single Branch

Consider watching the following YouTube video for any clarifications on branching:

Now that all three main branching statements have been covered, it is appropriate to mention how they can all be combined into a single branch — using all three instead of repeated “if” statements is an excellent habit because using the trio is faster and more efficient to use in a program. This is because when “elif” and “else” are combined with an “if”, once the computer identifies the branch that satisfies the condition, it will automatically be taken and void the other statements.

Any combination of these statements can be made, but it is usually most efficient to use all three statements in a single branch. Below is the general flow and structure of an average branch in a program:

if condition == true:
Block of Code
elif second condition == true:
Block of Code
elif third condition == true:
Block of Code
else:
Block of Code

Notice that after a single “if” Statement is used, “elif” statements begin to be used following it.

Using this information, it is possible to continue to optimize the code for identifying the value of a number. Currently, entering anything other than an integer will cause the program to output an error. Using some “elif” statements, these problems can be fixed.

Code:

num = int(input())
if num < 0:
print('The number is negative')
elif num > 0:
print('The number is positive')
elif num == 0:
print('Zero is neither positive nor negative')
else:
print("Please input an integer")
Output with input as "3":
The number is positive
Output with input as "0":
Zero is neither positive nor negative
Output with input as "ABC":
Please input an integer

In addition to identifying the value of a number, the program now knows what to do if something other than an integer is entered. This program can be extended in many ways simply with more “elif” statements.

Nested “if” Statements

Furthermore, branching statements can be combined with other branching statements. In programming, this is known as a nested “if” Statement. This occurs when another branch is placed in the code of an original branch. This concept of “nesting” is prevalent in programming and used with other concepts and functions.

“If” statements are the most used way to make decisions. Because of this, they have the potential to be combined with almost any other programming function. Many times, branches will be placed inside other branches to create even more specific conditions for the desired output, and nested “if” statements have superb usability in Python and can easily simplify a task that may seem complex at first.

Here is how the general structure of a nested “if” Statement may look:

if condition == true:
if second condition == true:
Block of Code
else:
Block of Code
else:
Block of Code

In this code, the nested “if” will only be considered if the “if” condition above is true. Otherwise, the code will jump to the “else” Statement and disregard the nested if completely.

This technique is called a “control flow” and refers to using branches within each other. This concept of nesting does not apply only to branching statements and can be done with many different concepts like loops and user-defined functions. The video below may help you understand nested control flow statements:

Common Problems and Issues Encountered

Programming is a task of trial and error. It takes multiple attempts and time to determine what should be done to fix the bugs. Most likely, a program will not work as expected the first time around. Programming branching statements within code is no exception to this, and it takes time to learn how this job should be done.

Sometimes, the code is not working properly because the syntax needs to be written correctly. A beginner programmer may make this mistake multiple times and be frustrated as to why their program needs to be fixed. It is essential to pay attention to little details to ensure that branching statements are being written correctly. The most common mistake is forgetting to use two equal signs when setting a condition. Remember that the logical equality operator differs from the numerical equality operator, and misusing one will cause an error.

Additionally, forgetting to put colons after a branching statement will also cause an error. It is essential to ensure proper spacing before blocks of code beneath branching statements. All code under a branching statement requires the “tab” key to be pressed before typing. This applies to a nested “if” Statement as well.

Moving on from syntax typos, it is essential to understand that in an “if-elif-else” branch, the computer will disregard all other conditional statements as soon as something satisfies a condition. For example, in the code below, notice that “x” is more significant than both two and one. However, the code does not execute both conditionals, only the one that appeared first.

Code:

x = 7
if x > 1:
print('a')
elif x > 2:
print('b')
else:
print('c')
Output:
a

The program did not print out “b” or “c”, only “a” because it was the first condition that was satisfied. Note that if a programmer uses multiple “if” statements instead of an “if-elif-else” branch, then the program will individually check each “if” Statement instead of skipping all of them if it finds a satisfying condition. This is why an “if-elif-else” branch is computationally quicker than an “if-if-if” branch.

Takeaway

Branching is present in practically every program. Statistically, every fifth instruction in a program is a branch. Conditionals are the base decision maker and are usually the reason for the specific output of a program. There is a wide range of usages for conditionals, which can be combined with many other concepts in programming. Whenever a programmer needs a code to perform differently based on different interactions with the program, branching is used to achieve that. It is a process at the core of programming and must be adequately understood to have the ability to write more complex code.

Branching has seemingly endless possibilities for where it can be implemented and combined in infinite ways with other functions. Any developer, whether for the web or mobile apps, will be familiar with branching and conditionals since it is a core part of software development.

What are Python Libraries

As previously mentioned, a library within python is simply a collection of data. To be more specific, a library is a collection of files within Python called “Modules”, most of the modules you find within python are user created since python is an open-source programming language. There are many different types of libraries out in the world of python, with each library having its own specific purpose. For example one would use the library “OpenPyxl” or “Xlwings” to read/write data to Microsoft Excel, create macros for automating processes, or generate graphical user interfaces using python as a means to communicate with excels programming language “VBA”(Visual Basic Analysis). Although Python does have many user-created libraries, it does come with many existing libraries pre-installed when you download Python onto your computer, these are called “Python Standard Libraries”. These libraries have a wide variety of uses that a programmer could utilize in a multitude of situations. For example, one popular standard library is called “NumPy”, this stands for Numerical Python and is mainly used in mathematical computations. Whenever a user designs a program that needs to perform mathematical problem solutions such as machine learning, they use this library. One interesting fact is that libraries can also pull modules from other libraries, such is the case for a library called “TensorFlow”. This library is like NumPy in the aspect of complex mathematical problem-solving and machine learning, but the interesting thing about TensorFlow is that it actually imports modules from NumPy in order to perform some tasks.

Importing and using Libraries

In order for a programmer to use a library in their code they would need to first have that specific library downloaded and installed onto their computer. To do this a user will have to have python already downloaded onto their computer as a basic prerequisite and do one of two options. First, the user would have to open their command prompt and use a tool called “pip”, which is the pre-installed data package managing tool python uses to install new libraries that aren’t a part of the pre-installed python standard library. To install pip to install a library, the user would open their command prompt, and type in the command “py -m pip install” (Figure 1) followed by the name of the library they would want to download.

After this is complete the user would then have to open whatever IDE they plan to use and then proceed to import either that entire library into their program or segments of it known as modules (Figure 2) into their program. I personally tend to only download certain modules I need within that library. You can see in Figure 2 that I opened my PyCharm IDE and have imported the library “OpenPyxl” and a specific module within that library called “openpyxl.cell”.

The second method to install and import libraries within python would be to simply just do it through your IDE, in this scenario it is PyCharm specific. A user would open their IDE, type “import” followed by the name of the of the library you would like to import. If the library is installed onto the user’s computer already it will simply just import the library. But if the user doesn’t have the library installed prior, PyCharm will highlight the segment of text in red prompting the programmer to right click on it and select “install package” (Figure 3).

In this scenario you can see that I have gone into my PyCharm editor and typed in the command “Import Xlwings”, I did not have this library installed prior to this so the section of code was highlighted red. I then right clicked on the red highlight, and it is now prompting me to install that package.

Common Python Libraries

Two of the most common python libraries that have been widely popularized due to the easy-to-use artificial intelligence interfaces are known as Keras and Pytorch. Both of these libraries specialize in the creation of machine learning and artificial intelligence. They both utilize a series of large datasets and neural networks to help the AI learn and grow. A neural network is named after the human brain; this is because a neural network actually mimics the functionality of how neurons are fired within the human brain. At its heart, a neural network is a cluster of “nodes” that contain inputs, a setpoint, and an output, all nodes are intertwined together, and each node won’t activate unless the adjacent nodes setpoint triggers it to activate. theses libraries are simply popular because they are easy to use while creating these node datasets. Of the two Keras is the most popular option, Keras offers a more plug-and-play method of programming that newer programmers find less intimidating. This also allows for programs to be created, compiled, and executed faster than if programmed using Pytorch. Another feature that draws newer programmers to Keras is the fact that models within Keras are easier to export and manipulate, this saves time when initially developing the program you want to create. Pytorch on the other hand is more popular with more experienced programmers due to it being able to work with larger datasets and having more extensive debugging capabilities that make it easier for developers to go back and fix any errors they may find at a later time. Below is an example video on how exactly a user would set up and use tools within Keras.

Keras Library How-To Video

Lesser-Known Python Libraries

So far, we have covered what a generic definition of a library is within Python, how to install and use some of these libraries, and what some of the most common types of libraries are within Python. Now we will move on to some of the lesser-known libraries in Python, what their uses are, and how they could be just as useful as some of their more popular counterparts. One lesser-known python module is one called Tabulate. Tabulate is a library that allows users to manipulate tabular datasets within python. A tabular dataset could be a data frame, a list of lists or dictionaries, or even a dictionary itself. The interesting thing about tabulate is that it doesn’t manipulate the values of the data itself but rather manipulates the way in which the data is formatted. Tabulate presents all of the data in the form of a table! This makes presenting the data easier for the user to read and understand what is happening within the data. Here is an example of a neatly formatted tabulate table presenting a list of animals.

- — — — — — — — — — — — — — — — — — — — — — — — -

Jadzia Domestic Short Hair Female Stray

Gonzo German Shepherd Dog/Mix Male Stray

Maggie Shep Mix/Siberian Husky Female Stray

Pretty Girl Domestic Short Hair Female Stray

Pretty Girl Domestic Short Hair Female Stray

— — — — — — — — — — — — — — — — — — — — — — — -

Another lesser-known library is one called Numerizer, this library is used in order to generate text-based numerical entries within a table or data set into an actual integer or float data types. For example, if one were to type out the word seven, then use Numerizer, the library would read and decode that word and spit out an output of “7”. This could be useful if a programmer was developing and commissioning a sort and search program. Lastly, we have a library that could add a little bit of fun to a developer’s program called Emoji. Emoji is a library in Python that allows the developer to insert fun emoji images into the program that they are creating. This could be used in various types of games one would develop in python, maybe a programmer would like to give players a fun Easter egg within the game or add a bit of flare at the end of the game for a winning player or even assign different emoji images to identify different players within a game. Below is an example of what it would look like for a programmer to use Emoji to add emoji’s to a python program. Below is a how-to guide on how to use the Emoji Library in Python for further clarification.

Emoji How-To Video

Emoji Code Example

import emoji
rint(emoji.emojize(':koala:'))
rint(emoji.demojize(''))
rint(emoji.emojize(':rana:', language='it'))

Takeaway

We have learned an in-depth description of what libraries in python are. We have learned two ways to install libraries onto our computer to use in our programming: one using pip install and the other using the install tools directly built into PyCharm. We have also seen some images showing some uses of modules within Python. We have also gone over some of the most common libraries contained within Python such as Keras, Pytorch, Numpy, and TensorFlow to name a few. We have also covered some of the not-so-common libraries within python such as Tabulate for formatting data into tables for easier presentation, Numerizer which is used to convert string data types into integer or float point data types for search functions, and emoji which is a library used for fun more than it is for work, this library allows programmers to insert popular and fun emoji images into a program. Every library has its place and specific use, some libraries are similar to one another and some are very original but each one is no less useful than the other.