Inițializarea unei matrice de dimensiune fixă în python

Aș dori să știu cum pot inițializa o matrice(sau lista), dar pentru a fi populate cu valori, pentru a avea o dimensiune definită.

de exemplu, în C:

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

Cum fac asta în python?

Multumesc.

Alexander Gessler
Întrebarea editată 26 mai 2011 в 5:36
Programare
arrays python list
26 mai 2011 в 5:33
6 vizualizări
Comentarii la întrebare (7)

Puteți folosi:

>>> lst = [None] * 5
>>> lst
[None, None, None, None, None]
Comentarii (2)

De ce nu't aceste întrebări primesc răspunsuri cu răspunsul evident?

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

Acest lucru creează o matrice de lungime n care poate stoca obiecte. Se poate't fi redimensionate sau anexată la acesta. În special, aceasta nu't deșeuri spațiu de umplutură lungimea sa. Aceasta este Python echivalentul Java's

Object[] a = new Object[n];

Daca're într-adevăr interesați de performanță și spațiu și să știți că o matrice va stoca doar anumite tipuri numerice apoi puteți schimba dtype argument pentru o altă valoare ca int. Apoi numpy va pack aceste elemente direct în matrice, mai degrabă decât a face matrice de referință int obiecte.

Alec
Răspuns editat 16 iulie 2019 в 9:21
Comentarii (4)

Face acest lucru:

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

Alte solutii va duce la acest tip de problemă:

>>> d = [ [ None ] * 2 ] * 2
>>> d
[[None, None], [None, None]]
>>> d[0][0] = 1
>>> d
[[1, None], [1, None]]
TTimo
Răspuns editat 30 decembrie 2015 в 5:47
Comentarii (1)

Cel mai bun pariu este de a utiliza numpy biblioteca.

from numpy import ndarray

a = ndarray((5,),int)
Comentarii (2)

O soluție simplă este x = [None]*lungimea, dar rețineți că se initializeaza toate lista de elemente pentru a "Nici unul". Dacă dimensiunea este într-adevăr ** fixă, puteți face x=[Nici unul,Nici unul,Nici unul,Nici unul,Nici unul] la fel de bine. Dar, strict vorbind, nu te vei't obține nedefinit elemente oricum, pentru că ciuma asta nu't există în Python.

Comentarii (1)
>>> 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 este 2-d matrice, și y este 1-d matrice. Ambele sunt inițializate cu zero.

kaamen
Răspuns editat 14 februarie 2018 в 7:37
Comentarii (1)
 
>>> 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]

sau cu adevărat nimic din listă pentru a începe cu:

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

pe 4 iterație a adăuga:

>>> 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 și toate ulterioare:

>>> 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]
litepresence
Răspuns editat 28 mai 2014 в 9:25
Comentarii (0)

Ei bine, aș dori să te ajut prin posta un program de probă și de ieșire

Program:

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

Ieșire :-

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

Sper ca acest respinga unele foarte concept de bază de-a ta privire la declararea acestora. Pentru a inițializa cu alte valori specifice, cum ar fi inițializarea ei cu 0.. puteți să le declare ca:

x = [0]*10

Sper că vă ajută..!! ;)

JimiDini
Răspuns editat 26 septembrie 2013 в 3:47
Comentarii (5)

Puteți încerca să utilizați Descriptor, pentru a limita dimensiunea

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

IEȘIRE:

[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]
Comentarii (1)

Un singur lucru mi se pare ușor să faceți este să am stabilit o serie de siruri de caractere goale pentru dimensiunea prefer, de exemplu

Cod:

import numpy as np

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

Ieșire:

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

Sper că acest lucru este de ajutor :)

lucian.pantelimon
Răspuns editat 24 martie 2014 в 2:04
Comentarii (0)

Dacă lucrați cu bytes ai putea folosi interna bytearray. Dacă lucrați cu alte integrantă tipuri uita-te la builtin "matrice".

În mod special înțeleagă că o "listă" nu este o "matrice".

Dacă, de exemplu, sunteți încercarea de a crea un tampon pentru a citi conținutul fișierului într-ai putea folosi bytearray după cum urmează (există modalități mai bune de a face acest lucru, dar exemplul este valabil):

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

În acest fragment de `bytearray de memorie este preallocated cu lungime fixă de NUME de fișier este dimensiunea în octeți. Acest preallocation permite utilizarea tampon protocol mai eficient de a citi fișiere într-un mutabil tampon fără o serie de copiere. Există modalități mai bune de a face acest lucru, dar cred că acest lucru oferă un răspuns la întrebarea ta.

Comentarii (0)