Quick recipes for the master caster

Now that you know a few things about objects. I thought I throw out a few suggestions on how to use that knowledge in a practical way. So this is just a quick post to show you how to do some clever things with the knowledge you already have. I also want to introduce the idea of “type casting”. Type casting in Python means exactly the opposite of what it means in acting. When you “cast” an object, you change its type from one thing to another. Meaning you can change a float object to an int object, or an int object to a string object, a string to a list, and so on. Not all object types are interchangeable, although you can usually find a circuitous path to get an object of one type to another if you try hard enough.

Python has built in functions for converting between object types making casting really easy to do. The functions work as follows:

<proposed object type>(<object>)

Check out the image below for some examples of casting objects from one type to another.

As you can see, I began with an integer type object. I then converted it to a new float object. I then created a new string object from the float, followed by a list from the string. Float objects and Int objects can’t be converted to a list, but strings can because they are the same style object (collection/sequence). So in order to convert my Int to a list I first have to convert it to a string then convert the string to the list. Note, in the above example I assigned the converted objects to new variables. I did this because type casting is non-destructive, meaning that even when I assign b equal to float(a), the new object b is a float but object a is still an int.

So here is a list of the conversion functions for the objects you know so far and the types of objects that each conversion will accept.

Casting Function	Accepted Object Types
int() – Integer cast	Float objects, String objects (must only have numeric characters, meaning no decimals, letters or special characters) It is possible to convert letter characters to int objects using the int() cast function, but it involves using non-base ten numbering systems which I won’t go into here.
float() – Float cast	Int objects, String objects (must only have numeric characters and one or less decimal points, no letters or special characters) Float cast accepts numbers and strings. The string can have a decimal but doesn’t have to, so ‘500’ and ‘500.0’ are ok. ‘50.0.0’ will not work.
str() – String cast	Any object. Any object can be converted to a string, though the results might not always be easily intelligible.
list() – List cast	Any ‘iterable’ object. List() cast accepts any ‘collection’ style object, including strings and tuples.
tuple() – Tuple cast	Any ‘iterable’ object. Tuple() cast accepts any ‘collection’ style object, including strings and lists.

So what can we do with this information? I’ll demonstrate a few bits of code that use some of the list functions I discussed in my last post and some type casting to do common programming tasks.

Finding an average value

If you have a list of numbers, but the length of the list might be different from time to time, you can find the average of the numbers in the list with a single line of code. For example, if I have a list myList = [5,7,2,100,3,1,1,23] I can find the average with the following line:

sum(myList) / float(len(myList))

Notice what happens when I don’t use the float() cast function. Remember, when a calculation is performed on two integers, an integer is returned. Averages are rarely integer values so in this case, we cast one of the values in the equation to a float type object in order to force the resulting value to have floating point precision. We could have also done the following:

float(sum(myList)) / len(myList)

Regardless of the side that we cast to float the outcome will be the same. If we don’t cast either side to a float object then we are performing an int divided by int calculation, which will produce an int result.

Rounding a float to the nearest integer

When you cast a float object to an int the decimal value of the float is just dropped. So 9.9 and 9.000001 both become 9. If you want to round a float to the nearest integer ( meaning a number with a decimal value of .5 or greater will be rounded up to the next highest integer ) you can do the following:

int(<float object> + 0.5)

This bit of code will cause 9.9 to be 10.4 prior to the integer cast and 9.000001 to be 9.500001. So 9.9 will be truncated to 10 and 9.000001 will be truncated to 9.