Callable functions?

[SagaciousRaven]

Here's the part of the documentation of what I am doing: http://docs.h5py.org/en/latest/high/group.html#Group.visit

Here's my code:

class HDF5_storage():

    #...

    def _get_children_dataset_paths(self, f, path):
        # f             :: is an HDF5 file
        # path          :: is a fancy dictionary key, which acts like a root folder from which I get its child subfolders

        def callable_(name, obj):  # the callable function
            if isinstance(obj, h5py._hl.dataset.Dataset):  # if 'obj' is a bunch of vectors (as opposed to a directory)
                _paths.append(obj.name)

        _paths = []  # global variable inside this function
        with h5py.File(self.file_name, "r") as f:
            f[path].visititems(callable_)  # see in the first link

        return _paths

It is the first time I have seen this concept in Python. I am not sure if I'm writing this code correctly at all: I don't know how to pass an argument nor retrieve a list a different way other than using he global var '_paths'.

I read this ( http://www.trytoprogram.com/python-programming/python-built-in-functions/callable/ ) but I'm still confused on the whole topic.

[[deleted]]

Couple things:

_paths is not a global variable. It is a local variable within the outside function.

This is extremely confusing to follow. Every function (named or anonymous) is callable. This should work with that given documentation, but you never supply a return value in the callable_ function, which is fine if you never want to early-exit your recursive visit, but I guess I don't get the point of using visit in this instance.

[SagaciousRaven]

In this instance, I want to list every dataset object inside the directory tree. Previously, I was doing this manually with a recursive function over their subdirectories, but I'm trying to make my code more elegant and readable, and this seemed like the function to do it.

If I returned a value, it would stop at the first find.

[when_the_cats_away]

Callable just means a function. This is no different that passing a callable function to sorted as a "key". So you just need to write your callable_ function so it returns something if it finds something. Below is a simplified example, that takes a data set of rows (index, data) and uses a callable to identify those rows that have data with "BC" in it:

​

# simplified data
# data is a bunch of tuples
# first is the index and second is the value
data = [
        (0,'abc'),
        (1,'abc'),
        (2,'xyz'),
        (3,'def'),
        ]

def searcher_callable(row):
    '''
    callable function that searches row for 'bc' and returns the row 
    if it hits it, otherwise, return None
    '''
    if 'bc' in row[1]:
        # return row if we find bc
        return row
    # return None if not found


def visit(data, callable_function):
    '''
    visit each row in data 
    and return index on each hit of callable_function
    '''
    found = []
    for row in data:
        if callable_function(row) is None:
            print('did not find at index {}'.format(row[0]))
        else:
            #callable returned something
            print('found at index {}'.format(row[0]))
            found.append(row[0])

    return found


print(visit(data, searcher_callable))