Odtnhj

Why do the following lines give me the same result?

str.upper('hello')

and

'hello'.upper()

I tried to do the same with list.append but got a TypeError.

list.append([1]) 

Is the str type in python overloaded? How can this be achieved by writing a class/function? I would appreciate an example.

Thanks,

RP.

list.append takes two arguments - the list to modify and the element to append. So you need to do it like this:

ls = [1]
list.append(ls, 2)

which is equivalent to the much more popular:

ls.append(2)

str.upper and list.append are both functions.

str.upper takes one argument.

>>> str.upper('test')
'TEST'

list.append takes two arguments.

>>> my_list = 
>>> list.append(my_list, 1)
>>> my_list
[1]

str.upper and list.append (like other functions) are also non-data-descriptors with a __get__ method which in this context has two implications:

1. When you access the function through the class via the dot notation (str.upper, list.append) the function's __get__ method (i.e. string.upper.__get__ and list.append.__get__) is called but it returns just the function itself.


2. When you access the function through an instance (my_string.upper, my_list.append) the function's __get__ method is called and it will return a new callable acting like the original function, but with whatever was "in front of the dot" automatically passed as the first argument. .

That's why you need to pass 1 - 1 = 0 arguments when calling my_string.upper() and 2 - 1 = 1 argument when calling my_list.append(1).

>>> 'my_string'.upper()
'MY_STRING'
>>>
>>> my_list = 
>>> my_list.append(1)
>>> my_list
[1]

You could even get these modified callables (methods) by explicitly calling __get__ and passing the argument to be bound (what has been before the dot) as its argument.

>>> my_string = 'my_string'
>>> upper_maker = str.upper.__get__(my_string)
>>> upper_maker()
'MY_STRING'
>>> 
>>> my_list = 
>>> appender = list.append.__get__(my_list)
>>> appender(1)
>>> my_list
[1]

Finally, here's a short example demonstrating how descriptor instances can detect whether they are being accessed via their owner-class or via an instance.

class Descriptor:
 def __get__(self, instance, owner_class):
 if instance is None:
 print('accessed through class')
 # list.append.__get__ would return list.append here
 else:
 print('accessed through instance')
 # list.append.__get__ would build a new callable here
 # that takes one argument x and that internally calls
 # list.append(instance, x)

class Class:
 attribute = Descriptor()

Class.attribute # prints 'accessed through class'

instance = Class()
instance.attribute # prints 'accessed through instance'

Quoting Dave Kirbys answer from Relationship between string module and str:

There is some overlap between the string module and the str type,
mainly for historical reasons. In early versions of Python str objects
did not have methods, so all string manipulation was done with
functions from the string module. When methods were added to the str
type (in Python 1.5?) the functions were left in the string module for
compatibility, but now just forward to the equivalent str method.

However the string module also contains constants and functions that
are not methods on str, such as formatting, character translation etc.

There is nothing at all magical going on with str (except that we have a nice syntactic shortcut to creating one using ""). You can write a class that behaves like str and list to see more clearly what is happening here.

class MyClass():
 def __init__(self, arg):
 self.val=str(arg)

 def do_thing(self):
 self.val = "asdf"

 def do_thing_with_arg(self, arg):
 self.val = "asdf " + str(arg)

 def __repr__(self):
 return self.val


my_thing = MyClass("qwerty")

# this is like 'hello'.upper()
my_thing.do_thing()
print(my_thing)
# it prints 'asdf'

my_thing = MyClass("qwerty")

# this is like str.upper('hello')
MyClass.do_thing(my_thing)
print(my_thing)
# it prints 'asdf'

my_thing = MyClass("qwerty")

# this is like my_list.append('qwerty')
my_thing.do_thing_with_arg('zxcv')
print(my_thing)
# it prints 'asdf zxcv'

my_thing = MyClass("qwerty")

# this is like list.append(my_list, 'qwerty')
MyClass.do_thing_with_arg(my_thing, 'zxcv')
print(my_thing)
# it prints 'asdf zxcv'

The short version is, you're invoking what looks like an "instance method" on a class, but you are supplying the instance ('self') yourself as the first argument to the function call.