[关闭]
@bergus 2015-12-18T11:13:37.000000Z 字数 17610 阅读 2014

pipetools类库代码研究

pipetools 代码分析

heyhapqqnqepzquj

最近研究了一下pipetools的代码,附上作者的github:https://github.com/0101/pipetools
pipetools是一个python类库,他能够让你通过管道符链式的方式给函数传递参数,比如:

  1. f = pipe | list | foreach("{0}=={0}")
  2. print f("1112342snfjfbjeryehbsa")
  4. #再简单一点的方式是:
  5. print (pipe | list | foreach("{0}=={0}"))("1112342snfjfbjeryehbsa")
  7. #又或者是:
  8. print "1112342snfjfbjeryehbsa" > pipe | list | foreach("{0}=={0}")
  9. #这种传参数方式比传统的要直观,方便,容易书写
copy一点小东西

函数对象

在python当中一切皆对象，函数也不例外，也具有属性（可用dir()查询）。作为对象，它还可以赋值给其它对象名，或者作为参数传递。
搬砖地址是：http://www.cnblogs.com/cnshen/p/3684863.html

  1. #lambda函数
  2. func = lambda x,y: x + y
  3. print func(3,4)
  4. #lambda生成一个函数对象。该函数参数为x,y，返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
  5. #以上定义可以写成以下形式：
  6. def func(x, y):
  7.     return x + y
  10. #函数作为参数传递
  11. #函数可以作为一个对象，进行参数传递。函数名(比如func)即该对象。比如说:
  12. def test(f, a, b):
  13.     print 'test'
  14.     print f(a, b)
  16. test(func, 3, 5)
  17. #test函数的第一个参数f就是一个函数对象。将func传递给f，test中的f()就拥有了func()的功能。
  18. #我们因此可以提高程序的灵活性。可以使用上面的test函数，带入不同的函数参数。比如:
  19. test((lambda x,y: x**2 + y), 6, 9)
  21. #函数作为返回结果
  22. #函数是一个对象，所以可以作为某个函数的返回结果。
  23. def line_conf():
  24.     def line(x):
  25.         return 2*x+1
  26.     return line       # return a function object
  28. my_line = line_conf()
  29. print(my_line(5))
  30. #其实，这也就是传说中的闭包
  33. #闭包与并行运算
  34. '''
  35. 闭包有效的减少了函数所需定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下，我们可以让每台电脑负责一个函数，然后将一台电脑的输出和下一台电脑的输入串联起来。最终，我们像流水线一样工作，从串联的电脑集群一端输入数据，从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。
  37. 并行运算正称为一个热点。这也是函数式编程又热起来的一个重要原因。函数式编程早在1950年代就已经存在，但应用并不广泛。然而，我们上面描述的流水线式的工作并行集群过程，正适合函数式编程。由于函数式编程这一天然优势，越来越多的语言也开始加入对函数式编程范式的支持。
  38. '''

partial函数

  1. #局部函数应用，又称偏函数
  2. #我的简单理解是functools.partial函数通过两次传递参数的方式计算被传递函数对象的结果，比如：
  3. def hello(x,y,z,w):
  4.     return 12
  5. print partial(hello)(1,2,3,4) == 12
  6. print partial(hello,1)(2,3,4) == 12
  7. print partial(hello,1,2)(3,4) == 12
  8. print partial(hello1,2,3,4)() == 12
  10. #具体的实现搬个砖：http://blog.csdn.net/largetalk/article/details/6612342
  11. def partial(func, *args, **keywords):  
  12.     def newfunc(*fargs, **fkeywords):  
  13.         newkeywords = keywords.copy()  
  14.         newkeywords.update(fkeywords)  
  15.         return func(*(args + fargs), **newkeywords)  
  16.     newfunc.func = func  
  17.     newfunc.args = args  
  18.     newfunc.keywords = keywords  
  19.     return newfunc  
在pipetools文件夹中有五个主要的python文件,咱们一个一个的分析起作用

debug.py文件

  1. # encoding=utf-8
  2. from itertools import imap, chain
  4. def set_name(name, f):
  5.     '''
  6.     给f函数对象增加一个名字为__pipetools__name__值为name的属性
  7.     :param name:
  8.     :param f:
  9.     :return:
  11.     >>> set_name("hello",lambda x:x).__pipetools__name__
  12.     'hello'
  13.     '''
  15.     try:
  16.         f.__pipetools__name__ = name
  17.     except (AttributeError, UnicodeEncodeError):
  18.         pass
  19.     return f
  22. def get_name(f):
  23.     '''
  24.     返回f函数对象的标识名
  25.     返回值是字符串
  26.     :param f:
  27.     :return:
  28.     '''
  29.     from pipetools.main import Pipe
  31.     pipetools_name = getattr(f, '__pipetools__name__', None)
  32.     if pipetools_name: #如果__pipetools__name__属性存在，那么f是函数对象或者函数
  33.         return pipetools_name() if callable(pipetools_name) else pipetools_name
  35.     if isinstance(f, Pipe):
  36.         return repr(f)
  38.     return f.__name__ if hasattr(f, '__name__') else repr(f)
  41. def repr_args(*args, **kwargs):
  42.     '''
  43.     返回列表和字典参数的字符串形式
  44.     :param args:
  45.     :param kwargs:
  46.     :return:
  48.     >>> repr_args(2, 3, 21, 4, 5, name=2234, ii='ffff')
  49.     "2, 3, 21, 4, 5, ii='ffff', name=2234"
  50.     '''
  51.     return ', '.join(chain( #chain连接多个迭代器为一个
  52.         imap('{0!r}'.format, args),
  53.         imap('{0[0]}={0[1]!r}'.format, kwargs.iteritems())))

ds_builder.py

  1. # encoding=utf-8
  3. from functools import partial
  4. from pipetools.main import XObject, StringFormatter
  6. class NoBuilder(ValueError):
  7.     pass
  9. def DSBuilder(definition):
  10.     '''
  11.     definition是一个可转换迭代器
  12.     可转换迭代器是让一个序列或者字典经过其他函数处理后可迭代
  13.     :param definition:
  14.     :return:
  15.     '''
  17.     builder = select_builder(definition)
  18.     if builder:
  19.         return builder(definition)
  20.     raise NoBuilder("Don't know how to build %s" % type(definition))
  23. def SequenceBuilder(cls, definition):
  24.     '''
  25.     把definition里面的可求值元素转换成其对应的函数
  26.     可求值元素是能够让里面的元素经过转换,变成一个能够传递参数的函数
  27.     而ds_item返回的是一个值,故而整体返回值是一个lambda包含着的cls类型的序列
  28.     :param cls:
  29.     :param definition:
  30.     :return:
  31.     '''
  32.     return lambda x: cls(ds_item(d, x) for d in definition)
  35. def DictBuilder(definition):
  36.     return lambda x: dict(
  37.         (ds_item(key_def, x), ds_item(val_def, x))
  38.         for key_def, val_def in definition.iteritems())
  39. '''
  40. 定义了三种构造器,列表,元组,字典构造器
  41. 定义构造器的目的是让列表,元组,字典里面的特殊元素转化成正常的元素
  42. 根据前面partial的介绍简单理解一下下面字典的作用，SequenceBuilder是一个有两个参数的函数，partial(SequenceBuilder, tuple)(data)得到计算结果，相当于tuple(data),也就是说partial(SequenceBuilder, tuple)是对tuple的封装，作用和tuple是一样的，封装的目的是处理data中复杂的数据结构
  43. '''
  44. builders = {
  45.     tuple: partial(SequenceBuilder, tuple),
  46.     list: partial(SequenceBuilder, list),
  47.     dict: DictBuilder,
  48. }
  51. def select_builder(definition):
  52.     '''
  53.     根据definition的类型,返回其对应的构造转换器，也就是上面builders中的value
  54.     :param definition:
  55.     :return:
  56.     '''
  57.     for cls, builder in builders.iteritems():
  58.         if isinstance(definition, cls):
  59.             return builder
  62. def ds_item(definition, data):
  63.     '''
  64.     根据definition的类型转换成其对应的函数,然后根据data参数值返回处理后的结果
  65.     简而言之,该函数的结果是值,不是函数对象
  66.     :param definition:
  67.     :param data:
  68.     :return:
  69.     '''
  70.     if isinstance(definition, XObject):
  71.         return (~definition)(data)
  72.     if isinstance(definition, basestring):
  73.         return StringFormatter(definition)(data)
  74.     if callable(definition):
  75.         return definition(data)
  76.     try:
  77.         return DSBuilder(definition)(data)
  78.     except NoBuilder:
  79.         # static item
  80.         return definition

decorators.py

  1. # encoding=utf-8
  3. import re
  4. from functools import partial, wraps
  5. from pipetools.debug import repr_args, set_name, get_name
  6. from pipetools.ds_builder import DSBuilder, NoBuilder
  7. from pipetools.main import pipe, XObject, StringFormatter, xpartial
  10. def pipe_util(func):
  11.     """
  12.     装饰器装饰函数func之后，然后让其返回一个函数对象pipe_util_wrapper
  13.     pipe_util_wrapper函数的首参数为函数，返回值是一个Pipe对象
  15.     被装饰者的首参数就是pipe_util_wrapper的首参数
  17.     """
  19.     @wraps(func)
  20.     def pipe_util_wrapper(function, *args, **kwargs):
  21.         if isinstance(function, XObject):
  22.             function = ~function
  24.         original_function = function
  26.         if args or kwargs:
  27.             function = xpartial(function, *args, **kwargs)
  29.         name = lambda: '%s(%s)' % (get_name(func), ', '.join(
  30.             filter(None, (get_name(original_function), repr_args(*args, **kwargs)))))
  32.         f = func(function) #被装饰者的返回值
  34.         result = pipe | set_name(name, f) #把被装饰者的返回值封装成一个Pipe对象
  36.         # if the util defines an 'attrs' mapping, copy it as attributes
  37.         # to the result
  38.         attrs = getattr(f, 'attrs', {})
  39.         for k, v in attrs.iteritems():
  40.             setattr(result, k, v)
  42.         # result是一个拥有f函数的Pipe对象
  43.         return result
  45.     return pipe_util_wrapper
  48. def auto_string_formatter(func):
  49.     """
  50.     把含有格式化的字符串转化成该字符串的格式化函数形式
  52.     """
  53.     @wraps(func)
  54.     def auto_string_formatter_wrapper(function, *args, **kwargs):
  55.         if isinstance(function, basestring):
  56.             function = StringFormatter(function) #StringFormatter的返回值类似于"{0}".format
  58.         return func(function, *args, **kwargs)
  59.     return auto_string_formatter_wrapper
  62. def data_structure_builder(func):
  63.     """
  64.     装饰器处理元素中包含特殊数据结构的元组，列表，字典等
  65.     """
  67.     @wraps(func)
  68.     def ds_builder_wrapper(function, *args, **kwargs):
  69.         try:
  70.             function = DSBuilder(function)
  71.         except NoBuilder:
  72.             pass
  73.         return func(function, *args, **kwargs)
  75.     return ds_builder_wrapper
  78. def regex_condition(func):
  79.     """
  80.     If a condition is given as string instead of a function, it is turned
  81.     into a regex-matching function.
  82.     """
  84.     @wraps(func)
  85.     def regex_condition_wrapper(condition, *args, **kwargs):
  86.         if isinstance(condition, basestring):
  87.             condition = partial(re.match, condition)
  88.         return func(condition, *args, **kwargs)
  90.     return regex_condition_wrapper

utils.py

  1. from functools import partial
  2. from itertools import imap, ifilter, islice, takewhile, dropwhile
  3. import operator
  5. from pipetools.debug import set_name, repr_args, get_name
  6. from pipetools.decorators import data_structure_builder, regex_condition
  7. from pipetools.decorators import pipe_util, auto_string_formatter
  8. from pipetools.main import pipe, X, _iterable
  10. KEY, VALUE = X[0], X[1]
  13. @pipe_util
  14. @auto_string_formatter
  15. @data_structure_builder
  16. def foreach(function):
  17.     """
  18.     Returns a function that takes an iterable and returns an iterator over the
  19.     results of calling `function` on each item of the iterable.
  21.     >>> xrange(5) > foreach(factorial) | list
  22.     [1, 1, 2, 6, 24]
  24.     >>> "1234567assfsd" > foreach("{0}") | list
  25.     [u'1', u'2', u'3', u'4', u'5', u'6', u'7', u'a', u's', u's', u'f', u's', u'd']
  27.     >>> "123455dHHJBHJgg" > foreach(X.lower()) | list
  28.     ['1', '2', '3', '4', '5', '5', 'd', 'h', 'h', 'j', 'b', 'h', 'j', 'g', 'g']
  30.     >>> "12BHJgg" > foreach(("{0}","{0}==")) | list
  31.     [(u'1', u'1=='), (u'2', u'2=='), (u'B', u'B=='), (u'H', u'H=='), (u'J', u'J=='), (u'g', u'g=='), (u'g', u'g==')]
  33.     >>> "12BHJgg" > foreach([X,X.upper()]) | list
  34.     [['1', '1'], ['2', '2'], ['B', 'B'], ['H', 'H'], ['J', 'J'], ['g', 'G'], ['g', 'G']]
  36.     >>> "12BHJgg" > foreach({X:X.upper()}) | list
  37.     [{'1': '1'}, {'2': '2'}, {'B': 'B'}, {'H': 'H'}, {'J': 'J'}, {'g': 'G'}, {'g': 'G'}]
  39.     """
  40.     return partial(imap, function)
  42. @pipe_util
  43. def foreach_do(function):
  44.     """
  45.     foreach除了返回一个迭代器什么都不会执行
  46.     foreach_do马上就会被执行，如果你只是想马上看到结果，不考虑性能等副作用的话，它很适合你
  48.     >>> xrange(5) > foreach_do(factorial) | foreach_do(X+3)
  49.     [4, 4, 5, 9, 27]
  51.     >>> "12332dffrrr" > foreach_do(X.upper())
  52.     ['1', '2', '3', '3', '2', 'D', 'F', 'F', 'R', 'R', 'R']
  53.     """
  54.     return lambda iterable: [function(item) for item in iterable]
  56. @pipe_util
  57. @regex_condition
  58. def where(condition):
  59.     """
  60.     Pipe-able lazy filter.
  62.     >>> odd_range = xrange | where(X % 2) | list
  63.     >>> odd_range(10)
  64.     [1, 3, 5, 7, 9]
  66.     """
  67.     return partial(ifilter, condition)
  70. @pipe_util
  71. @regex_condition
  72. def where_not(condition):
  73.     """
  74.     Inverted :func:`where`.
  75.     """
  76.     return partial(ifilter, pipe | condition | operator.not_)
  79. @pipe_util
  80. @data_structure_builder
  81. def sort_by(function):
  82.     """
  83.     Sorts an incoming sequence by using the given `function` as key.
  85.     >>> xrange(10) > sort_by(-X)
  86.     [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  88.     Supports automatic data-structure creation::
  90.         users > sort_by([X.last_name, X.first_name])
  92.     There is also a shortcut for ``sort_by(X)`` called ``sort``:
  94.     >>> [4, 5, 8, -3, 0] > sort
  95.     [-3, 0, 4, 5, 8]
  97.     And (as of ``0.2.3``) a shortcut for reversing the sort:
  99.     >>> 'asdfaSfa' > sort_by(X.lower()).descending
  100.     ['s', 'S', 'f', 'f', 'd', 'a', 'a', 'a']
  101.     """
  102.     f = partial(sorted, key=function)
  103.     f.attrs = {'descending': _descending_sort_by(function)}
  104.     return f
  107. @pipe_util
  108. def _descending_sort_by(function):
  109.     return partial(sorted, key=function, reverse=True)
  112. sort = sort_by(X)
  115. @pipe_util
  116. @auto_string_formatter
  117. @data_structure_builder
  118. def debug_print(function):
  119.     """
  120.     Prints function applied on input and returns the input.
  122.     ::
  124.         foo = (pipe
  125.             | something
  126.             | debug_print(X.get_status())
  127.             | something_else
  128.             | foreach(debug_print("attr is: {0.attr}"))
  129.             | etc)
  130.     """
  132.     def debug(thing):
  133.         print function(thing)
  134.         return thing
  136.     return debug
  139. @pipe_util
  140. def as_args(function):
  141.     """
  142.     Applies the sequence in the input as positional arguments to `function`.
  144.     ::
  146.         some_lists > as_args(izip)
  147.     """
  148.     return lambda x: function(*x)
  151. @pipe_util
  152. def as_kwargs(function):
  153.     """
  154.     Applies the dictionary in the input as keyword arguments to `function`.
  155.     """
  156.     return lambda x: function(**x)
  159. def take_first(count):
  160.     """
  161.     Assumes an iterable on the input, returns an iterable with first `count`
  162.     items from the input (or possibly less, if there isn't that many).
  164.     >>> xrange(9000) > where(X % 100 == 0) | take_first(5) | tuple
  165.     (0, 100, 200, 300, 400)
  167.     """
  169.     def _take_first(iterable):
  170.         return islice(iterable, count)
  172.     return pipe | set_name('take_first(%s)' % count, _take_first)
  175. def drop_first(count):
  176.     """
  177.     Assumes an iterable on the input, returns an iterable with identical items
  178.     except for the first `count`.
  180.     >>> xrange(10) > drop_first(5) | tuple
  181.     (5, 6, 7, 8, 9)
  182.     """
  184.     def _drop_first(iterable):
  185.         g = (x for x in xrange(1, count + 1))
  186.         return dropwhile(lambda i: unless(StopIteration, g.next)(), iterable)
  188.     return pipe | set_name('drop_first(%s)' % count, _drop_first)
  191. def unless(exception_class_or_tuple, func, *args, **kwargs):
  192.     """
  193.     When `exception_class_or_tuple` occurs while executing `func`, it will
  194.     be caught and ``None`` will be returned.
  196.     >>> f = where(X > 10) | list | unless(IndexError, X[0])
  197.     >>> f([5, 8, 12, 4])
  198.     12
  199.     >>> f([1, 2, 3])
  200.     None
  201.     """
  203.     @pipe_util
  204.     @auto_string_formatter
  205.     @data_structure_builder
  206.     def construct_unless(function):
  207.         # a wrapper so we can re-use the decorators
  208.         def _unless(*args, **kwargs):
  209.             try:
  210.                 return function(*args, **kwargs)
  211.             except exception_class_or_tuple:
  212.                 pass
  214.         return _unless
  216.     name = lambda: 'unless(%s, %s)' % (exception_class_or_tuple, ', '.join(
  217.         filter(None, (get_name(func), repr_args(*args, **kwargs)))))
  219.     return set_name(name, construct_unless(func, *args, **kwargs))
  222. @pipe_util
  223. @regex_condition
  224. def select_first(condition):
  225.     """
  226.     Returns first item from input sequence that satisfies `condition`. Or
  227.     ``None`` if none does.
  229.     >>> ['py', 'pie', 'pi'] > select_first(X.startswith('pi'))
  230.     'pie'
  232.     As of ``0.2.1`` you can also
  233.     :ref:`directly use regular expressions <auto-regex>` and write the above
  234.     as:
  236.     >>> ['py', 'pie', 'pi'] > select_first('^pi')
  237.     'pie'
  239.     There is also a shortcut for ``select_first(X)`` called ``first_of``:
  241.     >>> first_of(['', None, 0, 3, 'something'])
  242.     3
  243.     >>> first_of([])
  244.     None
  245.     """
  246.     return where(condition) | unless(StopIteration, X.next())
  249. first_of = select_first(X)
  252. @pipe_util
  253. @auto_string_formatter
  254. @data_structure_builder
  255. def group_by(function):
  256.     """
  257.     Groups input sequence by `function`.
  259.     Returns an iterator over a sequence of tuples where the first item is a
  260.     result of `function` and the second one a list of items matching this
  261.     result.
  263.     Ordering of the resulting iterator is undefined, but ordering of the items
  264.     in the groups is preserved.
  266.     >>> [1, 2, 3, 4, 5, 6] > group_by(X % 2) | list
  267.     [(0, [2, 4, 6]), (1, [1, 3, 5])]
  268.     """
  270.     def _group_by(seq):
  271.         result = {}
  272.         for item in seq:
  273.             result.setdefault(function(item), []).append(item)
  274.         return result.iteritems()
  276.     return _group_by
  279. def _flatten(x):
  280.     if not _iterable(x):
  281.         yield x
  282.     else:
  283.         for y in x:
  284.             for z in _flatten(y):
  285.                 yield z
  288. def flatten(*args):
  289.     """
  290.     Flattens an arbitrarily deep nested iterable(s).
  291.     """
  292.     return _flatten(args)
  295. flatten = pipe | flatten
  298. def count(iterable):
  299.     """
  300.     Returns the number of items in `iterable`.
  301.     """
  302.     return sum(1 for whatever in iterable)
  305. count = pipe | count
  308. @pipe_util
  309. @regex_condition
  310. def take_until(condition):
  311.     """
  312.     >>> [1, 4, 6, 4, 1] > take_until(X > 5) | list
  313.     [1, 4]
  314.     """
  315.     return partial(takewhile, pipe | condition | operator.not_)

main.py

  1. # encoding=utf-8
  2. from collections import Iterable
  3. from functools import partial, wraps
  5. from pipetools.debug import get_name, set_name, repr_args
  8. class Pipe(object):
  9.     """
  10.     Pipe-style combinator.
  12.     Example::
  14.         p = pipe | F | G | H
  16.         p(x) == H(G(F(x)))
  18.     """
  20.     def __init__(self, func=None):
  21.         self.func = func
  22.         self.__name__ = 'Pipe'
  24.     def __str__(self):
  25.         return get_name(self.func)
  27.     __repr__ = __str__
  29.     @staticmethod
  30.     def compose(first, second):
  31.         name = lambda: '{0} | {1}'.format(get_name(first), get_name(second))
  33.         def composite(*args, **kwargs):
  34.             return second(first(*args, **kwargs))
  36.         return set_name(name, composite)
  38.     @classmethod
  39.     def bind(cls, first, second):
  40.         return cls(cls.compose(first, second) if all([first, second]) else first or second)
  42.     def __or__(self, next_func):
  43.         return self.bind(self.func, prepare_function_for_pipe(next_func))
  45.     def __ror__(self, prev_func):
  46.         return self.bind(prepare_function_for_pipe(prev_func), self.func)
  48.     def __lt__(self, thing):
  49.         return self.func(thing) if self.func else thing
  51.     def __call__(self, *args, **kwargs):
  52.         return self.func(*args, **kwargs)
  54.     def __get__(self, instance, owner):
  55.         return partial(self, instance) if instance else self
  58. pipe = Pipe()
  61. class Maybe(Pipe):
  62.     @staticmethod
  63.     def compose(first, second):
  64.         name = lambda: '{0} ?| {1}'.format(get_name(first), get_name(second))
  66.         def composite(*args, **kwargs):
  67.             result = first(*args, **kwargs)
  68.             return None if result is None else second(result)
  70.         return set_name(name, composite)
  72.     def __call__(self, *args, **kwargs):
  73.         if len(args) == 1 and args[0] is None and not kwargs:
  74.             return None
  75.         return self.func(*args, **kwargs)
  77.     def __lt__(self, thing):
  78.         return (
  79.             None if thing is None else
  80.             self.func(thing) if self.func else
  81.             thing)
  84. maybe = Maybe()
  87. def prepare_function_for_pipe(thing):
  88.     if isinstance(thing, XObject):
  89.         return ~thing
  90.     if isinstance(thing, tuple):
  91.         return xpartial(*thing)
  92.     if isinstance(thing, basestring):
  93.         return StringFormatter(thing)
  94.     if callable(thing):
  95.         return thing
  96.     raise ValueError('Cannot pipe %s' % thing)
  99. def StringFormatter(template):
  100.     '''
  101.     把一个字符串转化为一个带有format格式的函数
  102.     content是格式化字符串的参数
  103.     :param template:
  104.     :return:
  105.     '''
  106.     f = unicode(template).format
  108.     def _format(content):
  109.         if isinstance(content, dict):
  110.             return f(**content)
  111.         if _iterable(content):
  112.             return f(*content)
  113.         return f(content)
  115.     return set_name(lambda: "format('%s')" % template[:20], _format)
  118. def _iterable(obj):
  119.     "Iterable but not a string"
  120.     return isinstance(obj, Iterable) and not isinstance(obj, basestring)
  123. class XObject(object):
  124.     def __init__(self, func=None):
  125.         self._func = func
  126.         set_name(lambda: get_name(func) if func else 'X', self)
  128.     def __repr__(self):
  129.         return get_name(self)
  131.     def __invert__(self):
  132.         return self._func or set_name('X', lambda x: x)
  134.     def bind(self, name, func):
  135.         set_name(name, func)
  136.         return XObject((self._func | func) if self._func else (pipe | func))
  138.     def __call__(self, *args, **kwargs):
  139.         name = lambda: 'X(%s)' % repr_args(*args, **kwargs)
  140.         return self.bind(name, lambda x: x(*args, **kwargs))
  142.     def __eq__(self, other):
  143.         return self.bind(lambda: 'X == {0!r}'.format(other), lambda x: x == other)
  145.     def __getattr__(self, name):
  146.         return self.bind(lambda: 'X.{0}'.format(name), lambda x: getattr(x, name))
  148.     def __getitem__(self, item):
  149.         return self.bind(lambda: 'X[{0!r}]'.format(item), lambda x: x[item])
  151.     def __gt__(self, other):
  152.         return self.bind(lambda: 'X > {0!r}'.format(other), lambda x: x > other)
  154.     def __ge__(self, other):
  155.         return self.bind(lambda: 'X >= {0!r}'.format(other), lambda x: x >= other)
  157.     def __lt__(self, other):
  158.         return self.bind(lambda: 'X < {0!r}'.format(other), lambda x: x < other)
  160.     def __le__(self, other):
  161.         return self.bind(lambda: 'X <= {0!r}'.format(other), lambda x: x <= other)
  163.     def __mod__(self, y):
  164.         return self.bind(lambda: 'X % {0!r}'.format(y), lambda x: x % y)
  166.     def __ne__(self, other):
  167.         return self.bind(lambda: 'X != {0!r}'.format(other), lambda x: x != other)
  169.     def __neg__(self):
  170.         return self.bind(lambda: '-X', lambda x: -x)
  172.     def __mul__(self, other):
  173.         return self.bind(lambda: 'X * {0!r}'.format(other), lambda x: x * other)
  175.     def __div__(self, other):
  176.         return self.bind(lambda: 'X / {0!r}'.format(other), lambda x: x / other)
  178.     def __add__(self, other):
  179.         return self.bind(lambda: 'X + {0!r}'.format(other), lambda x: x + other)
  181.     def __sub__(self, other):
  182.         return self.bind(lambda: 'X - {0!r}'.format(other), lambda x: x - other)
  184.     def __pow__(self, other):
  185.         return self.bind(lambda: 'X ** {0!r}'.format(other), lambda x: x ** other)
  187.     def __ror__(self, func):
  188.         return pipe | func | self
  190.     def __or__(self, func):
  191.         if isinstance(func, Pipe):
  192.             return func.__ror__(self)
  193.         return pipe | self | func
  195.     def _in_(self, y):
  196.         return self.bind(lambda: 'X._in_({0!r})'.format(y), lambda x: x in y)
  199. X = XObject()
  202. def xpartial(func, *xargs, **xkwargs):
  203.     """
  204.     Like :func:`functools.partial`, but can take an :class:`XObject`
  205.     placeholder that will be replaced with the first positional argument
  206.     when the partially applied function is called.
  208.     Useful when the function's positional arguments' order doesn't fit your
  209.     situation, e.g.:
  211.     >>> reverse_range = xpartial(range, X, 0, -1)
  212.     >>> reverse_range(5)
  213.     [5, 4, 3, 2, 1]
  215.     It can also be used to transform the positional argument to a keyword
  216.     argument, which can come in handy inside a *pipe*::
  218.         xpartial(objects.get, id=X)
  220.     Also the XObjects are evaluated, which can be used for some sort of
  221.     destructuring of the argument::
  223.         xpartial(somefunc, name=X.name, number=X.contacts['number'])
  225.     Lastly, unlike :func:`functools.partial`, this creates a regular function
  226.     which will bind to classes (like the ``curry`` function from
  227.     ``django.utils.functional``).
  228.     """
  229.     any_x = any(isinstance(a, XObject)
  230.                 for a in xargs + tuple(xkwargs.values()))
  231.     use = lambda x, value: (~x)(value) if isinstance(x, XObject) else x
  233.     @wraps(func)
  234.     def xpartially_applied(*func_args, **func_kwargs):
  235.         if any_x:
  236.             if not func_args:
  237.                 raise ValueError('Function "%s" partially applied with an '
  238.                                  'X placeholder but called with no positional arguments.'
  239.                                  % get_name(func))
  240.             first = func_args[0]
  241.             rest = func_args[1:]
  242.             args = tuple(use(x, first) for x in xargs) + rest
  243.             kwargs = dict((k, use(x, first)) for k, x in xkwargs.iteritems())
  244.             kwargs.update(func_kwargs)
  245.         else:
  246.             args = xargs + func_args
  247.             kwargs = dict(xkwargs, **func_kwargs)
  248.         return func(*args, **kwargs)
  250.     name = lambda: '%s(%s)' % (get_name(func), repr_args(*xargs, **xkwargs))
  251.     return set_name(name, xpartially_applied)
  254. if __name__ == '__main__':
  255.     f = 'ggggcdwecfwefhweejhjwq' > pipe | list | ','.join
  256.     print f
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注