Contents Cet article explique comment effectuer un traitement itératif [^ 1] dans une classe Python. Chaque code peut être téléchargé depuis le référentiel GitHub.
[^ 1]: Qiita: Python for statement ~ What is iterable ~
iter_minimum.py
iteration = IterClass(["a", "ab", "abc", "bb", "cc"])
print([v for v in iteration if "a" in v])
# ['a', 'ab', 'abc']
| Environnement d'exécution | |
|---|---|
| OS | Windows Subsystem for Linux |
| Python | version 3.8.5 |
Il peut être implémenté par les méthodes spéciales de la classe «iter» [^ 2] et la syntaxe «yield from» [^ 3]. Stocke une liste ou taple et la renvoie dans l'ordre depuis le début lorsqu'elle est appelée en tant que processus itératif.
[^ 2]: La vie avec Python: Comment utiliser la classe de génération d'itérateur de Python [^ 3]: blanktar: Quel est le rendement de python3.3 à partir de
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
Dans l'exemple ci-dessus, je ne ressens pas l'importance de créer une nouvelle classe, j'ai donc créé une version avancée.
Commencez par créer la plus petite classe d'unité ʻUnit` retournée par un traitement itératif.
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 a une valeur et un état uniques (bool`: True / False).
Créer une unité:
iter_advanced.py
unit1 = Unit(value=1.0)
#Afficher la valeur si l'état de l'unité est Vrai
if unit1:
print(unit1.value)
# 1.0
État à faux:
iter_advanced.py
# Disable
unit1.disable()
#Afficher la valeur si l'état de l'unité est Vrai
if unit1:
print(unit1.value)
#Aucune sortie
State to True:
iter_advanced.py
# Disable
unit1.enable()
#Afficher la valeur si l'état de l'unité est Vrai
if unit1:
print(unit1.value)
# 1.0
Créez une classe Series qui stocke les informations de plusieurs ʻUnit`s et les itère.
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()
Pour vérifier le comportement de la classe Series, créez une fonction qui renvoie la valeur de l'Unité dont l'état est True.
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])
Enregistrez ʻUnit avec Series et affichez toutes les valeurs de ʻUnit.
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]
Si l'état des 5e et 6e unités (les valeurs sont 4 et 5) est défini sur Faux ...
iter_advanced.py
# Disable two units
series.disable(4)
series.disable(5)
show_enabled(series)
# [0, 1, 2, 3]
Lorsque l'état de la 5e unité (la valeur est 4) est renvoyé à Vrai ...
iter_advanced.py
# Enable one disabled unit
series.enable(4)
show_enabled(series)
# [0, 1, 2, 3, 4]
Merci pour la navigation. Je vous remercie pour votre travail acharné.
Comment avez-vous créé cet article: J'ai utilisé ce mécanisme dans mon propre package Python CovsirPhy: analyse COVID-19 avec SIR dépendant de la phase.
Recommended Posts