Comment écrire ce processus en Python? est la deuxième décoction.

En fait, entraînez-vous en réfléchissant à la façon d'écrire si c'est perl. Liez le module CORE autant que possible.

Comment écrire ce processus en Perl?

Sortie standard / sortie d'erreur standard

#Message à la sortie standard
echo 'HELLO'

#Message à l'erreur standard
echo 'ERROR!' >&2

use strict;
use warnings;

#Message à la sortie standard
print "HELLO\n";
#Ou v5.Dites après avoir utilisé 10 ou plus
use v5.10;
say "HELLO";

#Message à l'erreur standard.(PBP p.235 「10.12 Sortie vers le descripteur de fichier)
print {*STDERR} "ERROR!\n";
#Ou utilisez avertir. S'il n'y a pas de saut de ligne à la fin, il vous indiquera également la position de l'avertissement.
warn "ERROR!\n";

Lié au fichier

Opération de chemin

name="$(basename "/foo/bar/baz.txt")" # => baz.nom de fichier txt
name="$(dirname "/foo/bar/baz.txt")"  # => /foo/bar/Chemin du répertoire parent
fullpath="/foo/bar/${name}"           # => /foo/bar/baz.txt Concaténation de chemin

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

Traitez les chemins contenant les refroidisseurs et les variables d'environnement

import pathlib

bad = pathlib.Path("~/Donwloads/report.txt") # ~N'est pas déployé automatiquement!

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

use strict;
use warnings;

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

#Utilisez glob. Attention aux jokers.
my $f = glob '~/Downloads/report.txt';  #Accès dans un contexte scalaire.

# %Vous pouvez prendre des variables d'environnement depuis ENV.
my $g = "$ENV{WORK_DIR}/input.txt";

Lecture et écriture de fichiers

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

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

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

with path.open('r') as f: #Il peut également être ouvert à l'aide de la méthode Path.
    # ...

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 = $_);
        # $Ligne de process
    }

    close $fh;
}

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

1;

Comptez le nombre de lignes (`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>;  #Prenez un descripteur de fichier dans un contexte de liste et accédez-y dans un contexte scalaire.

Énumération des fichiers

import pathlib
dir = pathlib.Path('/tmp')
for file in dir.glob('tmp.*'):
    #Traiter le fichier
    #le fichier n'est pas une chaîne, pathlib.Notez que c'est Path

use strict;
use warnings;

for my $file (glob '/tmp/tmp.*') {
    #Traiter le fichier
    # $le fichier est une chaîne
}

Informations sur le fichier (confirmation d'existence / date et heure de création)

import pathlib
f = pathlib.Path('/bin/bash')
f.exists()  #vérifier l'existence

f.is_file() #Fichier?
f.is_dir()  #annuaire?

f.stat().st_ctime #Date et heure de création
f.stat().st_mtime #Mettre à jour la date et l'heure
f.stat().st_atime #Date et heure d'accès

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

my $f = '/bin/bash';

my $sb = stat($f);  #Poignée de fichier spéciale"_"Est mis en cache.
-e _;  #vérifier l'existence
-f _;  #Fichier?
-d _;  #annuaire?

$sb->ctime;  #Date et heure de création
$sb->mtime;  #Mettre à jour la date et l'heure
$sb->atime;  #Date et heure d'accès

Déplacer / Supprimer

import pathlib

path_from = pathlib.Path('.bash_history')
path_to = pathlib.Path('/tmp/.bash_history')
path_from.rename(path_to) #Bouge toi
path_from.unlink() #Effacer

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;  #Bouge toi
unlink $path_from;  #Effacer

copie

import shutil
import pathlib

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

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;

Commande externe

Exécutez simplement

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

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

Exécuter une commande externe et recevoir une sortie standard

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

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

#Si la commande à exécuter est sûre
my $stdout = `monde d'écho`;
$stdout;  # 'monde\n'Chaîne binaire. Pas de drapeau utf8.
decode_utf8($stdout);  # 'monde\n', Avec le drapeau utf8.

#Si ce n'est pas sûr
my @cmd = qw(monde d'écho);
open my $fh, '-|', @cmd;
$stdout = do { local $/; <$fh> };  #Avaler
close $fh;

#Si vous ne voulez pas vous soucier du drapeau utf8
{
    use utf8;
    use open qw/:encoding(UTF-8) :std/;
    open my $fh, '-|', @cmd;
    $stdout = do { local $/; <$fh> };  #avec drapeau utf8
    close $fh;
}

#La locale est UTF sur les anciens systèmes-N'est-ce pas 8? es-tu sérieux? ??
{
    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;
}

Modifier les variables d'environnement et le répertoire courant

env = dict(os.environ) #Copier les variables d'environnement pour les scripts Python
env['DB_HOST'] = 'localhost' #Modifier les variables d'environnement

cwd = pathlib.Path('/')

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

use strict;
use warnings;
use Cwd qw(chdir);  #Chez chdir$ENV{PWD}Mise à jour
use autodie;

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

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

Utiliser la redirection

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.Les résultats de la recherche sont envoyés au format txt

#Liaison du module CORE
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;

#Si vous pouvez utiliser un autre module que le module CORE
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;

Utilisez une pipe

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] #De l'histoire'python'Résultats de la recherche de lignes contenant
p2.returncode #code de fin de 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 (démarrer une commande externe et attendre la fin)

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

Exécutez le shell

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

system 'echo Hello > /dev/null';  #Shell est appelé s'il y a un métacaractère

Relation temporelle

from datetime import datetime, timedelta #datetime représente la date et l'heure, et timedelta représente le temps écoulé

epoch = datetime.now().timestamp()
# => 1540277405.379158 Heure Unix actuelle (fractionnaire)

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

start = datetime.now()
#Faites quelque chose qui prend du temps

duration = datetime.now() - start # datetime -datetime est timedelta
print(duration / timedelta(seconds=1)) #Pour rendre le temps écoulé numérique, divisez par un autre chronomètre
# => 42.680422 Nombre de secondes prises (fractionnaire)
print(duration.total_seconds()) #C'est acceptable
# => 42.680422 Nombre de secondes prises (fractionnaire)

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

my $epoch = localtime->epoch;
# =>Heure Unix actuelle (entier)

my $start = localtime;
#Faites quelque chose qui prend du temps

my $duration = localtime() - $start;  # Time::Piece - Time::Piece is Time::Seconds
say $duration->seconds;
# =>Nombre de secondes prises (entier)

my $frac_epoch = Time::HiRes::time();
# =>Heure Unix actuelle (fractionnaire)

my $frac_duration = Time::HiRes::time() - $frac_epoch;
say $frac_duration;
# =>Nombre de secondes prises (fractionnaire)

Relation de chaîne de caractères

Expression incorporée dans une chaîne

message='monde!'
print(f"Hello {message}") # =>Bonjour le monde!

use strict;
use warnings;

my $message = 'monde!';
print "Hello ${message}\n";  # =>Bonjour le monde!

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

use strict;
use warnings;

#Passer par la référence pour qu'elle puisse être intégrée dans la chaîne
print "1 + 2 = ${\(1 + 2)}\n";  # => 1 + 2 = 3

Ici document

import textwrap

report = textwrap.dedent(f"""
rapport
Date: {date}
""")

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

my $report = <<~EOF;  #Dédent Perl relativement nouveau
rapport
Date: ${\(localtime->strftime("%Y année%m mois%jour j"))}
    EOF

Arguments de ligne de commande

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

#Le nom du fichier programme lui-même$C'est en 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);

#Cela peut être un peu gênant car je l'ai envoyé de force à argparse de python.

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

Traitement à la fin et piégeage du signal

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

Requête HTTP (alternative à curl ou wget)

#Demander une URL avec GET et afficher le corps de la réponse
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'))

#Demander une URL avec GET et afficher le corps de la réponse
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] Comment écrire ce processus en Perl?

Comment écrire ce processus en Perl?

Sortie standard / sortie d'erreur standard

Lié au fichier

Opération de chemin

Traitez les chemins contenant les refroidisseurs et les variables d'environnement

Lecture et écriture de fichiers

Comptez le nombre de lignes (wc -l)

Énumération des fichiers

Informations sur le fichier (confirmation d'existence / date et heure de création)

Déplacer / Supprimer

copie

Commande externe

Exécutez simplement

Exécuter une commande externe et recevoir une sortie standard

Modifier les variables d'environnement et le répertoire courant

Utiliser la redirection

Utilisez une pipe

spawn → wait (démarrer une commande externe et attendre la fin)

Exécutez le shell

Relation temporelle

Relation de chaîne de caractères

Expression incorporée dans une chaîne

Ici document

Arguments de ligne de commande

Traitement à la fin et piégeage du signal

Requête HTTP (alternative à curl ou wget)

Comptez le nombre de lignes (`wc -l`)