Collection¶
Classes:
Collection ([iterable]) |
List-based sequence with convenience methods for mapping and filtering, and NumPy-style fancy indexing |
Eacher (iterable) |
Applies operations chained onto it to each item in an iterator |
-
class
Collection
(iterable=None)[source]¶ List-based sequence with convenience methods for mapping and filtering, and NumPy-style fancy indexing
Methods:
append
(x)Append x to the end of this Collection
.extend
(x)Extend this Collection
by appending elements from the iterable.filter
(predicate)Returns a Collection
filtered by predicate.groupby
(*predicates)Groups items by predicates. map
(f)Returns a Collection
off
applied to each item.sort
(field[, ascending])Returns a Collection
, sorted by the given field and direction.sorted
(*predicates, **reverse)Returns a Collection
, sorted by predicates in ascending order.Attributes:
each
Any operations chained onto each
(attribute access, item access, and calls) are applied to each item in theCollection
.-
append
(x)[source]¶ Append x to the end of this
Collection
.The type of the item must match the type of the collection.
Parameters: x (Any) – Add an item to the collection
-
extend
(x)[source]¶ Extend this
Collection
by appending elements from the iterable.The type of the items in the list must all match the type of the collection.
Parameters: x (List[Any]) – Extend a collection with the items from the list.
-
filter
(predicate)[source]¶ Returns a
Collection
filtered by predicate.Predicate can either be a
callable
or anExpression
from Properties.If the predicate is a
callable
,filter()
will return all items for whichpredicate(item)
isTrue
.If the predicate is an
Expression
,filter()
will return all items for whichpredicate.evaluate(item)
isTrue
.Parameters: predicate (callable or Expression) – Either a callable or a Properties Expression
which is called or evaluated for each item in the list.Returns: A new collection with only those items for which the predicate returned or evaluated to True
.Return type: Collection
-
groupby
(*predicates)[source]¶ Groups items by predicates.
Groups items by predicates and yields tuple of
(group, items)
for each group, whereitems
is aCollection
.Each predicate can be a key function, or a string of dot-chained attributes to use as sort keys.
Parameters: predicates (callable or str) – Any positional arguments are predicates. If the predicate is a string, it denotes an attribute for each element, potentially with levels separated by a dot. If the predicate is a callable, it must return the value to sort by for each given element. Yields: Tuple[str, Collection] – A tuple of (group, Collection)
for each group.Examples
>>> import collections >>> FooBar = collections.namedtuple("FooBar", ["foo", "bar"]) >>> c = Collection([FooBar("a", True), FooBar("b", False), FooBar("a", False)])
>>> for group, items in c.groupby("foo"): ... print(group) ... print(items) a Collection([FooBar(foo='a', bar=True), FooBar(foo='a', bar=False)]) b Collection([FooBar(foo='b', bar=False)]) >>> for group, items in c.groupby("bar"): ... print(group) ... print(items) False Collection([FooBar(foo='b', bar=False), FooBar(foo='a', bar=False)]) True Collection([FooBar(foo='a', bar=True)])
-
map
(f)[source]¶ Returns a
Collection
off
applied to each item.Parameters: f (callable) – Apply function f
to each element of the collection and return the result as a collection.Returns: A collection with the results of the function f
applied to each element of the original collection.Return type: Collection
-
sort
(field, ascending=True)[source]¶ Returns a
Collection
, sorted by the given field and direction.Parameters: - field (str) – The name of the field to sort by
- ascending (bool) – Sorts results in ascending order if True (the default), and in descending order if False.
Returns: The sorted collection.
Return type: Example
>>> from descarteslabs.catalog import Product >>> collection = Product.search().collect() >>> sorted_collection = collection.sort("created", ascending=False) >>> sorted_collection
-
sorted
(*predicates, **reverse)[source]¶ Returns a
Collection
, sorted by predicates in ascending order.Each predicate can be a key function, or a string of dot-chained attributes to use as sort keys. The reverse flag returns results in descending order.
Parameters: - predicates (callable or str) – Any positional arguments are predicates. If the predicate is a string, it denotes an attribute for each element, potentially with levels separated by a dot. If the predicate is a callable, it must return the value to sort by for each given element.
- reverse (bool) – The sort is ascending by default, by setting
reverse
toTrue
, the sort will be descending.
Returns: The sorted collection.
Return type: Examples
>>> import collections >>> FooBar = collections.namedtuple("FooBar", ["foo", "bar"]) >>> X = collections.namedtuple("X", "x") >>> c = Collection([FooBar(1, X("one")), FooBar(2, X("two")), FooBar(3, X("three"))])
>>> c.sorted("foo") Collection([FooBar(foo=1, bar=X(x='one')), FooBar(foo=2, bar=X(x='two')), FooBar(foo=3, bar=X(x='three'))]) >>> c.sorted("bar.x") Collection([FooBar(foo=1, bar=X(x='one')), FooBar(foo=3, bar=X(x='three')), FooBar(foo=2, bar=X(x='two'))])
-
property
each
¶ Any operations chained onto
each
(attribute access, item access, and calls) are applied to each item in theCollection
.Yields: Any – The result of an item with all operations following each
applied to it.Notes
- Add
combine()
at the end of the operations chain to combine the results into a list by default, or any container type passed intocombine()
- Use
pipe(f, *args, **kwargs)
to yieldf(x, *args, **kwargs)
for each itemx
yielded by the preceeding operations chain
Examples
>>> c = Collection(["one", "two", "three", "four"]) >>> for x in c.each.capitalize(): ... print(x) One Two Three Four >>> c.each.capitalize()[:2] 'On' 'Tw' 'Th' 'Fo' >>> c.each.capitalize().pipe(len) 3 3 5 4 >>> list(c.each.capitalize().pipe(len).combine(set)) [3, 4, 5]
- Add
-