Beyond accessing items, additional operations can be performed on a tuple. Important operations include:

- Updating a tuple:
Tuples are immutable, meaning their values cannot be changed after creation. However, if you do wish to change a tuple value, you can work around this by turning the tuple into a list (which is mutable), modifying the list, and then turning it back into a tuple.
```python
tuple = ("apple", "orange", "banana")
list = list(tuple)
list[1] = "pineapple"
tuple = tuple(list)
```
- Unpacking a tuple:
When you create a tuple and feed it values, this is called packing. If you want to extract a tuple's values into variables, then this is called unpacking the tuple. You can unpack a tuple as shown.
```python
tuple = ("apple", "orange", "banana")
(red, orange, yellow) = tuple
print(red)
print(orange)
print(yellow)
```
The number of variables must match the number of items in the tuple, unless using an asterisk to collect the items in a list. In the above example, red is assigned to apple, orange to orange, and yellow to banana. Collecting items within a list using an asterisk is shown below.
```python
tuple = ("apple", "strawberry", "cherry", "orange", "banana")
(red*, orange, yellow) = tuple
print(red)
print(orange)
print(yellow)
```
Items in the tuple are added to red until the number of remaining variables (which is two, since orange and yellow come after red) matches the number of remaining items in the tuple. Thus, orange is assigned to orange and banana is assigned to yellow.

Tuple Operations

https://www.w3schools.com/python/python_tuples.asp

Tuple Reference

A programmer writes the following code snippet to update a collection of user roles. What will be the result when this code is executed?

```python
user_roles = ('viewer', 'commenter', 'editor', 'admin')
user_roles[1] = 'contributor'
print(user_roles)
```

A developer is defining a collection of RGB color values for a company's official brand palette. These specific color codes are considered constants and must not be altered anywhere in the application after they are defined. Analyze the provided code snippet and explain the potential risk. Then, propose a single, minimal change to the code to mitigate this risk and justify your recommendation.

Choosing the Right Data Structure for Constants

A developer needs to store a sequence of geographic coordinates (latitude and longitude) for a fixed historical landmark. The sequence of these coordinates must remain constant and in the correct order throughout the program's execution to prevent data corruption. Explain why a data structure that is both ordered and unchangeable is more suitable for this task than one that is ordered but changeable. What is the primary risk of using the changeable data structure in this specific scenario?

Choosing an Appropriate Data Structure

- A tuple is a data structure that can store items within a single variable.
- The items in a tuple are ordered (indexed) and are immutable (cannot be changed).
- Tuples can have duplicate items.
- To create a tuple, surround items (separated by commas) with parentheses.
Ex:
```python
tuple = ('apple', 34, 'banana')
```
- To access an element inside a tuple, use the tuple name along with square brackets and the desired index.
Ex:
```python
tuple[1] # access tuple index 1, which is 34.
```

Rutgers University

Google

Data structures facilitate the organization of data in computer memory in an efficient manner which further support faster and more flexible data manipulations.


The python interpreter offers the following built-in data structures:


- List
- Set
- Tuple
- Dictionary


Data Structures in Python

Python Documentation

Reference of Foundations of Large Language Models Course

- List is a built-in data type, it is also a collection datatype(  lists accommodate elements/items of various datatype )
- List is also a sequence data type which can accommodate items of various basic data types  like integers, float etc. but usually items in a list are of same basic data type.
-  A list contains values separated by comma inside a square bracket.
- Lists are resizable. Items in a list can be added, removed and modified after the list is created.
- Lists are mutable, that means  contents of a list can be changed.
- Lists can be nested, that means we can create a list containing another list.

``` python
my_list = [1,"1cademy",12.59,True]
my_list
```
Output

``` python
[1, '1cademy', 12.59, True]
```

List

- A set is an unordered collection of data.
- The items in a set are unordered, unmutable, and cannot contain duplicate values.
- Mathematical operations (e.g. union, intersection, difference, symmetric difference) can be performed on sets.
- To create a set, list elements separated by commas within two curly braces.

Example:
```python
set = {"apple", "orange", "banana"}
```


Tuple

• Dictionary is a built-in data structure. A dictionary is an ordered and mutable collection of objects.
• It consists of Key-Value pairs. Each Key must be Unique.

Syntax:
```python
dictionary = {"key name": value}
```
```python
student_scores = {
    "John" : 76,
    "Peter": 95,
    "Mike": 84
}
```
We can access the Values using the Keys:
```python
print(student_scores["John"])
```
This ```python print() ``` statement would print out the value 76. It is also important to note that keys must map to a unique value. 


Dictionary 

There are other basic data structures that are not defined in the Python standard library. These include:

- Linked List
- Stack
- Queue
- Tree
- Heap
- Graph

Learn Before

Related

Learn After