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）创建使用自己的类

 1 __metaclass__=type
 2 
 3 class Person:
 4     def setName(self,name):#这个self变量作为第一个参数传入函数，来绑定对象
 5         self.name=name
 6     def getname(self):
 7         return self.name
 8     def greet(self):
 9         print("hello word my name is %s" % self.name)
10 
11 #类的使用        
12 >>> foo=Person()#实例化一个对象
13 >>> foo.setName("yanliang")#调用对象的方法
14 >>> foo.getname()
15 'yanliang'
16 >>> foo.greet()
17 hello word my name is yanliang
18 
19 #特性是可以在外部访问的（这里和C++的私有成员有点区别）
20 >>> foo.name='yan'
21 >>> foo.getname()
22 'yan'

 （2）特性，函数，方法

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

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

 1 #__metaclass__=type
 2 class class1:
 3     def method(self):
 4         print("yanliang")
 5 
 6 def func():
 7     print("yan")
 8 
 9 
10 >>> a=class1()
11 >>> a.method()
12 yanliang
13 >>> a.method=func#可以将特性绑定到普通的函数身上
14 >>> a.method()
15 yan

 

 1 class bird:
 2     sing="yanliang"
 3     def singing(self):
 4         print(self.sing)
 5         
 6 #调用上面类的函数
 7 >>> bird1=bird()
 8 >>> bird1.singing()
 9 yanliang
10 
11 #可以将对象的变量赋值给别人
12 >>> a=bird1.sing
13 >>> a
14 'yanliang'
15 
16 #可以将对象的方法绑定到一个变量上去（还需要对self参数的访问）
17 >>> birdsing=bird1.singing
18 >>> birdsing()
19 yanliang

对象内部成员的私有化

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

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

1 class pclass:
2     __val1="yanliang"
3 
4     def __fun1(self):
5         print(self.__val1)
6 
7     def fun2(self):
8         self.__fun1()
9 #当调用这个类对象时，外部对__val1特性和__fun1方法是没有权利的   

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

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

 1 class class1:
 2     members=0;
 3     def init(self):
 4         class1.members+=1
 5 
 6 >>> a=class1()
 7 >>> a.init()
 8 >>> class1.members#这里有点类似于C++的静态成员变量
 9 1
10 >>> b=class1()
11 >>> b.init()
12 >>> class1.members
13 2
14 
15 >>> a.members="yanliang"#这里类似于C++一般的数据成员变量
16 >>> a.members
17 'yanliang'
18 >>> class1.members
19 2

 超类（基类）

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

 1 class class1:
 2     def init(self):
 3         self.num="yan"
 4     def print1(self):#子类直接继承基类的print1函数，就不需要再写了
 5         print(self.num)
 6 
 7 class class2(class1):
 8     def init(self):#这里的子类class2会重写超类的init函数
 9         self.num="yanliang"
10         
11 >>> a=class1()
12 >>> a.init()
13 >>> a.print1()
14 yan
15 
16 >>> b=class2()
17 >>> b.init()
18 >>> b.print1()
19 yanliang

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

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

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

 

转载于:https://www.cnblogs.com/yanliang12138/p/4713308.html