docs: def contains(self, key, value, findAll=False, exclude=False, includeMissing=False):
          '''Return entries that:
          
          * have the key
          * key points to a list, and
          * value is found in the list.
  
          If value is also a list itself, then the list entry is selected if any of
          the values match.  If findAll is set to True, then all the entries
          must be found.
  
          Example of use:
  
          >>> test = [
          ...    {"name": "Jim",   "age": 18, "income": 93000, "wigs": [9, 12]  },
          ...    {"name": "Larry", "age": 18,                  "wigs": [3, 2, 9]},
          ...    {"name": "Joe",   "age": 20, "income": 15000, "wigs": [1, 2, 3]},
          ...    {"name": "Bill",  "age": 19, "income": 29000                   },
          ... ]
          >>> print PLOD(test).contains("wigs", [1, 12]).returnString()
          [
              {age: 18, income: 93000, name: 'Jim', wigs: [9, 12]  },
              {age: 20, income: 15000, name: 'Joe', wigs: [1, 2, 3]}
          ]
  
          .. versionadded:: 0.1.3b
          
          :param key:
             The dictionary key (or cascading list of keys) that should point to
             a list.
          :param value:
             The value to locate in the list. This argument can be an immutable
             value such as a string, tuple, or number.
  
             If this argument is a list of values instead, then this method will
             search for any of the values in that list. If the optional 'findAll'
             parameter is set to True, then all of the values in that list must
             be found. 
              
          Optional named arguments:
          
          :param finalAll:
             If True, then all the values in the 'value' parameter must be found.
          :param exclude:
             If 'exclude' is True, then the entries that do NOT match the above
             conditions are returned.
          :param includeMissing:
             If 'includeMissing' is True, then if the key is missing then that
             entry is included in the results. However, it does not include
             entries that have the key but its value is for a non-list or empty
             list.
          :returns:
             self
          '''
          result = []
          result_index = []
          for counter, row in enumerate(self.table):
              (target, tkey, target_list) = internal.dict_crawl(row, key)
              if target:
                  if findAll:
                      success = internal.list_match_all(target_list, value)
                  else:
                      success = internal.list_match_any(target_list, value)
                  if exclude:
                      success = not success
                  if success:
                      result.append(row)
                      result_index.append(self.index_track[counter])
                  else:
                      # item missing from list, so skip over
                      pass
              else:
                  if includeMissing:
                      result.append(row)
                      result_index.append(self.index_track[counter])
                  else:
                      pass
          self.table = result
          self.index_track = result_index
          return self