Есть ли в Python неизменяемый список?

93

Есть ли в Python неизменяемые списки?

Предположим, я хочу иметь функциональность упорядоченного набора элементов, но я хочу гарантировать, что она не изменится. Как это можно реализовать? Списки упорядочены, но могут быть изменены.

python  list  tuples  immutability 
— Cammil
источник
4
@Marcin: Это вопрос в стиле FAQ, который задает и отвечает один и тот же человек.
— RichieHindle
@Marcin: Вы, очевидно, не заметили, что ОП ответила на свой вопрос .
— Sven Marnach
2
Основная мотивация неизменяемых типов в Python заключается в том, что их можно использовать в качестве ключей словаря и в наборах.
— Sven Marnach
16
Прошу прощения, если я кого-то здесь обидел. Я просто искал неизменяемые списки в Google и ничего не нашел. Когда я понял, что искал кортеж, я решил опубликовать его здесь. На всякий случай кто такой «тупой», как я.
— cammil
5
Согласен. Оглядываясь назад, это кажется глупым, но по какой-то причине мой тупой мозг повел меня по ложному пути. Практически полностью использовав списки и, наконец, осознав, что мне нужен неизменяемый, я задал естественный вопрос. Хотя мне было хорошо известно о существовании кортежей, я не связал их. Если это кому-то поможет, то я считаю, что это не бесполезный пост. Однако если это неправильный ответ на этот простой вопрос, то это совсем другое дело.
— cammil

Ответы:

107

Да. Это называется tuple.

Итак, вместо [1,2]which is a listи which can be mutated (1,2)is a tupleand cannot.

Дальнейшая информация:

Один-элемент tupleне может быть создан в письменной форме (1), вместо этого, вы должны писать (1,). Это связано с тем, что в интерпретаторе скобки используются и в других целях.

Вы также можете полностью отказаться от скобок: 1,2это то же самое, что(1,2)

Обратите внимание, что кортеж - это не совсем неизменный список. Щелкните здесь, чтобы узнать больше о различиях между списками и кортежами

— Cammil
источник
6
Кроме того, если вы поместите в кортеж изначально изменяемые указатели на объекты (например ([1,2],3)), кортеж больше не будет по-настоящему неизменным, потому что объект списка является просто указателем на изменяемый объект, и, хотя указатель является неизменяемым, объект, на который указывает ссылка, не является.
— Nisan.H
2
Кроме того, когда вы отвечаете на такой базовый вопрос, по крайней мере, дайте еще несколько объяснений, таких как различия в производительности (кортежи немного быстрее) и что кортежи могут использоваться как ключи dict, тогда как список не может. Я уверен, что есть и другие отличия.
— BrtH
3
Фактически можно записать и пустой кортеж (). Это единственный случай, когда скобки необходимы.
— RemcoGerlich
1
@Kane, ваше утверждение определенно верно для типизированных функциональных языков; в частности, (3,4,5)имеет совсем другой (int x int x int)тип [3,4,5]- чем тип (listof int). Однако кортеж python действительно кажется более близким к неизменяемому списку: в частности, их можно перебирать, и, похоже, они также могут быть отфильтрованы и сопоставлены.
— Джон Клементс
1
Кортеж не является списком, у них нет совместимого поведения, и вы не можете использовать их полиморфно.
— jeremyjjbrown 05
7

Вот реализация ImmutableList. Базовый список не отображается ни в одном из прямых элементов данных. Тем не менее, к нему можно получить доступ с помощью свойства закрытия функции-члена. Если мы будем следовать соглашению не изменять содержимое замыкания с использованием указанного выше свойства, эта реализация будет служить цели. Экземпляр этого класса ImmutableList можно использовать везде, где ожидается обычный список Python.

from functools import reduce

__author__ = 'hareesh'


class ImmutableList:
    """
    An unmodifiable List class which uses a closure to wrap the original list.
    Since nothing is truly private in python, even closures can be accessed and
    modified using the __closure__ member of a function. As, long as this is
    not done by the client, this can be considered as an unmodifiable list.

    This is a wrapper around the python list class
    which is passed in the constructor while creating an instance of this class.
    The second optional argument to the constructor 'copy_input_list' specifies
    whether to make a copy of the input list and use it to create the immutable
    list. To make the list truly immutable, this has to be set to True. The
    default value is False, which makes this a mere wrapper around the input
    list. In scenarios where the input list handle is not available to other
    pieces of code, for modification, this approach is fine. (E.g., scenarios
    where the input list is created as a local variable within a function OR
    it is a part of a library for which there is no public API to get a handle
    to the list).

    The instance of this class can be used in almost all scenarios where a
    normal python list can be used. For eg:
    01. It can be used in a for loop
    02. It can be used to access elements by index i.e. immList[i]
    03. It can be clubbed with other python lists and immutable lists. If
        lst is a python list and imm is an immutable list, the following can be
        performed to get a clubbed list:
        ret_list = lst + imm
        ret_list = imm + lst
        ret_list = imm + imm
    04. It can be multiplied by an integer to increase the size
        (imm * 4 or 4 * imm)
    05. It can be used in the slicing operator to extract sub lists (imm[3:4] or
        imm[:3] or imm[4:])
    06. The len method can be used to get the length of the immutable list.
    07. It can be compared with other immutable and python lists using the
        >, <, ==, <=, >= and != operators.
    08. Existence of an element can be checked with 'in' clause as in the case
        of normal python lists. (e.g. '2' in imm)
    09. The copy, count and index methods behave in the same manner as python
        lists.
    10. The str() method can be used to print a string representation of the
        list similar to the python list.
    """

    @staticmethod
    def _list_append(lst, val):
        """
        Private utility method used to append a value to an existing list and
        return the list itself (so that it can be used in funcutils.reduce
        method for chained invocations.

        @param lst: List to which value is to be appended
        @param val: The value to append to the list
        @return: The input list with an extra element added at the end.

        """
        lst.append(val)
        return lst

    @staticmethod
    def _methods_impl(lst, func_id, *args):
        """
        This static private method is where all the delegate methods are
        implemented. This function should be invoked with reference to the
        input list, the function id and other arguments required to
        invoke the function

        @param list: The list that the Immutable list wraps.

        @param func_id: should be the key of one of the functions listed in the
            'functions' dictionary, within the method.
        @param args: Arguments required to execute the function. Can be empty

        @return: The execution result of the function specified by the func_id
        """

        # returns iterator of the wrapped list, so that for loop and other
        # functions relying on the iterable interface can work.
        _il_iter = lambda: lst.__iter__()
        _il_get_item = lambda: lst[args[0]]  # index access method.
        _il_len = lambda: len(lst)  # length of the list
        _il_str = lambda: lst.__str__()  # string function
        # Following represent the >, < , >=, <=, ==, != operators.
        _il_gt = lambda: lst.__gt__(args[0])
        _il_lt = lambda: lst.__lt__(args[0])
        _il_ge = lambda: lst.__ge__(args[0])
        _il_le = lambda: lst.__le__(args[0])
        _il_eq = lambda: lst.__eq__(args[0])
        _il_ne = lambda: lst.__ne__(args[0])
        # The following is to check for existence of an element with the
        # in clause.
        _il_contains = lambda: lst.__contains__(args[0])
        # * operator with an integer to multiply the list size.
        _il_mul = lambda: lst.__mul__(args[0])
        # + operator to merge with another list and return a new merged
        # python list.
        _il_add = lambda: reduce(
            lambda x, y: ImmutableList._list_append(x, y), args[0], list(lst))
        # Reverse + operator, to have python list as the first operand of the
        # + operator.
        _il_radd = lambda: reduce(
            lambda x, y: ImmutableList._list_append(x, y), lst, list(args[0]))
        # Reverse * operator. (same as the * operator)
        _il_rmul = lambda: lst.__mul__(args[0])
        # Copy, count and index methods.
        _il_copy = lambda: lst.copy()
        _il_count = lambda: lst.count(args[0])
        _il_index = lambda: lst.index(
            args[0], args[1], args[2] if args[2] else len(lst))

        functions = {0: _il_iter, 1: _il_get_item, 2: _il_len, 3: _il_str,
                     4: _il_gt, 5: _il_lt, 6: _il_ge, 7: _il_le, 8: _il_eq,
                     9: _il_ne, 10: _il_contains, 11: _il_add, 12: _il_mul,
                     13: _il_radd, 14: _il_rmul, 15: _il_copy, 16: _il_count,
                     17: _il_index}

        return functions[func_id]()

    def __init__(self, input_lst, copy_input_list=False):
        """
        Constructor of the Immutable list. Creates a dynamic function/closure
        that wraps the input list, which can be later passed to the
        _methods_impl static method defined above. This is
        required to avoid maintaining the input list as a data member, to
        prevent the caller from accessing and modifying it.

        @param input_lst: The input list to be wrapped by the Immutable list.
        @param copy_input_list: specifies whether to clone the input list and
            use the clone in the instance. See class documentation for more
            details.
        @return:
        """

        assert(isinstance(input_lst, list))
        lst = list(input_lst) if copy_input_list else input_lst
        self._delegate_fn = lambda func_id, *args: \
            ImmutableList._methods_impl(lst, func_id, *args)

    # All overridden methods.
    def __iter__(self): return self._delegate_fn(0)

    def __getitem__(self, index): return self._delegate_fn(1, index)

    def __len__(self): return self._delegate_fn(2)

    def __str__(self): return self._delegate_fn(3)

    def __gt__(self, other): return self._delegate_fn(4, other)

    def __lt__(self, other): return self._delegate_fn(5, other)

    def __ge__(self, other): return self._delegate_fn(6, other)

    def __le__(self, other): return self._delegate_fn(7, other)

    def __eq__(self, other): return self._delegate_fn(8, other)

    def __ne__(self, other): return self._delegate_fn(9, other)

    def __contains__(self, item): return self._delegate_fn(10, item)

    def __add__(self, other): return self._delegate_fn(11, other)

    def __mul__(self, other): return self._delegate_fn(12, other)

    def __radd__(self, other): return self._delegate_fn(13, other)

    def __rmul__(self, other): return self._delegate_fn(14, other)

    def copy(self): return self._delegate_fn(15)

    def count(self, value): return self._delegate_fn(16, value)

    def index(self, value, start=0, stop=0):
        return self._delegate_fn(17, value, start, stop)


def main():
    lst1 = ['a', 'b', 'c']
    lst2 = ['p', 'q', 'r', 's']

    imm1 = ImmutableList(lst1)
    imm2 = ImmutableList(lst2)

    print('Imm1 = ' + str(imm1))
    print('Imm2 = ' + str(imm2))

    add_lst1 = lst1 + imm1
    print('Liist + Immutable List: ' + str(add_lst1))
    add_lst2 = imm1 + lst2
    print('Immutable List + List: ' + str(add_lst2))
    add_lst3 = imm1 + imm2
    print('Immutable Liist + Immutable List: ' + str(add_lst3))

    is_in_list = 'a' in lst1
    print("Is 'a' in lst1 ? " + str(is_in_list))

    slice1 = imm1[2:]
    slice2 = imm2[2:4]
    slice3 = imm2[:3]
    print('Slice 1: ' + str(slice1))
    print('Slice 2: ' + str(slice2))
    print('Slice 3: ' + str(slice3))

    imm1_times_3 = imm1 * 3
    print('Imm1 Times 3 = ' + str(imm1_times_3))
    three_times_imm2 = 3 * imm2
    print('3 Times Imm2 = ' + str(three_times_imm2))

    # For loop
    print('Imm1 in For Loop: ', end=' ')
    for x in imm1:
        print(x, end=' ')
    print()

    print("3rd Element in Imm1: '" + imm1[2] + "'")

    # Compare lst1 and imm1
    lst1_eq_imm1 = lst1 == imm1
    print("Are lst1 and imm1 equal? " + str(lst1_eq_imm1))

    imm2_eq_lst1 = imm2 == lst1
    print("Are imm2 and lst1 equal? " + str(imm2_eq_lst1))

    imm2_not_eq_lst1 = imm2 != lst1
    print("Are imm2 and lst1 different? " + str(imm2_not_eq_lst1))

    # Finally print the immutable lists again.
    print("Imm1 = " + str(imm1))
    print("Imm2 = " + str(imm2))

    # The following statemetns will give errors.
    # imm1[3] = 'h'
    # print(imm1)
    # imm1.append('d')
    # print(imm1)

if __name__ == '__main__':
    main()
— хариш
источник
6

Вы можете смоделировать неизменяемый односвязный список в стиле Lisp, используя двухэлементные кортежи (обратите внимание: это отличается от ответа кортежа с любым элементом , который создает гораздо менее гибкий кортеж):

nil = ()
cons = lambda ele, l: (ele, l)

например, для списка у [1, 2, 3]вас будет следующее:

l = cons(1, cons(2, cons(3, nil))) # (1, (2, (3, ())))

Ваш стандарт carи cdrфункции просты:

car = lambda l: l[0]
cdr = lambda l: l[1]

Поскольку этот список односвязен, добавление вперед - O (1). Поскольку этот список неизменяем, если базовые элементы в списке также неизменны, вы можете безопасно поделиться любым подсписком для повторного использования в другом списке.

— Кевинджи
источник
Как эта реализация более гибкая, чем собственный кортеж (a, b, c)?
— Буквально
@Literal Вы можете добавить в начало односвязного списка, в отличие от обычного кортежа, который заморожен. Это то, что делает их более универсальными и делает их неотъемлемой частью языков функционального программирования.
— kevinji
Спасибо за ваш ответ. Я все еще пытаюсь понять преимущества этой реализации, поскольку я также могу добавить элемент, создав новый экземпляр кортежа: (z,) + (a, b, c). Это вопрос производительности?
— Буквально
4

Но если есть кортеж массивов и кортежей, то массив внутри кортежа можно изменить.

>>> a
([1, 2, 3], (4, 5, 6))

>>> a[0][0] = 'one'

>>> a
(['one', 2, 3], (4, 5, 6))
— Гопал
источник
9
На самом деле не может быть такой вещи, как коллекция, которая делает ее содержимое неизменным, потому что вам понадобится способ сделать неизменяемую копию произвольных объектов. Для этого вам придется скопировать классы, к которым принадлежат эти объекты, и даже встроенные классы, на которые они ссылаются. И все же объекты могут относиться к файловой системе, сети или чему-то еще, что всегда будет изменчивым. Итак, поскольку мы не можем сделать произвольный объект неизменяемым, мы должны довольствоваться неизменяемыми коллекциями изменяемых объектов.
— Джек О'Коннор
1
@ JackO'Connor: Не совсем согласен. Все зависит от того, как вы моделируете мир: внешнюю изменчивость всегда можно смоделировать как состояния, развивающиеся во времени, и вместо поддержания одного изменяемого состояния s я всегда могу выбрать ссылку на s_t, который является неизменным. «Неизменяемая коллекция неизменяемых объектов» <- ознакомьтесь с Huskell, Scala и другими языками функционального программирования. Прежде чем я начал изучать Python, я думал, что Python полностью поддерживает неизменяемость и fp из того, что я слышал от других, но это оказалось неправдой.
— Кейн
Я должен был сказать, что в Python такого не может быть. Неизменяемость Python зависит от соблюдения программистом соглашений (например, _private_variables), а не от какого-либо принуждения интерпретатора.
— Джек О'Коннор,
1
Такой язык, как Haskell, дает гораздо больше гарантий, хотя, если программист действительно хотел быть злым, он все равно мог писать /proc/#/memили связывать небезопасные библиотеки или что-то еще, чтобы сломать модель.
— Джек О'Коннор,
1

У List и Tuple разные стили работы.

В LIST мы можем вносить изменения после его создания, но если вы хотите упорядоченную последовательность, в которой никакие изменения не могут быть применены в будущем, вы можете использовать TUPLE.

дальнейшая информация::

 1) the LIST is mutable that means you can make changes in it after its creation
 2) In Tuple, we can not make changes once it created
 3) the List syntax is
           abcd=[1,'avn',3,2.0]
 4) the syntax for Tuple is 
           abcd=(1,'avn',3,2.0) 
      or   abcd= 1,'avn',3,2.0 it is also correct
— Авниш кумар
источник
-1

Вместо кортежа можно использовать frozenset. frozenset создает неизменный набор. вы можете использовать список как член frozenset и получить доступ к каждому элементу списка внутри frozenset с помощью одного цикла for.

— Вишал Мопари
источник
3
Frozenset требует, чтобы его члены набора были хешируемыми, а список - нет.
— matias elgart
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.