Was ist, wenn Sie manchmal nicht garantieren oder nachweisen können, dass Sie 100% Kontrolle über die Art eines Wertes haben?
Gibt es eine bequeme Möglichkeit zum Schreiben, z. B. eine Typinferenz? Wenn jemand weiß, lassen Sie es mich bitte wissen. Ist es möglich, Diktat in Struktur umzuwandeln? Was ist gut? Ich fand, dass der mehrdeutige Typ nervig war **, also beschloss ich, noch einmal darüber nachzudenken.
Angenommen, Sie haben Diktierdaten mit dem Namen "Test" wie im folgenden Beispiel. Ich möchte überprüfen, ob der Schlüssel jedes Werts der Variablen "test" eine "1" enthält.
test_dict_key_value_type.py
test = {
0: {'key': [1, 2, 3]},
1: {'key': None},
2: {'key': []},
3: {},
4: None,
}
#Muster 1 Verwenden Sie diese Instanz, um den Typ zu überprüfen und mit get zu bestimmen
for k, v in test.iteritems():
if v is not None and isinstance(v.get('key'), list) and 1 in v.get('key'):
print k, ':found!'
#Muster 2 Bereiten Sie eine Funktion zum Neudefinieren der Daten vor
def set_default_dict_value_type(test, dict_value_key, dict_value_type):
for k, v in test.iteritems():
if v is None or not isinstance(v.get(dict_value_key), dict_value_type):
test[k] = {
dict_value_key: dict_value_type()
}
return test
# new_Da alle Testschlüsselwerte diktiert sind, können sie nur mit der get-Methode verwendet werden.
for k, v in set_default_dict_value_type(test.copy(), 'key', list).iteritems():
if 1 in v.get('key'):
print k, ':found!'
#Muster 3 Versuchen Sie es und ignorieren Sie es
for k, v in test.iteritems():
try:
if 1 in v.get('key'):
print k, ':found!'
except:
pass
Versuche zu rennen
bash
$ python test_dict_key_value_type.py
0 :found!
0 :found!
0 :found!
In diesem Fall besteht das Problem darin, dass die Definition von Daten nicht eindeutig ist **, wenn Sie sorgfältig darüber nachdenken. Also kam ich zu dem Schluss, dass ** eine Neudefinition des Datentyps das Problem lösen würde **. Mit anderen Worten, wenn sich der Typ vom Zeitplan unterscheidet, wird davon ausgegangen, dass die Daten beschädigt sind, und es ist in Ordnung, den Typ neu zu definieren. Im obigen Fall ist "Fall 2" in dieser Phase das bevorzugte Verfahren.
Ich habe ein Beispielmodul erstellt, das Liste und Diktat überprüft. Gibt es noch Verbesserungen?
data_type.py
#!/usr/bin/env python
def set_dict_key_value(dic, dict_value_key, dict_value_type):
"""
:param dict dic: dict data to test
:param str dict_value_key: dict value key name
:param Type dict_value_type: Type Object ex. dict, list...
:rtype: dict
:return: redefined dict data
ex.
>>> test = {
0: {'key': [1, 2, 3]},
1: {'key': None},
2: {'key': []},
3: {},
4: None,
}
>>> set_dict_key_value(test, 'key', list)
{
0: {'key': [1, 2, 3]},
1: {'key': []},
2: {'key': []},
3: {'key': []},
4: {'key': []}
}
"""
new_dic = dic.copy()
for k, v in new_dic.iteritems():
if v is None or not isinstance(v.get(dict_value_key), dict_value_type):
new_dic[k] = {dict_value_key: dict_value_type()}
return new_dic
def set_list_value(lst, list_value_type, default_none_value=None):
"""
:param list lst: list data to test
:param Type list_value_type: Type Object ex. dict, list,,,
:param not None clean_list_default_value: Any type of data except for None
:rtype: list
:return: redefined list data
ex.
>>> a = [None, 1, 'str', False, 1.0, {1: 0}]
>>> set_list_value(a, dict, {})
[{}, {}, {}, {}, {}, {1: 0}]
"""
return map(
lambda v: v if isinstance(v, list_value_type) else list_value_type(),
lst if default_none_value is None else
clean_list_none_value(lst, default_none_value)
)
def clean_list_none_value(lst, default_none_value):
"""
Replace None with defalut_none_value
:param list lst: list data to test
:param not None default_none_value: Any type of data except for None
:rtype: list
:return: cleaned list data
"""
return map(lambda v: default_none_value if v is None else v, lst)