Adjusted os.path.rst details

Author: arthurlw

Doc/library/os.path.rst

@@ -55,14 +55,12 @@ the :mod:`glob` module.)
 
 
 .. function:: abspath(path)
+
    Return a normalized absolutized version of the pathname *path*. On most
-   platforms, this is equivalent to calling the function :func:`normpath` as
-   follows: ``normpath(join(os.getcwd(), path))``.
-   
-   .. seealso:: 
-      :func:`join` - Used by abspath to combine paths
-      :func:`normpath` - Used by abspath to normalize paths
-   
+   platforms, this is equivalent to calling ``normpath(join(os.getcwd(), path))``.
+
+   .. seealso:: :func:`os.path.join` and :func:`os.path.normpath`.
+
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
 
@@ -241,16 +239,15 @@ the :mod:`glob` module.)
 
 
 .. function:: isabs(path)
+
    Return ``True`` if *path* is an absolute pathname.  On Unix, that means it
    begins with a slash, on Windows that it begins with two (back)slashes, or a
    drive letter, colon, and (back)slash together.
-   
-   .. seealso::
-      :func:`abspath` - Returns the absolute version of a path
-   
+
+   .. seealso:: :func:`abspath`
+
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object`.
-      
    .. versionchanged:: 3.13
       On Windows, returns ``False`` if the given path starts with exactly one
       (back)slash.
@@ -356,32 +353,36 @@ the :mod:`glob` module.)
 
 
 .. function:: join(path, *paths)
-    
+
    Join one or more path segments intelligently.  The return value is the
    concatenation of *path* and all members of *\*paths*, with exactly one
    directory separator following each non-empty part, except the last. That is,
    the result will only end in a separator if the last part is either empty or
-   ends in a separator. If a segment is an absolute path (which on Windows
-   requires both a drive and a root), then all previous segments are ignored and
-   joining continues from the absolute path segment.
-   
-   Examples::
-   
+   ends in a separator.
+
+   If a segment is an absolute path (which on Windows requires both a drive and
+   a root), then all previous segments are ignored and joining continues from the
+   absolute path segment. For instance::
+
       >>> os.path.join('/home/foo', 'bar')
       '/home/foo/bar'
       >>> os.path.join('/home/foo', '/home/bar')
       '/home/bar'
-   
-   The second example demonstrates how an absolute path argument ignores all
-   previous path segments.
-   
+
    On Windows, the drive is not reset when a rooted path segment (e.g.,
    ``r'\foo'``) is encountered. If a segment is on a different drive or is an
-   absolute path, all previous segments are ignored and the drive is reset. Note
-   that since there is a current directory for each drive,
+   absolute path, all previous segments are ignored and the drive is reset. For
+   instance::
+
+      >>> os.path.join('c:\\', 'foo')
+      'c:\\foo'
+      >>> os.path.join('c:\\foo', 'd:\\bar')
+      'd:\\bar'
+
+   Note that since there is a current directory for each drive,
    ``os.path.join("c:", "foo")`` represents a path relative to the current
    directory on drive :file:`C:` (:file:`c:foo`), not :file:`c:\\foo`.
-   
+
    .. versionchanged:: 3.6
       Accepts a :term:`path-like object` for *path* and *paths*.
 
@@ -501,24 +502,19 @@ the :mod:`glob` module.)
 
 
 .. function:: split(path)
-    
+
    Split the pathname *path* into a pair, ``(head, tail)`` where *tail* is the
    last pathname component and *head* is everything leading up to that.  The
    *tail* part will never contain a slash; if *path* ends in a slash, *tail*
    will be empty.  If there is no slash in *path*, *head* will be empty.  If
    *path* is empty, both *head* and *tail* are empty.  Trailing slashes are
    stripped from *head* unless it is the root (one or more slashes only).  In
    all cases, ``join(head, tail)`` returns a path to the same location as *path*
-   (but the strings may differ).  Also see the functions :func:`dirname` and
-   :func:`basename`.
-   
-   .. seealso::
-      :func:`join` - Can be used to reconstruct a path from split components
-      :func:`dirname` - Returns the directory name of a path
-      :func:`basename` - Returns the base name of a path
-   
+   (but the strings may differ).  Also see the functions :func:`join`,
+   :func:`dirname` and :func:`basename`.
+
    .. versionchanged:: 3.6
-      Accepts a :term:`path-like object`..
+      Accepts a :term:`path-like object`.
 
 
 .. function:: splitdrive(path)