diff --git a/Lib/test/test_zipfile/test_core.py b/Lib/test/test_zipfile/test_core.py
index 7c8a82d821a020..ad50bb38158f89 100644
--- a/Lib/test/test_zipfile/test_core.py
+++ b/Lib/test/test_zipfile/test_core.py
@@ -14,6 +14,7 @@
 import unittest
 import unittest.mock as mock
 import zipfile
+import filecmp
 
 
 from tempfile import TemporaryFile
@@ -610,14 +611,15 @@ def test_io_on_closed_zipextfile(self):
                 self.assertRaises(ValueError, fid.seek, 0)
                 self.assertRaises(ValueError, fid.tell)
 
-    def test_write_to_readonly(self):
-        """Check that trying to call write() on a readonly ZipFile object
+    def test_writing_to_readonly(self):
+        """Check that trying to write to a readonly ZipFile object
         raises a ValueError."""
         with zipfile.ZipFile(TESTFN2, mode="w") as zipfp:
             zipfp.writestr("somefile.txt", "bogus")
 
         with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
             self.assertRaises(ValueError, zipfp.write, TESTFN)
+            self.assertRaises(ValueError, zipfp.writestr, TESTFN, "data")
 
         with zipfile.ZipFile(TESTFN2, mode="r") as zipfp:
             with self.assertRaises(ValueError):
@@ -2057,6 +2059,7 @@ def test_closed_zip_raises_ValueError(self):
         # and report that the first file in the archive was corrupt.
         self.assertRaises(ValueError, zipf.read, "foo.txt")
         self.assertRaises(ValueError, zipf.open, "foo.txt")
+        self.assertRaises(ValueError, zipf.open, "foo.txt", "w")
         self.assertRaises(ValueError, zipf.testzip)
         self.assertRaises(ValueError, zipf.writestr, "bogus.txt", "bogus")
         with open(TESTFN, 'w', encoding='utf-8') as f:
@@ -2307,6 +2310,16 @@ def test_zipfile_with_short_extra_field(self):
             # testzip returns the name of the first corrupt file, or None
             self.assertIsNone(zipf.testzip())
 
+    def test_open_for_write_issues_exception_when_pwd_provided(self):
+        with zipfile.ZipFile(TESTFN2, 'w') as zipf:
+            with self.assertRaises(ValueError):
+                zipf.open("foo.txt", mode='w', pwd="password")
+
+    def test_open_for_write_issues_exception_when_force_zip_not_allowed(self):
+        with zipfile.ZipFile(TESTFN2, 'w', allowZip64=False) as zipf:
+            with self.assertRaises(ValueError):
+                zipf.open("foo.txt", mode='w', force_zip64=True)
+
     def test_open_conflicting_handles(self):
         # It's only possible to open one writable file handle at a time
         msg1 = b"It's fun to charter an accountant!"
@@ -2320,6 +2333,8 @@ def test_open_conflicting_handles(self):
                     zipf.open('handle', mode='w')
                 with self.assertRaises(ValueError):
                     zipf.open('foo', mode='r')
+                with self.assertRaises(ValueError):
+                    zipf.read('foo')
                 with self.assertRaises(ValueError):
                     zipf.writestr('str', 'abcde')
                 with self.assertRaises(ValueError):
@@ -2670,12 +2685,11 @@ class LzmaBadCrcTests(AbstractBadCrcTests, unittest.TestCase):
         b'\x00>\x00\x00\x00\x00\x00')
 
 
-class DecryptionTests(unittest.TestCase):
-    """Check that ZIP decryption works. Since the library does not
-    support encryption at the moment, we use a pre-generated encrypted
-    ZIP file."""
+class EncryptedFiles:
+    """ Since the library does not support encryption at the moment,
+    we use pre-generated encrypted ZIP files."""
 
-    data = (
+    encrypted_zip1_data = (
         b'PK\x03\x04\x14\x00\x01\x00\x00\x00n\x92i.#y\xef?&\x00\x00\x00\x1a\x00'
         b'\x00\x00\x08\x00\x00\x00test.txt\xfa\x10\xa0gly|\xfa-\xc5\xc0=\xf9y'
         b'\x18\xe0\xa8r\xb3Z}Lg\xbc\xae\xf9|\x9b\x19\xe4\x8b\xba\xbb)\x8c\xb0\xdbl'
@@ -2683,7 +2697,10 @@ class DecryptionTests(unittest.TestCase):
         b'\x1a\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x01\x00 \x00\xb6\x81'
         b'\x00\x00\x00\x00test.txtPK\x05\x06\x00\x00\x00\x00\x01\x00\x01\x006\x00'
         b'\x00\x00L\x00\x00\x00\x00\x00' )
-    data2 = (
+
+    zip1_filename = "test.txt"
+
+    encrypted_zip2_data = (
         b'PK\x03\x04\x14\x00\t\x00\x08\x00\xcf}38xu\xaa\xb2\x14\x00\x00\x00\x00\x02'
         b'\x00\x00\x04\x00\x15\x00zeroUT\t\x00\x03\xd6\x8b\x92G\xda\x8b\x92GUx\x04'
         b'\x00\xe8\x03\xe8\x03\xc7<M\xb5a\xceX\xa3Y&\x8b{oE\xd7\x9d\x8c\x98\x02\xc0'
@@ -2693,15 +2710,19 @@ class DecryptionTests(unittest.TestCase):
         b'roUT\x05\x00\x03\xd6\x8b\x92GUx\x00\x00PK\x05\x06\x00\x00\x00\x00\x01'
         b'\x00\x01\x00?\x00\x00\x00[\x00\x00\x00\x00\x00' )
 
+
+class DecryptionTests(EncryptedFiles, unittest.TestCase):
+    """Check that ZIP decryption works."""
+
     plain = b'zipfile.py encryption test'
     plain2 = b'\x00'*512
 
     def setUp(self):
         with open(TESTFN, "wb") as fp:
-            fp.write(self.data)
+            fp.write(self.encrypted_zip1_data)
         self.zip = zipfile.ZipFile(TESTFN, "r")
         with open(TESTFN2, "wb") as fp:
-            fp.write(self.data2)
+            fp.write(self.encrypted_zip2_data)
         self.zip2 = zipfile.ZipFile(TESTFN2, "r")
 
     def tearDown(self):
@@ -2786,6 +2807,180 @@ def test_seek_tell(self):
             fp.read()
 
 
+class AbstractCopyFileTests(EncryptedFiles):
+    @classmethod
+    def write_small_file(cls, destination):
+        destination.writestr(cls.small_file, cls.small_data,
+                             compress_type=cls.compression)
+
+    @classmethod
+    def write_large_file(cls, destination):
+        destination.writestr(cls.large_file, cls.large_data,
+                             compress_type=cls.compression)
+
+    @classmethod
+    def setUpClass(cls):
+        cls.small_zip = TESTFN + "_small.zip"
+        cls.large_zip = TESTFN + "_large.zip"
+        cls.small_large_zip = TESTFN + "_small_large.zip"
+        cls.emtpy_dir_zip = TESTFN + "_empty_dir.zip"
+        cls.encrypted_zip = TESTFN + "_encrypted.zip"
+
+        # compressed size is larger than the source contents
+        cls.small_data = "a"
+        # compressed size is smaller than the source contents
+        cls.large_data = "b" * 400
+
+        cls.small_file = "small.txt"
+        cls.large_file = "large.txt"
+        cls.emtpy_dir_name = "directory/"
+
+        # create zipfiles to compare against
+        # these zipfiles should never be written to outside of this method
+        with zipfile.ZipFile(cls.small_zip, "w") as destination:
+            cls.write_small_file(destination)
+
+        with zipfile.ZipFile(cls.large_zip, "w") as destination:
+            cls.write_large_file(destination)
+
+        with zipfile.ZipFile(cls.small_large_zip, "w") as destination:
+            cls.write_small_file(destination)
+            cls.write_large_file(destination)
+
+        with zipfile.ZipFile(cls.emtpy_dir_zip, "w") as destination:
+            # use mode other than default to check that mode is copied
+            destination.mkdir(cls.emtpy_dir_name, mode=123)
+
+        with open(cls.encrypted_zip, "wb") as destination:
+            destination.write(cls.encrypted_zip1_data)
+
+    def tearDown(cls):
+        if os.path.exists(TESTFN):
+            unlink(TESTFN)
+
+    @classmethod
+    def tearDownClass(cls):
+        unlink(cls.small_zip)
+        unlink(cls.large_zip)
+        unlink(cls.small_large_zip)
+        unlink(cls.emtpy_dir_zip)
+        unlink(cls.encrypted_zip)
+
+    def assertIdentical(self, file1, file2):
+        self.assertTrue(filecmp.cmp(file1, file2, shallow=False))
+
+    def _test_copy_files(self, source_zipfile, filenames=None):
+        with zipfile.ZipFile(TESTFN, 'w') as destination:
+            destination.copy_files(source_zipfile, filenames)
+        self.assertIdentical(TESTFN, source_zipfile)
+
+    # A compressed file can be larger than its uncompressed form,
+    # which are two different states we need to test
+
+    # Copying tests with one small file
+    def test_copy_one_small_file_via_iterable(self):
+        self._test_copy_files(self.small_zip, [self.small_file])
+
+    def test_copy_one_small_file_via_whole_zipfile(self):
+        self._test_copy_files(self.small_zip)
+
+    # Copying tests with one large file
+    def test_copy_one_large_file_via_iterable(self):
+        self._test_copy_files(self.large_zip, [self.large_file])
+
+    def test_copy_one_large_file_via_whole_zipfile(self):
+        self._test_copy_files(self.large_zip)
+
+    # Copying tests with empty directory
+    def test_copy_directory_via_iterable(self):
+        self._test_copy_files(self.emtpy_dir_zip, [self.emtpy_dir_name])
+
+    def test_copy_directory_via_whole_zipfile(self):
+        self._test_copy_files(self.emtpy_dir_zip)
+
+    # Copying tests with encrypted file
+    def test_copy_encrypted_file_via_iterable(self):
+        self._test_copy_files(self.encrypted_zip, [self.zip1_filename])
+
+    def test_copy_encrypted_file_via_whole_zipfile(self):
+        self._test_copy_files(self.encrypted_zip)
+
+    # Copying tests with nonempty destination zipfile
+    def _test_nonempty_zipfile(self, source_zipfile, filenames=None):
+        with zipfile.ZipFile(TESTFN, 'w') as destination:
+            self.write_small_file(destination)
+            destination.copy_files(source_zipfile, filenames)
+        self.assertIdentical(TESTFN, self.small_large_zip)
+
+    def test_copy_to_nonempty_zipfile_via_iterable(self):
+        self._test_nonempty_zipfile(self.large_zip, [self.large_file])
+
+    def test_copy_to_nonempty_zipfile_via_whole_zipfile(self):
+        self._test_nonempty_zipfile(self.large_zip)
+
+    # Copying tests with two files
+    def test_copy_two_files_via_iterable(self):
+        self._test_copy_files(self.small_large_zip,
+                              [self.small_file, self.large_file])
+
+    def test_copy_two_files_via_whole_zipfile(self):
+        self._test_copy_files(self.small_large_zip)
+
+class StoredCopyFileTests(AbstractCopyFileTests, unittest.TestCase):
+    compression = zipfile.ZIP_STORED
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.exceptions_zip = TESTFN + "_exception"
+
+        with zipfile.ZipFile(cls.exceptions_zip,
+                             "w") as destination:
+            cls.write_small_file(destination)
+
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        unlink(cls.exceptions_zip)
+
+    def copy_via_iterable(self, destination):
+        destination.copy_files(self.small_zip, [self.small_file])
+
+    def copy_entire_zipfile(self, destination):
+        destination.copy_files(self.small_zip)
+
+    def test_copy_methods_issue_exception_when_zipfile_not_open_for_write(self):
+        with zipfile.ZipFile(self.exceptions_zip, 'r') as destination:
+            self.assertRaises(ValueError, self.copy_via_iterable, destination)
+            self.assertRaises(ValueError, self.copy_entire_zipfile, destination)
+
+    def test_copy_file__issues_exception_when_already_writing(self):
+        with zipfile.ZipFile(self.exceptions_zip, 'w') as destination:
+            with destination.open('foo', mode='w') as open_file:
+                self.assertRaises(ValueError, self.copy_via_iterable,
+                                  destination)
+                self.assertRaises(ValueError, self.copy_entire_zipfile,
+                                  destination)
+
+    def test_copy_file__issues_exception_when_file_closed(self):
+        destination = zipfile.ZipFile(self.exceptions_zip, 'w')
+        destination.close()
+        self.assertRaises(ValueError, self.copy_via_iterable, destination)
+        self.assertRaises(ValueError, self.copy_entire_zipfile, destination)
+
+@requires_zlib()
+class DeflateCopyFileTests(AbstractCopyFileTests, unittest.TestCase):
+    compression = zipfile.ZIP_DEFLATED
+
+@requires_bz2()
+class Bzip2CopyFileTests(AbstractCopyFileTests, unittest.TestCase):
+    compression = zipfile.ZIP_BZIP2
+
+@requires_lzma()
+class LzmaCopyFileTests(AbstractCopyFileTests, unittest.TestCase):
+    compression = zipfile.ZIP_LZMA
+
+
 class AbstractTestsWithRandomBinaryFiles:
     @classmethod
     def setUpClass(cls):
diff --git a/Lib/zipfile/__init__.py b/Lib/zipfile/__init__.py
index b7840d0f945a66..cf0893ef0bbaeb 100644
--- a/Lib/zipfile/__init__.py
+++ b/Lib/zipfile/__init__.py
@@ -901,16 +901,28 @@ class ZipExtFile(io.BufferedIOBase):
     MAX_SEEK_READ = 1 << 24
 
     def __init__(self, fileobj, mode, zipinfo, pwd=None,
-                 close_fileobj=False):
+                 close_fileobj=False, decompress=True):
         self._fileobj = fileobj
         self._pwd = pwd
         self._close_fileobj = close_fileobj
 
-        self._compress_type = zipinfo.compress_type
+        if decompress:
+            self._compress_type = zipinfo.compress_type
+        else:
+            # if we aren't decompressing the data,
+            # we pretend that the data wasn't compressed
+            # so that we don't process the data
+            self._compress_type = ZIP_STORED
         self._compress_left = zipinfo.compress_size
-        self._left = zipinfo.file_size
+        if decompress:
+            self._left = zipinfo.file_size
+        else:
+            self._left = zipinfo.compress_size
 
-        self._decompressor = _get_decompressor(self._compress_type)
+        if decompress:
+            self._decompressor = _get_decompressor(self._compress_type)
+        else:
+            self._decompressor = None
 
         self._eof = False
         self._readbuffer = b''
@@ -921,7 +933,7 @@ def __init__(self, fileobj, mode, zipinfo, pwd=None,
         self.mode = mode
         self.name = zipinfo.filename
 
-        if hasattr(zipinfo, 'CRC'):
+        if hasattr(zipinfo, 'CRC') and decompress:
             self._expected_crc = zipinfo.CRC
             self._running_crc = crc32(b'')
         else:
@@ -1232,15 +1244,24 @@ def tell(self):
 
 
 class _ZipWriteFile(io.BufferedIOBase):
-    def __init__(self, zf, zinfo, zip64):
+    def __init__(self, zf, zinfo, zip64, *, precompressed=False):
         self._zinfo = zinfo
         self._zip64 = zip64
         self._zipfile = zf
-        self._compressor = _get_compressor(zinfo.compress_type,
-                                           zinfo.compress_level)
-        self._file_size = 0
+        if precompressed:
+            self._compute_crc = False  # Precomputed in zinfo.
+            self._crc = zinfo.CRC
+            self._compute_file_size = False  # Precomputed in zinfo.
+            self._file_size = zinfo.file_size
+            self._compressor = None
+        else:
+            self._compute_crc = True
+            self._crc = 0
+            self._compute_file_size = True
+            self._file_size = 0
+            self._compressor = _get_compressor(zinfo.compress_type,
+                                               zinfo._compresslevel)
         self._compress_size = 0
-        self._crc = 0
 
     @property
     def _fileobj(self):
@@ -1267,12 +1288,14 @@ def write(self, data):
         else:
             data = memoryview(data)
             nbytes = data.nbytes
-        self._file_size += nbytes
+        if self._compute_file_size:
+            self._file_size += nbytes
 
-        self._crc = crc32(data, self._crc)
+        if self._compute_crc:
+            self._crc = crc32(data, self._crc)
         if self._compressor:
             data = self._compressor.compress(data)
-            self._compress_size += len(data)
+        self._compress_size += len(data)
         self._fileobj.write(data)
         return nbytes
 
@@ -1286,11 +1309,11 @@ def close(self):
                 buf = self._compressor.flush()
                 self._compress_size += len(buf)
                 self._fileobj.write(buf)
-                self._zinfo.compress_size = self._compress_size
-            else:
-                self._zinfo.compress_size = self._file_size
-            self._zinfo.CRC = self._crc
-            self._zinfo.file_size = self._file_size
+            self._zinfo.compress_size = self._compress_size
+            if self._compute_crc:
+                self._zinfo.CRC = self._crc
+            if self._compute_file_size:
+                self._zinfo.file_size = self._file_size
 
             if not self._zip64:
                 if self._file_size > ZIP64_LIMIT:
@@ -1322,7 +1345,6 @@ def close(self):
             self._zipfile._writing = False
 
 
-
 class ZipFile:
     """ Class with methods to open, read, write, close, list zip files.
 
@@ -1663,21 +1685,43 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
             raise ValueError(
                 "Attempt to use ZIP archive that was already closed")
 
-        # Make sure we have an info object
+        if mode == 'w':
+            return self._open_to_write(name, force_zip64=force_zip64)
+        if mode == "r":
+            return self._open_to_read(name, pwd)
+
+    def _raise_if_cannot_write(self, force_zip64):
+        if not self.fp:
+            raise ValueError(
+                "Attempt to use ZIP archive that was already closed")
+        if force_zip64 and not self._allowZip64:
+            raise ValueError(
+                "force_zip64 is True, but allowZip64 was False when opening "
+                "the ZIP file."
+            )
+        if self._writing:
+            raise ValueError("Can't write to the ZIP file while there is "
+                             "another write handle open on it. "
+                             "Close the first handle before opening another.")
+
+    def _setup_for_writing(self, zinfo, is_zip64):
+        if self._seekable:
+            self.fp.seek(self.start_dir)
+        zinfo.header_offset = self.fp.tell()
+
+        self._writecheck(zinfo)
+        self._didModify = True
+
+        self.fp.write(zinfo.FileHeader(is_zip64))
+
+        self._writing = True
+
+    def _open_to_read(self, name, pwd=None, *, decompress=True):
         if isinstance(name, ZipInfo):
-            # 'name' is already an info object
             zinfo = name
-        elif mode == 'w':
-            zinfo = ZipInfo(name)
-            zinfo.compress_type = self.compression
-            zinfo.compress_level = self.compresslevel
         else:
-            # Get info object for name
             zinfo = self.getinfo(name)
 
-        if mode == 'w':
-            return self._open_to_write(zinfo, force_zip64=force_zip64)
-
         if self._writing:
             raise ValueError("Can't read from the ZIP file while there "
                     "is an open writing handle on it. "
@@ -1734,7 +1778,7 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
 
             # check for encrypted flag & handle password
             is_encrypted = zinfo.flag_bits & _MASK_ENCRYPTED
-            if is_encrypted:
+            if is_encrypted and decompress:
                 if not pwd:
                     pwd = self.pwd
                 if pwd and not isinstance(pwd, bytes):
@@ -1745,21 +1789,30 @@ def open(self, name, mode="r", pwd=None, *, force_zip64=False):
             else:
                 pwd = None
 
-            return ZipExtFile(zef_file, mode + 'b', zinfo, pwd, True)
+            return ZipExtFile(zef_file, 'rb', zinfo, pwd, True, decompress)
         except:
             zef_file.close()
             raise
 
-    def _open_to_write(self, zinfo, force_zip64=False):
-        if force_zip64 and not self._allowZip64:
-            raise ValueError(
-                "force_zip64 is True, but allowZip64 was False when opening "
-                "the ZIP file."
-            )
-        if self._writing:
-            raise ValueError("Can't write to the ZIP file while there is "
-                             "another write handle open on it. "
-                             "Close the first handle before opening another.")
+    def _open_to_write_precompressed(self, zinfo, force_zip64=False):
+        self._raise_if_cannot_write(force_zip64)
+
+        zip64 = force_zip64 or (zinfo.compress_size > ZIP64_LIMIT)
+        if not self._allowZip64 and zip64:
+            raise LargeZipFile("Filesize would require ZIP64 extensions")
+
+        self._setup_for_writing(zinfo, zip64)
+        return _ZipWriteFile(self, zinfo, zip64, precompressed=True)
+
+    def _open_to_write(self, name, force_zip64=False):
+        self._raise_if_cannot_write(force_zip64)
+
+        if isinstance(name, ZipInfo):
+            zinfo = name
+        else:
+            zinfo = ZipInfo(name)
+            zinfo.compress_type = self.compression
+            zinfo._compresslevel = self.compresslevel
 
         # Size and CRC are overwritten with correct data after processing the file
         zinfo.compress_size = 0
@@ -1780,16 +1833,7 @@ def _open_to_write(self, zinfo, force_zip64=False):
         if not self._allowZip64 and zip64:
             raise LargeZipFile("Filesize would require ZIP64 extensions")
 
-        if self._seekable:
-            self.fp.seek(self.start_dir)
-        zinfo.header_offset = self.fp.tell()
-
-        self._writecheck(zinfo)
-        self._didModify = True
-
-        self.fp.write(zinfo.FileHeader(zip64))
-
-        self._writing = True
+        self._setup_for_writing(zinfo, zip64)
         return _ZipWriteFile(self, zinfo, zip64)
 
     def extract(self, member, path=None, pwd=None):
@@ -1911,6 +1955,25 @@ def _writecheck(self, zinfo):
                 raise LargeZipFile(requires_zip64 +
                                    " would require ZIP64 extensions")
 
+    def _raise_if_archive_not_available_for_writing(self):
+        if not self.fp:
+            raise ValueError(
+                "Attempt to write to ZIP archive that was already closed")
+        if self._writing:
+            raise ValueError(
+                "Can't write to ZIP archive while an open writing handle exists"
+            )
+
+    def _write_precompressed(self, zinfo, file_contents):
+        self._raise_if_archive_not_available_for_writing()
+
+        if zinfo.is_dir():
+            self.mkdir(zinfo)
+            return
+
+        with self._open_to_write_precompressed(zinfo) as destination:
+            shutil.copyfileobj(file_contents, destination, 1024*8)
+
     def write(self, filename, arcname=None,
               compress_type=None, compresslevel=None):
         """Put the bytes from filename into the archive under the name
@@ -2012,6 +2075,37 @@ def mkdir(self, zinfo_or_directory_name, mode=511):
             self.fp.write(zinfo.FileHeader(False))
             self.start_dir = self.fp.tell()
 
+    def _copy_file(self, source_zipfile, source_zinfo):
+        with source_zipfile._open_to_read(source_zinfo, 'r',
+                decompress=False) as source_file_contents:
+            self._write_precompressed(source_zinfo, source_file_contents)
+
+    def copy_files(self, source_zipfile, files=None):
+        """
+        copy files from the source_zipfile to the ZIP archive. This method
+        copies the files as is, avoiding the overhead of decompressing and
+        compressing the data again.
+
+        source_zipfile is a string of the path of the ZIP archive to copy from.
+
+        files is an iterable of strings, where each string is a file name found
+        within the source_zipfile. If files=None, all files from source_zipfile
+        are copied.
+        """
+        if self.mode not in ('w', 'x', 'a'):
+            raise ValueError(
+                "copy_files() requires mode 'w', 'x', or 'a', but "
+                f"mode is '{self.mode}'")
+
+        with ZipFile(source_zipfile, 'r') as source:
+            if files is None:
+                zinfos = source.infolist()
+            else:
+                zinfos = [source.getinfo(file) for file in files]
+
+            for zinfo in zinfos:
+                self._copy_file(source, zinfo)
+
     def __del__(self):
         """Call the "close()" method in case the user forgot."""
         self.close()
diff --git a/Misc/NEWS.d/next/Library/2024-10-21-00-08-11.gh-issue-113924.IuVDzq.rst b/Misc/NEWS.d/next/Library/2024-10-21-00-08-11.gh-issue-113924.IuVDzq.rst
new file mode 100644
index 00000000000000..0b657c30c53e75
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2024-10-21-00-08-11.gh-issue-113924.IuVDzq.rst
@@ -0,0 +1 @@
+Added `zipfile.ZipFile.copy_files` to  allow copying from a zipfile.