Lesson 1 - Python Collections - Tuples and Lists New
Welcome to the first part of course about collections in Python. In this part, we'll deepen our knowledge of lists and learn to use tuples.
A tuple is a data type that stores its elements in a certain order. It's created as follows:
empty = () empty_2 = tuple() other = (1, 2, 3) other_2 = tuple(range(3))
We can create a tuple by placing its elements in parentheses and separating
the individual elements with a comma. The expression
also convert other data types to tuples (if possible), such as the result of the
Tuples can also be created using
For example, let's create a tuple with odd numbers:
odd = tuple(range(1, 10, 2)) even = tuple(range(0, 10, 2))
When we print the tuples, we'll see this:
Console application >>> odd = tuple(range(1, 10, 2)) >>> even = tuple(range(0, 10, 2)) >>> odd (1, 3, 5, 7, 9) >>> even (0, 2, 4, 6, 8) >>>
We can use the
zip() function to create tuples that contain
other tuples from multiple iterators of the
range() function. It
sounds complicated, so let's take a look at an example:
Console application >>> my_tuple = tuple(zip(range(1, 5, 1), range(2, 8, 3), range(1, 7, 2))) >>> my_tuple ((1, 2, 1), (2, 5, 3)) >>>
A tuple containing only two tuples was created here. The number of nested
tuples is given by the smallest number of elements returned by one of the
range() functions - in this case the second one, because:
the first one returns - 1, 2, 3, 4
the second one returns - 2, 5
the third one returns - 1, 3, 5
The smallest one is the second tuple - so the first two elements are taken from each tuple so tuples (1, 2, 1) and (2, 5, 3) are formed.
And that's all about the
We'll show first that tuples can be joined (
*) and tested to see if there is (are) an element in them. In the
following example, we create two tuples, one with odd and the other with even
digits. We'll then connect the two.
Console application >>> odd = tuple(range(1, 10, 2)) >>> odd (1, 3, 5, 7, 9) >>> even = tuple(range(0, 10, 2)) >>> even (0, 2, 4, 6, 8) >>> numbers = odd + even >>> numbers (1, 3, 5, 7, 9, 0, 2, 4, 6, 8) >>>
We can also replicate sets, which means that we "multiply" them:
>>> numbers = tuple(1, 2, 3) >>> numbers * 3 (1, 2, 3, 1, 2, 3, 1, 2, 3)
Additionally, we can find out whether a given element is (is not) in the tuple:
>>> numbers = tuple(1, 2, 3) >>> 1 in numbers True >>> 4 in numbers False >>> 2 not in numbers False >>> 5 not in numbers True
Trimming a Tuple and the
Only a certain part of the tuple can be extracted from one. E.g. we only need the first two elements. How to do it?
Each element in the tuple has its own serial number (the place where it's stored - an index). The first element has the number 0, the next 1, etc. We find the element in the tuple as follows - the name of the tuple[element number] - e.g. my_tuple - the element in the second place.
Console application >>> my_tuple = ("a", 2, 3.0, "d", 5.0) >>> my_tuple 'a' >>> my_tuple 2 >>> my_tuple 3.0 >>> my_tuple "d" >>> my_tuple 5.0 >>>
The number of elements in the tuple is determined by the
function. Since the indexing is zero-based, the last element has the number
len(*the name of the tuple*) - 1. The
returns an integer indicating the number of elements.
And another example:
Console application >>> my_tuple_1 = (1, 2, 3) >>> len(my_tuple_1) 3 >>> my_tuple_2 = (1, "a", 1.0, "A") >>> len(my_tuple_2) 4 >>> my_tuple_3 = () >>> len(my_tuple_3) 0 >>>
Elements from the tuple can also be obtained by negative indices. With
negative indices, numbering "goes" from the end to the beginning. Therefore, the
last element has the index -1, the second to last has -2 and so on, and the
first element has the index
-len(*the name of the tuple*).
Console application >>> my_tuple = tuple(range(10)) >>> my_tuple (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) >>> my_tuple 0 >>> my_tuple 9 >>> my_tuple[-1] 9 >>> my_tuple[-10] 0 >>> my_tuple[-len(my_tuple)] 0 >>> my_tuple[-2] 8 >>> my_tuple[-3] 7 >>> my_tuple[-4] 6 >>>
In the example, we created tuples using the
We can use trimming () a
little better. Imagine that you need to get all the elements in the tuple from
the first to the third one (from index 0 to index 2). The syntax of trimming is
similar to the syntax of the
- my_tuple[m] - returns the element with index m from the tuple
- my_tuple[m:n] - returns the elements with indices from m to n-1 from the tuple
- my_tuple[m:n:i] - returns the elements with indices from m and every other i-th element up to n from the tuple
m, n and i can also be omitted. In this case, for example, [:] can return all elements.
Now a few examples to make it clear:
Console application >>> my_tuple = tuple(range(10)) >>> my_tuple (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) >>> my_tuple 0 >>> my_tuple 1 >>> my_tuple[:] (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) >>> my_tuple[1:5] (1, 2, 3, 4) >>> my_tuple[1:7:2] (1, 3, 5) >>> my_tuple[::-1] (9, 8, 7, 6, 5, 4, 3, 2, 1, 0) >>>
Tuples can also be compared using comparison operators (see Lesson 3), but the data types in the tuple must be comparable. The comparison takes place between individual elements until one of the elements at the same index position is greater (or lesser). This tuple is then greater (or lesser).
The methods are used by writing:
Tuples have two methods:
method returns the number of occurrences of the specified element in the tuple,
index(*element*) method returns the lowest non-negative
index that contains the specified element.
Console application >>> my_tuple = (1, 2, "a", 4, 1, "a", 1) >>> my tuple.count(1) 3 >>> my_tuple.count("a") 2 >>> my_tuple.count(2) 1 >>> my_tuple.count(3) 0 >>> my_tuple.index(1) 0 >>> my_tuple.index("a") 2 >>> my_tuple.index(4) 3 >>>
That's all for tuples Now onto the lists.
We can use everything mentioned above for the lists, as well as other
functions and methods. This is because lists differ from tuples in the way that
elements can be added to the end of a list, because lists, unlike tuples, don't
have a fixed size. You can add, delete and overwrite elements in the list. In
Python, a list is created using brackets. You can also convert another data type
(if possible) to a list of
Now let's look at a few examples:
empty =  empty_2 = list() other = [1, 2, 3] other_2 = list(range(3))
List elements are overwritten by the following syntax -
list_name[element] = another_element.
Console application >>> my_list = [1, 2, "a", 4.0] >>> my_list 1 >>> my_list = 3 >>> my_list [3, 2, 'a', 4.0] >>> my_list[0:2] = [4, "b"] >>> my_list [4, 'b', 'a', 4.0] >>> my_list = list(range(3)) >>> my_list [4, 'b', 'a', [0, 1, 2]] >>> my_list 1 >>> my_list = 2 >>> my_list [4, 'b', 'a', [0, 2, 2]] >>>
At the end, we added another list to the list We can also work with list elements using loops. For example, to print individual list elements:
for element in my_list: print(element)
But if we want to go through the list gradually and do something with the elements, the following syntax is better:
for index in range(len(my_list)): my_list[index] = #here we can do whatever we need with the individual elements
Example - we have an array with different values and we want to increase the values e.g. by 1:
my_list = [1, 5, 2, 4, 6, 3] for index in range(len(my_list)): my_list[index] = my_list[index] + 1
And the result is [2, 6, 3, 5, 7, 4]
We can use the
index(element) methods for a list, and many
others, which we'll show:
Appends an element to the end of the list.
Deletes all elements in the list.
Creates a deep copy of a list. For example, if you create a new list by
referring to it with the
= (shallow copy) operator, only the
reference to the object is copied. In practice, this means that if you change
the original list, the newly created list will also change. The variables -
although they have a different name, actually point to the same thing This method creates a deep copy,
so if you change the original list, the copied one will not change at all.
Appends all elements from the iterable object (list, tuple, etc.) to the end of a list.
Inserts an element at the given position.
Returns the value of the element at a given position and at the same time removes the element from the list. If no position is specified, it returns the value of the last element and deletes it.
Removes the first occurrence of an element from the list.
Reverses the order of the elements in a list. The first element will be the last one, the second one the second to last... and the last one will be the first.
Without arguments, it sorts comparable elements in ascending order. This
method takes two arguments:
key (a function through which the
elements are "passed" and then compared) and
reversed (if set to
True, the list is sorted in descending order). The
function has the same key arguments.
They are used to create collections faster. They have the following syntax:
[expression for element in iterable_object]
Creates a new list of expressions.
[expression for element in iterable_object if condition]
Creates a new list of expressions. If the condition is met for the given expression, then the expression will be in the list.
Console application >>> my_list_1 = [number for number in range(10)] >>> my_list_1 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> my_list_2 = [number * 2 + 1 for number in range(10)] >>> my_list_2 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19] >>> my_list_3 = [number * 2 + 1 for number in range(10) if number % 3 == 0] >>> my_list_3 [1, 7, 13, 19] >>> my_list_4 = [number * 3 for number in range(50) if number % 2 == 0] >>> my_list_4 [0, 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120, 126, 132, 138, 144] >>>
In the next lesson, Iterators, Generators and Some Functions in Python, we'll show lambda functions, iterators and generators, and a few built-in functions.
No one has commented yet - be the first!