Как указать размер списка в python

Как в питоне объявить список фиксированной длины, но не заполнять его?

Вызове ошибку MemoryError , потому, что список в добавок к объявлению заполняется числами от 0 до 999999999.

Отслеживать
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
задан 15 янв 2018 в 11:44
alex romancov alex romancov
416 1 1 золотой знак 3 3 серебряных знака 15 15 бронзовых знаков

Встречный вопрос — а зачем? Если вы больше раскажете о своей задаче, то вам могут подсказать другие решения. PS не стоит применять шаблоны С/С++ в Python

15 янв 2018 в 11:47

«Вот в с++ к примеру это делается легко», правда, результат немного не компилируется 🙂 ideone.com/Or9N3C

– user181100
15 янв 2018 в 11:54

Вы не можете создать список фиксированной длины, не заполнив его, ни в питоне, ни c++, ни в си, ни в любом другом языке. Список обязательно будет заполнен хоть чем-нибудь — например, нулями, null или None. И в любом из этих случаев вы рискуете получить MemoryError или его аналог в любом языке.

15 янв 2018 в 12:00
int arr[10]; тоже выделяет память для массива.
15 янв 2018 в 12:11

5 ответов 5

Сортировка: Сброс на вариант по умолчанию

Список фиксированной длины — это скорее всего МАССИВ. Тогда так:

import numpy as np MAXSIZE = 1000000 l = np.empty(MAXSIZE, dtype=np.int16) 

только он будет заполнен «остаточным мусором», а не «Ничем». Ничем вам показали в другом ответе )
Реализация массива в numpy намного более экономна по расходованию памяти, чем стандартный список, но не позволяет хранить объекты разных типов и добавлять или удалять элементы массива.
Кстати — если тип не указывать, то будет массив float

Отслеживать
ответ дан 15 янв 2018 в 12:06
Vasyl Kolomiets Vasyl Kolomiets
4,080 5 5 золотых знаков 26 26 серебряных знаков 49 49 бронзовых знаков
И всё равно на больших размерах будет MemoryError
15 янв 2018 в 12:08

@Александр ну для решения этой проблемы есть распределенное хранение данных на нескольких серверах, SPARK в конце концов. Как известно — память ограничена физически, а натуральный ряд — нет. (: Всегда найдется «слишком большой» размер массива

15 янв 2018 в 12:10

Удивительно, что автор принял и этот ответ тоже, ведь он не решает ни одной из проблем, обозначенных в вопросе (в котором, кстати, правок не было)

15 янв 2018 в 12:25
@andreymal — я привел точный аналог int arr[10]; для пайтона. Это то что хотел автор.
15 янв 2018 в 12:28

@КонстантинЛи этот ответ также к MemoryError ведёт (может быть с небольшой задержкой. К примеру, у меня на телефоне numpy.empty(10**9) вызывает MemoryError

15 янв 2018 в 15:11

Список в Питоне содержит ссылки на объекты. Нельзя создать список, заданного размера, не заполнив его. Даже если все ссылки указывают на None:

L = [None] * 10**9 

необходимо место под сами ссылки и рано или поздно вы получите MemoryError (мне не известны реализации Питона, где списки лениво создаются). См. Размер списка в Python и объём оперативной памяти

В качестве альтернативы, вы можете пустой список создать:

и добавлять к нему элементы к нему по мере необходимости ( L.append(<>) ). Это не спасёт от MemoryError при достаточно большом количестве элементов.

Если вы хотите создать массив чисел, то для экономии памяти можно использовать array модуль, который может более компактное представление иметь. К примеру, что создать массив с миллиардом нулей:

import array a = array.array('i', [0]) * 10**9 

Это меньше памяти чем обычный список может занимать, но от MemoryError при достаточно больших размерах это не спасёт (также как и numpy.empty(10**9) ). Reserve memory for list in Python?

Чтобы память не требовать, можно использовать ленивые последовательности, к примеру, в Питоне 3:

R = range(10**9) 

Нужные элементы на лету могут создаваться. Большие размеры, такие как range(10**21) , не приводят к MemoryError в этом случае. Можно также свои классы создавать, к примеру, размер GmtimeOverflowTable практически не ограничен.

Как узнать длину списка в Python

В Python есть несколько способов для того, чтобы узнать длину списка. Длина списка — это количество элементов в нем. В этой статье мы рассмотрим три метода для определения длины списка. Как правило, наиболее эффективным является метод len(). Поскольку список — это объект, его размер уже хранится в памяти для быстрого извлечения.

Метод len()

Найти длину списка можно с помощью встроенного метода len() . Он принимает последовательность или коллекцию в качестве аргумента и возвращает количество элементов, которые в них есть.

Синтаксис метода len() следующий:

len(s)

В данном примере вы увидите список и определение его длины с помощью метода len():

inp_lst = ['Python', 'Java', 'Ruby', 'JavaScript'] size = len(inp_lst) print(size)

Вывод будет следующим:

Альтернативные способы определения длины списка

Метод len() обычно является наиболее эффективным способом определения длины списка, но в Python есть и несколько других.

Метод length_hint()

Модуль operator в Python содержит метод length_hint(), который позволяет оценить длину заданного итерируемого объекта. Если длина известна, то метод length_hint() возвращает фактическую длину, в противном случае он возвращает предполагаемую длину. Длина списков всегда известна, поэтому обычно для ее оценки используется метод len().

Синтаксис метода length_hint():

length_hint(object)

В следующем примере вы увидите список и определение его длины с помощью метода length_hint():

from operator import length_hint inp_lst = ['Python', 'Java', 'Ruby', 'JavaScript'] size = length_hint(inp_lst) print(size)

Получим следующий вывод:

Цикл for

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

Основные этапы определения длины списка с помощью цикла for:

• Объявите переменную counter и инициализируйте ее нулем.

counter = 0

• При помощи цикла for выполните перебор всех элементов данных и, находя новый элемент, увеличивайте переменную counter на 1.

for item in list: counter += 1

• Длина массива хранится в переменной counter, а сама переменная представляет количество элементов в списке. Переменная может быть использована в другом коде или выводе.

print(counter)

В следующем примере показано, как определить длину списка с помощью цикла:

inp_lst = ['Python', 'Java', 'Ruby', 'JavaScript'] size = 0 for x in inp_lst: size += 1 print(size)

Вывод будет следующим:

Читайте также: Циклы for в Python 3

Массивы и списки в Python

Рассмотрим в уроке массивы и их виды, списки, нумерацию списков и основные методы при работе с ними.

Массивы

Мы уже рассматривали строковой тип данных. Он представляется как массив символов и обозначается как array. Массивы могут быть одномерными и многомерны.

Перед началом работы с массивами подключаем соответствующий модуль. Для этого введем команду:

from array import *

Создадим массив для данных типа int:

>>> a = array('i', [2, 5, 4, 0, 8]) >>> type(a) >>> a array('i', [2, 5, 4, 0, 8])

Теперь обратимся к каждому из элементов данного массива. Попробуем изменить их и дополнить массив:

>>> a[2] 4 >>> a[6] Traceback (most recent call last): File "", line 1, in a[6] IndexError: array index out of range

Как видите, нельзя обратиться к элементу, которого нет.

Любой массив может содержать данные только одного типа, то есть нельзя использовать int и float в одном массиве. Это является недостатком при работе, для устранения которого были введены списки (list).

Список в Python

Список в Python похож на массив. Различие в том, что в списках можно хранить объекты различных типов данных. Размер списка не статичен и поддается изменениям.

На программном уровне переменная, определяемая как список, содержит ссылку на структуру в памяти, которая хранит ссылки на какие-либо другие объекты или структуры.

Рассмотрим на примере:

>>> a = [] >>> type(a)

Теперь добавим элементы и проверим доступ к ним:

>>> a = [1,0.34,"Hello"] >>> a [1, 0.34, 'Hello'] >>> a[2] 'Hello' >>> a[0] 1 >>> a[1] 0.34

Нумерация списка в Python

Прямая и обратная нумерация

По умолчанию нумерация начинается с 0.

a = [1, 'abc', h, 0,256] 0 1 2 3 

При обратной нумерации элементы считаются с конца и начинаются с -1:

a = [1, 'abc', h, 0,256] -4 -3 -2 -1

С помощью этих индексов можем обратиться к каждому элементу списка:

a[0] >>> 1 a[-2] >>> h

Срез

Срез — это некий диапазон символов, к которому мы обращаемся. При срезе вторым числом мы указываем номер символа, который не входит в диапазон:

a[0:2] #[1, 'abc'] a[-4:-2] #[1, 'abc']

Мы можем обратиться и к символам с использованием разных нумераций одновременно:

a[0:-2] #[1, 'abc']

Если мы не укажем одну из границ среза, то программа принимает за границу первый или последний символ:

a[:2] #[1, 'abc'] a[2:] #[h, 0,256]

Методы работы со списками

Рассмотрим основные методы работы со списками на примерах.

list.append(x)

Добавляет в конце списка новый элемент x:

>>> a = [0,0.1,"один"] >>> a.append(321) >>> a [0, 0.1, 'один', 321]

list.insert(i,x)

Вставка элемента x на место i (нумерация начинается с нуля):

>>> a = [0,0.1,"один"] >>> a.insert(1,321) >>> a [0, 321, 0.1, 'один']

list.extend(L)

Добавляет в конец списка список L:

>>> a = [0,0.1,"один"] >>> b = ["два",3,4.1] >>> a.extend(b) >>> a [0, 0.1, 'один', 'два', 3, 4.1]

list.remove(x)

Удаляет первый встреченный элемент со значением x:

>>> a = [0,0.1,"один",0] >>> a.remove(0) >>> a [0.1, 'один', 0]

list.pop(i)

Возвращает элемент, размещенный по индексу i, удаляет его из списка:

>>> a = [0,0.1,"один",0] >>> a.pop(3) 0 >>> a [0, 0.1, 'один']

list.count(x)

Возвращает количество элементов, равных x:

>>> a = [0,0.1,"один",0] >>> a.count(0) 2

list.clear()

>>> a = [0,0.1,"один",0] >>> a [0, 0.1, 'один', 0] >>> a.clear() >>> a []

Курсы Робикс, в которых изучается этот материал.

1. Программирование на Python в Minecraft
2. Duckietown робот с системой Автопилота

Массивы

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

Раньше мы сталкивались с задачей обработки элементов последовательности, например, вычисляя наибольший элемент последовательности. Но при этом мы не сохраняли всю последовательность в памяти компьютера, однако, во многих задачах нужно именно сохранять всю последовательность, например, если бы нам требовалось вывести все элементы последовательности в возрастающем порядке (“отсортировать последовательность”).

Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:

Primes = [2, 3, 5, 7, 11, 13]
Rainbow = ['Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet']

В списке Primes — 6 элементов, а именно, Primes[0] == 2, Primes[1] == 3, Primes[2] == 5, Primes[3] == 7, Primes[4] == 11, Primes[5] == 13. Список Rainbow состоит из 7 элементов, каждый из которых является строкой.

Также как и символы строки, элементы списка можно индексировать отрицательными числами с конца, например, Primes[-1] == 13, Primes[-6] == 2.

Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len, например, len(A) == 6.

Рассмотрим несколько способов создания и считывания списков. Прежде всего можно создать пустой список (не содержащий элементов, длины 0), в конец списка можно добавлять элементы при помощи метода append. Например, если программа получает на вход количество элементов в списке n, а потом n элементов списка по одному в отдельной строке, то организовать считывание списка можно так:

A = []
for i in range(int(input()): 
A.append(int(input())

В этом примере создается пустой список, далее считывается количество элементов в списке, затем по одному считываются элементы списка и добавляются в его конец.

Для списков целиком определены следующие операции: конкатенация списков (добавление одного списка в конец другого) и повторение списков (умножение списка на число). Например:

A = [1, 2, 3]
B = [4, 5]
C = A + B
D = B * 3

В результате список C будет равен [1, 2, 3, 4, 5], а список D будет равен [4, 5, 4, 5, 4, 5]. Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i-й элемент списка:

A = [0] * int(input())
for i in range(len(A)): 
A[i] = int(input())

Вывести элементы списка A можно одной инструкцией print(A), при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:

for i in range(len(A)): 
print(A[i])

Здесь в цикле меняется индекс элемента i, затем выводится элемент списка с индексом i.

for elem in A: 
print(elem, end = ' ')

В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’, ‘green’, ‘blue’.