# What is Python tuple() Function?

The `tuple()`

function in Python, is used to create `tuple`

objects, can be incredibly handy for you. It allows you to make `tuples`

in several ways: for `starters`

, you can create an empty tuple with `tuple()`

. Moreover, you can convert other iterable objects like `lists`

into `tuples`

, ensuring the immutability of your data.

Just remember that `tuples`

, unlike `lists`

, can’t have their elements changed once they’re assigned, making them perfect for situations where you need a `fixed`

set of values or when you want to use them as dictionary keys.

To get more better understanding of `tuple()`

, let’s suppose you’re building a program to manage a `library`

, and you want to keep track of `books`

and their respective `authors`

. You decide to use a `dictionary`

to store this information, with the `book title`

as the key and a tuple containing the `author's`

name and the publication year as the `value`

. Here’s how you can use the `tuple()`

function to create these tuples.

Having acquired a fundamental understanding of Python `tuple()`

, let’s proceed to examine its syntax and parameter. Having a clear grasp of these elements is essential for efficiently utilizing this function in real-world situations. To reinforce your understanding, let’s delve into these aspects with practical examples.

## Tuple Function Syntax and Parameter

Now, let’s delve into the details of how the syntax of the `tuple()`

function appears. This is what it resembles:

tuple(iterable)

When you utilize the Python `tuple()`

function, remember that it requires a `single`

parameter, which should be an `iterable`

. The critical aspect here is the `iterable`

parameter, which can be any iterable object such as a `list`

or even another `tuple`

.

Having gained a solid understanding of the syntax and parameter of Python `tuple()`

function, let’s now explore its output to get a better sense of how this function works in practical scenarios.

## Tuple Function Return Value

Python’s `tuple()`

, when you use it, returns a new `tuple`

object. The tuple that it returns contains the elements from the `iterable`

you provide, should you choose to pass one as an argument. If you don’t provide any `argument`

, it will give you an `empty`

tuple. To put it simply, here’s what the `tuple()`

function does for you:

For this example, we start by defining a string variable called `my_string`

, which contains the text `Hello, Python Helper!`

Next, we use the `tuple()`

function to convert this `string`

into a `tuple`

, and we store the resulting tuple in a variable named `my_tuple`

. As a result, the characters in the `string`

become individual elements in the `tuple`

. Finally, we use the `print()`

function to display the contents of `my_tuple`

.

As illustrated in the above example, you can observe that this is a straightforward method for transforming `strings`

into `tuples`

, accomplished by employing the `tuple()`

function.

As previously stated, Python’s `tuple()`

function serves the purpose of generating tuple objects or converting other iterable data structures into tuples to fulfill specific programming requirements. Now, let’s move forward and explore real-world examples to enhance your comprehension of how the `tuple()`

function in Python can be employed.

### I. Accessing Tuple Values with tuple()

You can also use the `tuple()`

to access `tuple`

values. Accessing these values involves utilizing `indexing`

, similar to the approach used with `lists`

. This indexing begins at `0`

for the first element within the `tuple`

, allowing you to extract specific elements by their position in the `tuple`

. To illustrate this concept, let’s consider the following example.

In this example, we have a tuple named `even_tuple`

that contains a series of `even`

numbers from `0`

to `20`

. It includes numbers like `0`

, `2`

, `4`

, `6`

, `8`

, `10`

, `12`

, `14`

, `16`

, `18`

, and `20`

. We’ve stored these numbers inside parentheses to create the `tuple`

.

Now, we want to extract a portion of this `tuple`

, specifically the elements from the `second`

element (`2`

) to the `sixth`

element (`10`

). To do this, we use `square brackets`

and a `colon`

to specify the `range`

of elements we want. In Python, the index starts from `0`

, so the `second`

element is at index `1`

, and the `sixth`

element is at index `5`

. Therefore, the expression `even_tuple[1:6]`

extracts a `subset`

of the `tuple`

. Finally, we use the `print()`

function to display the extracted `tuple`

.

By using this approach, you can easily `access`

the elements from the `tuples`

by specifying the desired range within square brackets. This allows you to extract and work with specific subsets of the tuple’s `elements`

, making it a convenient way to manipulate and use data stored in `tuples`

.

### II. Deleting Tuple Values with tuple()

In Python, `tuples`

are considered as `immutable`

objects, indicating that you can selectively eliminate individual elements from them. And you also have the ability to delete the entire `tuple`

using the `del`

keyword. Here’s an example to showcase this concept:

Here, we have a tuple named `odd_tuple`

that contains a sequence of `odd`

numbers, specifically `1`

, `3`

, `5`

, `7`

, and `9`

. Additionally, there’s another tuple called `elements_to_remove`

which contains the values `5`

and `9`

, indicating the elements we want to remove from `odd_tuple`

.

To create a new `tuple`

without the specified `elements`

, we use a `list`

comprehension within the `tuple()`

. Here’s how it works: For each item in `odd_tuple`

, we check if it is not present in the `elements_to_remove`

tuple. If it’s not in `elements_to_remove`

, we include it in the new tuple being generated. This filters out the elements we want to `remove`

, leaving us with a new tuple that contains only the elements that were not in `elements_to_remove`

. Finally, we use the `print()`

to display the contents of the `new_tuple`

.

This above example illustrates that you have successfully created a new tuple without the elements `5`

and `9`

, as specified in `elements_to_remove`

.

### III. Using the tuple() with Range

Utilizing the `tuple()`

alongside the `range()`

function enables you to change the series of `numbers`

produced by the `range()`

function into a `tuple`

. In Python, the `range()`

generates a numerical sequence evaluated by the provided `starting`

, `ending`

, and `step`

values. When you use `tuple()`

around it, you’re able to produce a tuple that encompasses all the values within that `sequence`

. For instance:

For this example, we first define a function `is_prime(num)`

to check if a given number is `prime`

. Then, we create a range object `prime_range`

that generates numbers from `2`

to `19`

(`inclusive`

). We filter this range using the `filter()`

function and our `is_prime()`

function to obtain a tuple containing `prime`

numbers within the specified range. Finally, we print `prime_tuple`

, which will display the tuple of `prime`

numbers within the range as per the `filter`

condition.

As you observe, employing the `tuple()`

in conjunction with the `range()`

allows for a straightforward conversion of integers and various numeric values into a `tuple`

.

Now that you’ve gained a good grasp of the `tuple()`

in action with `strings`

, `integers`

, and `range()`

, and you’ve also explored its usage in `accessing`

and `deleting`

tuple elements, let’s advance to exploring the capabilities of the `tuple()`

in combination with various `built-in functions`

. This will provide you with a clearer understanding of its functionality.

## Python tuple() with Built-In Functions

So, let’s delve in and investigate the `tuple()`

function in conjunction with certain built-in functions:

### I. Python tuple() with len()

The use of the `tuple`

function along with the `len()`

function in Python provides you with the ability to evaluate the `length`

or the `number`

of elements within a `tuple`

. Below is a detailed explanation, outlining the sequential stages of how this procedure functions:

- You begin with an existing
`tuple`

. - Next you can apply the
`tuple()`

function to that`tuple`

, although it’s redundant since the input is already a tuple. Alternatively, you can use it on any iterable, such as a`list`

. - Following this, you pass the
`result`

, which remains identical to the original`tuple`

, to the`len()`

function. - In return, the
`len()`

function furnishes you with an integer that signifies the quantity of elements within the tuple.

To better understand this process, let’s look at an example:

In this example, we have a tuple named `temperatures`

containing `temperature`

data for different countries in `Celsius`

. We use the `tuple()`

function though it’s not necessary because `temperatures`

is already a tuple and pass its result to the `len()`

function. Finally, we print the `number`

of countries with `temperature`

data, and it will output the `count`

, which indicates how many `countries`

‘ temperature data we have in the `tuple`

.

This example showcases how you can apply `tuple()`

with `len()`

to evaluate the `number`

of elements (`countries' temperature data`

) in a tuple in Python.

### II. Python tuple() with max()

In Python, you have the option to utilize the `tuple function`

along with `max()`

to locate the `maximum`

value within a `tuple`

. The process involves starting with an existing `tuple`

and then applying the `tuple()`

function to it. Afterward, you can directly pass the original, unchanged `tuple`

to the `max()`

function.

As a result, the `max()`

function will provide you with the `largest`

element present within the `tuple`

. To illustrate this concept, consider the following example.

Here, we’re working with a tuple named `float_tuple`

that contains a collection of `floating-point`

numbers, specifically `12.5`

, `6.3`

, `8.7`

, `15.2`

, and `10.9`

. Our goal here is to find the `largest`

value among these numbers.

To achieve this, we first apply the `tuple()`

to `float_tuple`

. Next, we use the `max()`

function, which is applied to the result of the `tuple()`

function. The `max()`

function evaluates the `maximum`

value within the `tuple`

.

Finally, we utilize `print()`

to display the `result`

. In this case, we’re printing a message that includes the phrase `The maximum value in the tuple is`

:, followed by the `maximum_value`

variable, which holds the `largest`

value from our `float_tuple`

.

This exemplifies the way in which you can apply both the `tuple()`

and `max()`

functions in Python to pinpoint the highest `floating-point`

value within a tuple.

### III. Python tuple() with sum()

The `tuple()`

is also used with the `sum()`

function, just like with the `max()`

and `len()`

functions. This pairing allows you to compute the overall `sum`

of all numerical values present in a `tuple`

. The procedure commences with the presence of an established `tuple`

. While you do have the option to use the `tuple()`

function on it, This step is generally not required because Python inherently includes built-in support for `tuples`

.

Instead, you simply pass the `original`

, unmodified tuple directly to the `sum()`

function. The `sum()`

function then carries out an iteration through the elements of the `tuple`

, performing `addition`

operations, and ultimately provides the total `sum`

as the end `result`

. This functionality can be illustrated with an example, as shown below:

For this example, we have a tuple called `numeric_tuple`

containing a variety of numeric `values`

, including `integers`

like `100`

and `2`

, a `floating-point`

number `0.0`

, and a more precise float `16.1112`

. Our objective here is to calculate the `sum`

of all these numeric elements within the `tuple`

.

To do this, we first apply the `tuple()`

to `numeric_tuple`

. Then, we use the `sum()`

function to calculate the `sum`

. The `sum()`

iterates through the elements in the `tuple`

, `adding`

them together. Finally, we employ `print()`

to display the outcome, which is the total `sum`

of all elements in the `tuple`

. In this specific case, it would print a message saying, `The sum of elements in the tuple is`

: followed by the `total_sum`

value, which will represent the `sum`

of all the numeric elements in `numeric_tuple`

.

With this method, you can readily employ the `tuple()`

in conjunction with the `sum()`

, facilitating straightforward `addition`

operations on each element within the `tuple`

.

## Python tuple() Advanced Examples

From this point, we will examine several advanced examples of Python `tuple()`

function, highlighting its flexibility and wide range of applications.

### I. Converting a Dictionary to Tuple by tuple()

Converting a `dictionary`

to a tuple using `tuple()`

creates a sequence of `key-value`

pairs, where each `key-value`

pair from the `dictionary`

becomes a `tuple`

element. This transformation is useful when you want to represent the `dictionary`

data as an `ordered`

sequence of pairs, making it suitable for operations like `iteration`

, `mapping`

, or passing the data to functions that expect a sequence of `tuples`

. For example:

In this example, we begin by importing the `math`

module, which provides mathematical functions like `factorial`

. We’ve defined a custom function called `calculate_factorial_and_convert_to_tuple`

, which takes an input parameter `num`

.

Inside this function, we calculate the `factorial`

of `num`

using the `math.factorial(num)`

and store the result in a variable called `factorial_result`

. Next, we create a tuple named `factorial_tuple`

, which holds two `elements`

: the original number `num`

and its corresponding factorial `result`

. The function then returns this `tuple`

.

In the main part of the code, we have assigned the value `20`

to the variable `num`

, indicating that we want to calculate the factorial of `20`

. Then call the `calculate_factorial_and_convert_to_tuple`

function with `num`

as its argument, which calculates the factorial and returns it as a `tuple`

. Finally, print the `result`

, displaying a message that says `The factorial of 20 is`

: followed by the computed `factorial`

value, making it clear what the code is doing.

As evident from the above example, you can easily convert the `dictionary`

into a `tuple`

by utilizing Python’s `tuple`

function. This showcase the flexibility and convenience of Python when it comes to manipulating data `structures`

, allowing for straightforward transformations such as this one.

### II. Python Tuple with while loop

In Python, employing the `tuple()`

in conjunction with a `while loop`

provides you a means of dynamically constructing a tuple by `iteratively`

incorporating elements as long as a specific condition remains `valid`

. The basic procedure involves the following steps:

- Create an
`empty`

list to serve as a container for the elements you intend to include in the`tuple`

. - Employ a
`while loop`

, using a condition to dictate when the addition of elements to the tuple should cease. - Within the
`loop`

, append elements to the`list`

. - Following the loop’s execution, utilize the
`tuple()`

function to transform the`list`

into a`tuple`

.

To better illustrate this concept, consider the following example:

Here, we begin by initializing two `variables`

, `a`

and `b`

, to represent the first two numbers in the `Fibonacci`

series. We assign `0`

to `a`

and `1`

to `b`

. We also create an `empty list`

called `fibonacci_list`

that will serve as our container to store the `Fibonacci`

series. We define the variable `max_terms`

to indicate the `maximum`

number of terms we want in the `Fibonacci`

series; in this case, it’s set to `10`

.

The core of the code lies within a `while`

loop. This loop continues executing as long as the `length`

of `fibonacci_list`

is less than the `max_terms`

we specified earlier. Inside the `loop`

, we append the current value of `a`

(`the current Fibonacci number`

) to `fibonacci_list`

.

We then update `a`

and `b`

to represent the next two numbers in the `Fibonacci`

sequence. `a`

becomes `b`

, and `b`

becomes the sum of the old `a`

and `b`

, which is the essence of the `Fibonacci`

sequence where each number is the `sum`

of the two preceding ones. After the `loop`

completes and we’ve generated the desired number of `Fibonacci`

terms, we use the `tuple()`

function to convert `fibonacci_list`

into a `tuple`

. Finally, we print out the resulting `Fibonacci`

series in `tuple`

form.

In summary, this example efficiently calculates and presents the first `10`

terms of the `Fibonacci`

sequence using a `while`

loop, transforming them into a `tuple`

, and then displaying the `Fibonacci`

series in a tuple format for further use or analysis.

Now that you have an understanding of how the Python `tuple()`

function works in various situations, let’s proceed to examine the distinctions between the `tuple()`

and `list()`

functions in Python, as this comparison holds significant importance in programming contexts.

## Difference between tuple() and list()

In Python, the key distinction between `tuple()`

and `list()`

lies in their mutability: `tuples`

are unchangeable (`immutable`

), whereas `lists`

can be modified (`mutable`

). Your choice between these data structures should align with the specific demands of your program. Let’s delve deeper into these distinctions to enhance your comprehension.

### I. Python Tuple Function

After examining the flexible and convenient applications of the Python `tuple()`

in various contexts, it’s apparent that `tuple()`

serves numerous purposes and can be readily applied in different sections of your program. Now, let’s compare and contrast it with the `list()`

function to gain a deeper and clearer understanding of its functionality. For example:

For this example, we’re working with a collection of `books`

and their respective `authors`

. To represent this `data`

, we use a Python set called `books_and_authors`

. Within this `set`

, we’ve included multiple pairs of `book titles`

and `author`

names, each enclosed in `parentheses`

and separated by `commas`

.

Next, we want to convert this `set`

of `book-author`

pairs into an `immutable`

data structure, and for this purpose, we use the `tuple()`

function. By applying `tuple(books_and_authors)`

, we create a tuple named `books_and_authors_tuple`

that now contains the same `book-author`

pairs, but in a format that cannot be altered once created, making it suitable for scenarios where `immutability`

is desired. Finally, we print out the resulting `books_and_authors_tuple`

, which will display the book and author pairs as an `ordered`

sequence.

This above example illustrates allows you to efficiently manage and work with this book data in a structured and unchangeable format.

### II. Python List() Function

The Python `list()`

is a valuable tool for your programming tasks. It allows you to create new `lists`

or convert `iterable`

objects, such as `strings`

, `tuples`

, or other `lists`

, into `lists`

. When you call `list()`

without any arguments, it generates an `empty`

list, which you can populate as needed.

If you have an `iterable`

, like a `string`

or a `tuple`

, you can use `list()`

to transform it into a new `list`

, making it easier to manipulate and organize your data in a `list`

format. Consider below illustration:

In this example, we start with a string `my_string`

that contains the text `Hello, Learners!`

We then use the `list()`

function to convert this `string`

into a list called `char_list`

. The resulting list will contain individual characters from the `string`

, including `letters`

, `punctuation`

, and `spaces`

. When you run this code, you’ll see the list of characters printed as the output.

Now that you’ve comprehensively grasped the Python `tuple()`

function, its uses, and its flexibility across various scenarios, you’ve established a strong foundation. Now, let’s delve into some theoretical concepts to further improve your comprehension.

## Tuple Function Advantages

Certainly! Here are the advantages of using Python’s `tuple()`

:

### I. Immutable Data Structure

With `tuple()`

, you can create immutable sequences of elements. Once defined, the elements cannot be modified, providing data integrity and security.

### II. Faster Access

Tuples are faster than lists for accessing elements because of their `immutability`

. They can be used as keys in dictionaries, unlike lists.

### III. Memory Efficiency

Tuples generally consume less memory compared to `lists`

, making them suitable for situations where memory usage is a concern.

## Practical Usage of tuple()

Certainly! Here are practical usage scenarios for Python’s `tuple()`

:

### I. Data Integrity

You can use tuples to ensure that certain data remains unchanged throughout your program, such as configuration settings or constants, guaranteeing data integrity.

### II. Function Return Values

Tuples are handy for functions that need to return multiple values. You can return a tuple of results, and the caller can easily unpack and utilize those values.

### III. Parallel Assignment

Tuples support parallel assignment, allowing you to assign multiple variables in a single line, simplifying code and making it more concise.

`Congratulations`

! You’ve learned about the Python `tuple function`

and its various applications. This function is incredibly useful for creating tuples, which can be essential in different scenarios. You can create an empty tuple with it or convert other iterable objects like `lists`

into `tuples`

, ensuring the immutability of your data.

Tuples, unlike lists, can’t have their elements changed once assigned, making them perfect for situations where you need a fixed set of values or when you want to use them as dictionary keys. As you’ve seen, Python’s `tuple function`

is quite flexible, whether you’re working with data structures, accessing tuple values, or even converting dictionaries into `tuples`

. It’s a valuable tool in your Python programming toolbox, allowing you to manage data in an efficient and structured way.

So, keep exploring and experimenting with `tuple()`

in your Python projects. It’s one of those handy functions that can simplify your code and make it more robust. `Happy coding`

!