Et s'il y a des moments où vous ne pouvez pas garantir ou prouver que vous avez un contrôle à 100% sur le type d'une valeur?
Existe-t-il un moyen pratique d'écrire comme l'inférence de type? Si quelqu'un sait, faites-le moi savoir. Est-il possible de convertir dict en struct? Ce qui est bon? J'ai senti que le type ambigu était ennuyeux **, alors j'ai décidé de réfléchir à nouveau.
Supposons que vous ayez des données dict appelées test comme dans l'exemple ci-dessous.
Je veux vérifier s'il y a un «1» dans la «clé» de chaque valeur de la variable «test».
test_dict_key_value_type.py
test = {
0: {'key': [1, 2, 3]},
1: {'key': None},
2: {'key': []},
3: {},
4: None,
}
#Modèle 1 Utilisez une instance pour vérifier le type et utilisez get pour déterminer
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!'
#Modèle 2 Préparez une fonction pour redéfinir les données
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_Puisque toutes les valeurs de clé de test sont dict, elles ne peuvent être utilisées qu'avec la méthode get.
for k, v in set_default_dict_value_type(test.copy(), 'key', list).iteritems():
if 1 in v.get('key'):
print k, ':found!'
#Motif 3 Essayez et ignorez
for k, v in test.iteritems():
try:
if 1 in v.get('key'):
print k, ':found!'
except:
pass
Essayez de courir
bash
$ python test_dict_key_value_type.py
0 :found!
0 :found!
0 :found!
Dans ce cas, si vous y réfléchissez bien, le problème est que la définition des données est ambiguë **. Je suis donc arrivé à la conclusion que ** redéfinir le type de données résoudrait le problème **. En d'autres termes, si le type est différent de la planification, on considère que les données sont corrompues et il est possible de redéfinir le type. Dans le cas ci-dessus, le «cas 2» est la méthode préférée à ce stade.
J'ai fait un exemple de module qui vérifie la liste et dict. Y a-t-il encore des améliorations?
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)
Recommended Posts