Home > Articles > Programming > Python

Python Libraries

  • Print
  • + Share This

Generic Operational System

This group of services provides interfaces to operating system features that you can use in almost every platform. Most of Python's operating system modules are based on the Posix interface.


The os module is a portable OS API that searches for Operating-System–dependent built-in modules (mac, posix, nt), and exports their functionality using the same interface. Certain tools are available only on platforms that support them. However, it is highly recommended that you use this module instead of the platform-specific modules, which are really an implementation detail of os. By using the os module, you make your program more portable.


This is a dictionary that contains all the environment variables.

You can search for a specific variable:

>>> import os
>>> path = os.environ["PATH"] #USER, EDITOR, etc...

or list all of them:

>>> for key in os.environ.keys():
...  print key, " = " , os.environ[key]


It returns the name of the current system.

>>> name = os.name  # "posix","dos","mac","nt"


This function returns the current working directory.

>>> os.getcwd()
'C:\\Program Files\\Python'


This is a simple constant that returns the OS-specific string used to identify the current directory.

>>> os.curdir


If directory is omitted, it lists the filenames of the current directory. Otherwise, it lists the filenames of directory.

basic syntax: os.listdir([directory])

>>> files = os.listdir(os.curdir)


It renames a file.

basic syntax: os.rename(oldfile, newfile)


It changes the file mode. This is a UNIX command.

basic syntax: os.chmod(file, mode)


It opens an Operating System subshell and executes the command.

basic syntax: os.system(command)

>>> os.system("rm -rf " + filename)


This is a UNIX function that returns a file-like object. It allows you to execute a shell command and read the standard output of external pipes (by setting mode to r) or write to their standard input (by setting mode to w). The default mode is r. Note that even though popen is a UNIX function, it is also implemented on the other Python ports.

basic syntax: os.popen(shell command, mode)

>>> file = os.popen('sed \'s/yes/no/g' > output','w')
>>> file.write("yes\n")
>>> file = os.popen('cat manual.txt', 'r')
>>> f = file.read()


It deletes a file.

basic syntax: os.remove(file)


It creates a new directory.

basic syntax: os.mkdir(directory)


It removes an existing directory.

basic syntax: os.rmdir(directory)


It is a wrapper for rmdir that deletes everything under the directory.

basic syntax: os.removedirs(directory)


The os.path is a module imported by the os module that exposes useful common functions to manipulate pathnames. Remember that you don't have to explicitly import os.path. You get it for free when you import os.


It returns true if path really exists.

basic syntax: os.path.exists(path)


It returns true if the specified path is a file.

basic syntax: os.path.isfile(path)


It returns true if the specified path is a directory.

basic syntax: os.path.isdir(path)


It splits filename, returning a tuple that contains the directory structure and filename, which together combine the original filename argument.

basic syntax: os.path.split(filename)


The dircache module reads directory listings using a cache. Note that this module will be replaced by the new module filecmp in Python 1.6.


The stat module works along with the os module by interpreting information about existing files that is extracted by the os.stat() function and stored on a tuple structure. This tuple contains the file size, the file owner group, the file owner name, the last accessed and last modified dates, and its mode.


The statcache module is a simple optimization of the os.stat() function.


The statvfs module stores constants that are used to interpret the results of a call to the os.statvfs() function. By the way, the os.statvfs provides information about your file system.

>>> import statvfs, os
>>> stat = os.statvfs(".")
>>> maxfnl = stat[statvfs.F_NAMEMAX]
>>> print "%d is the maximum file name length" % maxfnl
>>> print "that is allowed on your file system."


The cmp module is used to compare files. Note that this module will be replaced by the new module filecmp in Python 1.6.


The cmpcache module is a more efficient version of the cmp module for file comparisons. Note that this module will be replaced by the new module filecmp in Python 1.6.


The time module exposes functions for time access and conversion. It is important to remember that there are no Year 2000 issues in the Python language.


It returns the current timestamp in seconds since the UNIX epoch began (start of 1970, UTC - Universal Time Coordinated).

basic syntax: time.time()


It converts a time expressed in seconds into a time tuple. This tuple has the following format: (4digitsyear, month, day, hour, minute, second, day of week, day of year, daylight savings flag).

basic syntax: time.locatime(seconds)


It converts a time tuple into a 24-character string.

basic syntax: time.asctime(tuple)

>>> import time
>>> time.time()
>>> time.localtime(time.time())
(2000, 4, 29, 17, 42, 14, 5, 120, 1)
>>> time.asctime(time.localtime(time.time()))
'Sat Apr 29 17:42:59 2000'


It suspends the execution of a program for a specific number of seconds.

basic syntax: time.sleep(seconds)

>>> import time
>>> time.sleep(10)  # waits for 10 seconds


The sched module implements a general-purpose event scheduler.


The getpass module implements a portable function that enables the user to type a password without echoing the entry in the screen.

basic syntax: getpass.getpass([prompt])

This module also provides a function to collect information about the user's login.

basic syntax: getpass.getuser()

import getpass
defaultpwd = "Ahhhhh"
user = getpass.getuser()
print "Hello %s," % user
pass = getpass.getpass("Please, type the password. ")
if pass == defaultpwd:
  print "Welcome back to the system!!
  print r"You've just activated the detonation process.Sorry"


The curses module is a terminal independent I/O interface to the curses UNIX library.

For more details, check out the curses HOWTO at http://py-howto.sourceforge.net/curses/curses.html.


The getopt module is a parser for command-line options and arguments (sys.argv). This module provides the standard C getopt functionality.

1: >>> import getopt
2: >>> args = ['-h','-r','origin.txt','—file','work.txt','755','777']
3: >>> opts, pargs = getopt.getopt(args, 'hr:', ['file='])
4: >>> opts
5: [('-h', ''), ('-r','origin.txt') , ('—file','work.txt')]
6: >>> pargs
7: ['755','777']

Before transporting arguments to this function, line 2 shows you that single options must be preceded by a single hyphen and long options must be preceded by double hyphens.

In line 3, note that single options that require an argument must end with a colon. On the other hand, long options that require an argument must end with an equal sign.

The getopt.getopt() returns two values: A tuple that contains pairs of (option, argument) values (line 5), and a list of standalone arguments that aren't associated with any options (line 7).


The tempfile module generates unique temporary filenames based on templates defined by the variables tempfile.tempdir and tempfile.template.


This function returns a temporary filename. It doesn't physically create or remove files.

basic syntax: filename = tempfile.mktemp()

>>> import tempfile, os
>>> temp = tempfile.mktemp()
>>> open(temp, 'w')
>>> os.close(file)
>>> os.remove(file)


This function returns a file object that is saved in your temporary local folder (/tmp or c:/temp, for example). The system removes this file after it gets closed.

basic syntax: fileobject = tempfile.TemporaryFile()


The errno module makes available the standard errno system symbols, such as EACCES, EADDRINUSE, and EDEADLOCK.

Each symbol is associated to a constant error code value.

>>> import errno
>>> errno.ELOOP

More information about this module and its symbols is provided in Chapter 4.


The glob module finds and returns pathnames matching a specific pattern, just like the UNIX shell does.

basic syntax: glob.glob(pattern)

>>> import glob
>>> lst = glob.glob("c:\\*.txt")
>>> print lst


The fnmatch module uses wildcards to provide support for UNIX shell-style filename pattern matching. These wildcards are different from those normally used by the re module.


This function returns 1 (true) if the provided filename matches the pattern defined.

basic syntax: fnmatch.fnmatch(filename, pattern)

>>> import fnmatch
>>> fnmatch.fnmatch("foo.gif", "*.gif")


This function converts a fnmatch-style pattern into a regular expression.

basic syntax: variable = fnmatch.translate(pattern)

>>> import fnmatch
>>> regexpr = fnmatch.translate("*.txt")
>>> print regexpr


The shutil module provides high-level file operations. Essentially, it offers many file-copying functions and one directory removal function.


It makes a straight binary copy of the source file, calling it newcopy.

basic syntax: shutil.copyfile(source, newcopy)


It deletes the path directory, including all of its subdirectories, recursively. If ignore_errors is set to 0, errors are ignored. Otherwise, the onerror function argument is called to handle the error. If the clause onerror is set to None, an exception is raised when an error occurs.

basic syntax: shutil.rmtree(path, ignore_errors=0, onerror=None)


The locale module provides access to the POSIX locale mechanism, enabling internationalization services. This module defines a set of parameters that describe the representation of strings, time, numbers, and currency.

The good thing about using this module is that programmers don't have to worry about the specifics of each country where their applications are executed.


The mutex module defines a mutex class that allows mutual-exclusion support via acquiring and releasing locks.

  • + Share This
  • 🔖 Save To Your Account

Related Resources

There are currently no related titles. Please check back later.