Python之路，Day20 = 序列类型，绑定方法，类方法，静态方法，封装继承和多态

 1 非绑定方法必须被实例调用
 2 
 3 
 4 class foo():
 5     foovar=1
 6     def __init__(self):
 7         self.avar=3
 8     def method(self):
 9         methodvar=2
10         print ‘hello‘,methodvar
11 class foo1(foo):
12     foo1var=4
13     def __init__(self,nm):
14         foo.__init__(self)
15         #调用非绑定方法——父类构造器
16         self.fooo=self.avar
17         print self.fooo
18     def method(self):
19         pass
20 a=foo1(2)
21 #1.这是我根据Python核心编程上的例子写的，我们要弄清楚一点：类里面的方法就是非绑定方法，实例里面的方法就是绑定的。
22 #2.既然上面说非绑定方法只能被实例调用，那么我们是如何调用一个类的非绑定方法的呢？实际上用类不能调用非绑定方法，无非是没有给
23 self参数，那么我们给它就是。
24 >>> foo.hehe(a)
25 haha
26 
27 #self=a
28 同样的道理，调用父类构造器给子类用，那么直接给self（就是子类对象）就可以啦！
29 # 我们一般都是通过实例来调用，但也可以使用类来调用，比如上面通过调用父类的构造器可以避免子类调用时需要大量参数传递的情况

 1 #coding=utf-8
 2 class A(object):
 3     count=1
 4     def foo(self,x):
 5     #类实例方法
 6         print "executing foo(%s,%s)"%(self,x)
 7     def foo2(self):
 8         self.foo(5)
 9         foo2var=self.count
10     @classmethod
11     def class_foo(cls):
12     #类方法
13         cls.count=cls.count+1
14 
15     @staticmethod
16     def static_foo(x):
17     #静态方法
18         x+=1.1
19         print "executing static_foo(%s)"%x,id(x)
20 a=A()
21 b=A()
22 a.class_foo()
23 print a.count,b.count,A.count
24 b.class_foo()
25 print a.count,b.count,A.count
26 A.class_foo()
27 print a.count,b.count,A.count
28 打印结果
29 2 2 2
30 3 3 3
31 4 4 4
32 
33 #一个类数据属性，只有通过类来调用时才会改变，通过实例来改变实际上不会对类产生影响。但是如果通过类方法来改，那么即便是实例调用也能改变类数据属性，这我觉得是很危险的。
34 #一般其它编程语言都会不允许实例调用类方法，比如Java，这样做的好处就是你能很轻松的利用类方法修改类属性。但Python允许实例调用类方法，但请不要这么做！

 1 #coding=utf-8
 2 class A(object):
 3     count=1
 4     def foo(self,x):
 5     #类实例方法
 6         print "executing foo(%s,%s)"%(self,x)
 7     def foo2(self):
 8         self.foo(5)
 9         foo2var=self.count
10     @classmethod
11     def class_foo(cls):
12     #类方法
13         cls.count=cls.count+1
14 
15     @staticmethod
16     def static_foo(self,x):
17     #静态方法
18         x+=1.1
19         self.count=3
20         print "executing static_foo(%s)"%x,id(x)
21 a=A()
22 b=A()
23 a.static_foo(a,2)
24 print a.count,b.count,A.count
25 b.static_foo(b,3)
26 print a.count,b.count,A.count
27 A.static_foo(A,4)
28 print a.count,b.count,A.count
29 输出结果
30 executing static_foo(3.1) 20196512
31 3 1 1
32 executing static_foo(4.1) 20196512
33 3 3 1
34 executing static_foo(5.1) 20196512
35 3 3 3
36 
37 #一般静态方法不要求你写self，但你可以这么干，同类数据属性的性质一样，类的静态方法修改会影响实例，实例却只影响自身
38 #id(x)告诉我们静态方法里的变量同样是静态的。

1 >>>1 + 2
2 3
3 >>>‘fish‘ + ‘license‘
4 fishlicense

>>> def add(x,y):
    return x+y

>>> add(1,2)

>>> add(‘hello.‘,‘world‘)
‘hello.world‘

1 >>> def length_message(x):
2     print"The length of " , repr(x),"is",len(x)
3 
4     
5 >>> length_message(‘chongshi‘)
6 The length of  ‘chongshi‘ is 8
7 >>> length_message([1,2,3])
8 The length of  [1, 2, 3] is 3

 

封装

封装是对全局作用域中其它区域隐藏多余信息的原则。
封装听起来有些像多态，因为他们都是 抽象的原则---他们都会帮助处理程序组件而不用过多关心多余细节，就像函数做的一样。
但是封装并不等同于多态。多态的可以让用户对于不知道是什么类（或对象类型）的对象进行方法调用，而封装是可以不用关心对象是如何构建的而直接进行使用。
创建一个有对象（通过像调用函数一样调用类）后，将变量c绑定到该对象上。可以使用setName 和 getName 方法（假设已经有）

1 >>> c = closedObject()
2 >>> c.setName(‘sir lancelot‘)
3 >>> c.getName()
4 ‘sir lancelot’

1 >>> issubclass(SPAMFilter, Filter)
2 True
3 >>> issubclass(Filter,SPAMFilter)
4 False