Comment définissez-vous un conditionnel en python basé sur les types de données?

Il y a vraiment un gros "ça dépend" de la vérification de type Python. Il existe de nombreuses façons de traiter avec des types, et tous ont leurs avantages et leurs inconvénients. Avec Python3, plusieurs ont vu le jour.

• De type explicite de l'égalité

Types sont des objets de première classe, et vous pouvez les traiter comme n'importe quelle autre valeur.
Donc, si vous voulez le type de quelque chose pour être égale à int, il suffit de tester pour elle:

if type(x) == int:

C'est le plus restrictif type de test: il nécessite exacte de l'égalité de traitement. Souvent, ce n'est pas ce que vous voulez:

• Il les règles de substitution types: un float ne serait pas valide, même si elle se comporte comme une int à de nombreuses fins.
• Elle exclut les sous-classes et types abstract: une impression int sous-classe ou enum serait rejetée, même si elles sont logiquement Entiers.
  • Cela limite grandement la portabilité: Python2 Chaînes de caractères peuvent être soit str ou unicode, et les nombres Entiers peuvent être soit int ou long.

Noter que le type explicite de l'égalité a ses utilisations pour les opérations de bas niveau:

• Certains types ne peut pas être sous-classé, comme slice. Une vérification explicite est plus explicite ici.
• Certaines opérations de bas niveau, tels que la sérialisation ou C-Api, prescrivent des types spécifiques.

Variantes

Une comparaison peut également être effectuée à l'encontre de la __class__ attribut:

if x.__class__ == int:

Remarque si une classe définit un __class__ de la propriété, ce n'est pas le même que type(x).

Quand il y a plusieurs classes de vérifier, à l'aide d'un dict à l'expédition des actions est plus extensible et peut être plus rapide (≥5 à 10 types) qu'explicite des contrôles.
Ceci est particulièrement utile pour les conversions et la sérialisation:

dispatch_dict = {float: round, str: int, int: lambda x: x}
def convert(x):
    converter = self.dispatch_dict[type(x)]  # lookup callable based on type
    return converter(x)

• Exemple de voir sur les types explicites

La idiomatiques type de test qui utilise la isinstance builtin:

if isinstance(x, int):

Cette case est à la fois précis et performant. C'est le plus souvent ce que les gens voulez pour la vérification de types:

• Il gère correctement les sous-types. Une impression int sous-classe serait encore de passer ce test.
• Il permet la vérification de plusieurs types à la fois. En Python2, faire isinstance(x, (int, long)) vous reçoit tous builtin entiers.

Plus important encore, les inconvénients sont négligeables, la plupart du temps:

• Il accepte toujours funky sous-classes qui se comportent de moyens détournés. Depuis rien peut être fait pour se comporter étranges façons, c'est futile de se prémunir contre.
• Il peut facilement être trop restrictive: beaucoup de gens vérifier isinstance(x, list) quand toute la séquence (par exemple,tuple) ou même itérable (par exemple, un generator) ferait aussi bien. C'est plus une préoccupation pour l'usage général des bibliothèques que des scripts ou des applications.

Variantes

Si vous avez déjà un type, issubclass se comporte de la même:

if issubclass(x_type, int):

• Exemple de voir sur le type abstrait

Python a une notion de les classes de base abstraites. Grosso modo, ils expriment le sens de types, et pas de leur hiérarchie:

if isinstance(x, numbers.Real):  # accept anything you can sum up like a number

En d'autres termes, le type(x) n'est pas nécessairement hériter de numbers.Real mais doit se comporter comme elle.
Pourtant, c'est un très complexes et difficiles concept:

• Il est souvent exagéré si vous êtes à la recherche pour les types de base. Un nombre Entier est tout simplement un int la plupart du temps.
• Des personnes venant d'autres langues, souvent, la confusion des concepts.
  • Distinguer, par exemple, le C++, l'accent est mis de base abstraite classe, par opposition à résumé de la classe de base.
  • Bruns peuvent être utilisés comme interfaces de Java, mais peut encore avoir béton fonctionnalité.

Cependant, il est très utile pour les bibliothèques génériques et des abstractions.

• De nombreuses fonctions/algorithmes n'ont pas besoin de types explicites, juste de leur comportement.
  • Si vous avez juste besoin de regarder les choses par la clé, dict vous limite à un type in-memory. En revanche, collections.abc.Mapping comprend également la base de données des wrappers, des disques de grande capacité adossés à des dictionnaires, des paresseux, des conteneurs, ... - et dict.
• Il permet d'exprimer partielle des contraintes de type.
  • Il n'y a pas de stricte type de base à la mise en œuvre de l'itération. Mais si vous vérifiez les objets contre collections.abc.Iterable, ils travaillent tous dans une for boucle.
• Il permet de créer séparée, d'optimiser les implémentations qui apparaissent comme le même type abstrait.

Alors qu'il n'est généralement pas nécessaire de jeter les scripts, je vous recommande fortement de l'utiliser pour tout ce qui vit au-delà de quelques versions de python.

• Indicative de conversion

La idiomatiques de manipulation des types n'est pas de les tester, mais à supposer qu'elles sont compatibles. Si vous avez déjà s'attendre à quelques mauvais types dans votre entrée, il suffit de sauter tout ce qui n'est pas compatible:

try:
    ix = int(x)
except (ValueError, TypeError):
    continue  # not compatible with int, try the next one
else:
    a.append(ix)

Ce n'est pas réellement un type de case, mais sert généralement la même intention.

• Il garanties vous avez le type attendu de votre sortie.
• Il a une certaine marge de manœuvre est limitée dans la conversion de mauvais types, par exemple, spécialisée float à int.
• Il fonctionne sans vous savoir quels types conformes à int.

L'inconvénient majeur est qu'il est explicite transformation.

• Vous pouvez en silence accepter "mauvais" valeurs, par exemple la conversion d'un str contenant un littéral.
• Inutilement convertit même les types qui serait assez bon, par exemple, float à int lorsque vous avez simplement besoin de chiffres.

De Conversion est un outil efficace pour certains cas d'utilisation spécifiques. Il fonctionne mieux si vous savez à peu près ce que votre entrée est, et doit donner des garanties au sujet de votre sortie.

• Contrôle l'entrée

Le meilleur plan d'action est de vous assurer de ne jamais avoir à vérifier pour le type dans la première place. C'est un peu un méta-sujet, car il dépend fortement du cas d'utilisation.

Ici, la source de somelist ne devrait jamais avoir à mettre des numéros en elle.

Facile - utiliser des types.

import types
k = 5
if(type(k)==types.IntType):
   print "int"

Voici un rapide dir(types):

['BooleanType', 'BufferType', 'BuiltinFunctionType', 'BuiltinMethodType', 'ClassType', 'CodeType', 'ComplexType', 'DictProxyType', 'DictType', 'DictionaryType', 'EllipsisType', 'FileType', 'FloatType', 'FrameType', 'FunctionType', 'GeneratorType', 'GetSetDescriptorType', 'InstanceType', 'IntType', 'LambdaType', 'ListType', 'LongType', 'MemberDescriptorType', 'MethodType', 'ModuleType', 'NoneType', 'NotImplementedType', 'ObjectType', 'SliceType', 'StringType', 'StringTypes', 'TracebackType', 'TupleType', 'TypeType', 'UnboundMethodType', 'UnicodeType', 'XRangeType', '__builtins__', '__doc__', '__file__', '__name__', '__package__']