比较perl+python

sqrt exp log sin cos tan asin acos atan atan2

int($x)
round($x, 0)
ceil($x)
floor($x)
abs($x)

int(x)
int(round(x))
math.ceil(x)
math.floor(x)
abs(x)

min(1,2,3);
max(1,2,3);
@a = (1,2,3);
min(@a);
max(@a);

random.randint(0,99)
random.random()
random.gauss(0,1)

my $sd = srand;
srand($sd);

random.seed(17)
sd = random.getstate()
random.setstate(sd)

single quoted:
\‘ \\

Python 3:
\uhhhh \Uhhhhhhhh

fmt = ‘lorem {0} {1} {2}‘
fmt.format(‘ipsum‘, 13, 3.7)

juxtaposition can be used to concatenate literals:
s2 = ‘Hello, ‘ "World!"

trim " lorem "
ltrim " lorem"
rtrim "lorem "

anchors: ^ $ \A \b \B \z \Z

anchors: ^ $ \A \b \B \Z

my $s = "do re";
$s =~ s/(\w+) (\w+)/$2 $1/;

rx = re.compile(‘(\w+) (\w+)‘)
rx.sub(r‘\2 \1‘, ‘do re‘)

my $t = localtime(time);
my $utc = gmtime(time);

t = datetime.datetime.now()
utc = datetime.datetime.utcnow()

my $epoch = timelocal($t);
my $t2 = localtime(1304442000);

epoch = int(t.strftime("%s"))
t2 = dt.fromtimestamp(1304442000)

t = datetime.datetime.now()
epoch = int(t.strftime("%s"))

$t = localtime(time);
$fmt = "%Y-%m-%d %H:%M:%S";
print $t->strftime($fmt);

$s = "2011-05-03 10:00:00";
$fmt = "%Y-%m-%d %H:%M:%S";
$t = Time::Piece->strptime($s,$fmt);

s = ‘2011-05-03 10:00:00‘
fmt = ‘%Y-%m-%d %H:%M:%S‘
t = datetime.strptime(s, fmt)

$epoch = str2time("July 7, 1999");

s = ‘July 7, 1999‘
t = dateutil.parser.parse(s)

$now = localtime(time);
$now += 10 * ONE_MINUTE() + 3;

delta = datetime.timedelta(
  minutes=10,
  seconds=3)
t = datetime.datetime.now() + delta

$dt = DateTime->now();
$tz = DateTime::TimeZone->new(
  name=>"local");

$tz->name;
$tz->offset_for_datetime($dt) /
  3600;
$tz->is_dst_for_datetime($dt);

tm = time.localtime()
  
time.tzname[tm.tm_isdst]
(time.timezone / -3600) + tm.tm_isdst
tm.tm_isdst

($sec, $usec) = gettimeofday;

time.sleep(0.5)

class Timeout(Exception): pass

def timeout_handler(signo, fm):
  raise Timeout()

signal.signal(signal.SIGALRM,
  timeout_handler)

try:
  signal.alarm(5)
  time.sleep(10)
except Timeout:
  pass
signal.alarm(0)

@a = qw(x y z w);
$i = first {$a[$_] eq "y"} (0..$#a);

my @a = (1,2,[3,4]);
my $a2 = \@a;
my @a3 = @a;
my @a4 = @{dclone(\@a)};

a = [1,2,[3,4]]
a2 = a
a3 = list(a)
a4 = copy.deepcopy(a)

my @a = (1,2,2,3);
my @a2 = uniq @a;
@a = uniq @a;

reduce { $x + $y } 0, (1,2,3)

reduce(lambda x, y: x+y, [1,2,3], 0)

all { $_ % 2 == 0 } (1,2,3,4)
any { $_ % 2 == 0 } (1,2,3,4)

@a = (1, 2, 3, 4);
shuffle(@a);
none

a = [1, 2, 3, 4]
shuffle(a)
sample(a, 2)

@nums = (1, 2, 3);
@lets = qw(a b c);
# flat array of 6 elements:
@a = zip @nums, @lets;

a = [1,‘a‘,2,‘b‘,3,‘c‘]
d = dict(zip(a[::2], a[1::2]))

Python 3:
for k, v in d.items():
  code

Python 3:
list(d.keys())
list(d.values())

define a tied hash for computed values and defaults other than zero or empty string

counts = defaultdict(lambda: 0)
counts[‘foo‘] += 1

class Factorial(dict):
  def __missing__(self, k):
    if k > 1:
      return k * self[k-1]
    else:
      return 1

factorial = Factorial()

sub add {
  my ($a, $b) = @_;
  $a + $b;
}

parens are optional:
add 1, 2;

log($x)/log($base);
}

my_log(42);
my_log(42, exp(1));

def my_log(x, base=10):
  return math.log(x)/math.log(base)

my_log(42)
my_log(42, math.e)

fequal(1.0, 1.001)
fequal(1.0, 1.001, eps=0.1**10)

my $n = 7;
my $s = "hard";
foo($n, $s);

my @a = (1,2,3);
my %d = ("t"=> 1, "f" => 0);
foo(\@a, \%d);

a = [1,2,3]
d = {‘t‘:1, ‘f‘:0}
foo(a, d)

x, y = first_and_second([1,2,3])

sub counter {
  state $i = 0;
  ++$i;
}

print counter() . "\n";

counter.i = 0
print(counter())

nays = make_counter()

nays = make_counter()
print(nays.next())

@logcall
def square(x):
  return x * x

square(5)

given ($n) {
  when (0) { print "no hits\n"; }
  when (1) { print "one hit\n"; }
  default { print "$n hits\n"; }
}

foreach  (@a) {

print "$_\n";

}

@a = (1..5);

for (@a) {

print "$_\n"

}

for i, s in enumerate(a):

print(‘%s at index %d‘ % (s, i))

for i in [1,2,3]:

print(i)

$func = sub { sleep 10 };
$thr = threads->new($func);

thr = sleep10()
thr.start()

$f->flush();

copy("/tmp/foo", "/tmp/bar");
unlink "/tmp/foo";
move("/tmp/bar", "/tmp/foo");
unlink();

shutil.copy(‘/tmp/foo‘, ‘/tmp/bar‘)
os.remove(‘/tmp/foo‘)
shutil.move(‘/tmp/bar‘, ‘/tmp/foo‘)
os.remove()

$f = File::Temp->new();
print $f "lorem ipsum\n";
close $f;

print "tmp file: ";
print $f->filename . "\n";

f = tempfile.NamedTemporaryFile(
  prefix=‘foo‘)
f.write(‘lorem ipsum\n‘)
f.close()

print("tmp file: %s" % f.name)

f = StringIO()
f.write(‘lorem ipsum\n‘)
s = f.getvalue()

Python 3 moved StringIO to the io module

File::Spec->catfile("/etc", "hosts")

print dirname("/etc/hosts");
print basename("/etc/hosts");

Cwd::abs_path("..")

while ( </etc/*> ) {
   print basename($_) . "\n";
}

make_path "/tmp/foo/bar";

dircopy "/tmp/foodir",
  "/tmp/bardir";

shutil.copytree(‘/tmp/foodir‘,
  ‘/tmp/bardir‘)

remove_tree "/tmp/foodir";

shutil.rmtree(‘/tmp/foodir‘)

my ($src, $help);

sub usage {
  print "usage: $0 --f SRC\n";
  exit -1;
}

GetOptions("file=s" => \$src,
  "help" => \$help);

usage if $help;

parser = argparse.ArgumentParser()
parser.add_argument(‘--file‘, ‘-f‘,
  dest=‘file‘)

args = parser.parse_args()
src = args.file

$ENV{"PATH") = "/bin";

os.environ[‘PATH‘] = ‘/bin‘

def handler(signo, frame):
  print(‘exiting…‘)
  exit -1
signal.signal(signal.SIGINT, handler)

cmd = [‘ls‘, ‘-l‘, ‘/tmp‘]
if subprocess.call(cmd):
  raise Exception(‘ls failed‘)

cmd = [‘ls‘, ‘-l‘, ‘/tmp‘]
files = subprocess.check_output(cmd)