Contents In diesem Artikel wird erläutert, wie die iterative Verarbeitung [^ 1] in einer Python-Klasse ausgeführt wird. Jeder Code kann aus dem [GitHub-Repository] heruntergeladen werden (https://github.com/lisphilar/article_qiita/tree/master/python/01_italable_class).
[^ 1]: Qiita: Python für Anweisung ~ Was ist iterierbar ~
iter_minimum.py
iteration = IterClass(["a", "ab", "abc", "bb", "cc"])
print([v for v in iteration if "a" in v])
# ['a', 'ab', 'abc']
| Ausführungsumgebung | |
|---|---|
| OS | Windows Subsystem for Linux |
| Python | version 3.8.5 |
Es kann mit den speziellen Methoden der Klasse __iter__ [^ 2] und der Syntax Yield from [^ 3] implementiert werden. Speichert eine Liste oder ein Taple und gibt sie von Anfang an in der Reihenfolge zurück, in der sie als iterativer Prozess aufgerufen wird.
[^ 2]: Leben mit Python: Verwendung der Iterator-Generierungsklasse von Python [^ 3]: blanktar: Woraus ergibt sich die Python3.3-Ausbeute
iter_minimum.py
class IterClass(object):
"""
Iterable class.
Args:
values (list[object] or tuple(object)): list of values
Raises:
TypeError: @values is not a list/tuple
"""
def __init__(self, values):
if not isinstance(values, (list, tuple)):
raise TypeError("@values must be a list or tuple.")
self._values = values
def __iter__(self):
yield from self._values
__bool__)Im obigen Beispiel ist es mir nicht wichtig, eine neue Klasse zu erstellen, daher habe ich eine erweiterte Version erstellt.
Erstellen Sie zuerst die kleinste Einheitsklasse "Einheit", die durch iterative Verarbeitung zurückgegeben wird.
iter_advanced.py
class Unit(object):
"""
The smallest unit.
"""
def __init__(self, value):
if not isinstance(value, (float, int)):
raise TypeError(
f"@value must be integer or float value, but {value} was applied.")
self._value = value
self._enabled = True
def __bool__(self):
return self._enabled
@property
def value(self):
"""
float: value of the unit
"""
return self._value
def enable(self):
"""
Enable the unit.
"""
self._enabled = True
def disable(self):
"""
Disable the unit.
"""
self._enabled = False
Unit hat einen eindeutigen Wert und Status ( __bool__: True / False).
Eine Einheit erstellen:
iter_advanced.py
unit1 = Unit(value=1.0)
#Wert anzeigen, wenn der Einheitenstatus True ist
if unit1:
print(unit1.value)
# 1.0
Zustand zu falsch:
iter_advanced.py
# Disable
unit1.disable()
#Wert anzeigen, wenn der Einheitenstatus True ist
if unit1:
print(unit1.value)
#Keine Leistung
State to True:
iter_advanced.py
# Disable
unit1.enable()
#Wert anzeigen, wenn der Einheitenstatus True ist
if unit1:
print(unit1.value)
# 1.0
Erstellen Sie eine Klasse "Serie", die Informationen über mehrere "Einheiten" speichert und eine iterative Verarbeitung durchführt.
iter_advanced.py
class Series(object):
"""
A series of units.
"""
def __init__(self):
self._units = []
def __iter__(self):
yield from self._units
def add(self, unit):
"""
Append a unit.
Args:
unit (Unit]): the smallest unit
Raises:
TypeError: unit is not an instance of Unit
"""
if not isinstance(unit, Unit):
raise TypeError("@unit must be a instance of Unit")
self._units.append(unit)
def _validate_index(self, num):
"""
Validate the index number.
Args:
num (int): index number of a unit
Raises:
TypeError: @num is not an integer
IndexError: @num is not a valid index number
"""
if not isinstance(num, int):
raise TypeError(
f"@num must be integer, but {num} was applied.")
try:
self._units[num]
except IndexError:
raise IndexError(f"@num must be under {len(self._units)}")
def enable(self, num):
"""
Enable a unit.
Args:
num (int): index of the unit to be enabled
Raises:
TypeError: @num is not an integer
IndexError: @num is not a valid index number
"""
self._validate_index(num)
self._units[num].enable()
def disable(self, num):
"""
Disable a unit.
Args:
num (int): index of the unit to be disabled
Raises:
TypeError: @num is not an integer
IndexError: @num is not a valid index number
"""
self._validate_index(num)
self._units[num].disable()
Um das Verhalten der Klasse "Series" zu überprüfen, erstellen Sie eine Funktion, die den Wert der Einheit zurückgibt, deren Status "True" ist.
iter_advanced.py
def show_enabled(series):
"""
Show the values of enabled units.
"""
if not isinstance(series, Series):
raise TypeError("@unit must be a instance of Series")
print([unit.value for unit in series if unit])
Registrieren Sie "Unit" bei "Series" und zeigen Sie alle "Unit" -Werte an.
iter_advanced.py
# Create a series of units
series = Series()
[series.add(Unit(i)) for i in range(6)]
show_enabled(series)
# [0, 1, 2, 3, 4, 5]
Wenn der Status der 5. und 6. Einheit (Werte 4 und 5) auf False gesetzt ist ...
iter_advanced.py
# Disable two units
series.disable(4)
series.disable(5)
show_enabled(series)
# [0, 1, 2, 3]
Wenn der Status der 5. Einheit (Wert 4) auf True zurückgesetzt wird ...
iter_advanced.py
# Enable one disabled unit
series.enable(4)
show_enabled(series)
# [0, 1, 2, 3, 4]
Vielen Dank für das Surfen. Danke für deine harte Arbeit.
Wie haben Sie diesen Artikel erstellt: Ich habe diesen Mechanismus in meinem eigenen Python-Paket CovsirPhy: COVID-19-Analyse mit phasenabhängigen SIRs verwendet.
Recommended Posts