functional package¶
Submodules¶
functional.chain module¶
-
class
functional.chain.
FunctionalSequence
(sequence, transform=None)¶ Bases:
object
FunctionalSequence is a wrapper around any type of sequence which provides access to common functional transformations and reductions in a data pipelining style
-
all
()¶ Returns True if the truth value of all items in the sequence true.
>>> seq([True, True]).all() True
>>> seq([True, False]).all() False
Returns: True if all items truth value evaluates to True
-
any
()¶ Returns True if any element in the sequence has truth value True
>>> seq([True, False]).any() True
>>> seq([False, False]).any() False
Returns: True if any element is True
-
cache
()¶
-
count
(func)¶ Counts the number of elements in the sequence which satisfy the predicate f.
>>> seq([-1, -2, 1, 2]).count(lambda x: x > 0) 2
Parameters: func – predicate to count elements on Returns: count of elements that satisfy predicate
-
dict
()¶ Converts sequence of (Key, Value) pairs to a dictionary.
>>> type(seq([('a', 1)]).to_dict()) dict
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([('a', 1), ('b', 2)]).to_dict() {'a': 1, 'b': 2}
Returns: dictionary from sequence of (Key, Value) elements
-
difference
(other)¶ New sequence with unique elements present in sequence but not in other.
>>> seq([1, 2, 3]).difference([2, 3, 4]) [1]
Parameters: other – sequence to perform difference with Returns: difference of sequence and other :rtype FunctionalSequence
-
distinct
()¶ Returns sequence of distinct elements. Elements must be hashable.
>>> seq([1, 1, 2, 3, 3, 3, 4]).distinct() [1, 2, 3, 4]
Returns: sequence of distinct elements :rtype FunctionalSequence
-
drop
(n)¶ Drop the first n elements of the sequence.
>>> seq([1, 2, 3, 4, 5]).drop(2) [3, 4, 5]
Parameters: n – number of elements to drop Returns: sequence without first n elements :rtype FunctionalSequence
-
drop_right
(n)¶ Drops the last n elements of the sequence.
>>> seq([1, 2, 3, 4, 5]).drop_right(2) [1, 2, 3]
Parameters: n – number of elements to drop Returns: sequence with last n elements dropped :rtype FunctionalSequence
-
drop_while
(func)¶ Drops elements in the sequence while f evaluates to True, then returns the rest.
>>> seq([1, 2, 3, 4, 5, 1, 2]).drop_while(lambda x: x < 3) [3, 4, 5, 1, 2]
Parameters: func – truth returning function Returns: elements including and after f evaluates to False :rtype FunctionalSequence
-
empty
()¶ Returns True if the sequence has length zero.
>>> seq([]).empty() True
>>> seq([1]).empty() False
Returns: True if sequence length is zero
-
enumerate
(start=0)¶ Uses python enumerate to to zip the sequence with indexes starting at start.
>>> seq(['a', 'b', 'c']).enumerate(start=1) [(1, 'a'), (2, 'b'), (3, 'c')]
Parameters: start – Beginning of zip Returns: enumerated sequence starting at start :rtype FunctionalSequence
-
exists
(func)¶ Returns True if an element in the sequence makes f evaluate to True.
>>> seq([1, 2, 3, 4]).exists(lambda x: x == 2) True
>>> seq([1, 2, 3, 4]).exists(lambda x: x < 0) False
Parameters: func – existence check function Returns: True if any element satisfies f
-
filter
(func)¶ Filters sequence to include only elements where f is True.
>>> seq([-1, 1, -2, 2]).filter(lambda x: x > 0) [1, 2]
Parameters: func – function to filter on Returns: filtered sequence :rtype FunctionalSequence
-
filter_not
(func)¶ Filters sequence to include only elements where f is False.
>>> seq([-1, 1, -2, 2]).filter_not(lambda x: x > 0) [-1, -2]
Parameters: func – function to filter_not on Returns: filtered sequence :rtype FunctionalSequence
-
find
(func)¶ Finds the first element of the sequence that satisfies f. If no such element exists, then return None.
>>> seq(["abc", "ab", "bc"]).find(lambda x: len(x) == 2) 'ab'
Parameters: func – function to find with Returns: first element to satisfy f or None
-
first
()¶ Returns the first element of the sequence.
>>> seq([1, 2, 3]).first() 1
Raises IndexError when the sequence is empty.
>>> seq([]).first() Traceback (most recent call last): ... IndexError: list index out of range
Returns: first element of sequence
-
flat_map
(func)¶ Applies f to each element of the sequence, which themselves should be sequences. Then appends each element of each sequence to a final result
>>> seq([[1, 2], [3, 4], [5, 6]]).flat_map(lambda x: x) [1, 2, 3, 4, 5, 6]
>>> seq(["a", "bc", "def"]).flat_map(list) ['a', 'b', 'c', 'd', 'e', 'f']
>>> seq([[1], [2], [3]]).flat_map(lambda x: x * 2) [1, 1, 2, 2, 3, 3]
Parameters: func – function to apply to each sequence in the sequence Returns: application of f to elements followed by flattening :rtype FunctionalSequence
-
flatten
()¶ Flattens a sequence of sequences to a single sequence of elements.
>>> seq([[1, 2], [3, 4], [5, 6]]) [1, 2, 3, 4, 5, 6]
Returns: flattened sequence :rtype FunctionalSequence
-
fold_left
(zero_value, func)¶ Takes a zero_value and performs a reduction to a value using f. f should take two parameters, 1) the value to accumulate into the result and 2) the current result. Elements are folded left to right.
>>> seq('a', 'bc', 'de', 'f', 'm', 'nop').fold_left("Start:", lambda v, curr: curr + 2 * v) 'Start:aabcbcdedeffmmnopnop'
Parameters: - zero_value – zero value to reduce into
- func – Two parameter function. First parameter is value to be accumulated into result. Second parameter is the current result
Returns: value from folding values with f into zero_value
-
fold_right
(zero_value, func)¶ Takes a zero_value and performs a reduction to a value using f. f should take two parameters, 1) the value to accumulate into the result and 2) the current result. Elements are folded right to left.
>>> seq('a', 'bc', 'de', 'f', 'm', 'nop').fold_right("Start:", lambda v, curr: curr + 2 * v) 'Start:nopnopmmffdedebcbcaa'
Parameters: - zero_value – zero value to reduce into
- func – Two parameter function. First parameter is value to be accumulated into result. Second parameter is the current result
Returns: value from folding values with f into zero_value
:rtype FunctionalSequence
-
for_all
(func)¶ Returns True if all elements in sequence make f evaluate to True.
>>> seq([1, 2, 3]).for_all(lambda x: x > 0) True
>>> seq([1, 2, -1]).for_all(lambda x: x > 0) False
Parameters: func – function to check truth value of all elements with Returns: True if all elements make f evaluate to True
-
for_each
(func)¶ Executes f on each element of the sequence.
>>> l = [] >>> seq([1, 2, 3, 4]).for_each(l.append) >>> l [1, 2, 3, 4]
Parameters: func – function to execute Returns: None
-
group_by
(func)¶ Group elements into a list of (Key, Value) tuples where f creates the key and maps to values matching that key.
>>> seq(["abc", "ab", "z", "f", "qw"]).group_by(len) [(1, ['z', 'f']), (2, ['ab', 'qw']), (3, ['abc'])]
Parameters: func – group by result of this function Returns: grouped sequence :rtype FunctionalSequence
-
group_by_key
()¶ Group sequence of (Key, Value) elements by Key.
>>> seq([('a', 1), ('b', 2), ('b', 3), ('b', 4), ('c', 3), ('c', 0)]).group_by_key() [('a', [1]), ('c', [3, 0]), ('b', [2, 3, 4])]
Returns: sequence grouped by key :rtype FunctionalSequence
-
grouped
(size)¶ Partitions the elements into groups of length size.
>>> seq([1, 2, 3, 4, 5, 6, 7, 8]).grouped(2) [[1, 2], [3, 4], [5, 6], [7, 8]]
>>> seq([1, 2, 3, 4, 5, 6, 7, 8]).grouped(3) [[1, 2, 3], [4, 5, 6], [7, 8]]
The last partition will be at least of size 1 and no more than length size :param size: size of the partitions :return: sequence partitioned into groups of length size :rtype FunctionalSequence
-
head
()¶ Returns the first element of the sequence.
>>> seq([1, 2, 3]).head() 1
Raises IndexError when the sequence is empty.
>>> seq([]).head() Traceback (most recent call last): ... IndexError: list index out of range
Returns: first element of sequence
-
head_option
()¶ Returns the first element of the sequence or None, if the sequence is empty.
>>> seq([1, 2, 3]).head_option() 1
>>> seq([]).head_option() None
Returns: first element of sequence or None if sequence is empty
-
init
()¶ Returns the sequence, without its last element.
>>> seq([1, 2, 3]).init() [1, 2]
Returns: sequence without last element :rtype FunctionalSequence
-
inits
()¶ Returns consecutive inits of the sequence.
>>> seq([1, 2, 3]).inits() [[1, 2, 3], [1, 2], [1], []]
Returns: consecutive init()s on sequence :rtype FunctionalSequence
-
inner_join
(other)¶ Sequence and other must be composed of (Key, Value) pairs. If self.sequence contains (K, V) pairs and other contains (K, W) pairs, the return result is a sequence of (K, (V, W)) pairs. Will return only elements where the key exists in both sequences.
>>> seq([('a', 1), ('b', 2), ('c', 3)]).inner_join([('a', 2), ('c', 5)]) [('a', (1, 2)), ('c', (3, 5))]
Parameters: other – sequence to join with Returns: joined sequence of (K, (V, W)) pairs :rtype FunctionalSequence
-
intersection
(other)¶ New sequence with unique elements present in sequence and other.
>>> seq([1, 1, 2, 3]).intersection([2, 3, 4]) [2, 3]
Parameters: other – sequence to perform intersection with Returns: intersection of sequence and other :rtype FunctionalSequence
-
join
(other, join_type='inner')¶ Sequence and other must be composed of (Key, Value) pairs. If self.sequence contains (K, V) pairs and other contains (K, W) pairs, the return result is a sequence of (K, (V, W)) pairs. If join_type is “left”, V values will always be present, W values may be present or None. If join_type is “right”, W values will always be present, W values may be present or None. If join_type is “outer”, V or W may be present or None, but never at the same time.
>>> seq([('a', 1), ('b', 2), ('c', 3)]).join([('a', 2), ('c', 5)], "inner") [('a', (1, 2)), ('c', (3, 5))]
>>> seq([('a', 1), ('b', 2), ('c', 3)]).join([('a', 2), ('c', 5)]) [('a', (1, 2)), ('c', (3, 5))]
>>> seq([('a', 1), ('b', 2)]).join([('a', 3), ('c', 4)], "left") [('a', (1, 3)), ('b', (2, None)]
>>> seq([('a', 1), ('b', 2)]).join([('a', 3), ('c', 4)], "right") [('a', (1, 3)), ('c', (None, 4)]
>>> seq([('a', 1), ('b', 2)]).join([('a', 3), ('c', 4)], "outer") [('a', (1, 3)), ('b', (2, None)), ('c', (None, 4))]
Parameters: - other – sequence to join with
- join_type – specifies join_type, may be “left”, “right”, or “outer”
Returns: side joined sequence of (K, (V, W)) pairs
:rtype FunctionalSequence
-
last
()¶ Returns the last element of the sequence.
>>> seq([1, 2, 3]).last() 3
Raises IndexError when the sequence is empty.
>>> seq([]).last() Traceback (most recent call last): ... IndexError: list index out of range
Returns: last element of sequence
-
last_option
()¶ Returns the last element of the sequence or None, if the sequence is empty.
>>> seq([1, 2, 3]).last_option() 3
>>> seq([]).last_option() None
Returns: last element of sequence or None if sequence is empty
-
left_join
(other)¶ Sequence and other must be composed of (Key, Value) pairs. If self.sequence contains (K, V) pairs and other contains (K, W) pairs, the return result is a sequence of (K, (V, W)) pairs. V values will always be present, W values may be present or None.
>>> seq([('a', 1), ('b', 2)]).join([('a', 3), ('c', 4)]) [('a', (1, 3)), ('b', (2, None)]
Parameters: other – sequence to join with Returns: left joined sequence of (K, (V, W)) pairs :rtype FunctionalSequence
-
len
()¶ Return length of sequence using its length function.
>>> seq([1, 2, 3]).len() 3
Returns: length of sequence
-
list
()¶ Converts sequence to list of elements.
>>> type(seq([]).list()) list
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([1, 2, 3]).list() [1, 2, 3]
Returns: list of elements in sequence
-
make_string
(separator)¶ Concatenate the elements of the sequence into a string separated by separator.
>>> seq([1, 2, 3]).make_string("@") '1@2@3'
Parameters: separator – string separating elements in string Returns: concatenated string separated by separator
-
map
(f)¶ Maps f onto the elements of the sequence.
>>> seq([1, 2, 3, 4]).map(lambda x: x * -1) [-1, -2, -3, -4]
Parameters: f – function to map with Returns: sequence with f mapped onto it :rtype FunctionalSequence
-
max
()¶ Returns the largest element in the sequence. If the sequence has multiple maximal elements, only the first one is returned.
The compared objects must have defined comparison methods. Raises TypeError when the objects are not comparable.
The sequence can not be empty. Raises ValueError when the sequence is empty.
>>> seq([2, 4, 5, 1, 3]).max() 5
>>> seq('aa', 'xyz', 'abcd', 'xyy').max() 'xyz'
>>> seq([1, "a"]).max() Traceback (most recent call last): ... TypeError: unorderable types: int() < str()
>>> seq([]).max() Traceback (most recent call last): ... ValueError: max() arg is an empty sequence
-
max_by
(func)¶ Returns the largest element in the sequence. Provided function is used to generate key used to compare the elements. If the sequence has multiple maximal elements, only the first one is returned.
The sequence can not be empty. Raises ValueError when the sequence is empty.
>>> seq([2, 4, 5, 1, 3]).max_by(lambda num: num % 4) 3
>>> seq('aa', 'xyz', 'abcd', 'xyy').max_by(len) 'abcd'
>>> seq([]).max_by(lambda x: x) Traceback (most recent call last): ... ValueError: max() arg is an empty sequence
-
min
()¶ Returns the smallest element in the sequence. If the sequence has multiple minimal elements, only the first one is returned.
The compared objects must have defined comparison methods. Raises TypeError when the objects are not comparable.
The sequence can not be empty. Raises ValueError when the sequence is empty.
>>> seq([2, 4, 5, 1, 3]).min() 1
>>> seq('aa', 'xyz', 'abcd', 'xyy').min() 'aa'
>>> seq([1, "a"]).min() Traceback (most recent call last): ... TypeError: unorderable types: int() < str()
>>> seq([]).min() Traceback (most recent call last): ... ValueError: min() arg is an empty sequence
-
min_by
(func)¶ Returns the smallest element in the sequence. Provided function is used to generate key used to compare the elements. If the sequence has multiple minimal elements, only the first one is returned.
The sequence can not be empty. Raises ValueError when the sequence is empty.
>>> seq([2, 4, 5, 1, 3]).min_by(lambda num: num % 6) 5
>>> seq('aa', 'xyz', 'abcd', 'xyy').min_by(len) 'aa'
>>> seq([]).min_by(lambda x: x) Traceback (most recent call last): ... ValueError: min() arg is an empty sequence
-
non_empty
()¶ Returns True if the sequence does not have length zero.
>>> seq([]).non_empty() False
>>> seq([1]).non_empty() True
Returns: True if sequence length is not zero
-
outer_join
(other)¶ Sequence and other must be composed of (Key, Value) pairs. If self.sequence contains (K, V) pairs and other contains (K, W) pairs, the return result is a sequence of (K, (V, W)) pairs. One of V or W will always be not None, but the other may be None
>>> seq([('a', 1), ('b', 2)]).outer_join([('a', 3), ('c', 4)], "outer") [('a', (1, 3)), ('b', (2, None)), ('c', (None, 4))]
Parameters: other – sequence to join with Returns: outer joined sequence of (K, (V, W)) pairs :rtype FunctionalSequence
-
partition
(func)¶ Partition the sequence based on satisfying the predicate f.
>>> seq([-1, 1, -2, 2]).partition(lambda x: x < 0) ([-1, -2], [1, 2])
Parameters: func – predicate to partition on Returns: tuple of partitioned sequences :rtype FunctionalSequence
-
product
()¶ Takes product of elements in sequence.
>>> seq([1, 2, 3, 4]).product() 24
>>> seq([]).product() 1
Returns: product of elements in sequence
-
reduce
(func)¶ Reduce sequence of elements using f.
>>> seq([1, 2, 3]).reduce(lambda x, y: x + y) 6
Parameters: func – two parameter, associative reduce function Returns: reduced value using f :rtype FunctionalSequence
-
reduce_by_key
(func)¶ Reduces a sequence of (Key, Value) using f on each Key.
>>> seq([('a', 1), ('b', 2), ('b', 3), ('b', 4), ('c', 3), ('c', 0)]) .reduce_by_key(lambda x, y: x + y) [('a', 1), ('c', 3), ('b', 9)]
Parameters: func – reduce each list of values using two parameter, associative f Returns: Sequence of tuples where the value is reduced with f :rtype FunctionalSequence
-
reverse
()¶ Returns the reversed sequence.
>>> seq([1, 2, 3]).reverse() [3, 2, 1]
Returns: reversed sequence :rtype FunctionalSequence
-
right_join
(other)¶ Sequence and other must be composed of (Key, Value) pairs. If self.sequence contains (K, V) pairs and other contains (K, W) pairs, the return result is a sequence of (K, (V, W)) pairs. W values will always bepresent, V values may be present or None.
>>> seq([('a', 1), ('b', 2)]).join([('a', 3), ('c', 4)]) [('a', (1, 3)), ('b', (2, None)]
Parameters: other – sequence to join with Returns: right joined sequence of (K, (V, W)) pairs :rtype FunctionalSequence
-
sequence
¶
-
set
()¶ Converts sequence to a set of elements.
>>> type(seq([])).to_set() set
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([1, 1, 2, 2]).set() {1, 2}
:return:set of elements in sequence
-
size
()¶ Return size of sequence using its length function.
Returns: size of sequence
-
slice
(start, until)¶ Takes a slice of the sequence starting at start and until but not including until.
>>> seq([1, 2, 3, 4]).slice(1, 2) [2] >>> seq([1, 2, 3, 4]).slice(1, 3) [2, 3]
Parameters: - start – starting index
- until – ending index
Returns: slice including start until but not including until
:rtype FunctionalSequence
-
sorted
(key=None, reverse=False)¶ Uses python sort and its passed arguments to sort the input.
>>> seq([2, 1, 4, 3]).sorted() [1, 2, 3, 4]
Parameters: - key –
- reverse – return list reversed or not
Returns: sorted sequence
:rtype FunctionalSequence
-
sum
()¶ Takes sum of elements in sequence.
>>> seq([1, 2, 3, 4]).sum() 10
Returns: sum of elements in sequence
-
symmetric_difference
(other)¶ New sequence with elements in either sequence or other, but not both.
>>> seq([1, 2, 3, 3]).symmetric_difference([2, 4, 5]) [1, 3, 4, 5]
Parameters: other – sequence to perform symmetric difference with Returns: symmetric difference of sequence and other :rtype FunctionalSequence
-
tail
()¶ Returns the sequence, without its first element.
>>> seq([1, 2, 3]).init() [2, 3]
Returns: sequence without first element :rtype FunctionalSequence
-
tails
()¶ Returns consecutive tails of the sequence.
>>> seq([1, 2, 3]).tails() [[1, 2, 3], [2, 3], [3], []]
Returns: consecutive tail()s of the sequence :rtype FunctionalSequence
-
take
(n)¶ Take the first n elements of the sequence.
>>> seq([1, 2, 3, 4]).take(2) [1, 2]
Parameters: n – number of elements to take Returns: first n elements of sequence :rtype FunctionalSequence
-
take_while
(func)¶ Take elements in the sequence until f evaluates to False, then return them.
>>> seq([1, 2, 3, 4, 5, 1, 2]).take_while(lambda x: x < 3) [1, 2]
Parameters: func – truth returning function Returns: elements taken until f evaluates to False :rtype FunctionalSequence
-
to_dict
()¶ Converts sequence of (Key, Value) pairs to a dictionary.
>>> type(seq([('a', 1)]).to_dict()) dict
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([('a', 1), ('b', 2)]).to_dict() {'a': 1, 'b': 2}
Returns: dictionary from sequence of (Key, Value) elements
-
to_list
()¶ Converts sequence to list of elements.
>>> type(seq([]).to_list()) list
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([1, 2, 3]).to_list() [1, 2, 3]
Returns: list of elements in sequence
-
to_set
()¶ Converts sequence to a set of elements.
>>> type(seq([])).to_set() set
>>> type(seq([])) functional.chain.FunctionalSequence
>>> seq([1, 1, 2, 2]).to_set() {1, 2}
:return:set of elements in sequence
-
union
(other)¶ New sequence with unique elements from self.sequence and other.
>>> seq([1, 1, 2, 3, 3]).union([1, 4, 5]) [1, 2, 3, 4, 5]
Parameters: other – sequence to union with Returns: union of sequence and other :rtype FunctionalSequence
-
zip
(sequence)¶ Zips the stored sequence with the given sequence.
>>> seq([1, 2, 3]).zip([4, 5, 6]) [(1, 4), (2, 5), (3, 6)]
Parameters: sequence – second sequence to zip Returns: stored sequence zipped with given sequence :rtype FunctionalSequence
-
zip_with_index
()¶ Zips the sequence to its index, with the index being the first element of each tuple.
>>> seq(['a', 'b', 'c']).zip_with_index() [(0, 'a'), (1, 'b'), (2, 'c')]
Returns: sequence zipped to its index :rtype FunctionalSequence
-
-
functional.chain.
seq
(*args)¶ Alias function for creating a new FunctionalSequence. Additionally it also parses various types of input to a FunctionalSequence as best it can.
>>> type(seq([1, 2])) functional.chain.FunctionalSequence
>>> type(FunctionalSequence([1, 2])) functional.chain.FunctionalSequence
>>> seq([1, 2, 3]) [1, 2, 3]
>>> seq(1, 2, 3) [1, 2, 3]
>>> seq(1) [1]
>>> seq(range(4)) [0, 1, 2, 3]
Parameters: args – Three types of arguments are valid. 1) Iterable which is then directly wrapped as a FunctionalSequence 2) A list of arguments is converted to a FunctionalSequence 3) A single non-iterable is converted to a single element FunctionalSequence :rtype FunctionalSequence :return: wrapped sequence
Module contents¶
Package which supplies utilities primarily through functional.seq to do pipeline style, functional transformations and reductions.