Issue #25523: Further a-to-an corrections new in 3.5

Doc/library/argparse.rst

@@ -530,7 +530,7 @@ allow_abbrev
 ^^^^^^^^^^^^
 
 Normally, when you pass an argument list to the
-:meth:`~ArgumentParser.parse_args` method of a :class:`ArgumentParser`,
+:meth:`~ArgumentParser.parse_args` method of an :class:`ArgumentParser`,
 it :ref:`recognizes abbreviations <prefix-matching>` of long options.
 
 This feature can be disabled by setting ``allow_abbrev`` to ``False``::

Doc/reference/datamodel.rst

@@ -2358,7 +2358,7 @@ An *asynchronous iterable* is able to call asynchronous code in its
 ``__aiter__`` implementation, and an *asynchronous iterator* can call
 asynchronous code in its ``__anext__`` method.
 
-Asynchronous iterators can be used in a :keyword:`async for` statement.
+Asynchronous iterators can be used in an :keyword:`async for` statement.
 
 .. method:: object.__aiter__(self)
 
@@ -2393,7 +2393,7 @@ Asynchronous Context Managers
 An *asynchronous context manager* is a *context manager* that is able to
 suspend execution in its ``__aenter__`` and ``__aexit__`` methods.
 
-Asynchronous context managers can be used in a :keyword:`async with` statement.
+Asynchronous context managers can be used in an :keyword:`async with` statement.
 
 .. method:: object.__aenter__(self)
 

Doc/whatsnew/3.5.rst

@@ -465,7 +465,7 @@ not make an additional system call::
 PEP 475: Retry system calls failing with EINTR
 ----------------------------------------------
 
-A :py:data:`errno.EINTR` error code is returned whenever a system call, that
+An :py:data:`errno.EINTR` error code is returned whenever a system call, that
 is waiting for I/O, is interrupted by a signal.  Previously, Python would
 raise :exc:`InterruptedError` in such case.  This meant that, when writing a
 Python application, the developer had two choices:

Lib/concurrent/futures/process.py

@@ -456,7 +456,7 @@ class ProcessPoolExecutor(_base.Executor):
     submit.__doc__ = _base.Executor.submit.__doc__
 
     def map(self, fn, *iterables, timeout=None, chunksize=1):
-        """Returns a iterator equivalent to map(fn, iter).
+        """Returns an iterator equivalent to map(fn, iter).
 
         Args:
             fn: A callable that will take as many arguments as there are

Lib/signal.py

@@ -34,7 +34,7 @@ def _int_to_enum(value, enum_klass):
 
 def _enum_to_int(value):
     """Convert an IntEnum member to a numeric value.
-    If it's not a IntEnum member return the value itself.
+    If it's not an IntEnum member return the value itself.
     """
     try:
         return int(value)

Lib/unittest/test/test_discovery.py

@@ -255,12 +255,12 @@ class TestDiscovery(unittest.TestCase):
         self.addCleanup(sys.path.remove, abspath('/foo'))
 
         # Test data: we expect the following:
-        # a listdir to find our package, and a isfile and isdir check on it.
+        # a listdir to find our package, and isfile and isdir checks on it.
         # a module-from-name call to turn that into a module
         # followed by load_tests.
         # then our load_tests will call discover() which is messy
         # but that finally chains into find_tests again for the child dir -
-        # which is why we don't have a infinite loop.
+        # which is why we don't have an infinite loop.
         # We expect to see:
         # the module load tests for both package and plain module called,
         # and the plain module result nested by the package module load_tests

Misc/NEWS

@@ -1990,7 +1990,7 @@ Library
 - Issue #23132: Improve performance and introspection support of comparison
   methods created by functool.total_ordering.
 
-- Issue #19776: Add a expanduser() method on Path objects.
+- Issue #19776: Add an expanduser() method on Path objects.
 
 - Issue #23112: Fix SimpleHTTPServer to correctly carry the query string and
   fragment when it redirects to add a trailing slash.

Modules/_collectionsmodule.c

@@ -629,7 +629,7 @@ volume rotations should take care not to penalize the common case.
 
 Conceptually, a rotate by one is equivalent to a pop on one side and an
 append on the other.  However, a pop/append pair is unnecessarily slow
-because it requires a incref/decref pair for an object located randomly
+because it requires an incref/decref pair for an object located randomly
 in memory.  It is better to just move the object pointer from one block
 to the next without changing the reference count.