Lists

A sequence is an object that holds multiple items of data, stored one after the other. Operations can be performed on a sequence to examine and manipulate the items stored in it.

Both lists and tuples are sequences that can hold various types of data. 

The difference between lists and tuples is simple: a list is mutable, which means that a program can change its contents,  but a tuple is immutable, which means that once it is created, its contents cannot be changed.

Lists

A list is an object that contains multiple data items. Lists are mutable, which means that their contents can be changed during a program’s execution. Lists are dynamic data structures, meaning that items may be added to them or removed from them. Indexing, slicing, and various methods can be used to work with lists in a program.

Each item that is stored in a list is called an element.

Here is a statement that creates a list of integers:

even_numbers = [2, 4, 6, 8, 10]

The items that are enclosed in brackets and separated by commas are the list elements.

A list can hold items of different types, as shown in the following example:

info = ['Ashraf', 27, 2650.87]

This statement creates a list containing a string, an integer, and a floating-point number.

Python also has a built-in list() function that can convert certain types of objects to lists.

Example 1:

numbers = list(range(5))

When this statement executes, the following things happen:

• The range function is called with 5 passed as an argument. The function returns an iterable containing the values 0, 1, 2, 3, 4.

• The iterable is passed as an argument to the list() function. The list() function returns the list [0, 1, 2, 3, 4].

• The list [0, 1, 2, 3, 4] is assigned to the numbers variable.

Example 2:

numbers = list(range(1, 10, 2))

when three parameters are passed as arguments to the range function, the first argument is the starting value, the second argument is the ending limit, and the third argument is the step value. This statement will assign the list [1, 3, 5, 7, 9] to the numbers variable.

The Repetition Operator

The * symbol multiplies two numbers. However, when the operand on the left side of the * symbol is a sequence (such as a list) and the operand on the right side is an integer, it becomes the repetition operator. The repetition operator makes multiple copies of a list and joins them all together.

Here is the general format:

list * n

In the general format, list is a list and n is the number of copies to make.

Example:

>>> numbers = [1, 2, 3] * 3

>>> print(numbers)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

Note: You cannot create traditional arrays in Python because lists serve the same purpose and provide many more built-in capabilities.

Iterating over a List with the for Loop

Many of the same programming techniques also apply to lists. For example, you can iterate over a list with the for loop, as shown here:

numbers = [99, 100, 101, 102]

for n in numbers:

print(n)

If we run this code, it will print:

99

100

101

102

 

Indexing

 Another way that you can access the individual elements in a list is with an index. Each element in a list has an index that specifies its position in the list. Indexing starts at 0. The index of the last element in a list is 1 less than the number of elements in the list.

 Negative indexes can be used with lists to identify element positions relative to the end of the list. The Python interpreter adds negative indexes to the length of the list to determine the element position. The index -1 identifies the last element in a list, -2 identify the next to last element, and so forth.

The following code shows an example:

my_list = [10, 20, 30, 40]

print(my_list[−1], my_list[−2], my_list[−3], my_list[−4])

In this example, the print function will display:

40 30 20 10

An IndexError exception will be raised if you use an invalid index with a list.

 

Concatenating Lists

The + operator is used to concatenate two lists. Here is an example:

 

list1 = [1, 2, 3, 4]

list2 = [5, 6, 7, 8]

list3 = list1 + list2

 

After this code executes, list1 and list2 remain unchanged, and list3 references the following list:

[1, 2, 3, 4, 5, 6, 7, 8]

 

Note: Keep in mind that you can concatenate lists only with other lists. If you try to concatenate a list with something that is not a list, an exception will be raised.