Vermeiden Sie verschachtelte Schleifen in PHP und Python

Vermeiden Sie die Notation verschachtelter Schleifen, indem Sie Generatoren in PHP und Python verwenden

Beim Decodieren und Verwenden des folgenden JSON kann die Schleifenverarbeitung durch Verschachteln (Verschachteln) beschrieben werden.

nest.json

{
  "a": {"A": {"A0": [1, 2], "A1": [3, 4]}, "B": {"A0": [5, 6], "A1": [7, 8]}},
  "b": {"A": {"A0": [10, 20], "A1": [30, 40]}, "B": {"A0": [50, 60], "A1": [70, 80]}}
}

Zu diesem Zeitpunkt hat die Wertextraktion des Index "1" des Schlüssels "A0" das folgende Ergebnis, aber wenn die Verarbeitung mit PHP oder Python realisiert wird, gibt es Fälle, in denen es sich um eine Doppelschleife oder eine Dreifachschleife handelt.

[2, 6, 20, 60]

Da in PHP7 und Python3.3 oder höher ein Generator mit "Ausbeute von" verfügbar ist, können Sie mit dieser Funktion überprüfen, ob Sie aus der verschachtelten Schleife ausbrechen können. Zur Überprüfung werden PHP 7.1.5 und Python 3.5.0 verwendet.

Bei Realisierung durch eine verschachtelte Schleife

Hier ist der PHP- und Python-Code für ein Beispiel einer Triple-Loop- oder Double-Loop-Implementierung.

Für PHP7

Unter der Annahme, dass "array_walk" usw. nicht verwendet wird, wird es nur mit "foreach" implementiert.

<?php

$nest = json_decode(file_get_contents("nest.json"), true);

/*
$nest = [
  "a" => ["A" => ["A0" => [1,2], "A1" => [3,4]], "B" => ["A0" => [5,6], "A1" => [7,8]]],
  "b" => ["A" => ["A0" => [10,20], "A1" => [30,40]], "B" => ["A0" => [50,60], "A1" => [70,80]]]
];
*/

$r = [];
foreach ($nest as $v1) {
    foreach ($v1 as $v2) {
        foreach ($v2 as $k => $v3)  {
            if ($k === "A0") {
                $r[] = $v3[1];
            }
        }
    }
}
print_r($r);

$r = [];
foreach ($nest as $v1) {
    foreach ($v1 as $v2) {
        if (isset($v2["A0"][1]))  {
            $r[] = $v2["A0"][1];
        }
    }
}
print_r($r);

Für Python 3

Schreiben fast genauso wie PHP.

import json
from collections import OrderedDict

nest = json.load(open("nest.json"), object_pairs_hook=OrderedDict)

"""
nest = {
  "a": {"A": {"A0": [1,2], "A1": [3,4]}, "B": {"A0": [5,6], "A1": [7,8]}},
  "b": {"A": {"A0": [10,20], "A1": [30,40]}, "B": {"A0": [50,60], "A1": [70,80]}}
}
"""

r = []
for v1 in nest.values():
    for v2 in v1.values():
        for k, v3 in v2.items():
            if k == "A0" and len(v3) > 1:
                r.append(v3[1])
print(r)

r = []
for v1 in nest.values():
    for v2 in v1.values():
        if "A0" in v2 and len(v2["A0"]) > 1:
            r.append(v2["A0"][1])
print(r)

Wenn durch "Ausbeute von" realisiert

Sowohl PHP als auch Python können auf die gleiche Weise geschrieben werden.

Für PHP7

Es wird relativ einfach sein. Es ist nicht erforderlich, eine Schleifenverarbeitung hinzuzufügen, selbst wenn die Hierarchie des Arrays tiefer wird.

<?php

$nest = json_decode(file_get_contents("nest.json"), true);

function zslice ($n)
{
     foreach($n as $k => $v) {
         yield from $v;
     }
}

$r = [];
foreach(zslice(zslice($nest)) as $k => $v) {
    if ($k == "A0") {
        $r[] = $v[1];
    }
}
print_r($r);

$r = [];
foreach(zslice($nest) as $k => $v) {
    if (isset($v["A0"][1])) {
        $r[] = $v["A0"][1];
    }
}
print_r($r);

Für Python 3

Da es von dict gehandhabt wird, ist eine etwas komplizierte Verarbeitung erforderlich, aber die grundlegende Methode ist dieselbe wie bei PHP7.

import json
from collections import OrderedDict

nest = json.load(open("nest.json"), object_pairs_hook=OrderedDict)


def zslice(n):
    r = n.values() if isinstance(n, dict) else n
    for v in r:
        if isinstance(v, dict):
            d = v.items()
        elif isinstance(v, tuple) and len(v) > 1:
            d = v[1].items()
        else:
            raise ValueError
        yield from d

r = []
for k, v in zslice(zslice(nest)):
    if k == "A0" and len(v) > 1:
        r.append(v[1])
print(r)

r = []
for k, v in zslice(nest):
    if "A0" in v and len(v["A0"]) > 1:
       r.append(v["A0"][1])
print(r)

Andere

Es kann einfacher und leichter zu lesen sein, indem die "zslice" wie unten gezeigt getrennt wird.

import json
from collections import OrderedDict

nest = json.load(open("nest.json"), object_pairs_hook=OrderedDict)


def zslice1(n):
    for v in n.values():
        yield from v.items()


def zslice2(n):
    for k, v in n:
        yield from v.items()

r = []
for k, v in zslice2(zslice1(nest)):
    if k == "A0" and len(v) > 1:
        r.append(v[1])
print(r)

r = []
for k, v in zslice1(nest):
    if "A0" in v and len(v["A0"]) > 1:
       r.append(v["A0"][1])
print(r)

Ausgabeergebnis

Das hier beschriebene Ausgabeergebnis des PHP- und Python-Beispielcodes wird beschrieben.

Für PHP

python

Array
(
    [0] => 2
    [1] => 6
    [2] => 20
    [3] => 60
)
Array
(
    [0] => 2
    [1] => 6
    [2] => 20
    [3] => 60
)

Für Python

Ausgabeergebnis

[2, 6, 20, 60]
[2, 6, 20, 60]

Ergänzung: Über die Reihenfolge der Python-Wörterbücher

Wenn Sie im zweiten Argument von "json.load" nicht "object_pairs_hook = OrderedDict" angeben, kann die Reihenfolge der Elemente unterschiedlich sein, wenn Sie das Beispiel mehrmals ausführen.

Muster 1

[60, 20, 6, 2]
[60, 20, 6, 2]

Muster 2

[6, 2, 60, 20]
[6, 2, 60, 20]

Da die Reihenfolge der Elemente beim Erstellen von "dict" nicht garantiert ist, verwenden Sie "OrderedDict", um die Konsistenz aufrechtzuerhalten.