python有不可变的列表吗？
假设我希望有一个有序的元素集合的功能，但我想保证不会改变，这如何实现？列表是有序的，但它们可以改变。
问问题
83850 次
7 回答
124
是的。它被称为tuple.
因此，不是[1,2]which is a listand which can be mutated，(1,2)而是 is a tupleand cannot。
更多信息：
单元素tuple不能通过 write 实例化(1)，相反，您需要 write (1,)。这是因为解释器对括号有各种其他用途。
您也可以完全取消括号：1,2与(1,2)
请注意，元组并不完全是不可变列表。单击此处阅读有关列表和元组之间差异的更多信息
于 2012-06-21T16:15:55.063 回答
10
这是一个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()
于 2014-01-10T18:23:24.700 回答
7
您可以使用双元素元组模拟 Lisp 样式的不可变单链表（注意：这与任何元素元组 answer不同，后者创建的元组灵活性要差得多）：
nil = ()
cons = lambda ele, l: (ele, l)
例如对于 list [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)。由于这个列表是不可变的，如果列表中的底层元素也是不可变的，那么您可以安全地共享任何子列表以在另一个列表中重用。
于 2019-03-23T04:59:48.747 回答
4
但是如果有数组和元组的元组，那么元组里面的数组是可以修改的。
>>> a
([1, 2, 3], (4, 5, 6))
>>> a[0][0] = 'one'
>>> a
(['one', 2, 3], (4, 5, 6))
于 2014-03-21T20:44:11.783 回答
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
于 2018-07-25T17:27:29.093 回答
0
这个问题值得一个现代的答案，现在类型注释和类型检查通过mypy变得越来越流行。
使用类型注释时，用元组替换 aList[T]可能不是理想的解决方案。从概念上讲，列表的泛型数量为 1，即，它们有一个泛型参数T（当然，这个参数可以是 aUnion[A, B, C, ...]来解释异构类型的列表）。相反，元组本质上是可变参数泛型Tuple[A, B, C, ...]。这使得元组成为一个尴尬的列表替换。
实际上，类型检查提供了另一种可能性：可以通过 using 将变量注释为不可变列表typing.Sequence，它对应于不可变接口的类型collections.abc.Sequence。例如：
from typing import Sequence
def f(immutable_list: Sequence[str]) -> None:
# We want to prevent mutations like:
immutable_list.append("something")
mutable_list = ["a", "b", "c"]
f(mutable_list)
print(mutable_list)
当然，就运行时行为而言，这不是一成不变的，也就是说，Python 解释器会很高兴地 mutate immutable_list，并且输出会是["a", "b", "c", "something"].
但是，如果您的项目使用类似的类型检查器mypy，它将拒绝以下代码：
immutable_lists_1.py:6: error: "Sequence[str]" has no attribute "append"
Found 1 error in 1 file (checked 1 source file)
所以在后台你可以继续使用常规列表，但是类型检查器可以有效地防止在类型检查时发生任何突变。
同样，您可以防止修改列表成员，例如在不可变数据类中：
@dataclass(frozen=True)
class ImmutableData:
immutable_list: Sequence[str]
def f(immutable_data: ImmutableData) -> None:
# mypy will prevent mutations here as well:
immutable_data.immutable_list.append("something")
相同的原理可以通过typing.Mapping.
于 2021-09-28T08:47:22.447 回答
-2
您可以使用frozenset 来代替元组。freezeset 创建一个不可变的集合。您可以使用 list 作为 freezeset 的成员，并使用单个 for 循环访问 freezeset 内列表的每个元素。
于 2016-02-01T11:35:18.043 回答