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.

os

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.

os.environ

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]
...

os.name

It returns the name of the current system.

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

os.getcwd()

This function returns the current working directory.

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

os.curdir

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

>>> os.curdir
'.'

os.listdir()

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)

os.rename()

It renames a file.

basic syntax: os.rename(oldfile, newfile)

os.chmod()

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

basic syntax: os.chmod(file, mode)

os.system()

It opens an Operating System subshell and executes the command.

basic syntax: os.system(command)

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

os.popen()

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()

os.remove()

It deletes a file.

basic syntax: os.remove(file)

os.mkdir()

It creates a new directory.

basic syntax: os.mkdir(directory)

os.rmdir()

It removes an existing directory.

basic syntax: os.rmdir(directory)

os.removedirs()

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

basic syntax: os.removedirs(directory)

os.path

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.

os.path.exists()

It returns true if path really exists.

basic syntax: os.path.exists(path)

os.path.isfile()

It returns true if the specified path is a file.

basic syntax: os.path.isfile(path)

os.path.isdir()

It returns true if the specified path is a directory.

basic syntax: os.path.isdir(path)

os.path.split()

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)

dircache

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.

stat

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.

statcache

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

statvfs

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."
255

cmp

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

cmpcache

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.

time

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.

time.time()

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

basic syntax: time.time()

time.localtime()

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)

time.asctime()

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

basic syntax: time.asctime(tuple)

>>> import time
>>> time.time()
957044415.14
>>> 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'

time.sleep()

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

sched

The sched module implements a general-purpose event scheduler.

getpass

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!!
else:
  print r"You've just activated the detonation process.Sorry"

curses

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.

getopt

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).

tempfile

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

tempfile.mktemp()

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)

tempfile.TemporaryFile()

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()

errno

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
10062

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

glob

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
['c:\\FRUNLOG.TXT', 'c:\\DETLOG.TXT', 'c:\\BOOTLOG.TXT', 'c:\\SETUPLOG.TXT',
 'c:\\NETLOG.TXT', 'c:\\RESETLOG.TXT']

fnmatch

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.

fnmatch.fnmatch()

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")
1

fnmatch.translate()

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
.*\.txt$

shutil

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

shutil.copyfile()

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

basic syntax: shutil.copyfile(source, newcopy)

shutil.rmtree()

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)

locale

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.

mutex

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.