Comment écrire ce processus en Perl?

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

Recommended Posts

Comment écrire ce processus en Perl?
Comment écrire sobrement avec des pandas
Comment écrire Ruby to_s en Python
Comment écrire un document tuple nommé en 2020
Comment écrire le bon shebang dans les scripts Perl, Python et Ruby
20e Comment écrire des problèmes en temps réel hors ligne en Python
Comment écrire une concaténation de chaînes sur plusieurs lignes en Python
XPath Basics (2) - Comment écrire XPath
Comment développer en Python
Comment écrire une validation personnalisée dans Django REST Framework
[Python] Comment écrire une instruction if en une phrase.
Résumé de l'écriture des fichiers .proto utilisés dans gRPC
Comment gérer une session dans SQLAlchemy
Comment utiliser les classes dans Theano
Comment collecter des images en Python
Réutilisation du flacon Comment écrire du HTML
Comment mettre à jour Spyder dans Anaconda
Comment utiliser SQLite en Python
Comment convertir 0,5 en 1056964608 en un seul coup
Comment refléter CSS dans Django
Comment tuer des processus en vrac
Comment utiliser Mysql avec python
Comment envelopper C en Python
Comment utiliser ChemSpider en Python
Comment utiliser PubChem avec Python
Comment écrire une image de base Docker
Comment écrire un fichier wsgi.py indépendant de l'environnement Django1.9
Comment exécuter du code TensorFlow 1.0 en 2.0
Remarques sur la rédaction de requirements.txt
Comment gérer le japonais avec Python
Comment se connecter à Docker + NGINX
Comment appeler PyTorch dans Julia
Repeated @ app.callback dans Dash Comment écrire correctement l'entrée et l'état
Le 15e comment écrire un problème de référence en temps réel hors ligne en Python
Comment utiliser les fonctions dans des fichiers séparés version Perl et version Python
Comment utiliser l'astérisque (*) en Python. C'est peut-être tout? ..
Comment écrire en temps réel hors ligne Résolution des problèmes E04 avec Python
Différence de vitesse d'exécution en fonction de la façon d'écrire la fonction Cython
Le 18ème comment écrire un problème de référence en temps réel hors ligne en Python
Comment utiliser les colonnes calculées dans CASTable
[Introduction à Python] Comment utiliser la classe en Python?
Comment supprimer l'erreur d'affichage dans matplotlib
Qiita (1) Comment écrire un nom de code
Comment définir dynamiquement des variables en Python
Comment définir optuna (comment écrire un espace de recherche)
Comment faire R chartr () en Python
Comment convertir csv en tsv dans la CLI
Comment écrire des commentaires de document Python (Docstrings)
Comment supprimer des sessions expirées dans Django
Comment utiliser Google Test en langage C
Comment implémenter un sérialiseur imbriqué avec drf-flex-fields
Comment utiliser BigQuery en Python
Comment exécuter des commandes avec Jupyter Notebook
Comment faire 'git fetch --tags' dans GitPython
Comment obtenir stacktrace en python
Comment afficher la table quatre-vingt-dix-neuf en python
Comment extraire une zone de polygone en Python