Named tuples were added in 2.6 for this purpose. Also see os.stat for a similar builtin example.

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

In recent versions of Python 3 (3.6+, I think), the new typing library got the NamedTuple class to make named tuples easier to create and more powerful. Inheriting from typing.NamedTuple lets you use docstrings, default values, and type annotations.

Example (From the docs):

class Employee(NamedTuple):  # inherit from typing.NamedTuple
    name: str
    id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

You cannot return two values, but you can return a tuple or a list and unpack it after the call:

Copydef select_choice():
    ...
    return i, card  # or [i, card]

my_i, my_card = select_choice()

On line return i, card i, card means creating a tuple. You can also use parenthesis like return (i, card), but tuples are created by comma, so parens are not mandatory. But you can use parens to make your code more readable or to split the tuple over multiple lines. The same applies to line my_i, my_card = select_choice().

If you want to return more than two values, consider using a named tuple. It will allow the caller of the function to access fields of the returned value by name, which is more readable. You can still access items of the tuple by index. For example in Schema.loads method Marshmallow framework returns a UnmarshalResult which is a namedtuple. So you can do:

Copydata, errors = MySchema.loads(request.json())
if errors:
    ...

or

Copyresult = MySchema.loads(request.json())
if result.errors:
    ...
else:
    # use `result.data`

In other cases you may want to return a dict from your function:

Copydef select_choice():
    ...
    return {'i': i, 'card': card, 'other_field': other_field, ...}

But consider returning an instance of a utility class (or a Pydantic/dataclass model instance), which wraps your data:

Copyclass ChoiceData(pydantic.BaseModel):
    i: int
    card: str
    other_field: typing.Any

def select_choice():
    ...
    return ChoiceData(i=i, card=card, other_field=other_field)

choice_data = select_choice()
print(choice_data.i, choice_data.card)

EDIT: Since Python 3.9 and the acceptance of PEP 585, you should use the built-in tuple class to typehint tuples.

You can use a typing.Tuple type hint (to specify the type of the content of the tuple, if it is not necessary, the built-in class tuple can be used instead):

from typing import Tuple, List

def greeting(name: str) -> Tuple[str, List[float], int]:
    # do something
    return a, b, c