lil_array#
- class scipy.sparse.lil_array(arg1, shape=None, dtype=None, copy=False, *, maxprint=None)[source]#
- Row-based LIst of Lists sparse array. - This is a structure for constructing sparse arrays incrementally. Note that inserting a single item can take linear time in the worst case; to construct the array efficiently, make sure the items are pre-sorted by index, per row. - This can be instantiated in several ways:
- lil_array(D)
- where D is a 2-D ndarray 
- lil_array(S)
- with another sparse array or matrix S (equivalent to S.tolil()) 
- lil_array((M, N), [dtype])
- to construct an empty array with shape (M, N) dtype is optional, defaulting to dtype=’d’. 
 
 - Attributes:
 - Methods - __len__()- asformat(format[, copy])- Return this array/matrix in the passed format. - astype(dtype[, casting, copy])- Cast the array/matrix elements to a specified type. - conj([copy])- Element-wise complex conjugation. - conjugate([copy])- Element-wise complex conjugation. - copy()- Returns a copy of this array/matrix. - count_nonzero([axis])- Number of non-zero entries, equivalent to - diagonal([k])- Returns the kth diagonal of the array/matrix. - dot(other)- Ordinary dot product - getrow(i)- Returns a copy of the 'i'th row. - getrowview(i)- Returns a view of the 'i'th row (without copying). - maximum(other)- Element-wise maximum between this and another array/matrix. - mean([axis, dtype, out])- Compute the arithmetic mean along the specified axis. - minimum(other)- Element-wise minimum between this and another array/matrix. - multiply(other)- Element-wise multiplication by another array/matrix. - nonzero()- Nonzero indices of the array/matrix. - power(n[, dtype])- Element-wise power. - reshape(self, shape[, order, copy])- Gives a new shape to a sparse array/matrix without changing its data. - resize(*shape)- Resize the array/matrix in-place to dimensions given by - shape- setdiag(values[, k])- Set diagonal or off-diagonal elements of the array/matrix. - sum([axis, dtype, out])- Sum the array/matrix elements over a given axis. - toarray([order, out])- Return a dense ndarray representation of this sparse array/matrix. - tobsr([blocksize, copy])- Convert this array/matrix to Block Sparse Row format. - tocoo([copy])- Convert this array/matrix to COOrdinate format. - tocsc([copy])- Convert this array/matrix to Compressed Sparse Column format. - tocsr([copy])- Convert this array/matrix to Compressed Sparse Row format. - todense([order, out])- Return a dense representation of this sparse array. - todia([copy])- Convert this array/matrix to sparse DIAgonal format. - todok([copy])- Convert this array/matrix to Dictionary Of Keys format. - tolil([copy])- Convert this array/matrix to List of Lists format. - trace([offset])- Returns the sum along diagonals of the sparse array/matrix. - transpose([axes, copy])- Reverses the dimensions of the sparse array/matrix. - __getitem__ - __mul__ - Notes - Sparse arrays can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power. - Advantages of the LIL format
- supports flexible slicing 
- changes to the array sparsity structure are efficient 
 
- Disadvantages of the LIL format
- arithmetic operations LIL + LIL are slow (consider CSR or CSC) 
- slow column slicing (consider CSC) 
- slow matrix vector products (consider CSR or CSC) 
 
- Intended Usage
- LIL is a convenient format for constructing sparse arrays 
- once an array has been constructed, convert to CSR or CSC format for fast arithmetic and matrix vector operations 
- consider using the COO format when constructing large arrays 
 
- Data Structure
- An array ( - self.rows) of rows, each of which is a sorted list of column indices of non-zero elements.
- The corresponding nonzero values are stored in similar fashion in - self.data.