Django 1.11 TypeError at / context must be a dict rather than unicode
我使用django 1.11创建一个网站。当我运行本地主机http://127.0.0.1:8000/时,出现错误"typeerror at/上下文必须是dict而不是unicode。"我不知道怎么修。
有问题的行:venvlibsite packagesdjango emplatecontext.py in make_context,第287行
全景上下文代码.py进口警告从ContextLib导入ContextManager从副本导入副本
从django.utils.deprecation import removedindjango20警告
硬编码处理器,便于使用CSRF保护。_内置的_context_processors=('django.template.context_processors.csrf',)
类ContextPopException(异常):"pop()被调用的次数多于push()"通过
类ContextDict(dict):def init(self、context、*args、**kwargs):super(contextdict,self).init(*args,**kwargs)
1 2 3 4 5 6 7 8 | context.dicts.append(self) self.context = context def __enter__(self): return self def __exit__(self, *args, **kwargs): self.context.pop() |
类BaseContext(对象):def init(self,dict_uu=none):自我重置听写(dict)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 | def _reset_dicts(self, value=None): builtins = {'True': True, 'False': False, 'None': None} self.dicts = [builtins] if value is not None: self.dicts.append(value) def __copy__(self): duplicate = copy(super(BaseContext, self)) duplicate.dicts = self.dicts[:] return duplicate def __repr__(self): return repr(self.dicts) def __iter__(self): for d in reversed(self.dicts): yield d def push(self, *args, **kwargs): dicts = [] for d in args: if isinstance(d, BaseContext): dicts += d.dicts[1:] else: dicts.append(d) return ContextDict(self, *dicts, **kwargs) def pop(self): if len(self.dicts) == 1: raise ContextPopException return self.dicts.pop() def __setitem__(self, key, value): "Set a variable in the current context" self.dicts[-1][key] = value def set_upward(self, key, value): """ Set a variable in one of the higher contexts if it exists there, otherwise in the current context. """ context = self.dicts[-1] for d in reversed(self.dicts): if key in d.keys(): context = d break context[key] = value def __getitem__(self, key): "Get a variable's value, starting at the current context and going upward" for d in reversed(self.dicts): if key in d: return d[key] raise KeyError(key) def __delitem__(self, key): "Delete a variable from the current context" del self.dicts[-1][key] def has_key(self, key): warnings.warn( "%s.has_key() is deprecated in favor of the 'in' operator." % self.__class__.__name__, RemovedInDjango20Warning ) return key in self def __contains__(self, key): for d in self.dicts: if key in d: return True return False def get(self, key, otherwise=None): for d in reversed(self.dicts): if key in d: return d[key] return otherwise def setdefault(self, key, default=None): try: return self[key] except KeyError: self[key] = default return default def new(self, values=None): """ Returns a new context with the same properties, but with only the values given in 'values' stored. """ new_context = copy(self) new_context._reset_dicts(values) return new_context def flatten(self): """ Returns self.dicts as one dictionary """ flat = {} for d in self.dicts: flat.update(d) return flat def __eq__(self, other): """ Compares two contexts by comparing theirs 'dicts' attributes. """ if isinstance(other, BaseContext): # because dictionaries can be put in different order # we have to flatten them like in templates return self.flatten() == other.flatten() # if it's not comparable return false return False |
类上下文(baseContext):"变量上下文的堆栈容器"def init(self,dict_u=none,autoescape=true,use_l10n=none,use_tz=none):self.autoescape=自动退出self.use_l10n=使用_l10nself.use_tz=使用self.template_name="未知"self.render_context=renderContext()。#设置为原始模板——而不是扩展或包含的模板#模板——在渲染过程中,请参见绑定模板。self.template=无super(上下文,self).init(dict_uuu)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | @contextmanager def bind_template(self, template): if self.template is not None: raise RuntimeError("Context is already bound to a template") self.template = template try: yield finally: self.template = None def __copy__(self): duplicate = super(Context, self).__copy__() duplicate.render_context = copy(self.render_context) return duplicate def update(self, other_dict): "Pushes other_dict to the stack of dictionaries in the Context" if not hasattr(other_dict, '__getitem__'): raise TypeError('other_dict must be a mapping (dictionary-like) object.') if isinstance(other_dict, BaseContext): other_dict = other_dict.dicts[1:].pop() return ContextDict(self, other_dict) |
类renderContext(baseContext):"用于存储模板状态的堆栈容器。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | RenderContext simplifies the implementation of template Nodes by providing a safe place to store state between invocations of a node's `render` method. The RenderContext also provides scoping rules that are more sensible for 'template local' variables. The render context stack is pushed before each template is rendered, creating a fresh scope with nothing in it. Name resolution fails if a variable is not found at the top of the RequestContext stack. Thus, variables are local to a specific template and don't affect the rendering of other templates as they would if they were stored in the normal template context. """ template = None def __iter__(self): for d in self.dicts[-1]: yield d def __contains__(self, key): return key in self.dicts[-1] def get(self, key, otherwise=None): return self.dicts[-1].get(key, otherwise) def __getitem__(self, key): return self.dicts[-1][key] @contextmanager def push_state(self, template, isolated_context=True): initial = self.template self.template = template if isolated_context: self.push() try: yield finally: self.template = initial if isolated_context: self.pop() |
类RequestContext(上下文):"template.context的这个子类使用在引擎配置中定义的处理器。可以将其他处理器指定为可调用文件列表使用"processors"关键字参数。"def init(self,request,dict_=none,processors=none,use_l10n=none,use_tz=none,autoescape=true):super(requestContext,self).init(dict_u,use_l10n=使用_l10n,use_tz=使用_tz,autoescape=自动退出)self.request=请求self.u processors=(如果处理器不是其他元组(处理器))。self._processors_index=len(self.dicts)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | # placeholder for context processors output self.update({}) # empty dict for any new modifications # (so that context processors don't overwrite them) self.update({}) @contextmanager def bind_template(self, template): if self.template is not None: raise RuntimeError("Context is already bound to a template") self.template = template # Set context processors according to the template engine's settings. processors = (template.engine.template_context_processors + self._processors) updates = {} for processor in processors: updates.update(processor(self.request)) self.dicts[self._processors_index] = updates try: yield finally: self.template = None # Unset context processors. self.dicts[self._processors_index] = {} def new(self, values=None): new_context = super(RequestContext, self).new(values) # This is for backwards-compatibility: RequestContexts created via # Context.new don't include values from context processors. if hasattr(new_context, '_processors_index'): del new_context._processors_index return new_context |
def make_context(上下文,请求=无,**kwargs):"从普通的dict和可选的httpRequest创建合适的上下文。"如果context不是none,也不是isinstance(context,dict):raise typeerror('context必须是dict而不是%s.'%context.class.name)//287如果请求为无:context=context(context,**kwargs)其他:#需要以下模式来确保#上下文重写模板上下文处理器中的那些。原始上下文=上下文context=requestContext(请求,**kwargs)如果原始上下文:context.push(原始上下文)返回上下文
在将上下文传递到模板的位置,请确保它是字典而不是字符串