3

Problem: I have to check that the a returned value is a Python dictionary.

Q1. Which of these options is the proper way to do this?

type(x) == dict

type(x) == type(dict)

isinstance(d, dict)

Then there are the other variants using is operator instead of ==.

Q2. Many people say that checking the type of an object is generally a bad practice, but regarding to my initial problem, do I have any other choice?

Improve this question
7
  • Do you need it to be a dictionary or do you need to access items on it? Commented Aug 1, 2011 at 23:29
  • And anyways, the question you linked already provides the answer. Commented Aug 1, 2011 at 23:30
  • @Garet I need to be a dictionary because I'll use it to .update another dict. Commented Aug 1, 2011 at 23:31
  • @Garet I'm sorry, I missed the right answer for me. Though, my Q2 is not covered. Commented Aug 1, 2011 at 23:36
  • 1
    If you ever do actually need to check type, the Python docs tell you to use isinstance not type, and says to use isinstance with abstract base classes (from collections, numbers, io) to see if an object supports a particular interface. Commented Aug 2, 2011 at 0:05

3 Answers 3

Reset to default
8

Q1. Which of these options is the proper way to do this?

Don't waste time on type checking.

It's error-prone because it's based on assumptions.

Q2. ... do I have any other choice?

Yes do this.

try:
    x.the_dict_operation()
except TypeError:
    # x was not the expected type for the operation
    raise # or whatever.

In most cases, this amounts to "do nothing".

Just write the code. If "somehow" a malicious sociopath uses the wrong type, it will just crash like it's supposed to.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

+1 a big thanks, now I really understand what "Duck typing" is about.
This way I have to trust that x.the_dict_operation method still does what it was supposed to do (in my case a plain .update of another dictionary). Isn't this a potential problem?
@Guandalino: since you're using the user-supplied dict to update your own dict, your own dict's .update() method is getting called. If you can't trust that...
Let it just crash and fix the code, instead of lots of checks. I think that is good practice.
@Guandalino: "This way I have to trust..." What's the alternative? Magical introspection to assert that "somehow" the code is bug-free, satisfies all the contract specifications in the all of the "require" and "assure" clauses in the original design? There's no possible way to do anything other than trust.
2

Rely on behaviour, not on actual type (see other answers).

Lot of objects can act like dictionaries, you don't want to force users of your function/API to use plain dicts, right?

On the pragmatic side:

>>> type({})
<type 'dict'>
>>> dict
<type 'dict'>
>>> type(dict)
<type 'type'>
>>> isinstance({}, dict)
True
>>> isinstance("", dict)
False
Improve this answer

Comments

1

Check for __getitem__ rather than verifying the type. If you really want to type-check, any is fine (well, except type(x) == type(dict), that will never be true for a dict instance). isinstance is probably the most standard way to do it.

Improve this answer

2 Comments

__getitem__ doesn't have anything to do with dict. Lots of objects have __getitem__ that aren't dicts. For what he's doing (checking if the object can be passed to {}.update), this is particularly wrong: there are objects which can be passed to that function which don't have __getitem__. He wants to check if the object is iterable.
@Glenn It needs to be iterable such that the iterated-over elements are each iterable, such that there are 2 elements in each of those. :)

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.