GNU Info

(python2.1-lib.info)os.path

---

Next: dircache Prev: os Up: Generic Operating System Services

---

Enter node , (file) or (file)node

Common pathname manipulations
=============================

Common pathname manipulations.

This module implements some useful functions on pathnames.

`abspath(path)'
     Return a normalized absolutized version of the pathname PATH.  On
     most platforms, this is equivalent to `normpath(join(os.getcwd(),
     PATH))'.  _Added in Python version 1.5.2_

`basename(path)'
     Return the base name of pathname PATH.  This is the second half of
     the pair returned by `split(PATH)'.  Note that the result of this
     function is different from the UNIX `basename' program; where
     `basename' for `'/foo/bar/'' returns `'bar'', the `basename()'
     function returns an empty string (`''').

`commonprefix(list)'
     Return the longest path prefix (taken character-by-character) that
     is a prefix of all paths in LIST.  If LIST is empty, return the
     empty string (`''').  Note that this may return invalid paths
     because it works a character at a time.

`dirname(path)'
     Return the directory name of pathname PATH.  This is the first
     half of the pair returned by `split(PATH)'.

`exists(path)'
     Return true if PATH refers to an existing path.

`expanduser(path)'
     Return the argument with an initial component of `~' or `~USER'
     replaced by that USER's home directory.  An initial `~{}' is
     replaced by the environment variable `HOME'; an initial `~USER' is
     looked up in the password directory through the built-in module
     `pwd' .  If the expansion fails, or if the path does not begin
     with a tilde, the path is returned unchanged.  On the Macintosh,
     this always returns PATH unchanged.

`expandvars(path)'
     Return the argument with environment variables expanded.
     Substrings of the form `$NAME' or `${NAME}' are replaced by the
     value of environment variable NAME.  Malformed variable names and
     references to non-existing variables are left unchanged.  On the
     Macintosh, this always returns PATH unchanged.

`getatime(path)'
     Return the time of last access of FILENAME.  The return value is
     integer giving the number of seconds since the epoch (see the
     `time' module).  Raise `os.error' if the file does not exist or is
     inaccessible.  _Added in Python version 1.5.2_

`getmtime(path)'
     Return the time of last modification of FILENAME.  The return
     value is integer giving the number of seconds since the epoch (see
     the `time' module).  Raise `os.error' if the file does not exist
     or is inaccessible.  _Added in Python version 1.5.2_

`getsize(path)'
     Return the size, in bytes, of FILENAME.  Raise `os.error' if the
     file does not exist or is inaccessible.  _Added in Python version
     1.5.2_

`isabs(path)'
     Return true if PATH is an absolute pathname (begins with a slash).

`isfile(path)'
     Return true if PATH is an existing regular file.  This follows
     symbolic links, so both `islink()' and `isfile()' can be true for
     the same path.

`isdir(path)'
     Return true if PATH is an existing directory.  This follows
     symbolic links, so both `islink()' and `isdir()' can be true for
     the same path.

`islink(path)'
     Return true if PATH refers to a directory entry that is a symbolic
     link.  Always false if symbolic links are not supported.

`ismount(path)'
     Return true if pathname PATH is a "mount point": a point in a file
     system where a different file system has been mounted.  The
     function checks whether PATH's parent, `PATH/..', is on a
     different device than PATH, or whether `PATH/..' and PATH point to
     the same i-node on the same device -- this should detect mount
     points for all UNIX and POSIX variants.

`join(path1[, path2[, ...]])'
     Joins one or more path components intelligently.  If any component
     is an absolute path, all previous components are thrown away, and
     joining continues.  The return value is the concatenation of
     PATH1, and optionally PATH2, etc., with exactly one slash (`'/'')
     inserted between components, unless PATH is empty.

`normcase(path)'
     Normalize the case of a pathname.  On UNIX, this returns the path
     unchanged; on case-insensitive filesystems, it converts the path to
     lowercase.  On Windows, it also converts forward slashes to
     backward slashes.

`normpath(path)'
     Normalize a pathname.  This collapses redundant separators and
     up-level references, e.g. `A//B', `A/./B' and `A/foo/../B' all
     become `A/B'.  It does not normalize the case (use `normcase()'
     for that).  On Windows, it converts forward slashes to backward
     slashes.

`samefile(path1, path2)'
     Return true if both pathname arguments refer to the same file or
     directory (as indicated by device number and i-node number).
     Raise an exception if a `os.stat()' call on either pathname fails.
     Availability:  Macintosh, UNIX.

`sameopenfile(fp1, fp2)'
     Return true if the file objects FP1 and FP2 refer to the same
     file.  The two file objects may represent different file
     descriptors.  Availability:  Macintosh, UNIX.

`samestat(stat1, stat2)'
     Return true if the stat tuples STAT1 and STAT2 refer to the same
     file.  These structures may have been returned by `fstat()',
     `lstat()', or `stat()'.  This function implements the underlying
     comparison used by `samefile()' and `sameopenfile()'.
     Availability:  Macintosh, UNIX.

`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 nearly all cases, `join(HEAD, TAIL)'
     equals PATH (the only exception being when there were multiple
     slashes separating HEAD from TAIL).

`splitdrive(path)'
     Split the pathname PATH into a pair `(DRIVE, TAIL)' where DRIVE is
     either a drive specification or the empty string.  On systems
     which do not use drive specifications, DRIVE will always be the
     empty string.  In all cases, `DRIVE + TAIL' will be the same as
     PATH.  _Added in Python version 1.3_

`splitext(path)'
     Split the pathname PATH into a pair `(ROOT, EXT)' such that `ROOT
     + EXT == PATH', and EXT is empty or begins with a period and
     contains at most one period.

`walk(path, visit, arg)'
     Calls the function VISIT with arguments `(ARG, DIRNAME, NAMES)'
     for each directory in the directory tree rooted at PATH (including
     PATH itself, if it is a directory).  The argument DIRNAME
     specifies the visited directory, the argument NAMES lists the
     files in the directory (gotten from `os.listdir(DIRNAME)').  The
     VISIT function may modify NAMES to influence the set of
     directories visited below DIRNAME, e.g., to avoid visiting certain
     parts of the tree.  (The object referred to by NAMES must be
     modified in place, using `del' or slice assignment.)