Tuple in python example

Python Tuples: A Step-by-Step Tutorial (with 14 Code Examples)

When working with data collections, we occasionally encounter situations where we want to ensure it’s impossible to change the sequence of objects after creation.

For instance, when reading data from a database in Python, we can represent each table record as an ordered and unchangeable sequence of objects since we don’t need to alter the sequence later. Python has a built-in sequence data type to store data in an unchangeable object, called a tuple.

After you finish this Python tutorial, you’ll know the following:

• How to work with tuples in Python
• The difference between tuples and lists in Python
• The basic uses of tuples

In this tutorial, we assume you know the fundamentals of Python, including variables, data types, and basic structures. If you’re not familiar with these or would like to review, you might like to try our Python Basics for Data Analysis – Dataquest.

What Is a Python Tuple?

A tuple represents a sequence of any objects separated by commas and enclosed in parentheses. A tuple is an immutable object, which means it cannot be changed, and we use it to represent fixed collections of items.

Let’s take a look at some examples of Python tuples:

• () — an empty tuple
• (1.0, 9.9, 10) — a tuple containing three numeric objects
• (‘Casey’, ‘Darin’, ‘Bella’, ‘Mehdi’) — a tuple containing four string objects
• (’10’, 101, True) — a tuple containing a string, an integer, and a Boolean object

Also, other objects like lists and tuples can comprise a tuple, like this:

a_tuple = (0, [1, 2, 3], (4, 5, 6), 7.0)

The code above creates a tuple containing an integer, a list, a tuple, and a float number. The following code returns the entire tuple and its data type.

print(a_tuple) print(type(a_tuple))

However, (‘A’) is not a tuple. Let’s look at its data type:

So, how can we declare a single-value tuple? The answer is easy. We need to add an extra comma just before the closing parenthesis, like this:
(‘A’,)
The trailing comma means that the parentheses are holding a single-value tuple, not to increase the precedence of a mathematical operation.

Indexing and Slicing a Tuple

As mentioned earlier, because a tuple is a sequence of objects, we can access these objects through indexing. As with strings, the index of the first element is 0, the second element is 1, and so on. Let’s try indexing a tuple:

print('The first element:', a_tuple[0]) print('The last element:', a_tuple[-1]) print('The data type of the second element:', type(a_tuple[1]))

The first element: 0 The last element: 7.0 The data type of the second element:

In the code above, the first and second statements return the values of the tuple’s first and last elements. The last statement prints out the data type of the second element of the tuple, which is a list object.

Furthermore, the following piece of code shows how to retrieve the second element of the inner tuple, at index 2.

This means that we can access an element stored in an inner tuple (a tuple stored inside another tuple) by doing a series of indexing operations.

Slicing a tuple is as simple as slicing a Python string or a list with the same rules. To get a range of elements within a tuple, we can specify a range of indices to retrieve by selecting where to start (inclusive) and end (exclusive) the range.

Let’s take a look at some examples:

num_tuple = 2, 4, 5, 7, 8, 10 print(num_tuple[:3]) print(num_tuple[4:]) print(num_tuple[-3:]) print(num_tuple[2:5])

The first line of the code declares a tuple of integer values. Although it’s unusual, it’s another way to declare a tuple by providing a sequence of objects separated by commas without enclosing them in parentheses. The subsequent statements print out different slices of the tuple, as shown.

If you’re not familiar with indexing and slicing a sequence object in Python or would like to review, there is a good tutorial on the Dataquest blog at Tutorial: Demystifying Python Lists.

To concatenate two or more tuples, we can use + sign as with strings. For example, the following code concatenates two tuples:

tuple_1 = (1, 2) tuple_2 = (3, 4) print(tuple_1 + tuple_2)

Moreover, multiplying a tuple by an integer produces a tuple containing the original tuple repeated that many times. Let’s try it:

my_tuple = (1, 7, 9, 8) print(my_tuple * 2)

Zipping Tuples

The zip() method takes multiple sequence objects and returns an iterable object by matching their elements. To learn more about zipping tuples, consider the following example.

Let’s assume that we have three different tuples containing the personal details of four customers. We want to create a single tuple that holds the corresponding data for each customer, including their first name, last name, and age, in the form of separate tuples:

first_names = ('Simon', 'Sarah', 'Mehdi', 'Fatime') last_names = ('Sinek', 'Smith', 'Lotfinejad', 'Lopes') ages = (49, 55, 39, 33) zipped = zip(first_names, last_names,ages) print(zipped)

We declare the first_name , last_name , and ages tuples in the code above. The zip() method takes the three tuples and returns a zip object, which is an iterator. To consume the iterator object, we need to convert it to either a list or a tuple, like this:

customers = tuple(zipped) print(customers)

(('Simon', 'Sinek', 49), ('Sarah', 'Smith', 55), ('Mehdi', 'Lotfinejad', 39), ('Fatime', 'Lopes', 33))

The customers tuple consists of four tuple objects, each of which belongs to a customer.

Unpacking Tuples

Unpacking a tuple allows us to extract the tuple elements and assign them to named variables. Let’s try it:

first_name, last_name, age = customers[2] print(first_name, last_name, ',', age, 'years old')

Mehdi Lotfinejad , 39 years old

The code above retrieves the tuple elements stored at index 2 of the customers tuple and assigns them to the first_name , last_name , and age variables.

Difference Between Tuples and Lists in Python

Besides the intuitive difference between tuples and lists, as mentioned before, tuples are immutable, so unlike lists, tuples cannot be modified. However, some technical differences make tuples an undeniable asset in Python programming.

The first difference that makes lists more preferable iterable objects than tuples is that a list object provides more methods. But the extra functionality comes at a price. Let’s first look at the size of the occupied memory of each object in the code below, then discuss why tuples are the better choice in some situations.

import sys a_list = ['abc', 'xyz', 123, 231, 13.31, 0.1312] a_tuple = ('abc', 'xyz', 123, 231, 13.31, 0.1312) print('The list size:', sys.getsizeof(a_list), 'bytes') print('The tuple size:', sys.getsizeof(a_tuple), 'bytes')

The list size: 104 Bytes The tuple size: 88 Bytes

We can see that a list object occupies more memory than a tuple object. The significance of occupying less memory becomes more apparent when we work with big data, which means immutability makes significant optimization when working with a large amount of data.
In addition to occupying less memory, processing tuple objects is much faster than lists, especially when dealing with millions and millions of sequence objects.

Usage of Python Tuples

This section will discuss two exciting ways of using tuples in practice. Let’s explore them.

Tuple Element Swapping

We can use tuples to swap the values associated with variables only if the variables are tuple elements. Let’s try it out:

x = 19 y = 91 print('Before swapping:') print(f'x = , y = ') (x, y) = (y, x) print('After swapping:') print(f'x = , y = ')

Before swapping: x = 19, y = 91 After swapping: x = 91, y = 19

The value of y is assigned to the x variable, and the x value is simultaneously assigned to the y . It’s a more Pythonic way to swap values.

Returning More Than One Value from a Function

Functions can only return a single value. However, we can use a tuple and put as many values as we need inside it, then return the tuple object as the function’s return value. Let’s see how we can use a tuple to return multiple values from a function in the following code:

def sum_and_avg(x, y, z): s = x + y + z a = s/3 return(s, a) (S, A) = sum_and_avg(3, 8, 5) print('Sum =', S) print('Avg =', A)

Sum = 16 Avg = 5.333333333333333

The sum_and_avg() function calculates the sum and average of three numeric values. The function returns s and a , which are the two values that it calculates, in the context of the tuple object. In fact, the function only returns a single value, which is a tuple object containing multiple values. We also used the tuple unpacking technique to extract the values in the returned tuple object, then print them out.

Conclusion

This tutorial covered how to create tuple objects, as well as many aspects of Python tuples, such as indexing, slicing, zipping, unpacking, etc. We also discussed the difference between tuples and lists. Using Python tuples properly will definitely make our code more efficient and robust.

Dataquest

Dataquest teaches through challenging exercises and projects instead of video lectures. It’s the most effective way to learn the skills you need to build your data career.

Источник

Python Tuples

Tuples are used to store multiple items in a single variable.

Tuple is one of 4 built-in data types in Python used to store collections of data, the other 3 are List, Set, and Dictionary, all with different qualities and usage.

A tuple is a collection which is ordered and unchangeable.

Tuples are written with round brackets.

Example

Tuple Items

Tuple items are ordered, unchangeable, and allow duplicate values.

Tuple items are indexed, the first item has index [0] , the second item has index [1] etc.

Ordered

When we say that tuples are ordered, it means that the items have a defined order, and that order will not change.

Unchangeable

Tuples are unchangeable, meaning that we cannot change, add or remove items after the tuple has been created.

Allow Duplicates

Since tuples are indexed, they can have items with the same value:

Example

Tuples allow duplicate values:

Tuple Length

To determine how many items a tuple has, use the len() function:

Example

Print the number of items in the tuple:

Create Tuple With One Item

To create a tuple with only one item, you have to add a comma after the item, otherwise Python will not recognize it as a tuple.

Example

One item tuple, remember the comma:

thistuple = («apple»,)
print(type(thistuple))

#NOT a tuple
thistuple = («apple»)
print(type(thistuple))

Tuple Items — Data Types

Tuple items can be of any data type:

Example

String, int and boolean data types:

A tuple can contain different data types:

Example

A tuple with strings, integers and boolean values:

type()

From Python’s perspective, tuples are defined as objects with the data type ‘tuple’:

Example

What is the data type of a tuple?

The tuple() Constructor

It is also possible to use the tuple() constructor to make a tuple.

Example

Using the tuple() method to make a tuple:

Python Collections (Arrays)

There are four collection data types in the Python programming language:

• List is a collection which is ordered and changeable. Allows duplicate members.
• Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
• Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.
• Dictionary is a collection which is ordered** and changeable. No duplicate members.

*Set items are unchangeable, but you can remove and/or add items whenever you like.

**As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered.

When choosing a collection type, it is useful to understand the properties of that type. Choosing the right type for a particular data set could mean retention of meaning, and, it could mean an increase in efficiency or security.

Источник