Der Unterschied zwischen PHP und Python wird aus Sicht von PHP als Memorandum zusammengefasst.
Wie auch immer, Python ist kurz und einfach zu schreiben. Das gleiche Ergebnis wird ausgegeben, auch wenn es wie folgt konvertiert wird. Es bleibt nichts anderes übrig, als sich an diese Kultur zu gewöhnen, anstatt sie zu lernen.
Vor der Konvertierung
def test(v):
r = []
if v > 0:
for i in range(v):
r += [v - i]
return r
Nach der Konvertierung
test = lambda v: [v - i for i in range(v)] if v > 0 else []
Es gibt auch Code Golf und es gibt einen Wettbewerb, um einen Kurzcode zu schreiben (siehe [hier] für Details (http://qiita.com/shibacho/items/37413a5d479d8bb57764)).
In Python3 können Sie eine Funktion namens Interaktiver Modus verwenden. Wenn Sie eine einzelne Codezeile eingeben, wird der Inhalt ausgewertet und ausgeführt. Getan werden. Wenn ein Fehler auftritt, wird vor Ort darauf hingewiesen, was für eine einfache Funktionsprüfung und -berechnung praktisch ist.
Ein Array, das in PHP selbstverständlich verwendet wurde. Python3 verfügt auch über ähnliche Funktionen wie list, tapple, dictionary und set, die jedoch je nach Verwendungszweck ordnungsgemäß verwendet werden müssen. Mit Ausnahme von Sets können Sie nicht nur Objekte, sondern auch Listen, Taples, Wörterbücher und Sets als Elemente wie PHP angeben.
Ein einfaches Array wie "$ a = [1, 2, 3];" in PHP kann in Python 3 mit "a = [1, 2, 3]" dargestellt werden. Mehrdimensional ist ebenfalls möglich. Jedes Element kann durch Setzen von "i, j, k = a" erhalten werden. Es ist jedoch erforderlich, ein Wörterbuch zu verwenden, um eine Funktion wie ein Referenzarray wie PHP zu realisieren.
PHP hat array_slice, aber Python 3 hat nützlichere Funktionen. Durch Setzen von "a = b [m: n]" kann das "n-1" -te Element aus dem "m" herausgeschnitten werden. Wenn m weggelassen wird, wird es von Anfang an sein, und wenn n weggelassen wird, wird es bis zum Ende sein. Wenn m und n negativ sind, können sie umgekehrt angegeben werden. Es gibt auch eine erweiterte Scheibe "a = b [:: m]", die jedes "m" erhalten werden kann.
a = [0, 1, 2, 3, 4, 5, 6, 7]
print(a[2:5])
print(a[4:])
print(a[:4])
print(a[-1:-4])
print(a[-1:])
print(a[:-4])
print(a[::3])
print(a[::-1])
Ausgabeergebnis
[2, 3, 4]
[4, 5, 6, 7]
[0, 1, 2, 3]
[4, 5, 6]
[4, 5, 6, 7]
[0, 1, 2, 3, 4, 5, 6]
[0, 3, 6]
[7, 6, 5, 4, 3, 2, 1, 0]
Wenn Sie "a [1: 6: 3]" einstellen, können Sie vom 1. bis zum 5. ausschneiden und alle 3 weiteren herausnehmen.
Wenn Sie sich an PHP gewöhnt haben, ist der Umgang mit Zeichenfolgen ein Problem. In Python3 kann es wie unten gezeigt in ein Array umgewandelt werden, sodass Zeichenfolgen einfach verarbeitet werden können.
a = "abcd"
b1 = list(a)
b2 = [a[i:i+2] for i in range(0, len(a), 2)]
print(b1, b2)
Ausgabeergebnis
['a', 'b', 'c', 'd'] ['ab', 'cd']
Eine Liste, deren Werte grob gesagt nicht geändert werden können. Es kann definiert werden als "a = (1, 2, 3)", und Elemente können auf die gleiche Weise wie eine Liste erhalten werden, indem "i, j, k = a" gesetzt wird. Im Fall von PHP war es bei Rückgabewerten mehrerer Funktionen erforderlich, sich die Mühe zu machen, in einem Array zurückzukehren. Im Fall von Python3 geben Sie unter Verwendung dieser Eigenschaft mit einem Taple wie "return r1, r2, r3" an tun können.
So etwas wie eine PHP-Referenzsequenz. Es kann beim Parsen von JSON verwendet werden. Nehmen Sie eine Python-Beschreibung wie "$ a = ['a' => 1, 'b' => 2];" als Beispiel in Python3: "a = {'a': 1, 'b': 2}" Kann ausgedrückt werden. Wenn Sie "i, j = a" setzen, können Sie auch den Schlüssel anstelle des Werts erhalten. Selbst wenn "b = Liste (a)" gesetzt ist, wird die Liste der Elemente, die aus den Schlüsseln von "a" bestehen, "b" zugewiesen.
Beim Erstellen eines Arrays mit eindeutigen Elementen in PHP musste jedes Mal "array_unique" angewendet werden, wie "$ a = array_unique" ([1, 1, 2, 3, 3, 3]); `, Durch die Definition von "a = {1, 2, 3}" in Python3 wird keine Duplizierung garantiert, selbst wenn danach "a.add (1)" verwendet wird.
l1 = [1, 2, 3]
print(l1)
l2 = [4, 5, 6, l1]
print(l2)
print(11 + l2)
t1 = ("a", "b", "c")
print(t1)
t2 = ("d", l1, l2)
print(t2)
print(t1 + t2)
d1 = {'a':l1, 1:l2, "c":t1}
s1 = set(l1)
print(s1)
print({'d1':d1, 's1':s1})
Ausgabeergebnis
[1, 2, 3]
[4, 5, 6, [1, 2, 3]]
[1, 2, 3, [4, 5, 6, [...]]]
('a', 'b', 'c')
('d', [1, 2, 3, [4, 5, 6, [...]]], [4, 5, 6, [1, 2, 3, [...]]])
('a', 'b', 'c', 'd', [1, 2, 3, [4, 5, 6, [...]]], [4, 5, 6, [1, 2, 3, [...]]])
{1, 3, 5}
{1, 3, 5}
{'d1': {1: [4, 5, 6, [1, 2, 3, [...]]], 'c': ('a', 'b', 'c'), 'a': [1, 2, 3, [4, 5, 6, [...]]]}, 's1': {1, 3, 5}}
Da es im Ausgabeergebnis als "..." abgekürzt wird, ist die Methode zum Anzeigen, ohne es wegzulassen, hier Wird hilfreich sein.
Python3 hat das Konzept unveränderlich und veränderlich. Unveränderlich bedeutet, dass es nicht geändert werden kann, und veränderlich bedeutet, dass es geändert werden kann. Die oben genannten Tupel sind unveränderlich und Listen, Wörterbücher und Mengen sind veränderlich. Dies ist das Verhalten von "Zuweisung", das sich zwischen PHP und Python3 stark unterscheidet. Das Verhalten dieser Zuweisung in Python3 ähnelt dem in Ruby und ist in [hier] zusammengefasst (http://qiita.com/hiroykam/items/e11fbfaa6974ed9ffb08).
In Python3 bedeutet Zuweisung "eine Einschränkung zwischen dem Ziel und dem Objekt vornehmen". Wenn Sie einer Variablen ein Objekt zuweisen, speichern Sie einen Verweis auf das Objekt in der Variablen. Das folgende Beispiel zeigt die Objekt-ID (Identifikationswert), wenn ein unveränderliches Objekt zugewiesen wird.
Durch Manipulieren der Variablen "a" wird die "ID" von "a" geändert, die unveränderlich ist, da sie für das ganzzahlige Objekt "3" nicht geändert werden kann. Hier wird ein solches Objekt der Einfachheit halber als unveränderliches Objekt behandelt.
a = 3
print("id_3:%d, id_a:%d" % (id(3), id(a)))
b = a
print("id_b:%d" % id(b))
a += 1
print("id_3:%d, id_4:%d, id_a:%d, id_b:%d" % (id(3), id(4), id(a), id(b)))
Ausgabeergebnis
id_3:1623654960, id_a:1623654960
id_b:1623654960
id_3:1623654960, id_4:1623654992, id_a:1623654992, id_b:1623654960
Selbst wenn der Wert durch Manipulieren von "a" geändert wird, ist er dieselbe "ID" und kann in einen anderen Wert geändert werden. Das heißt, es ist veränderlich (veränderbar). Hier wird ein solches Objekt der Einfachheit halber als veränderliches Objekt behandelt. Wenn der Wert von "a" "b" zugewiesen wird, ist die "id" dieselbe. Wenn also der Wert durch Manipulieren von "a" geändert wird, ändert sich auch "b".
a = [1,2,3]
b = a
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
a[1] = 4
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
Ausgabeergebnis
id_a:4332032456, id_b:4332032456
[1, 2, 3] [1, 2, 3]
id_a:4332032456, id_b:4332032456
[1, 4, 3] [1, 4, 3]
Im Fall eines veränderlichen Objekts, wie im obigen Beispiel, ist, wenn der Wert von "a" "b" zugewiesen ist, die "id" dieselbe. Wenn also der Wert durch Manipulieren von "a" geändert wird, "b" `Ändert sich auch. Sie müssen eine Kopie erstellen, um den Wert von "b" unabhängig von "a" zu machen. Im Fall der Liste oder des Arrays in diesem Beispiel kann dies durch Erstellen einer flachen Kopie realisiert werden. Im folgenden Beispiel ändert sich durch Erstellen einer flachen Kopie der Wert von "b" nicht, selbst wenn der Wert durch die Operation "a" geändert wird. Eine flache Kopie kann durch Ersetzen der Funktion "copy.copy" oder "a [:]" erstellt werden.
import copy as cp
a = [1,2,3]
b = cp.copy(a)
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
a[1] = 4
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
b = a[:]
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
a[1] = 3
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print(a, b)
Ausgabeergebnis
id_a:4460690760, id_b:4460690888
[1, 2, 3] [1, 2, 3]
id_a:4460690760, id_b:4460690888
[1, 4, 3] [1, 2, 3]
id_a:4460690760, id_b:4460691272
[1, 4, 3] [1, 4, 3]
id_a:4460690760, id_b:4460691272
[1, 3, 3] [1, 4, 3]
Im folgenden Beispiel, in dem das Element der Liste eine Liste und das Element des Arrays ein Array enthält, dh, es gibt ein anderes veränderbares Objekt aus dem veränderlichen Objekt, können Sie "a [0]" ausführen, selbst wenn Sie eine flache Kopie erstellen. Der Wert von "b [0]" wird geändert. Dies verhält sich für Python 3.6 und Ruby 2.4 gleich.
import copy as cp
a = [[1,2,3], "abc"]
b = cp.copy(a)
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
a[0][1] = 4
a[1] = "def"
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
b = a[:]
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
a[0][1] = 3
a[1] = "abc"
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
Ausgabeergebnis
id_a:4393106888, id_b:4393107272
id_a[0]:4393106760, id_b[0]:4393106760
id_a[1]:4391239728, id_b[1]:4391239728
[[1, 2, 3], 'abc'] [[1, 2, 3], 'abc']
id_a:4393106888, id_b:4393107272
id_a[0]:4393106760, id_b[0]:4393106760
id_a[1]:4392739984, id_b[1]:4391239728
[[1, 4, 3], 'def'] [[1, 4, 3], 'abc']
id_a:4393106888, id_b:4393112648
id_a[0]:4393106760, id_b[0]:4393106760
id_a[1]:4392739984, id_b[1]:4392739984
[[1, 4, 3], 'def'] [[1, 4, 3], 'def']
id_a:4393106888, id_b:4393112648
id_a[0]:4393106760, id_b[0]:4393106760
id_a[1]:4391239728, id_b[1]:4392739984
[[1, 3, 3], 'abc'] [[1, 3, 3], 'def']
Wenn ein veränderbares Objekt ein anderes veränderbares Objekt enthält, bei dem es sich um eine "flache Kopie ist nicht genug" handelt, müssen Sie eine tiefe Kopie anstelle einer flachen Kopie erstellen, um den Wert von "b" nach "a" vollständig zu kopieren. Es gibt.
Eine tiefe Kopie kann mit copy.deepcopy erreicht werden.
import copy as cp
a = [[1,2,3], "abc"]
b = cp.deepcopy(a)
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
a[0][1] = 4
a[1] = "def"
print("id_a:%d, id_b:%d" % (id(a), id(b)))
print("id_a[0]:%d, id_b[0]:%d" % (id(a[0]), id(b[0])))
print("id_a[1]:%d, id_b[1]:%d" % (id(a[1]), id(b[1])))
print(a, b)
Ausgabeergebnis
id_a:4306767304, id_b:4306767688
id_a[0]:4306767176, id_b[0]:4306773064
id_a[1]:4304900144, id_b[1]:4304900144
[[1, 2, 3], 'abc'] [[1, 2, 3], 'abc']
id_a:4306767304, id_b:4306767688
id_a[0]:4306767176, id_b[0]:4306773064
id_a[1]:4306400400, id_b[1]:4304900144
[[1, 4, 3], 'def'] [[1, 2, 3], 'abc']
Bei PHP wird der Wert der Variablen auf der rechten Seite durch Zuweisen auf den Wert der Variablen auf der linken Seite kopiert. Es verhält sich wie eine tiefe Kopie von Python 3. Darüber hinaus kann eine Zuweisung durch Referenz wie "$ a = & $ b;" in PHP in Python3 nicht realisiert werden.
<?php
$a = [3];
$b = &$a;
$a = [5];
print_r($a);
print_r($b);
Ausgabeergebnis
Array
(
[0] => 5
)
Array
(
[0] => 5
)
Im obigen Beispiel ändern sich die Referenzwerte von $ b und $ a nicht, selbst wenn "$ a = [5];".
In PHP wurden bei doppelten Anführungszeichen Sonderzeichen und Variablen in der Zeichenfolge ersetzt, bei einfachen Anführungszeichen nicht. In Python3 wird das Escape-Zeichen ersetzt und in beiden Fällen ausgegeben. Um einen Austausch zu vermeiden, stellen Sie "r" oder "R" voran.
<?php
print("a\r\nb");
print('a\r\nb');
Ausgabeergebnis
a
ba\r\nb
print("a\r\nb")
print('a\r\nb')
print(r"a\r\nb")
print(R"a\r\nb")
Ausgabeergebnis
a
b
a
b
a\r\nb
a\r\nb
Notation von $ a> 0 && $ a <10 im bedingten Ausdruck in PHP. In Python3 möchte ich auch "a> 0" und "a <10" setzen, aber es kann vereinfacht werden als "0 <a <10".
Formate wie "$ a = $ f?" Hallo ":" Welt ", die in PHP bekannt sind. In Pyhon3 lautet das Format "a =" Hallo ", wenn" sonst "Welt". Die Funktion besteht darin, "if" und "else" mit dem ternären Operator zu verwenden.
In Python3 führen Formate wie "i ++" und "i -" zu einem Fehler. Das Inkrement ist "i + = 1" oder "i- = 1".
foreach
Foreach und Python3, die in PHP unverzichtbar sind, können mit for dasselbe oder besser machen, wie im folgenden Beispiel gezeigt.
print("Muster 1")
for v in range(1, 4):
print(v)
print("Muster 2")
for v in [x for x in range(4, 1, -1)]:
print(v)
print("Muster 3")
for v in (1, 2, 3):
print(v)
print("Muster 4")
for k, v in enumerate([1, 2, 3]):
print(k, v)
print("Muster 5")
for k, v in {"a":1, "b":2}.items():
print(k, v)
print("Muster 6")
for k in {"a":1, "b":2}.keys():
print(k)
print("Muster 7")
for v in {"a":1, "b":2}.values():
print(v)
print("Muster 8")
for v in [1, 2]:
print(v)
else:
print("else", v)
print("Muster 9")
for v in [1, 2]:
print(v)
break
else:
print("else", v)
print("Muster 10")
for v in [1, 2]:
print(v)
continue
else:
print("else", v)
print("Muster 11")
for v1, v2, v3, v4 in zip([1, 2], (2, 1, 3), {1:"d", 2:"i", 3:"c"}, {"s", "e", "t"}):
print(v1, v2, v3, v4)
print("Muster 12")
for v1, v2 in zip([1, 2], [3, 4, 5, 6]):
print(v1, v2)
print("Muster 13")
import itertools as it
for v1, v2 in it.zip_longest([1, 2], [3, 4, 5, 6]):
print(v1, v2)
Ausgabeergebnis
Muster 1
1
2
3
Muster 2
4
3
2
Muster 3
1
2
3
Muster 4
0 1
1 2
2 3
Muster 5
a 1
b 2
Muster 6
a
b
Muster 7
1
2
Muster 8
1
2
else 2
Muster 9
1
Muster 10
1
2
else 2
Muster 11
1 2 1 s
2 1 2 e
Muster 12
1 3
2 4
Muster 13
1 3
2 4
None 5
None 6
range
Abgesehen davon hat range unterschiedliche Grenzwerte zwischen PHP und Python3.
<?php
print_r(range(0, 10, 2));
Ausgabeergebnis
Array
(
[0] => 0
[1] => 2
[2] => 4
[3] => 6
[4] => 8
[5] => 10
)
print(list(range(0, 10, 2)))
Ausgabeergebnis
[0, 2, 4, 6, 8]
Es gibt einen Unterschied zwischen PHP und Python3. Beschrieben unter dem Gesichtspunkt des Codevergleichs durch Unterteilung in Muster.
Die Funktion "inner" hat eine Namensauflösung und kann von außen aufgerufen werden. Die Manipulation von extern definierten Variablen innerhalb der "inneren" Funktion hat keine Auswirkung auf die Außenseite, es sei denn, sie wird als Referenz übergeben. Außerdem werden außerhalb definierte Variablen als außerhalb des Gültigkeitsbereichs behandelt.
<?php
function outer($arg1)
{
$out1 = 3;
function inner($arg1, $arg2, &$arg3)
{
$arg1 += isset($out1) ? $out1 : -1;
$arg2 += 5;
$arg3 += 11;
print($arg1. " : inner arg1\n");
print($arg2. " : inner arg2\n");
print($arg3. " : inner arg3\n");
}
inner($arg1, $arg1, $out1);
print($arg1. " : outer arg1\n");
print($out1. " : outer out1\n");
}
outer(10);
$a = 13;
inner(1, 7, $a);
print($a. " : a");
Ausgabeergebnis
9 : inner arg1
15 : inner arg2
14 : inner arg3
10 : outer arg1
14 : outer out1
0 : inner arg1
12 : inner arg2
24 : inner arg3
24 : a
Da der Name der "inneren" Funktion nicht aufgelöst wird, muss der Rückgabewert von "äußere" abgerufen und aufgerufen werden, um die "innere" Funktion von außen aufzurufen. Sie können auch auf extern definierte Variablen zugreifen.
Wie Sie aus dem Ergebnis von 15: inner arg1 sehen können, ist out1 [14] und der vorherige Status wird gespeichert.
def outer(arg1):
out1 = [3]
def inner(arg1, arg2, arg3):
arg1 += -1 if out1 is None else out1[0]
arg2 += 5
arg3[0] += 11
print(arg1, "inner arg1", sep=" : ")
print(arg2, "inner arg2", sep=" : ")
print(arg3[0], "inner arg3", sep=" : ")
inner(arg1, arg1, out1)
print(arg1, "outer arg1", sep=" : ")
print(out1[0], "outer out1", sep=" : ")
return inner
f = outer(10)
a = [13]
f(1, 7, a)
print(a[0], "a", sep=" : ")
Ausgabeergebnis
13 : inner arg1
15 : inner arg2
14 : inner arg3
10 : outer arg1
14 : outer out1
15 : inner arg1
12 : inner arg2
24 : inner arg3
24 : a
Der Einfachheit halber wird die anonyme Funktion zweimal definiert. Der Abschluss wird mit der Funktion "Outer" zurückgegeben, und der Abschluss wird mit "array_map" auch innerhalb des Verschlusses definiert. Auf extern definierte Variablen kann mit use zugegriffen werden.
<?php
function outer($arg1)
{
$out = 2;
return function ($arg2) use ($arg1, $out) {
$a = [0 => $arg1, 1 => $arg1 * 2, 2 => $arg1 * 3];
return array_map(function ($k, $v) use ($arg2, $out) {
return ($v + $arg2) * $k + $out;
}, array_keys($a), array_values($a));
};
}
$f = outer(1);
print_r($f(3));
Ausgabeergebnis
Array
(
[0] => 2
[1] => 7
[2] => 14
)
Geben Sie den Verschluss mit der Funktion "Outer" wie in PHP zurück. Anonyme Funktionen können mit "Lambda" definiert werden, es gibt jedoch eine Einschränkung, dass Variablen nicht definiert werden können.
def outer(arg1):
out = 2
def inner(arg2):
a = {0:arg1, 1:arg1 * 2, 2:arg1 * 3}
return map(lambda v: (v[1] + arg2) * v[0] + out, a.items())
return inner
f = outer(1)
print(list(f(3)))
Ausgabeergebnis
[2, 7, 14]
Variable Variablen und Funktionen, die manchmal in PHP verwendet wurden. Vergleichen wir den Code für PHP und Python3.
<?php
$a1 = "b1";
$b1 = "test1";
$a2 = "b2";
function b2 () {
print("test2");
}
print($$a1. "\n");
print($a2());
Ausgabeergebnis
test1
test2
Die Benutzerfreundlichkeit unterscheidet sich von PHP, aber das Gleiche kann erreicht werden.
a1 = "b1"
b1 = "test1"
a2 = "b2"
def b2():
print("test2")
print(locals()[a1])
print(globals()[a1])
print(eval(a1))
locals()[a2]()
globals()[a2]()
eval(a2)()
Ausgabeergebnis
test1
test1
test1
test2
test2
test2
Ich war verwirrt, als ich mir den Python 3-Code auf GitHub ansah, also eine kurze Anmerkung. Wie der Name schon sagt, schmückt es.
def deco1(func):
def overwrite():
print("overwrite is called")
func()
return overwrite
def deco2(func):
import functools
@functools.wraps(func)
def overwrite(*args,**kwargs):
print("overwrite2 is called")
func(*args,**kwargs)
return overwrite
@deco1
def test1():
print('test1 is called')
test1()
print(test1.__name__)
@deco2
def test2():
print('test2 is called')
test2()
print(test2.__name__)
Hier ist leicht verständlich organisiert.
Anmerkungen, die Sie bei der Verwendung von PHPDoc hören. Es kann mit Python3 verwendet werden, aber es kann auch für verschiedene Dinge wie Generika verwendet werden. Wenn Sie mit diesen Funktionen nicht vertraut sind, werden Sie verwirrt, wenn Sie sich den Python-Code ansehen. Daher möchte ich die Funktionen selbst kennen. Klicken Sie hier für Details (http://qiita.com/icoxfog417/items/c17eb042f4735b7924a3)
Funktionen höherer Ordnung sind sowohl in PHP als auch in Python3 verfügbar. Es scheint kaum einen Unterschied zu geben.
map Zunächst für "map" ein Verarbeitungsbeispiel, das alle Elemente des Arrays quadriert.
<?php
$r1 = array_map(function($n) {
return $n ** 2;
}, range(1, 9));
print_r($r1);
Ausgabeergebnis
Array
(
[0] => 1
[1] => 4
[2] => 9
[3] => 16
[4] => 25
[5] => 36
[6] => 49
[7] => 64
[8] => 81
)
Dies kann auch durch Einschlussnotation realisiert werden.
r11 = list(map(lambda n: n ** 2, range(1, 10)))
r12 = [n ** 2 for n in range(1, 10)]
print(r11)
print(r12)
Ausgabeergebnis
[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
filter Ein Beispiel, das Elemente mit nur geraden Werten extrahiert.
<?php
$r2 = array_filter(range(1, 9), function($n) {
return $n % 2 == 0;
});
print_r($r2);
Ausgabeergebnis
Array
(
[1] => 2
[3] => 4
[5] => 6
[7] => 8
)
Dies kann sowohl durch die Einschlussnotation als auch durch "Karte" realisiert werden.
r21 = list(filter(lambda n: n % 2 == 0, range(1, 10)))
r22 = [n for n in range(1, 10) if n % 2 == 0]
print(r21)
print(r22)
Ausgabeergebnis
[2, 4, 6, 8]
[2, 4, 6, 8]
reduce Es gibt ein Gefühl der Inkongruenz, wenn es als Falten oder Verringern übersetzt wird, also interpretiere ich es so. Ist es in Rubin "injizieren"? Hier ist ein Beispiel, in dem die Elemente als Ganzzahlen aufgelistet sind.
<?php
$r3 = array_reduce(range(1, 9), function($a, $b) {
return $a * 10 + $b;
}, 0);
print_r($r3);
Ausgabeergebnis
123456789
Benötigt functools.
from functools import reduce
r3 = reduce(lambda a, b: a * 10 + b, range(1, 10))
print(r3)
Ausgabeergebnis
123456789
PHP hat mehr Funktionen vom Typ Array, aber ich frage mich oft, was ich verwenden soll und wo ich es verwenden soll. Verwendet oft array_walk als Haupt.
Um einen regulären Ausdruck im PCRE-Format zu verwenden, muss das Muster in PHP in einem Trennzeichen eingeschlossen sein. Am Beispiel einer 4-stelligen Zahl wird das Muster als "/ \ d {4} /" ausgedrückt.
Fügen Sie andererseits in Python3 zuerst "r" zu der Zeichenfolge hinzu, die zum Muster wird. Auf diese Weise wird r" \ n " nicht als Zeilenvorschubcode behandelt, sondern kann als Zeichenfolge aus \ (Schrägstrich) und n interpretiert werden. Wenn r nicht hinzugefügt wird, muss es" \\\\ n " sein. Außerdem wird das Muster für reguläre Ausdrücke kompiliert und als Objekt für reguläre Ausdrücke mit "re.compile (" / \ d {4} / ")" verwendet ("import re" ist erforderlich).
Eine einfache Ähnlichkeitsvergleichstabelle zwischen PHP und Python 3 sieht folgendermaßen aus:
| PHP | Python | Bemerkungen |
|---|---|---|
| preg_match | re.findall | re.Wenn im Muster eine Menge angegeben ist, tippt findall auf die Elemente des Arrays, und die Mengenelemente werden dort angezeigt. |
| re.match | re.Übereinstimmung bestätigt Übereinstimmung nur am Anfang | |
| re.search | re.Die Suche kann an einer beliebigen Stelle in der Zeichenfolge erfolgen | |
| preg_replace | re.sub | Das erste übereinstimmende Zeichen ist${1}（PHP）、\1Anders als (Python) |
| preg_replace_callback | re.Das Argument repl von sub kann eine Zeichenfolge oder eine Funktion sein | |
| preg_split | re.split |
Der Umgang mit regulären Ausdrücken in PHP und Python3 ist in [hier] zusammengefasst (http://qiita.com/hiroykam/items/e42a050c56a5fbf08247).
private、protected Python 3 ist weder privat noch geschützt. Fügen Sie daher für den üblichen Betrieb ein oder zwei Unterbalken (_) hinzu.
class Test(object):
def __init__(self):
self.value = "value"
self._value = "_value"
self.__value = "__value"
def method(self): print("method")
def _method(self): print("_method")
def __method(self): print("__method")
t = Test()
print(t.value)
print(t._value)
print(t._Test__value)
t.method()
t._method()
t._Test__method()
Ausgabeergebnis
value
_value
__value
method
_method
__method
Statische Methoden sind bei der Verwendung von PHP bekannt. Der Unterschied zur statischen Methode besteht darin, ob Class selbst als erstes Argument empfangen werden soll. Es ist leicht zu bestimmen, aus welcher Klasse es ausgeführt wird. Im Gegensatz zu PHP kann es von einer Instanz der Klasse aufgerufen werden. Für beide ist ein Dekorateur erforderlich.
class MyParent(object):
var = "parent"
@staticmethod
def static_test(called):
print(called, MyParent.var)
@classmethod
def class_test(cls, called):
print(called, cls.var)
class MyChild(MyParent):
var = "child"
def test(self):
print("child test")
MyParent.class_test("Parent")
MyParent.static_test("Parent")
MyParent.class_test("Child")
MyParent.static_test("Child")
p = MyParent()
c = MyChild()
p.static_test(p.__class__)
p.class_test(p.__class__)
c.static_test(c.__class__)
c.class_test(c.__class__)
Ausgabeergebnis
Parent parent
Parent parent
Child parent
Child parent
<class '__main__.MyParent'> parent
<class '__main__.MyParent'> parent
<class '__main__.MyChild'> parent
<class '__main__.MyChild'> child
Wenn Sie eine Klassenmethode wie Python3 in PHP implementieren, sieht es folgendermaßen aus: In diesem Fall kann das gleiche Ergebnis erzielt werden, indem "new static ()" in "new self ()" geändert wird.
<?php
class MyParent
{
public $var = "parent";
public static function class_method($called) {
$cls = new static();
print($called. " ". $cls->var. "\n");
}
}
class MyChild extends MyParent
{
public $var = "child";
}
MyParent::class_method("Parent");
MyChild::class_method("Child");
Ausgabeergebnis
Parent parent
Child child
Python 3 hat eine Syntax mit.
Es ist ähnlich wie bei PHP.
file = open("filename")
try:
print(file.read())
finally:
file.close()
Es wird sehr einfach sein.
with open("filename") as file:
print(file.read())
Sie können Klasseninstanzen mit Syntax behandeln, indem Sie in der Klasse "enter" und "exit" definieren.
class WithTest:
def __init__(self, name):
self._name = name
def print(self):
print(self._name)
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
print("end of with statement!")
with WithTest("With Statement!") as t:
t.print()
Ausgabeergebnis
With Statement!
end of with statement!
Iterator, der relativ zum zeilenweisen Lesen und Verarbeiten von Dateien wie CSV verwendet wird, um Taples aus einer Tabelle zu extrahieren und einzeln zu verarbeiten. Sowohl PHP als auch Python haben Iteratoren und Generatoren, aber bereiten Sie den Code tatsächlich vor und versuchen Sie festzustellen, ob es einen Unterschied gibt.
Python 3 kann auf die gleiche Weise wie PHP implementiert werden. Python 3 verfügt jedoch standardmäßig über eine integrierte Funktion.
Es ist etwas ärgerlich, weil es die Iterator-Schnittstelle implementiert, sodass Sie nur "next" und andere Methoden definieren müssen.
<?php
class MyIterator implements Iterator
{
private $var = [];
public function __construct($array)
{
if (is_array($array)) {
$this->var = $array;
}
}
public function rewind()
{
reset($this->var);
}
public function current()
{
return current($this->var);
}
public function key()
{
return key($this->var);
}
public function next()
{
return next($this->var);
}
public function valid()
{
$key = key($this->var);
return ($key !== NULL && $key !== FALSE);
}
}
$iter = new MyIterator([1, 2, 3, 4, 5]);
foreach ($iter as $k => $v) {
print("$k: $v\n");
}
Ausgabeergebnis
0: 1
1: 2
2: 3
3: 4
4: 5
Es kann einfacher als PHP implementiert werden, aber seien Sie vorsichtig, da Sie nach Abschluss des Vorgangs "StopIteration" auslösen müssen.
class MyIterator:
def __init__(self, *numbers):
self._numbers = numbers
self._i = 0
def __iter__(self):
return self
def __next__(self):
if self._i == len(self._numbers):
raise StopIteration()
v = self._numbers[self._i]
self._i += 1
return v
iter = MyIterator(1, 2, 3, 4, 5)
for i, num in enumerate(iter):
print("{0}:{1}".format(i, num))
Ausgabeergebnis
0:1
1:2
2:3
3:4
4:5
Generatoren sind auch in Python 3 und PHP (5.5+) verfügbar. Im Beispiel hier werden die folgenden Dateien gelesen.
numbers.txt
zero
one
two
three
four
five
Die Implementierungsmethode ist für PHP und Python3 nahezu identisch.
<?php
function my_generator($name)
{
$file = fopen($name, "r");
if ($file) {
while ($line = fgets($file)) {
yield $line;
}
}
fclose($file);
}
$g = my_generator("numbers.txt");
foreach ($g as $k => $v) {
print($k. ":". $v);
}
Ausgabeergebnis
0:zero
1:one
2:two
3:three
4:four
5:five
def my_generator(name):
with open(name) as lines:
for line in lines:
yield line
g = my_generator("numbers.txt")
for k, v in enumerate(g):
print("{0}:{1}".format(k, v), end="")
Ausgabeergebnis
0:zero
1:one
2:two
3:three
4:four
5:five
Es ist dasselbe, da es von "send" gesendet wird, aber die Benutzerfreundlichkeit unterscheidet sich zwischen PHP und Python.
Ein Bild, das Daten an "Yield" sendet. Das Ausgabeergebnis ist das gleiche wie bei der "grundlegenden Implementierungsmethode".
<?php
function my_generator()
{
$k = 0;
while (true) {
$v = yield;
print($k++. ":". $v);
}
}
$g = my_generator();
$file = fopen("numbers.txt", "r");
if ($file) {
while ($line = fgets($file)) {
$g->send($line);
}
}
Ein Bild, das Daten an die durch "Yield" angegebene Variable sendet. Es scheint sich von PHP darin zu unterscheiden, dass es notwendig ist, "next" einmal auszuführen, um an die Position "Ausbeute" zu gelangen. Das Ausgabeergebnis ist das gleiche wie bei der "grundlegenden Implementierungsmethode".
def my_generator():
k, v = 0, ""
while True:
v = yield v
print("{0}:{1}".format(k, v), end="")
k += 1
g = my_generator()
g.__next__()
with open("numbers.txt") as lines:
for line in lines:
g.send(line)
Sie können rekursive Logik mit "Ausbeute von" erreichen.
Implementiert von PHP7. Das Ausgabeergebnis ist das gleiche wie bei der "grundlegenden Implementierungsmethode". Es gibt nicht viel Verdienst beim Lesen von Dateien, aber bei Operationen wie Arrays scheint es, dass es Python 3 entsprechen kann.
<?php
function my_generator($name)
{
$from = function () use ($name) {
$file = fopen($name, "r");
if ($file) {
while ($line = fgets($file)) {
yield $line;
}
}
fclose($file);
};
yield from $from();
}
$g = my_generator("numbers.txt");
foreach ($g as $k => $v) {
print($k. ":". $v);
}
Das Ausgabeergebnis ist das gleiche wie bei der "grundlegenden Implementierungsmethode". Die "grundlegende Implementierungsmethode" macht Schleifen überflüssig und vereinfacht dies.
def my_generator(name):
with open(name) as lines:
yield from lines
g = my_generator("numbers.txt")
for k, v in enumerate(g):
print("{0}:{1}".format(k, v), end="")
interface、abstract In Python3 gibt es keine Schnittstelle wie PHP. Da Python3 mehrfach vererbt werden kann, erscheint es zunächst unnötig. In Python3 können abstrakte Klassen mit dem Modul ABC (Abstract Base Class) implementiert werden. Darüber hinaus scheint Trait für Python 3 nicht erforderlich zu sein, da eine Mehrfachvererbung möglich ist.
Um eine abstrakte Methode bereitzustellen, ist die Klassenmetaklasse (angegeben durch "metaclass") "ABCMeta" oder erbt sie. Aus dem folgenden Ausgabeergebnis können Sie auch eine abstrakte Methode in einer abstrakten Klasse implementieren. Selbst wenn sie in einer Unterklasse nicht definiert ist, tritt kein Fehler auf.
python
from abc import *
class MyAbstract(object):
__metaclass__ = ABCMeta
@abstractmethod
def test1(self):
print("method")
@staticmethod
@abstractmethod
def static_test():
print("static_method")
@classmethod
@abstractmethod
def class_test(cls):
print("class_method")
class Test(MyAbstract):
pass
MyAbstract.static_test()
MyAbstract.class_test()
Test.static_test()
Test.class_test()
p = MyAbstract()
p.test1()
t = Test()
t.test1()
Ausgabeergebnis
static_method
class_method
static_method
class_method
method
method
Wenn Sie dasselbe Verhalten wie bei PHP erwarten, kann eine ähnliche Operation ausgeführt werden, indem in der Methode der übergeordneten Klasse Folgendes definiert wird.
def test1(self):
raise NotImplementedError("error message")
Eine andere Methode besteht darin, eine Klasse vorzubereiten, die die Klassenmethode "subclasshook" wie unten gezeigt überschreibt, und zu überprüfen, ob die Methode durch die integrierte Funktion "issubclacss" definiert ist. Der Scheck wird durch "Registrieren" bestanden.
from abc import ABCMeta
class MyAbstract(metaclass=ABCMeta):
@classmethod
def __subclasshook__(cls, C):
if cls is MyAbstract:
if any("test" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class A(object):
pass
class B(object):
def test(self):
print("test")
print(issubclass(A, MyAbstract))
print(issubclass(B, MyAbstract))
MyAbstract.register(A)
print(issubclass(A, MyAbstract))
Ausgabeergebnis
False
True
True
PHPs Magic Method ist der sogenannte Python3 Data Model Special Method Name. /3.6/reference/datamodel.html#special-method-names). Es gibt viele ähnliche Elemente, wie z. B. "__toString" von PHP, das dem "str" von Python3 entspricht.
Sie können die Eigenschaften eines Objekts mit get_object_vars abrufen.
<?php
class Magic
{
public function __get($name)
{
return 0;
}
public function __call($name, $arguments)
{
print($arguments[0]. "\n");
}
}
$m = new Magic();
print($m->x. "\n");
$m->x = 10;
print($m->x. "\n");
print($m->test(20));
print_r(get_object_vars($m));
Ausgabeergebnis
0
10
20
Array
(
[x] => 10
)
Da die Instanzvariable in __dict__ gespeichert ist, kann ihr Inhalt mit der eingebauten Funktion vars abgerufen werden.
class Magic(object):
def __getattr__(self, name):
class Callable(int):
def __call__(self, *arguments):
print(arguments[0])
return Callable(0)
m = Magic()
print(m.x)
m.x = 10
print(m.x)
m.test(20)
print(vars(m))
Ausgabeergebnis
0
10
20
{'x': 10}
Setter/Getter Nebenbei können Sie in Python 3 Setter / Getter auch auf folgende Weise definieren.
class Magic(object):
def __init__(self):
self._x = 0
self._y = 0
def getx(self):
return self._x
def setx(self, value):
self._x = value
x = property(getx, setx)
@property
def y(self):
return self._y
@y.setter
def y(self, value):
self._y = value
m = magic()
print(m.x)
print(m.y)
m.x = 10
m.y = 20
print(m.x)
print(m.y)
Ausgabeergebnis
0
0
10
20
Recommended Posts