Question: I am looking for way how to add new objects to existing queryset, or how to implement what I want by other way. 

`contact = watson.filter(contacts, searchline)` This line returns queryset, which I later use to iterate.

Then I want to do this to add more objects, which watson couldn't find

```
contact_in_iteration = Contact.objects.get(id = fild.f_for)
contact.append(contact_in_iteration)

```

And sorry for my poor english

Did this 

```
contacts = Contact.objects.filter(crm_id=request.session['crm_id'])
query = Q(contacts,searchline)
contact = watson.filter(query)

```

and get 'filter() missing 1 required positional argument: 'search\_text'' error

Answer: 
You can use | and Q lookups. See [the docs](https://docs.djangoproject.com/en/1.9/topics/db/queries/#complex-lookups-with-q-objects).

I'm not sure I've fully understood your initial query, but I think that in your case you would want to do:

```
query = Q(contacts='Foo', searchline='Bar')
contact = watson.filter(query)

```

Then later:

```
contact = watson.filter(query | Q(id=field.f_for))

```

Strictly speaking it won't append to the queryset, but will return a new queryset. But that's okay, because that's what `.filter()` does anyway.
You should look at a queryset as a sql query that will be executed later. When constructing a queryset and save the result in a variable, you can later filter it even more, but you can not expand it. If you need a query that has more particular rules (like, you need an OR operation) you should state that when you are constructing the query. One way of doing that is indeed using the Q object.

But it looks like you are confused about what querysets really are and how they are used. First of all:

```
Contact.objects.get(id = fild.f_for)

```

will never return a queryset, but an instance, because you use `get` and thus ask for a single particular record. You need to use filter() if you want to get a quersyet. So if you had an existing queryset say `active_contacts` and you wanted to filter it down so you only get the contacts that have a first\_name of 'John' you would do:

```
active_contacts = Contact.objects.filter(active=True)
active_contacts_named_John = active_contacts.filter(first_name='John')

```

Of course you could do this in one line too, but I'm assuming you do the first queryset construction somewhere else in your code.

Second remark:
If in your example `watson` is a queryset, your user of `filter()` is unclear. This doesn't really make sense:

```
contact = watson.filter(contacts, searchline)

```

As stated earlier, filtering a queryset returns another queryset. So you should use a plurar as your variable name e.g. `contacts`. Then the correct use of filter would be:

```
contacts = watson.filter(first_name=searchline)

```

I'm assuming `searchline` here is a variable that contains a user inputted search term. So maybe here you should name your variable `searchterm` or similar. This will return all contacts that are filtered by whatever watson is filtering out already and whose first\_name matches `searchline` exactly. You could also use a more liberate method and filter out results that 'contains' the searching term, like so:

```
contacts = watson.filter(first_name__contains=searchline)

```

Hope this helps you get on the right path.