Изменить то, что операторы *splat и **splatty-splat делают с моим объектом

* перебирает объект и использует его элементы в качестве аргументов. ** перебирает keys объекта и использует __getitem__ (эквивалент скобочной нотации) для выборки пар ключ-значение. Чтобы настроить *, просто сделайте свой объект итерируемым, а чтобы настроить **, сделайте свой объект сопоставлением:

class MyIterable(object):
    def __iter__(self):
        return iter([1, 2, 3])

class MyMapping(collections.Mapping):
    def __iter__(self):
        return iter('123')
    def __getitem__(self, item):
        return int(item)
    def __len__(self):
        return 3

Если вы хотите, чтобы * и ** делали что-то помимо того, что описано выше, вы не можете этого сделать. У меня нет ссылки на документацию для этого утверждения (поскольку легче найти документацию о том, что вы можете это сделать, чем не можете), но у меня есть цитата из источника. Цикл интерпретатора байт-кода в PyEval_EvalFrameEx вызывает ext_do_call для реализации вызовов функций с * или ** аргументами. ext_do_call содержит следующий код:

        if (!PyDict_Check(kwdict)) {
            PyObject *d;
            d = PyDict_New();
            if (d == NULL)
                goto ext_call_fail;
            if (PyDict_Update(d, kwdict) != 0) {

который, если аргумент ** не является словарем, создает словарь и выполняет обычный update для его инициализации из аргументов ключевого слова (за исключением того, что PyDict_Update не принимает список пар ключ-значение). Таким образом, вы не можете настроить ** отдельно от реализации протокола сопоставления.

Точно так же для * аргументов ext_do_call выполняет

        if (!PyTuple_Check(stararg)) {
            PyObject *t = NULL;
            t = PySequence_Tuple(stararg);

что эквивалентно tuple(args). Таким образом, вы не можете настроить * отдельно от обычной итерации.

Было бы ужасно запутанно, если бы f(*thing) и f(*iter(thing)) делали разные вещи. В любом случае, * и ** являются частью синтаксиса вызова функции, а не отдельными операторами, поэтому их настройка (если возможно) будет задачей вызываемого объекта, а не аргумента. Я полагаю, что могут быть варианты использования для того, чтобы позволить вызываемым объектам настраивать их, возможно, для передачи dict подклассов, таких как defaultdict, через...

Мне удалось создать объект, который ведет себя так, как я описал в своем вопросе, но мне действительно пришлось схитрить. Так что просто размещаю это здесь для развлечения, на самом деле -

class Thing:
    def __init__(self):
        self.mode = 'abc'
    def __iter__(self):
        if self.mode == 'abc':
            yield 'a'
            yield 'b'
            yield 'c'
            self.mode = 'def'
        else:
            yield 'd'
            yield 'e'
            yield 'f'
            self.mode = 'abc'
    def __getitem__(self, item):
        return 'I am a potato!!'
    def keys(self):
        return ['hello world']

Протоколу итератора соответствует объект-генератор, возвращенный из __iter__ (обратите внимание, что экземпляр Thing() сам по себе не является итератором, хотя он итерируемый). Протокол отображения удовлетворяется наличием keys() и __getitem__. Тем не менее, если это еще не очевидно, вы не можете вызвать *thing дважды подряд и заставить его распаковать a,b,c дважды подряд - так что на самом деле это не переопределяет splat, как он притворяется.