code: def read_edgelist(
      path,
      comments="#",
      delimiter=None,
      create_using=None,
      nodetype=None,
      data=True,
      edgetype=None,
      encoding="utf-8",
  ):
      """Read a graph from a list of edges.
  
      Parameters
      ----------
      path : file or string
         File or filename to read. If a file is provided, it must be
         opened in 'rb' mode.
         Filenames ending in .gz or .bz2 will be uncompressed.
      comments : string, optional
         The character used to indicate the start of a comment. To specify that
         no character should be treated as a comment, use ``comments=None``.
      delimiter : string, optional
         The string used to separate values.  The default is whitespace.
      create_using : NetworkX graph constructor, optional (default=nx.Graph)
         Graph type to create. If graph instance, then cleared before populated.
      nodetype : int, float, str, Python type, optional
         Convert node data from strings to specified type
      data : bool or list of (label,type) tuples
         Tuples specifying dictionary key names and types for edge data
      edgetype : int, float, str, Python type, optional OBSOLETE
         Convert edge data from strings to specified type and use as 'weight'
      encoding: string, optional
         Specify which encoding to use when reading file.
  
      Returns
      -------
      G : graph
         A networkx Graph or other type specified with create_using
  
      Examples
      --------
      >>> nx.write_edgelist(nx.path_graph(4), "test.edgelist")
      >>> G = nx.read_edgelist("test.edgelist")
  
      >>> fh = open("test.edgelist", "rb")
      >>> G = nx.read_edgelist(fh)
      >>> fh.close()
  
      >>> G = nx.read_edgelist("test.edgelist", nodetype=int)
      >>> G = nx.read_edgelist("test.edgelist", create_using=nx.DiGraph)
  
      Edgelist with data in a list:
  
      >>> textline = "1 2 3"
      >>> fh = open("test.edgelist", "w")
      >>> d = fh.write(textline)
      >>> fh.close()
      >>> G = nx.read_edgelist("test.edgelist", nodetype=int, data=(("weight", float),))
      >>> list(G)
      [1, 2]
      >>> list(G.edges(data=True))
      [(1, 2, {'weight': 3.0})]
  
      See parse_edgelist() for more examples of formatting.
  
      See Also
      --------
      parse_edgelist
      write_edgelist
  
      Notes
      -----
      Since nodes must be hashable, the function nodetype must return hashable
      types (e.g. int, float, str, frozenset - or tuples of those, etc.)
      """
      lines = (
          line if isinstance(line, str) else line.decode(encoding)
          for line in path
      )
      return parse_edgelist(
          lines,
          comments=comments,
          delimiter=delimiter,
          create_using=create_using,
          nodetype=nodetype,
          data=data,
      )
  
file_path: networkx/networkx/readwrite/edgelist.py
imports: import networkx
  from networkx.utils import open_file
label_desc: Use image node_id 4 for calling a global function with example usage: read_edgelist(path, comments, delimiter, create_using, nodetype, data, edgetype, encoding) and returns: parse_edgelist