Существует ли компактная операция Perl для среза альтернативных элементов из массива?

Если у меня есть массив myarray в Python я могу использовать нотацию среза

myarray[0::2]

выбрать только четно-индексированных элементов. Например:

>>> ar = [ "zero", "one", "two", "three", "four", "five", "six" ]
>>> ar [ 0 : : 2 ]
['zero', 'two', 'four', 'six']

есть ли аналогичный объект в Perl?

спасибо.

15
perl syntax

10 ответов

есть фрагменты массива:

my @slice = @array[1,42,23,0];

есть способ генерировать списки между $x и $y:

my @list = $x .. $y

существует способ создания новых списков из списков:

my @new = map { $_ * 2 } @list;

и есть способ получить длину массива:

my $len = $#array;

собрал:

my @even_indexed_elements = @array[map { $_ * 2 } 0 .. int($#array / 2)];

конечно, не так хорошо, как эквивалент python, но он выполняет ту же работу, и вы можете, конечно, поместить это в подпрограмму, если вы используете ее много и хотите сохранить себя от некоторых пишу.

также вполне возможно, что-то, что позволит написать это более естественным образом в List::AllUtils.

21

срез массива Perl-это @ перед именем массива, затем список индексов, которые вы хотите:

 @array[@indices];

нет встроенного синтаксиса для выбора кратных, но это не так сложно. Команда grep() для получения списка индексов, которые вы хотите:

 my @array = qw( zero one two three four five six );
 my @evens = @array[ grep { ! ($_ % 2) } 0 .. $#array ];

Если вы используете PDL, есть много хороших вариантов нарезки.

22

я написал модуль Список:: Gen на CPAN, который предоставляет альтернативный способ сделать это:

use List::Gen qw/by/;

my @array = qw/zero one two three four five six/;

my @slice = map {$$_[0]} by 2 => @array;

by разделы @array в группы из двух элементов и возвращает массив массивов. map затем получает этот список, поэтому каждый $_ на карте будет ссылка на массив. $$_[0] (который также может быть написано $_->[0]) затем захватывает первый элемент каждой группы, что by создать.

или, используя

11

Я сделаю это в двухэтапном процессе: сначала создайте нужные индексы, а затем используйте операцию среза для их извлечения:

@indices = map { $_ * 2 } (0 .. int($#array / 2));
my @extracted = @array[@indices];

шаг-за-шагом, вот:

  • создайте список целых чисел от 0 до последнего элемента массива, разделенного на два
  • умножьте каждое целое число на два: теперь у нас есть четные числа от нуля до индекса последнего элемента
  • извлечь эти элементы из исходного массива
9

Perl 6 значительно улучшит ситуацию, но (до сих пор?) Perl 5 имеет довольно ограниченную возможность нарезки: вы должны явно указать нужные индексы, и он не может быть открытым.

Так что вам придется делать:

@ar = ( "zero", "one", "two", "three", "four", "five", "six" );
print @ar[ grep $_ % 2 == 0, 0..$#ar ]
7

один из способов сделать это красивше это завернуть его во что-то вроде autobox.

используя autobox::Core: 
use autobox::Core;
my @ar = qw/zero one two three four five six/;

# you could do this
@ar->slice_while( sub{ not $_ % 2 } );

# and this
@ar->slice_by(2);

# or even this
@ar->evens;

вот как вы можете определить эти методы autobox:

sub autobox::Core::ARRAY::slice_while {
    my ($self, $code) = @_;
    my @array;

    for (my $i = 0; $i <= $#{ $self }; $i++) {
        local $_ = $i;
        push @array, $self->[ $i ] if $code->();
    }

    return wantarray ? @array : \@array;
}

sub autobox::Core::ARRAY::slice_by {
    my ($self, $by) = @_;
    my @array = @$self[ map { $_ * $by } 0 .. int( $#{$self} / $by )];
    return wantarray ? @array : \@array;
}

sub autobox::Core::ARRAY::evens {
    my $self  = shift;
    my @array = $self->slice_by(2);
    return wantarray ? @array : \@array;
}

/ I3az/

5

Если вы не заботитесь о порядке, и если нечетные элементы списка уникальны, вы можете кратко преобразовать массив в хэш и взять values:

@even_elements = values %{{@array}};
@odd_elements = keys %{{@array}};

(нет, это не серьезный ответ)

4

еще один путь было бы с помощью grep: 

my @array = qw( zero one two three four five six );

print map { "$_ " } @array[grep { !($_ & 1) } 0 .. $#array];  #even
Output:zero two four six

print map { "$_ " } @array[grep { ($_ & 1) } 0 .. $#array];  #odd
Output:one three five
2

Если вы не против использовать неясную функцию$/, вы можете сделать это:

{
    local $|; # don't mess with global $|
    @ar = ( "zero", "one", "two", "three", "four", "five", "six" );
    $| = 0;
    @even = grep --$|, @ar;
    $| = 1;
    @odd = grep --$|, @ar;
    print "even: @even\n";
    # even: zero two four six
    print "odd: @odd\n";
    # odd: one three five
}

или, как 1 вкладыш:

 { local $|=0; @even = grep --$|, @ar; }

в основном, -- $ / flip flops между значением 0 и 1 (несмотря на--, которое обычно уменьшает числовое значение), поэтому grep видит "истинное" значение каждый раз, заставляя его возвращать каждый другой элемент, начиная с начального значения $|. Обратите внимание, что вы должны начать с 0 или 1, а не с произвольного индекса.

1

вот самый простой код без создания каких-либо массивов индексов:

sub even { my $f=0; return grep {++$f%2} @_; }
sub odd { my $f=1; return grep {++$f%2} @_; }
1