Python基础教程笔记——第7章：更加抽象（类）

下面进入Python的面向对象：

对象的魔力：

多态：---可以对不同类的对象使用同样的操作

封装：---对外部隐藏对象内部的工作方式

继承：---以普通的类为基础建立专门的类对象

（1）多态：

isinstance(...)
isinstance(object, class-or-type-or-tuple) -> bool   检查object的类型

isinstance(object, tuple) 检查是否为元组

绑定到对象上的函数称为方法   例如>>> [1,2,'a','1','a'].count('a')  2

repr(object) -> string   一种多态的方式，无论什么转化为字符串

（2）封装

（3）继承

7.2 类和类型

（1）创建使用自己的类

 __metaclass__=type

 class Person:
     def setName(self,name):#这个self变量作为第一个参数传入函数，来绑定对象
         self.name=name
     def getname(self):
         return self.name
     def greet(self):
         print("hello word my name is %s" % self.name)

 #类的使用
 >>> foo=Person()#实例化一个对象
 >>> foo.setName("yanliang")#调用对象的方法
 >>> foo.getname()
 'yanliang'
 >>> foo.greet()
 hello word my name is yanliang

 #特性是可以在外部访问的（这里和C++的私有成员有点区别）
 >>> foo.name='yan'
 >>> foo.getname()
 'yan'

（2）特性，函数，方法

1. 前面的self参数正是方法和函数的区别了，方法可以将它的的一个参数绑定到它的实例上，而函数没有

但是这个参数也是可以不用提供的，就没有了self参数了

 #__metaclass__=type
 class class1:
     def method(self):
         print("yanliang")

 def func():
     print("yan")

 >>> a=class1()
 >>> a.method()
 yanliang
 >>> a.method=func#可以将特性绑定到普通的函数身上
 >>> a.method()
 yan

 class bird:
     sing="yanliang"
     def singing(self):
         print(self.sing)

 #调用上面类的函数
 >>> bird1=bird()
 >>> bird1.singing()
 yanliang

 #可以将对象的变量赋值给别人
 >>> a=bird1.sing
 >>> a
 'yanliang'

 #可以将对象的方法绑定到一个变量上去（还需要对self参数的访问）
 >>> birdsing=bird1.singing
 >>> birdsing()
 yanliang

对象内部成员的私有化

Python不直接支持私有的方式：

让特性或者方法变成私有只要在它的前面加上双下划线就可以了。

 class pclass:
     __val1="yanliang"

     def __fun1(self):
         print(self.__val1)

     def fun2(self):
         self.__fun1()
 #当调用这个类对象时，外部对__val1特性和__fun1方法是没有权利的   

类的定义其实就是只是在执行代码块

类里面的所有实例访问的变量和实例自己所拥有的变量：

 class class1:
     members=0;
     def init(self):
         class1.members+=1

 >>> a=class1()
 >>> a.init()
 >>> class1.members#这里有点类似于C++的静态成员变量
 1
 >>> b=class1()
 >>> b.init()
 >>> class1.members
 2

 >>> a.members="yanliang"#这里类似于C++一般的数据成员变量
 >>> a.members
 'yanliang'
 >>> class1.members
 2

超类（基类）

在定义时在类名后面加一个括号，括号里面为超类。

 class class1:
     def init(self):
         self.num="yan"
     def print1(self):#子类直接继承基类的print1函数，就不需要再写了
         print(self.num)

 class class2(class1):
     def init(self):#这里的子类class2会重写超类的init函数
         self.num="yanliang"

 >>> a=class1()
 >>> a.init()
 >>> a.print1()
 yan

 >>> b=class2()
 >>> b.init()
 >>> b.print1()
 yanliang

可以采用内建的>>> issubclass(class2,class1) 函数来判断一个类是否是另外一个类的子类

可以采用>>> class2.__bases__来找到已知类的所有基类(<class '__main__.class1'>,)

可以采用>>> isinstance(a,class1)来判断一个对象是否是一个类的实例