Bonjours,

Je viens d'écrire une classe que je suis sensé utilisé régulièrement, et dans le but de simplifié sont utilisation, j'utilise des setters.
L'écriture de ces setters dans la classe me semble répétitive et je me demande s'il est possible d'écrire cela de meilleurs façons: Est-il possible de bouclé les setters?

Voici le code de ma classe pour mieux visualisé ma demande.
Je ne suis pas informaticien, des choses qui vous paraissent évidente ne le sont pas forcement pour moi.
En vous remerciant pour le temps que vous m'accorder.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
class DefPara(object):
	""" Définition des parametreS pour class Machine
                          typval  #  Parametre type type
                          val #  Valeur du parametre
                          valini #  Valeur du parametre apprès réinitialisation
                          defmax #  Valeur Max provoquant un défaut
                          defmin #  Valeur Min provoquant un défaut
                          almax #  Valeur Max provoquant une alarme
                          almin #  Valeur Min provoquant une alarme
                          etq #  Libellé du parametre type string
        """
	ensType = {'None','bool','int','float','str'}
	ensArg = {'typeval', 'defmin', 'defmax', 'almin', 'almax', 'etq', 'val', 'valini'}
 
	def __init__(self, **kwargs):
		self._kwarg = {}
		for key in DefPara.ensArg:
			self._kwarg[key] = None
		for key, value in kwargs.items():
			if self._control(key, value):
				self._kwarg[key] = value
 
        @property
	def typval(self):
		"""Type du parametre"""
		return self._kwarg['typeval']
 
        @typval.setter
	def typval(self, value):
		if self._control("typeval",value):
			self._kwarg['typeval'] = value
 
        @property
	def val(self):
		"""Valeur du parametre"""
		return self._kwarg['val']
 
        @val.setter
	def val(self, value):
		if self._control("val",value):
			self._kwarg['val'] = value
 
        @val.deleter
	def val(self):
		self._kwarg['val'] = self._kwarg['valini']
 
        @property
	def valini(self):
		"""Valeur du parametre après réinitialisation"""
		return self._kwarg['valini']
 
        @valini.setter
	def valini(self, value):
		if self._control("valini",value):
			self._kwarg['valini'] = value
 
        @property
	def etq(self):
		"""Libellé du parametre"""
		return self._kwarg['etq']
 
        @etq.setter
	def etq(self, value):
		if self._control("etq",value):
			self._kwarg['etq'] = value
 
        @property
	def defmin(self):
		"""Valeur Min provoquant un défaut"""
		return self._kwarg['defmin']
 
        @defmin.setter
	def defmin(self, value):
		if self._control("defmin",value):
			self._kwarg['defmin'] = value
 
        @defmin.deleter
	def defmin(self):
		self._kwarg['defmin'] = None
 
        @property
	def defmax(self):
		"""Valeur Max provoquant un défaut"""
		return self._kwarg['defmax']
 
        @defmax.setter
	def defmax(self, value):
		if self._control("defmax",value):
			self._kwarg['defmax'] = value
 
        @defmax.deleter
	def defmax(self):
		self._kwarg['defmax'] = None
 
        @property
	def almin(self):
		"""Valeur Min provoquant une alarme"""
		return self._kwarg['almin']
 
        @almin.setter
	def almin(self, value):
		if self._control("almin",value):
			self._kwarg['almin'] = value
 
        @almin.deleter
	def almin(self):
		self._kwarg['almin'] = None
 
        @property
	def almax(self):
		"""Valeur Max provoquant une alarme"""
		return self._kwarg['almax']
 
        @almax.setter
	def almax(self, value):
		if self._control("almax",value):
			self._kwarg['almax'] = value
 
        @almax.deleter
	def almax(self):
		self._kwarg['almax'] = None
 
	def _control(self, arg, value):
		if arg not in DefPara.ensArg:
			logpara.debug('''Parametre: argument inconnu: {} n'est pas dans DefPara.ensArg'''.Format(arg))
			return False
 
		if arg == "typeval":
			if (not isinstance(value, type)):
				logpara.debug('''Parametre: typeval doit etre de type : type''')
				return False
			elif (value not in DefPara.ensType):
				logpara.debug('''Parametre: typeval doit etre de type : {'None','bool','int','float','str'}''')
				return False
			return True
 
		if arg in {"defmax", "defmin", "almax", "almin"}:
			if (self._kwarg['typeval'] in {'int', 'float'}):
				if arg == "defmax":
					if (type(arg) is not None
					and type(self._kwarg['defmin']) is not None
					and arg < self._kwarg['defmin']):
						logpara.debug('''Parametre: defmax doit etre superieur a defmin''')
						return False
					return True
				if arg == "defmin":
					if (type(arg) is not None
						and type(self._kwarg['defmax']) is not None
						and arg > self._kwarg['defmax']):
						logpara.debug('''Parametre: defmin doit etre inferieur a defmax''')
						return False
					return True
				if arg == "almax":
					if (type(arg) is not None
						and type(self._kwarg['almin']) is not None):
						if arg < self._kwarg['almin']:
							logpara.debug('''Parametre: almax doit etre superieur a almin''')
							return False
						if arg > self._kwarg['defmax']:
							logpara.debug('''Parametre: almax doit etre inferieur a defmax''')
							return False
					return True
				if arg == "almin":
					if (type(arg) is not None
						and type(self._kwarg['almax']) is not None):
						if arg > self._kwarg['almax']:
							logpara.debug('''Parametre: almin doit etre inferieur a almax''')
							return False
						if arg < self._kwarg['defmin']:
							logpara.debug('''Parametre: almin doit etre superieur a defmin''')
							return False
					return True
		if arg in {"val","valini"}:
			if (self._kwarg['typeval'] in {'int', 'float'}):
				if type(arg) is not None:
					if type(self._kwarg['defmax']) is not None:
						if arg >= self._kwarg['defmax']:
							logpara.debug('''Parametre: {} doit etre inferieur a defmax''').format(arg)
							return False
						if arg <= self._kwarg['defmin']:
							logpara.debug('''Parametre: {} doit etre superieur a defmin''').format(arg)
							return False
			return True
		if arg == 'etq':
			if (type(arg) is not None
				and type(arg) is not str):
					logpara.debug('''Parametre: etq doit etre de type string''')
					return False
			return True