Python Data Structures: Lists, Tuples and Sets

Sequences

sentence = "I always lose at least one sock when I do laundry." 
words = sentence.split()
words

['I',
 'always',
 'lose',
 'at',
 'least',
 'one',
 'sock',
 'when',
 'I',
 'do',
 'laundry.']

sentence.split("e")

['I always los', ' at l', 'ast on', ' sock wh', 'n I do laundry.']

In the last section, we discussed the string (str) data type.

We described it as a sequence of characters. In many cases, there is good reason to split up a long text string into separate ones. Luckily, we have a convenient verb to do that .split().

This verb then splits up the string into separate words.

We can change where to split the string as well.

This argument uses the character “e” to separate the string and discards the separator.

Why is it returned in square brackets, though?

Lists

words

['I',
 'always',
 'lose',
 'at',
 'least',
 'one',
 'sock',
 'when',
 'I',
 'do',
 'laundry.']

type(words)

list

my_list = [1.2, 3, None, True, 'One of the lost socks']
my_list

[1.2, 3, None, True, 'One of the lost socks']

The output from the .split() verb is called a list.

Similarly to how a string is a sequence of characters in order, a list is a sequence of elements with a particular order.

Lists can be identified by their square brackets.

The elements in a list can be any objects, and they don’t all need to have the same type.

lists_of_lists = [[1,2], ['buckle', 'My', 'Shoe'], 3, 4]
lists_of_lists

[[1, 2], ['buckle', 'My', 'Shoe'], 3, 4]

my_list = [1.2, 3, None, True, 'One of the lost socks']
len(my_list)

5

len(lists_of_lists)

4

Lists can even have more lists as elements.

We can get the length of a list with len() like we did for strings.

Note that if your list contains lists, len() will return the number of elements in the outer list (not the total number of elements).

my_list

[1.2, 3, None, True, 'One of the lost socks']

my_list[1]

3

my_list[1:3]

[3, None]

Similarly to how we can slice dataframes by columns and rows, we can slice lists by elements.

Slicing lists is similar to slicing with iloc[]; the start is inclusive, and the end is exclusive.

So my_list[1:3] fetches elements 1 and 2, but not 3.

In other words, it gets the 2nd and 3rd elements in the list.

Mutable vs Immutable

my_list

[1.2, 3, None, True, 'One of the lost socks']

my_list[2] = "Ta Da!"

my_list

[1.2, 3, 'Ta Da!', True, 'One of the lost socks']

Next, we’ll talk about mutable and immutable data types.

An object is mutable if it can be modified.

Lists are mutable, and we can assign new values for their various entries.

For example, we can edit any entry in this list and replace it with a new value.

lists_of_lists

[[1, 2], ['buckle', 'My', 'Shoe'], 3, 4]

lists_of_lists[1][2] = "Sandal"
lists_of_lists

[[1, 2], ['buckle', 'My', 'Sandal'], 3, 4]

We can also replace entries in a nested list (a list within a list). Here, we’re first taking element 1 of list_of_lists, which gets us the inner list. We’re then setting element 2 of that inner list to the value “Sandal”.

sentence

'I always lose at least one sock when I do laundry.'

sentence[27:35]

'sock whe'

sentence[5] = "Z"

TypeError: 'str' object does not support item assignment

Detailed traceback: 
  File "<string>", line 1, in <module>

Strings can be sliced, just like lists.

But we cannot replace characters - if we try, we get an error.

That means values of type str are immutable.

List Verbs

primes = [2,3,5,7,11]

primes.append(13)
primes

[2, 3, 5, 7, 11, 13]

max(primes)

13

sum(primes)

41

Lists have a variety of different methods for interacting with their data. Here are just a few.

We can add to the end of a list with append(). Notice how we didn’t need to write prime = and overwrite the prime object, because append modified primes directly.

We can find the maximum value in the list with max().

And the sum of the list with sum().

Lists to Dataframes

	item	location	price
0	toothpaste	London Drugs	3.99
1	apples	Produce Store	4.00
2	bread	Bakery	3.50

item1 = ['toothpaste', 'London Drugs', 3.99]
item2 = ['apples', 'Produce Store', 4.00]
item3 = ['bread', 'Bakery', 3.50]
column_names = ['item', 'location', 'price']

shopping_items = pd.DataFrame(data=[item1, item2, item3], columns=column_names)
shopping_items

	item	location	price
0	toothpaste	London Drugs	3.99
1	apples	Produce Store	4.00
2	bread	Bakery	3.50

type(shopping_items)

pandas.core.frame.DataFrame

Up until this point, we have been working with dataframes that have been read in and converted from different types of files.

However, we can also make dataframes from scratch using lists.

Let’s say we wanted a dataframe of things we needed to purchase from the store on our next grocery shopping trip, as shown in the table here.

We can use a list for each row and a list for the column labels. We then use another list of all the rows to make up the data.

Now the shopping items are no longer in a structure type list, but in a type DataFrame.

Tuples

my_tuple = ('I', 'lose', None,  'socks', 'when', 1, 'do', 'laundry.', False)
my_tuple

('I', 'lose', None, 'socks', 'when', 1, 'do', 'laundry.', False)

type(my_tuple)

tuple

Tuples are a data structure very similar to lists but with two main differences:

1. They are represented with parentheses instead of square brackets, and
2. They are immutable

my_tuple

('I', 'lose', None, 'socks', 'when', 1, 'do', 'laundry.', False)

my_tuple[2] = 'Many'

TypeError: 'tuple' object does not support item assignment

Detailed traceback: 
  File "<string>", line 1, in <module>

my_list = list(my_tuple)
type(my_list)

list

Just to recap, immutable means that the elements within the structure cannot be changed.

We can still cast objects from type tuple into type list by using the verb list().

Sets

my_set = {2, 1.0, 'Buckle my shoe'}
my_set

{1.0, 2, 'Buckle my shoe'}

my_set = {2, 1.0, 'Buckle my shoe', 1.0, 2}
my_set

{1.0, 2, 'Buckle my shoe'}

Sets, not unlike lists and tuples, are a data structure that contains elements. Sets differ from lists and tuples in that:

• They are unordered, meaning there is no element 0 and element 1, and
  
• The values contained are unique - meaning there are no duplicate entries.

Let’s explore this a bit.

Sets are made with curly brackets.

You’ll notice that the printed order is not the same as we inputted then in. That’s because sets do not preserve order.

If we have repeats of any entries, they only occur once in the set. This is useful if you want to keep track of a set of things, like who visited a store, and you’re not interested in repeat entries.

my_set

{1.0, 2, 'Buckle my shoe'}

my_set[1]

TypeError: 'set' object is not subscriptable

Detailed traceback: 
  File "<string>", line 1, in <module>

my_set.add(3)
my_set.add(4)
my_set

{1.0, 2, 3, 4, 'Buckle my shoe'}

Can we select a specific element?

Remember, this data structure does not preserve order, so Python displays them according to some internal sorting scheme.

We cannot select or slice from them. However, we can add to them with .add() (meaning that sets are mutable!).

You’ll notice that unlike lists, the new entries are not added to the end of the structure.

All Together Now

Data Structure	preserves order	Mutable	Symbol	Can contain duplicates
str	✓	☓	'' or ""	✓
list	✓	✓	[]	✓
tuple	✓	☓	()	✓
set	☓	✓	{}	☓

We have condensed the data structures characteristics into a convenient table for you.

Let’s apply what we learned!