常用方法与特殊方法整理（完成）

Everything is Object

两个内置函数，dir()和help()

dir()用来查询一个类或者对象所有属性。

>>>print dir(list)

help()用来查询的说明文档。

>>>print help(list)

(list是Python内置的一个类，对应于我们之前讲解过的列表)

list常用方法

在上面以及看到，表是Python已经定义好的一个类。当我们新建一个表时，比如：

>>>nl = [1,2,5,3,5]

实际上，nl是类list的一个对象。

实验一些list的方法：

>>>print nl.count(5)            #计数，看总共有多少个5

>>>print nl.index(3)            #查询 nl 的第一个3的下标

>>>nl.append(6)                #在 nl 的最后增添一个新元素6

>>>nl.sort()                        #对nl的元素排序

>>>print nl.pop()                #从nl中去除最后一个元素，并将该元素返回。

>>>nl.remove(2)                #从nl中去除第一个2

>>>nl.insert(0,9)                #在下标为0的位置插入9

总之，list是一个类。每个列表都属于该类。

Python补充中有list常用方法的附录。

运算符是特殊方法

使用dir(list)的时候，能看到一个属性，是__add__()。从形式上看是特殊方法（下划线，下划线）。它特殊在哪呢？

这个方法定义了"+"运算符对于list对象的意义，两个list的对象相加时，会进行的操作。

>>>print [1,2,3] + [5,6,9]

运算符，比如+, -, >, <, 以及下标引用[start:end]等等，从根本上都是定义在类内部的方法。

尝试一下

>>>print [1,2,3] - [3,4]

会有错误信息，说明该运算符“-”没有定义。现在我们继承list类，添加对"-"的定义

class superList(list):
    def __sub__(self, b):
        a = self[:]          #这里，self是supeList的对象。由于superList继承于list，它可以利用和list[:]相同的引用方法来表示整个对象。
        b = b[:]        
        while len(b) > 0:
            element_b = b.pop()
            if element_b in a:
                a.remove(element_b)
        return a

print superList([1,2,3]) - superList([3,4])

内置函数len()用来返回list所包含的元素的总数。

内置函数__sub__()定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。如果__sub__()已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。

（教程最后也会给出一个特殊方法的清单）

定义运算符对于复杂的对象非常有用。举例来说，人类有多个属性，比如姓名，年龄和身高。我们可以把人类的比较（>, <, =）定义成只看年龄。

这样就可以根据自己的目的，将原本不存在的运算增加在对象上了。

没有看懂这个例子，要回过头再来看下。

参考：https://segmentfault.com/q/1010000004004170/a-1020000004004317

---

我们可以看到，python中对'+'做了定义，是对两个list的相加，注意不是值相加。

>>> print [1,2,3] + [5,6,9]
[1, 2, 3, 5, 6, 9]              #输出结果值

但是并没有对'-'做定义，直接输出会报错。

>>> print [1,2,3] - [5,6,9]

Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    print [1,2,3] - [5,6,9]
TypeError: unsupported operand type(s) for -: 'list' and 'list'

内置函数__sub__()定义了“-”的操作：从第一个表中去掉第二个表中出现的元素。

这句话我只在大神的博客里面看到，百度了很久都没找到__sub__的解释。暂且理解字面意思。

继续看给出的示例：

class superList(list):         #定义list类
    def __sub__(self, b):      #定义'-'运算符的操作
        a = self[:]            #self引用来表示整个对象
        b = b[:]               #b为减号后的对象
        while len(b) > 0:      #判断b的长度是否大于0
            element_b = b.pop()       #去除b的最后一个元素，赋值给element_b
            if element_b in a:        #判断b的该元素是否在a中
                a.remove(element_b)   #如果是，从a中移除该元素
        return a                      #整个while循环结束，返回a

a = superList([1,2,3,5])     #object为list，说明具体的list
b = superList([3,4])
c = superList([1,2,3])

print a + b    #不调用__sub__函数，结果为[1, 2, 3, 5, 3, 4]
print a - b    #运行到'-'号时，运行__sub__函数，结果为[1, 2，5]

我们看到__sub__是定义对'-'号的操作，所以当运行到print a - ...减号时，调用__sub__函数，a为减号前的list，b为减号后的list，再运行下面的语句。

所以整个a - b其实运行了一遍__sub_函数。

return理解

对于上述return的位置，可以用下面例子说明。

class superList(list):     
    def __sub__(self, b):  
        a = self[:]        
        b = b[:]           
        while len(b) > 0:     
            element_b = b.pop()   
            if element_b in a:    
                a.remove(element_b)   
            return a                    #如果放在while内结果是什么？

>>> a = superList([1,2,3,5])
>>> b = superList([3,5])
>>> print a - b
[1, 2, 3]                              #结果值

如果放在while内时，执行第一次循环到return时，while循环已结束，所以只会执行一次操作。

结果值在a中只去除了3，没有把5去除掉。

__sub__函数理解

对于__sub__函数，如果我们定义其他函数会怎样呢？

再来理解下大神的原话：

如果__sub__()已经在父类中定义，你又在子类中定义了，那么子类的对象会参考子类的定义，而不会载入父类的定义。任何其他的属性也是这样。

我们来试下，将函数修改为__add__结果会如何。

class superList(list):
    def __add__(self, b):     #替换为__add__函数
        a = self[:]    
        b = b[:]        
        while len(b) > 0:
            element_b = b.pop()
            if element_b in a:
                a.remove(element_b)
        return a

a = superList([1,2,3])
b = superList([2,3])
print a - b             #函数中未对'-'号定义操作，结果报错
Traceback (most recent call last):
  File "<pyshell#4>", line 1, in <module>
    print a - b
TypeError: unsupported operand type(s) for -: 'superList' and 'superList'
print a + b             #输出结果值
[1]

我们会发现，即使python中对__add__函数已经做了定义，但是我们重新对__add__做了定义，所以只载入定义后的。

所以上述函数中，a + b结果值被子类修改后输出为1。

修改为自定义名称调用。

>>> class superList(list):
       def jian(self, b):     #修改为函数名jian
           a = self[:]    
           b = b[:]        
           while len(b) > 0:
               element_b = b.pop()
               if element_b in a:
                   a.remove(element_b)
           return a

>>> m = superList([1,2,3])
>>> n = superList([3,4])
>>> l = superList([2,3,4,5])
>>> m.jian(n)
[1, 2] 
>>> print m.jian(n)
[1, 2]
 
>>> (m.jian(n)).jian(l)              #m-n-l,前者未调用superList类
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    (m.jian(n)).jian(l)
AttributeError: 'list' object has no attribute 'jian'

>>> superList(m.jian(n)).jian(l)     #可修改为如下格式
[1]
>>> m.jian(n+l)                      #注意结果并不完全等于m-n-l，'+'号可直接输入
[1]
>>> m.jian(l.jian(n))                #m-(l-n)
[1, 3]
>>> m.jian(n.jian(l))                #m-(n-l)
[1, 2, 3]

注意调用方式m.jian(n)，注意在python中加法和减法结果值有可能不同。

第一次在看这系列文章时，想着直接使用__sub__怎么实现。

class superlist(list):
    def __sub__(self,b):
        a = self[:]
        b = b[:]
        return a+b

    
>>> a = superlist([1,2])
>>> b = superlist([2,3])
>>> print a - b          #输出结果值
[1, 2, 2, 3]

可能还没有正确理解怎么使用__sub__输出减法值，但对'-'号操作定义，是可以做任何处理的。

感谢大神带领进入python的世界。