Инициализация массива фиксированного размера в python

Ответ 1

Вы можете использовать:

>>> lst = [None] * 5
>>> lst
[None, None, None, None, None]

Ответ 2

Почему на эти вопросы не дают очевидного ответа?

a = numpy.empty(n, dtype=object)

Это создает массив длины n, который может хранить объекты. Это не может быть изменено или добавлено. В частности, он не теряет пространство, дополняя его длину. Это Python эквивалент Java

Object[] a = new Object[n];

Если вы действительно заинтересованы в производительности и пространстве и знаете, что ваш массив будет хранить только определенные числовые типы, вы можете изменить аргумент dtype на другое значение, например, int. Затем numpy будет упаковывать эти элементы непосредственно в массив, а не делать массив ссылками на объекты int.

Ответ 3

Сделайте это:

>>> d = [ [ None for y in range( 2 ) ] for x in range( 2 ) ]
>>> d
[[None, None], [None, None]]
>>> d[0][0] = 1
>>> d
[[1, None], [None, None]]

Другие решения приведут к такой проблеме:

>>> d = [ [ None ] * 2 ] * 2
>>> d
[[None, None], [None, None]]
>>> d[0][0] = 1
>>> d
[[1, None], [1, None]]

Ответ 4

Лучше всего использовать библиотеку numpy.

from numpy import ndarray

a = ndarray((5,),int)

Ответ 5

>>> import numpy
>>> x = numpy.zeros((3,4))
>>> x
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
>>> y = numpy.zeros(5)   
>>> y
array([ 0.,  0.,  0.,  0.,  0.])

x является двумерным массивом, а y является одномерным массивом. Они оба инициализируются нулями.

Ответ 6

Простое решение x = [None]*length, но обратите внимание, что оно инициализирует все элементы списка None. Если размер действительно исправлен, вы можете сделать x=[None,None,None,None,None]. Но, строго говоря, вы не получите элементов undefined в любом случае, потому что эта чума не существует в Python.

Ответ 7

>>> n = 5                     #length of list
>>> list = [None] * n         #populate list, length n with n entries "None"
>>> print(list)
[None, None, None, None, None]

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[None, None, None, None, 1]

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[None, None, None, 1, 1]

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[None, None, 1, 1, 1]

или в самом деле ничего не нужно в списке:

>>> n = 5                     #length of list
>>> list = []                 # create list
>>> print(list)
[]

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[1]

на 4-й итерации добавления:

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[1,1,1,1]

5 и все последующие:

>>> list.append(1)            #append 1 to right side of list
>>> list = list[-n:]          #redefine list as the last n elements of list
>>> print(list)
[1,1,1,1,1]

Ответ 8

Хорошо, я хотел бы помочь вам, разместив образец программы и ее выход

Программа:

t = input("")
x = [None]*t
y = [[None]*t]*t

for i in range(1, t+1):
    x[i-1] = i;

    for j in range(1, t+1):
        y[i-1][j-1] = j;

print x
print y

Выход: -

2
[1, 2]
[[1, 2], [1, 2]]

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

x = [0]*10

Надеюсь, это поможет..!!;)

Ответ 9

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

class fixedSizeArray(object):
    def __init__(self, arraySize=5):
        self.arraySize = arraySize
        self.array = [None] * self.arraySize

    def __repr__(self):
        return str(self.array)

    def __get__(self, instance, owner):
        return self.array

    def append(self, index=None, value=None):
        print "Append Operation cannot be performed on fixed size array"
        return

    def insert(self, index=None, value=None):
        if not index and index - 1 not in xrange(self.arraySize):
            print 'invalid Index or Array Size Exceeded'
            return
        try:
            self.array[index] = value
        except:
            print 'This is Fixed Size Array: Please Use the available Indices'


arr = fixedSizeArray(5)
print arr
arr.append(100)
print arr
arr.insert(1, 200)
print arr
arr.insert(5, 300)
print arr

ВЫВОД:

[None, None, None, None, None]
Append Operation cannot be performed on fixed size array
[None, None, None, None, None]
[None, 200, None, None, None]
This is Fixed Size Array: Please Use the available Indices
[None, 200, None, None, None]

Ответ 10

Одна вещь, которую мне легко найти, - это установить массив пустых строк для размера, который я предпочитаю, например

код:

import numpy as np

x= np.zeros(5,str)
print x

Вывод:

['' '' '' '' '']

Надеюсь, что это будет полезно:)

Ответ 11

Если вы работаете с байтами, вы можете использовать встроенный bytearray. Если вы работаете с другими интегральными типами, посмотрите на встроенный array.

В частности, понимаем, что a list не является array.

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

with open(FILENAME, 'rb') as f:
    data = bytearray(os.path.getsize(FILENAME))
    f.readinto(data)

В этом фрагменте память bytearray предопределена с фиксированной длиной FILENAME в байтах. Это предварительное распределение позволяет использовать буферный протокол для более эффективного считывания файла в изменяемый буфер без копии массива. Есть еще лучшие способы сделать это, но я считаю, что это дает один ответ на ваш вопрос.