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.
#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";
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
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";
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;
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.
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
}
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
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
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;
import subprocess
subprocess.run(['sl', '-h'], check=True)
use strict;
use warnings;
use autodie qw(system);
system qw(sl -h);
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;
}
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;
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;
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;
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;
}
subprocess.run('echo Hello > /dev/null', shell=True)
system 'echo Hello > /dev/null'; #Shell wird aufgerufen, wenn ein Metazeichen vorhanden ist
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)
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
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
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
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;
}
#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