maximum - ¿Cómo establecer una longitud máxima para una lista/conjunto de python?

python maximum of a list

Question

En c / c ++, podríamos tener:

maxnum = 10;
double xlist[maxnum];

¿Cómo establecer una longitud máxima para una lista / conjunto de python?

Answer 1

Aquí está la versión extendida de la list de python. Se comporta como list , pero aumentará BoundExceedError , si se excede la longitud (probado en Python 2.7):

class BoundExceedError(Exception):
pass
class BoundList(list):
def __init__(self, *args, **kwargs):
self.length = kwargs.pop(''length'', None)
super(BoundList, self).__init__(*args, **kwargs)
def _check_item_bound(self):
if self.length and len(self) >= self.length:
raise BoundExceedError()
def _check_list_bound(self, L):
if self.length and len(self) + len(L) > self.length:
raise BoundExceedError()
def append(self, x):
self._check_item_bound()
return super(BoundList, self).append(x)
def extend(self, L):
self._check_list_bound(L)
return super(BoundList, self).extend(L)
def insert(self, i, x):
self._check_item_bound()
return super(BoundList, self).insert(i, x)
def __add__(self, L):
self._check_list_bound(L)
return super(BoundList, self).__add__(L)
def __iadd__(self, L):
self._check_list_bound(L)
return super(BoundList, self).__iadd__(L)
def __setslice__(self, *args, **kwargs):
if len(args) > 2 and self.length:
left, right, L = args[0], args[1], args[2]
if right > self.length:
if left + len(L) > self.length:
raise BoundExceedError()
else:
len_del = (right - left)
len_add = len(L)
if len(self) - len_del + len_add > self.length:
raise BoundExceedError()
return super(BoundList, self).__setslice__(*args, **kwargs)

Uso

>>> l = BoundList(length=10)
>>> l.extend([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
>>> l
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> # now all these attempts will raise BoundExceedError:
>>> l.append(11)
>>> l.insert(0, 11)
>>> l.extend([11])
>>> l += [11]
>>> l + [11]
>>> l[len(l):] = [11]

Answer 2

No se puede, las listas y los conjuntos son de naturaleza dinámica y pueden crecer a cualquier tamaño.

Python no es c ++, python es un lenguaje dinámico. Los conjuntos y la lista se pueden ampliar o reducir a cualquier tamaño.

Utilice el módulo heapq si desea x elementos más pequeños o más grandes de un iterable.

heapq.nsmallest(n, iterable[, key])

Devuelva una lista con los n elementos más pequeños del conjunto de datos definido por iterable. key, si se proporciona, especifica una función de un argumento que se usa para extraer una clave de comparación de cada elemento en iterable: key = str.lower Equivalent to: sorted (iterable, key = key) [: n]

O puede ser un módulo bisect :

Este módulo proporciona soporte para mantener una lista ordenada sin tener que ordenar la lista después de cada inserción.

Luego, usa slicing o itertools.slice para obtener los mejores x elementos de la lista.

Answer 3

Una vez que tengas tu lista, lst , puedes

if len(lst)>10:
lst = lst[:10]

Si el tamaño de más de 10 elementos, se trunca a los primeros diez elementos.

Answer 4

Usted no lo hace y no necesita hacerlo.

Las listas de Python crecen y se reducen dinámicamente según sea necesario para adaptarse a sus contenidos. Los conjuntos se implementan como una tabla hash, y al igual que los diccionarios de Python, crecen y se reducen dinámicamente según sea necesario para ajustarse a sus contenidos.

¿Quizás estaba buscando collections.deque (que toma un parámetro maxlen ) o algo usando un heapq (usando heapq.heappushpop() cuando ha alcanzado el máximo)?