Follow Techotopia on Twitter

On-line Guides
All Guides
eBook Store
iOS / Android
Linux for Beginners
Office Productivity
Linux Installation
Linux Security
Linux Utilities
Linux Virtualization
Linux Kernel
System/Network Admin
Scripting Languages
Development Tools
Web Development
GUI Toolkits/Desktop
Mail Systems
Eclipse Documentation

How To Guides
General System Admin
Linux Security
Linux Filesystems
Web Servers
Graphics & Desktop
PC Hardware
Problem Solutions
Privacy Policy




Property Files and Configuration (or.INI) Files: The ConfigParser Module

A property file, also known as a configuration (or .INI) file defines property or configuration values. It is usually just a collection of settings. The essential property-file format has a simple row-oriented format with only two values in each row. A configuration (or .INI) file organizes a simple list of properties into one or more named sections.

A property file uses a few punctuation rules to encode the data.

  • Lines begining with # or ; are ignored. In some dialects the comments are # and !.

  • Each property setting is delimited by an ordinary newline character. This is usually the standard \n. If you are exchanging files across platforms, you may need to open files for reading using the "rU" mode to get universal newline handling.

  • Each property is a simple name and a value. The name is a string characters that does not use a separator character of : or =. The value is everything after the punctuation mark, with leading and trailing spaces removed. In some dialects space is also a separator character.

Some property file dialects allow a value to continue on to the next line. In this case, a line that ends with \ (the cwo-character sequence \ \n) escapes the usual meaning of \n. Rather being the end of a line, \\n is just another whitespace character.

A property file is an extension to the basic tab-delimited file. It has just two columns per line, and some space-stripping is done. However, it doesn't have a consistent separator, so it is slightly more complex to parse.

The extra feature introduced in a configuration file is named sections.

  • A line beginning with [, ending with ], is the beginning of a section. The []'s surround the section name. All of the lines from here to the next section header are collected together.

Reading a Simple Property File. Here's an example of reading the simplest kind of property file. In this case, we'll turn the entire file into a dictionary. Python doesn't provide a module for doing this. The processing is a sequence string manipulations to parse the file.

propFile= file( r"C:\Java\jdk1.5.0_06\jre\lib\", "rU" )
propDict= dict()
for propLine in propFile:
    propDef= propLine.strip()
    if len(propDef) == 0:
    if propDef[0] in ( '!', '#' ):
    punctuation= [ propDef.find(c) for c in ':= ' ] + [ len(propDef) ]
    found= min( [ pos for pos in punctuation if pos != -1 ] )
    name= propDef[:found].rstrip()
    value= propDef[found:].lstrip(":= ").rstrip()
    propDict[name]= value
print propDict
print propDict['handlers']

The input line is subject to a number of processing steps.

  1. First the leading and trailing whitespace is removed. If the line is empty, nothing more needs to be done.

  2. If the line begins with ! or # (; in some dialects) it is ignored.

  3. We find the location of all relevant puncuation marks. In some dialects, space is not permitted. Note that we through the length of the line on the end to permit a single word to be a valid property name, with an implicit value of a zero-length string.

  4. By discarding punction positions of -1, we are only processing the positions of punctuation marks which actually occur in the string. The smallest of these positions is the left-most punctuation mark.

  5. The name is everything before the punctuation mark with whitespace remove.

  6. The value is everything after the punctuaion mark. Any additional separators are removed, and any trailing whitespace is also removed.

Reading a Config File. The ConfigParser module has a number of classes for processing configuration files. You initialize a ConfigParse object with default values. The object can the read one or more a configuration files. You can then use methods to determine what sections were present and what options were defined in a given section.

import ConfigParser
cp= ConfigParser.RawConfigParser( ) r"C:\Program Files\Mozilla Firefox\updater.ini" )
print cp.sections()
print cp.options('Strings')
print cp.get('Strings','info')

Eschewing Obfuscation. While a property file is rather simple, it is possible to simplify property files further. The essential property definition syntax is so close to Python's own syntax that some applications use a simple file of Python variable settings. In this case, the settings file would look like this.

Example 34.3.

# Some Properties
TITLE = "The Title String"
INFO = """The information string.
Which uses Python's ordinary techniques
for long lines."""

This file can be introduced in your program with one statement: import settings. This statement will create module-level variables, settings.TITLE and settings.INFO.

  Published under the terms of the Open Publication License Design by Interspire