Wie schreibe ich diesen Prozess in Python? ist der zweite Sud.

Übe tatsächlich, während du darüber nachdenkst, wie man schreibt, wenn es Perl ist. Binden Sie das CORE-Modul so weit wie möglich.

Wie schreibe ich diesen Prozess in Perl?

Standardausgabe / Standardfehlerausgabe

#Nachricht an die Standardausgabe
echo 'HELLO'

#Meldung an Standardfehler
echo 'ERROR!' >&2

use strict;
use warnings;

#Nachricht an die Standardausgabe
print "HELLO\n";
#Oder v5.Sprich nach 10 oder mehr
use v5.10;
say "HELLO";

#Meldung an Standardfehler.(PBP p.235 「10.12 Ausgabe an Dateihandle)
print {*STDERR} "ERROR!\n";
#Oder verwenden Sie warn. Wenn am Ende kein Zeilenumbruch auftritt, wird auch die Position der Warnung angezeigt.
warn "ERROR!\n";

Datei bezogen

Pfadoperation

name="$(basename "/foo/bar/baz.txt")" # => baz.txt Dateiname
name="$(dirname "/foo/bar/baz.txt")"  # => /foo/bar/Pfad des übergeordneten Verzeichnisses
fullpath="/foo/bar/${name}"           # => /foo/bar/baz.txt Pfadverkettung

use strict;
use warnings;
use File::Basename qw(basename dirname);
use File::Spec;

my $name = basename("/foo/bar/baz.txt");  # => baz.txt
my $dir = dirname("/foo/bar/baz.txt");  # => /foo/bar
$fullpath = File::Spec->catfile("/foo/bar", $name);  # => /foo/bar/buz.txt

Behandeln Sie Pfade mit Kältemaschinen und Umgebungsvariablen

import pathlib

bad = pathlib.Path("~/Donwloads/report.txt") # ~Wird nicht automatisch bereitgestellt!

f = pathlib.Path("~/Donwloads/report.txt").expanduser()
g = pathlib.Path("${WORK_DIR}/input.txt").expandvars()

use strict;
use warnings;

my $bad = "~/Downloads/report.txt";

#Verwenden Sie glob. Achten Sie auf Platzhalter.
my $f = glob '~/Downloads/report.txt';  #Zugriff im skalaren Kontext.

# %Sie können Umgebungsvariablen aus ENV übernehmen.
my $g = "$ENV{WORK_DIR}/input.txt";

Dateien lesen und schreiben

import pathlib
path = pathlib.Path('foo.txt')

with open(path, 'r', encoding="utf-8") as f:
    for line in f:
        #Prozesslinie

with open(path, 'w', encoding="utf-8") as f:
    print("Inhalt", file=f)

with path.open('r') as f: #Es kann auch mit der Path-Methode geöffnet werden.
    # ...

use strict;
use warnings;
use open qw/:encoding(UTF-8) :std/;
use utf8;
use autodie;

my $path = 'foo.txt';

READ: {
    open my $fh, '<', $path;

    while (<$fh>) {
        chomp(my $line = $_);
        # $Prozesslinie
    }

    close $fh;
}

WRITE: {
    open my $fh, '>', $path;
    print {$fh} "Inhalt";
    close $fh;
}

1;

Zähle die Anzahl der Zeilen (`wc -l`)

with path.open('rb') as f:
    count = sum(1 for line in f)

use strict;
use warnings;
use autodie;
open my $fh, '<:raw', $path;
my $count = () = <$fh>;  #Nehmen Sie ein Dateihandle in einem Listenkontext und greifen Sie in einem skalaren Kontext darauf zu.

Aufzählung von Dateien

import pathlib
dir = pathlib.Path('/tmp')
for file in dir.glob('tmp.*'):
    #Verarbeiten Sie die Datei
    #Datei ist keine Zeichenfolge, pathlib.Beachten Sie, dass es Pfad ist

use strict;
use warnings;

for my $file (glob '/tmp/tmp.*') {
    #Verarbeiten Sie die Datei
    # $Datei ist eine Zeichenfolge
}

Dateiinformationen (Existenzbestätigung / Erstellungsdatum und -zeit)

import pathlib
f = pathlib.Path('/bin/bash')
f.exists()  #Existenz prüfen

f.is_file() #Datei?
f.is_dir()  #Verzeichnis?

f.stat().st_ctime #Erstellungsdatum und -zeit
f.stat().st_mtime #Datum und Uhrzeit aktualisieren
f.stat().st_atime #Zugriff auf Datum und Uhrzeit

use strict;
use warnings;
use File::stat;

my $f = '/bin/bash';

my $sb = stat($f);  #Spezielles Dateihandle"_"Wird zwischengespeichert.
-e _;  #Existenz prüfen
-f _;  #Datei?
-d _;  #Verzeichnis?

$sb->ctime;  #Erstellungsdatum und -zeit
$sb->mtime;  #Datum und Uhrzeit aktualisieren
$sb->atime;  #Zugriff auf Datum und Uhrzeit

Verschieben / Löschen

import pathlib

path_from = pathlib.Path('.bash_history')
path_to = pathlib.Path('/tmp/.bash_history')
path_from.rename(path_to) #Bewegung
path_from.unlink() #Löschen

use strict;
use warnings;
use File::Copy qw(move);
use autodie qw(move);

my $path_from = '.bash_history';
my $path_to = '/tmp/.bash_history';
move $path_from, $path_to;  #Bewegung
unlink $path_from;  #Löschen

Kopieren

import shutil
import pathlib

path_from = pathlib.Path('.bash_history')
path_to = pathlib.Path('/tmp/.bash_history')
shutil.copy2(path_from, path_to) #Kopieren

use strict;
use warnings;
use File::Copy qw(copy);
use autodie qw(copy);

my $path_from = '.bash_history';
my $path_to = '/tmp/.bash_history';
copy $path_from, $path_to;

Externer Befehl

Einfach laufen

import subprocess
subprocess.run(['sl', '-h'], check=True)

use strict;
use warnings;
use autodie qw(system);
system qw(sl -h);

Führen Sie einen externen Befehl aus und erhalten Sie die Standardausgabe

import subprocess
r = subprocess.run(['echo', 'Welt'], check=True, stdout=subprocess.PIPE)
r.stdout # => b'\xe4\xb8\x96\xe7\x95\x8c\n' 'Welt\n'UTF-8 codiert
r.stdout.decode(sys.getfilesystemencoding()) # => 'Welt\n'

use strict;
use warnings;
use autodie;
use Encode;

#Wenn der auszuführende Befehl sicher ist
my $stdout = `Echo Welt`;
$stdout;  # 'Welt\n'Binäre Zeichenfolge. Keine utf8-Flagge.
decode_utf8($stdout);  # 'Welt\n', Mit utf8-Flag.

#Wenn nicht sicher
my @cmd = qw(Echo Welt);
open my $fh, '-|', @cmd;
$stdout = do { local $/; <$fh> };  #Schlucken
close $fh;

#Wenn Sie sich keine Sorgen um das utf8-Flag machen möchten
{
    use utf8;
    use open qw/:encoding(UTF-8) :std/;
    open my $fh, '-|', @cmd;
    $stdout = do { local $/; <$fh> };  #mit utf8 flag
    close $fh;
}

#Das Gebietsschema ist UTF auf älteren Systemen-Ist es nicht 8? sind Sie im Ernst? ??
{
    no utf8;
    use Encode::Locale;  # non-core
    my @lcmd = map { encode(locale => decode_utf8($_)) } @cmd;
    open my $fh, '-|', @lcmd;
    $stdout = decode(locale => do { local $/; <$fh> });
    close $fh;
}

Ändern Sie die Umgebungsvariablen und das aktuelle Verzeichnis

env = dict(os.environ) #Kopieren Sie Umgebungsvariablen für Python-Skripte
env['DB_HOST'] = 'localhost' #Umgebungsvariablen ändern

cwd = pathlib.Path('/')

subprocess.run(['setup.sh'], cwd=cwd, env=env)

use strict;
use warnings;
use Cwd qw(chdir);  #Bei chdir$ENV{PWD}Aktualisieren
use autodie;

local $ENV{DB_HOST} = 'localhost';
my $orig_dir = Cwd::getcwd();

chdir "/";
system "setup.sh";
chdir $orig_dir;

Verwenden Sie die Umleitung

import subprocess
import os.path

fi = open(os.path.expanduser('~/.bash_history'))
fo = open('p.txt', 'wb')
subprocess.run(['grep', 'python[23]'], stdin=fi, stdout=fo)
# p.Suchergebnisse werden in txt ausgegeben

#CORE-Modulbindung
use strict;
use warnings;
use autodie;
use IPC::Open2;

open my $fh_history, '<', scalar glob '~/.bash_history';

my ($fh_out, $fh_in);
my $pid = open2($fh_out, $fh_in, 'grep', 'python');
print {$fh_in} $_ while <$fh_history>;
close $fh_in;
close $fh_history;

open my $fh_txt, '>:raw', 'p.txt';
print {$fh_txt} $_ while <$fh_out>;
close $fh_txt;
close $fh_out;

waitpid $pid, 0;
my $return_code = $? >> 8;

#Wenn Sie ein anderes als das CORE-Modul verwenden können
use strict;
use warnings;
use IPC::Run3 qw(run3);  # non-core

my $fi = scalar glob '~/.bash_history';
my $fo = 'p.txt';

run3 ['grep', 'python[23]'], $fi, $fo;

Verwenden Sie ein Rohr

p1 = subprocess.Popen(["cat", '.bash_history'], stdout=subprocess.PIPE)
p2 = subprocess.Popen(["grep", "python"], stdin=p1.stdout, stdout=subprocess.PIPE)
p1.stdout.close()
output = p2.communicate()[0] #Aus der Geschichte'python'Ergebnisse der Suche nach Zeilen mit
p2.returncode #Endcode von grep

use strict;
use warnings;
use autodie;
use IPC::Open2;

open my $fh_history, '<', scalar glob '~/.bash_history';

my ($fh_out, $fh_in);
my $pid = open2($fh_out, $fh_in, 'grep', 'python');

print {$fh_in} $_ while <$fh_history>;

close $fh_in;
close $fh_history;

waitpid $pid, 0;
my $returncode = $? >> 8;
my $output = do { local $/; <$fh_out> };

close $fh_out;

spawn → wait (starte einen externen Befehl und warte bis zum Ende)

import subprocess

p1 = subprocess.Popen(['/path/to/heavy-sub-process1'])
p2 = subprocess.Popen(['/path/to/heavy-sub-process2'])

p1.wait()
p2.wait()

use strict;
use warnings;

my @cmds = (
    ['/path/to/heavy-sub-process1'],
    ['/path/to/heavy-sub-process2'],
);

my @pids;
for my $cmd (@cmds) {
    my $pid = fork;
    if (!defined $pid) {
        die "Can't fork: $!";
    }
    elsif (!$pid) {
        exec @{$cmd};
        exit 1;
    }
    else {
        push @pids, $pid;
    }
}

my @rcs;
for my $pid (@pids) {
    waitpid $pid, 0;
    push @rcs, $? >> 8;
}

Führen Sie die Shell aus

subprocess.run('echo Hello > /dev/null', shell=True)

system 'echo Hello > /dev/null';  #Shell wird aufgerufen, wenn ein Metazeichen vorhanden ist

Zeitbeziehung

from datetime import datetime, timedelta #datetime steht für Datum und Uhrzeit und timedelta für die verstrichene Zeit

epoch = datetime.now().timestamp()
# => 1540277405.379158 Aktuelle Unix-Zeit (gebrochen)

datetime.fromtimestamp(1540277405).strftime('%FT%T')
# => '2018-10-23T15:50:05'

start = datetime.now()
#Mach etwas, das Zeit braucht

duration = datetime.now() - start # datetime -datetime ist timedelta
print(duration / timedelta(seconds=1)) #Teilen Sie durch ein anderes Zeitdelta, um die verstrichene Zeit numerisch zu machen
# => 42.680422 Anzahl der Sekunden (gebrochen)
print(duration.total_seconds()) #Das ist in Ordnung
# => 42.680422 Anzahl der Sekunden (gebrochen)

use strict;
use warnings;
use v5.12;
use Time::Piece;
use Time::HiRes;

my $epoch = localtime->epoch;
# =>Aktuelle Unix-Zeit (Ganzzahl)

my $start = localtime;
#Mach etwas, das Zeit braucht

my $duration = localtime() - $start;  # Time::Piece - Time::Stück ist Zeit::Seconds
say $duration->seconds;
# =>Anzahl der Sekunden (Ganzzahl)

my $frac_epoch = Time::HiRes::time();
# =>Aktuelle Unix-Zeit (gebrochen)

my $frac_duration = Time::HiRes::time() - $frac_epoch;
say $frac_duration;
# =>Anzahl der Sekunden (gebrochen)

Zeichenkettenbeziehung

Einbettung von Ausdrücken in eine Zeichenfolge

message='Welt!'
print(f"Hello {message}") # =>Hallo Welt!

use strict;
use warnings;

my $message = 'Welt!';
print "Hello ${message}\n";  # =>Hallo Welt!

print(f"1 + 2 = {1 + 2}") # => 1 + 2 = 3

use strict;
use warnings;

#Übergeben Sie die Referenz, damit sie in die Zeichenfolge eingebettet werden kann
print "1 + 2 = ${\(1 + 2)}\n";  # => 1 + 2 = 3

Hier dokumentieren

import textwrap

report = textwrap.dedent(f"""
Bericht
Datum: {date}
""")

use strict;
use warnings;
use v5.26;
use Time::Piece;

my $report = <<~EOF;  #Relativ neuer Perl Dedent
Bericht
Datum: ${\(localtime->strftime("%Y Jahr%m Monat%d Tag"))}
    EOF

Kommandozeilenargumente

import sys
sys.argv # => ['a.py', 'input.txt', '-o', 'output.txt']

#Der Programmdateiname selbst$Es ist in 0.
@ARGV; # => ('input.txt', '-o', 'output.txt')

import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

#!/usr/bin/perl
use v5.12;
use strict;
use warnings;
use Getopt::Long qw(:config posix_default no_ignore_case gnu_compat permute);
use Pod::Usage qw(pod2usage);
use File::Basename qw(basename);
use List::Util qw(max sum);

#Es kann etwas umständlich sein, weil ich es gewaltsam an argparse of python geschickt habe.

my %args = (
    accumulate => \&max,
);

GetOptions(
    'h|help' => sub { pod2usage(0) },
    sum => sub { $args{accumulate} = \&sum },
) or pod2usage(1);

for my $arg (@ARGV) {
    if ($arg =~ /\D/) {
        pod2usage(
            -exitval => 1,
            -msg => "argument N: invalid int value: $arg",
        );
    }
}

say $args{accumulate}->(@ARGV);

1;
__END__

=pod

=encoding UTF-8

=head1 NAME

test.pl -- blah blah

=head1 SYNOPSIS

test.pl [-h] [--sum] N [N ...]

Process some integers.

=head2 OPTIONS

=over 2

=item C<-h>

show this help message

=item C<--sum>

sum the integers (default: find the max)

=back

=cut

Verarbeitung am Ende & Einfangen des Signals

import atexit
import os

tf = '/path/to/tempfile'

@atexit.register
def cleanup():
    os.remove(tf)

use strict;
use warnings;
use autodie;

my $tf = '/path/to/tmp';
$SIG{$_} = \&cleanup for qw( HUP INT QUIT TERM );

sub cleanup {
    unlink $tf;
}

HTTP-Anfrage (Alternative zu Curl oder Wget)

#URL mit GET anfordern und Antworttext ausgeben
import urllib.request
import urllib.parse

params = urllib.parse.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
url = f"http://www.musi-cal.com/cgi-bin/query?{params}"
with urllib.request.urlopen(url) as f:
     print(f.read().decode('utf-8'))

#URL mit GET anfordern und Antworttext ausgeben
use strict;
use warnings;
use v5.12;
use HTTP::Tiny;

my %params = (spam => 1, eggs => 2, bacon => 0);
my $url = 'http://www.musi-cal.com/cgi-bin/query';
my $response = HTTP::Tiny->new->get($url, \%params);
die "Failed" unless $response->{success};
say $response->{content};

[PYTHON] Wie schreibe ich diesen Prozess in Perl?

Wie schreibe ich diesen Prozess in Perl?

Standardausgabe / Standardfehlerausgabe

Datei bezogen

Pfadoperation

Behandeln Sie Pfade mit Kältemaschinen und Umgebungsvariablen

Dateien lesen und schreiben

Zähle die Anzahl der Zeilen (wc -l)

Aufzählung von Dateien

Dateiinformationen (Existenzbestätigung / Erstellungsdatum und -zeit)

Verschieben / Löschen

Kopieren

Externer Befehl

Einfach laufen

Führen Sie einen externen Befehl aus und erhalten Sie die Standardausgabe

Ändern Sie die Umgebungsvariablen und das aktuelle Verzeichnis

Verwenden Sie die Umleitung

Verwenden Sie ein Rohr

spawn → wait (starte einen externen Befehl und warte bis zum Ende)

Führen Sie die Shell aus

Zeitbeziehung

Zeichenkettenbeziehung

Einbettung von Ausdrücken in eine Zeichenfolge

Hier dokumentieren

Kommandozeilenargumente

Verarbeitung am Ende & Einfangen des Signals

HTTP-Anfrage (Alternative zu Curl oder Wget)

Zähle die Anzahl der Zeilen (`wc -l`)