Learn Python in One Day and Learn It Well (2015)

Chapter 4: Data Types in Python

In this chapter, we’ll first look at some basic data types in Python, specifically the integer, float and string. Next, we’ll explore the concept of type casting. Finally, we’ll discuss three more advanced data types in Python: the list, tuple and dictionary.

Integers

Integers are numbers with no decimal parts, such as -5, -4, -3, 0, 5, 7 etc.

To declare an integer in Python, simply write variableName = initial value

Example:

userAge = 20, mobileNumber = 12398724

Float

Float refers to numbers that have decimal parts, such as 1.234, -0.023, 12.01.

To declare a float in Python, we write variableName = initial value

Example:

userHeight = 1.82, userWeight = 67.2

String

String refers to text.

To declare a string, you can either use variableName = ‘initial value’ (single quotes) or variableName = “initial value” (double quotes)

Example:

userName = ‘Peter’, userSpouseName = “Janet”, userAge = ‘30’

In the last example, because we wrote userAge = ‘30’, userAge is a string. In contrast, if you wrote userAge = 30 (without quotes), userAge is an integer.

We can combine multiple substrings by using the concatenate sign (+). For instance, “Peter” + “Lee” is equivalent to the string “PeterLee”.

Built-In String Functions

Python includes a number of built-in functions to manipulate strings. A function is simply a block of reusable code that performs a certain task. We’ll discuss functions in greater depth in Chapter 7.

An example of a function available in Python is the upper() method for strings. You use it to capitalize all the letters in a string. For instance, ‘Peter’.upper() will give us the string “PETER”. You can refer to Appendix A for more examples and sample codes on how to use Python’s built-in string methods.
 

Formatting Strings using the % Operator

Strings can also be formatted using the % operator. This gives you greater control over how you want your string to be displayed and stored. The syntax for using the % operator is

“string to be formatted” %(values or variables to be inserted into string, separated by commas)

There are three parts to this syntax. First we write the string to be formatted in quotes. Next we write the % symbol. Finally, we have a pair of round brackets ( ) within which we write the values or variables to be inserted into the string. This round brackets with values inside is actually known as a tuple, a data type that we’ll cover in the chapter later.

Type the following code in IDLE and run it.

brand = ‘Apple’

exchangeRate = 1.235235245

message = ‘The price of this %s laptop is %d USD and the exchange rate is %4.2f USD to 1 EUR’ %(brand, 1299, exchangeRate)

print (message)

In the example above, the string ‘The price of this %s laptop is %d USD and the exchange rate is %4.2f USD to 1 EUR’ is the string that we want to format. We use the %s, %d and %4.2f formatters as placeholders in the string.

These placeholders will be replaced with the variable brand, the value 1299 and the variable exchangeRate respectively, as indicated in the round brackets. If we run the code, we’ll get the output below.

The price of this Apple laptop is 1299 USD and the exchange rate is 1.24 USD to 1 EUR

The %s formatter is used to represent a string (“Apple” in this case) while the %d formatter represents an integer (1299). If we want to add spaces before an integer, we can add a number between % and d to indicate the desired length of the string. For instance“%5d” %(123) will give us “ 123” (with 2 spaces in front and a total length of 5).

The %f formatter is used to format floats (numbers with decimals). Here we format it as %4.2f where 4 refers to the total length and 2 refers to 2 decimal places. If we want to add spaces before the number, we can format is as %7.2f, which will give us “ 1.24”(with 2 decimal places, 3 spaces in front and a total length of 7).

Formatting Strings using the format() method

In addition to using the % operator to format strings, Python also provides us with the format() method to format strings. The syntax is

“string to be formatted”.format(values or variables to be inserted into string, separated by commas)

When we use the format method, we do not use %s, %f or %d as placeholders. Instead we use curly brackets, like this:

message = ‘The price of this {0:s} laptop is {1:d} USD and the exchange rate is {2:4.2f} USD to 1 EUR’.format(‘Apple’, 1299, 1.235235245)

Inside the curly bracket, we first write the position of the parameter to use, followed by a colon. After the colon, we write the formatter. There should not be any spaces within the curly brackets.

When we write format(‘Apple’, 1299, 1.235235245), we are passing in three parameters to the format() method. Parameters are data that the method needs in order to perform its task. The parameters are ‘Apple’, 1299 and 1.235235245.

The parameter ‘Apple’ has a position of 0,

1299 has a position of 1 and

1.235235245 has a position of 2.

Positions always start from ZERO.

When we write {0:s}, we are asking the interpreter to replace {0:s} with the parameter in position 0 and that it is a string (because the formatter is ‘s’).

When we write {1:d}, we are referring to the parameter in position 1, which is an integer (formatter is d).

When we write {2:4.2f}, we are referring to the parameter in position 2, which is a float and we want it to be formatted with 2 decimal places and a total length of 4 (formatter is 4.2f).

If we print message, we’ll get

The price of this Apple laptop is 1299 USD and the exchange rate is 1.24 USD to 1 EUR

Note: If you do not want to format the string, you can simply write

message = ‘The price of this {} laptop is {} USD and the exchange rate is {} USD to 1 EUR’.format(‘Apple’, 1299, 1.235235245)

Here we do not have to specify the position of the parameters. The interpreter will replace the curly brackets based on the order of the parameters provided. We’ll get

The price of this Apple laptop is 1299 USD and the exchange rate is 1.235235245 USD to 1 EUR

The format() method can be kind of confusing to beginners. In fact, string formatting can be more fanciful than what we’ve covered here, but what we’ve covered is sufficient for most purposes. To get a better understanding of the format() method, try the following program.

message1 = ‘{0} is easier than {1}’.format(‘Python’, ‘Java’)

message2 = ‘{1} is easier than {0}’.format(‘Python’, ‘Java’)

message3 = ‘{:10.2f} and {:d}’.format(1.234234234, 12)

message4 = ‘{}’.format(1.234234234)

print (message1)

#You’ll get ‘Python is easier than Java’

print (message2)

#You’ll get ‘Java is easier than Python’

print (message3)

#You’ll get ‘ 1.23 and 12’

#You do not need to indicate the positions of the parameters.

print (message4)

#You’ll get 1.234234234. No formatting is done.

You can use the Python Shell to experiment with the format() method. Try typing in various strings and see what you get.

Type Casting In Python

Sometimes in our program, it is necessary for us to convert from one data type to another, such as from an integer to a string. This is known as type casting.

There are three built-in functions in Python that allow us to do type casting. These are the int(), float(), and str() functions.

The int() function in Python takes in a float or an appropriate string and converts it to an integer. To change a float to an integer, we can type int(5.712987). We’ll get 5 as the result (anything after the decimal point is removed). To change a string to an integer, we can type int (“4”) and we’ll get 4. However, we cannot type int (“Hello”) or int (“4.22321”). We’ll get an error in both cases.

The float() function takes in an integer or an appropriate string and changes it to a float. For instance, if we type float(2) or float(“2”), we’ll get 2.0. If we type float(“2.09109”), we’ll get 2.09109 which is a float and not a string since the quotation marks are removed.

The str() function on the other hand converts an integer or a float to a string. For instance, if we type str(2.1), we’ll get “2.1”.

Now that we’ve covered the three basic data types in Python and their casting, let’s move on to the more advanced data types.

List

List refers to a collection of data which are normally related. Instead of storing these data as separate variables, we can store them as a list. For instance, suppose our program needs to store the age of 5 users. Instead of storing them as user1Age, user2Age,user3Age, user4Age and user5Age, it makes more sense to store them as a list.

To declare a list, you write listName = [initial values]. Note that we use square brackets [ ] when declaring a list. Multiple values are separated by a comma.

Example:

userAge = [21, 22, 23, 24, 25]

We can also declare a list without assigning any initial values to it. We simply write listName = []. What we have now is an empty list with no items in it. We have to use the append() method mentioned below to add items to the list.

Individual values in the list are accessible by their indexes, and indexes always start from ZERO, not 1. This is a common practice in almost all programming languages, such as C and Java. Hence the first value has an index of 0, the next has an index of 1 and so forth. For instance, userAge[0] = 21, userAge[1] = 22

Alternatively, you can access the values of a list from the back. The last item in the list has an index of -1, the second last has an index of -2 and so forth. Hence, userAge[-1] = 25, userAge[-2] = 24.

You can assign a list, or part of it, to a variable. If you write userAge2 = userAge, the variable userAge2 becomes [21, 22, 23, 24, 25].

If you write userAge3 = userAge[2:4], you are assigning items with index 2 to index 4-1 from the list userAge to the list userAge3. In other words, userAge3 = [23, 24].

The notation 2:4 is known as a slice. Whenever we use the slice notation in Python, the item at the start index is always included, but the item at the end is always excluded. Hence the notation 2:4 refers to items from index 2 to index 4-1 (i.e. index 3), which is whyuserAge3 = [23, 24] and not [23, 24, 25].

The slice notation includes a third number known as the stepper. If we write userAge4 = userAge[1:5:2], we will get a sub list consisting of every second number from index 1 to index 5-1 because the stepper is 2. Hence, userAge4 = [22, 24].

In addition, slice notations have useful defaults. The default for the first number is zero, and the default for the second number is size of the list being sliced. For instance, userAge[ :4] gives you values from index 0 to index 4-1 while userAge[1: ] gives you values from index 1 to index 5-1 (since the size of userAge is 5, i.e. userAge has 5 items).


To modify items in a list, we write listName[index of item to be modified] = new value. For instance, if you want to modify the second item, you write userAge[1] = 5. Your list becomes userAge = [21, 5, 23, 24, 25]

To add items, you use the append() function. For instance, if you write userAge.append(99), you add the value 99 to the end of the list. Your list is now userAge = [21, 5, 23, 24, 25, 99]

To remove items, you write del listName[index of item to be deleted]. For instance, if you write del userAge[2], your list now becomes userAge = [21, 5, 24, 25, 99] (the third item is deleted)

To fully appreciate the workings of a list, try running the following program.

#declaring the list, list elements can be of different data types

myList = [1, 2, 3, 4, 5, “Hello”]      

#print the entire list.

print(myList)                              

#You’ll get [1, 2, 3, 4, 5, “Hello”]

#print the third item (recall: Index starts from zero).

print(myList[2])                        

#You’ll get 3

#print the last item.

print(myList[-1])      

#You’ll get “Hello”

#assign myList (from index 1 to 4) to myList2 and print myList2

myList2 = myList[1:5]

print (myList2)

#You’ll get [2, 3, 4, 5]

#modify the second item in myList and print the updated list

myList[1] = 20

print(myList)                              

#You’ll get [1, 20, 3, 4, 5, 'Hello']

#append a new item to myList and print the updated list

myList.append(“How are you”)            

print(myList)                              

#You’ll get [1, 20, 3, 4, 5, 'Hello', 'How are you']

#remove the sixth item from myList and print the updated list

del myList[5]                              

print(myList)            

#You’ll get [1, 20, 3, 4, 5, 'How are you']

There are a couple more things that you can do with a list. For sample codes and more examples on working with a list, refer to Appendix B.

Tuple

Tuples are just like lists, but you cannot modify their values. The initial values are the values that will stay for the rest of the program. An example where tuples are useful is when your program needs to store the names of the months of the year.

To declare a tuple, you write tupleName = (initial values). Notice that we use round brackets ( ) when declaring a tuple. Multiple values are separated by a comma.

Example:

monthsOfYear = (“Jan”, “Feb”, “Mar”, “Apr”, “May”, “Jun”, “Jul”, “Aug”, “Sep”, “Oct”, “Nov”, “Dec”)

You access the individual values of a tuple using their indexes, just like with a list.

Hence, monthsOfYear[0] = “Jan”, monthsOfYear[-1] = “Dec”.

For more examples of what you can do with a tuple, check out Appendix C.

Dictionary

Dictionary is a collection of related data PAIRS. For instance, if we want to store the username and age of 5 users, we can store them in a dictionary.

To declare a dictionary, you write dictionaryName = {dictionary key : data}, with the requirement that dictionary keys must be unique (within one dictionary). That is, you cannot declare a dictionary like this 
myDictionary = {“Peter”:38, “John”:51, “Peter”:13}.

This is because “Peter” is used as the dictionary key twice. Note that we use curly brackets { } when declaring a dictionary. Multiple pairs are separated by a comma.

Example:

userNameAndAge = {“Peter”:38, “John”:51, “Alex”:13, “Alvin”:“Not Available”}

You can also declare a dictionary using the dict( ) method. To declare the userNameAndAge dictionary above, you write

userNameAndAge = dict(Peter = 38, John = 51, Alex = 13, Alvin = “Not Available”)

When you use this method to declare a dictionary, you use round brackets ( ) instead of curly brackets { } and you do not put quotation marks for the dictionary keys.

To access individual items in the dictionary, we use the dictionary key, which is the first value in the {dictionary key : data} pair. For instance, to get John’s age, you write userNameAndAge[“John”]. You’ll get the value 51.

To modify items in a dictionary, we write dictionaryName[dictionary key of item to be modified] = new data. For instance, to modify the “John”:51 pair, we write userNameAndAge[“John”] = 21. Our dictionary now becomesuserNameAndAge = {“Peter”:38, “John”:21, “Alex”:13, “Alvin”:“Not Available”}.

We can also declare a dictionary without assigning any initial values to it. We simply write dictionaryName = { }. What we have now is an empty dictionary with no items in it.

To add items to a dictionary, we write dictionaryName[dictionary key] = data. For instance, if we want to add “Joe”:40 to our dictionary, we write userNameAndAge[“Joe”] = 40. Our dictionary now becomes userNameAndAge = {“Peter”:38, “John”:21, “Alex”:13, “Alvin”:“Not Available”, “Joe”:40}

To remove items from a dictionary, we write del dictionaryName[dictionary key]. For instance, to remove the “Alex”:13 pair, we write del userNameAndAge[“Alex”]. Our dictionary now becomes userNameAndAge = {“Peter”:38, “John”:21, “Alvin”:“Not Available”, “Joe”:40}

Run the following program to see all these in action.

#declaring the dictionary, dictionary keys and data can be of different data types

myDict = {“One”:1.35, 2.5:”Two Point Five”, 3:”+”, 7.9:2}

#print the entire dictionary

print(myDict)                              

#You’ll get {2.5: 'Two Point Five', 3: '+', 'One': 1.35, 7.9: 2}

#Note that items in a dictionary are not stored in the same order as the way you declare them.

#print the item with key = “One”.

print(myDict[“One”])                        

#You’ll get 1.35

#print the item with key = 7.9.

print(myDict[7.9])      

#You’ll get 2

#modify the item with key = 2.5 and print the updated dictionary

myDict[2.5] = “Two and a Half”

print(myDict)                              

#You’ll get {2.5: 'Two and a Half', 3: '+', 'One': 1.35, 7.9: 2}

#add a new item and print the updated dictionary

myDict[“New item”] = “I’m new”            

print(myDict)                              

#You’ll get {'New item': 'I’m new', 2.5: 'Two and a Half', 3: '+', 'One': 1.35, 7.9: 2}

#remove the item with key = “One” and print the updated dictionary

del myDict[“One”]                              

print(myDict)      

#You’ll get {'New item': 'I’m new', 2.5: 'Two and a Half', 3: '+', 7.9: 2}

For more examples and sample codes of working with a dictionary, you can refer to Appendix D.