### Overview of Python Lists and Tuples

Two of the most commonly used built-in data types in Python are the list and the tuple.

Lists and tuples are part of the group of sequence data types—in other words, lists and tuples store one or more objects or values in a specific order. The objects stored in a list or tuple can be of any type, including the nothing type defined by the None keyword.

The big difference between lists and tuples is that lists are mutable, however tuples are immutable. Meaning once tuples are created, objects can’t be added or removed, and the order cannot be changed. However, certain objects in tuples can be changed, as we’ll see later.

### Creating a Python List or Tuple

Creating a list or tuple is easy, here are some empty ones:

# Lists must be surrounded by brackets
>>> emptylst = []
# Tuples may or may not be surrounded by parenthesis
>>> emptytup = ()

To create non-empty lists or tuples, values are separated by commas:

# Lists must be surrounded by brackets
>>> lst = [1, 2, 3]
>>> lst
[1, 2, 3]
# Tuples may or may not be surrounded by parenthesis
>>> tup = 1, 2, 3
>>> tup
(1, 2, 3)
>>> tup = ('one', 'two', 'three')
>>> tup
('one', 'two', 'three')

Note: To create a tuple with only one value, add a trailing comma to the value.

# The length of this tuple is 1
>>> tup2 = 0,
>>> tup2
(0,)

### Get Python List or Tuple Values

The values in lists and tuples, as with other sequence types, are referenced by an index. This is a number, referring to the sequence of the value, that begins with 0 for the first value. Such as the following:

>>> lst[0]
1
>>> tup[1]
'two'

Using an index below zero gets the values starting from the end of the list or tuple:

>>> lst[-1]
3
>>> tup[-2]
'two'

### Slicing Python Lists and Tuples

Multiple values can be referenced by “slicing” the list or tuple (referencing a range[start:stop]):

>>> lst[0:2]
[1, 2]
# Note an out-of-range stopindex translates to the end
>>> tup[1:5]
('two', 'three')

### Assigning a Python List Value by Index

Values for lists can be assigned with indexes (as long as the index already exists), but not for tuples:

>>> lst[2] = 'three'
>>> lst
[1, 2, 'three']
>>> tup[2] = 3
Traceback (most recent call last):
File "<pyshell#68>", line 1, in <module>
tup[2] = 3
TypeError: 'tuple' object does not support item assignment

### Adding to a Python List

Values can also be added to lists (and lists can be combined, or concatenated) with the ‘+’ operator, or with the standard append method:

# concatenation, the same as lst = lst + [None]
>>> lst += [None]
>>> lst
[1, 2, 'three', None]
>>> lst.append(5)
>>> lst
[1, 2, 'three', None, 5]

### The Python del Keyword for Lists

Values can be removed from lists with the del keyword:

>>> del lst[3]
>>> lst
[1, 2, 'three', 5]
# Slicing deletion; no stop index means through the end
>>> del lst[2:]
>>> lst
[1, 2]

Assignment and deletion methods for lists don’t work for tuples, but concatenation works:

# Note only tuples can be added to tuples
>>> tup += (4,)
>>> tup
('one', 'two', 'three', 4)

Even though tuples are not mutable like lists, with the slicing technique and a little creativity, tuples can be manipulated like lists:

# Almost like slice deletion
>>> tup = tup[0:2]
>>> tup
('one', 'two')
>>> tup2 += tup
>>> tup2
# almost like index assignment
>>> tup2 = tup2[0:1] + (1,) + tup2[2:]
>>> tup2
(0, 1, 'two')

In addition, if a tuple contains a list, the mutability of the list in that tuple is preserved:

>>> tup3 = 0, 'one', None, []
>>> tup3[3].append('three')
>>> tup3
(0, 'one', None, ['three'])

Aside from the methods described here more exist for lists and tuples, but these cover the most common list and tuple operations. And remember, lists and tuples can be nested (can contain lists and tuples, and other data types that store sets of values, such as dictionaries), and can store different types simultaneously, making them very useful.