Changes between Version 38 and Version 39 of DjangoSpecifications/Core/Threading

Timestamp:

Apr 26, 2008, 2:51:19 PM (17 years ago)

Author:

anonymous

Comment:

--

DjangoSpecifications/Core/Threading

@@ -108 +108 @@
  1. `django/db/models/fields/related.py`: `append()` in `add_lazy_relation()` can add duplicated values, which may or may not confuse `pop()` in `do_pending_lookups()`
 
-=== Raw `grep` results ===
-
-==== Globals accessed with the `global` keyword ====
+
+== Class attributes ==
+
+Class attributes are shared between instances and thus between threads as well
+(as module-level classes are just global class objects).
+
+The behaviour is similar to globals: in similar manner to the global keyword in
+functions, explicit class specifier `foo.__class__.bar` is required for setting
+class variable `bar` from instance `foo`, otherwise a instance scope variable
+will be created that hides the class scope variable.
+
+(As this may not be obvious, let me illustrate it:)
+{{{
+>>> class Foo(object): bar = 1
+... 
+>>> f = Foo()
+>>> f.bar = 2
+>>> Foo.bar
+1
+>>> f.bar
+2
+>>> f.__class__.bar
+1
+>>> f.__class__.bar = 3
+>>> f.bar
+2
+>>> Foo.bar
+3
+}}}
+
+As with globals,
+ 1. class variables that are assigned to when the class is defined and never modified later (THREAD-SAFE),
+ 1. mutable class level data structures (lists and dictionaries, also instances) that are assigned to when the class is defined but whose elements are modified in methods and that are accessed without using the `__class__` keyword (NOT THREAD-SAFE),
+ 1. class variables assigned to in methods by using the `__class__` keyword (NOT THREAD-SAFE),
+
+Metaclasses -- think through the implications.
+
+== Raw `grep` results ==
+
+=== Globals accessed with the `global` keyword ===
 
 {{{
@@ -133 +170 @@
 Out of these, `django.core.management` is not used in multi-threading context.
 
-==== Global dictionaries ====
+=== Global dictionaries ===
 
 {{{
@@ -219 +256 @@
 }}}
 
-==== Global lists ====
+=== Global lists ===
 
 {{{
@@ -248 +285 @@
 As a matter of style, the read-only ones should really be tuples, not lists -- the 'say what you mean' idiom: if it shouldn't be modified, don't let it be by making it a tuple. Tuples are also marginally more efficient speed- and space-wise. There is a slight semantic distinction between lists and tuples though http://jtauber.com/blog/2006/04/15/python_tuples_are_not_just_constant_lists/ . But as there are no constant lists in Python, tuples are the only way to be const-correct.
 
-== Class attributes ==
-
-Class attributes are shared between instances and thus between threads as well
-(as module-level classes are just global class objects).
-
-The behaviour is similar to globals: in similar manner to the global keyword in
-functions, explicit class specifier `foo.__class__.bar` is required for setting
-class variable `bar` from instance `foo`, otherwise a instance scope variable
-will be created that hides the class scope variable.
-
-(As this may not be obvious, let me illustrate it:)
-{{{
->>> class Foo(object): bar = 1
-... 
->>> f = Foo()
->>> f.bar = 2
->>> Foo.bar
-1
->>> f.bar
-2
->>> f.__class__.bar
-1
->>> f.__class__.bar = 3
->>> f.bar
-2
->>> Foo.bar
-3
-}}}
-
-As with globals,
- 1. class variables that are assigned to when the class is defined and never modified later (THREAD-SAFE),
- 1. mutable class level data structures (lists and dictionaries, also instances) that are assigned to when the class is defined but whose elements are modified in methods and that are accessed without using the `__class__` keyword (NOT THREAD-SAFE),
- 1. class variables assigned to in methods by using the `__class__` keyword (NOT THREAD-SAFE),
-
-Metaclasses -- think through the implications.
-
-=== Raw `grep` results ===
-
-==== `__class__` keyword used for accessing anything other than `__name__` ====
+=== `__class__` keyword used for accessing anything other than `__name__` ===
 
 {{{