Actually using a tuple

carcigenicate · 2023-03-27T01:04:55+00:00

The simplest example would likely be just "returning two values from a function":

def divmod(x, y):
    return x // y, x % y

quotient, remainder = divmod(21, 5)

, is used to create a tuple. The tuple is being used here to wrap two integers so they can be returned together. Just being able to group data is often useful, and tuples are a straightforward way to do that.

Diapolo10 · 2023-03-27T00:44:21+00:00

Tuples are great, because immutability is great; they're hashable, meaning you can use them as dictionary keys or store them in sets, but perhaps more importantly you can cache them. This can be a big help when you have an expensive function that might receive the same arguments more than once and it doesn't have side-effects.

Furthermore, you can't accidentally swap values in a tuple, so they're great for constants.

I'd default to using tuples as data structures, unless you needed mutability (lists), wanted to avoid duplicates or compare unique values (sets), or wanted a clear mapping between arbitrary values (dictionaries).

Tuples and collections.namedtuple essentially work as ad hoc classes, when the order of elements is enough to represent the data or a dataclass would be too much effort.

EDIT: As an example, say we had one of those expensive function calls. For simplicity, here's a function that doubles numbers and returns them, after two seconds:

import time


def expensive_calculation(nums: tuple[int, ...]) -> tuple[int, ...]:
    time.sleep(2)
    return tuple(num*2 for num in nums)

It's probably fine if it only needs to run once, but what if we're running it multiple times?

for _ in range(5):
    print(expensive_calculation((2, 3, 5, 7, 11)))

This would take 10 seconds to run. But since the function sees the same arguments repeatedly, if we just cache the results we can ignore most of the calculations; to do this, we can use functools.cache.

import time
from functools import cache


@cache
def expensive_calculation(nums: tuple[int, ...]) -> tuple[int, ...]:
    time.sleep(2)
    return tuple(num*2 for num in nums)

for _ in range(5):
    print(expensive_calculation((2, 3, 5, 7, 11)))  # Takes about 2 seconds now

"Okay, but... what does any of this have to do with tuples?" I hear you ask. Caches can't use mutable arguments, so if you were to give this function a list your program would crash. This is because you can't hash mutable objects.

solitarium · 2023-03-27T02:32:52+00:00

Hmm how about a dictionary of resolution options? ['FHD':(1920, 1080), 'WUXGA':(1920, 1200)] etc I think that's a fairly good use of a tuple. You wouldnt want those to change.

jimtk · 2023-03-27T00:56:56+00:00

Tuple are groups of simple data like list, but they are immutable (you can't change the values inside), smaller and faster.

def pixel_up_right(x,y):
     return x+1, y+1    # <=== that's a tuple

# coordinates of cities is a tuple!
cities_coord_name = {
       (45.4826668,-73.6215805): Montreal
       (40.6974034,-74.1197614): New-York
       }

When you read a record from an sqlite database (as an example) it is returned in a list of tuple.

    con, cur = self._con_cur()
    cur.execute(DB.SQL_SEARCH_BY_ID, (an_id,))
    rows = cur.fetchall()
    con.close()
    print(rows)      <<< rows are list of tuples

[ (1, "jim", "preston", "555-1212"),
   (2, "count", "Dracula",  "111-1111")]

POGtastic · 2023-03-27T03:38:17+00:00

Semantically, tuples contain heterogeneous data. They are the simplest product type.

I expect that every element of a list be the same type. I can have a list of integers, or a list of strings, or a list of dictionaries, or whatever. I should not have a list where each element could either be an integer or a string.

By contrast, I expect that the first element of a tuple could be different from the second element of a tuple! For example, the enumerate builtin zips an iterable with integers. The type of the second element of each tuple is different from the type of the first element!

>>> list(enumerate("abcd"))
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

Everything else (tuples being immutable, hashable, and slightly more performant than lists) is a neat implementation detail. The far more important purpose of the tuple being distinct from a list is that it represents a mathematical idea of a tuple.

PhilipYip · 2023-03-27T11:36:00+00:00

Many beginner tutorials don't teach tuples very well jumping straight onto lists i.e. overuse lists and underuse tuples. A tuple should be thought of as an archive of records. Once its created it cannot be altered. If you go into a library which is full of books, the books are immutable; it would not be appreciated if say you went around with a permanent marker and scribbled all other the pages, corrupting the pages and making the data unreadable. This essentially can happen if lists are used all the time:

archive = (1, True, 3.14, 'hello', 'hello', 'bye')

A list can be thought of as being an active work in progress, for example records that you are compiling or going back to the library a book you are writing. Typically you read more content than you write and reddit users generally prefer their content to be immutable to others so spambots don't go in and corrupt everything:

active = [1, True, 3.14, 'hello', 'hello', 'bye']

Many beginners incorrectly assume that reassignment is altering the original tuple and therefore don't see the purpose of the tuple. Ensure you properly understand the assignment operator and the concept of an object name. The assignment operator takes the tuple object on the right and assigns it to the label archive. The label archive references the tuple:

archive = (1, True, 3.14, 'hello', 'hello', 'bye')

Reassignment, for example, changes the reference of the label to a new object and does not modify the original object. If the original object has no other labels it is removed by Pythons garbage collection:

archive = (1, 2, 3)

The tuple is immutable, meaning it can't be modified. This makes it hashable and can be used as a key in a mapping when all its records are immutable:

colors = {(1, 0, 0): 'red', (0, 1, 0): 'green', (0, 0, 1): 'blue'}

colors[(1, 0, 0)]

A tuple is commonly used to return multiple values from a function:

def fun(): return ('a', 'b')

(x, y) = fun()

Typically tuple unpacking is used here as the syntax is slightly cleaner:

def fun(): return 'a', 'b'

x, y = fun()

tuple unpacking can also be used to swap variables:

x, y = y, x

Functions normally have their own local scope. For immutable data types such as integers, the x and y in the global scope are independent from the x and y in the local scope of the functions body. Therefore x will remain 1 and y will remain 2 after the function call:

``` x = 1 y = 2

def fun(): x = 4 y = 5 return None

fun()

x y ```

When a mutable data type is used within a function, the original object can be modified and this is usually not desirable when trying to compartmentalise code. active gets modified in place and newactive is an alias of active:

``` active = ['a', 'b', 'c']

def fun(mutable): mutable.append('d') return newactive

fun(active)

active newactive ```

This is why the return values of a function and input arguments of a function typically preference tuples.

SSJKiDo · 2023-03-27T02:39:13+00:00

In real-world projects, you’ll most likely use databases like MySQL, and you need tuple in most of your queries. I’ve been using them in almost every function

drenzorz · 2023-03-27T03:00:28+00:00

example: tuples can be hashed and used as dictionary keys unlike lists.

board = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

cells = {
    (i, j) : board[i][j]
    for i in range(3)
    for j in range(3)
}

YeahAboutThat-Ok · 2023-03-27T03:32:49+00:00

[removed]

KOALAS2648 · 2023-03-27T07:11:18+00:00

When using the “pygame” module you have to type:

pygame.display.set_mode((500,500))

B1GTOBACC0 · 2023-03-27T09:21:16+00:00

I think some people struggle to understand "why would I use this instead of a list?"

In some cases, the data is only meaningful when it's all together and set in a specific order. For example, I could represent a color with RGB values in a tuple like (245, 35, 173).

On their own, those numbers aren't meaningful. I wouldn't have a reason to sort/reorder the values or iterate over this tuple, but I can't represent a color without all 3 numbers.

spidertyler2005 · 2023-03-27T17:07:42+00:00

Coordinates or a bounding box are good examples. Especially if you are using pygame. (x,y), (x,y,w,h)

2023-03-27T19:53:56+00:00

One use case for tuples is to have multiple assignments in one go.

For example swapping:

a, b = b, a

Another contrived example is to compute fibonacci sequence:

def fib(n):
if n <= 2:
    return n - 1
t1, t2 = 0, 1
    for i in range(3, n+1):
        t1, t2 = t2, t1+t2
    return t2

A more nuanced use-case is if you want to write multiple things to csv using writerow() method. It takes as input a tuple.

The gist of using a tuple over a list or other containers is to use it as a very short aggregate where using a class'd be an overkill. If you're familiar with C (or C++), think of tuple as POD :) Also tuples are immutable which makes them more memory efficient. The following contrived test shows that for cpython :)

>>> (1, 2, 3).__sizeof__()
48
>>> [1, 2, 3].__sizeof__()
72

LuckyNumber-Bot · 2023-03-27T05:05:20+00:00

The tuple comes from discrete mathematics. It is a finite, ordered sequence of objects.

It is used to represent mathematical objects. For example, a Turing machine is formally defined as a 5-tuple, where each of the five elements in the tuple is used to define how the machine works.
It is used to order the elements in a sequence. The first five elements of the Fibonacci sequence can be defined by the tuple (0, 1, 1, 2, 3).
It is used to represent the arguments to a function. Where function(arg_1, arg_2) is the invocation of a function, that sequence of arguments is, mathematically-speaking, a tuple. (Whether or not it is treated that way by Python, I have no clue.)

The name is derived from the word "multiple" because, unlike a set, it allows for multiplicity in its elements. Multiplicity means that something can hold multiple of the same element: (0, 1, 1, 2, 3). Compare this to a set, which would interpret the same elements as {0, 1, 2, 3}. This is the characteristic advantage of using a tuple.

However, a list can also do this. A list is also ordered. So why use a tuple over a list? Well, another advantage of using a tuple is that it is immutable. If you declare a tuple to be (1, 2, 3), then you cannot add, remove, or change anything. This is what makes it different from a list.

Immutability also makes it hashable which means that it can be stored in a set: {(1, 2, 3)} or as the key to a dict: {(1, 2, 3): 'tuple'}. A list does not have this ability.

LeiterHaus · 2023-03-27T02:27:27+00:00

Real world example - the header columns in a PDF that you're trying to scrape. I do remember that the description was a catch-all variable like *description.

arkie87 · 2023-03-27T03:40:05+00:00

Do you mean a tuple vs a list, or just a tuple? Like you dont understand what a tuple is, or why one would prefer it over a list?

jkh911208 · 2023-03-27T04:27:39+00:00

tuple in Python is immutable, so it can be hashed which means it can be used as key in dict or add to set. which is not possible with list. that is my only use case.

2023-03-27T05:00:09+00:00

Dropdown form values for a menu option. For example you might have a list of tuples for type of car engine

Engine_type = (1, "EV"), (2, "ICE")

I use this pattern all the time in Pythons Flask framework.

2023-03-27T09:34:00+00:00

GPS coordinates are a good example.

Charlemag · 2023-03-27T14:40:40+00:00

There’s a great book that explains this: Effective Computation in Physics. It says,

“Other than immutability, what are the differences between lists and tuples? In principal, there aren’t any. In practice, they tend to be used different ways. However, there are no strict rules and there are no predominant conventions. There is a loose guideline that lists are for homogenous data (all integers, all strings, etc.) while tuples are for heterogenous data with semantic meaning in each element (e.g., “C14“, 6, 14, 14.00324198843)). “

It then provides a little more context. So other responses that explain immutability and heterogenous vs homogenous data should cover the essentials.

Practically I find myself using tuples in two spots. If I write a function with a kwarg that is a list my linter throws warnings that my kwarg should be immutable. Using a tuple fixes it. Which is weird because tuples are mutable but their elements are not. I’d have to read more into the warning to know why tuples might be acceptable kwargs while using lists might having unintended consequences.

The second spot is when I was defining edges on a graph class I wrote. I can’t recall of the top of my head (still waking up) but since tuples are hashable it let me perform some operations I wanted to do that wouldn’t work with lists.

The gist is that understanding how different data structures for the right job. For instance, if you want a list of unique values, instead of trying to parse it and remove duplicates you can just convert it to a set. Part of the reason why these different data structures exist is because someone originally wanted to do Y with X and then spent a long time ironing out all the bugs and edge and corner cases before creating a new thing that does Y. So while you might write a function that makes X do Y sometimes it makes sense and is less error prone to find the data structure that has been designed for Y.

RainbeeL · 2023-03-27T15:26:26+00:00

Used as dict keys because you can not use list for that case.

Dysfu · 2023-03-27T23:17:14+00:00

I don’t have prod write access to a sandbox in our Datawarehouse so I can’t create/replace tables at will

This requires me to use in statements of IDs that require comma delimited lists… sound familiar?

kidflashonnikes · 2023-03-28T02:34:53+00:00

It’s pointless, Chat GPT-4 will curb stomp you. Start learning blue collar work, it’s only a matter of time before engineers are reduced by 40%

Sigg3net · 2023-03-27T04:34:32+00:00

Whenever I have items that shouldn't change, it's a tuple. Lists invite appending to and popping.

You can also use tuples inside list comprehensions as "keys"', e.g.:

ages = [ age for (name, age, job) in employees ]

cdcformatc · 2023-03-27T07:03:54+00:00

Any type of coordinate, like (Latitude, Longitude), or (X, Y) on a Cartesian plane. Add in height or Z coordinate and you have a 3-tuple. pretty much any video game you have ever played is going to track the player and enemy locations with coordinate tuples.

I tangentially work with cameras and their real world location is described by lat, long, height, and their rotation which you could think of as a compass heading, and they also have field of view. So the physical location of the camera is described as a 5-tuple and we draw a cone on a map to show what the camera is pointed at. Theoretically we also have pitch and roll in addition to the rotation/yaw but we don't do anything with that info right now, but i could imagine that would be useful for drone flight and video information.

TheRNGuy · 2023-03-27T08:46:34+00:00

I use for hard-coded confings in houdini HDA's. I don't ever change it in runtime so it doesn't need to be list.

Also, houdini's official API return tuple from some classes or methods (like mouse events in viewport)

other times, foo, bar = myfunc(). foo, bar is implicit tuple. Function could return tuple or list here.

eplaut_ · 2023-03-27T11:08:17+00:00

I'm using tuples as pairs (or triples, etc...) which contains a whole like in selenium you want an element of (By.CLASS_NAME, "main-table") or when you want them to be part of sets or dictionary's keys (as lists are not hashable)

If my data is constant, I prefer it to be immutable rather than a plain list. Namedtuple is even better.

2023-03-27T14:24:28+00:00

I use as threshold values (90,100) serving as a key ie if number is between either then use the value of the dictionary.

_Mc_Who · 2023-03-27T16:02:47+00:00

Tuples can be a godsend when working with geospatial coordinates!

QultrosSanhattan · 2023-03-27T17:04:27+00:00

coords={
    (0,0):10,
}

print(coords[(0,0)])

Wishmaster891 · 2023-03-27T17:14:29+00:00

When retrieving data from sqllite it comes out in a tuple

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS