code: def rich_club_coefficient(G, normalized=True, Q=100, seed=None):
      r"""Returns the rich-club coefficient of the graph `G`.
  
      For each degree *k*, the *rich-club coefficient* is the ratio of the
      number of actual to the number of potential edges for nodes with
      degree greater than *k*:
  
      .. math::
  
          \phi(k) = \frac{2 E_k}{N_k (N_k - 1)}
  
      where `N_k` is the number of nodes with degree larger than *k*, and
      `E_k` is the number of edges among those nodes.
  
      Parameters
      ----------
      G : NetworkX graph
          Undirected graph with neither parallel edges nor self-loops.
      normalized : bool (optional)
          Normalize using randomized network as in [1]_
      Q : float (optional, default=100)
          If `normalized` is True, perform `Q * m` double-edge
          swaps, where `m` is the number of edges in `G`, to use as a
          null-model for normalization.
      seed : integer, random_state, or None (default)
          Indicator of random number generation state.
          See :ref:`Randomness<randomness>`.
  
      Returns
      -------
      rc : dictionary
         A dictionary, keyed by degree, with rich-club coefficient values.
  
      Examples
      --------
      >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
      >>> rc = nx.rich_club_coefficient(G, normalized=False, seed=42)
      >>> rc[0]
      0.4
  
      Notes
      -----
      The rich club definition and algorithm are found in [1]_.  This
      algorithm ignores any edge weights and is not defined for directed
      graphs or graphs with parallel edges or self loops.
  
      Estimates for appropriate values of `Q` are found in [2]_.
  
      References
      ----------
      .. [1] Julian J. McAuley, Luciano da Fontoura Costa,
         and Tibério S. Caetano,
         "The rich-club phenomenon across complex network hierarchies",
         Applied Physics Letters Vol 91 Issue 8, August 2007.
         https://arxiv.org/abs/physics/0701290
      .. [2] R. Milo, N. Kashtan, S. Itzkovitz, M. E. J. Newman, U. Alon,
         "Uniform generation of random graphs with arbitrary degree
         sequences", 2006. https://arxiv.org/abs/cond-mat/0312028
      """
      if nx.number_of_selfloops(G) > 0:
          raise Exception(
              "rich_club_coefficient is not implemented for graphs with self loops."
          )
      rc = _compute_rc(G)
      if normalized:
          # make R a copy of G, randomize with Q*|E| double edge swaps
          # and use rich_club coefficient of R to normalize
          R = G.copy()
          E = R.number_of_edges()
          nx.double_edge_swap(R, Q * E, max_tries=Q * E * 10, seed=seed)
          rcran = _compute_rc(R)
          rc = {k: v / rcran[k] for k, v in rc.items()}
      return rc
  
imports: from itertools import accumulate
  import networkx
  from networkx.utils import not_implemented_for
label_desc: Use image node_id 1 for calling a global function with example usage: rich_club_coefficient(G, normalized, Q, seed) and returns: rc