[PYTHON] Wie schreibe ich diesen Prozess in Perl?

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};

Recommended Posts

Wie schreibe ich diesen Prozess in Perl?
Wie man nüchtern mit Pandas schreibt
Wie schreibe ich Ruby to_s in Python
Wie schreibe ich ein benanntes Tupeldokument im Jahr 2020?
So schreiben Sie den richtigen Shebang in Perl-, Python- und Ruby-Skripten
20. Offline-Echtzeit So schreiben Sie Probleme in Python
So schreiben Sie in Python die Verkettung von Zeichenfolgen in mehrere Zeilen
XPath-Grundlagen (2) - So schreiben Sie XPath
Wie man in Python entwickelt
So schreiben Sie eine benutzerdefinierte Validierung in Django REST Framework
[Python] Wie schreibe ich eine if-Anweisung in einen Satz?
Zusammenfassung zum Schreiben von in gRPC verwendeten .proto-Dateien
Umgang mit Sitzungen in SQLAlchemy
Verwendung von Klassen in Theano
So sammeln Sie Bilder in Python
Wiederverwendung von Flaschen Wie schreibe ich HTML?
So aktualisieren Sie Spyder in Anaconda
Verwendung von SQLite in Python
So konvertieren Sie 0,5 in 1056964608 auf einmal
Wie man CSS in Django reflektiert
Wie man Prozesse in großen Mengen abbricht
Wie man MySQL mit Python benutzt
So verpacken Sie C in Python
Verwendung von ChemSpider in Python
Verwendung von PubChem mit Python
So schreiben Sie ein Docker-Basis-Image
Wie schreibe ich Django1.9 umweltunabhängig wsgi.py
So führen Sie TensorFlow 1.0-Code in 2.0 aus
Hinweise zum Schreiben von require.txt
Umgang mit Japanisch mit Python
So melden Sie sich bei Docker + NGINX an
So rufen Sie PyTorch in Julia an
Repeated @ app.callback in Dash So schreiben Sie Input und State ordentlich
Das 15. Offline-Echtzeit-Schreiben eines Referenzproblems in Python
Verwendung von Funktionen in separaten Dateien Perl-Version und Python-Version
Verwendung von Sternchen (*) in Python. Vielleicht ist das alles? ..
So schreiben Sie offline in Echtzeit Lösen von E04-Problemen mit Python
Unterschied in der Ausführungsgeschwindigkeit abhängig vom Schreiben der Cython-Funktion
Das 18. Offline-Echtzeit-Schreiben eines Referenzproblems in Python
Verwendung berechneter Spalten in CASTable
[Einführung in Python] Wie verwende ich eine Klasse in Python?
So unterdrücken Sie Anzeigefehler in matplotlib
Qiita (1) Wie schreibe ich einen Codenamen?
Dynamisches Definieren von Variablen in Python
Wie man optuna einstellt (wie man einen Suchraum schreibt)
So machen Sie R chartr () in Python
So konvertieren Sie csv in tsv in CLI
So schreiben Sie Python-Dokumentkommentare (Docstrings)
So löschen Sie abgelaufene Sitzungen in Django
Verwendung von Google Test in C-Sprache
So implementieren Sie einen verschachtelten Serializer mit drf-flex-Feldern
So arbeiten Sie mit BigQuery in Python
So führen Sie Befehle mit einem Jupyter-Notebook aus
Wie man in GitPython '--gags fetch --tags' macht
Wie bekomme ich Stacktrace in Python?
So zeigen Sie die neunundneunzig Tabelle in Python an
So extrahieren Sie einen Polygonbereich in Python