diff --git a/django/utils/formats.py b/django/utils/formats.py
index 372998f..1c5f381 100644
--- a/django/utils/formats.py
+++ b/django/utils/formats.py
@@ -7,14 +7,26 @@ from django.utils.importlib import import_module
 from django.utils.encoding import smart_str
 from django.utils import dateformat, numberformat, datetime_safe
 
-def get_format_modules(reverse=False):
+# format_cache is a mapping from format_type to a 1-tuple. This allows 
+# us to separate 3 distinct cases:
+#      (None,)            the format_type was checked previously, but 
+#                         no value was found.
+#      (<format value>, ) the previously fetched value for format_type
+#                         is format_value
+#      if a format_type key is not in _format_cache, then format_type
+#      hasn't yet been fetched.
+_format_cache = {}
+
+def get_format_modules(reverse=False, lang=None):
     """
     Returns an iterator over the format modules found in the project and Django
     """
+    if lang is None:
+        lang = get_language()
     modules = []
-    if not check_for_language(get_language()) or not settings.USE_L10N:
+    if not check_for_language(lang) or not settings.USE_L10N:
         return modules
-    locale = to_locale(get_language())
+    locale = to_locale(lang)
     if settings.FORMAT_MODULE_PATH:
         format_locations = [settings.FORMAT_MODULE_PATH + '.%s']
     else:
@@ -34,20 +46,43 @@ def get_format_modules(reverse=False):
         modules.reverse()
     return modules
 
-def get_format(format_type):
+_use_l10n = None
+def get_format(format_type, lang=None):
     """
     For a specific format type, returns the format for the current
     language (locale), defaults to the format in the settings.
     format_type is the name of the format, e.g. 'DATE_FORMAT'
     """
-    format_type = smart_str(format_type)
-    if settings.USE_L10N:
-        for module in get_format_modules():
-            try:
-                return getattr(module, format_type)
-            except AttributeError:
+    # format_type = smart_str(format_type)
+    global _format_cache
+    global _use_l10n
+    if _use_l10n is None:
+        _use_l10n = settings.USE_L10N
+        
+    if _use_l10n:
+        if lang is None:
+            lang = get_language()
+        cached_value = _format_cache.get((format_type, lang), None)
+        if cached_value:
+            if cached_value[0]:
+                return cached_value[0]
+            else:
+                # format_type was previously checked, but didn't have a value
                 pass
-    return getattr(settings, format_type)
+        else: 
+            for module in get_format_modules(lang=lang):
+                try:
+                    val = getattr(module, format_type)
+                    _format_cache[(format_type, lang)] = (val,)
+                    return val
+                except AttributeError:
+                    pass
+            _format_cache[(format_type, lang)] = (None,)
+    cached_value = _format_cache.get(format_type)
+    if not cached_value:
+        cached_value = (getattr(settings, format_type),)
+        _format_cache[format_type] = cached_value
+    return cached_value[0]
 
 def date_format(value, format=None):
     """
@@ -66,12 +101,13 @@ def number_format(value, decimal_pos=None):
     """
     Formats a numeric value using localization settings
     """
+    lang = get_language()
     return numberformat.format(
         value,
-        get_format('DECIMAL_SEPARATOR'),
+        get_format('DECIMAL_SEPARATOR', lang=lang),
         decimal_pos,
-        get_format('NUMBER_GROUPING'),
-        get_format('THOUSAND_SEPARATOR'),
+        get_format('NUMBER_GROUPING', lang=lang),
+        get_format('THOUSAND_SEPARATOR', lang=lang),
     )
 
 def localize(value):
diff --git a/django/utils/translation/__init__.py b/django/utils/translation/__init__.py
index 6d81726..7d8eec3 100644
--- a/django/utils/translation/__init__.py
+++ b/django/utils/translation/__init__.py
@@ -20,20 +20,24 @@ __all__ = ['gettext', 'gettext_noop', 'gettext_lazy', 'ngettext',
 # replace the functions with their real counterparts (once we do access the
 # settings).
 
+_trans = None
+
 def delayed_loader(real_name, *args, **kwargs):
     """
     Call the real, underlying function.  We have a level of indirection here so
     that modules can use the translation bits without actually requiring
     Django's settings bits to be configured before import.
     """
-    from django.conf import settings
-    if settings.USE_I18N:
-        from django.utils.translation import trans_real as trans
-    else:
-        from django.utils.translation import trans_null as trans
-
+    global _trans
+    if not _trans:
+        from django.conf import settings
+        if settings.USE_I18N:
+            from django.utils.translation import trans_real as trans
+        else:
+            from django.utils.translation import trans_null as trans
+        _trans = trans
     # Make the originally requested function call on the way out the door.
-    return getattr(trans, real_name)(*args, **kwargs)
+    return getattr(_trans, real_name)(*args, **kwargs)
 
 g = globals()
 for name in __all__:
