Python len() function returns the length of the object. This function internally calls __len__() function of the object.
length method= len() => It's return number of element from value of variable. count method = count() =>It's return how many times appeared from value of variable which you are specified value. Because in "list1" which has total value inside is 4. So that's why it becomes output 4 by using len() method.
__len__(self) is the special method which is called in the implementation of len() function. For a class you define object. __len__(self) function and compute the length, then calling len(obj) on the instance gives you the length. len() also does sanity checking on top of object. __len__(self) output.
Python __repr__() function returns the object representation in string format. This method is called when repr() function is invoked on the object. If possible, the string returned should be a valid Python expression that can be used to reconstruct the object again.
len
is a function to get the length of a collection. It works by calling an object's __len__
method. __something__
attributes are special and usually more than meets the eye, and generally should not be called directly.
It was decided at some point long ago getting the length of something should be a function and not a method code, reasoning that len(a)
's meaning would be clear to beginners but a.len()
would not be as clear. When Python started __len__
didn't even exist and len
was a special thing that worked with a few types of objects. Whether or not the situation this leaves us makes total sense, it's here to stay.
It's often the case that the "typical" behavior of a built-in or operator is to call (with different and nicer syntax) suitable magic methods (ones with names like __whatever__
) on the objects involved. Often the built-in or operator has "added value" (it's able to take different paths depending on the objects involved) -- in the case of len
vs __len__
, it's just a bit of sanity checking on the built-in that is missing from the magic method:
>>> class bah(object):
... def __len__(self): return "an inch"
...
>>> bah().__len__()
'an inch'
>>> len(bah())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object cannot be interpreted as an integer
When you see a call to the len
built-in, you're sure that, if the program continues after that rather than raising an exception, the call has returned an integer, non-negative, and <= sys.maxsize
-- when you see a call to xxx.__len__()
, you have no certainty (except that the code's author is either unfamiliar with Python or up to no good;-).
Other built-ins provide even more added value beyond simple sanity checks and readability. By uniformly designing all of Python to work via calls to builtins and use of operators, never through calls to magic methods, programmers are spared from the burden of remembering which case is which. (Sometimes an error slips in: until 2.5, you had to call foo.next()
-- in 2.6, while that still works for backwards compatibility, you should call next(foo)
, and in 3.*
, the magic method is correctly named __next__
instead of the "oops-ey" next
!-).
So the general rule should be to never call a magic method directly (but always indirectly through a built-in) unless you know exactly why you need to do that (e.g., when you're overriding such a method in a subclass, if the subclass needs to defer to the superclass that must be done through explicit call to the magic method).
You can think of len() as being roughly equivalent to
def len(x):
return x.__len__()
One advantage is that it allows you to write things like
somelist = [[1], [2, 3], [4, 5, 6]]
map(len, somelist)
instead of
map(list.__len__, somelist)
or
map(operator.methodcaller('__len__'), somelist)
There is slightly different behaviour though. For example in the case of ints
>>> (1).__len__()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute '__len__'
>>> len(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()
You can check Pythond docs:
>>> class Meta(type):
... def __getattribute__(*args):
... print "Metaclass getattribute invoked"
... return type.__getattribute__(*args)
...
>>> class C(object):
... __metaclass__ = Meta
... def __len__(self):
... return 10
... def __getattribute__(*args):
... print "Class getattribute invoked"
... return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__() # Explicit lookup via instance
Class getattribute invoked
10
>>> type(c).__len__(c) # Explicit lookup via type
Metaclass getattribute invoked
10
>>> len(c) # Implicit lookup
10
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With