Creating Lists in Python

In many situations, you’ll define alist object using aliteral. A list literal is a comma-separated sequence of objects enclosed in square brackets:

>>>countries=["United States","Canada","Poland","Germany","Austria"]>>>countries['United States', 'Canada', 'Poland', 'Germany', 'Austria']

In this example, you create a list of countries represented by string objects. Because lists are ordered sequences, the values retain the insertion order.

Alternatively, you can create new lists using thelist()constructor:

>>>digits=list(range(10))>>>digits[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In this example, you use thelist() constructor to define a list of digits using arange object. In general,list() can convert any iterable to a list.

That means that you can also use it to convert a tuple into a list:

>>>list((1,2,3))[1, 2, 3]

You can also create newlist objects usinglist comprehensions. For example, the following comprehension builds a list of even digits:

>>>even_digits=[numberfornumberinrange(1,10)ifnumber%2==0]>>>even_digits[2, 4, 6, 8]

List comprehensions are powerful tools for creating lists in Python. You’ll often find them in Python code that runs transformations over sequences of data.

Finally, to create an empty list, you can use either an empty pair of square brackets or thelist() constructor without arguments:

>>>[][]>>>list()[]

The first approach is arguably the most efficient and most commonly used. However, the second approach can be more explicit and readable in some situations.

Creating Tuples in Python

Similar to lists, you’ll often create new tuples using literals. Here’s a short example showing a tuple definition:

>>>connection=("localhost","8080",3,"database.db")>>>connection('localhost', '8080', 3, 'database.db')

In this example, you create a tuple containing the parameters for a database connection. The data includes the server name, port, timeout, and database name.

Strictly speaking, to define a tuple, you don’t need the parentheses. The comma-separated sequence will be enough:

>>>contact="John Doe","john@example.com","55-555-5555">>>contact('John Doe', 'john@example.com', '55-555-5555')

In practice, you can define tuples without using a pair of parentheses. However, using the parentheses is a common practice because it improves the readability of your code.

Because the parentheses are optional, to define a single-item tuple, you need to use a comma:

>>>t=(2,)>>>type(t)<class 'tuple'>>>>t=(2)>>>type(t)<class 'int'>

In the first example, you create a tuple containing a single value by appending a comma after the value. In the second example, you use the parentheses without the comma. In this case, you create an integer value instead of a tuple.

You can also create new tuples using thetuple() constructor:

>>>tuple(range(10))(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

In this example, you create a list of digits usingtuple(). This way of creating tuples can be helpful when you’re working withiterators and need to convert them into tuples.

For example, you can convert a list into a tuple using thetuple() constructor:

>>>tuple([1,2,3])(1, 2, 3)

Finally, to create empty tuples, you can use a pair of parentheses or calltuple() without arguments:

>>>()()>>>tuple()()

The first approach is a common way to create empty tuples. However, usingtuple() can be more explicit and readable.

Lists and Tuples Are Ordered Sequences

List and tuples are ordered sequences of objects. The order in which you insert the objects when you create a list or tuple is an innate characteristic. This order remains the same for that list or tuple’s lifetime:

>>>["mango","orange","apple"]['mango', 'orange', 'apple']>>>("Jane",25,"Norway")('Jane', 25, 'Norway')

In these examples, you can confirm that the order of items in lists and tuples is the same order you define when creating the list or tuple.

Lists and Tuples Can Contain Arbitrary Objects

Lists and tuples can contain any Python objects. The elements of a list or tuple can all be the same type:

>>>[1,2,3,4,5][1, 2, 3, 4, 5]>>>(1,2,3,4,5)(1, 2, 3, 4, 5)

In these examples, you create a list of integer numbers and then a tuple of similar objects. In both cases, the contained objects have the same data type. So, they’re homogeneous.

The elements of a list or tuple can also be of heterogeneous data types:

>>>["Pythonista",7,False,3.14159]['Pythonista', 7, False, 3.14159]>>>("Pythonista",7,False,3.14159)('Pythonista', 7, False, 3.14159)

Here, your list and tuple contain objects of different types, including strings, integers, Booleans, and floats. So, your list and tuple are heterogeneous.

Lists and tuples can even contain objects like functions, classes, and modules:

>>>int<class 'int'>>>>len<built-in function len>>>>deffunc():...pass...>>>func<function func at 0x1053abec0>>>>importmath>>>math<module 'math' from '.../math.cpython-312-darwin.so'>>>>[int,len,func,math][    <class 'int'>,    <built-in function len>,    <function func at 0x1053abec0>,    <module 'math' from '.../math.cpython-312-darwin.so'>]>>>(int,len,func,math)(    <class 'int'>,    <built-in function len>,    <function func at 0x1053abec0>,    <module 'math' from '.../math.cpython-312-darwin.so'>)

In these examples, the list and the tuple contain a class,built-in function, customfunction, and module objects.

Lists and tuples can contain any number of objects, from zero to as many as your computer’s memory allows. In the following code, you have a list and tuple built out of a range with a million numbers:

>>>list(range(1_000_000))>>>tuple(range(1_000_000))

These two lines of code will take some time to run and populate your screen with many, many numbers.

Finally, objects in a list or tuple don’t need to be unique. A given object can appear multiple times:

>>>["bark","meow","woof","bark","cheep","bark"]['bark', 'meow', 'woof', 'bark', 'cheep', 'bark']>>>("bark","meow","woof","bark","cheep","bark")('bark', 'meow', 'woof', 'bark', 'cheep', 'bark')

Lists and tuples can contain duplicated values like"bark" in the above examples.

Lists and Tuples Can Be Indexed and Sliced

You can access individual elements in a list or tuple using the item’s index in square brackets. This is exactly analogous to accessing individual characters in a string. List indexing is zero-based, as it is with strings.

Consider the following list:

>>>words=["foo","bar","baz","qux","quux","corge"]

The indices for the elements inwords are shown below:

Here’s the Python code to access individual elements ofwords:

>>>words[0]'foo'>>>words[2]'baz'>>>words[5]'corge'

The first element in the list has an index of0. The second element has an index of1, and so on. Virtually everything about indexing works the same for tuples.

You can also use a negative index, in which case the count starts from the end of the list:

Index-1 corresponds to the last element in the list, while the first element is-len(words), as shown below:

>>>words[-1]'corge'>>>words[-2]'quux'>>>words[-len(words)]'foo'

Slicing also works with lists and tuples. For example, the expressionwords[m:n] returns the portion ofwords from indexm to, but not including, indexn:

>>>words[2:5]['baz', 'qux', 'quux']

Other features of slicing work for lists as well. For example, you can use both positive and negative indices:

>>>words[-5:-2]['bar', 'baz', 'qux']>>>words[1:4]['bar', 'baz', 'qux']>>>words[-5:-2]==words[1:4]True

Omitting the first index starts the slice at the beginning of the list or tuple. Omitting the second index extends the slice to the end of the list or tuple:

>>>words[:4]['foo', 'bar', 'baz', 'qux']>>>words[0:4]['foo', 'bar', 'baz', 'qux']>>>words[2:]['baz', 'qux', 'quux', 'corge']>>>words[2:len(words)]['baz', 'qux', 'quux', 'corge']>>>words[:4]+words[4:]['foo', 'bar', 'baz', 'qux', 'quux', 'corge']>>>words[:4]+words[4:]==wordsTrue

You can specify a stride—either positive or negative:

>>>words[0:6:2]['foo', 'baz', 'quux']>>>words[1:6:2]['bar', 'qux', 'corge']>>>words[6:0:-2]['corge', 'qux', 'bar']

The slicing operator ([:]) works for both lists and tuples. You can check it out by turningwords into a tuple and running the same slicing operations on it.

Lists and Tuples Can Be Nested

You’ve seen that an element in a list or tuple can be of any type. This means that they can contain other lists or tuples. For example, a list can contain sublists, which can contain other sublists, and so on, to arbitrary depth.

Consider the following example:

>>>x=["a",["bb",["ccc","ddd"],"ee","ff"],"g",["hh","ii"],"j"]

The internal structure of this list is represented in the diagram below:

In this diagram,x[0],x[2], andx[4] are strings, each one character long:

>>>x[0],x[2],x[4]('a', 'g', 'j')

However,x[1] andx[3] are sublists or nested lists:

>>>x[1]['bb', ['ccc', 'ddd'], 'ee', 'ff']>>>x[3]['hh', 'ii']

To access the items in a sublist, append an additional index:

>>>x[1][0]'bb'>>>x[1][1]['ccc', 'ddd']>>>x[1][2]'ee'>>>x[1][3]'ff'

Here,x[1][1] is yet another sublist, so adding one more index accesses its elements:

>>>x[1][1][0]'ccc'>>>x[1][1][1]'ddd'

There’s no limit to the depth you can nest lists this way. However, deeply nested lists or tuples can be hard to decipher in an indexing or slicing context.

Lists Are Mutable, Tuples Are Immutable

The built-inlist class provides amutable data type. Being mutable means that once you create alist object, you can add, delete, shift, and move elements around at will. Python provides many ways to modify lists, as you’ll learn in a moment. Unlike lists, tuples areimmutable, meaning that you can’t change a tuple once it has been created.

You can replace or update a value in a list by indexing it on the left side of anassignment statement:

>>>letters=["A","B","c","d"]# A list>>>letters[2]="C">>>letters['A', 'B', 'C', 'd']>>>letters[-1]="D">>>letters['A', 'B', 'C', 'D']

In this example, you create a list of letters where some letters are in uppercase while others are in lowercase. You use an assignment to turn the lowercase letters into uppercase letters.

Now, because tuples are immutable, you can’t do with a tuple what you did in the above example with a list:

>>>letters=("A","B","c","d")# A tuple>>>letters[2]="C"Traceback (most recent call last):...TypeError:'tuple' object does not support item assignment

If you try to update the value of a tuple element, you get aTypeError exception because tuples are immutable, and this type of operation isn’t allowed for them.

You can also use thedel statement to delete individual items from a list. However, that operation won’t work on tuples:

>>>fruits=["apple","orange","mango","grape"]>>>delfruits[0]# Remove apple>>>fruits['orange', 'mango', 'grape']>>>person=("John Doe",35,"Web Dev")>>>delperson[1]# Try to remove the age valueTraceback (most recent call last):...TypeError:'tuple' object doesn't support item deletion

You can remove individual elements from lists using thedel statement because lists are mutable, but this won’t work with tuples because they’re immutable.

What if you want to change several elements in a list at once? Python allows this operation with aslice assignment, which has the following syntax:

a_list[m:n]=<iterable>

Think of aniterable as a container of multiple values like a list or tuple. This assignment replaces the specified slice ofa_list with the content of<iterable>:

>>>numbers=[1,2,3,0,0,0,7]>>>numbers[3:6]=[4,5,6]>>>numbers[1, 2, 3, 4, 5, 6, 7]

In this example, you replace the0 values with the corresponding consecutive numbers using a slice assignment.

It’s important to note that the number of elements to insert doesn’t need to be equal to the number of elements in the slice. Python grows or shrinks the list as needed. For example, you can insert multiple elements in place of a single element:

>>>numbers=[1,2,3,7]>>>numbers[3:4]=[4,5,6,7]>>>numbers[1, 2, 3, 4, 5, 6, 7]

In this example, you replace the7 with a list of values from4 to7. Note how Python automatically grows the list for you.

You can also insert elements into a list without removing anything. To do this, you can specify a slice of the form[n:n] at the desired index:

>>>numbers=[1,2,3,7]>>>numbers[3:3]=[4,5,6]>>>numbers[1, 2, 3, 4, 5, 6, 7]

In this example, you insert the desired values at index3. Because you’re using an empty slice, Python doesn’t replace any of the existing values. Instead, it makes space for the new values as needed.

You can’t do slice assignment ontuple objects:

>>>numbers[3:3]=[4,5,6]Traceback (most recent call last):...TypeError:'tuple' object does not support item assignment

Because tuples are immutable, they don’t support slice assignment. If you try to do it, then you get aTypeError exception.

Lists Have Mutator Methods, Tuples Don’t

Python lists have several methods that you can use to modify the underlying list. These methods aren’t available for tuples because tuples are immutable, so you can’t change them in place.

In this section, you’ll explore themutator methods available in Pythonlist objects. These methods are handy in many situations, so they’re great tools for you as a Python developer.

>>>a=["a","b"]>>>a.append("c")>>>a['a', 'b', 'c']

>>>a=["a","b"]>>>x=a.append("c")>>>print(x)None>>>a['a', 'b', 'c']

>>>a=["a","b"]>>>a.append(["c","d","e"])>>>a['a', 'b', ['c', 'd', 'e']]

>>>a=["a","b"]>>>a.extend(["c","d","e"])>>>a['a', 'b', 'c', 'd', 'e']

>>>a=["a","b"]>>>a+=["c","d","e"]>>>a['a', 'b', 'c', 'd', 'e']

>>>a=["a","c"]>>>a.insert(1,"b")>>>a['a', 'b', 'c']

>>>a=["a","b","c","d","e"]>>>a.remove("b")>>>a['a', 'c', 'd', 'e']>>>a.remove("c")>>>a['a', 'd', 'e']

>>>a=["a","b","c","d","e"]>>>a.pop()'e'>>>a['a', 'b', 'c', 'd']>>>a.pop()'d'>>>a['a', 'b', 'c']

>>>a=["a","b","c","d","e"]>>>a.pop(1)'b'>>>a['a', 'c', 'd', 'e']>>>a.pop(3)'e'>>>a['a', 'c', 'd']>>>a.pop(-2)'c'>>>a['a', 'd']>>>a.pop(-1)'d'>>>a['a']