diff --git a/docs/release.rst b/docs/release.rst
index bf0dcd69e9..f6c102091f 100644
--- a/docs/release.rst
+++ b/docs/release.rst
@@ -18,6 +18,12 @@ Release notes
 Unreleased
 ----------
 
+Maintenance
+~~~~~~~~~~~
+
+* Change occurrences of % and format() to f-strings.
+  By :user:`Dimitri Papadopoulos Orfanos <DimitriPapadopoulos>` :issue:`1423`.
+
 .. _release_2.16.1:
 
 2.16.1
diff --git a/zarr/_storage/absstore.py b/zarr/_storage/absstore.py
index f62529f096..77bfdfc821 100644
--- a/zarr/_storage/absstore.py
+++ b/zarr/_storage/absstore.py
@@ -84,10 +84,10 @@ def __init__(
 
             blob_service_kwargs = blob_service_kwargs or {}
             client = ContainerClient(
-                "https://{}.blob.core.windows.net/".format(account_name),
+                f"https://{account_name}.blob.core.windows.net/",
                 container,
                 credential=account_key,
-                **blob_service_kwargs
+                **blob_service_kwargs,
             )
 
         self.client = client
@@ -141,7 +141,7 @@ def __getitem__(self, key):
         try:
             return self.client.download_blob(blob_name).readall()
         except ResourceNotFoundError:
-            raise KeyError("Blob %s not found" % blob_name)
+            raise KeyError(f"Blob {blob_name} not found")
 
     def __setitem__(self, key, value):
         value = ensure_bytes(value)
@@ -154,7 +154,7 @@ def __delitem__(self, key):
         try:
             self.client.delete_blob(self._append_path_to_prefix(key))
         except ResourceNotFoundError:
-            raise KeyError("Blob %s not found" % key)
+            raise KeyError(f"Blob {key} not found")
 
     def __eq__(self, other):
         return (
diff --git a/zarr/_storage/store.py b/zarr/_storage/store.py
index 8daedae48f..d943e8b150 100644
--- a/zarr/_storage/store.py
+++ b/zarr/_storage/store.py
@@ -227,7 +227,7 @@ def _validate_key(self, key: str):
             # TODO: Possibly allow key == ".zmetadata" too if we write a
             #       consolidated metadata spec corresponding to this?
         ):
-            raise ValueError("keys starts with unexpected value: `{}`".format(key))
+            raise ValueError(f"keys starts with unexpected value: `{key}`")
 
         if key.endswith("/"):
             raise ValueError("keys may not end in /")
diff --git a/zarr/_storage/v3.py b/zarr/_storage/v3.py
index 00dc085dac..61e7a27ac0 100644
--- a/zarr/_storage/v3.py
+++ b/zarr/_storage/v3.py
@@ -570,7 +570,7 @@ def __init__(self, store: StoreLike, metadata_key=meta_root + "consolidated/.zme
         consolidated_format = meta.get("zarr_consolidated_format", None)
         if consolidated_format != 1:
             raise MetadataError(
-                "unsupported zarr consolidated metadata format: %s" % consolidated_format
+                f"unsupported zarr consolidated metadata format: {consolidated_format}"
             )
 
         # decode metadata
diff --git a/zarr/convenience.py b/zarr/convenience.py
index ff236d0df2..10a2a28948 100644
--- a/zarr/convenience.py
+++ b/zarr/convenience.py
@@ -257,7 +257,7 @@ def save_group(store: StoreLike, *args, zarr_version=None, path=None, **kwargs):
     try:
         grp = _create_group(_store, path=path, overwrite=True, zarr_version=zarr_version)
         for i, arr in enumerate(args):
-            k = "arr_{}".format(i)
+            k = f"arr_{i}"
             grp.create_dataset(k, data=arr, overwrite=True, zarr_version=zarr_version)
         for k, arr in kwargs.items():
             grp.create_dataset(k, data=arr, overwrite=True, zarr_version=zarr_version)
@@ -497,7 +497,7 @@ def __init__(self, log):
             self.log_file = log
         else:
             raise TypeError(
-                "log must be a callable function, file path or " "file-like object, found %r" % log
+                f"log must be a callable function, file path or file-like object, found {log!r}"
             )
 
     def __enter__(self):
@@ -524,9 +524,9 @@ def _log_copy_summary(log, dry_run, n_copied, n_skipped, n_bytes_copied):
         message = "dry run: "
     else:
         message = "all done: "
-    message += "{:,} copied, {:,} skipped".format(n_copied, n_skipped)
+    message += f"{n_copied:,} copied, {n_skipped:,} skipped"
     if not dry_run:
-        message += ", {:,} bytes copied".format(n_bytes_copied)
+        message += f", {n_bytes_copied:,} bytes copied"
     log(message)
 
 
@@ -655,9 +655,7 @@ def copy_store(
     # check if_exists parameter
     valid_if_exists = ["raise", "replace", "skip"]
     if if_exists not in valid_if_exists:
-        raise ValueError(
-            "if_exists must be one of {!r}; found {!r}".format(valid_if_exists, if_exists)
-        )
+        raise ValueError(f"if_exists must be one of {valid_if_exists!r}; found {if_exists!r}")
 
     # setup counting variables
     n_copied = n_skipped = n_bytes_copied = 0
@@ -720,20 +718,20 @@ def copy_store(
             if if_exists != "replace":
                 if dest_key in dest:
                     if if_exists == "raise":
-                        raise CopyError("key {!r} exists in destination".format(dest_key))
+                        raise CopyError(f"key {dest_key!r} exists in destination")
                     elif if_exists == "skip":
                         do_copy = False
 
             # take action
             if do_copy:
-                log("copy {}".format(descr))
+                log(f"copy {descr}")
                 if not dry_run:
                     data = source[source_key]
                     n_bytes_copied += buffer_size(data)
                     dest[dest_key] = data
                 n_copied += 1
             else:
-                log("skip {}".format(descr))
+                log(f"skip {descr}")
                 n_skipped += 1
 
         # log a final message with a summary of what happened
@@ -744,7 +742,7 @@ def copy_store(
 
 def _check_dest_is_group(dest):
     if not hasattr(dest, "create_dataset"):
-        raise ValueError("dest must be a group, got {!r}".format(dest))
+        raise ValueError(f"dest must be a group, got {dest!r}")
 
 
 def copy(
@@ -756,7 +754,7 @@ def copy(
     log=None,
     if_exists="raise",
     dry_run=False,
-    **create_kws
+    **create_kws,
 ):
     """Copy the `source` array or group into the `dest` group.
 
@@ -889,7 +887,7 @@ def copy(
             without_attrs=without_attrs,
             if_exists=if_exists,
             dry_run=dry_run,
-            **create_kws
+            **create_kws,
         )
 
         # log a final message with a summary of what happened
@@ -911,11 +909,9 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
     # check if_exists parameter
     valid_if_exists = ["raise", "replace", "skip", "skip_initialized"]
     if if_exists not in valid_if_exists:
-        raise ValueError(
-            "if_exists must be one of {!r}; found {!r}".format(valid_if_exists, if_exists)
-        )
+        raise ValueError(f"if_exists must be one of {valid_if_exists!r}; found {if_exists!r}")
     if dest_h5py and if_exists == "skip_initialized":
-        raise ValueError("{!r} can only be used when copying to zarr".format(if_exists))
+        raise ValueError(f"{if_exists!r} can only be used when copying to zarr")
 
     # determine name to copy to
     if name is None:
@@ -936,7 +932,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
         if exists:
             if if_exists == "raise":
                 raise CopyError(
-                    "an object {!r} already exists in destination " "{!r}".format(name, dest.name)
+                    f"an object {name!r} already exists in destination " "{dest.name!r}"
                 )
             elif if_exists == "skip":
                 do_copy = False
@@ -949,7 +945,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
         if do_copy:
 
             # log a message about what we're going to do
-            log("copy {} {} {}".format(source.name, source.shape, source.dtype))
+            log(f"copy {source.name} {source.shape} {source.dtype}")
 
             if not dry_run:
 
@@ -1018,7 +1014,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
             n_copied += 1
 
         else:
-            log("skip {} {} {}".format(source.name, source.shape, source.dtype))
+            log(f"skip {source.name} {source.shape} {source.dtype}")
             n_skipped += 1
 
     elif root or not shallow:
@@ -1029,9 +1025,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
         exists_array = dest is not None and name in dest and hasattr(dest[name], "shape")
         if exists_array:
             if if_exists == "raise":
-                raise CopyError(
-                    "an array {!r} already exists in destination " "{!r}".format(name, dest.name)
-                )
+                raise CopyError(f"an array {name!r} already exists in destination {dest.name!r}")
             elif if_exists == "skip":
                 do_copy = False
 
@@ -1039,7 +1033,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
         if do_copy:
 
             # log action
-            log("copy {}".format(source.name))
+            log(f"copy {source.name}")
 
             if not dry_run:
 
@@ -1075,7 +1069,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
                     without_attrs=without_attrs,
                     if_exists=if_exists,
                     dry_run=dry_run,
-                    **create_kws
+                    **create_kws,
                 )
                 n_copied += c
                 n_skipped += s
@@ -1084,7 +1078,7 @@ def _copy(log, source, dest, name, root, shallow, without_attrs, if_exists, dry_
             n_copied += 1
 
         else:
-            log("skip {}".format(source.name))
+            log(f"skip {source.name}")
             n_skipped += 1
 
     return n_copied, n_skipped, n_bytes_copied
@@ -1098,7 +1092,7 @@ def copy_all(
     log=None,
     if_exists="raise",
     dry_run=False,
-    **create_kws
+    **create_kws,
 ):
     """Copy all children of the `source` group into the `dest` group.
 
@@ -1200,7 +1194,7 @@ def copy_all(
                 without_attrs=without_attrs,
                 if_exists=if_exists,
                 dry_run=dry_run,
-                **create_kws
+                **create_kws,
             )
             n_copied += c
             n_skipped += s
@@ -1335,7 +1329,7 @@ def open_consolidated(store: StoreLike, metadata_key=".zmetadata", mode="r+", **
         store, storage_options=kwargs.get("storage_options"), mode=mode, zarr_version=zarr_version
     )
     if mode not in {"r", "r+"}:
-        raise ValueError("invalid mode, expected either 'r' or 'r+'; found {!r}".format(mode))
+        raise ValueError(f"invalid mode, expected either 'r' or 'r+'; found {mode!r}")
 
     path = kwargs.pop("path", None)
     if store._store_version == 2:
diff --git a/zarr/core.py b/zarr/core.py
index 43ccdbaf7d..faff693bf7 100644
--- a/zarr/core.py
+++ b/zarr/core.py
@@ -2453,11 +2453,11 @@ def _encode_chunk(self, chunk):
 
     def __repr__(self):
         t = type(self)
-        r = "<{}.{}".format(t.__module__, t.__name__)
+        r = f"<{t.__module__}.{t.__name__}"
         if self.name:
-            r += " %r" % self.name
-        r += " %s" % str(self.shape)
-        r += " %s" % self.dtype
+            r += f" {self.name!r}"
+        r += f" {str(self.shape)}"
+        r += f" {self.dtype}"
         if self._read_only:
             r += " read-only"
         r += ">"
@@ -2493,11 +2493,11 @@ def info_items(self):
 
     def _info_items_nosync(self):
         def typestr(o):
-            return "{}.{}".format(type(o).__module__, type(o).__name__)
+            return f"{type(o).__module__}.{type(o).__name__}"
 
         def bytestr(n):
             if n > 2**10:
-                return "{} ({})".format(n, human_readable_size(n))
+                return f"{n} ({human_readable_size(n)})"
             else:
                 return str(n)
 
@@ -2508,7 +2508,7 @@ def bytestr(n):
             items += [("Name", self.name)]
         items += [
             ("Type", typestr(self)),
-            ("Data type", "%s" % self.dtype),
+            ("Data type", str(self.dtype)),
             ("Shape", str(self.shape)),
             ("Chunk shape", str(self.chunks)),
             ("Order", self.order),
@@ -2518,7 +2518,7 @@ def bytestr(n):
         # filters
         if self.filters:
             for i, f in enumerate(self.filters):
-                items += [("Filter [%s]" % i, repr(f))]
+                items += [(f"Filter [{i}]", repr(f))]
 
         # compressor
         items += [("Compressor", repr(self.compressor))]
@@ -2535,9 +2535,9 @@ def bytestr(n):
         if self.nbytes_stored > 0:
             items += [
                 ("No. bytes stored", bytestr(self.nbytes_stored)),
-                ("Storage ratio", "%.1f" % (self.nbytes / self.nbytes_stored)),
+                ("Storage ratio", f"{self.nbytes / self.nbytes_stored:.1f}"),
             ]
-        items += [("Chunks initialized", "{}/{}".format(self.nchunks_initialized, self.nchunks))]
+        items += [("Chunks initialized", f"{self.nchunks_initialized}/{self.nchunks}")]
 
         return items
 
diff --git a/zarr/creation.py b/zarr/creation.py
index 726d0b5932..6e00031cb3 100644
--- a/zarr/creation.py
+++ b/zarr/creation.py
@@ -282,7 +282,7 @@ def _kwargs_compat(compressor, fill_value, kwargs):
             compressor = compression
 
         else:
-            raise ValueError("bad value for compression: %r" % compression)
+            raise ValueError(f"bad value for compression: {compression!r}")
 
     # handle 'fillvalue'
     if "fillvalue" in kwargs:
@@ -292,7 +292,7 @@ def _kwargs_compat(compressor, fill_value, kwargs):
 
     # ignore other keyword arguments
     for k in kwargs:
-        warn("ignoring keyword argument %r" % k)
+        warn(f"ignoring keyword argument {k!r}")
 
     return compressor, fill_value
 
diff --git a/zarr/errors.py b/zarr/errors.py
index 30c9b13d39..7c6c42b374 100644
--- a/zarr/errors.py
+++ b/zarr/errors.py
@@ -67,9 +67,7 @@ def __init__(self):
 
 
 def err_too_many_indices(selection, shape):
-    raise IndexError(
-        "too many indices for array; expected {}, got {}".format(len(shape), len(selection))
-    )
+    raise IndexError(f"too many indices for array; expected {shape}, got {selection}")
 
 
 class VindexInvalidSelectionError(_BaseZarrIndexError):
diff --git a/zarr/hierarchy.py b/zarr/hierarchy.py
index 3361969f08..fad3e4337e 100644
--- a/zarr/hierarchy.py
+++ b/zarr/hierarchy.py
@@ -145,7 +145,7 @@ def __init__(
         synchronizer=None,
         zarr_version=None,
         *,
-        meta_array=None
+        meta_array=None,
     ):
         store: BaseStore = _normalize_store_arg(store, zarr_version=zarr_version)
         if zarr_version is None:
@@ -340,9 +340,9 @@ def __len__(self):
 
     def __repr__(self):
         t = type(self)
-        r = "<{}.{}".format(t.__module__, t.__name__)
+        r = f"<{t.__module__}.{t.__name__}"
         if self.name:
-            r += " %r" % self.name
+            r += f" {self.name!r}"
         if self._read_only:
             r += " read-only"
         r += ">"
@@ -358,7 +358,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
     def info_items(self):
         def typestr(o):
-            return "{}.{}".format(type(o).__module__, type(o).__name__)
+            return f"{type(o).__module__}.{type(o).__name__}"
 
         items = []
 
@@ -1161,17 +1161,15 @@ def _require_dataset_nosync(self, name, shape, dtype=None, exact=False, **kwargs
             shape = normalize_shape(shape)
             if shape != a.shape:
                 raise TypeError(
-                    "shape do not match existing array; expected {}, got {}".format(a.shape, shape)
+                    f"shape do not match existing array; expected {a.shape}, got {shape}"
                 )
             dtype = np.dtype(dtype)
             if exact:
                 if dtype != a.dtype:
-                    raise TypeError(
-                        "dtypes do not match exactly; expected {}, got {}".format(a.dtype, dtype)
-                    )
+                    raise TypeError(f"dtypes do not match exactly; expected {a.dtype}, got {dtype}")
             else:
                 if not np.can_cast(dtype, a.dtype):
-                    raise TypeError("dtypes ({}, {}) cannot be safely cast".format(dtype, a.dtype))
+                    raise TypeError(f"dtypes ({dtype}, {a.dtype}) cannot be safely cast")
             return a
 
         else:
@@ -1235,7 +1233,7 @@ def _full_nosync(self, name, fill_value, **kwargs):
             path=path,
             chunk_store=self._chunk_store,
             fill_value=fill_value,
-            **kwargs
+            **kwargs,
         )
 
     def array(self, name, data, **kwargs):
@@ -1361,7 +1359,7 @@ def group(
     path=None,
     *,
     zarr_version=None,
-    meta_array=None
+    meta_array=None,
 ):
     """Create a group.
 
@@ -1452,7 +1450,7 @@ def open_group(
     storage_options=None,
     *,
     zarr_version=None,
-    meta_array=None
+    meta_array=None,
 ):
     """Open a group using file-mode-like semantics.
 
diff --git a/zarr/indexing.py b/zarr/indexing.py
index 487cc8b9d9..bd6c51ca4b 100644
--- a/zarr/indexing.py
+++ b/zarr/indexing.py
@@ -346,8 +346,8 @@ def __init__(self, selection, array):
 
             else:
                 raise IndexError(
-                    "unsupported selection item for basic indexing; "
-                    "expected integer or slice, got {!r}".format(type(dim_sel))
+                    f"unsupported selection item for basic indexing; "
+                    f"expected integer or slice, got {type(dim_sel)!r}"
                 )
 
             dim_indexers.append(dim_indexer)
@@ -380,8 +380,8 @@ def __init__(self, dim_sel, dim_len, dim_chunk_len):
         # check shape
         if dim_sel.shape[0] != dim_len:
             raise IndexError(
-                "Boolean array has the wrong length for dimension; "
-                "expected {}, got {}".format(dim_len, dim_sel.shape[0])
+                f"Boolean array has the wrong length for dimension; "
+                f"expected {dim_len}, got { dim_sel.shape[0]}"
             )
 
         # store attributes
@@ -627,9 +627,9 @@ def __init__(self, selection, array):
 
             else:
                 raise IndexError(
-                    "unsupported selection item for orthogonal indexing; "
-                    "expected integer, slice, integer array or Boolean "
-                    "array, got {!r}".format(type(dim_sel))
+                    f"unsupported selection item for orthogonal indexing; "
+                    f"expected integer, slice, integer array or Boolean "
+                    f"array, got {type(dim_sel)!r}"
                 )
 
             dim_indexers.append(dim_indexer)
@@ -718,8 +718,8 @@ def __init__(self, selection, array):
 
                 if dim_sel.step not in {1, None}:
                     raise IndexError(
-                        "unsupported selection item for block indexing; "
-                        "expected integer or slice with step=1, got {!r}".format(type(dim_sel))
+                        f"unsupported selection item for block indexing; "
+                        f"expected integer or slice with step=1, got {type(dim_sel)!r}"
                     )
 
                 # Can't reuse wraparound_indices because it expects a numpy array
@@ -735,8 +735,8 @@ def __init__(self, selection, array):
 
             else:
                 raise IndexError(
-                    "unsupported selection item for block indexing; "
-                    "expected integer or slice, got {!r}".format(type(dim_sel))
+                    f"unsupported selection item for block indexing; "
+                    f"expected integer or slice, got {type(dim_sel)!r}"
                 )
 
             dim_indexer = SliceDimIndexer(slice_, dim_len, dim_chunk_size)
@@ -803,9 +803,9 @@ def __init__(self, selection, array):
         # validation
         if not is_coordinate_selection(selection, array):
             raise IndexError(
-                "invalid coordinate selection; expected one integer "
-                "(coordinate) array per dimension of the target array, "
-                "got {!r}".format(selection)
+                f"invalid coordinate selection; expected one integer "
+                f"(coordinate) array per dimension of the target array, "
+                f"got {selection!r}"
             )
 
         # handle wraparound, boundscheck
@@ -899,8 +899,8 @@ def __init__(self, selection, array):
         # validation
         if not is_mask_selection(selection, array):
             raise IndexError(
-                "invalid mask selection; expected one Boolean (mask)"
-                "array with the same shape as the target array, got {!r}".format(selection)
+                f"invalid mask selection; expected one Boolean (mask)"
+                f"array with the same shape as the target array, got {selection!r}"
             )
 
         # convert to indices
@@ -944,8 +944,7 @@ def check_fields(fields, dtype):
     # check type
     if not isinstance(fields, (str, list, tuple)):
         raise IndexError(
-            "'fields' argument must be a string or list of strings; found "
-            "{!r}".format(type(fields))
+            f"'fields' argument must be a string or list of strings; found " f"{type(fields)!r}"
         )
     if fields:
         if dtype.names is None:
@@ -958,7 +957,7 @@ def check_fields(fields, dtype):
                 # multiple field selection
                 out_dtype = np.dtype([(f, dtype[f]) for f in fields])
         except KeyError as e:
-            raise IndexError("invalid 'fields' argument, field not found: {!r}".format(e))
+            raise IndexError(f"invalid 'fields' argument, field not found: {e!r}")
         else:
             return out_dtype
     else:
diff --git a/zarr/meta.py b/zarr/meta.py
index 48791ddf17..f023d824af 100644
--- a/zarr/meta.py
+++ b/zarr/meta.py
@@ -112,7 +112,7 @@ def decode_array_metadata(cls, s: Union[MappingType, bytes, str]) -> MappingType
         # check metadata format
         zarr_format = meta.get("zarr_format", None)
         if zarr_format != cls.ZARR_FORMAT:
-            raise MetadataError("unsupported zarr format: %s" % zarr_format)
+            raise MetadataError(f"unsupported zarr format: {zarr_format}")
 
         # extract array metadata fields
         try:
@@ -200,7 +200,7 @@ def decode_group_metadata(cls, s: Union[MappingType, bytes, str]) -> MappingType
         # check metadata format version
         zarr_format = meta.get("zarr_format", None)
         if zarr_format != cls.ZARR_FORMAT:
-            raise MetadataError("unsupported zarr format: %s" % zarr_format)
+            raise MetadataError(f"unsupported zarr format: {zarr_format}")
 
         meta = dict(zarr_format=zarr_format)
         return meta
@@ -347,7 +347,7 @@ def decode_group_metadata(cls, s: Union[MappingType, bytes, str]) -> MappingType
         # # check metadata format version
         # zarr_format = meta.get("zarr_format", None)
         # if zarr_format != cls.ZARR_FORMAT:
-        #     raise MetadataError("unsupported zarr format: %s" % zarr_format)
+        #     raise MetadataError(f"unsupported zarr format: {zarr_format}")
 
         assert "attributes" in meta
         # meta = dict(attributes=meta['attributes'])
@@ -384,7 +384,7 @@ def decode_hierarchy_metadata(cls, s: Union[MappingType, bytes, str]) -> Mapping
         # check metadata format
         # zarr_format = meta.get("zarr_format", None)
         # if zarr_format != "https://purl.org/zarr/spec/protocol/core/3.0":
-        #     raise MetadataError("unsupported zarr format: %s" % zarr_format)
+        #     raise MetadataError(f"unsupported zarr format: {zarr_format}")
         if set(meta.keys()) != {
             "zarr_format",
             "metadata_encoding",
@@ -519,7 +519,7 @@ def decode_array_metadata(cls, s: Union[MappingType, bytes, str]) -> MappingType
                 meta["storage_transformers"] = storage_transformers
 
         except Exception as e:
-            raise MetadataError("error decoding metadata: %s" % e)
+            raise MetadataError(f"error decoding metadata: {e}")
         else:
             return meta
 
diff --git a/zarr/meta_v1.py b/zarr/meta_v1.py
index 4ac381f2ca..65bfd3488e 100644
--- a/zarr/meta_v1.py
+++ b/zarr/meta_v1.py
@@ -10,7 +10,7 @@ def decode_metadata(b):
     meta = json.loads(s)
     zarr_format = meta.get("zarr_format", None)
     if zarr_format != 1:
-        raise MetadataError("unsupported zarr format: %s" % zarr_format)
+        raise MetadataError(f"unsupported zarr format: {zarr_format}")
     try:
         meta = dict(
             zarr_format=meta["zarr_format"],
@@ -23,7 +23,7 @@ def decode_metadata(b):
             order=meta["order"],
         )
     except Exception as e:
-        raise MetadataError("error decoding metadata: %s" % e)
+        raise MetadataError(f"error decoding metadata: {e}")
     else:
         return meta
 
diff --git a/zarr/n5.py b/zarr/n5.py
index 7e73905527..3459e3255d 100644
--- a/zarr/n5.py
+++ b/zarr/n5.py
@@ -879,9 +879,9 @@ def decode(self, chunk, out=None) -> bytes:
         if out is not None:
 
             # out should only be used if we read a complete chunk
-            assert chunk_shape == self.chunk_shape, "Expected chunk of shape {}, found {}".format(
-                self.chunk_shape, chunk_shape
-            )
+            assert (
+                chunk_shape == self.chunk_shape
+            ), f"Expected chunk of shape {self.chunk_shape}, found {chunk_shape}"
 
             if self._compressor:
                 self._compressor.decode(chunk, out)
diff --git a/zarr/storage.py b/zarr/storage.py
index b36f804ebd..278daebec0 100644
--- a/zarr/storage.py
+++ b/zarr/storage.py
@@ -2702,14 +2702,12 @@ def listdir(self, path=None):
         path = normalize_storage_path(path)
         sep = "_" if path == "" else "/"
         keys = self.cursor.execute(
-            """
+            f"""
             SELECT DISTINCT SUBSTR(m, 0, INSTR(m, "/")) AS l FROM (
                 SELECT LTRIM(SUBSTR(k, LENGTH(?) + 1), "/") || "/" AS m
                 FROM zarr WHERE k LIKE (? || "{sep}%")
             ) ORDER BY l ASC
-            """.format(
-                sep=sep
-            ),
+            """,
             (path, path),
         )
         keys = list(map(operator.itemgetter(0), keys))
@@ -2865,7 +2863,7 @@ def __init__(self, prefix="zarr", dimension_separator=None, **kwargs):
         self.client = redis.Redis(**kwargs)
 
     def _key(self, key):
-        return "{prefix}:{key}".format(prefix=self._prefix, key=key)
+        return f"{self._prefix}:{key}"
 
     def __getitem__(self, key):
         return self.client[self._key(key)]
@@ -2950,7 +2948,7 @@ def __init__(self, store: StoreLike, metadata_key=".zmetadata"):
         consolidated_format = meta.get("zarr_consolidated_format", None)
         if consolidated_format != 1:
             raise MetadataError(
-                "unsupported zarr consolidated metadata format: %s" % consolidated_format
+                f"unsupported zarr consolidated metadata format: {consolidated_format}"
             )
 
         # decode metadata
diff --git a/zarr/tests/test_core.py b/zarr/tests/test_core.py
index 77b9415d8b..6e061d42bd 100644
--- a/zarr/tests/test_core.py
+++ b/zarr/tests/test_core.py
@@ -179,7 +179,7 @@ def test_store_has_text_keys(self):
 
         for k in z.chunk_store.keys():
             if not isinstance(k, expected_type):  # pragma: no cover
-                pytest.fail("Non-text key: %s" % repr(k))
+                pytest.fail(f"Non-text key: {k!r}")
 
         z.store.close()
 
@@ -193,7 +193,7 @@ def test_store_has_binary_values(self):
             try:
                 ensure_ndarray(v)
             except TypeError:  # pragma: no cover
-                pytest.fail("Non-bytes-like value: %s" % repr(v))
+                pytest.fail(f"Non-bytes-like value: {v!r}")
 
         z.store.close()
 
@@ -1207,7 +1207,7 @@ def test_dtypes(self):
         # datetime, timedelta
         for base_type in "Mm":
             for resolution in "D", "us", "ns":
-                dtype = "{}8[{}]".format(base_type, resolution)
+                dtype = f"{base_type}8[{resolution}]"
                 z = self.create_array(shape=100, dtype=dtype, fill_value=0)
                 assert z.dtype == np.dtype(dtype)
                 a = np.random.randint(
@@ -1401,7 +1401,7 @@ def compare_arrays(expected, actual, item_dtype):
 
         # convenience API
         for item_type in "int", "<u4":
-            z = self.create_array(shape=data.shape, dtype="array:{}".format(item_type))
+            z = self.create_array(shape=data.shape, dtype=f"array:{item_type}")
             assert z.dtype == object
             assert isinstance(z.filters[0], VLenArray)
             assert z.filters[0].dtype == np.dtype(item_type)
@@ -1983,7 +1983,7 @@ def test_object_arrays_vlen_array(self):
         # convenience API
         for item_type in "int", "<u4":
             with pytest.raises(ValueError):
-                self.create_array(shape=data.shape, dtype="array:{}".format(item_type))
+                self.create_array(shape=data.shape, dtype=f"array:{item_type}")
 
     def test_object_arrays_danger(self):
         # Cannot hacking out object codec as N5 doesn't allow object codecs
diff --git a/zarr/tests/test_meta.py b/zarr/tests/test_meta.py
index db50560c8e..66b28c1d6c 100644
--- a/zarr/tests/test_meta.py
+++ b/zarr/tests/test_meta.py
@@ -45,19 +45,16 @@ def test_encode_decode_array_1():
         order="C",
     )
 
-    meta_json = (
-        """{
+    meta_json = f"""{{
         "chunks": [10],
-        "compressor": {"id": "zlib", "level": 1},
+        "compressor": {{"id": "zlib", "level": 1}},
         "dtype": "<f8",
         "fill_value": null,
         "filters": null,
         "order": "C",
         "shape": [100],
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
 
     # test encoding
     meta_enc = encode_array_metadata(meta)
@@ -92,27 +89,24 @@ def test_encode_decode_array_2():
         filters=[df.get_config()],
     )
 
-    meta_json = (
-        """{
+    meta_json = f"""{{
         "chunks": [10, 10],
-        "compressor": {
+        "compressor": {{
             "id": "blosc",
             "clevel": 3,
             "cname": "lz4",
             "shuffle": 2,
             "blocksize": 0
-        },
+        }},
         "dtype": [["a", "<i4"], ["b", "|S10"]],
         "fill_value": "AAAAAAAAAAAAAAAAAAA=",
         "filters": [
-            {"id": "delta", "astype": "<u2", "dtype": "|V14"}
+            {{"id": "delta", "astype": "<u2", "dtype": "|V14"}}
         ],
         "order": "F",
         "shape": [100, 100],
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
 
     # test encoding
     meta_enc = encode_array_metadata(meta)
@@ -147,26 +141,22 @@ def test_encode_decode_array_complex():
             filters=[],
         )
 
-        meta_json = """{
+        meta_json = f"""{{
             "chunks": [10, 10],
-            "compressor": {
+            "compressor": {{
                 "id": "blosc",
                 "clevel": 3,
                 "cname": "lz4",
                 "shuffle": 2,
                 "blocksize": 0
-            },
-            "dtype": "%s",
+            }},
+            "dtype": "{dtype.str}",
             "fill_value": ["NaN", -1.0],
             "filters": [],
-            "order": "%s",
+            "order": "{dtype.char}",
             "shape": [100, 100],
-            "zarr_format": %s
-        }""" % (
-            dtype.str,
-            dtype.char,
-            ZARR_FORMAT,
-        )
+            "zarr_format": {ZARR_FORMAT}
+        }}"""
 
         # test encoding
         meta_enc = encode_array_metadata(meta)
@@ -205,26 +195,22 @@ def test_encode_decode_array_datetime_timedelta():
             filters=[],
         )
 
-        meta_json = """{
+        meta_json = f"""{{
             "chunks": [10, 10],
-            "compressor": {
+            "compressor": {{
                 "id": "blosc",
                 "clevel": 3,
                 "cname": "lz4",
                 "shuffle": 2,
                 "blocksize": 0
-            },
-            "dtype": "%s",
+            }},
+            "dtype": "{dtype.str}",
             "fill_value": -9223372036854775808,
             "filters": [],
-            "order": "%s",
+            "order": "{dtype.char}",
             "shape": [100, 100],
-            "zarr_format": %s
-        }""" % (
-            dtype.str,
-            dtype.char,
-            ZARR_FORMAT,
-        )
+            "zarr_format": {ZARR_FORMAT}
+        }}"""
 
         # test encoding
         meta_enc = encode_array_metadata(meta)
@@ -258,19 +244,16 @@ def test_encode_decode_array_dtype_shape():
         order="C",
     )
 
-    meta_json = (
-        """{
+    meta_json = f"""{{
         "chunks": [10],
-        "compressor": {"id": "zlib", "level": 1},
+        "compressor": {{"id": "zlib", "level": 1}},
         "dtype": "<f8",
         "fill_value": null,
         "filters": null,
         "order": "C",
         "shape": [100, 10, 10],
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
 
     # test encoding
     meta_enc = encode_array_metadata(meta)
@@ -374,19 +357,16 @@ def test_encode_decode_array_structured():
         order="C",
     )
 
-    meta_json = (
-        """{
+    meta_json = f"""{{
         "chunks": [10],
-        "compressor": {"id": "zlib", "level": 1},
+        "compressor": {{"id": "zlib", "level": 1}},
         "dtype": [["f0", "<i8"], ["f1", "<f8", [10, 10]], ["f2", "|u1", [5, 10, 15]]],
         "fill_value": null,
         "filters": null,
         "order": "C",
         "shape": [100],
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
 
     # test encoding
     meta_enc = encode_array_metadata(meta)
@@ -426,19 +406,16 @@ def test_encode_decode_fill_values_nan():
             order="C",
         )
 
-        meta_json = """{
+        meta_json = f"""{{
             "chunks": [10],
-            "compressor": {"id": "zlib", "level": 1},
+            "compressor": {{"id": "zlib", "level": 1}},
             "dtype": "<f8",
-            "fill_value": "%s",
+            "fill_value": "{s}",
             "filters": null,
             "order": "C",
             "shape": [100],
-            "zarr_format": %s
-        }""" % (
-            s,
-            ZARR_FORMAT,
-        )
+            "zarr_format": {ZARR_FORMAT}
+        }}"""
 
         # test encoding
         meta_enc = encode_array_metadata(meta)
@@ -472,19 +449,16 @@ def test_encode_decode_fill_values_bytes():
         # define expected metadata encoded as JSON
         s = base64.standard_b64encode(v)
         s = s.decode()
-        meta_json = """{
+        meta_json = f"""{{
             "chunks": [10],
-            "compressor": {"id": "zlib", "level": 1},
+            "compressor": {{"id": "zlib", "level": 1}},
             "dtype": "|S10",
-            "fill_value": "%s",
+            "fill_value": "{s}",
             "filters": null,
             "order": "C",
             "shape": [100],
-            "zarr_format": %s
-        }""" % (
-            s,
-            ZARR_FORMAT,
-        )
+            "zarr_format": {ZARR_FORMAT}
+        }}"""
 
         # test encoding
         assert_json_equal(meta_json, meta_enc)
@@ -499,17 +473,15 @@ def test_encode_decode_fill_values_bytes():
 def test_decode_array_unsupported_format():
 
     # unsupported format
-    meta_json = """{
-        "zarr_format": %s,
+    meta_json = f"""{{
+        "zarr_format": {ZARR_FORMAT - 1},
         "shape": [100],
         "chunks": [10],
         "dtype": "<f8",
-        "compressor": {"id": "zlib", "level": 1},
+        "compressor": {{"id": "zlib", "level": 1}},
         "fill_value": null,
         "order": "C"
-    }""" % (
-        ZARR_FORMAT - 1
-    )
+    }}"""
     with pytest.raises(MetadataError):
         decode_array_metadata(meta_json)
 
@@ -517,12 +489,9 @@ def test_decode_array_unsupported_format():
 def test_decode_array_missing_fields():
 
     # missing fields
-    meta_json = (
-        """{
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+    meta_json = f"""{{
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
     with pytest.raises(MetadataError):
         decode_array_metadata(meta_json)
 
@@ -540,21 +509,16 @@ def test_encode_decode_dtype():
 def test_decode_group():
 
     # typical
-    b = (
-        """{
-        "zarr_format": %s
-    }"""
-        % ZARR_FORMAT
-    )
+    b = f"""{{
+        "zarr_format": {ZARR_FORMAT}
+    }}"""
     meta = decode_group_metadata(b)
     assert ZARR_FORMAT == meta["zarr_format"]
 
     # unsupported format
-    b = """{
-        "zarr_format": %s
-    }""" % (
-        ZARR_FORMAT - 1
-    )
+    b = f"""{{
+        "zarr_format": {ZARR_FORMAT - 1}
+    }}"""
     with pytest.raises(MetadataError):
         decode_group_metadata(b)
 
diff --git a/zarr/tests/test_storage.py b/zarr/tests/test_storage.py
index ca6a6c1a98..3c1cbd8e59 100644
--- a/zarr/tests/test_storage.py
+++ b/zarr/tests/test_storage.py
@@ -1399,9 +1399,9 @@ def s3(request):
     pytest.importorskip("moto")
 
     port = 5555
-    endpoint_uri = "http://127.0.0.1:%d/" % port
+    endpoint_uri = f"http://127.0.0.1:{port}/"
     proc = subprocess.Popen(
-        shlex.split("moto_server s3 -p %d" % port),
+        shlex.split("moto_server s3 -p {port}"),
         stderr=subprocess.DEVNULL,
         stdout=subprocess.DEVNULL,
     )
@@ -2387,7 +2387,7 @@ def test_format_compatibility():
             order = "C"
 
         for j, compressor in enumerate(compressors):
-            path = "{}/{}".format(i, j)
+            path = f"{i}/{j}"
 
             if path not in fixture:  # pragma: no cover
                 # store the data - should be one-time operation
diff --git a/zarr/util.py b/zarr/util.py
index ea0dd9fcec..fcc16caedc 100644
--- a/zarr/util.py
+++ b/zarr/util.py
@@ -180,7 +180,6 @@ def normalize_chunks(chunks: Any, shape: Tuple[int, ...], typesize: int) -> Tupl
 
 
 def normalize_dtype(dtype: Union[str, np.dtype], object_codec) -> Tuple[np.dtype, Any]:
-
     # convenience API for object arrays
     if inspect.isclass(dtype):
         dtype = dtype.__name__  # type: ignore
@@ -200,9 +199,8 @@ def normalize_dtype(dtype: Union[str, np.dtype], object_codec) -> Tuple[np.dtype
                     object_codec = codec_registry[codec_id](*args)
                 except KeyError:  # pragma: no cover
                     raise ValueError(
-                        "codec %r for object type %r is not "
-                        "available; please provide an "
-                        "object_codec manually" % (codec_id, key)
+                        f"codec {codec_id!r} for object type {key!r} is not "
+                        f"available; please provide an object_codec manually"
                     )
             return dtype, object_codec
 
@@ -241,11 +239,10 @@ def is_total_slice(item, shape: Tuple[int]) -> bool:
             for it, sh in zip(item, shape)
         )
     else:
-        raise TypeError("expected slice or tuple of slices, found %r" % item)
+        raise TypeError(f"expected slice or tuple of slices, found {item!r}")
 
 
 def normalize_resize_args(old_shape, *args):
-
     # normalize new shape argument
     if len(args) == 1:
         new_shape = args[0]
@@ -266,23 +263,23 @@ def normalize_resize_args(old_shape, *args):
 
 def human_readable_size(size) -> str:
     if size < 2**10:
-        return "%s" % size
+        return f"{size}"
     elif size < 2**20:
-        return "%.1fK" % (size / float(2**10))
+        return f"{size / float(2**10):.1f}K"
     elif size < 2**30:
-        return "%.1fM" % (size / float(2**20))
+        return f"{size / float(2**20):.1f}M"
     elif size < 2**40:
-        return "%.1fG" % (size / float(2**30))
+        return f"{size / float(2**30):.1f}G"
     elif size < 2**50:
-        return "%.1fT" % (size / float(2**40))
+        return f"{size / float(2**40):.1f}T"
     else:
-        return "%.1fP" % (size / float(2**50))
+        return f"{size / float(2**50):.1f}P"
 
 
 def normalize_order(order: str) -> str:
     order = str(order).upper()
     if order not in ["C", "F"]:
-        raise ValueError("order must be either 'C' or 'F', found: %r" % order)
+        raise ValueError(f"order must be either 'C' or 'F', found: {order!r}")
     return order
 
 
@@ -290,11 +287,10 @@ def normalize_dimension_separator(sep: Optional[str]) -> Optional[str]:
     if sep in (".", "/", None):
         return sep
     else:
-        raise ValueError("dimension_separator must be either '.' or '/', found: %r" % sep)
+        raise ValueError(f"dimension_separator must be either '.' or '/', found: {sep!r}")
 
 
 def normalize_fill_value(fill_value, dtype: np.dtype):
-
     if fill_value is None or dtype.hasobject:
         # no fill value
         pass
@@ -309,8 +305,8 @@ def normalize_fill_value(fill_value, dtype: np.dtype):
 
         if not isinstance(fill_value, str):
             raise ValueError(
-                "fill_value {!r} is not valid for dtype {}; must be a "
-                "unicode string".format(fill_value, dtype)
+                f"fill_value {fill_value!r} is not valid for dtype {dtype}; "
+                f"must be a  unicode string"
             )
 
     else:
@@ -324,15 +320,14 @@ def normalize_fill_value(fill_value, dtype: np.dtype):
         except Exception as e:
             # re-raise with our own error message to be helpful
             raise ValueError(
-                "fill_value {!r} is not valid for dtype {}; nested "
-                "exception: {}".format(fill_value, dtype, e)
+                f"fill_value {fill_value!r} is not valid for dtype {dtype}; "
+                f"nested exception: {e}"
             )
 
     return fill_value
 
 
 def normalize_storage_path(path: Union[str, bytes, None]) -> str:
-
     # handle bytes
     if isinstance(path, bytes):
         path = str(path, "ascii")
@@ -342,7 +337,6 @@ def normalize_storage_path(path: Union[str, bytes, None]) -> str:
         path = str(path)
 
     if path:
-
         # convert backslash to forward slash
         path = path.replace("\\", "/")
 
@@ -400,10 +394,10 @@ def info_html_report(items) -> str:
     report += "<tbody>"
     for k, v in items:
         report += (
-            "<tr>"
-            '<th style="text-align: left">%s</th>'
-            '<td style="text-align: left">%s</td>'
-            "</tr>" % (k, v)
+            f"<tr>"
+            f'<th style="text-align: left">{k}</th>'
+            f'<td style="text-align: left">{v}</td>'
+            f"</tr>"
         )
     report += "</tbody>"
     report += "</table>"
@@ -439,7 +433,7 @@ def get_children(self):
     def get_text(self):
         name = self.obj.name.split("/")[-1] or "/"
         if hasattr(self.obj, "shape"):
-            name += " {} {}".format(self.obj.shape, self.obj.dtype)
+            name += f" {self.obj.shape} {self.obj.dtype}"
         return name
 
     def get_type(self):
@@ -467,7 +461,7 @@ def tree_get_icon(stype: str) -> str:
     elif stype == "Group":
         return tree_group_icon
     else:
-        raise ValueError("Unknown type: %s" % stype)
+        raise ValueError(f"Unknown type: {stype}")
 
 
 def tree_widget_sublist(node, root=False, expand=False):
@@ -491,10 +485,10 @@ def tree_widget(group, expand, level):
         import ipytree
     except ImportError as error:
         raise ImportError(
-            "{}: Run `pip install zarr[jupyter]` or `conda install ipytree`"
-            "to get the required ipytree dependency for displaying the tree "
-            "widget. If using jupyterlab<3, you also need to run "
-            "`jupyter labextension install ipytree`".format(error)
+            f"{error}: Run `pip install zarr[jupyter]` or `conda install ipytree`"
+            f"to get the required ipytree dependency for displaying the tree "
+            f"widget. If using jupyterlab<3, you also need to run "
+            f"`jupyter labextension install ipytree`"
         )
 
     result = ipytree.Tree()
@@ -506,7 +500,6 @@ def tree_widget(group, expand, level):
 
 class TreeViewer:
     def __init__(self, group, expand=False, level=None):
-
         self.group = group
         self.expand = expand
         self.level = level
@@ -554,14 +547,10 @@ def _repr_mimebundle_(self, **kwargs):
 
 def check_array_shape(param, array, shape):
     if not hasattr(array, "shape"):
-        raise TypeError(
-            "parameter {!r}: expected an array-like object, got {!r}".format(param, type(array))
-        )
+        raise TypeError(f"parameter {param!r}: expected an array-like object, got {type(array)!r}")
     if array.shape != shape:
         raise ValueError(
-            "parameter {!r}: expected array with shape {!r}, got {!r}".format(
-                param, shape, array.shape
-            )
+            f"parameter {param!r}: expected array with shape {shape!r}, got {array.shape!r}"
         )