Résumé des différences entre PHP et Python

Un mémorandum sur la différence entre PHP et Python3

La différence entre PHP et Python est résumée dans un mémorandum du point de vue de PHP.

Mettre court

Quoi qu'il en soit, Python est court et facile à écrire. Le même résultat est produit même s'il est converti comme suit. Il n'y a pas d'autre choix que de s'habituer à cette culture plutôt que de l'apprendre.

Avant la conversion

def test(v):
    r = []
    if v > 0:
        for i in range(v):
            r += [v - i]
    return r

Après la conversion

test = lambda v: [v - i for i in range(v)] if v > 0 else []

Il y a aussi le code golf, et il y a une compétition pour écrire un code court (voir [ici] pour plus de détails (http://qiita.com/shibacho/items/37413a5d479d8bb57764)).

Mode interactif

En Python3, vous pouvez utiliser une fonction appelée Mode interactif, et si vous entrez une seule ligne de code, le contenu sera évalué et exécuté. Sera fait. S'il y a une erreur, elle sera signalée sur place, ce qui est pratique pour un contrôle et un calcul simples du fonctionnement.

Tableau

Liste, tuple, dict, ensemble

Un tableau qui a été utilisé naturellement en PHP. Python3 a également des fonctions similaires telles que liste, tapple, dictionnaire et set, mais il est nécessaire de les utiliser correctement en fonction du but de l'utilisation. À l'exception des ensembles, vous pouvez spécifier non seulement des objets, mais également des listes, des taples, des dictionnaires et des ensembles en tant qu'éléments comme PHP.

liste

Un tableau simple comme $ a = [1, 2, 3]; en PHP peut être représenté en Python 3 avec ʻa = [1, 2, 3] . Le multi-dimensionnel est également possible. Chaque élément peut être obtenu en définissant ʻi, j, k = a. Cependant, il est nécessaire d'utiliser un dictionnaire pour réaliser une fonction comme un tableau de référence comme PHP.

Tranche de liste

PHP a ʻarray_slice, mais Python 3 a des fonctionnalités plus utiles. En réglant ʻa = b [m: n] , le n-1e élément du mth peut être coupé. Si «m» est omis, ce sera depuis le début, et si «n» est omis, ce sera jusqu'à la fin. Si «m» et «n» sont négatifs, ils peuvent être spécifiés en sens inverse. De plus, il existe une tranche étendue ʻa = b [:: m] , qui peut être obtenue chaque m`.

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])

Résultat de sortie

[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]

Si vous définissez ʻa [1: 6: 3] `, vous pouvez couper du 1er au 5e, et en retirer tous les 3 de plus.

De la chaîne à la liste

Lorsque vous vous habituez à PHP, la gestion des chaînes de caractères est un problème. Dans Python3, il peut être transformé en un tableau comme indiqué ci-dessous, il est donc facile de gérer les chaînes de caractères.

a = "abcd"
b1 = list(a)
b2 = [a[i:i+2] for i in range(0, len(a), 2)]
print(b1, b2)

Résultat de sortie

['a', 'b', 'c', 'd'] ['ab', 'cd']

Tuple

Une liste dont les valeurs ne peuvent pas être modifiées, en gros. Il peut être défini comme ʻa = (1, 2, 3) , et les éléments peuvent être obtenus de la même manière qu'une liste en définissant ʻi, j, k = a. Dans le cas de PHP, s'il y a des valeurs de retour de plusieurs fonctions, il fallait se donner la peine de retourner dans un tableau, mais dans le cas de Python3, en utilisant cette propriété, spécifiez avec un taple comme return r1, r2, r3. peut faire.

Dict

Quelque chose comme une séquence de référence PHP. Il peut être utilisé lors de l'analyse de JSON. Par exemple, une description PHP telle que $ a = ['a' => 1, 'b' => 2];, en Python3, ʻa = {'a': 1, 'b': 2} Peut être exprimé. De plus, si ʻi, j = a, vous pouvez obtenir la clé au lieu de la valeur. Même si «b = list (a)» est défini, la liste des éléments composés des clés de «a» est affectée à «b».

Ensemble

Lors de la création d'un tableau avec des éléments uniques en PHP, il était nécessaire d'appliquer ʻarray_unique à chaque fois comme $ a = array_unique ([1, 1, 2, 3, 3, 3]); , En définissant ʻa = {1, 2, 3} dans Python3, aucune duplication n'est garantie même si ʻa.add (1)` est utilisé par la suite.

Exemples d'utilisation de listes, taples, dictionnaires et ensembles dans Python3

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

Résultat de sortie

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

Puisqu'il est abrégé en ... dans le résultat de sortie, la méthode à afficher sans l'omettre est ici Sera utile.

Substitution

Mutable immuable

Python3 a le concept d'immuable et de mutable. Immuable signifie immuable, mutable signifie mutable. Les tuples mentionnés ci-dessus sont immuables et les listes, dictionnaires et ensembles sont modifiables. C'est le comportement d '«affectation», qui est très différent entre PHP et Python3. Le comportement de cette affectation dans Python3 est similaire à celui de Ruby et est résumé dans here.

Affectation Python3

En Python3, l'affectation signifie "créer une contrainte entre la cible et l'objet". Lorsque vous affectez un objet à une variable, vous stockez une référence à l'objet dans la variable. Voici un exemple de sortie de l'ID d'objet (valeur d'identification) lorsqu'un objet immuable est attribué.

Pour les objets immuables

La manipulation de la variable ʻa change l'id de ʻa, qui est immuable car il ne peut pas être changé pour l'objet entier 3`. Ici, pour des raisons de commodité, un tel objet est traité comme un objet immuable.

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)))

Résultat de sortie

id_3:1623654960, id_a:1623654960
id_b:1623654960
id_3:1623654960, id_4:1623654992, id_a:1623654992, id_b:1623654960

Pour les objets mutables

Même si la valeur est modifiée en manipulant ʻa, c'est le même ʻid et peut être changé en une valeur différente. Autrement dit, il est mutable (modifiable). Ici, pour plus de commodité, un tel objet est traité comme un objet mutable. Lorsque la valeur de ʻa est assignée à b, ʻid est le même, donc si la valeur est modifiée en manipulant ʻa, b` change également.

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)

Résultat de sortie

id_a:4332032456, id_b:4332032456
[1, 2, 3] [1, 2, 3]
id_a:4332032456, id_b:4332032456
[1, 4, 3] [1, 4, 3]

Copie superficielle

Dans le cas d'un objet mutable, comme dans l'exemple ci-dessus, si la valeur de «a» est affectée à «b», «id» est le même, donc si la valeur est modifiée en opérant «a», «b ʻAussi change. Vous devez faire une copie pour rendre la valeur de «b» indépendante de «a». Dans le cas de la liste ou du tableau dans cet exemple, il peut être réalisé en faisant une copie superficielle. Dans l'exemple ci-dessous, en faisant une copie superficielle, la valeur de «b» ne change pas même si la valeur est modifiée par l'opération de «a». Une copie superficielle peut être faite en remplaçant la fonction copy.copy ou ʻa [:]`.

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)

Résultat de sortie

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]

Cas où la copie superficielle ne suffit pas

Par exemple, dans l'exemple suivant où il y a une liste dans l'élément de la liste et un tableau dans l'élément du tableau, c'est-à-dire qu'il y a un autre objet mutable de l'objet mutable, même si vous faites une copie superficielle, vous pouvez opérer ʻa [0] `. La valeur de «b [0]» est modifiée. Cela se comporte de la même manière pour Python 3.6 et Ruby 2.4.

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)

Résultat de sortie

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']

Copie profonde

Si un objet mutable contient un autre objet mutable, qui est une "copie superficielle n'est pas assez de cas", vous devez faire une copie profonde au lieu d'une copie superficielle pour copier complètement la valeur de b dans ʻa. Il y a. Une copie complète peut être réalisée avec copy.deepcopy`.

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)

Résultat de sortie

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']

Affectation PHP

Dans le cas de PHP, la valeur de la variable sur le côté droit est copiée dans la valeur de la variable sur le côté gauche en affectant. Il se comporte comme une copie complète de Python 3. De plus, l'affectation par référence telle que «$ a = & $ b;» en PHP ne peut pas être réalisée en Python3.

<?php

$a = [3];
$b = &$a;
$a = [5];
print_r($a);
print_r($b);

Résultat de sortie

Array
(
    [0] => 5
)
Array
(
    [0] => 5
)

Dans l'exemple ci-dessus, même si «$ a = [5];», les valeurs de référence de «$ b» et «$ a» ne changent pas.

Relatif à la syntaxe

Devis double, devis simple

En PHP, dans le cas des guillemets doubles, les caractères spéciaux et les variables de la chaîne de caractères ont été remplacés, et dans le cas des guillemets simples, ils n'ont pas été remplacés. Dans le cas de Python3, le caractère d'échappement est remplacé et affiché dans les deux cas. Pour éviter le remplacement, préfixez «r» ou «R».

Pour PHP

<?php
print("a\r\nb");
print('a\r\nb');

Résultat de sortie

a
ba\r\nb

Pour Python 3

print("a\r\nb")
print('a\r\nb')
print(r"a\r\nb")
print(R"a\r\nb")

Résultat de sortie

a
b
a
b
a\r\nb
a\r\nb

Inégalité

Notation de $ a> 0 && $ a <10 dans l'expression conditionnelle en PHP. En Python3, je voudrais également définir ʻa> 0 et a <10, mais cela peut être simplifié comme 0 <a <10`.

Opérateur binaire

Des formats tels que $ a = $ f?" Hello ":" world ", qui sont familiers en PHP. Dans Pyhon3, le format est ʻa = "hello" if f else "world" . La fonction est d'utiliser ʻif et ʻelse` dans l'opérateur ternaire.

Augmenter la décrémentation

En Python3, les formats tels que ʻi ++ et ʻi - sont des erreurs. L'incrément est ʻi + = 1 ou ʻi- = 1.

foreach Foreach et Python3, qui sont indispensables en PHP, peuvent faire la même chose ou mieux avec for comme indiqué dans l'exemple ci-dessous.

Python3 par exemple

print("modèle 1")
for v in range(1, 4):
    print(v)

print("Motif 2")
for v in [x for x in range(4, 1, -1)]:
    print(v)

print("Modèle 3")
for v in (1, 2, 3):
    print(v)

print("Modèle 4")
for k, v in enumerate([1, 2, 3]):
    print(k, v)

print("Modèle 5")
for k, v in {"a":1, "b":2}.items():
    print(k, v)

print("Modèle 6")
for k in {"a":1, "b":2}.keys():
    print(k)

print("Modèle 7")
for v in {"a":1, "b":2}.values():
    print(v)

print("Modèle 8")
for v in [1, 2]:
    print(v)
else:
    print("else", v)

print("Modèle 9")
for v in [1, 2]:
    print(v)
    break
else:
    print("else", v)

print("Modèle 10")
for v in [1, 2]:
    print(v)
    continue
else:
    print("else", v)

print("Modèle 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("Modèle 12")
for v1, v2 in zip([1, 2], [3, 4, 5, 6]):
    print(v1, v2)

print("Modèle 13")
import itertools as it
for v1, v2 in it.zip_longest([1, 2], [3, 4, 5, 6]):
    print(v1, v2)

Résultat de sortie

modèle 1
1
2
3
Motif 2
4
3
2
Modèle 3
1
2
3
Motif 4
0 1
1 2
2 3
Modèle 5
a 1
b 2
Modèle 6
a
b
Modèle 7
1
2
Modèle 8
1
2
else 2
Modèle 9
1
Modèle 10
1
2
else 2
Modèle 11
1 2 1 s
2 1 2 e
Modèle 12
1 3
2 4
Modèle 13
1 3
2 4
None 5
None 6

range En passant, range a des valeurs limites différentes entre PHP et Python3.

Pour PHP

<?php
print_r(range(0, 10, 2));

Résultat de sortie

Array
(
    [0] => 0
    [1] => 2
    [2] => 4
    [3] => 6
    [4] => 8
    [5] => 10
)

Pour Python 3

print(list(range(0, 10, 2)))

Résultat de sortie

[0, 2, 4, 6, 8]

fermeture

Il y a une différence entre PHP et Python3. Décrit du point de vue de la comparaison de codes en les divisant en modèles.

Définition de fonction dans une fonction

Pour PHP

La fonction ʻinner a une résolution de nom et peut être appelée de l'extérieur. À moins d'être passé par référence, la manipulation de variables définies de manière externe dans la fonction ʻinner n'a aucun effet sur l'extérieur. De plus, les variables définies à l'extérieur sont traitées comme hors de portée.

<?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");

Résultat de sortie

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

Pour Python 3

Puisque le nom de la fonction ʻinner n'est pas résolu, il est nécessaire d'obtenir la valeur de retour de ʻouter et de l'appeler afin d'appeler la fonction ʻinnerde l'extérieur. Vous pouvez également accéder à des variables définies en externe. Comme vous pouvez le voir d'après le résultat de15: inner arg1, ʻout1 est [14], et l'état précédent est sauvegardé.

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=" : ")

Résultat de sortie

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

Fonction anonyme

Pour PHP

Pour plus de commodité, la fonction anonyme est définie deux fois. La fermeture est retournée par la fonction ʻouter, et la fermeture est définie par ʻarray_map même dans la fermeture. En utilisant ʻuse`, il est possible d'accéder à des variables définies en externe.

<?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));

Résultat de sortie

Array
(
    [0] => 2
    [1] => 7
    [2] => 14
)

Pour Python 3

Renvoyez la fermeture avec la fonction ʻoutercomme en PHP. Les fonctions anonymes peuvent être définies aveclambda`, mais il existe une limitation selon laquelle les variables ne peuvent pas être définies.

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)))

Résultat de sortie

[2, 7, 14]

Variable variable, fonction variable

Variables et fonctions variables parfois utilisées en PHP. Comparons le code pour PHP et Python3.

Pour PHP

<?php

$a1 = "b1";
$b1 = "test1";

$a2 = "b2";

function b2 () {
    print("test2");
}

print($$a1. "\n");
print($a2());

Résultat de sortie

test1
test2

Pour Python 3

La convivialité est différente de PHP, mais la même chose peut être réalisée.

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)()

Résultat de sortie

test1
test1
test1
test2
test2
test2

Décorateur

J'étais confus quand je regardais le code Python 3 sur GitHub, donc une note rapide. Comme son nom l'indique, il décore.

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__)

Ici est organisé de manière facile à comprendre.

Annotation

Annotations que vous entendez lorsque vous utilisez PHPDoc. Il peut être utilisé avec Python3, mais il peut également être utilisé pour diverses choses telles que les génériques. Si vous n'êtes pas familier avec ces fonctionnalités, vous serez confus lorsque vous regarderez le code Python, donc je veux connaître les fonctionnalités elles-mêmes. Cliquez ici pour plus de détails (http://qiita.com/icoxfog417/items/c17eb042f4735b7924a3)

Lister les opérations à l'aide de la carte, filtrer, réduire

Fonctions d'ordre supérieur disponibles en PHP et python3. Il semble y avoir peu de différence.

map Tout d'abord, pour map, un exemple de traitement qui met au carré tous les éléments du tableau.

Pour PHP

<?php

$r1 = array_map(function($n) {
    return $n ** 2;
}, range(1, 9));
print_r($r1);

Résultat de sortie

Array
(
    [0] => 1
    [1] => 4
    [2] => 9
    [3] => 16
    [4] => 25
    [5] => 36
    [6] => 49
    [7] => 64
    [8] => 81
)

Pour Python 3

Il peut également être réalisé par notation d'inclusion.

r11 = list(map(lambda n: n ** 2, range(1, 10)))
r12 = [n ** 2 for n in range(1, 10)]
print(r11)
print(r12)

Résultat de sortie

[1, 4, 9, 16, 25, 36, 49, 64, 81]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

filter Un échantillon qui extrait des éléments avec seulement des valeurs paires.

Pour PHP

<?php

$r2 = array_filter(range(1, 9), function($n) {
    return $n % 2 == 0;
});
print_r($r2);

Résultat de sortie

Array
(
    [1] => 2
    [3] => 4
    [5] => 6
    [7] => 8
)

Pour Python 3

Il peut être réalisé par la notation d'inclusion ainsi que par map.

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)

Résultat de sortie

[2, 4, 6, 8]
[2, 4, 6, 8]

reduce Cela me semble étrange de le traduire par pliage ou diminution, alors je l'interprète de cette façon. Est-ce «injecter» en rubis? Voici un exemple qui répertorie les éléments sous forme d'entiers.

Pour PHP

<?php

$r3 = array_reduce(range(1, 9), function($a, $b) {
    return $a * 10 + $b;
}, 0);
print_r($r3);

Résultat de sortie

123456789

Pour Python 3

Nécessite functools.

from functools import reduce

r3 = reduce(lambda a, b: a * 10 + b, range(1, 10))
print(r3)

Résultat de sortie

123456789

Autre

PHP a plus de fonctions de type tableau, mais je me demande souvent quoi utiliser et où l'utiliser. ʻArray_walk` est souvent utilisé comme principal.

Expressions régulières

introduction

Pour utiliser une expression régulière au format PCRE, PHP nécessite que le modèle soit entouré d'un délimiteur. En prenant un nombre à 4 chiffres comme exemple, le modèle est exprimé par `` '/ \ d {4} /' '. D'autre part, dans Python3, ajoutez d'abord r à la chaîne de caractères qui devient le modèle. Ce faisant, r" \ n " n'est pas traité comme un code de saut de ligne, mais peut être interprété comme une chaîne de caractères de \ (barre oblique inverse) et n. Si r n'est pas ajouté, il doit être" \\\\ n ". De plus, le modèle d'expression régulière est compilé et utilisé comme objet d'expression régulière avec re.compile ('/ \ d {4} /') (ʻimport re` est requis).

À propos de la comparaison des fonctions

Un simple tableau de comparaison de similitudes entre PHP et Python 3 ressemble à ceci:

Autre

La gestion des expressions régulières en PHP et Python3 est résumée dans ici.

lié à la classe

private、protected Python 3 n'a ni privé ni protégé. Par conséquent, ajoutez une ou deux barres inférieures (_) pour le fonctionnement habituel.

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()

Résultat de sortie

value
_value
__value
method
_method
__method

Classes et méthodes statiques

Les méthodes statiques sont familières lors de l'utilisation de PHP. La différence avec la méthode statique est de savoir s'il faut recevoir la classe elle-même comme premier argument. Il est facile de déterminer à partir de quelle classe il est exécuté. Contrairement à PHP, il peut être appelé depuis une instance de la classe. Un décorateur est requis pour les deux.

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__)

Résultat de sortie

Parent parent
Parent parent
Child parent
Child parent
<class '__main__.MyParent'> parent
<class '__main__.MyParent'> parent
<class '__main__.MyChild'> parent
<class '__main__.MyChild'> child

Supplément

Lors de l'implémentation d'une méthode de classe comme Python3 en PHP, cela ressemble à ceci: Dans ce cas, le même résultat peut être obtenu en remplaçant new static () par new self ().

<?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");

Résultat de sortie

Parent parent
Child child

avec syntaxe

Python 3 a une syntaxe with.

Écriture héritée

C'est similaire à PHP.

file = open("filename")
try:
    print(file.read())
finally:
   file.close()

Comment écrire en utilisant la syntaxe with

Ce sera très simple.

with open("filename") as file:
  print(file.read())

Faire correspondre les instances de classe avec la syntaxe

Vous pouvez gérer les instances de classe avec la syntaxe en définissant simplement «enter» et «exit» dans la classe.

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()

Résultat de sortie

With Statement!
end of with statement!

Itérateur et générateur

Itérateur qui est relativement utilisé pour lire et traiter des fichiers tels que csv ligne par ligne, extraire des taples d'une table et les traiter un par un. PHP et Python ont tous deux des itérateurs et des générateurs, mais préparent en fait le code et essaient de voir s'il y a une différence.

Itérateur

Python 3 peut être implémenté de la même manière que PHP. Cependant, Python 3 a une fonction intégrée en standard.

Pour PHP

<?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");
}

``

0: 1
1: 2
2: 3
3: 4
4: 5

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))

``

0:1
1:2
2:3
3:4
4:5

Résultat de sortie Python3 peut être implémenté plus simplement que PHP, mais soyez prudent car il est nécessaire de lancer StopIteration lorsque le processus est terminé. Les générateurs de résultats de sortie sont également disponibles en Python 3 et PHP (5.5+). Dans l'exemple ici, les fichiers suivants sont lus.

numbers.txt

zero
one
two
three
four
five

Méthode de mise en œuvre de base

La méthode d'implémentation est presque la même pour PHP et Python3.

Pour PHP

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

Résultat de sortie

0:zero
1:one
2:two
3:three
4:four
5:five

Pour Python 3

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="")

Résultat de sortie

0:zero
1:one
2:two
3:three
4:four
5:five

Envoyez des données à chaque appel

C'est la même chose en ce sens qu'il est envoyé par send, mais la convivialité est différente entre PHP et Python.

Pour PHP

Une image qui envoie des données à «yield». Le résultat de sortie est le même que celui de la "méthode de mise en œuvre de base".

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

Pour Python 3

Une image qui envoie des données à la variable spécifiée par yield. Cela semble être différent de PHP en ce sens qu'il est nécessaire d'exécuter __next__ une fois pour passer à la position yield. Le résultat de sortie est le même que celui de la "méthode de mise en œuvre de base".

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)

Sous-générateur

Vous pouvez obtenir une logique récursive avec yield from.

Pour PHP

Implémenté à partir de PHP7. Le résultat de sortie est le même que celui de la "méthode de mise en œuvre de base". Il n'y a pas beaucoup de mérite en termes de lecture de fichiers, mais dans le cas d'opérations telles que des tableaux, il semble que cela puisse être équivalent à Python 3.

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

Pour Python 3

Le résultat de sortie est le même que celui de la "méthode de mise en œuvre de base". La «méthode de mise en œuvre de base» élimine le besoin de boucles, ce qui la rend plus simple.

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 Il n'y a pas d '«interface» comme PHP dans Python3. Puisque Python3 peut hériter plusieurs fois, cela semble inutile en premier lieu. En Python3, les classes abstraites peuvent être implémentées à l'aide du module ABC (Abstract Base Class). De plus, Trait semble inutile pour Python 3 car l'héritage multiple est possible.

Exemple d'implémentation de méthode abstraite en Python3

Pour fournir une méthode abstraite, la métaclasse de classe (spécifiée par __metaclass__) est ʻABCMeta` ou en hérite. À partir du résultat de sortie ci-dessous, vous pouvez également implémenter une méthode abstraite dans une classe abstraite, et même si elle n'est pas définie dans une sous-classe, aucune erreur ne se produira.

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()

Résultat de sortie

static_method
class_method
static_method
class_method
method
method

Si vous vous attendez au même comportement que PHP, il semble que vous puissiez effectuer une opération similaire en la définissant comme suit dans la méthode de la classe parente.

def test1(self):
    raise NotImplementedError("error message")

Sous-classe virtuelle

Une autre méthode consiste à préparer une classe qui remplace la méthode de classe __subclasshook__ comme indiqué ci-dessous et à vérifier si la méthode est définie par la fonction intégrée ʻissubclacss. Le contrôle passe en faisant register`.

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))

Résultat de sortie

False
True
True

Méthode magique

La [méthode magique] de PHP (http://php.net/manual/ja/language.oop5.magic.php) est ce que l'on appelle Python3 nom de la méthode spéciale du modèle de données /3.6/reference/datamodel.html#special-method-names). Il existe de nombreux éléments similaires, tels que «__toString» de PHP correspondant à «str» de Python3.

Accès à des méthodes de propriété non définies ou non accessibles

Pour PHP

Vous pouvez obtenir les propriétés d'un objet avec get_object_vars.

<?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));

Résultat de sortie

0
10
20
Array
(
    [x] => 10
)

Pour Python 3

Puisque la variable d'instance est stockée dans «dict», son contenu peut être obtenu avec la fonction intégrée «vars».

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))

Résultat de sortie

0
10
20
{'x': 10}

Setter/Getter En passant, dans Python 3, vous pouvez également définir Setter / Getter de la manière suivante.

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)

Résultat de sortie

0
0
10
20