Создайте пустой список определенного размера в Python
В этом посте мы обсудим, как создать пустой список заданного размера в Python.
Чтобы присвоить любое значение списку, используя оператор присваивания в позиции i , a[i] = x , размер списка должен быть не менее i+1 . В противном случае он поднимет IndexError , как показано ниже:
if __name__ == ‘__main__’ :
# поднять IndexError: индекс назначения списка вне допустимого диапазона
Решение состоит в том, чтобы создать пустой список None когда элементы списка заранее неизвестны. Это можно легко сделать, как показано ниже:
if __name__ == ‘__main__’ :
a = [ None ] * 5
# prints [None, None, None, None, None]
Приведенный выше код создаст список размеров 5 , где каждая позиция инициализируется None . None часто используется в Python для обозначения отсутствия значения.
Другой альтернативой для создания пустых списков заданного размера является использование генераторов списков:
if __name__ == ‘__main__’ :
a = [ None for x in range ( 5 ) ]
Какое решение использовать?
Первое решение хорошо работает для нессылочных типов, таких как числа. Но в некоторых случаях вы можете столкнуться с ошибками ссылок. Например, [[]] * 5 приведет к повторению списка, содержащего один и тот же объект списка 5 раз.
if __name__ == ‘__main__’ :
a [ 0 ] . append ( 1 )
# печатает [[1], [1], [1], [1], [1]]
Решение этой проблемы заключается в использовании списков, подобных этому:
if __name__ == ‘__main__’ :
a = [ [ ] for x in range ( 5 ) ]
a [ 0 ] . append ( 1 )
# печатает [[1], [], [], [], []]
Это все о создании пустого списка заданного размера в Python.
Также см:
Оценить этот пост
Средний рейтинг 4.9 /5. Подсчет голосов: 20
Голосов пока нет! Будьте первым, кто оценит этот пост.
Сожалеем, что этот пост не оказался для вас полезным!
Расскажите, как мы можем улучшить этот пост?
Спасибо за чтение.
Пожалуйста, используйте наш онлайн-компилятор размещать код в комментариях, используя C, C++, Java, Python, JavaScript, C#, PHP и многие другие популярные языки программирования.
Как мы? Порекомендуйте нас своим друзьям и помогите нам расти. Удачного кодирования 🙂
Подписывайся
1 Комментарий
Большинство голосов
Новейшие Самый старый
Встроенные отзывы
Просмотреть все комментарии
Просмотр комментариев
Загрузить больше комментариев
Просматривать
Подпишитесь на новые публикации
- Все проблемы
- Практика DSA
- 100 самых популярных задач
- 50 лучших классических задач
- Лучшие алгоритмы
- Компилятор С/С++
- Компилятор Java
- Компилятор Python
- Компилятор JavaScript
- компилятор PHP
- Компилятор C#
- Свяжитесь с нами
- Политика конфиденциальности
- условия обслуживания
- Подпишитесь на новые публикации
Techie Delight © 2023 Все права защищены.
Этот веб-сайт использует файлы cookie. Используя этот сайт, вы соглашаетесь с использованием файлов cookie, нашей политикой, условиями авторского права и другими условиями. Читайте наши Политика конфиденциальности. Понятно
Списки, кортежи и словари
Для работы с наборами данных Python предоставляет такие встроенные типы как списки, кортежи и словари.
Список (list) представляет тип данных, который хранит набор или последовательность элементов. Во многих языках программирования есть аналогичная структура данных, которая называется массив.
Создание списка
Для создания списка применяются квадратные скобки [] , внутри которых через запятую перечисляются элементы списка. Например, определим список чисел:
numbers = [1, 2, 3, 4, 5]
Подобным образом можно определять списки с данными других типов, например, определим список строк:
people = ["Tom", "Sam", "Bob"]
Также для создания списка можно использовать функцию-конструктор list() :
numbers1 = [] numbers2 = list()
Оба этих определения списка аналогичны — они создают пустой список.
Список необязательно должен содержать только однотипные объекты. Мы можем поместить в один и тот же список одновременно строки, числа, объекты других типов данных:
objects = [1, 2.6, "Hello", True]
Для проверки элементов списка можно использовать стандартную функцию print, которая выводит содержимое списка в удобочитаемом виде:
numbers = [1, 2, 3, 4, 5] people = ["Tom", "Sam", "Bob"] print(numbers) # [1, 2, 3, 4, 5] print(people) # ["Tom", "Sam", "Bob"]
Конструктор list может принимать набор значений, на основе которых создается список:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list(numbers1) print(numbers2) # [1, 2, 3, 4, 5] letters = list("Hello") print(letters) # ['H', 'e', 'l', 'l', 'o']
Если необходимо создать список, в котором повторяется одно и то же значение несколько раз, то можно использовать символ звездочки *, то есть фактически применить операцию умножения к уже существующему списку:
numbers = [5] * 6 # 6 раз повторяем 5 print(numbers) # [5, 5, 5, 5, 5, 5] people = ["Tom"] * 3 # 3 раза повторяем "Tom" print(people) # ["Tom", "Tom", "Tom"] students = ["Bob", "Sam"] * 2 # 2 раза повторяем "Bob", "Sam" print(students) # ["Bob", "Sam", "Bob", "Sam"]
Обращение к элементам списка
Для обращения к элементам списка надо использовать индексы, которые представляют номер элемента в списка. Индексы начинаются с нуля. То есть первый элемент будет иметь индекс 0, второй элемент — индекс 1 и так далее. Для обращения к элементам с конца можно использовать отрицательные индексы, начиная с -1. То есть у последнего элемента будет индекс -1, у предпоследнего — -2 и так далее.
people = ["Tom", "Sam", "Bob"] # получение элементов с начала списка print(people[0]) # Tom print(people[1]) # Sam print(people[2]) # Bob # получение элементов с конца списка print(people[-2]) # Sam print(people[-1]) # Bob print(people[-3]) # Tom
Для изменения элемента списка достаточно присвоить ему новое значение:
people = ["Tom", "Sam", "Bob"] people[1] = "Mike" # изменение второго элемента print(people[1]) # Mike print(people) # ["Tom", "Mike", "Bob"]
Разложение списка
Python позволяет разложить список на отдельные элементы:
people = ["Tom", "Bob", "Sam"] tom, bob, sam = people print(tom) # Tom print(bob) # Bob print(sam) # Sam
В данном случае переменным tom, bob и sam последовательно присваиваются элементы из списка people. Однако следует учитывать, что количество переменных должно быть равно числу элементов присваиваемого списка.
Перебор элементов
Для перебора элементов можно использовать как цикл for, так и цикл while.
Перебор с помощью цикла for :
people = ["Tom", "Sam", "Bob"] for person in people: print(person)
Здесь будет производиться перебор списка people, и каждый его элемент будет помещаться в переменную person.
Перебор также можно сделать с помощью цикла while :
people = ["Tom", "Sam", "Bob"] i = 0 while i < len(people): print(people[i]) # применяем индекс для получения элемента i += 1
Для перебора с помощью функции len() получаем длину списка. С помощью счетчика i выводит по элементу, пока значение счетчика не станет равно длине списка.
Сравнение списков
Два списка считаются равными, если они содержат один и тот же набор элементов:
numbers1 = [1, 2, 3, 4, 5] numbers2 = list([1, 2, 3, 4, 5]) if numbers1 == numbers2: print("numbers1 equal to numbers2") else: print("numbers1 is not equal to numbers2")
В данном случае оба списка будут равны.
Получение части списка
Если необходимо получить какую-то определенную часть списка, то мы можем применять специальный синтаксис, который может принимать следующие формы:
- list[:end] : через параметр end передается индекс элемента, до которого нужно копировать список
- list[start:end] : параметр start указывает на индекс элемента, начиная с которого надо скопировать элементы
- list[start:end:step] : параметр step указывает на шаг, через который будут копироваться элементы из списка. По умолчанию этот параметр равен 1.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:3] # с 0 по 3 print(slice_people1) # ["Tom", "Bob", "Alice"] slice_people2 = people[1:3] # с 1 по 3 print(slice_people2) # ["Bob", "Alice"] slice_people3 = people[1:6:2] # с 1 по 6 с шагом 2 print(slice_people3) # ["Bob", "Sam", "Bill"]
Можно использовать отрицательные индексы, тогда отсчет будет идти с конца, например, -1 - предпоследний, -2 - третий сконца и так далее.
people = ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people1 = people[:-1] # с предпоследнего по нулевой print(slice_people1) # ["Tom", "Bob", "Alice", "Sam", "Tim", "Bill"] slice_people2 = people[-3:-1] # с третьего с конца по предпоследний print(slice_people2) # [ "Sam", "Tim"]
Методы и функции по работе со списками
Для управления элементами списки имеют целый ряд методов. Некоторые из них:
- append(item) : добавляет элемент item в конец списка
- insert(index, item) : добавляет элемент item в список по индексу index
- extend(items) : добавляет набор элементов items в конец списка
- remove(item) : удаляет элемент item. Удаляется только первое вхождение элемента. Если элемент не найден, генерирует исключение ValueError
- clear() : удаление всех элементов из списка
- index(item) : возвращает индекс элемента item. Если элемент не найден, генерирует исключение ValueError
- pop([index]) : удаляет и возвращает элемент по индексу index. Если индекс не передан, то просто удаляет последний элемент.
- count(item) : возвращает количество вхождений элемента item в список
- sort([key]) : сортирует элементы. По умолчанию сортирует по возрастанию. Но с помощью параметра key мы можем передать функцию сортировки.
- reverse() : расставляет все элементы в списке в обратном порядке
- copy() : копирует список
Кроме того, Python предоставляет ряд встроенных функций для работы со списками:
- len(list) : возвращает длину списка
- sorted(list, [key]) : возвращает отсортированный список
- min(list) : возвращает наименьший элемент списка
- max(list) : возвращает наибольший элемент списка
Добавление и удаление элементов
Для добавления элемента применяются методы append() , extend и insert , а для удаления - методы remove() , pop() и clear() .
people = ["Tom", "Bob"] # добавляем в конец списка people.append("Alice") # ["Tom", "Bob", "Alice"] # добавляем на вторую позицию people.insert(1, "Bill") # ["Tom", "Bill", "Bob", "Alice"] # добавляем набор элементов ["Mike", "Sam"] people.extend(["Mike", "Sam"]) # ["Tom", "Bill", "Bob", "Alice", "Mike", "Sam"] # получаем индекс элемента index_of_tom = people.index("Tom") # удаляем по этому индексу removed_item = people.pop(index_of_tom) # ["Bill", "Bob", "Alice", "Mike", "Sam"] # удаляем последний элемент last_item = people.pop() # ["Bill", "Bob", "Alice", "Mike"] # удаляем элемент "Alice" people.remove("Alice") # ["Bill", "Bob", "Mike"] print(people) # ["Bill", "Bob", "Mike"] # удаляем все элементы people.clear() print(people) # []
Проверка наличия элемента
Если определенный элемент не найден, то методы remove и index генерируют исключение. Чтобы избежать подобной ситуации, перед операцией с элементом можно проверять его наличие с помощью ключевого слова in :
people = ["Tom", "Bob", "Alice", "Sam"] if "Alice" in people: people.remove("Alice") print(people) # ["Tom", "Bob", "Sam"]
Выражение if "Alice" in people возвращает True, если элемент "Alice" имеется в списке people. Поэтому конструкция if "Alice" in people может выполнить последующий блок инструкций в зависимости от наличия элемента в списке.
Удаление с помощью del
Python также поддерживает еще один способ удаления элементов списка - с помощью оператора del . В качестве параметра этому оператору передается удаляемый элемент или набор элементов:
people = ["Tom", "Bob", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[1] # удаляем второй элемент print(people) # ["Tom", "Alice", "Sam", "Bill", "Kate", "Mike"] del people[:3] # удаляем по четвертый элемент не включая print(people) # ["Bill", "Kate", "Mike"] del people[1:] # удаляем со второго элемента print(people) # ["Bill"]
Изменение подсписка
Для изменения подсписка - набора элементов в списке можно использовать вышерассмотренный синтаксис [start:end] :
nums = [10, 20, 30, 40, 50] nums[1:4]=[11, 22] print(nums) # [10, 11, 22, 50]
Здесь выражение nums[1:4] фактически обращается к подсписку [20, 30, 40] . Присвоение этому подсписку списка [11, 22] позволяет заменить элемента с 1 по 4 индекс не включая на элементы [11, 22] . И после изменения получим список [10, 11, 22, 50]
Подсчет вхождений
Если необходимо узнать, сколько раз в списке присутствует тот или иной элемент, то можно применить метод count() :
people = ["Tom", "Bob", "Alice", "Tom", "Bill", "Tom"] people_count = people.count("Tom") print(people_count) # 3
Сортировка
Для сортировки по возрастанию применяется метод sort() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() print(people) # ["Alice", "Bill", "Bob", "Sam", "Tom"]
Если необходимо отсортировать данные в обратном порядке, то мы можем после сортировки применить метод reverse() :
people = ["Tom", "Bob", "Alice", "Sam", "Bill"] people.sort() people.reverse() print(people) # ["Tom", "Sam", "Bob", "Bill", "Alice"]
При сортировке фактически сравниваются два объекта, и который из них "меньше", ставится перед тем, который "больше". Понятия "больше" и "меньше" довольно условны. И если для чисел все просто - числа расставляются в порядке возрастания, то для строк и других объектов ситуация сложнее. В частности, строки оцениваются по первым символам. Если первые символы равны, оцениваются вторые символы и так далее. При чем цифровой символ считается "меньше", чем алфавитный заглавный символ, а заглавный символ считается меньше, чем строчный.
Таким образом, если в списке сочетаются строки с верхним и нижним регистром, то мы можем получить не совсем корректные результаты, так как для нас строка "bob" должна стоять до строки "Tom". И чтобы изменить стандартное поведение сортировки, мы можем передать в метод sort() в качестве параметра функцию:
people = ["Tom", "bob", "alice", "Sam", "Bill"] people.sort() # стандартная сортировка print(people) # ["Bill", "Sam", "Tom", "alice", "bob"] people.sort(key=str.lower) # сортировка без учета регистра print(people) # ["alice", "Bill", "bob", "Sam", "Tom"]
Кроме метода sort мы можем использовать встроенную функцию sorted , которая имеет две формы:
- sorted(list) : сортирует список list
- sorted(list, key) : сортирует список list, применяя к элементам функцию key
people = ["Tom", "bob", "alice", "Sam", "Bill"] sorted_people = sorted(people, key=str.lower) print(sorted_people) # ["alice", "Bill", "bob", "Sam", "Tom"]
При использовании этой функции следует учитывать, что эта функция не изменяет сортируемый список, а все отсортированные элементы она помещает в новый список, который возвращается в качестве результата.
Минимальное и максимальное значения
Встроенный функции Python min() и max() позволяют найти минимальное и максимальное значения соответственно:
numbers = [9, 21, 12, 1, 3, 15, 18] print(min(numbers)) # 1 print(max(numbers)) # 21
Копирование списков
При копировании списков следует учитывать, что списки представляют изменяемый (mutable) тип, поэтому если обе переменных будут указывать на один и тот же список, то изменение одной переменной, затронет и другую переменную:
people1 = ["Tom", "Bob", "Alice"] people2 = people1 people2.append("Sam") # добавляем элемент во второй список # people1 и people2 указывают на один и тот же список print(people1) # ["Tom", "Bob", "Alice", "Sam"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Это так называемое "поверхностное копирование" (shallow copy). И, как правило, такое поведение нежелательное. И чтобы происходило копирование элементов, но при этом переменные указывали на разные списки, необходимо выполнить глубокое копирование (deep copy). Для этого можно использовать метод copy() :
people1 = ["Tom", "Bob", "Alice"] people2 = people1.copy() # копируем элементы из people1 в people2 people2.append("Sam") # добавляем элемент ТОЛЬКО во второй список # people1 и people2 указывают на разные списки print(people1) # ["Tom", "Bob", "Alice"] print(people2) # ["Tom", "Bob", "Alice", "Sam"]
Соединение списков
Для объединения списков применяется операция сложения (+):
people1 = ["Tom", "Bob", "Alice"] people2 = ["Tom", "Sam", "Tim", "Bill"] people3 = people1 + people2 print(people3) # ["Tom", "Bob", "Alice", "Tom", "Sam", "Tim", "Bill"]
Списки списков
Списки кроме стандартных данных типа строк, чисел, также могут содержать другие списки. Подобные списки можно ассоциировать с таблицами, где вложенные списки выполняют роль строк. Например:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] print(people[0]) # ["Tom", 29] print(people[0][0]) # Tom print(people[0][1]) # 29
Чтобы обратиться к элементу вложенного списка, необходимо использовать пару индексов: people[0][1] - обращение ко второму элементу первого вложенного списка.
Добавление, удаление и изменение общего списка, а также вложенных списков аналогично тому, как это делается с обычными (одномерными) списками:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] # создание вложенного списка person = list() person.append("Bill") person.append(41) # добавление вложенного списка people.append(person) print(people[-1]) # ["Bill", 41] # добавление во вложенный список people[-1].append("+79876543210") print(people[-1]) # ["Bill", 41, "+79876543210"] # удаление последнего элемента из вложенного списка people[-1].pop() print(people[-1]) # ["Bill", 41] # удаление всего последнего вложенного списка people.pop(-1) # изменение первого элемента people[0] = ["Sam", 18] print(people) # [ ["Sam", 18], ["Alice", 33], ["Bob", 27]]
Перебор вложенных списков:
people = [ ["Tom", 29], ["Alice", 33], ["Bob", 27] ] for person in people: for item in person: print(item, end=" | ")
Tom | 29 | Alice | 33 | Bob | 27 |
Списки в Python: методы и основные операции
Рассмотрим создание списков в Python и разберём основные методы. Научимся изменять, сортировать и совершать другие операции над list.
Списки в Python представляют собой упорядоченные изменяемые наборы объектов, пронумерованных от 0. При этом объекты могут быть разными — от целых чисел до строк. Списки могут также хранить в себе списки.
В статье разберёмся с базовыми принципами списков в Питоне, а также рассмотрим методы работы с ними. Если вы изучаете Python с нуля, предлагаем также ознакомиться с дорожной картой для начинающих.
- Хранение в памяти
- Создание списка
- Срезы (slice)
- Простые операции
- Методы списков
Хранение в памяти
При создании списка, в памяти резервируется пустая область. С одной стороны, это ничем не отличается от создания любого другого типа данных, но разница в том, что содержимое list может меняться:
numbers = [1, 2] numbers[1] = 3 # обновлённый список: [1, 3] До замены элемента последовательности print(numbers[1]) выведет 2, а после замены — 3.
Создание списка в Python
Это можно сделать несколькими способами, например перечислением элементов списка в квадратных скобках:
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9] При этом единица будет на позиции 0, то есть print(numbers[0]) выведет 1.
Также можно использовать обработку итерируемого объекта функцией list() . Пусть у нас будет некоторая строка, тогда:
list('tproger') # ['t', 'p', 'r', 'o', 'g', 'e', 'r'] Также существуют генераторы списков, которые позволяют применить заданное выражение к каждому элементу последовательности. Допустим, необходимо создать list, состоящий из чисел от 1 до 5 включительно:
numbers = [i for i in range(1,6)] # [1, 2, 3, 4, 5] Срезы (slice) списка
Срезы позволяют получить некое подмножество значений. Следующий код вернёт список с элементами, начиная индексом 0 и не включая при этом индекс 2 и выше:
numbers = [1, 5, 9, 6] print(numbers[0:2]) # вывод [1, 5] Далее выведем всё, за исключением элемента на позиции 3:
print(numbers[:3]) # вывод [1, 5, 9] А теперь начиная с индекса 1 и до конца:
print(numbers[1:]) # вывод [5, 9, 6] Операции над списками Python
- x in l — true , если элемент x есть в списке l ;
- x not in l — true , если элемент x отсутствует в l ;
- l1 + l2 — объединение двух списков;
- l * n , n * l — копирует список n раз;
- len(l) — количество элементов в l ;
- min(l) — наименьший элемент;
- max(l) — наибольший элемент;
- sum(l) — сумма чисел списка;
- for i in list() — перебирает элементы слева направо.
Методы списков Python
Index
Возвращает положение первого совпавшего элемента. Поиск совпадения происходит слева направо. Пример:
numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.index(1)) # вывод 0: первая найденная единица на позиции 0 Count
Данный метод считает, сколько раз указанное значение появляется в списке Python:
numbers = [1, 5, 9, 6, 1, 2, 1] print(numbers.count(1)) # вывод 3, потому что единица встречается 3 раза Append
Добавляет указанное значение в конец:
numbers = [1, 5, 9, 6] numbers.append(3) # обновлённый список: [1, 5, 9, 6, 3] Sort
Сортирует список в Пайтоне. По умолчанию от меньшего к большему:
numbers = [1, 5, 9, 6] numbers.sort() # обновлённый список: [1, 5, 6, 9] Также можно сортировать последовательность элементов от большего к меньшему:
numbers = [1, 5, 9, 6] numbers.sort(reverse = true) # обновлённый список: [9, 6, 5, 1] Insert
Вставляет элемент перед указанным индексом:
numbers = [1, 5, 9, 6] numbers.insert(3, [2, 3]) # обновлённый список: [1, 5, 9, [2, 3], 6] Remove
Удаляет первое попавшееся вхождение элемента в списке Python:
numbers = [1, 5, 9, 6, 1, 2, 1] numbers.remove(1) # обновлённый список: [5, 9, 6, 1, 2, 1] Extend
Подобно методу append() , добавляет элементы, но преимущество метода extend() в том, что он также позволяет добавлять списки:
numbers = [1, 5, 9, 6] numbers.extend([2, 3]) # обновлённый список: [1, 5, 9, 6, 2, 3] Pop
А данный метод удаляет элемент в конкретно указанном индексе, а также выводит удалённый элемент. Если индекс не указан, метод по умолчанию удалит последний элемент:
numbers = [1, 5, 9, 6] numbers.pop(1) # получаем: # 5 # [1, 9, 6] Join
Преобразовывает список в строку. Разделитель элементов пишут в кавычках перед методом, а сам список Питона должен состоять из строк:
mylist = ['сайт', 'типичный', 'программист'] print(', '.join(mylist)) # вывод 'сайт, типичный, программист' 
Следите за новыми постами по любимым темам
Подпишитесь на интересующие вас теги, чтобы следить за новыми постами и быть в курсе событий.
Как в питоне объявить список фиксированной длины, но не заполнять его?
Вызове ошибку 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,120 5 5 золотых знаков 25 25 серебряных знаков 46 46 бронзовых знаков
И всё равно на больших размерах будет 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 практически не ограничен.