$ 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.