code: def group(store=None, overwrite=False, chunk_store=None,
            cache_attrs=True, synchronizer=None, path=None):
      
  
      # handle polymorphic store arg
      store = _normalize_store_arg(store)
      path = normalize_storage_path(path)
  
      # require group
      if overwrite or not contains_group(store):
          init_group(store, overwrite=overwrite, chunk_store=chunk_store,
                     path=path)
  
      return Group(store, read_only=False, chunk_store=chunk_store,
                   cache_attrs=cache_attrs, synchronizer=synchronizer, path=path)
docs: Create a group.
  
      Parameters
      ----------
      store : MutableMapping or string, optional
          Store or path to directory in file system.
      overwrite : bool, optional
          If True, delete any pre-existing data in `store` at `path` before
          creating the group.
      chunk_store : MutableMapping, optional
          Separate storage for chunks. If not provided, `store` will be used
          for storage of both chunks and metadata.
      cache_attrs : bool, optional
          If True (default), user attributes will be cached for attribute read
          operations. If False, user attributes are reloaded from the store prior
          to all attribute read operations.
      synchronizer : object, optional
          Array synchronizer.
      path : string, optional
          Group path within store.
  
      Returns
      -------
      g : zarr.hierarchy.Group
  
      Examples
      --------
      Create a group in memory::
  
          >>> import zarr
          >>> g = zarr.group()
          >>> g
          <zarr.hierarchy.Group '/'>
  
      Create a group with a different store::
  
          >>> store = zarr.DirectoryStore('data/example.zarr')
          >>> g = zarr.group(store=store, overwrite=True)
          >>> g
          <zarr.hierarchy.Group '/'>