Metadata-Version: 1.1
Name: funclib
Version: 2.1.4
Summary: A data processing methods lib of python
Home-page: https://github.com/CN-Tower/FuncLib
Author: CN-Tower
Author-email: 247114045@qq.com
License: BSD License
Description: # FuncLib
        > A data processing methods lib for Python(2/3)
        ```
        Author: @CN-Tower
        Version: 2.1.4
        Create At: 2018-2-2
        Update At: 2018-7-9
        ```
        ## Quick Start
        ```
        $ pip install funclib
        $ python
        >>> from funclib import fn
        >>> fn.help()
        ```
        ## Methods
         * [fn.index   ](#fnindex)
         * [fn.find    ](#fnfind)
         * [fn.filter  ](#fnfilter)
         * [fn.reject  ](#fnreject)
         * [fn.reduce  ](#fnreduce)
         * [fn.contains](#fncontains)
         * [fn.flatten ](#fnflatten)
         * [fn.each    ](#fneach)
         * [fn.uniq    ](#fnuniq)
         * [fn.pluck   ](#fnpluck)
         * [fn.pick    ](#fnpick)
         * [fn.every   ](#fnevery)
         * [fn.some    ](#fnsome)
         * [fn.list    ](#fnlist)
         * [fn.drop    ](#fndrop)
         * [fn.dump    ](#fndump)
         * [fn.clone   ](#fnclone)
         * [fn.test    ](#fntest)
         * [fn.replace ](#fnreplace)
         * [fn.iscan   ](#fniscan)
         * [fn.log     ](#fnlog)
         * [fn.timer   ](#fntimer)
         * [fn.now     ](#fnnow)
         * [fn.help    ](#fnhelp)
        ## Document
        ### fn.index
        ```
            Looks through the list and returns the item index. If no match is found,
            or if list is empty, -1 will be returned.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 12},
                    {"name": "Jerry", "age": 20},
                    {"name": "Mary", "age": 35}]
        
                Jerry_idx = fn.index({"name": 'Jerry'}, persons)
                Mary_idx  = fn.index(lambda x: x['name'] == 'Mary', persons)
        
                print(Jerry_idx)  # => 1
                print(Mary_idx)   # => 2
        
        ```
        ### fn.find
        ```
            Looks through each value in the list, returning the first one that passes
            a truth test (predicate), or None.If no value passes the test the function
            returns as soon as it finds an acceptable element, and doesn't traverse
            the entire list.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 12},
                    {"name": "Jerry", "age": 20},
                    {"name": "Mary", "age": 35}]
        
                Jerry = fn.find({"name": 'Jerry'}, persons)
                Mary  = fn.find(lambda x: x['name'] == 'Mary', persons)
        
                print(Jerry)  # => {'age': 20, 'name': 'Jerry'}
                print(Mary)   # => {'age': 35, 'name': 'Mary'}
        
        ```
        ### fn.filter
        ``` 
            Looks through each value in the list, returning an array of all the values that
            pass a truth test (predicate).
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 20},
                           {"name": "Jerry", "age": 20},
                           {"name": "Jerry", "age": 35}]
        
                Jerry = fn.filter({"age": 20}, persons)
                Mary = fn.filter(lambda x: x['name'] == 'Jerry', persons)
                print(Jerry)  # => [{'age': 20, 'name': 'Tom'}, {'age': 20, 'name': 'Jerry'}]
                print(Mary)   # => [{'age': 20, 'name': 'Jerry'}, {'age': 35, 'name': 'Jerry'}]
                
        ```
        ### fn.reject
        ``` 
            Returns the values in list without the elements that the truth test (predicate) passes.
            The opposite of filter.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 12},
                           {"name": "Jerry", "age": 20},
                           {"name": "Mary", "age": 35}]
        
                not_Mary = fn.reject({"name": "Mary"}, persons)
                adults = fn.reject(lambda x: x['age'] < 18, persons)
        
                print(not_Mary)  # => [{"age": 12, "name": "Tom"}, {"age": 20, "name": "Jerry"}]
                print(adults)    # => [{"age": 20, "name": "Jerry"}, {"age": 35, "name": "Mary"}]
        
        ```
        ### fn.reduce
        ```
            Returns the buildIn method 'reduce', in python 3 the 'reduce' is imported from functools.
            eg:
                from funclib import fn
                num_list = [1 , 2, 3, 4]
                print(fn.reduce(lambda a, b: a + b, num_list))  # => 10
        
        ```
        ### fn.contains
        ```
            Returns true if the value is present in the list.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 12},
                           {"name": "Jerry", "age": 20},
                           {"name": "Mary", "age": 35}]
        
                is_contains_Jerry = fn.contains({"name": "Jerry", "age": 12}, persons)
                is_contains_Mary = fn.contains(lambda x: x['name'] == 'Mary', persons)
        
                print(is_contains_Jerry)  # => False
                print(is_contains_Mary)   # => True
        
        ```
        ### fn.flatten
        ```
            Flattens a nested array (the nesting can be to any depth). If you pass shallow,
            the array will only be flattened a single level.
            eg:
                from funclib import fn
                flt_list_01 = fn.flatten([1, [2], [3, [[4]]]])
                flt_list_02 = fn.flatten([1, [2], [3, [[4]]]], True)
                print (flt_list_01)  # => [1, 2, 3, [[4]]]
                print (flt_list_02)  # => [1, 2, 3, 4];
        
        ```
        ### fn.each
        ```
            Produces a new values list by mapping each value in list through a transformation
            function (iteratee).
            eg:
                from funclib import fn
                num_list = [1 , 2, 3, 4]
                list_10 = fn.each(lambda x: x % 2, num_list)
                print(list_10)  #=> [1, 0, 1, 0]
        
        ```
        ### fn.uniq
        ```
            Produces a duplicate-free version of the array.
            In particular only the first occurence of each value is kept.
            eg:
                from funclib import fn
                persons00 = ("Tom", "Tom", "Jerry")
                persons01 = ["Tom", "Tom", "Jerry"]
                demo_list = [False, [], False, True, [], {}, False, '']
                persons02 = [{"name": "Tom", "age": 12, "pet": {"species": "dog", "name": "Kitty"}},
                             {"name": "Tom", "age": 20, "pet": {"species": "cat", "name": "wang"}},
                             {"name": "Mary", "age": 35, "pet": {"species": "cat", "name": "mimi"}}]
                             
                unique_persons00 = fn.uniq(persons00)
                unique_persons01 = fn.uniq(persons01)
                unique_demo_list = fn.uniq(demo_list)
                unique_name = fn.uniq(persons02, 'name')
                unique_pet = fn.uniq(persons02, 'pet', 'species')
                
                print(unique_persons00)  # => ["Jerry", "Tom"]
                print(unique_persons01)  # => ["Jerry", "Tom"]
                print(unique_demo_list)  # => [False, [], True, {}, '']
                
        ```
        ### fn.pluck
        ```
            Pluck the collections element.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "hobbies": ["sing", "running"]},
                    {"name": "Jerry", "hobbies": []},
                    {"name": "Mary", "hobbies": ['hiking', 'sing']}]
        
                hobbies = fn.pluck(persons, 'hobbies')
                hobbies_uniq = fn.pluck(persons, 'hobbies', uniq=True)
        
                print(hobbies)      # => ["sing", "running", 'hiking', 'sing']
                print(hobbies_uniq) # => ["sing", "running", 'hiking']
        
        ```
        ### fn.pick
        ```
            Pick values form dict or list.
            eg:
                from funclib import fn
                Tom = {
                    "name": "Tom",
                    "age": 12,
                    "pets": [
                        {"species": "dog", "name": "Kitty"},
                        {"species": "cat", "name": "mimi"}
                    ]
                }
                pets = fn.pick(Tom, 'age')
                first_pet_species = fn.pick(Tom, 'pets', [0], 'species')
                find_mimi_species = fn.pick(Tom, 'pets', {'name': 'mimi'}, 'species')
                find_dog_name = fn.pick(Tom, 'pets', lambda x: x['species'] == 'dog', 'name')
                print(pets)               # => 12
                print(first_pet_species)  # => dog
                print(find_mimi_species)  # => cat
                print(find_dog_name)      # => Kitty
                    
        ```
        ### fn.every
        ```
            Returns true if all of the values in the list pass the predicate truth test.
            Short-circuits and stops traversing the list if a false element is found.
            eg:
                from funclib import fn
                num_list = [1, 1, 2, 3, 5, 8]
                persons = [{"name": "Tom", "age": 12, "sex": "m"},
                           {"name": "Jerry", "age": 20, "sex": "m"},
                           {"name": "Mary", "age": 35, "sex": "f"}]
        
                is_all_five = fn.every(5, num_list)
                is_all_male = fn.every({"sex": "m"}, persons)
                is_all_adult = fn.every(lambda x: x['age'] > 18, persons)
                print(is_all_five)   # => False
                print(is_all_male)   # => False
                print(is_all_adult)  # => False
        
        ```
        ### fn.some
        ```
            Returns true if any of the values in the list pass the predicate truth test.
            Short-circuits and stops traversing the list if a true element is found.
            eg:
                from funclib import fn
                num_list = [1, 1, 2, 3, 5, 8]
                persons = [{"name": "Tom", "age": 12, "sex": "m"},
                           {"name": "Jerry", "age": 20, "sex": "m"},
                           {"name": "Mary", "age": 35, "sex": "f"}]
        
                is_any_five = fn.some(5, num_list)
                is_any_male = fn.some({"sex": "m"}, persons)
                is_any_adult = fn.some(lambda x: x['age'] > 18, persons)
                print(is_any_five)   # => True
                print(is_any_male)   # => True
                print(is_any_adult)  # => True
        
        ```
        ### fn.list
        ```
            Return now system time.
            eg:
                from funclib import fn
                print(fn.list())       # => []
                print(fn.list([]))     # => []
                print(fn.list({}))     # => [{}]
                print(fn.list(None))   # => [None]
                print(fn.list('test')) # => ['test']
        
        ```
        ### fn.drop
        ```
            Delete false values expect 0.
            eg:
                from funclib import fn
                tmp_list = [0, '', 3, None, [], {}, ['Yes'], 'Test']
                drop_val = fn.drop(tmp_list)
                without_0 = fn.drop(tmp_list, True)
        
                print(drop_val)  # => [3, ['Yes'], 'Test']
                print(without_0)  # => [0, 3, ['Yes'], 'Test']
        
        ```
        ### fn.dump
        ```
            Return a formatted json string.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "hobbies": ["sing", "running"]},
                    {"name": "Jerry", "hobbies": []}]
                print(fn.dump(persons)) #=>
                [
                  {
                    "hobbies": [
                      "sing",
                      "running"
                    ],
                    "name": "Tom"
                  },
                  {
                    "hobbies": [],
                    "name": "Jerry"
                  }
                ]
        
        ```
        ### fn.clone
        ```
            Create a deep-copied clone of the provided plain object.
            eg:
                from funclib import fn
                persons = [{"name": "Tom", "age": 12}, {"name": "Jerry", "age": 20}]
                persons_01 = persons
                persons_02 = fn.clone(persons)
                fn.find({'name': 'Tom'}, persons)['age'] = 18
                print(persons_01)  # => [{"name": "Tom", "age": 18}, {"name": "Jerry", "age": 20}]
                print(persons_02)  # => [{"name": "Tom", "age": 12}, {"name": "Jerry", "age": 20}]
        
        ```
        ### fn.test
        ```
            Check is the match successful, a boolean value will be returned.
            eg:
                from funclib import fn
                not_in = fn.test(r'ab', 'Hello World!')
                in_str = fn.test(r'll', 'Hello World!')
                print(not_in)  # => False
                print(in_str)  # => True
        
        ```
        ### fn.replace
        ```
            Replace sub string of the origin string with re.sub()
            eg:
                from funclib import fn
                greetings = 'Hello I\'m Tom!'
                print(fn.replace('Tom', 'Jack', greetings))  # => Hello I'm Jack!
        
        ```
        ### fn.iscan
        ```
            Test is the expression valid, a boolean value will be returned.
            eg:
                from funclib import fn
                print(fn.iscan("int('a')"))  # => False
                print(fn.iscan("int('5')"))  # => True
        
        ```
        ### fn.log
        ```
            Show log clear in console.
            eg:
                from funclib import fn
                fn.log([{"name": "Tom", "hobbies": ["sing", "running"]}, {"name": "Jerry", "hobbies": []}])
        
                # =>
                ===========================================================================
                                            FuncLib ( V2.0.8 )
                ---------------------------------------------------------------------------
                [
                  {
                    "hobbies": [
                      "sing",
                      "running"
                    ],
                    "name": "Tom"
                  },
                  {
                    "hobbies": [],
                    "name": "Jerry"
                  }
                ]
                ===========================================================================
        
        ```
        ### fn.timer
        ```
            Set a timer with interval and timeout limit.
            eg:
                from funclib import fn
                count = 0
                def fn():
                    global count
                    if count == 4:
                        return True
                    count += 1
                    print(count)
                fn.timer(fn, 10, 2)
                # =>
                    >>> 1  #at 0s
                    >>> 2  #at 2s
                    >>> 3  #at 4s
                    >>> 4  #at 4s
        
        ```
        ### fn.now
        ```
            Return now system time.
            eg:
                from funclib import fn
                print(fn.now()) # => '2018-2-1 19:32:10'
        
        ```
        ### fn.help
        ```
            Return the FuncLib or it's method doc
            eg:
                from funclib import fn
                fn.help('index')
                # =>
            ===========================================================================
                                    FuncLib ( V2.0.8 ) --> fn.index
            ---------------------------------------------------------------------------
                Looks through the list and returns the item index. If no match is found,
                or if list is empty, -1 will be returned.
                eg:
                    from funclib import fn
                    persons = [{"name": "Tom", "age": 12},
                        {"name": "Jerry", "age": 20},
                        {"name": "Mary", "age": 35}]
        
                    Jerry_idx = fn.index({"name": 'Jerry'}, persons)
                    Mary_idx  = fn.index(lambda x: x['name'] == 'Mary', persons)
        
                    print(Jerry_idx)  # => 1
                    print(Mary_idx)   # => 2
            ===========================================================================
        
        ```
        
Platform: all
Classifier: Development Status :: 4 - Beta
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: Implementation
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Topic :: Software Development :: Libraries
