#!/usr/bin/env perl
use warnings;
use 5.012;
use List::Util qw(reduce);
use List::Util::XS;

my @array = qw( one two three four five six seven eight nine ten eleven );

my $l = reduce{ length($a) > length($b) ? $a : $b } @array;

say $l;

sub longest {
    my $max = -1;
    my $max_i = 0;
    for (0 .. $#_) {              # for each index
        my $len = length $_[$_];  # only get length once per item
        if ($len > $max) {        # save index and update max if larger
            $max = $len;
            $max_i = $_;
        }
    }
    $_[$max_i]   # return the largest item
}

如果你要运行上面的代码很多次,我建议嵌入子程序的正文.

编辑：

drewk的基准显示,上述代码中的数组索引有点瓶颈.再试一次,我终于找到了一种比reduce解决方案更快的方法：

sub fastest {
    my $max = -1;
    my $max_ref;
    for (@_) {
        if (length > $max) {  # no temp variable,length() twice is faster
            $max = length;
            $max_ref = \$_;   # avoid any copying
        }
    }
    $$max_ref
}

这导致以下基准：

Rate longest   drewk  reduce fastest
longest 44245/s      --    -21%    -30%    -47%
drewk   55854/s     26%      --    -11%    -33%
reduce  63014/s     42%     13%      --    -25%
fastest 83638/s     89%     50%     33%      --

像这样：

L=[[1,2,3],[4,5,6]]

当元素为3时,我想成为输出：

output=[0][2]

L=[[1,6],[2,3,4,3]]

a = 3

print([(i,j) for i,x in enumerate(L) if a in x for j,b in enumerate(x) if b == a])
#[(0,2),(2,1),4)]

使用列表推导,您可以挖掘并返回所有子值.如果你需要更深入,只需继续链接列表理解或编写一个函数来完成它.

例如：

L = set(["a","ab","c","e"])

然后“abac”是L的子集的元素的有效串联

“aaaaaaa”也是一种有效的连接.

但“广告”不是因为“d”不在L.

import re
L = ["no","force","in","the","verse","can","stop","me"]
# make this: "(?:no|force|in|the|verse|can|stop|me)*$"
r = re.compile( "(?:" + "|".join(L) + ")*$")
r.match("shiny")  # -> None
r.match("canme")  # -> not None

这适用于给定的字符串集. re库中有一个函数引用字符串(转义| etc),以便您可以在运行时安全地创建这样的表达式.

r = re.compile( "(?:"  + "|".join( re.escape(s) for s in L) + ")*$" )

无论子串出现多少次,它都会匹配;如果某些字符串是其他字符串的前缀,则可能会出现奇怪的结果,等等.它可能有令人讨厌的运行时.如果所有字符串在开头都很容易区分,那就不应该.