title: Django Class Based Views: Understanding the arguments in the view class
body: <p>Reading through the source code for <code>View Class</code> </p>
  
  <p>Source code:</p>
  
  <pre><code>class View(object):
  """
  Intentionally simple parent class for all views. Only implements
  dispatch-by-method and simple sanity checking.
  """
  
  http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']
  
  def __init__(self, **kwargs):
      """
      Constructor. Called in the URLconf; can contain helpful extra
      keyword arguments, and other things.
      """
      # Go through keyword arguments, and either save their values to our
      # instance, or raise an error.
      for key, value in six.iteritems(kwargs):
          setattr(self, key, value)
  
  @classonlymethod
  def as_view(cls, **initkwargs):
      """
      Main entry point for a request-response process.
      """
      for key in initkwargs:
          if key in cls.http_method_names:
              raise TypeError("You tried to pass in the %s method name as a "
                              "keyword argument to %s(). Don't do that."
                              % (key, cls.__name__))
          if not hasattr(cls, key):
              raise TypeError("%s() received an invalid keyword %r. as_view "
                              "only accepts arguments that are already "
                              "attributes of the class." % (cls.__name__, key))
  
      def view(request, *args, **kwargs):
          self = cls(**initkwargs)
          if hasattr(self, 'get') and not hasattr(self, 'head'):
              self.head = self.get
          self.request = request
          self.args = args
          self.kwargs = kwargs
          return self.dispatch(request, *args, **kwargs)
      view.view_class = cls
      view.view_initkwargs = initkwargs
  
      # take name and docstring from class
      update_wrapper(view, cls, updated=())
  
      # and possible attributes set by decorators
      # like csrf_exempt from dispatch
      update_wrapper(view, cls.dispatch, assigned=())
      return view
  
  def dispatch(self, request, *args, **kwargs):
      # Try to dispatch to the right method; if a method doesn't exist,
      # defer to the error handler. Also defer to the error handler if the
      # request method isn't on the approved list.
      if request.method.lower() in self.http_method_names:
          handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
      else:
          handler = self.http_method_not_allowed
      return handler(request, *args, **kwargs)
  
  def http_method_not_allowed(self, request, *args, **kwargs):
      logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
          extra={
              'status_code': 405,
              'request': request
          }
      )
      return http.HttpResponseNotAllowed(self._allowed_methods())
  </code></pre>
  
  <p>My understanding is that when the urlconf is loaded, the <code>as_view</code> class only method is called.  <code>as_view</code> calls the <code>view</code> method which instantiates a View object with <code>self= cls(**initkwargs)</code> and then the <code>__init__</code> runs.  </p>
  
  <p>I get confused with figuring out the difference between <code>**kwargs</code> which is taken by the <code>view</code> method, and <code>**initkwargs</code> which are used while instantiating a class.  I assume the <code>view</code> method is passed all arguments through the <code>**kwargs</code>...then why isn't the <code>self= cls(**initkwargs)</code> line written as <code>self = cls(**kwargs)</code>?</p>
  
  <p>What's the difference between <code>**initkwargs</code> and <code>**kwargs</code>?</p>