Published

2025-03-31

Open In Colab

Lists and Tuples

Now we’ll look a bit more at lists and introduce tuples - basically an immutable list.

Recall our plan as we go through our common data types: - Learn how to create - Consider commonly used functions and methods - See control flow and other tricks along the way

Note: These types of webpages are built from Jupyter notebooks (.ipynb files). You can access your own versions of them by clicking here. It is highly recommended that you go through and run the notebooks yourself, modifying and rerunning things where you’d like!

Properties of lists and tuples:

Both are: - One-dimensional
- Heterogenous
- Have an ordering (starting at 0) - Can have duplicate values

A few differences:

  • lists are mutable but tuples are not (cannot be modified)
  • lists take up more memory

Lists

Constructing a List

Earlier we saw there were four ways to construct lists (although we didn’t go through them all) - [element1, element2] - list((element1, element2, ...)) - an empty list and use the .append() method to add elements - list comprehensions

Constructing a list from and empty list

  • Create an empty list and use the append method to add elements
mylist = []
# or
mylist = list()
  • Add elements with .append()
mylist.append("Dog")
mylist.append("Cat")
mylist
['Dog', 'Cat']

Constructing a List using []

  • Create an empty list and use the append method to add elements
  • Often used with a for loop
animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
mylist = []

for x in animals:
    if "o" in x:
        mylist.append(x)

mylist
['Dog', 'Horse', 'Frog', 'Cow', 'Buffalo', 'Fox', 'Racoon']

Constructing a list using list comprehensions

  • Rather than write the loop out, you can use list comprehensions (shorthand!)

  • The general syntax for list comprehensions is:

    [expression for member in iterable]

  • Let’s do a quick example. First, the for loop way:

animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
mylist = []
for x in animals:
    mylist.append(x)
  • Now, we can do the same thing with shorthand!
mylist = [x for x in animals] #for x in animals, return x (essentially)
mylist
['Dog',
 'Cat',
 'Horse',
 'Frog',
 'Cow',
 'Buffalo',
 'Deer',
 'Fish',
 'Bird',
 'Fox',
 'Racoon']

  • You can do more complicated things with list comprehensions as well. For instance, we can include condition logic.

    [expression for member in iterable (if conditional)]

  • First the for loop way:

animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
for x in animals:
    if "o" in x:
        mylist.append(x)
  • Now using a list comprehension:
mylist = [x for x in animals if "o" in x]
mylist
['Dog', 'Horse', 'Frog', 'Cow', 'Buffalo', 'Fox', 'Racoon']
  • We can also modify the thing that gets put into the loop. Check out this example where we upper case the string.
  • First the for loop way:
animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
mylist = []

for x in animals:
    if "o" in x:
        mylist.append(x.upper()) #upper case prior to appending

mylist
['DOG', 'HORSE', 'FROG', 'COW', 'BUFFALO', 'FOX', 'RACOON']
  • Now using a list comprehension:
mylist = [x.upper() for x in animals if "o" in x]
mylist
['DOG', 'HORSE', 'FROG', 'COW', 'BUFFALO', 'FOX', 'RACOON']

Reminder About Strings

  • Strings are a sequence type object (so you can iterate over them naturally)
mylist = []
for x in "Man do I love learning all this python!":
    if x in "aeiou":
        mylist.append(x)
mylist
['a', 'o', 'o', 'e', 'e', 'a', 'i', 'a', 'i', 'o']
  • That means we can do something like the for loop above using list comprehensions!
mylist = [x for x in "Man do I love learning all this python!" if x in "aeiou"]
mylist
['a', 'o', 'o', 'e', 'e', 'a', 'i', 'a', 'i', 'o']

List Operations (Indexing & Slicing)

Recall:

  • Index with a [] (just like strings)
  • Counting starts at 0
x = [10, 15, 10, 100, "Help!"]
x[0]
10
x[1]
15
x[-1]
'Help!'
  • Multiple elements at once with :
  • Remember the last number isn’t included and the counting starts at 0
    • :2 is really giving you 0 and 1
x[:2]
[10, 15]
x[1:]
[15, 10, 100, 'Help!']
x[1:3]
[15, 10]
x[1:4:2]
[15, 100]

Lists are Mutable

  • That is, we can replace or change elements of a list
x = [10, 15, 10, 100, "Help!"]
x[0] = 11
x
[11, 15, 10, 100, 'Help!']
x[1] = ["hi", "ho"]
x
[11, ['hi', 'ho'], 10, 100, 'Help!']
x[1:3] = [1, 2]
x
[11, 1, 2, 100, 'Help!']

List Methods

Many useful methods to modify lists:

  • mylist.append(object_to_add)
x = [x for x in range(1,10)]
y = [y for y in "abcde"]
x.append(y) #modifies x
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, ['a', 'b', 'c', 'd', 'e']]
  • mylist.extend(object_to_add)
x = [x for x in range(1,10)]
y = [y for y in "abcde"]
x.extend(y) #modifies x and iterates over list elements rather than appending a list into x
x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e']
  • Using + is similar but doesn’t overwrite x
x + y
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e']
  • mylist.insert(index, object_to_add)
y = [y for y in "abcde"]
y.insert(2, 30) #modifies y
y
['a', 'b', 30, 'c', 'd', 'e']
  • mylist.remove(element_to_remove)
y.remove("d") #modifies y
y
['a', 'b', 30, 'c', 'e']
  • mylist.count(value)
w = [x for x in range(0, 4)] * 4
print(w)
w.count(1) #count the number of times 1 occurs
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
4
  • mylist.index(value)
v = [y for y in "abcde"]
v.extend(["z", "y"] * 3)
print(v)
print(v.index("y")) #get the index corresponding to the first 'y'
print(v.index("y", v.index("y") + 1)) #index corresponding to second 'y'
['a', 'b', 'c', 'd', 'e', 'z', 'y', 'z', 'y', 'z', 'y']
6
8

List Packing & Unpacking

  • We can pack a list. That is, put a bunch of values in a list in one line of code.
animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
short_animals = animals[:3]

#pack the values first, second, and third
first, second, third = short_animals
print(first + " " + second + " " + third)
Dog Cat Horse
  • We can also pack leftover elements into a list using *name
first, second, third, *other = animals
print(first + " " + second + " " + third)
print(other)
Dog Cat Horse
['Frog', 'Cow', 'Buffalo', 'Deer', 'Fish', 'Bird', 'Fox', 'Racoon']
  • You can pack in different orders as well!
animals = ["Dog", "Cat", "Horse", "Frog", "Cow", "Buffalo", "Deer", "Fish", "Bird", "Fox", "Racoon"]
*other, second_last, last = animals
print(other)
print(second_last + " " + last)
['Dog', 'Cat', 'Horse', 'Frog', 'Cow', 'Buffalo', 'Deer', 'Fish', 'Bird']
Fox Racoon
  • If we want to ignore some of the values we can use our _ temporary variable with packing and *:
first, *_, last = animals
print(first + " " + last)
Dog Racoon
  • Later we’ll look at unpacking a list when calling functions
def my_fun(a, b, c):
    print(a, b, c)

fav_animals = ["cat", "dog", "cow"]
my_fun(*fav_animals)
cat dog cow

Tuples

Tuples are very similar to lists but aren’t mutable

Constructing Tuples

  • We create by separating elements with a ,, ( ), or tuple(())
tup1 = 3, 10, "word", True
tup1
(3, 10, 'word', True)
tup2 = (1, 2, "word", False)
tup2
(1, 2, 'word', False)
tup3 = tuple((tup1, tup2))
tup3
((3, 10, 'word', True), (1, 2, 'word', False))
tup4 = tup1 + tup2 #like other sequence type objects we can concatenate them with +
tup4
(3, 10, 'word', True, 1, 2, 'word', False)
tup5 = (1, [1, 3])
tup5
(1, [1, 3])
tup5 * 3
(1, [1, 3], 1, [1, 3], 1, [1, 3])

One interesting thing is that although we can’t modify the tuple, we can modify mutable elements within the tuple!

tup5[1][1] = 5
tup5
(1, [1, 5])

Constructing Tuples from list comprehensions

  • To populate a tuple we can wrap a list comprehension with tuple()
y = [x for x in range(1, 10)]
y = tuple(y)
y
(1, 2, 3, 4, 5, 6, 7, 8, 9)
  • Can sort of edit a tuple by switching it between a list and a tuple… but this isn’t really editing it!
y = list(y)
y.append("new element")
y = tuple(y)
y
(1, 2, 3, 4, 5, 6, 7, 8, 9, 'new element')

Tuple Operations & Methods

As with strings and lists:

  • We can index and slice using [:]

  • Concatenate with + and *

  • Some similar functions like len() and count()

  • Some similar methods like .index() and .count()

  • Can do packing and unpacking

Video Demo

This quick video demo shows an example of creating lists with the map() function and utilizing the zip() function for iterating over multiple lists at the same time. Remember to pop the video out into the full player.

The notebook written in the video is available here.

from IPython.display import IFrame
IFrame(src="https://ncsu.hosted.panopto.com/Panopto/Pages/Embed.aspx?id=6e745cc1-fb2c-4941-8a97-b0f800efe933&autoplay=false&offerviewer=true&showtitle=true&showbrand=true&captions=false&interactivity=all", height="405", width="720")

Recap

  • Lists and tuples are very similar

    • Heterogenous elements
    • Sequence type objects
    • Ordering (counting starts at 0)
    • Index with []

  • Lists are mutable but tuples are not

  • List comprehensions are a common quick way to populate a list

If you are on the course website, use the table of contents on the left or the arrows at the bottom of this page to navigate to the next learning material!

If you are on Google Colab, head back to our course website for our next lesson!