Zip the collection together with one or more arrays.

        :param items: The items to zip
        :type items: list

        :rtype: Collection
196440
def zip(self, *items):
        
        return self.__class__(list(zip(self.items, *items)))
363270
function zipObject(keys, values) {
  return keys.reduce(function(object, currentValue, currentIndex) {
    object[currentValue] = values[currentIndex];

    return object;
  }, {});
}
196298
def format_items(self, data, many):
        
        if many:
            return [self.format_item(item) for item in data]
        else:
            return self.format_item(data)
255060
public boolean addItems(Collection<? extends T> items) {
        if (mListItems.addAll(items)) {
            notifyDataSetChanged();
            return true;
        }
        return false;
    }
531297
@Nonnull
    public static <T> List<T> join(@Nonnull Collection<? extends T>... items) {
        int size = 0;
        for (Collection<? extends T> item : items)
            size += item.size();
        List<T> r = new ArrayList<>(size);
        for (Collection<? extends T> item : items)
            r.addAll(item);
        return r;
    }
111147
def add(self, *items):
        
        for item in items:
            self.unsorted.append(item)
            key = item[0]
            self.index[key] = item
        return self
1186878
public function zip(...$items): ArrayCollection
    {
        $arrayItems = array_map(function ($items) {
            return $this->itemsArray($items);
        }, $items);

        $params = array_merge([function (...$items) {
            return new static($items);
        }, $this->items], $arrayItems);

        return new static(call_user_func_array('array_map', $params));
    }
1109023
def __add_item(self, item, keys=None):
        
        if(not keys or not len(keys)):
            raise Exception('Error in %s.__add_item(%s, keys=tuple/list of items): need to specify a tuple/list containing at least one key!'
                            % (self.__class__.__name__, str(item)))
        direct_key = tuple(keys) # put all keys in a tuple, and use it as a key
        for key in keys:
            key_type = str(type(key))

            # store direct key as a value in an intermediate dictionary
            if(not key_type in self.__dict__):
                self.__setattr__(key_type, dict())
            self.__dict__[key_type][key] = direct_key

            # store the value in the actual dictionary
            if(not 'items_dict' in self.__dict__):
                self.items_dict = dict()
            self.items_dict[direct_key] = item
1074622
def n_at_a_time(
    items: List[int], n: int, fillvalue: str
) -> Iterator[Tuple[Union[int, str]]]:
    
    it = iter(items)
    return itertools.zip_longest(*[it] * n, fillvalue=fillvalue)
283375
public void setItems(java.util.Collection<java.util.Map<String,AttributeValue>> items) {
        if (items == null) {
            this.items = null;
            return;
        }

        java.util.List<java.util.Map<String,AttributeValue>> itemsCopy = new java.util.ArrayList<java.util.Map<String,AttributeValue>>(items.size());
        itemsCopy.addAll(items);
        this.items = itemsCopy;
    }
124948
def register_items(self, items):
        
        for item in items:
            item.set_parent(self)
        self.items.extend(items)
1059266
public static <T> Set<T> toSet(Iterable<T> items) {
    Set<T> set = new HashSet<T>();
    addAll(set, items);
    return set;
  }
542184
public FacetBuilder setItemsList(Map<String, String> items) {
        ArrayList<FacetWidgetItem> facetWidgetItems = new ArrayList<FacetWidgetItem>();

        for (String key : items.keySet()){
            String label = items.get(key);
            FacetWidgetItem facetWidgetItem = new FacetWidgetItem(key, label);
            facetWidgetItems.add(facetWidgetItem);
        }
        this.listItems = facetWidgetItems;
        return this;
    }
878386
def load_items(self, items):
        
        loaded_items = {}
        requests = collections.deque(create_batch_get_chunks(items))
        while requests:
            request = requests.pop()
            try:
                response = self.dynamodb_client.batch_get_item(RequestItems=request)
            except botocore.exceptions.ClientError as error:
                raise BloopException("Unexpected error while loading items.") from error

            # Accumulate results
            for table_name, table_items in response.get("Responses", {}).items():
                loaded_items.setdefault(table_name, []).extend(table_items)

            # Push additional request onto the deque.
            # "UnprocessedKeys" is {} if this request is done
            if response["UnprocessedKeys"]:
                requests.append(response["UnprocessedKeys"])
        return loaded_items
1229468
public static <T1, T2> List<Tuple2<T1, T2>> zip(Collection<T1> col1, Collection<T2> col2) {
        int resultSize = _max(col1.size(), col2.size());
        List<Tuple2<T1, T2>> result = new ArrayList<Tuple2<T1, T2>>(resultSize);

        Iterator<T1> it1 = col1.iterator();
        Iterator<T2> it2 = col2.iterator();

        while (resultSize-- > 0) {
            result.add(tuple(next(it1), next(it2)));
        }

        return result;
    }
374065
def uncache(self,*items):
        
        if not items:
            self.cache = {}
        for it in items:
            self.cache.pop(it,None)
42419
def items(self):
        ""
        return list(zip(list(self.keys()), list(self.values())))