Initialiser un tableau de taille fixe en python [dupliquer]

vous pouvez utiliser:

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

pourquoi ces questions ne reçoivent-elles pas une réponse évidente?

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

Cela crée un tableau de longueur n qui peut stocker des objets. Il ne peut pas être redimensionné ou ajouté. En particulier, il ne perd pas d'espace en rembourrant sa longueur. C'est L'équivalent Java de

Object[] a = new Object[n];

si vous êtes vraiment intéressé par la performance et l'espace et que vous savez que votre tableau ne stockera que certains types numériques, alors vous pouvez changer le dtype argument à une autre valeur comme int. Puis numpy va empaqueter ces éléments directement dans le tableau plutôt que de faire la référence tableau dans les objets.

Faites ceci:

>>> 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]]

les autres solutions conduiront à ce genre de problème:

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

le meilleur pari est d'utiliser la bibliothèque numpy .

from numpy import ndarray

a = ndarray((5,),int)

>>> 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 est un tableau 2-D, et y est un tableau 1-d. Ils sont tous les deux initialisés avec des zéros.

une solution facile est x = [None]*length , mais notez qu'elle initialise tous les éléments de liste à None . Si la taille est vraiment fixe, vous pouvez faire x=[None,None,None,None,None] . Mais à proprement parler, vous n'obtiendrez pas d'éléments non définis de toute façon parce que cette peste n'existe pas en Python.

Eh bien, je voudrais vous aider en affichant un programme échantillon et sa sortie

programme:

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

sortie: -

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

j'espère que cela éclaircit quelque concept très basique de la vôtre en ce qui concerne leur déclaration. Pour les initialiser avec certains autres valeurs spécifiques, comme l'initialisation avec 0 .. vous pouvez les déclarer comme:

x = [0]*10

J'espère que ça aidera..!! ;)

>>> 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]

ou avec vraiment rien dans la liste pour commencer:

>>> 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]

sur la 4ème itération de l'appendice:

>>> 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 et tous les suivants:

>>> 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]

vous pouvez essayer D'utiliser le descripteur, pour limiter la taille

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

sortie:

[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]

une chose que je trouve facile à faire est de mettre un tableau de chaînes vides pour la taille que je préfère, par exemple

Code:

import numpy as np

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

sortie:

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

j'Espère que cela est utile :)

si vous travaillez avec des octets, vous pouvez utiliser le builtin bytearray . Si vous travaillez avec d'autres types intégraux regarder la builtin array .

comprend spécifiquement qu'un list n'est pas un array .

si, par exemple, vous essayez de créer un tampon pour lire le contenu d'un fichier, vous pouvez utiliser bytearray comme suit (il y a de meilleures façons de le faire, mais l'exemple est valide):

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

dans cet extrait, la mémoire bytearray est pré-attribuée avec la longueur fixe de FILENAME taille de s en octets. Cette préallocation permet l'utilisation du protocole buffer pour lire plus efficacement le fichier dans un buffer mutable sans copie de tableau. Il y a encore de meilleures façons de le faire, mais je crois que cela apporte une réponse à votre question.