$ python
Python 2.2.2 (#1, Oct 28 2002, 17:22:19)
[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>> help
Type help() for interactive help, or help(object) for help about object.

>>> help()
Welcome to Python 2.2!  This is the online help utility.
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://www.python.org/doc/tut/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics".  Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
help>

help> keywords
Here is a list of the Python keywords.  Enter any keyword to get more help.
and                 elif                global              or
assert              else                if                  pass
break               except              import              print
class               exec                in                  raise
continue            finally             is                  return
def                 for                 lambda              try
del                 from                not                 while
help> quit
You are now leaving help and returning to the Python interpreter.
If you want to ask for help on a particular object directly from the
interpreter, you can type "help(object)".  Executing "help(‘string‘)"
has the same effect as typing a particular string at the help> prompt.
>>>

>>> help(‘modules‘)
Please wait a moment while I gather a list of all available modules...
BaseHTTPServer      cgitb               marshal             sndhdr
Bastion             chunk               math                socket
CDROM               cmath               md5                 sre
CGIHTTPServer       cmd                 mhlib               sre_compile
Canvas              code                mimetools           sre_constants
	<...>
bisect              macpath             signal              xreadlines
cPickle             macurl2path         site                xxsubtype
cStringIO           mailbox             slgc (package)      zipfile
calendar            mailcap             smtpd
cgi                 markupbase          smtplib
Enter any module name to get more help.  Or, type "modules spam" to search
for modules whose descriptions contain the word "spam".
>>>

$ python
Python 2.2.2 (#1, Oct 28 2002, 17:22:19)
[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.executable
‘/usr/local/bin/python‘

>>> sys.platform
‘linux2‘

>>> sys.version
‘2.2.2 (#1, Oct 28 2002, 17:22:19) \n[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)]‘
>>> sys.version_info
(2, 2, 2, ‘final‘, 0)

>>> sys.maxint
2147483647

>>> sys.argv
[‘‘]

>>> sys.argv[0]
‘/home/pobrien/Code/PyCrust/PyCrustApp.py‘

>>> sys.path
[‘‘, ‘/home/pobrien/Code‘,
‘/usr/local/lib/python2.2‘,
‘/usr/local/lib/python2.2/plat-linux2‘,
‘/usr/local/lib/python2.2/lib-tk‘,
‘/usr/local/lib/python2.2/lib-dynload‘,
‘/usr/local/lib/python2.2/site-packages‘]

>>> sys.modules
{‘stat‘: <module ‘stat‘ from ‘/usr/local/lib/python2.2/stat.pyc‘>,
‘__future__‘: <module ‘__future__‘ from ‘/usr/local/lib/python2.2/__future__.pyc‘>,
‘copy_reg‘: <module ‘copy_reg‘ from ‘/usr/local/lib/python2.2/copy_reg.pyc‘>,
‘posixpath‘: <module ‘posixpath‘ from ‘/usr/local/lib/python2.2/posixpath.pyc‘>,
‘UserDict‘: <module ‘UserDict‘ from ‘/usr/local/lib/python2.2/UserDict.pyc‘>,
‘signal‘: <module ‘signal‘ (built-in)>,
‘site‘: <module ‘site‘ from ‘/usr/local/lib/python2.2/site.pyc‘>,
‘__builtin__‘: <module ‘__builtin__‘ (built-in)>,
‘sys‘: <module ‘sys‘ (built-in)>,
‘posix‘: <module ‘posix‘ (built-in)>,
‘types‘: <module ‘types‘ from ‘/usr/local/lib/python2.2/types.pyc‘>,
‘__main__‘: <module ‘__main__‘ (built-in)>,
‘exceptions‘: <module ‘exceptions‘ (built-in)>,
‘os‘: <module ‘os‘ from ‘/usr/local/lib/python2.2/os.pyc‘>,
‘os.path‘: <module ‘posixpath‘ from ‘/usr/local/lib/python2.2/posixpath.pyc‘>}

>>> help(‘modules keywords‘)
Here is a list of matching modules.  Enter any module name to get more help.
keyword - Keywords (from "graminit.c")

>>> import keyword
>>> keyword.kwlist
[‘and‘, ‘assert‘, ‘break‘, ‘class‘, ‘continue‘, ‘def‘, ‘del‘, ‘elif‘, ‘else‘,
‘except‘, ‘exec‘, ‘finally‘, ‘for‘, ‘from‘, ‘global‘, ‘if‘, ‘import‘, ‘in‘, ‘is‘,
‘lambda‘, ‘not‘, ‘or‘, ‘pass‘, ‘print‘, ‘raise‘, ‘return‘, ‘try‘, ‘while‘, ‘yield‘]

>>> dir(keyword)
[‘__all__‘, ‘__builtins__‘, ‘__doc__‘, ‘__file__‘, ‘__name__‘,
‘iskeyword‘, ‘keyword‘, ‘kwdict‘, ‘kwlist‘, ‘main‘]

>>> dir(sys)
[‘__displayhook__‘, ‘__doc__‘, ‘__excepthook__‘, ‘__name__‘, ‘__stderr__‘,
‘__stdin__‘, ‘__stdout__‘, ‘_getframe‘, ‘argv‘, ‘builtin_module_names‘,
‘byteorder‘, ‘copyright‘, ‘displayhook‘, ‘exc_info‘, ‘exc_type‘, ‘excepthook‘,
‘exec_prefix‘, ‘executable‘, ‘exit‘, ‘getdefaultencoding‘, ‘getdlopenflags‘,
‘getrecursionlimit‘, ‘getrefcount‘, ‘hexversion‘, ‘last_traceback‘,
‘last_type‘, ‘last_value‘, ‘maxint‘, ‘maxunicode‘, ‘modules‘, ‘path‘,
‘platform‘, ‘prefix‘, ‘ps1‘, ‘ps2‘, ‘setcheckinterval‘, ‘setdlopenflags‘,
‘setprofile‘, ‘setrecursionlimit‘, ‘settrace‘, ‘stderr‘, ‘stdin‘, ‘stdout‘,
‘version‘, ‘version_info‘, ‘warnoptions‘]

>>> dir()
[‘__builtins__‘, ‘__doc__‘, ‘__name__‘, ‘keyword‘, ‘sys‘]

>>> __builtins__
<module ‘__builtin__‘ (built-in)>

>>> dir(__builtins__)
[‘ArithmeticError‘, ‘AssertionError‘, ‘AttributeError‘, ‘DeprecationWarning‘,
‘EOFError‘, ‘Ellipsis‘, ‘EnvironmentError‘, ‘Exception‘, ‘False‘,
‘FloatingPointError‘, ‘IOError‘, ‘ImportError‘, ‘IndentationError‘,
‘IndexError‘, ‘KeyError‘, ‘KeyboardInterrupt‘, ‘LookupError‘, ‘MemoryError‘,
‘NameError‘, ‘None‘, ‘NotImplemented‘, ‘NotImplementedError‘, ‘OSError‘,
‘OverflowError‘, ‘OverflowWarning‘, ‘ReferenceError‘, ‘RuntimeError‘,
‘RuntimeWarning‘, ‘StandardError‘, ‘StopIteration‘, ‘SyntaxError‘,
‘SyntaxWarning‘, ‘SystemError‘, ‘SystemExit‘, ‘TabError‘, ‘True‘, ‘TypeError‘,
‘UnboundLocalError‘, ‘UnicodeError‘, ‘UserWarning‘, ‘ValueError‘, ‘Warning‘,
‘ZeroDivisionError‘, ‘_‘, ‘__debug__‘, ‘__doc__‘, ‘__import__‘, ‘__name__‘,
‘abs‘, ‘apply‘, ‘bool‘, ‘buffer‘, ‘callable‘, ‘chr‘, ‘classmethod‘, ‘cmp‘,
‘coerce‘, ‘compile‘, ‘complex‘, ‘copyright‘, ‘credits‘, ‘delattr‘, ‘dict‘,
‘dir‘, ‘divmod‘, ‘eval‘, ‘execfile‘, ‘exit‘, ‘file‘, ‘filter‘, ‘float‘,
‘getattr‘, ‘globals‘, ‘hasattr‘, ‘hash‘, ‘help‘, ‘hex‘, ‘id‘, ‘input‘, ‘int‘,
‘intern‘, ‘isinstance‘, ‘issubclass‘, ‘iter‘, ‘len‘, ‘license‘, ‘list‘,
‘locals‘, ‘long‘, ‘map‘, ‘max‘, ‘min‘, ‘object‘, ‘oct‘, ‘open‘, ‘ord‘, ‘pow‘,
‘property‘, ‘quit‘, ‘range‘, ‘raw_input‘, ‘reduce‘, ‘reload‘, ‘repr‘, ‘round‘,
‘setattr‘, ‘slice‘, ‘staticmethod‘, ‘str‘, ‘super‘, ‘tuple‘, ‘type‘, ‘unichr‘,
‘unicode‘, ‘vars‘, ‘xrange‘, ‘zip‘]

>>> dir(‘this is a string‘)
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__doc__‘, ‘__eq__‘,
‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getslice__‘, ‘__gt__‘,
‘__hash__‘, ‘__init__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘,
‘__new__‘, ‘__reduce__‘, ‘__repr__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__str__‘,
‘capitalize‘, ‘center‘, ‘count‘, ‘decode‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘,
‘find‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdigit‘, ‘islower‘, ‘isspace‘,
‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘replace‘, ‘rfind‘,
‘rindex‘, ‘rjust‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘,
‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]

dir(42)   # Integer (and the meaning of life)
dir([])   # List (an empty list, actually)
dir(())   # Tuple (also empty)
dir({})   # Dictionary (ditto)
dir(dir)  # Function (functions are also objects)

>>> class Person(object):
...     """Person class."""
...     def __init__(self, name, age):
...         self.name = name
...         self.age = age
...     def intro(self):
...         """Return an introduction."""
...         return "Hello, my name is %s and I‘m %s." % (self.name, self.age)
...
>>> bob = Person("Robert", 35)   # Create a Person instance
>>> joe = Person("Joseph", 17)   # Create another
>>> joe.sport = "football"       # Assign a new attribute to one instance
>>> dir(Person)      # Attributes of the Person class
[‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__doc__‘, ‘__getattribute__‘,
‘__hash__‘, ‘__init__‘, ‘__module__‘, ‘__new__‘, ‘__reduce__‘, ‘__repr__‘,
‘__setattr__‘, ‘__str__‘, ‘__weakref__‘, ‘intro‘]
>>> dir(bob)         # Attributes of bob
[‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__doc__‘, ‘__getattribute__‘,
‘__hash__‘, ‘__init__‘, ‘__module__‘, ‘__new__‘, ‘__reduce__‘, ‘__repr__‘,
‘__setattr__‘, ‘__str__‘, ‘__weakref__‘, ‘age‘, ‘intro‘, ‘name‘]
>>> dir(joe)         # Note that joe has an additional attribute
[‘__class__‘, ‘__delattr__‘, ‘__dict__‘, ‘__doc__‘, ‘__getattribute__‘,
‘__hash__‘, ‘__init__‘, ‘__module__‘, ‘__new__‘, ‘__reduce__‘, ‘__repr__‘,
‘__setattr__‘, ‘__str__‘, ‘__weakref__‘, ‘age‘, ‘intro‘, ‘name‘, ‘sport‘]
>>> bob.intro()      # Calling bob‘s intro method
"Hello, my name is Robert and I‘m 35."
>>> dir(bob.intro)   # Attributes of the intro method
[‘__call__‘, ‘__class__‘, ‘__cmp__‘, ‘__delattr__‘, ‘__doc__‘, ‘__get__‘,
‘__getattribute__‘, ‘__hash__‘, ‘__init__‘, ‘__new__‘, ‘__reduce__‘,
‘__repr__‘, ‘__setattr__‘, ‘__str__‘, ‘im_class‘, ‘im_func‘, ‘im_self‘]

>>> print __builtins__.__doc__   # Module docstring
Built-in functions, exceptions, and other objects.
Noteworthy: None is the `nil‘ object; Ellipsis represents `...‘ in slices.

>>> Person.__doc__         # Class docstring
‘Person class.‘
>>> Person.intro.__doc__   # Class method docstring
‘Return an introduction.‘

>>> print dir.__doc__   # Function docstring
dir([object]) -> list of strings
Return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it:
No argument:  the names in the current scope.
Module object:  the module attributes.
Type or class object:  its attributes, and recursively the attributes of
    its bases.
Otherwise:  its attributes, its class‘s attributes, and recursively the
    attributes of its class‘s base classes.

$ python
Python 2.2.2 (#1, Oct 28 2002, 17:22:19)
[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> dir()                # The dir() function
[‘__builtins__‘, ‘__doc__‘, ‘__name__‘]
>>> directory = dir      # Create a new variable
>>> directory()          # Works just like the original object
[‘__builtins__‘, ‘__doc__‘, ‘__name__‘, ‘directory‘]
>>> dir.__name__         # What‘s your name?
‘dir‘
>>> directory.__name__   # My name is the same
‘dir‘
>>> __name__             # And now for something completely different
‘__main__‘

if __name__ == ‘__main__‘:
    # Do something appropriate here, like calling a
    # main() function defined elsewhere in this module.
    main()
else:
    # Do nothing. This module has been imported by another
    # module that wants to make use of the functions,
    # classes and other useful bits it has defined.

>>> import types
>>> print types.__doc__
Define names for all type symbols known in the standard interpreter.
Types that are part of optional modules (e.g. array) are not listed.
>>> dir(types)
[‘BufferType‘, ‘BuiltinFunctionType‘, ‘BuiltinMethodType‘, ‘ClassType‘,
‘CodeType‘, ‘ComplexType‘, ‘DictProxyType‘, ‘DictType‘, ‘DictionaryType‘,
‘EllipsisType‘, ‘FileType‘, ‘FloatType‘, ‘FrameType‘, ‘FunctionType‘,
‘GeneratorType‘, ‘InstanceType‘, ‘IntType‘, ‘LambdaType‘, ‘ListType‘,
‘LongType‘, ‘MethodType‘, ‘ModuleType‘, ‘NoneType‘, ‘ObjectType‘, ‘SliceType‘,
‘StringType‘, ‘StringTypes‘, ‘TracebackType‘, ‘TupleType‘, ‘TypeType‘,
‘UnboundMethodType‘, ‘UnicodeType‘, ‘XRangeType‘, ‘__builtins__‘, ‘__doc__‘,
‘__file__‘, ‘__name__‘]
>>> s = ‘a sample string‘
>>> type(s)
<type ‘str‘>
>>> if type(s) is types.StringType: print "s is a string"
...
s is a string
>>> type(42)
<type ‘int‘>
>>> type([])
<type ‘list‘>
>>> type({})
<type ‘dict‘>
>>> type(dir)
<type ‘builtin_function_or_method‘>

>>> print id.__doc__
id(object) -> integer
Return the identity of an object.  This is guaranteed to be unique among
simultaneously existing objects.  (Hint: it‘s the object‘s memory address.)
>>> alist = [1, 2, 3]
>>> blist = [1, 2, 3]
>>> clist = blist
>>> clist
[1, 2, 3]
>>> blist
[1, 2, 3]
>>> alist
[1, 2, 3]
>>> id(alist)
145381412
>>> id(blist)
140406428
>>> id(clist)
140406428
>>> alist is blist    # Returns 1 if True, 0 if False
0
>>> blist is clist    # Ditto
1
>>> clist.append(4)   # Add an item to the end of the list
>>> clist
[1, 2, 3, 4]
>>> blist             # Same, because they both point to the same object
[1, 2, 3, 4]
>>> alist             # This one only looked the same initially
[1, 2, 3]

>>> print hasattr.__doc__
hasattr(object, name) -> Boolean
Return whether the object has an attribute with the given name.
(This is done by calling getattr(object, name) and catching exceptions.)
>>> print getattr.__doc__
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, ‘y‘) is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn‘t
exist; without it, an exception is raised in that case.
>>> hasattr(id, ‘__doc__‘)
1
>>> print getattr(id, ‘__doc__‘)
id(object) -> integer
Return the identity of an object.  This is guaranteed to be unique among
simultaneously existing objects.  (Hint: it‘s the object‘s memory address.)

>>> print callable.__doc__
callable(object) -> Boolean
Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances with a __call__() method.
>>> callable(‘a string‘)
0
>>> callable(dir)
1

>>> print isinstance.__doc__
isinstance(object, class-or-type-or-tuple) -> Boolean
Return whether an object is an instance of a class or of a subclass thereof.
With a type as second argument, return whether that is the object‘s type.
The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
isinstance(x, A) or isinstance(x, B) or ... (etc.).
>>> isinstance(42, str)
0
>>> isinstance(‘a string‘, int)
0
>>> isinstance(42, int)
1
>>> isinstance(‘a string‘, str)
1

>>> print issubclass.__doc__
issubclass(C, B) -> Boolean
Return whether class C is a subclass (i.e., a derived class) of class B.
>>> class SuperHero(Person):   # SuperHero inherits from Person...
...     def intro(self):       # but with a new SuperHero intro
...         """Return an introduction."""
...         return "Hello, I‘m SuperHero %s and I‘m %s." % (self.name, self.age)
...
>>> issubclass(SuperHero, Person)
1
>>> issubclass(Person, SuperHero)
0
>>>

>>> def interrogate(item):
...     """Print useful information about item."""
...     if hasattr(item, ‘__name__‘):
...         print "NAME:    ", item.__name__
...     if hasattr(item, ‘__class__‘):
...         print "CLASS:   ", item.__class__.__name__
...     print "ID:      ", id(item)
...     print "TYPE:    ", type(item)
...     print "VALUE:   ", repr(item)
...     print "CALLABLE:",
...     if callable(item):
...         print "Yes"
...     else:
...         print "No"
...     if hasattr(item, ‘__doc__‘):
...         doc = getattr(item, ‘__doc__‘)
... 	doc = doc.strip()   # Remove leading/trailing whitespace.
... 	firstline = doc.split(‘\n‘)[0]
... 	print "DOC:     ", firstline
...
>>> interrogate(‘a string‘)     # String object
CLASS:    str
ID:       141462040
TYPE:     <type ‘str‘>
VALUE:    ‘a string‘
CALLABLE: No
DOC:      str(object) -> string
>>> interrogate(42)             # Integer object
CLASS:    int
ID:       135447416
TYPE:     <type ‘int‘>
VALUE:    42
CALLABLE: No
DOC:      int(x[, base]) -> integer
>>> interrogate(interrogate)    # User-defined function object
NAME:     interrogate
CLASS:    function
ID:       141444892
TYPE:     <type ‘function‘>
VALUE:    <function interrogate at 0x86e471c>
CALLABLE: Yes
DOC:      Print useful information about item.