1. The parentheses around (?!...) aren't optional.
2. Look-around assertions are zero-width, i.e. if they match, they don't consume any part of the string. It means replacing them doesn't remove anything.

perl -ne 'print if 1 != $.'
[download]

$. is the current line number of the last accessed file handle.

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

The parentheses aren't optional. ^? means ^ (beginning of the string) 0 or 1 time; this will match if you are either at the beginning of the string, or if you are not... meaning everywhere. So your pattern actually is /!\d+\s+.*\n/ which is clearly not what you wanted.

While it's possible to do what you want with the -p option (read and print for each line, with possible modification), the -n option probably fits your problem better (read, but only print when you explictly ask for it), your one-liner becomes: perl -ne "print unless /^\d+\s+.*\n/"

Edit: or print if /regex/ if you want to keep only the lines with the pattern. I misread the title (didn't realise that "remove" + "except" works like a double negation, so print only the lines with the pattern). Thanks johngg

Close, just missing parens.

s/^(?!\d+\s+).*\n//
[download]

G'day bbs2web,

There may be more to your data than you show; however, from what's in your OP, you may be overthinking the solution.

A cut-down version of your data:

$ cat fred
id pool     image         snap device
0  rbd_hdd  vm-209-disk-1 -    /dev/rbd0
1  rbd_hdd  vm-107-disk-1 -    /dev/rbd1
10 rbd_hdd  vm-144-disk-1 -    /dev/rbd10
[download]

Removing ... except:

$ cat fred | perl -ne 'print unless /^[^\d]/'
0  rbd_hdd  vm-209-disk-1 -    /dev/rbd0
1  rbd_hdd  vm-107-disk-1 -    /dev/rbd1
10 rbd_hdd  vm-144-disk-1 -    /dev/rbd10
[download]

Which is basically a double-negative for:

$ cat fred | perl -ne 'print if /^\d/'
0  rbd_hdd  vm-209-disk-1 -    /dev/rbd0
1  rbd_hdd  vm-107-disk-1 -    /dev/rbd1
10 rbd_hdd  vm-144-disk-1 -    /dev/rbd10
[download]

Think of positive/negative look-ahead/look-behind regular expression patterns like this:

e.g.    'this(?=\ that)' # match 'this' when followed by ' that')

e.g.    'this(?!\ that)' # match 'this' when NOT followed by ' that'

e.g.    '(?<=this\ )that' # match 'that' when preceded by 'this '

e.g.    '(?<!this\ )that' # match 'that' when NOT preceded by 'this '

Both the PRECEDING_PATTERN and the FOLLOWING_PATTERN are matched as the 'look-around' patterns, but neither are captured to a variable, only what is matched as part of your (PATTERN_OF_INTEREST) capture group (i.e. if you use capturing parenthesis).

Note that in the comments of the code examples in the Positive and Negative Look-behind sections, e.g.
    '(?<=this\ )that' # match 'that' when followed by 'this '
    '(?<!this\ )that' # match 'that' when NOT followed by 'this '
the word "followed" should be "preceded" in both cases, i.e.
    '(?<=this\ )that' # match 'that' when preceded by 'this '
    '(?<!this\ )that' # match 'that' when NOT preceded by 'this '
respectively.

Both the PRECEDING_PATTERN and the FOLLOWING_PATTERN are matched as the 'look-around' patterns, but neither are captured to a variable, only what is matched as part of your (PATTERN_OF_INTEREST) capture group ...

As an interesting (I hope) side note, a capture group embedded within a positive lookaround assertion will capture something:

c:\@Work\Perl\monks>perl -wMstrict -le
"my $s = 'foobar';
 ;;
 print qq{positive look-behind capture: '$1'} if $s =~ m{ (?<= (foo)) 
+   bar   }xms;
 print qq{positive look-ahead capture:  '$1'} if $s =~ m{       foo (?
+= (bar)) }xms;
"
positive look-behind capture: 'foo'
positive look-ahead capture:  'bar'
[download]

An embedded positive look-ahead capture is a way to capture and extract certain overlapping matches:

c:\@Work\Perl\monks>perl -wMstrict -MData::Dump -le
"my $s = 'abcd efgh';
 ;;
 my @caps = $s =~ m{ \w+ }xmsg;
 dd 'non-overlapping captures: ', \@caps;
 ;;
 @caps = $s =~ m{ (?= (\w+)) }xmsg;
 dd 'overlapping captures: ', \@caps;
"
("non-overlapping captures: ", ["abcd", "efgh"])

(
  "overlapping captures: ",
  ["abcd", "bcd", "cd", "d", "efgh", "fgh", "gh", "h"],
)
[download]

Update: Slight, essentially trivial wording and emphasis changes.

---

Give a man a fish:  <%-{-{-{-<

...interesting indeed, a double negative :)...switching off the anti-capture could prove useful at some point...(but I must always remember I will forget what I did and why I did it so I have to keep it simple for my dumb future self :P