Krojenie krotkowe nie zwraca nowego obiektu w przeciwieństwie do krojenia listowego

W Pythonie (2 i 3). Ilekroć używamy wycinania list, zwraca nowy obiekt, np .:

l1 = [1,2,3,4]
print(id(l1))
l2 = l1[:]
print(id(l2))

Wynik

>>> 140344378384464
>>> 140344378387272

Jeśli to samo powtarza się z krotką, zwracany jest ten sam obiekt, np .:

t1 = (1,2,3,4)
t2 = t1[:]
print(id(t1))
print(id(t2))

Wynik

>>> 140344379214896
>>> 140344379214896

Byłoby wspaniale, gdyby ktoś mógł wyjaśnić, dlaczego tak się dzieje, przez całe moje doświadczenie w Pythonie miałem wrażenie, że pusty plasterek zwraca nowy obiekt.

Rozumiem, że zwraca ten sam obiekt, ponieważ krotki są niezmienne i nie ma sensu tworzyć nowej kopii. Ale znowu, nigdzie nie wspomniano w dokumentach.

Implementacje mogą zwracać identyczne instancje dla typów niezmiennych (w CPython możesz czasem zobaczyć podobne optymalizacje dla ciągów i liczb całkowitych). Ponieważ obiekt nie może zostać zmieniony, w kodzie użytkownika nie ma nic, co musiałoby dbać o to, czy zawiera on unikalną instancję, czy tylko inne odniesienie do istniejącej instancji.

Zwarcie można znaleźć w kodzie C tutaj .

static PyObject*
tuplesubscript(PyTupleObject* self, PyObject* item)
{
    ... /* note: irrelevant parts snipped out */
    if (start == 0 && step == 1 &&
                 slicelength == PyTuple_GET_SIZE(self) &&
                 PyTuple_CheckExact(self)) {
            Py_INCREF(self);          /* <--- increase reference count */
            return (PyObject *)self;  /* <--- return another pointer to same */
        }
    ...

Jest to szczegół implementacji, zauważ, że pypy nie robi tego samego.

To szczegół implementacji. Ponieważ listy są zmienne, l1[:] musisz utworzyć kopię, ponieważ nie spodziewałbyś się, że zmiany l2wpłyną l1.

Ponieważ krotka jest niezmienna , nic nie możesz zrobić, aby t2wpłynąć na nią t1w jakikolwiek widoczny sposób, więc kompilator może swobodnie (ale nie musi ) używać tego samego obiektu dla t1i t1[:].

W Pythonie 3. * my_list[:]jest cukrem składniowym, dla type(my_list).__getitem__(mylist, slice_object)którego: slice_objectjest obiektem wycinka zbudowanym z my_listatrybutów (długości) i wyrażenia [:]. Obiekty, które zachowują się w ten sposób, nazywane są subskrybowalnymi w modelu danych Python, patrz tutaj . W przypadku list i krotek __getitem__jest wbudowany metoda.

W CPython oraz dla list i krotek __getitem__jest interpretowany przez operację kodu bajtowego, BINARY_SUBSCRktóra jest implementowana dla krotek tutaj i dla list tutaj .

W przypadku krotek, spacery przez kod widać, że w tym bloku kodu , static PyObject* tuplesubscript(PyTupleObject* self, PyObject* item)powróci odniesienie do tego samego PyTupleObject, który dostał jako argumentu wejściowego, jeśli element jest typu PySlicei analizuje schemat plasterek całego krotki.

    static PyObject*
    tuplesubscript(PyTupleObject* self, PyObject* item)
    {
        /* checks if item is an index */ 
        if (PyIndex_Check(item)) { 
            ...
        }
        /* else it is a slice */ 
        else if (PySlice_Check(item)) { 
            ...
        /* unpacks the slice into start, stop and step */ 
        if (PySlice_Unpack(item, &start, &stop, &step) < 0) { 
            return NULL;
        }
       ...
        }
        /* if we start at 0, step by 1 and end by the end of the tuple then !! look down */
        else if (start == 0 && step == 1 &&
                 slicelength == PyTuple_GET_SIZE(self) && 
                 PyTuple_CheckExact(self)) {
            Py_INCREF(self); /* increase the reference count for the tuple */
            return (PyObject *)self; /* and return a reference to the same tuple. */
        ...
}

Teraz sprawdzasz kod static PyObject * list_subscript(PyListObject* self, PyObject* item)i przekonujesz się, że niezależnie od wycinka zawsze zwracany jest nowy obiekt listy.

Nie jestem tego pewien, ale wydaje się, że Python zapewnia nowy wskaźnik do tego samego obiektu, aby uniknąć kopiowania, ponieważ krotki są identyczne (a ponieważ obiekt jest krotką, jest niezmienny).