4.3. Using type, str, dir, and Other Built-In Functions
Description: Python from novice to pro
Keywords: Python, Dive Into Python, tutorial, object-oriented, programming, documentation, book, free

# Dive Into Python Python from novice to pro | Find:

## 4.3. Using `type`, `str`, `dir`, and Other Built-In Functions

Python has a small set of extremely useful built-in functions. All other functions are partitioned off into modules. This was actually a conscious design decision, to keep the core language from getting bloated like other scripting languages (cough cough, Visual Basic).

### 4.3.1. The `type` Function

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 that can handle several types of data.

### Example 4.5. Introducing `type`

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

| `type` takes anything -- and I mean anything -- and returns its datatype. Integers, strings, lists, dictionaries, tuples, functions, classes, modules, even types are acceptable.
| `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 `info` function does, as you'll see shortly.

### 4.3.2. The `str` Function

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

### Example 4.6. Introducing `str`

    >>> str(1)
    '1'
    >>> horsemen = ['war', 'pestilence', 'famine']
    >>> 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 you'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'`. You'll use this to your advantage in the `info` function, as you'll see shortly.

At the heart of the `info` 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 4.7. 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__`, `__doc__`, and whatever other attributes and methods you define. In this case, `odbchelper` has only one user-defined method, the `buildConnectionString` function described in Chapter 2.

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

### Example 4.8. Introducing `callable`

    >>> import string
    >>> string.punctuation
    '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
    >>> string.join
    <function join at 00C55A7C>
    >>> callable(string.punctuation)
    False
    >>> callable(string.join)
    True
    >>> 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 many people still use the `join` function), but the module contains a lot 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`. By using the `callable` function on each of an object's attributes, you can determine which attributes you care about (methods, functions, classes) and which you want to ignore (constants and so on) without knowing anything about the object ahead of time.

### 4.3.3. Built-In Functions

`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, Python has a function called `info`. 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.)

### Example 4.9. Built-in Attributes and Functions

    >>> from apihelper import info
    >>> import __builtin__
    >>> info(__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 unlike most languages, where you would find yourself referring back to the manuals or man pages to remind yourself how to use these modules, Python is largely self-documenting.

### Further Reading on Built-In Functions

- Python Library Reference documents all the built-in functions and all the built-in exceptions.