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

原文链接：http://www.cnblogs.com/shengyin/p/11248083.html

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类，添加对"-"的定义

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

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

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

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

 

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

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

 

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

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

 

 

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

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

 

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

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

 

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

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

 

继续看给出的示例：

1 class superList(list):         #定义list类
2     def __sub__(self, b):      #定义'-'运算符的操作
3         a = self[:]            #self引用来表示整个对象
4         b = b[:]               #b为减号后的对象
5         while len(b) > 0:      #判断b的长度是否大于0
6             element_b = b.pop()       #去除b的最后一个元素，赋值给element_b
7             if element_b in a:        #判断b的该元素是否在a中
8                 a.remove(element_b)   #如果是，从a中移除该元素
9         return a                      #整个while循环结束，返回a
10
11 a = superList([1,2,3,5])     #object为list，说明具体的list
12 b = superList([3,4])
13 c = superList([1,2,3])
14
15 print a + b    #不调用__sub__函数，结果为[1, 2, 3, 5, 3, 4]
16 print a - b    #运行到'-'号时，运行__sub__函数，结果为[1, 2，5]

 

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

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

 

return理解

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

1 class superList(list):
2     def __sub__(self, b):
3         a = self[:]
4         b = b[:]
5         while len(b) > 0:
6             element_b = b.pop()
7             if element_b in a:
8                 a.remove(element_b)
9             return a                    #如果放在while内结果是什么？
10
11 >>> a = superList([1,2,3,5])
12 >>> b = superList([3,5])
13 >>> print a - b
14 [1, 2, 3]                              #结果值

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

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

 

__sub__函数理解

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

再来理解下大神的原话：

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

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

1 class superList(list):
2     def __add__(self, b):     #替换为__add__函数
3         a = self[:]
4         b = b[:]
5         while len(b) > 0:
6             element_b = b.pop()
7             if element_b in a:
8                 a.remove(element_b)
9         return a
10
11 a = superList([1,2,3])
12 b = superList([2,3])
13 print a - b             #函数中未对'-'号定义操作，结果报错
14 Traceback (most recent call last):
15   File "<pyshell#4>", line 1, in <module>
16     print a - b
17 TypeError: unsupported operand type(s) for -: 'superList' and 'superList'
18 print a + b             #输出结果值
19 [1]

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

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

 

修改为自定义名称调用。

1 >>> class superList(list):
2        def jian(self, b):     #修改为函数名jian
3            a = self[:]
4            b = b[:]
5            while len(b) > 0:
6                element_b = b.pop()
7                if element_b in a:
8                    a.remove(element_b)
9            return a
10
11 >>> m = superList([1,2,3])
12 >>> n = superList([3,4])
13 >>> l = superList([2,3,4,5])
14 >>> m.jian(n)
15 [1, 2]
17 >>> print m.jian(n)
18 [1, 2]

20 >>> (m.jian(n)).jian(l)              #m-n-l,前者未调用superList类
21 Traceback (most recent call last):
22   File "<pyshell#15>", line 1, in <module>
23     (m.jian(n)).jian(l)
24 AttributeError: 'list' object has no attribute 'jian'

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

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

 

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

1 class superlist(list):
2     def __sub__(self,b):
3         a = self[:]
4         b = b[:]
5         return a+b
6
7
8 >>> a = superlist([1,2])
9 >>> b = superlist([2,3])
10 >>> print a - b          #输出结果值
11 [1, 2, 2, 3]

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

 

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

 

转载于:https://www.cnblogs.com/shengyin/p/11248083.html