Handling of extra fields during create and insert
> Is there a reason for Model.create to ignore "extra" keyword arguments and for Model.insert to throw an error?

It's just an oversight on my part. At present, I am not inclined to change this as people may have code that relies on the behavior of `create()`. Additionally, `create()` is a bit semantically different than `insert()`....so I think I'm going to leave this as wontfix.
 > I prefer the behavior of ignoring keys without corresponding model fields

Out of curiosity, @poliquin, what is your use case for that feature? I always thought I prefer the opposite and rather throw an error when trying to assign values to non-existent fields.
 @tuukkamustonen, I find it useful when processing messy CSV data with fields that change slightly from file to file and have many uninteresting columns. I frequently encounter data like this from government sources. I read all data with `csv.DictReader`, transform fields to have consistent names matching my schema (e.g. lowercase, no spaces, ....), then simply pass the keyword arguments to `Model.create` with the `**` syntax. The stuff I want gets loaded, and the junk is ignored.

I definitely see the logic in throwing errors when encountering unexpected inputs, however, which is probably why the default `csv.DictWriter` behavior is `extrasaction='raise'`.

The `create` and `insert` methods of `Model` treat extra keys differently.  The following toy example demonstrates what I mean:

``` python
from peewee import Model, SqliteDatabase, IntegerField

db = SqliteDatabase(':memory:')


class ToyModel(Model):
    x = IntegerField()
    y = IntegerField()

    class Meta:
        database = db
        db_table = 'toys'


db.create_table(ToyModel, safe=True)

# insert some data, notice the extra 'z' key is ignored
data = {'x': 2, 'y': 4, 'z': 1}
m = ToyModel.create(**data)
m.save()  # no error here

# show that it worked
assert [(t.x, t.y) for t in ToyModel.select()] == [(2, 4)]

# insert some data, raises a KeyError for 'z'
ToyModel.insert(**data).execute()
```

`Model.insert` looks for each key in `cls._meta.fields`, but `create` and `__init__` simply iterate over the keywords and assign attributes for everything, regardless of whether there is an actual field in the model.

I prefer the behavior of ignoring keys without corresponding model fields (i.e. making `insert` consistent with `create`), but Python's `csv.DictWriter` is an example of allowing both behaviors via the `extrasaction` argument. Perhaps `peewee` could use a similar interface?

Is there a reason for `Model.create` to ignore "extra" keyword arguments and for `Model.insert` to throw an error? 
