Dive Into Python

The type function returns the datatype of any arbitrary object. The possible types are listed in the types module. This is useful for helper functions which can handle several types of data.

Example 2.6. Introducing type

>>> type(1)           
<type 'int'>
>>> li = []
>>> type(li)          
<type 'list'>
>>> import odbchelper
>>> type(odbchelper)  
<type 'module'>
>>> import types      
>>> type(odbchelper) == types.ModuleType
1

	type takes anything and returns its datatype. And I mean anything. Integers, strings, lists, dictionaries, tuples, functions, classes, modules, even types.
	type can take a variable and return its datatype.
	type also works on modules.
	You can use the constants in the types module to compare types of objects. This is what the help function does, as we’ll see shortly.

The str coerces data into a string. Every datatype can be coerced into a string.

Example 2.7. Introducing str

>>> str(1)          
'1'
>>> horsemen = ['war', 'pestilence', 'famine']
>>> horsemen.append('Powerbuilder')
>>> str(horsemen)   
"['war', 'pestilence', 'famine', 'Powerbuilder']"
>>> str(odbchelper) 
"<module 'odbchelper' from 'c:\\docbook\\dip\\py\\odbchelper.py'>"
>>> str(None)       
'None'

	For simple datatypes like integers, you would expect str to work, because almost every language has a function to convert an integer to a string.
	However, str works on any object of any type. Here it works on a list which we’ve constructed in bits and pieces.
	str also works on modules. Note that the string representation of the module includes the pathname of the module on disk, so yours will be different.
	A subtle but important behavior of str is that it works on None, the Python null value. It returns the string 'None'. We will use this to our advantage in the help function, as we’ll see shortly.

At the heart of our help function is the powerful dir function. dir returns a list of the attributes and methods of any object: modules, functions, strings, lists, dictionaries... pretty much anything.

Example 2.8. Introducing dir

>>> li = []
>>> dir(li)           
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>> d = {}
>>> dir(d)            
['clear', 'copy', 'get', 'has_key', 'items', 'keys', 'setdefault', 'update', 'values']
>>> import odbchelper
>>> dir(odbchelper)   
['__builtins__', '__doc__', '__file__', '__name__', 'buildConnectionString']

	li is a list, so dir(li) returns a list of all the methods of a list. Note that the returned list contains the names of the methods as strings, not the methods themselves.
	d is a dictionary, so dir(d) returns a list of the names of dictionary methods. At least one of these, keys, should look familiar.
	This is where it really gets interesting. odbchelper is a module, so dir(odbchelper) returns a list of all kinds of stuff defined in the module, including built-in attributes, like __name__ and __doc__, and whatever other attributes and methods you define. In this case, odbchelper has only one user-defined method, the buildConnectionString function we studied in Getting To Know Python.

Finally, the callable function takes any object and returns 1 if the object can be called, or 0 otherwise. Callable objects include functions, class methods, even classes themselves. (More on classes in chapter 3.)

Example 2.9. Introducing callable

>>> import string
>>> string.punctuation           
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>> string.join                  
<function join at 00C55A7C>
>>> callable(string.punctuation) 
0
>>> callable(string.join)        
1
>>> print string.join.__doc__    
join(list [,sep]) -> string

    Return a string composed of the words in list, with
    intervening occurrences of sep.  The default separator is a
    single space.

    (joinfields and join are synonymous)

	The functions in the string module are deprecated (although lots of people still use the join function), but the module contains lots of useful constants like this string.punctuation, which contains all the standard punctuation characters.
	string.join is a function that joins a list of strings.
	string.punctuation is not callable; it is a string. (A string does have callable methods, but the string itself is not callable.)
	string.join is callable; it’s a function that takes two arguments.
	Any callable object may have a doc string. Using the callable function on each of an object’s attributes, we can determine which attributes we care about (methods, functions, classes) and which we want to ignore (constants, etc.) without knowing anything about the object ahead of time.

type, str, dir, and all the rest of Python’s built-in functions are grouped into a special module called __builtin__. (That’s two underscores before and after.) If it helps, you can think of Python automatically executing from __builtin__ import * on startup, which imports all the “built-in” functions into the namespace so you can use them directly.

The advantage of thinking like this is that you can access all the built-in functions and attributes as a group by getting information about the __builtin__ module. And guess what, we have a function for that; it’s called help. Try it yourself and skim through the list now; we’ll dive into some of the more important functions later. (Some of the built-in error classes, like AttributeError, should already look familiar.)

>>> from apihelper import help
>>> import __builtin__
>>> help(__builtin__, 20)
ArithmeticError      Base class for arithmetic errors.
AssertionError       Assertion failed.
AttributeError       Attribute not found.
EOFError             Read beyond end of file.
EnvironmentError     Base class for I/O related errors.
Exception            Common base class for all exceptions.
FloatingPointError   Floating point operation failed.
IOError              I/O operation failed.

[...snip...]

	Python comes with excellent reference manuals, which you should peruse thoroughly to learn all the modules Python has to offer. But whereas in most languages you would find yourself referring back to the manuals (or man pages, or, God help you, MSDN) to remind yourself how to use these modules, Python is largely self-documenting.