class_docstr: Row-based linked list sparse matrix
  
  This is a structure for constructing sparse matrices incrementally.
  Note that inserting a single item can take linear time in the worst case;
  to construct a matrix efficiently, make sure the items are pre-sorted by
  index, per row.
  
  This can be instantiated in several ways:
      lil_matrix(D)
          with a dense matrix or rank-2 ndarray D
  
      lil_matrix(S)
          with another sparse matrix S (equivalent to S.tolil())
  
      lil_matrix((M, N), [dtype])
          to construct an empty matrix with shape (M, N)
          dtype is optional, defaulting to dtype='d'.
  
  Attributes
  ----------
  dtype : dtype
      Data type of the matrix
  shape : 2-tuple
      Shape of the matrix
  ndim : int
      Number of dimensions (this is always 2)
  nnz
      Number of nonzero elements
  data
      LIL format data array of the matrix
  rows
      LIL format row index array of the matrix
  
  Notes
  -----
  
  Sparse matrices 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 matrix 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 matrices
      - once a matrix has been constructed, convert to CSR or
        CSC format for fast arithmetic and matrix vector operations
      - consider using the COO format when constructing large matrices
  
  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``.
code: def count_nonzero(self):
      return sum(np.count_nonzero(rowvals) for rowvals in self.data)
  
imports: from __future__ import division, print_function, absolute_import
  from bisect import bisect_left
  import numpy
  from scipy._lib._version import NumpyVersion
  from scipy._lib.six import xrange, zip
  from .base import spmatrix, isspmatrix
  from .sputils import getdtype, isshape, isscalarlike, IndexMixin, upcast_scalar, get_index_dtype, isintlike, check_shape, check_reshape_kwargs, asmatrix
  from .None import _csparsetools
label_desc: Use image node_id 7 for calling the lil_matrix obj's underlying member method code with example usage: obj.count_nonzero() and returns: sum