How To Use Python dir() And help() Function With Examples

Two essential tools in a Python programmer’s toolkit are the `dir()` and `help()` functions. In this guide, we’ll dive deep into these functions, explore their capabilities, and provide practical examples to help you unlock their potential.

Table of Contents

1. Understanding the `dir()` Function.

The `dir()` function is a built-in Python function that returns a list of all valid attributes and methods of an object.

It provides a quick way to inspect the available features of an object, including its methods, attributes, and even special methods (often called “magic methods”).

1.1 Syntax.

The basic syntax of the `dir()` function is as follows:
```
dir(object)
```
`object`: The object whose attributes and methods you want to explore.

1.2 Example 1: Using `dir()` with Built-in Types.

Let’s start with a simple example using `dir()` with built-in Python types like strings and lists:
```
my_string = "Hello, Python"
print(dir(my_string))
```

The output will be a list of attributes and methods available for the string object `my_string`.

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

Call a method swapcase() of my_string like below.

>>> str1 = my_string.swapcase()
>>>
>>> str1
'hELLO, pYTHON'

1.3 Example 2: Using `dir()` with Custom Classes.

You can also use `dir()` to inspect custom classes and objects. Here’s an example:

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

my_car = Car("Toyota", "Camry")
print(dir(my_car))

This will display a list of attributes and methods associated with the `my_car` object.

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'make', 'model']

2. Understanding the `help()` Function.

The `help()` function is another valuable tool that provides documentation and information about Python objects, functions, modules, and more.

It can be especially handy when you’re working with unfamiliar libraries or want to learn more about a specific Python entity.

2.1 Syntax.

The basic syntax of the `help()` function is straightforward:
```
help(object)
```
`object`: The object you want to retrieve help information for.

2.2 Example 1: Using `help()` with Built-in Functions.

You can use `help()` to get information about built-in functions like `len()`:
```
help(len)
```
This will display detailed information about the `len()` function, including its purpose, usage, and parameters.
```
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.
```

2.3 Example 2: Using `help()` with Modules.

`help()` is also handy when exploring modules and their contents.

Let’s say you want to learn more about the `math` module:
```
import math
help(math)
```

This will provide an overview of the `math` module’s functions, constants, and their descriptions.

Help on built-in module math:

NAME
    math

DESCRIPTION
    This module provides access to the mathematical functions
    defined by the C standard.

FUNCTIONS
    acos(x, /)
        Return the arc cosine (measured in radians) of x.

        The result is between 0 and pi.

    acosh(x, /)
        Return the inverse hyperbolic cosine of x.

    asin(x, /)
        Return the arc sine (measured in radians) of x.

        The result is between -pi/2 and pi/2.

    asinh(x, /)
        Return the inverse hyperbolic sine of x.

    atan(x, /)
        Return the arc tangent (measured in radians) of x.

        The result is between -pi/2 and pi/2.

    atan2(y, x, /)
        Return the arc tangent (measured in radians) of y/x.

        Unlike atan(y/x), the signs of both x and y are considered.

    atanh(x, /)
        Return the inverse hyperbolic tangent of x.

    ceil(x, /)
        Return the ceiling of x as an Integral.

        This is the smallest integer >= x.

    comb(n, k, /)
        Number of ways to choose k items from n items without repetition and without order.

2.4 Example 3: Using `help()` with Custom Classes.

`help()` can be incredibly useful when working with custom classes.

To access documentation for a class, use `help()` on an instance of that class or on the class itself:

class Dog:
    """A simple class to represent a dog."""

    def __init__(self, name, age):
        self.name = name
        self.age = age

help(Dog)

This will display the class docstring and information about its methods.

Help on class Dog in module __main__:

class Dog(builtins.object)
 |  Dog(name, age)
 |  
 |  A simple class to represent a dog.
 |
 |  Methods defined here:
 |
 |  __init__(self, name, age)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |
 |  __dict__
 |      dictionary for instance variables (if defined)
 |
 |  __weakref__
 |      list of weak references to the object (if defined)

3. Conclusion.

In this article, we’ve explored two essential Python functions: `dir()` and `help()`.

These functions are indispensable for inspecting and understanding Python objects, modules, and classes, whether they are built-in or custom.
By using `dir()`, you can quickly discover the available attributes and methods of an object, while `help()` provides detailed documentation and context.
Incorporating these functions into your Python workflow will undoubtedly enhance your coding experience and productivity.