If it might help toward the answers, this is from the data dictionary, something I had formatted manually and saved in a file:

 SIDData(  
   {  
      'sid': Security(  
             2174,  
             symbol        = u'DIA',  
             security_name = u'SPDR DOW JONES INDUSTRIAL AVER',  
             exchange      = u'NYSE ARCA EXCHANGE',  
             start_date    = datetime.datetime(1998, 1, 20, 5, 0, tzinfo=<UTC>),  
             end_date      = datetime.datetime(2013, 12, 27, 5, 0, tzinfo=<UTC>),  
             first_traded  = None  
          ),  
      'price':       148.14,  
      'open_price':  148.88,  
      'high':        149.2,  
      'low':         147.61,  
      'close_price': 148.14,  
      'volume':      5347802,  
      'type':        4  
      'vwap':        <function _transform at 0x9583aa0>,  
      'mavg':        <function _transform at 0x9583b18>,  
      'stddev':      <function _transform at 0x9583c08>,  
      'returns':     <function _transform at 0x9583b90>,  
      'dt':          datetime.datetime(2013, 9, 3, 0, 0, tzinfo=<UTC>),  
      'datetime':    datetime.datetime(2013, 9, 3, 0, 0, tzinfo=<UTC>),  
      'source_id':   'DynamicUniverseTradeSource43befd58175be9f1cde1965b3abd2fd3',  
      'MovingVWAPad9473767b9caa535f616974b59616c3': 148.14,  
   }  
 )

Extremely helpful - Thank you.

Is it possible to get a similar extract of what is contained in 'Context' or does that vary tremendously based on the initialize function?

Yes, maybe. This doesn't fully address the questions. I have some of those same questions and hope for discussion.

If try to print context from initialize, just results in something similar to 1970-01-01 PRINT qexec.algo.algoproxy.AlgorithmContext object at 0x7275c50,
however printing a sub-level works...

def handle_data(context, data):  
    print context.portfolio  

...and then after spending some time with the output, example:

 Portfolio(  
   {  
      'portfolio_value': 5000.0,  
      'cash':            5000.0,  
      'starting_cash':   5000.0,  
      'returns':         0.0,  
      'capital_used':    0.0,  
      'pnl':             0.0,  
      'positions_value': 0.0,  
      'start_date':      datetime.datetime(2013, 9, 1, 0, 0, tzinfo=<UTC>)  
      'positions': {  
           Security(  
                2174,  
                symbol        = u'DIA',  
                security_name = u'SPDR DOW JONES INDUSTRIAL AVER',  
                exchange      = u'NEW YORK STOCK EXCHANGE',  
                start_date    = datetime.datetime(1993, 1, 4, 5, 0, tzinfo=<UTC>),  
                end_date      = datetime.datetime(2013, 12, 27, 5, 0, tzinfo=<UTC>),  
                first_traded  = None  
           ): Position(  
                 {  
                   'amount':          0,  
                   'last_sale_price': 14.26,  
                   'cost_basis':      0.0,  
                   'sid': Security(  
                        2174,  
                        symbol        = u'DIA',  
                        security_name = u'SPDR DOW JONES INDUSTRIAL AVER',  
                        exchange      = u'NEW YORK STOCK EXCHANGE',  
                        start_date    = datetime.datetime(1993, 1, 4, 5, 0, tzinfo=<UTC>),  
                        end_date      = datetime.datetime(2013, 12, 27, 5, 0, tzinfo=<UTC>),  
                        first_traded  = None  
                    )  
                 }  
              )  
       },  
   }  
 )  

The Security() object is used as a dictionary key in one case and value in another.

If you are refering to propery objects, then they can be thought of as sugar for wrapping reads and writes to an attribute. For example, to create a read-only attribute, you may use:

class MyClass(object):  
    def __init__(self):  
        self._read_only_attr = 10

    @property  
    def read_only(self):  
        return self._read_only_attr

myobj = MyClass()  
print myobj.read_only  # prints 10, valid code.

# however:  
myobj.read_only = 'not 10'  # Raises: AttributeError: can't set attribute  

If you are refering to attributes in general, then we should start with what the syntax you describe actually means.
Fundementally, everything in python is an object. This means that classes, modules, functions, methods, string literals, and so on are all instances of classes.
For most cases, you may take your example of:
myobject.myattribute and replace it with:
myobject.__dict__['myattribute'] This is a simplification, but it may help to understand what this means first.
User defined attributes are merely stored in a dictionary on the object, and are looked up as strings.
Of course, it is better to use the myobject.myattribute syntax, as not all objects with have a '__dict__', and looking through '__dict__' will not search for attributes defined on the class or super classes or you object.

To address your other questions:
The code:
def initialize(context): Defines a new function object name 'initialize' that accepts one argument named 'context'.
When you say:

do the dot properties work like they would with a class?

remember that everything is an object, so saying:
initialize.atribute = 10 is completely legal.

There is nothing special about 'initialize' in python; however, this is the function that Quantopian will call with an empty Context object to set up your algorithm. The Context object there is basically a dictionary that allows you to index into it with attribute access notation. This means that:
context.attr == context['attr'] and that notation may be interchanged on the Context object.

To add attributes to an object, you must simply do:
myobject.newattribute = new_value This will only fail if 'myobject' is an instance of a class that defines a '__slots__' attribute, in which case, only the attributes named in that tuple will be allowed. In the general case, this is not defined, and instead a '__dict__' is defined implicitly so that users may add attributes as they wish.

Currently, there is no easy way to get a list of all the attributes of an object from within the Quantopian IDE; however, in a local python environment, you may use the builtin function 'dir' to return a list of strings naming all the attributes on an object. Hopefully someone will add this feature to the Quantopian IDE, it seems like it could be useful.

Hi Paul,

Another concept which might be helpful is to think of context as a container that the Quantopian initialize() and handle_data() functions can mutually access. At a higher level (that we don't see in Quantopian), the context variable is shared between these two functions, and then you can pass it around to others that you define as well.

Besides all of the predefined attributes in context listed above helpfully, you can also define your own at will. Say, if you need an iterator, just put a context.i = 0 in your initialize, and then in handle_data, you can reference it as context.i to read/write, and so on.

Some good explanations from Joe up the for sure too. He certainly embraces python.
I'm still a bit in translation from other languages.

HTH too.

Thanks for the responses folks, it is definitely helping me understand!