day33 序列类型，绑定方法，类方法，静态方法，封装继承和多态

Posted 2020-09-27 何必从头

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

 

序列是指有序的队列，重点在"有序"。

一、Python中序列的分类

---

Python中的序列主要以下几种类型：

• 3种基本序列类型(Basic Sequence Types)：list、tuple、range
• 专门处理文本的附加序列类型(Text Sequence Types)：str
• 专门处理二进制数据的附加序列类型(Binary Sequence Types): bytes、bytearray、memoryview

按照序列是否可被改变分类：

• 可变序列: list
• 不可变序列：tuple、str

参考内容：http://www.cnblogs.com/yyds/p/6123692.html

 

---

二、非绑定方法

 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)告诉我们静态方法里的变量同样是静态的。

 

---

四、封装、继承与多态

创建自已对象就python非常核心的概念，事实上，python被称为面向对象语言，本章会介绍如何创建对象。以及面向对象的概念：继承、封装、多态。

多态： 可对不同类的对象使用同样的操作。
封装：对外部世界隐藏对象的工作细节。 
继承：以普通的类为基础建立专门的类对象。

 

多态
面向对象程序设计最有趣的特性是多太，它是是让大多数人犯晕的特性。所以，先来介绍这个。
多态意思是“有多种形式”。多态意味着就算不知道变量所引用的对象类是什么，还是能对它进行操作，而它也会根据对象（或类）类型的不同而表现出不同的行为。

从最简单的开始
　　任何不知道对象到底是什么类型，但是又要对对象“做点什么”的时候，都会用到多态。这不仅限于方法----很多内建运算符和函数都有多态的性质，考虑下面这个例子：

1 >>>1 + 2
2 3
3 >>>\'fish\' + \'license\'
4 fishlicense

这里的加运算符对于数字（本例中为整数）和字符串（以及其他类型的序列）都能起作用。假设有个叫做add的函数，它可以将两个对象相加。那么可以直接将其定义成上面的形式，对于很多类型的参数都可以用，如下：

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

>>> add(1,2)

>>> add(\'hello.\',\'world\')
\'hello.world\'

看起来有点傻，但是关键在于参数可以是任何支持加法的对象。

如果需要编写打印对象长度消息的函数，则只需对象具有长度（len函数可用）即可。

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

len函数用于计算长度，repr用于放置函数的内容；repr函数是多态特性的代表之一---可以对任何东西使用。 
很多函数和运算符都是多态的，你写的绝大多数程序可能都是，即便你并非有意这样。

 

封装

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

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

继承
我们不想把同一段代码写好几，之前使用的函数避免了这种情况。但现在又有个更微妙的问题。如果已经有了一个类，又想建立一个非常类似的类，只是添加几个方法。
比如有动物类，我们又想在动物类的基础上建立鸟类、鱼类，哺乳动物类。

调查继承

如果想要查看一个类是否是另一个的子类。可以使用内建的issubclass函数：

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

 

---

其它注释：

类方法和 不传递参数的区别
　　感觉还是为了让类和对象共享一个方法而已，上面和下面的。。那啥。。
静态方法 让它自动传参，不用不就好了
　　程序写的多的时候，谁会去找含有这个方法的类是谁啊，当然是，实例谁用谁啊