GH-45619: [Python] Use f-string instead of string.format (#45629)

### Rationale for this change

See #45619.

### What changes are included in this PR?

Refactor using f-string instead of `string.format`. But do not use f-string for following case,  `string.format` allows passing parameters, making the code more reusable.

https://github.com/apache/arrow/blob/0fbf9823542233c5f32c26534c34cc97ce3f0be2/python/pyarrow/parquet/core.py#L1624-L1695

### Are these changes tested?

Via CI.

### Are there any user-facing changes?

No.

* GitHub Issue: #45619

Lead-authored-by: Chilin Chiou <chilin.chiou@gmail.com>
Co-authored-by: Raúl Cumplido <raulcumplido@gmail.com>
Signed-off-by: Raúl Cumplido <raulcumplido@gmail.com>

Author: chilin0525

cpp/build-support/asan_symbolize.py

@@ -171,7 +171,7 @@ def symbolize(self, addr, binary, offset):
     #   foo(type1, type2) (in object.name) (filename.cc:80)
     match = re.match(r'^(.*) \(in (.*)\) \((.*:\d*)\)$', atos_line)
     if DEBUG:
-      print('atos_line: {0}'.format(atos_line))
+      print(f'atos_line: {atos_line}')
     if match:
       function_name = match.group(1)
       function_name = re.sub(r'\(.*?\)', '', function_name)

cpp/build-support/fuzzing/pack_corpus.py

@@ -31,13 +31,12 @@ def process_dir(corpus_dir, zip_output):
 
     for child in corpus_dir.iterdir():
         if not child.is_file():
-            raise IOError("Not a file: {0}".format(child))
+            raise IOError(f"Not a file: {child}")
         with child.open('rb') as f:
             data = f.read()
         arcname = hashlib.sha1(data).hexdigest()
         if arcname in seen:
-            raise ValueError("Duplicate hash: {0} (in file {1})"
-                             .format(arcname, child))
+            raise ValueError(f"Duplicate hash: {arcname} (in file {child})")
         zip_output.writestr(str(arcname), data)
         seen.add(arcname)
 
@@ -49,6 +48,6 @@ def main(corpus_dir, zip_output_name):
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
-        print("Usage: {0} <corpus dir> <output zip file>".format(sys.argv[0]))
+        print(f"Usage: {sys.argv[0]} <corpus dir> <output zip file>")
         sys.exit(1)
     main(sys.argv[1], sys.argv[2])

cpp/build-support/iwyu/iwyu_tool.py

@@ -204,7 +204,7 @@ def main(compilation_db_path, source_files, verbose, formatter, iwyu_args):
             if matches:
                 entries.extend(matches)
             else:
-                print("{} not in compilation database".format(source))
+                print(f"{source} not in compilation database")
                 # TODO: As long as there is no complete compilation database available this check cannot be performed
                 pass
                 #print('WARNING: \'%s\' not found in compilation database.', source)

cpp/build-support/lint_cpp_cli.py

@@ -121,7 +121,7 @@ def lint_files():
 if __name__ == '__main__':
     failures = list(lint_files())
     for path, why, i, line in failures:
-        print('File {0} failed C++/CLI lint check: {1}\n'
-              'Line {2}: {3}'.format(path, why, i + 1, line))
+        print(f'File {path} failed C++/CLI lint check: {why}\n'
+              f'Line {i + 1}: {line}')
     if failures:
         exit(1)

cpp/build-support/run_clang_format.py

@@ -38,8 +38,7 @@ def _check_one_file(filename, formatted):
             original.decode('utf8').splitlines(True),
             formatted.decode('utf8').splitlines(True),
             fromfile=filename,
-            tofile="{} (after clang format)".format(
-                filename)))
+            tofile=f"{filename} (after clang format)"))
     else:
         diff = None
 
@@ -85,8 +84,7 @@ def _check_one_file(filename, formatted):
 
     if arguments.fix:
         if not arguments.quiet:
-            print("\n".join(map(lambda x: "Formatting {}".format(x),
-                                formatted_filenames)))
+            print("\n".join(f"Formatting {x}" for x in formatted_filenames))
 
         # Break clang-format invocations into chunks: each invocation formats
         # 16 files. Wait for all processes to complete
@@ -122,9 +120,9 @@ def _check_one_file(filename, formatted):
             # check the output from each invocation of clang-format in parallel
             for filename, diff in pool.starmap(_check_one_file, checker_args):
                 if not arguments.quiet:
-                    print("Checking {}".format(filename))
+                    print(f"Checking {filename}")
                 if diff:
-                    print("{} had clang-format style issues".format(filename))
+                    print(f"{filename} had clang-format style issues")
                     # Print out the diff to stderr
                     error = True
                     # pad with a newline

cpp/build-support/run_cpplint.py

@@ -78,7 +78,7 @@ def _check_some_files(completed_processes, filenames):
     if arguments.quiet:
         cmd.append('--quiet')
     else:
-        print("\n".join(map(lambda x: "Linting {}".format(x),
+        print("\n".join(map(lambda x: f"Linting {x}",
                             linted_filenames)))
 
     # lint files in chunks: each invocation of cpplint will process 16 files

cpp/src/arrow/util/bpacking64_codegen.py

@@ -73,55 +73,52 @@ def howmanybytes(bit):
 
 
 print("inline const uint8_t* unpack0_64(const uint8_t* in, uint64_t* out) {")
-print("  for(int k = 0; k < {0} ; k += 1) {{".format(howmany(0)))
+print(f"  for(int k = 0; k < {howmany(0)} ; k += 1) {{")
 print("    out[k] = 0;")
 print("  }")
 print("  return in;")
 print("}")
 
 for bit in range(1, 65):
     print("")
-    print(
-        "inline const uint8_t* unpack{0}_64(const uint8_t* in, uint64_t* out) {{".format(bit))
+    print(f"inline const uint8_t* unpack{bit}_64(const uint8_t* in, uint64_t* out) {{")
 
     if(bit < 64):
-        print("  const uint64_t mask = {0}ULL;".format((1 << bit)-1))
+        print(f"  const uint64_t mask = {((1 << bit)-1)}ULL;")
     maskstr = " & mask"
     if (bit == 64):
         maskstr = ""  # no need
 
     for k in range(howmanywords(bit)-1):
-        print("  uint64_t w{0} = util::SafeLoadAs<uint64_t>(in);".format(k))
-        print("  w{0} = arrow::BitUtil::FromLittleEndian(w{0});".format(k))
-        print("  in += 8;".format(k))
+        print(f"  uint64_t w{k} = util::SafeLoadAs<uint64_t>(in);")
+        print(f"  w{k} = arrow::BitUtil::FromLittleEndian(w{k});")
+        print("  in += 8;")
     k = howmanywords(bit) - 1
     if (bit % 2 == 0):
-        print("  uint64_t w{0} = util::SafeLoadAs<uint64_t>(in);".format(k))
-        print("  w{0} = arrow::BitUtil::FromLittleEndian(w{0});".format(k))
-        print("  in += 8;".format(k))
+        print(f"  uint64_t w{k} = util::SafeLoadAs<uint64_t>(in);")
+        print(f"  w{k} = arrow::BitUtil::FromLittleEndian(w{k});")
+        print("  in += 8;")
     else:
-        print("  uint64_t w{0} = util::SafeLoadAs<uint32_t>(in);".format(k))
-        print("  w{0} = arrow::BitUtil::FromLittleEndian(w{0});".format(k))
-        print("  in += 4;".format(k))
+        print(f"  uint64_t w{k} = util::SafeLoadAs<uint32_t>(in);")
+        print(f"  w{k} = arrow::BitUtil::FromLittleEndian(w{k});")
+        print("  in += 4;")
 
     for j in range(howmany(bit)):
         firstword = j * bit // 64
         secondword = (j * bit + bit - 1)//64
         firstshift = (j*bit) % 64
-        firstshiftstr = " >> {0}".format(firstshift)
+        firstshiftstr = f" >> {firstshift}"
         if(firstshift == 0):
             firstshiftstr = ""  # no need
         if(firstword == secondword):
             if(firstshift + bit == 64):
-                print("  out[{0}] = w{1}{2};".format(
-                    j, firstword, firstshiftstr, firstshift))
+                print(f"  out[{j}] = w{firstword}{firstshiftstr};")
             else:
-                print("  out[{0}] = (w{1}{2}){3};".format(
-                    j, firstword, firstshiftstr, maskstr))
+                print(f"  out[{j}] = (w{firstword}{firstshiftstr}){maskstr};")
         else:
             secondshift = (64-firstshift)
-            print("  out[{0}] = ((w{1}{2}) | (w{3} << {4})){5};".format(
-                j, firstword, firstshiftstr, firstword+1, secondshift, maskstr))
+            print(f"  out[{j}] = ((w{firstword}{firstshiftstr}) | "
+                  f"(w{firstword+1} << {secondshift})){maskstr};")
     print("")
     print("  return in;")
     print("}")

cpp/src/gandiva/make_precompiled_bitcode.py

@@ -37,8 +37,8 @@ def apply_template(template, data):
 
 if __name__ == "__main__":
     if len(sys.argv) != 4:
-        raise ValueError("Usage: {0} <template file> <data file> "
-                         "<output file>".format(sys.argv[0]))
+        raise ValueError(f"Usage: {sys.argv[0]} <template file> <data file> "
+                         "<output file>")
     with open(sys.argv[1], "rb") as f:
         template = f.read()
     with open(sys.argv[2], "rb") as f:

dev/archery/archery/benchmark/compare.py

@@ -23,30 +23,30 @@
 
 def items_per_seconds_fmt(value):
     if value < 1000:
-        return "{} items/sec".format(value)
+        return f"{value} items/sec"
     if value < 1000**2:
-        return "{:.3f}K items/sec".format(value / 1000)
+        return f"{value / 1000:.3f}K items/sec"
     if value < 1000**3:
-        return "{:.3f}M items/sec".format(value / 1000**2)
+        return f"{value / 1000**2:.3f}M items/sec"
     else:
-        return "{:.3f}G items/sec".format(value / 1000**3)
+        return f"{value / 1000**3:.3f}G items/sec"
 
 
 def bytes_per_seconds_fmt(value):
     if value < 1024:
-        return "{} bytes/sec".format(value)
+        return f"{value} bytes/sec"
     if value < 1024**2:
-        return "{:.3f} KiB/sec".format(value / 1024)
+        return f"{value / 1024:.3f} KiB/sec"
     if value < 1024**3:
-        return "{:.3f} MiB/sec".format(value / 1024**2)
+        return f"{value / 1024**2:.3f} MiB/sec"
     if value < 1024**4:
-        return "{:.3f} GiB/sec".format(value / 1024**3)
+        return f"{value / 1024**3:.3f} GiB/sec"
     else:
-        return "{:.3f} TiB/sec".format(value / 1024**4)
+        return f"{value / 1024**4:.3f} TiB/sec"
 
 
 def change_fmt(value):
-    return "{:.3%}".format(value)
+    return f"{value:.3%}"
 
 
 def formatter_for_unit(unit):

dev/archery/archery/benchmark/core.py

@@ -43,7 +43,7 @@ def value(self):
         return self.median
 
     def __repr__(self):
-        return "Benchmark[name={},value={}]".format(self.name, self.value)
+        return f"Benchmark[name={self.name},value={self.value}]"
 
 
 class BenchmarkSuite:
@@ -52,6 +52,4 @@ def __init__(self, name, benchmarks):
         self.benchmarks = benchmarks
 
     def __repr__(self):
-        return "BenchmarkSuite[name={}, benchmarks={}]".format(
-            self.name, self.benchmarks
-        )
+        return f"BenchmarkSuite[name={self.name}, benchmarks={self.benchmarks}]"