Python Functions That Add Items To Python Lists And Their Applications

In an earlier post, I discussed on how to remove items from python lists. Today, we will expand on the concept of lists and python list functions. We will be discussing on how to add items to python lists. In doing this, we are going to be using two functions, python’s append to list and python’s extend list functions. The two do the same job of adding objects to a list but they are not cousins. I mean, they are adding very different objects and use very different concepts.

 

First we will start by discussing the python append to list function.

Python append to list function.

The syntax for this function is list.append(x). What it says is that you are going to be adding an item, x, to the end of the list. When you call the python append list function and give it an argument, x, where x is an object, it just adds x to the end of the list. Any object can be added to the end of the list, even sequences, but they are added just as one item.

Let us give examples of the python append to list function.

You can see from running the code above that no matter the length of the object being appended or the nature of the object, it is treated as a single item. So, whenever you want to add to a list and you want to treat that object as a single item in the list, you should use the python append to list function.

Python extend list function.

The syntax of the python extend list function is list.extend(iterable). The function takes an iterable and what it does is that it iterates through each of the items in the iterable and adds them to the list. It mutates the original list based on the number of items in the argument; the python extend list function is acting like a concatenating of the original list. Therefore, you could say that while in the python append to list function the length of the list increases by 1, in the python extend list function the list increases by the number of items in the iterable.

A picture is worth a thousand words. So, let’s illustrate the concept using examples.

I used the same examples for both the python append to list and python extend list functions just to help you better understand their functionality. You could see that for the cases, the python extend list function gives lists of longer length.

These two python list functions are not the only way you can add items to a python list. There are overloaded methods we could also use.

Using overloaded operators to add to python lists.

Operator overloading or function overloading is when the same built-in operator like + or * have different behaviors for different objects or classes. You might have noticed this earlier in your python journey. For example, adding integers, 2 + 3, gives a different behavior for the + operator from adding strings, ‘mango’ + ‘banana’.

We will discuss how the + and += operators are used to add iterables to lists. They are both semantically similar to the python extend list function. When using either of them, the second object must be an iterable, otherwise python will return an error.

Here is some code to show how these overloaded operators work.

So you now have at your arsenal methods to add items to python lists.

Happy pythoning.

To cap it all, note that the worst case complexity of the python append to list function is O(1) i.e constant complexity while that of python extend list is O(k) where k is the length of the iterable that is being used to extend the original list.

From Carbon Dioxide To Liquid Fuel With New, Cheaper, Efficient, And Innovative Technique

Human activity has been impacting the environment in negative ways. The greenhouse effect which produces climate change due to the trapping of the sunlight energy in the atmosphere is caused by having extra carbon dioxide in the atmosphere which is not removed by the photosynthetic processes of green plants. These extra carbon dioxide causes global warming. Climate change mitigation, or actions to reduce the magnitude and rate of global warming, along with climate change mitigation strategies, are now very popular. Several approaches have been proposed to remove these extra carbon dioxide or what is called carbon sequestration. Today, we will focus on a new innovation that not only promises to help the environment, but is commercially viable.

Scientists at the U.S Department of Energy’s (D.O.E) Argonne National Laboratory in collaboration with Northern Illinois University have undertaken research that have realized a way to not only remove carbon dioxide from the environment, but to also break it down and use it to manufacture ethanol.

 

The discovery involves using catalysts, specifically electrocatalysts under low voltage. A catalyst is a substance that increases the rate of a chemical reaction without undergoing in the reaction itself and electrocatalysts are types of catalysts that function at electrode surfaces or they may be the electrode themselves. The electrocatalyst that was used by the researchers was copper, or atomically dispersed copper on carbon-powdered supports. These copper was used to break down trapped carbon-dioxide and water molecules and then these molecules were selectively reassembled into ethanol under an external electric field. When the efficiency was measured, it was found that the electrocatalytic selectivity process was 90 percent efficient, much better than existing techniques for converting carbon dioxide to ethanol. Furthermore, over extended periods of time it was found to operate under stable conditions at low voltages. The researchers also say that the costs for the process is also reasonable.

So one may ask: why convert carbon dioxide and water to ethanol? This is because ethanol is widely used in the U.S. It is used to produce gasoline and it is the chemical for many personal care and household products. Also, industries need ethanol to manufacture a host of products that provide lots of benefits to other industries and humans.

This is not the first time though that carbon dioxide will be converted into ethanol. But this method is more efficient and more cost-effective. Furthermore, the researchers say it is more stable than other previous methods. According to Tao Xu, a professor in physical chemistry and nanotechnology from Northern Illinois University, this process would open the doors to technology that would convert carbon dioxide electrocatalytically not only to ethanol, but to a vast array of other industrial chemicals.

So what are the benefits of removing carbon dioxide from the environment? The benefits are immense. Reusing carbon dioxide to manufacture ethanol would provide raw materials for industries making use of this ethanol at a cheaper cost. It reduces the increase in global temperatures. Presently, the world is working to make sure global temperatures do not exceed the two degrees Celsius mark. This approach will contribute its share. Also, greenhouse gases are being removed from the environment, helping to slow down climate change. Greta Thunberg, the Swedish teenage climate activist, would be happy to promote this technique. Also, since this approach has an efficient and reasonable cost, it will confer a lot of benefit to fossil fuel industries and alcohol fermentation plants who emit a lot of carbon dioxide annually into the atmosphere. They could derive some revenue by converting that carbon dioxide into ethanol. Furthermore, lots of jobs and career options would be created in the process in the U.S and around the world if this efficient technique is implemented.

The research has become successful that the researchers are in collaborative talks with industries to start producing ethanol. According to Di-Jia Liu, a senior chemist at Argonne’s Chemical Science and Engineering division, and one of the authors, they have plans to collaborate with industries in order to advance the promising technology. There are also plans to produce several other catalysts.

Material for this post was taken from Argonne National Laboratory press release.

From Zero To Hero In Handling Python Exceptions

No code is perfect. No matter how expert you are at programming, once in a while an error will occur. For beginners, this is more common. One area of errors that beginners encounter are syntax errors. These are errors that occur due to the fact that the programmer did not follow one of the rules of the language. In whatever IDE you are working with, syntax errors are usually highlighted so that the programmer can learn from them. We will not be talking about syntax errors in this post. Rather our focus will be on another type of error that occurs in programming, and that is exceptions.

 

Exceptions are errors that are detected during the execution of the program. They are different from syntax errors. They disrupt the normal operation of the program and tends to make the program produce results that are, though not fatal, unintended by the programmer. In python, there are standard ways of handling exceptions and we will discuss on those ways.

All exceptions in python have a type, and that type derives from a parent class, the BaseException class. If you go to the python documentation page on exceptions, you will realize that there are so many documented exceptions in python and ways to handle them. You can take a look at the various ones. But we will be discussing on only a representative few.

As we have said before, when a code contains lines that would cause unusual execution in the program, such as asking for a division by zero, an exception will be raised. When an exception is raised if it is not handled, python will ask the program to stop execution. Therefore, it is in our best interest to catch and handle exceptions if we want our programs to run to the end.

Let’s look at some examples of common exceptions you must have already encountered in your programs: ZeroDivisionError and IndexError.

A ZeroDivisionError is raised when the denominator for a division or modulus operation is zero. Because you cannot divide by zero, this is an error in the code that must have to be handled, otherwise python will stop execution of the program. If it is not handled, python will stop execution and print out a stack traceback report, indicating where the exception happened and the type of the exception. Let’s take an example to illustrate this. Just run the code below.

The code has a list of denominators we want to use to divide the numerator, 20. It runs well until the denominator becomes 0 and we run into an exception. Because the exception is not handled, python stops execution of the program and prints out a stack traceback of the exception so the programmer can understand where it occurred.

Now, let’s talk about the IndexError exception. IndexError exceptions are raised when a sequence subscript is out of range. Remember that the index for a sequence starts from zero to length of the sequence minus 1, so if we call for an index that is out of that range, an IndexError exception is raised. Here is an example.

When we called for the fourth fruit, it raised an error which was not handled and the program had to stop execution. Notice the message in the stack traceback. It gives the type of exception and what caused the exception to happen.

How to handle exceptions in python.

When you notice that a line of code might result in an error, you can handle it using that try…except…else…finally blocks. I will describe each of them in turn. But here is how they would be arranged in code.

try:
    # place relevant code that you expect
    # will result in an error here
except ExceptionErrorToCatch:
    # place code to handle the exception here
else:
    # place code for what to do after 
    # the code runs successfully at 
    # try block
finally:
    # place clean up code here 

The try block:

The try block is where you place the code that can raise an exception. More than one type of exception can occur at the try block but they can all be handled at the except block area.

The except block:

At the except block is where you place code that will handle the exception After the except statement you state the exception error that you want to handle or catch. It could be a ZeroDivisionError, IndexError, AttributeError etc. You just state it here. You could decide to handle all the exceptions separately and so this means you can write more than one except statement, but if you decide to use the same code to handle all the exceptions coming from the try statement, then you will denote the exceptions you are catching one after the other in a single except statement and separate them using a comma. For example, if your code will result in a ValueError or ZeroDivisonError, you could handle them in the following ways:

try:
    m = int(input()) #expect ValueError here
    n = 20/m         #Expect ZeroDivisionError here
except (ZeroDivisionError, ValueError):
    print('Exception handled here')    

You can see the both exceptions I was expecting were placed in a tuple. You use code like this to handle more than one exception at the same time. But if you want to handle each exception separately, you could use the code below:

try:
    m = int(input()) #expect ValueError here
    n = 20/m         #Expect ZeroDivisionError here
except ZeroDivisionError:
    print('ZeroDivisionError exception handled here')
except ValueError:
    print('ValueError exception handled here')        

Some people use a generic Exception clause when handling exceptions and I would encourage you not to do so. When handling exceptions be specific as to the type of exception you want to handle.

Note: when the statements in the try block are run, if no exception occurs, then the except block is not triggered, instead it is skipped. And that is when you come to the else block.

The else block:

In case you want to run some code if no exception was raised in the try blocks or statement, then you would use an else block to write the code. The else block continues execution when no exception was realized in the try statement. But if an exception is realized, python uses the except blocks to try to handle the exception. Here is some code that illustrates the use of the try…except…else statements. It will ask you to input a number of your choice when you run it.

Try running the above code with the following scenarios to see how the try…except…else statements with work. When the program asks for your input, first 1. Insert a zero to see how the exception will be handled. 2. Second, insert something that is not a number, like a string, ‘mmj’, to see how it handles the exception where something that is not a number is entered. 3. Enter a valid number to see what is printed out. You will notice that the code in the else block is executed when a valid number is entered.

Finally, there is a fourth block we have not discussed, the finally block.

The finally block.

The finally block is an optional block. It is used to clean up resources after the try block and other blocks have been run. No matter what happens in the code, whether an exception is raised or not, the finally block is called last before the program leaves the exception handling area. Note that if an exception occurs during the try block and it is not handled, python will re-raise the exception again after it has run the finally block. Exceptions can also sometimes occur during execution of the except clause, it will be re-raised again after the execution of the statements in the finally block.

Let’s demonstrate an example of how finally block can be used.

Try to run the scenarios again that I gave in the else paragraph to see how the finally block will be run. It is executed every time, whether an exception is raised or not. Whenever you are using up resources, or opening and writing to files, you use the finally block to do clean up of those resources.

The Arguments of an Exception:

Sometimes, we might want to retrieve the additional information that comes with the exception. That is when we supply the arguments variable when specifying the exception(s) in the except block. You state the arguments variable after specifying the name of the exception. In the code below, I used the keyword, as, to separate the exception name from the argument, I then referenced the argument in the exception handling code.

Raising an Exception

What if, as a programmer, you want to raise an exception when a condition is breached. For example, instead of waiting for python to detect the exception in the division by zero case above, you want to check if the user inputted zero yourself. You can raise an exception to handle that error yourself. You raise an exception by calling the raise statement like this: raise ExceptionName(argument). The argument could be optional.

Here is some example:

In line 3, I checked on the condition that the user entered 0 and if that is the case, I raised an exception which was handled by the except block in lines 5 and 6. Notice that I supplied an argument to the exception when I raised it and that argument was retrieved when the exception was handled for informative debugging. Try running the code above using two scenarios: 1. Enter 0 on input to see how it will run. 2. Enter a number on input to see how it skips the conditional in the try statement without raising an exception and goes to the else block. Please, don’t enter a non-number; I'm not handling that exception.

So, you have all you need to work with exceptions. I wish you get creative and start experimenting with them. In case you want further information on exceptions and how to handle them, you can reference the python documentation page on exceptions here.

5 Interesting Ways To Remove Items From A List.

In python, a list is an ordered sequence of elements that is mutable, or changeable. Each element in a list is called an item. Although the types of items in a list can vary, most times you will find that the items in a list are of the same type. You denote a list by having the items enclosed between []. The items in a list could be mutable or immutable data types like strings, integers, floats, or even lists themselves in a nested list structure.

 

Lists have several functions that could be used to operate on the items like adding items to a list, reversing the items in a list, and sorting the items in a list according to defined keys or order. In this post, we will be discussing five ways you can use to remove an item or items from a list.

The different ways are divided into two groups: removing a single item from the list and when you want to remove more than one item in a single operation.

Removing a single item.

In this section I will mention two ways you can use just to remove a single item. They are designed for just that.

list.remove(x):

The remove function is a function that comes with the list class in python. It is used to remove a single item, x, from the list and it does not return anything. It removes the first item, x, from the list even if there are more than one occurrence of the item in the list.

Now for some code to demonstrate it:

You can see that I asked the remove function to remove ‘mango’ from the list of fruits and it removed the first occurrence of the fruit, mango, leaving behind the second. If there is no item like mango in the list, remove function would have returned an error.

list.pop([i]):

This function gives you the ability to remove an item by index. Although you can remove only one item at a time, using the pop built-in function, you do not remove by value but by index in the list. And remember, the indices of lists in python starts from 0. In the syntax above, the item at index i is being removed from the list. If you do not specify an index to pop, it then removes the last item in the list thereby acting as a stack, i.e last in first out behavior. The function also returns the item you popped, giving you the added ability to reuse that item that was popped from the list.

Here is some code on the fruits list to demonstrate that.

You could experiment with removing items from a list you created yourself using any of the two functions above.

Now we will go on to methods that gives you the ability to remove more than one item in a single operation.

Ways to remove more than one item from a list.

These methods can remove a single item or more than one item in a single operation. I have catalogued three ways that this can be done, using both functions and programming logic.

del object_name[index]:

The del operator can be used to remove any object in python. It can act on lists and other types in python. Unlike the earlier two functions, the del operator can be used to remove a single item from a list or a slice of items provided they exist consecutively. It does not return anything. When using del on a list, you must specify the list index of the item you want to remove or the slice you want to remove.

Here is some code illustrating the operation of the del operator.

Notice that when I completely deleted the fruits list and tried to reference it again, it gave a NameError. Fruits list does not exist any longer after applying del operator to the object. So, you can see that the del operator is a powerful tool. Use it at your discretion.

Using slicing logic to delete items:

We can use the concept of the slice operator, just as we used for the del operator above, to remove specific items from a list. I find this cumbersome sometimes but I need to add it here. A slice can be denoted as list_name[start:stop:step]. The stop and step are optional but if you don’t specify step, step defaults to 1, and if you don’t specify stop and step, what it gives you is a value, the item, and not a list, but we need to have a list back in this operation, so we will be specifying both the start and stop.

Here is some code.

Now, let’s move on to the last method for removing more than one item from a list. It involves using programming logic and list comprehension.

Programming logic method:

In this method, which I use often, you just move through the list and filter out the item you don’t need. That's all. I use list comprehension to do it, but you can also use for loop if you don’t understand list comprehension.

For those of you who don’t understand list comprehension, here is the same logic using a for loop. But list comprehension is more preferred because it looks more beautiful.

The for loop took four lines while list comprehension took only one line. Grrrh!

That’s all folks. I hope I have given you ideas on how you can remove items from your lists.

Happy pythoning.

The Secrets Of Random Numbers In Python – The Number Guessing Game Part 2

Yesterday, we explained in depth some of the functions that are included in the random module in python. Today, we will be applying that knowledge to build a simple guessing game. This is how the game goes.

The computer will think of a random number between 1 and 20 inclusive and ask the player to guess it. The player has 6 tries to guess it right. For each guess, the computer will tell the player if the guess is too high, too low, or the correct guess. After 6 tries, if the player has not correctly guessed the number, the game will end.

 

Interesting, not so? Well, here is the code for the game.

Now, let’s explain the code line by line so you understand what is going on.

Line 1: To use the random number functions, we have to import the random module. So, that is what this does.

Line 3: using the random.randint function with arguments 1, 20, we are asking the computer to generate a random number between 1 and 20. Simple. I believe you understood this line.

Lines 4-7: The computer asks the player to input his or her name, initializes num_guesses, the counter we use to calculate how many guesses the player has made so far, and sets the guessed_right switch to False to indicate that the player hasn’t made the right guess yet.

Line 9: Using a while loop, we wait for the player to make at most 6 guesses until he guesses the number right or fails to guess it right. Now, here comes the interesting parts after this line.

Lines 10-28: This is the main logic of the game and it occurs inside the while loop. First the computer informs the player of how many guesses have been made so far and asks him or her to make a guess. We use a try-except-else clause to catch the guess entered. If the player enters a guess that is not a number, such as a float or string, that is an error and the program catches it as an error and penalizes the player for the error by increasing the number of guesses made by 1. But if the player enters a number, it skips through the try-except block and goes to the else block which starts at line 16. From here on we are checking to see what number the player entered. The first conditional checks for whether the number is within the acceptable range. If it is not, the program asks the player to enter a number within the acceptable range and penalizes him by increasing the guess count by 1. The next elif blocks checks if the number, which is within the range for acceptable numbers, is too low or too high. If either of these, the number of guesses count is increased by 1. But if these two are skipped that means the player guessed the right number and the guessed_right switch is set to True. The program then breaks out of the while loop.

Elegant! Not to mention beautiful.

Lines 30-33: This is the cleaning up code. Here after the loop exits the program checks whether the player guessed right or not. If he or she guessed right, the program prints a congratulatory message and tells him how many guesses he took. But if the player guessed wrongly, the program encourages the player to try again and then tells the player what the number was.

You could write your own code that implements the functions in the random module. It is a really useful module. I wish you success in doing so.

You can download the script for the game here if you want to run it on your own machine.

The Secrets Of Random Numbers In Python Part 1

 

When people think of random numbers, they think of something disorganized and that cannot be predicted. That is what I thought until I entered the world of random numbers using python. You see, random numbers do not just run arbitrarily. The name is deceptive. They are based on what are called seeds. A seed can either be provided by the programmer, and if one is not provided, python uses the system clock or what is supplied by the operating system.

If you decide to set the random number generator rather than allow the program to initialize it on its own, you call the random.seed function, supplying it with a seed that you desire. The seed has to be an int. This could be done using the code:

As you can see from running the above code where we gave the random function the same seed, the same output was produced consecutively. That is why the random function is deceptive. Why it is really random is because since the programmer most times does not provide a seed but allows it to self-generate, the random number becomes really random.

By the way, the disclaimer from the makers of the python programming language is that the functions in the random module should not be used in cryptography.

Now let’s take a ride on some of the functions included in the random module.

The functions are divided into functions that manipulate integers, sequences, and real-valued distributions. We will concentrate on the first two in this article.

What are the functions that manipulate integers.

The two functions in the random module that manipulate integers are random.randint and random.randrange. They both do the same thing. They return an integer based on a given range. The differences between them is that in random.randint the second positional argument is included in the range of numbers to be considered, while in random.randrange the range to consider stops just before the second positional argument. The syntax for both of them is random.randint(a, b) and random.randrange(start, stop[, step]). For random.randrange the stop is not included in the range that is to be considered, while in random.randint the last positional argument, b, is considered in the range to be considered. Also, note that you could step through random.randrange using the step argument. For example, you could leave out some numbers in a range using step, just as you can do using the in-built range function.

Overall, both of them serves the same function: give a random integer from a given range and conditions.

If you run the code below, you will be sure to get a random integer between 1 and 20 inclusive.

What are the functions that manipulate sequences.

The functions for manipulating sequences are four in number and they sometimes overlap. I will describe each of them and give code you can run.

random.choice(sequence):

This function returns a random element from sequence provided sequence has items in it otherwise it will raise an IndexError. I think this is simple enough. Now, the code.

Each time you run the code above, it will give you a chosen fruit. There are repeats too. So, don’t be surprised because the list of fruits is not exhaustive.

random.choices(population, weights=None, *, cum_weights=None, k=1):

This function returns a list of size k (default is 1, note) from the population which could be a sequence or a range. If you do not want to apply any probability to the items that would be returned in the list, then you would leave weights and cum_weights keyword arguments alone. But if you want to give some weight or assign probabilities to what can be chosen at random, you have to provide value for weights or cumulative weight, cum_weights. Using the list from above, let us give higher probability to apple and orange using the keyword argument, weights=[5,5,5,15,15]. I will also tell the code to chose just two items from the list of fruits at random.

If you run the code, you will see that you will have a high probability of having orange and apple in the returned list rather than the other fruits. One point to note is that weights cannot be negative.

random.shuffle(x[, random]):

This function takes as argument a sequence, x, and shuffles the items in place. You can provide an optional random function that could be used to shuffle the items. I think this is well explained using code. I will provide code that does not use the random function and one that does.

This code does not use the random function.

Each time you run it, it randomly rearranges the items in the list.

Now this one uses a random function. I want you to run it more than one time and notice the arrangement of the items.

Did you notice that the rand_function acted as a seed to the random.shuffle function? Each time it runs, it returns the list of items in the same sequence. Very cool! You can play with it. Note that the random function can be any function that returns a floating point number between 0.0 and 1.0. I used 0.09.

Now for the last function that manipulates sequences.

random.sample(population, k):

This function is used for random sampling without replacement. It returns a list of size k from the population. It is similar to the choices function but without the weights and without replacement. In random.choices, the returned list can have repeated items but not in random.sample. Now for some code.

Run the above code repeatedly and see. The sample size, k, should not be larger than the population size otherwise python will raise a ValueError.

You can use this function to generate a random list of integers from a very large sample size using the range function as the population argument using code like this: random.sample(range(1000000), 100). Very cool and very efficient.

So, that is the secret to the random function. Now that you have learned what it is and how to use it, why don’t we play with it a little.

Tomorrow, I am going to post a little game that uses the random function. So, make sure to watch out for the game.

Happy pythoning.