web-dev-qa-db-fra.com

Initialisation d'un tableau de taille fixe dans python

Je voudrais savoir comment je peux initialiser un tableau (ou une liste), qui doit encore être rempli de valeurs, pour avoir une taille définie.

par exemple en C:

int x[5]; /* declared without adding elements*/

Comment puis-je faire cela en python?

Merci.

pythonarrayslist
131
kbb

Vous pouvez utiliser:

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

Pourquoi ces questions ne reçoivent-elles pas la réponse évidente?

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

Cela crée un tableau de longueur n pouvant stocker des objets. Il ne peut pas être redimensionné ou ajouté. En particulier, il ne perd pas d’espace en rembourrant sa longueur. Ceci est le Python équivalent de Java

Object[] a = new Object[n];

Si vous êtes vraiment intéressé par les performances et l'espace et que vous savez que votre tableau ne stockera que certains types numériques, vous pouvez changer l'argument dtype en une autre valeur comme int. Ensuite, numpy emballera ces éléments directement dans le tableau plutôt que de faire en sorte que le tableau fasse référence à des objets int.

69
Pat Morin

Faire 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]]
21
TTimo

La meilleure solution consiste à utiliser la bibliothèque numpy .

from numpy import ndarray

a = ndarray((5,),int)
12
lafras
>>> 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 deux initialisés avec des zéros.

9
kaamen

Une solution simple est x = [None]*length, mais notez qu'il initialise tous les éléments de la liste sur None. Si la taille est vraiment fixée, vous pouvez également utiliser x=[None,None,None,None,None]. Mais à proprement parler, vous n’obtiendrez pas d’éléments indéfinis, car ce fléau n’existe pas en Python.

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

à la 4ème itération de append:

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

J'aimerais vous aider en publiant un exemple de programme et ses résultats.

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 efface un concept très fondamental de votre part concernant leur déclaration. Pour les initialiser avec d'autres valeurs spécifiques, comme l'initialisation avec 0 .., vous pouvez les déclarer en tant que:

x = [0]*10

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

3
Archit

Vous pouvez essayer d’utiliser Descriptor, 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]
1
Siva Cn

Une chose que je trouve facile à faire est de définir un tableau de chaînes vides de 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 c'est utile :)

0
Pfesi van Zyl

Si vous travaillez avec des octets, vous pouvez utiliser la fonction intégrée bytearray. Si vous travaillez avec d'autres types d'intégraux, examinez la fonction intégrée array.

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

Si, par exemple, vous essayez de créer un tampon pour la lecture du contenu du fichier, vous pouvez utiliser bytearray comme suit (il existe de meilleures façons de procéder, 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éallouée avec la longueur fixe de FILENAMEs en octets. Cette préallocation permet d'utiliser le protocole de mémoire tampon pour lire plus efficacement le fichier dans une mémoire tampon modifiable sans copie de tableau. Il existe encore de meilleures façons de le faire, mais je pense que cela fournit une réponse à votre question.

0
Dave