Strings

The first data type we will learn about is the string. You may not have heard the word string used in this context before, but a string is basically text and it is denoted by using quotes. Strings can contain numbers, letters, and symbols.

These are all strings:

'cat'
'This is a string.'
'5'
'walking'
'$GOObarBaz340   '

If you enter each of those values into your Python interpreter, the interpreter will return them back to you. The program is saying, “Hey, I heard you. You said, 'cat' (or whatever you entered).”

The content of a string doesn’t matter as long as it is between matching quotes, which can be either single or double quotes. You must begin and end the string with the same quote (either single or double):

'cat'
"cat"

Both of these examples mean the same thing to Python. In both cases, Python will return 'cat', with single quotes. Some folks use single quotes by convention in their code, and others prefer double quotes. Whichever you use, the main thing is to be consistent in your style. Personally, we prefer single quotes because double quotes require us to hold down the Shift key. Single quotes let us be lazy.

Integers and Floats

The second and third data types we are going to learn about are integers and floats, which are how you handle numbers in Python. Let’s begin with integers.

10
1
0
-1
-10

5
'5'

5 == '5'

'02108'
02108

2
2.0

2/3

2.0/3

0.3
0.1 + 0.2

from decimal import getcontext, Decimal
getcontext().prec = 1
Decimal(0.1) + Decimal(0.2)

from decimal import getcontext, Decimal     
getcontext().prec = 1                       
Decimal(0.1) + Decimal(0.2)                 

String Methods: Things Strings Can Do

Let’s use our initial variable, filename. Originally, we defined the variable using filename = 'budget.csv'. That was pretty convenient. Sometimes, though, things are not so convenient. Let’s go through a few examples:

filename = 'budget.csv        '

You’ll notice our filename string now has a lot of extra spaces we probably need to strip off. We can use the Python string’s strip method, a built-in function that removes unnecessary whitespace from the beginning and end of a string:

filename = 'budget.csv        '
filename = filename.strip()

If you enter filename in your Python interpreter, you should now see the spaces have been stripped off.

Let’s say our filename needs to be in all capital letters. We can transform all the letters to uppercase using the Python string’s built-in upper method:

filename = 'budget.csv'
filename.upper()

Your output should now show that we have properly uppercased the filename:

'BUDGET.CSV'

In this case, we did not reassign the uppercase string to the variable filename. What happens when you call filename in your interpreter again? The output should still read 'budget.csv'. If you don’t want to modify your variable but want to transform it for one-time use, you can call methods like upper, as they will return the modified string without changing the underlying variable.

What if we wanted to reassign the variable by storing the return value using the same variable name? In the following, we are changing the value of the filename variable to be uppercase:

filename = 'budget.csv'         
filename = filename.upper()     

If you call filename after this line, the output will be 'budget.csv'.

If you call filename after this line, the output will be 'BUDGET.CSV'.

We could condense this code to run on one line:

filename = 'budget.csv'.upper()

The number of lines you use for your code is sometimes a matter of personal style or preference. Make choices that make sense to you but keep your code clear, easy to read, and obvious.

We only covered two string methods in these examples, strip and upper, but there are many other built-in string methods. We will learn more about these methods as we work with strings in our data wrangling.

Numerical Methods: Things Numbers Can Do

Integers and floats/decimals are mathematical objects. If you enter 40 + 2, Python returns 42. If you want to store the answer in a variable, you assign it to a variable just as we did in the string examples:

answer = 40 + 2

Now, if you type answer, you will get 42 in return. Most of the things you can do with integers are pretty predictable, but there may be some special formatting you need to use so your Python interpreter understands the math you want to perform. For example, if you wanted to square 42, then you would enter 42**2.

Integers, floats, and decimals also have many other methods, some of which we will encounter as we learn about data wrangling.

List Methods: Things Lists Can Do

There are a few must-know methods for lists. Let’s start with an empty list and use a method to add values to it.

First, define an empty list like so:

dog_names = []

If you enter dog_names into your interpreter, it will return [], Python’s way of showing an empty list. Earlier in the chapter, we had a bunch of names stored in that variable, but we redefined it in the last line so now it is an empty list. The built-in append method adds items to the list. Let’s use it now and add “Joker” to the list:

dog_names.append('Joker')

Now, if you enter dog_names, your list will return one item: ['Joker'].

On your own, build out the list using the append method until you have a list that looks like this:

['Joker', 'Simon', 'Ellie', 'Lishka', 'Turtle']

Let’s say you accidentally added 'Walter', one of the cat names:

dog_names.append('Walter')

You can remove it with the Python list’s built-in remove method:

dog_names.remove('Walter')

While there are many more built-in methods for lists, append and remove are among the most commonly used.

Dictionary Methods: Things Dictionaries Can Do

To learn some useful dictionary methods, let’s build our dictionary of animal counts from scratch.

In the next example, we create an empty dictionary. Then, we add a key and define the value of that key:

animal_counts = {}
animal_counts['horses'] = 1

Adding an object to a dictionary (animal_counts['horses']) is a little different from adding an object to a list. This is because a dictionary has both a key and a value. The key in this case is 'horses' and the value is 1.

Let’s define the rest of the dictionary with our animal counts:

animal_counts['cats'] = 2
animal_counts['dogs'] = 5
animal_counts['snakes'] = 0

Now when you type animal_counts in your Python interpreter, you should get the following dictionary: {'horses': 1, 'cats': 2, 'dogs': 5, 'snakes': 0}. (Since Python dictionaries don’t store order, your output might look different but should contain the same keys and values.)

We are working with a very small example, but programming is not always so convenient. Imagine a dictionary of animal counts for all domesticated animals in the world. As the programmer, we might not know all of the different types of animal this animal_counts dictionary holds. When handling a large and unknown dictionary, we can use dictionary methods to tell us more about it. The following command returns all the keys the dictionary holds:

animal_counts.keys()

If you have been following along with the exercises, if you type this in your interpreter will return a list of keys that looks like this:

['horses', 'cats', 'dogs', 'snakes']

You can take any of those keys and retrieve the value associated with it from the dictionary. The following lookup will return the number of dogs:

animal_counts['dogs']

The output for this line is 5.

If you wanted to, you could save that value in a new variable so you don’t have to look it up again:

dogs = animal_counts['dogs']

Now, if you enter the variable dogs directly, Python will return 5.

Those are some of the basic things you can do with a dictionary. Just like with strings and lists, we will learn more about dictionaries as we apply more complex problems to our code.

type

type will help you identify what kind of data type your object is. To do this in your Python code, wrap the variable in type()—for example, if the variable name is dogs, then you would enter type(dogs) into the Python prompt. This is extremely helpful when you are using a variable to hold data and need to know what type of data is in the variable. Consider the zip code example from earlier in the chapter.

Here, we have two different uses for the value 20011. In the first case, it is a zip code stored as a string. In the second case, it is an integer:

'20011'
20011

If those values were stored in variables, they would be further obscured and we might not know or remember whether we used a string or an integer.

If we pass the value to the built-in method type, then Python will tell us what kind of data type the object is. Try it:

type('20011')
type(20011)

The first line returns str. The second line returns int. What happens when you pass a list to type? And a variable?

Identifying the type of an object can be very helpful when you are trying to troubleshoot an error or work with someone else’s code. Remember when we tried to subtract a list from another list (in “Addition and Subtraction”)? Well, you cannot subtract a string from a string either. So, the string '20011' has very different possible methods and use cases than the integer 20011.

dir

dir will help you identify all the things a particular data type can do, by returning a list of built-in methods and properties. Let’s try it out with the string 'cat,dog,horse':

dir('cat,dog,horse')

For now, ignore everything at the beginning of the returned list (the strings starting with double underscores). These are internal or private methods Python uses.

The methods that are most useful are contained in the second part of the returned list output. Many of these methods are obvious, or self-documenting. You should see some of the methods we used on strings earlier in this chapter:

 [...,
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '_formatter_field_name_split',
 '_formatter_parser',
 'capitalize',
 'center',
 'count',
 'decode',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'index',
 'isalnum',
 'isalpha',
 'isdigit',
 'islower',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

If you look at the string 'cat,dog,horse', it looks like it is a list saved in a string. It’s actually a single value, but with the Python string’s built-in split method we can divide the string into smaller pieces by splitting it on the comma character, like so:

'cat,dog,horse'.split(',')

Python will return a list:

['cat', 'dog', 'horse']

Now let’s call the dir method on our list:

dir(['cat', 'dog', 'horse'])

There are not as many options as for strings, but let’s try a few. First, let’s turn the list into a variable. You should know how to assign the list to a variable by now, but here’s an example:

animals = ['cat', 'dog', 'horse']

Now, let’s try some new methods we found using dir on a list with our variable animals:

animals.reverse()
animals.sort()

After you run each of those lines, print out the value of animals so you can see how the the method has modified the list. What output did you expect? Was it the same that you saw? Try using the dir method on integers and floats. (Hint: dir expects you to pass only one object, so try dir(1) or dir(3.0)). Are there methods you didn’t expect?

As you can see, dir gives you insight into the built-in methods for each Python data type; these methods can prove valuable when wrangling data using Python. We recommend taking time to experiment with the listed methods that interest you and testing more methods with different data types.

help

The third helpful built-in Python method we will review in this chapter is the help method. This method will return the documentation for an object, method, or module—although it is often written in a very technical (sometimes cryptic) manner. Let’s review the help for the split method we used in the previous section. If you didn’t know you needed to put the character you wanted to split the string on inside the parentheses, how would you know what the Python string’s split method expected? Let’s pretend we didn’t know how to use split and called it without passing ',':

animals = 'cat,dog,horse'
animals.split()

This code returns the following:

['cat,dog,horse']

Looks good, right? Not upon closer inspection. As we can see, Python took our string and put it into a list, but didn’t split the words into pieces using the commas. This is because the built-in split method defaults to splitting the string on spaces, not commas. We have to tell Python to split on the commas by passing a comma string (',') into the method.

To help us understand how the method works, let’s pass it to help. First, we have to redefine our animals variable, because we turned it into a list. Let’s turn it back into a string, then look up how split works:

animals = 'cat,dog,horse'
help(animals.split) 

This line passes animals.split—without the ()—to the help method. You can pass any object, method, or module to the help method, but as seen here, you should not include the end parentheses when passing methods.

Python returns the following:

split(...)
    S.split([sep [,maxsplit]]) -> list of strings

    Return a list of the words in the string S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are removed
    from the result.

The first line of the description reads: S.split([sep [,maxsplit]]) → list of strings. In English, this tells us that for a string (S) we have a method (split) with a first possible argument (a.k.a. thing we can pass), sep, and a second possible argument, maxsplit. The square brackets ([]) around the argument names indicate that they are optional, not mandatory. This method returns (->) a list of strings.

The following line reads: "Return a list of the words in the string S, using sep as the delimiter string." sep is an argument passed to the split method that is used as a separator. A delimiter is a character or series of characters used to separate fields. For example, in a comma-delimited file, the comma is the delimiter. The comma is also the delimiter in the string we created, as it separates the words we want in our list.

The help description also tells us that spaces, or whitespace, are the default delimiter if no other delimiter is specified. This tells us that if we had a string 'cat dog horse' the split method would not require us to pass a delimiter inside the (). As you can see, the built-in help method can teach you a lot about what a method expects you to use and whether it’s a good fit for the problem you are solving.