在python中将函数链接为shell管道命令_Python_Function_Shell_Pipe

在python中将函数链接为shell管道命令

python function shell

在python中将函数链接为shell管道命令,python,function,shell,pipe,Python,Function,Shell,Pipe,在Unix/linux shell中，我们可以： seq 0 100 | head -10 | awk 'NF%2==0' | awk 'NF%2==1' | rev 现在我定义： seqsrc = list(range(0,100)) def all(src): return src def head(src, count, offset = 0): return src[:count] def tail(src, count, offset = 0): return src[-count

在Unix/linux shell中，我们可以：

seq 0 100 | head -10 | awk 'NF%2==0' | awk 'NF%2==1' | rev

现在我定义：

seqsrc = list(range(0,100))

def all(src): return src
def head(src, count, offset = 0): return src[:count]
def tail(src, count, offset = 0): return src[-count:]
def odd(src): return [x for x in src if x % 2 != 0]
def even(src): return [x for x in src if x % 2 == 0]
def reverse(src): return src[::1]
...
#def other_sequence_manpulation_method()

以下是我的问题：

一,。如何在python中获得类似shell管道的语法

seqdst = all(seqsrc).head(10).odd().even().reverse()

二,。出于某种原因，我想列举我定义的那些简单函数的所有可能组合，我可以使用itertools.product（）生成组合-EDIT:以及下面的Seq类解决方案吗

possible_head_limit = [10,20,30]

all(seqsrc).head(10)                    # 10 is one item in possible_head_limit
all(seqsrc).head(10).odd()
all(seqsrc).head(10).odd().even()
all(seqsrc).head(10).odd().even().reverse()
all(seqsrc).head(10).even()
all(seqsrc).head(10).even().odd()
....
all(seqsrc).head(20)                    # 20 is one item in possible_head_limit

all(seqsrc).head(20).odd()
...

3：假设

seqsrc=range（0,10）

那么

head（20）

可能会返回与

head（10）

相同的值，或者有时它是无意义的

all(seqsrc).head(20).odd().even().reverse()  
# = all(seqsrc).head(10).odd().even().reverse() 
# = all(seqsrc).head(11).odd().even().reverse()
# ...

我可以在方法链中添加控制函数，然后控制收益的平均值吗

ignore_insufficient(True).all(seqsrc).head(20).odd().even().reverse()
ignore_insufficient(False).all(seqsrc).head(20).odd().even().reverse()  # it will print some sort of error

# or even I can control each function I defined?
ignore_insufficient(True).all(seqsrc).\
ignore_insufficient(True).head(20).\
ignore_insufficient(False).tail(10)

谢谢

你的帖子中有很多问题，我不确定是否能全部理解。然而，这是一个起点

可链接方法通常通过使用返回类自身新实例的方法设计类来实现。这允许从以前方法的返回值调用更多方法

因此，您可以如下定义

Seq

类：

class Seq(object):
    def __init__(self, seq):
        self.seq = seq
    def __repr__(self):
        return repr(self.seq)
    def __str__(self):
        return str(self.seq)
    def all(self):
        return Seq(self.seq[:])
    def head(self, count):
        return Seq(self.seq[:count])
    def tail(self, count):
        return Seq(self.seq[-count:])
    def odd(self):
        return Seq(self.seq[1::2])
    def even(self):
        return Seq(self.seq[::2])
    def reverse(self):
        return Seq(self.seq[::-1])

然后像这样使用它：

>>> s = Seq(range(0, 100))
>>> print s.head(10).odd().even().reverse()
[9, 5, 1]

请注意，这可以在许多方面得到改进。例如，在Javascript世界中，可链接的方法实际上将其结果推送到堆栈中，从而允许在调用历史中回溯并恢复以前的上下文。详情请参阅。

您的帖子中有许多问题，我不确定是否能全部理解。然而，这是一个起点

可链接方法通常通过使用返回类自身新实例的方法设计类来实现。这允许从以前方法的返回值调用更多方法

因此，您可以如下定义

Seq

类：

class Seq(object):
    def __init__(self, seq):
        self.seq = seq
    def __repr__(self):
        return repr(self.seq)
    def __str__(self):
        return str(self.seq)
    def all(self):
        return Seq(self.seq[:])
    def head(self, count):
        return Seq(self.seq[:count])
    def tail(self, count):
        return Seq(self.seq[-count:])
    def odd(self):
        return Seq(self.seq[1::2])
    def even(self):
        return Seq(self.seq[::2])
    def reverse(self):
        return Seq(self.seq[::-1])

然后像这样使用它：

>>> s = Seq(range(0, 100))
>>> print s.head(10).odd().even().reverse()
[9, 5, 1]

请注意，这可以在许多方面得到改进。例如，在Javascript世界中，可链接的方法实际上将其结果推送到堆栈中，从而允许在调用历史中回溯并恢复以前的上下文。有关详细信息，请参阅。

。奇数（）。偶数（）

不太可能非常有用。@Johnsyweb；是的，只是一个例子来说明我想要什么。类似的问题：

.odd（）.偶数（）

不太可能有用。@Johnsyweb；是的，只是一个示例来说明我想要什么。类似的问题：@Frédéric Hamidi，谢谢你的帮助，这是否意味着我必须定义类定义中的所有序列函数？@user478514，实际上，这样做可能是最好的。你可以使用自由函数来获取并返回

Seq

实例，而不是方法（想想

def head（s，count）：返回Seq（s.Seq[：count]）

和

head（s，10）。奇数。偶数。倒数

），但这可能会更难看。@Frédéric Hamidi，哼哼，谢谢，顺便说一句，我想我的第三个问题可以通过在类

def ignore_uncipled（self，flag）中定义它来解决：self.flag=flag；返回Seq（Seq.Seq[：count]）

然后基于标志值对每个其他函数测试长度

self.Seq

。但是，我仍然不知道第二个问题，也许我必须在类Seq？@user478514中列出所有函数名，你的第二个问题本身可能值得一提（我会选择方法装饰器，但其他人可能会有更好的答案）。关于你的第三个问题，同样的问题可能也适用，但我不能确定，因为我仍然不明白

忽略不足（）

应该做什么：）@Frédéric Hamidi，为我糟糕的英语，我应该在学校更加努力学习：-，

忽略不足（）

只意味着如果源序列小于

头（）

限制，例如，

头（10，[1,2,3,4,5]）

，它肯定只会打印

[1,2,3,4,5]

，但我认为有时它没有意义，所以我想添加一个标志来控制它-允许这样或那样做not@Fr艾德里克·哈米迪，谢谢你的帮助，这是否意味着我必须定义类定义中的所有序列函数？@user478514，实际上，这样做可能是最好的。你可以使用自由函数来获取并返回

Seq