API Documentation — PyFunctional 1.3.0 documentation (original) (raw)

PyFunctional

Streams API¶

The streams API enables you to read data into PyFunctional. The seq function imported withfrom functional import seq is actually an instance of functional.streams.Stream. Therefore, all the methods available on seq such as seq.csv are documented in the Streams class.

class functional.streams. ParallelStream(processes=None, partition_size=None, disable_compression=False, no_wrap=None)[source]¶

Bases: functional.streams.Stream

Parallelized version of functional.streams.Stream normally accessible as pseq

class functional.streams. Stream(disable_compression=False, max_repr_items=100, no_wrap=None)[source]¶

Bases: object

Represents and implements a stream which separates the responsibilities of Sequence and ExecutionEngine.

An instance of Stream is normally accessed as seq

csv(csv_file, dialect='excel', **fmt_params)[source]¶

Reads and parses the input of a csv stream or file.

csv_file can be a filepath or an object that implements the iterator interface (defines next() or __next__() depending on python version).

seq.csv('examples/camping_purchases.csv').take(2) [['1', 'tent', '300'], ['2', 'food', '100']]

csv_dict_reader(csv_file, fieldnames=None, restkey=None, restval=None, dialect='excel', **kwds)[source]¶

json(json_file)[source]¶

Reads and parses the input of a json file handler or file.

Json files are parsed differently depending on if the root is a dictionary or an array.

1. If the json’s root is a dictionary, these are parsed into a sequence of (Key, Value) pairs

2. If the json’s root is an array, these are parsed into a sequence of entries

seq.json('examples/users.json').first() [u'sarah', {u'date_created': u'08/08', u'news_email': True, u'email': u'sarah@gmail.com'}]

jsonl(jsonl_file)[source]¶

Reads and parses the input of a jsonl file stream or file.

Jsonl formatted files must have a single valid json value on each line which is parsed by the python json module.

seq.jsonl('examples/chat_logs.jsonl').first() {u'date': u'10/09', u'message': u'hello anyone there?', u'user': u'bob'}

open(path, delimiter=None, mode='r', buffering=-1, encoding=None, errors=None, newline=None)[source]¶

Reads and parses input files as defined.

If delimiter is not None, then the file is read in bulk then split on it. If it is None (the default), then the file is parsed as sequence of lines. The rest of the options are passed directly to builtins.open with the exception that write/append file modes is not allowed.

seq.open('examples/gear_list.txt').take(1) [u'tent\n']

range(*args)[source]¶

Alias to range function where seq.range(args) is equivalent to seq(range(args)).

seq.range(1, 8, 2) [1, 3, 5, 7]

sqlite3(conn, sql, parameters=None, *args, **kwargs)[source]¶

Reads input by querying from a sqlite database.

seq.sqlite3('examples/users.db', 'select id, name from users where id = 1;').first() [(1, 'Tom')]

Transformations and Actions API¶

The pipeline module contains the transformations and actions API of PyFunctional

class functional.pipeline. Sequence(sequence, transform=None, engine=None, max_repr_items=None, no_wrap=None)[source]¶

Bases: object

Sequence is a wrapper around any type of sequence which provides access to common functional transformations and reductions in a data pipeline style

accumulate(func=)[source]¶

Accumulate sequence of elements using func. API mirrors itertools.accumulate

seq([1, 2, 3]).accumulate(lambda x, y: x + y) [1, 3, 6]

seq(['a', 'b', 'c']).accumulate() ['a', 'ab', 'abc']

aggregate(*args)[source]¶

Aggregates the sequence by specified arguments. Its behavior varies depending on if one, two, or three arguments are passed. Assuming the type of the sequence is A:

One Argument: argument specifies a function of the type f(current: B, next: A => result: B. current represents results computed so far, and next is the next element to aggregate into current in order to return result.

Two Argument: the first argument is the seed value for the aggregation. The second argument is the same as for the one argument case.

Three Argument: the first two arguments are the same as for one and two argument calls. The additional third parameter is a function applied to the result of the aggregation before returning the value.

all()[source]¶

Returns True if the truth value of all items in the sequence true.

seq([True, True]).all() True

seq([True, False]).all() False

any()[source]¶

Returns True if any element in the sequence has truth value True

seq([True, False]).any() True

seq([False, False]).any() False

average(projection=None)[source]¶

Takes the average of elements in the sequence

seq([1, 2]).average() 1.5

seq([('a', 1), ('b', 2)]).average(lambda x: x[1])

cache(delete_lineage=False)[source]¶

Caches the result of the Sequence so far. This means that any functions applied on the pipeline before cache() are evaluated, and the result is stored in the Sequence. This is primarily used internally and is no more helpful than to_list() externally. delete_lineage allows for cache() to be used in internal initialization calls without the caller having knowledge of the internals via the lineage

cartesian(*iterables, **kwargs)[source]¶

Returns the cartesian product of the passed iterables with the specified number of repetitions.

The keyword argument repeat is read from kwargs to pass to itertools.cartesian.

seq.range(2).cartesian(range(2)) [(0, 0), (0, 1), (1, 0), (1, 1)]

count(func)[source]¶

Counts the number of elements in the sequence which satisfy the predicate func.

seq([-1, -2, 1, 2]).count(lambda x: x > 0) 2

count_by_key()[source]¶

Reduces a sequence of (Key, Value) by counting each key

seq([('a', 1), ('b', 2), ('b', 3), ('b', 4), ('c', 3), ('c', 0)]).count_by_key() [('a', 1), ('b', 3), ('c', 2)] :return: Sequence of tuples where value is the count of each key

count_by_value()[source]¶

Reduces a sequence of items by counting each unique item

seq(['a', 'a', 'a', 'b', 'b', 'c', 'd']).count_by_value() [('a', 3), ('b', 2), ('c', 1), ('d', 1)] :return: Sequence of tuples where value is the count of each key

dict(default=None)[source]¶

Converts sequence of (Key, Value) pairs to a dictionary.

type(seq([('a', 1)]).dict()) dict

seq([('a', 1), ('b', 2)]).dict() {'a': 1, 'b': 2}

difference(other)[source]¶

New sequence with unique elements present in sequence but not in other.

seq([1, 2, 3]).difference([2, 3, 4]) [1]

distinct()[source]¶

Returns sequence of distinct elements. Elements must be hashable.

seq([1, 1, 2, 3, 3, 3, 4]).distinct() [1, 2, 3, 4]

distinct_by(func)[source]¶

Returns sequence of elements who are distinct by the passed function. The return value of func must be hashable. When two elements are distinct by func, the first is taken.

drop(n)[source]¶

Drop the first n elements of the sequence.

seq([1, 2, 3, 4, 5]).drop(2) [3, 4, 5]

drop_right(n)[source]¶

Drops the last n elements of the sequence.

seq([1, 2, 3, 4, 5]).drop_right(2) [1, 2, 3]

drop_while(func)[source]¶

Drops elements in the sequence while func 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]

empty()[source]¶

Returns True if the sequence has length zero.

seq([1]).empty() False

enumerate(start=0)[source]¶

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')]

exists(func)[source]¶

Returns True if an element in the sequence makes func 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

filter(func)[source]¶

Filters sequence to include only elements where func is True.

seq([-1, 1, -2, 2]).filter(lambda x: x > 0) [1, 2]

filter_not(func)[source]¶

Filters sequence to include only elements where func is False.

seq([-1, 1, -2, 2]).filter_not(lambda x: x > 0) [-1, -2]

find(func)[source]¶

Finds the first element of the sequence that satisfies func. If no such element exists, then return None.

seq(["abc", "ab", "bc"]).find(lambda x: len(x) == 2) 'ab'

first(no_wrap=None)[source]¶

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

flat_map(func)[source]¶

Applies func 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]

flatten()[source]¶

Flattens a sequence of sequences to a single sequence of elements.

seq([[1, 2], [3, 4], [5, 6]]) [1, 2, 3, 4, 5, 6]

fold_left(zero_value, func)[source]¶

Assuming that the sequence elements are of type A, folds from left to right starting with the seed value given by zero_value (of type A) using a function of type func(current: B, next: A) => B. current represents the folded value so far and next is the next element from the sequence to fold into current.

seq('a', 'b', 'c').fold_left(['start'], lambda current, next: current + [next])) ['start', 'a', 'b', 'c']

fold_right(zero_value, func)[source]¶

Assuming that the sequence elements are of type A, folds from right to left starting with the seed value given by zero_value (of type A) using a function of type func(next: A, current: B) => B. current represents the folded value so far and next is the next element from the sequence to fold into current.

seq('a', 'b', 'c').fold_left(['start'], lambda next, current: current + [next]) ['start', 'c', 'b', a']

for_all(func)[source]¶

Returns True if all elements in sequence make func 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

for_each(func)[source]¶

Executes func on each element of the sequence.

l = [] seq([1, 2, 3, 4]).for_each(l.append) l [1, 2, 3, 4]

group_by(func)[source]¶

Group elements into a list of (Key, Value) tuples where func 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'])]

group_by_key()[source]¶

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])]

grouped(size)[source]¶

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 has at least one element but may have less than size elements.

head(no_wrap=None)[source]¶

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

head_option(no_wrap=None)[source]¶

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

init()[source]¶

Returns the sequence, without its last element.

seq([1, 2, 3]).init() [1, 2]

inits()[source]¶

Returns consecutive inits of the sequence.

seq([1, 2, 3]).inits() [[1, 2, 3], [1, 2], [1], []]

inner_join(other)[source]¶

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))]

intersection(other)[source]¶

New sequence with unique elements present in sequence and other.

seq([1, 1, 2, 3]).intersection([2, 3, 4]) [2, 3]

join(other, join_type='inner')[source]¶

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))]

last(no_wrap=None)[source]¶

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

last_option(no_wrap=None)[source]¶

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

left_join(other)[source]¶

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)]

len()[source]¶

Return length of sequence using its length function.

seq([1, 2, 3]).len() 3

list(n=None)[source]¶

Converts sequence to list of elements.

type(seq([]).list()) list

type(seq([])) functional.pipeline.Sequence

seq([1, 2, 3]).list() [1, 2, 3]

make_string(separator)[source]¶

Concatenate the elements of the sequence into a string separated by separator.

seq([1, 2, 3]).make_string("@") '1@2@3'

map(func)[source]¶

Maps f onto the elements of the sequence.

seq([1, 2, 3, 4]).map(lambda x: x * -1) [-1, -2, -3, -4]

max()[source]¶

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)[source]¶

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()[source]¶

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)[source]¶

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()[source]¶

Returns True if the sequence does not have length zero.

seq([]).non_empty() False

seq([1]).non_empty() True

order_by(func)[source]¶

Orders the input according to func

seq([(2, 'a'), (1, 'b'), (4, 'c'), (3, 'd')]).order_by(lambda x: x[0]) [1, 2, 3, 4]

outer_join(other)[source]¶

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))]

partition(func)[source]¶

Partition the sequence based on satisfying the predicate func.

seq([-1, 1, -2, 2]).partition(lambda x: x < 0) ([-1, -2], [1, 2])

peek(func)[source]¶

Executes func on each element of the sequence and returns the element

seq([1, 2, 3, 4]).peek(print).map(lambda x: x ** 2).to_list() 1 2 3 4 [1, 4, 9, 16]

product(projection=None)[source]¶

Takes product of elements in sequence.

seq([1, 2, 3, 4]).product() 24

seq([(1, 2), (1, 3), (1, 4)]).product(lambda x: x[0]) 1

reduce(func, *initial)[source]¶

Reduce sequence of elements using func. API mirrors functools.reduce

seq([1, 2, 3]).reduce(lambda x, y: x + y) 6

reduce_by_key(func)[source]¶

Reduces a sequence of (Key, Value) using func on each sequence of values.

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)]

reverse()[source]¶

Returns the reversed sequence.

seq([1, 2, 3]).reverse() [3, 2, 1]

right_join(other)[source]¶

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)]

select(func)[source]¶

Selects f from the elements of the sequence.

seq([1, 2, 3, 4]).select(lambda x: x * -1) [-1, -2, -3, -4]

sequence¶

Alias for to_list used internally for brevity

set()[source]¶

Converts sequence to a set of elements.

type(seq([])).to_set() set

type(seq([])) functional.pipeline.Sequence

seq([1, 1, 2, 2]).set() {1, 2}

:return:set of elements in sequence

show(n=10, headers=(), tablefmt='simple', floatfmt='g', numalign='decimal', stralign='left', missingval='')[source]¶

Pretty print first n rows of sequence as a table. Seehttps://bitbucket.org/astanin/python-tabulate for details on tabulate parameters

size()[source]¶

Return size of sequence using its length function.

slice(start, until)[source]¶

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]

sliding(size, step=1)[source]¶

Groups elements in fixed size blocks by passing a sliding window over them.

The last window has at least one element but may have less than size elements

smap(func)[source]¶

Alias to Sequence.starmap

starmaps f onto the sequence as itertools.starmap does.

seq([(2, 3), (-2, 1), (0, 10)]).smap(lambda x, y: x + y) [5, -1, 10]

sorted(key=None, reverse=False)[source]¶

Uses python sort and its passed arguments to sort the input.

seq([2, 1, 4, 3]).sorted() [1, 2, 3, 4]

starmap(func)[source]¶

starmaps f onto the sequence as itertools.starmap does.

seq([(2, 3), (-2, 1), (0, 10)]).starmap(lambda x, y: x + y) [5, -1, 10]

sum(projection=None)[source]¶

Takes sum of elements in sequence.

seq([1, 2, 3, 4]).sum() 10

seq([(1, 2), (1, 3), (1, 4)]).sum(lambda x: x[0]) 3

symmetric_difference(other)[source]¶

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]

tabulate(n=None, headers=(), tablefmt='simple', floatfmt='g', numalign='decimal', stralign='left', missingval='')[source]¶

Return pretty string table of first n rows of sequence or everything if n is None. Seehttps://bitbucket.org/astanin/python-tabulate for details on tabulate parameters

tail()[source]¶

Returns the sequence, without its first element.

seq([1, 2, 3]).tail() [2, 3]

tails()[source]¶

Returns consecutive tails of the sequence.

seq([1, 2, 3]).tails() [[1, 2, 3], [2, 3], [3], []]

take(n)[source]¶

Take the first n elements of the sequence.

seq([1, 2, 3, 4]).take(2) [1, 2]

take_while(func)[source]¶

Take elements in the sequence until func evaluates to False, then return them.

seq([1, 2, 3, 4, 5, 1, 2]).take_while(lambda x: x < 3) [1, 2]

to_csv(path, mode='wt', dialect='excel', compression=None, newline='', **fmtparams)[source]¶

Saves the sequence to a csv file. Each element should be an iterable which will be expanded to the elements of each row.

to_dict(default=None)[source]¶

Converts sequence of (Key, Value) pairs to a dictionary.

type(seq([('a', 1)]).to_dict()) dict

seq([('a', 1), ('b', 2)]).to_dict() {'a': 1, 'b': 2}

to_file(path, delimiter=None, mode='wt', buffering=-1, encoding=None, errors=None, newline=None, compresslevel=9, format=None, check=-1, preset=None, filters=None, compression=None)[source]¶

Saves the sequence to a file by executing str(self) which becomes str(self.to_list()). If delimiter is defined will instead execute self.make_string(delimiter)

to_json(path, root_array=True, mode='wt', compression=None)[source]¶

Saves the sequence to a json file. If root_array is True, then the sequence will be written to json with an array at the root. If it is False, then the sequence will be converted from a sequence of (Key, Value) pairs to a dictionary so that the json root is a dictionary.

to_jsonl(path, mode='wb', compression=None)[source]¶

Saves the sequence to a jsonl file. Each element is mapped using json.dumps then written with a newline separating each element.

to_list(n=None)[source]¶

Converts sequence to list of elements.

type(seq([]).to_list()) list

type(seq([])) functional.pipeline.Sequence

seq([1, 2, 3]).to_list() [1, 2, 3]

to_pandas(columns=None)[source]¶

Converts sequence to a pandas DataFrame using pandas.DataFrame.from_records

to_set()[source]¶

Converts sequence to a set of elements.

type(seq([])).to_set() set

type(seq([])) functional.pipeline.Sequence

seq([1, 1, 2, 2]).to_set() {1, 2}

:return:set of elements in sequence

to_sqlite3(conn, target, *args, **kwargs)[source]¶

Saves the sequence to sqlite3 database. Target table must be created in advance. The table schema is inferred from the elements in the sequence if only target table name is supplied.

seq([(1, 'Tom'), (2, 'Jack')]) .to_sqlite3('users.db', 'INSERT INTO user (id, name) VALUES (?, ?)')

seq([{'id': 1, 'name': 'Tom'}, {'id': 2, 'name': 'Jack'}]).to_sqlite3(conn, 'user')

union(other)[source]¶

New sequence with unique elements from self and other.

seq([1, 1, 2, 3, 3]).union([1, 4, 5]) [1, 2, 3, 4, 5]

where(func)[source]¶

Selects elements where func evaluates to True.

seq([-1, 1, -2, 2]).where(lambda x: x > 0) [1, 2]

zip(sequence)[source]¶

Zips the stored sequence with the given sequence.

seq([1, 2, 3]).zip([4, 5, 6]) [(1, 4), (2, 5), (3, 6)]

zip_with_index(start=0)[source]¶

Zips the sequence to its index, with the index being the second element of each tuple.

seq(['a', 'b', 'c']).zip_with_index() [('a', 0), ('b', 1), ('c', 2)]

functional.pipeline. extend(func=None, aslist=False, final=False, name=None, parallel=False)[source]¶

Function decorator for adding new methods to the Sequence class.

@extend() def zip2(it): return [(i,i) for i in it]

seq.range(3).zip2() [(0, 0), (1, 1), (2, 2)]

@extend(aslist=True) def zip2(it): return zip(it,it)

seq.range(3).zip2() [(0, 0), (1, 1), (2, 2)]

@extend(final=True) def make_set(it): return set(it)

r = seq([0,1,1]).make_set() r {0, 1}

type(r) <class 'set'>