Index: django/utils/datastructures.py
===================================================================
--- django/utils/datastructures.py	(revision 7818)
+++ django/utils/datastructures.py	(working copy)
@@ -59,12 +59,12 @@
             data = {}
         super(SortedDict, self).__init__(data)
         if isinstance(data, dict):
-            self.keyOrder = data.keys()
+            self.key_order = data.keys()
         else:
-            self.keyOrder = []
+            self.key_order = []
             for key, value in data:
-                if key not in self.keyOrder:
-                    self.keyOrder.append(key)
+                if key not in self.key_order:
+                    self.key_order.append(key)
 
     def __deepcopy__(self, memo):
         from copy import deepcopy
@@ -73,21 +73,21 @@
 
     def __setitem__(self, key, value):
         super(SortedDict, self).__setitem__(key, value)
-        if key not in self.keyOrder:
-            self.keyOrder.append(key)
+        if key not in self.key_order:
+            self.key_order.append(key)
 
     def __delitem__(self, key):
         super(SortedDict, self).__delitem__(key)
-        self.keyOrder.remove(key)
+        self.key_order.remove(key)
 
     def __iter__(self):
-        for k in self.keyOrder:
+        for k in self.key_order:
             yield k
 
     def pop(self, k, *args):
         result = super(SortedDict, self).pop(k, *args)
         try:
-            self.keyOrder.remove(k)
+            self.key_order.remove(k)
         except ValueError:
             # Key wasn't in the dictionary in the first place. No problem.
             pass
@@ -95,27 +95,27 @@
 
     def popitem(self):
         result = super(SortedDict, self).popitem()
-        self.keyOrder.remove(result[0])
+        self.key_order.remove(result[0])
         return result
 
     def items(self):
-        return zip(self.keyOrder, self.values())
+        return zip(self.key_order, self.values())
 
     def iteritems(self):
-        for key in self.keyOrder:
+        for key in self.key_order:
             yield key, super(SortedDict, self).__getitem__(key)
 
     def keys(self):
-        return self.keyOrder[:]
+        return self.key_order[:]
 
     def iterkeys(self):
-        return iter(self.keyOrder)
+        return iter(self.key_order)
 
     def values(self):
-        return [super(SortedDict, self).__getitem__(k) for k in self.keyOrder]
+        return [super(SortedDict, self).__getitem__(k) for k in self.key_order]
 
     def itervalues(self):
-        for key in self.keyOrder:
+        for key in self.key_order:
             yield super(SortedDict, self).__getitem__(key)
 
     def update(self, dict_):
@@ -123,29 +123,29 @@
             self.__setitem__(k, v)
 
     def setdefault(self, key, default):
-        if key not in self.keyOrder:
-            self.keyOrder.append(key)
+        if key not in self.key_order:
+            self.key_order.append(key)
         return super(SortedDict, self).setdefault(key, default)
 
     def value_for_index(self, index):
         """Returns the value of the item at the given zero-based index."""
-        return self[self.keyOrder[index]]
+        return self[self.key_order[index]]
 
     def insert(self, index, key, value):
         """Inserts the key, value pair before the item with the given index."""
-        if key in self.keyOrder:
-            n = self.keyOrder.index(key)
-            del self.keyOrder[n]
+        if key in self.key_order:
+            n = self.key_order.index(key)
+            del self.key_order[n]
             if n < index:
                 index -= 1
-        self.keyOrder.insert(index, key)
+        self.key_order.insert(index, key)
         super(SortedDict, self).__setitem__(key, value)
 
     def copy(self):
         """Returns a copy of this object."""
         # This way of initializing the copy means it works for subclasses, too.
         obj = self.__class__(self)
-        obj.keyOrder = self.keyOrder[:]
+        obj.key_order = self.key_order[:]
         return obj
 
     def __repr__(self):
@@ -157,7 +157,7 @@
 
     def clear(self):
         super(SortedDict, self).clear()
-        self.keyOrder = []
+        self.key_order = []
 
 class MultiValueDictKeyError(KeyError):
     pass
Index: tests/regressiontests/datastructures/tests.py
===================================================================
--- tests/regressiontests/datastructures/tests.py	(revision 7818)
+++ tests/regressiontests/datastructures/tests.py	(working copy)
@@ -104,7 +104,7 @@
 >>> d.clear()
 >>> d
 {}
->>> d.keyOrder
+>>> d.key_order
 []
 
 ### DotExpandedDict ############################################################
