本节目录-面向对象

1 类介绍

1.1 面向对象oo特征

1.2 类的特性

1.3 创建与调用

1.3.1 基本结构

1.3.2 结构说明

1.3.3 对外部提供只读访问接口

1.3.4 析构方法

2 继承

2.1 继承介绍

2.2 横向关系（组合）VS纵向关系（继承）

2.3 内置函数

2.3.1 issubclass

2.3.2 isinstance

2.3.3 hassttr

 

1 类介绍

1.1 面向对象oo特征

oo=Object Oriented

1、封装---信息隐蔽技术

2、继承---子类自动共享父类之间数据和方法的机制

3、多态---不同对象对同一方法响应不同的行动(不同的class中可以含有相同的函数名，响应根据函数中的定义进行)

1.2 类的特性

封装:

1、防止数据被随意修改； 2、使外部程序不需要关注对象内部的构造，只需要通过此对象对外提供的接口进行直接访问即可；

继承：

通过父类-子类的方式以最简洁的方式实现，不同角色

1.3 创建与调用

1.3.1 基本结构

类创造对象，对象称为类的一个实例（实例对象）

类对象（class、大写字母开头）=属性（变量）+方法（函数）

class Tirle:#python中类以大写字母开头

class Dog(object):

nation = 'china' #公有属性

def __init__(self,name,food): #构造函数、构造方法==初始化函数

self.name = name #成员属性

# self.food = food

self.__heart = 'namal' #私有属性

def wark(self): #类的方法

print('%s is dog'% self.name)

def eat(self,food):

print("%s is eating %s" %(self.name,food))

D = dog('sss','dutou') #实例化后产生的对象称为实例

D.wark()

D.eat('baozi')

1.3.2 结构说明

类-->>实例化-->>实例

self 就是调用当前方法的对象

__init__ #构造方法

返回值为None，强制添加返回值会报错TypeError:__init__() should return None

self.name = name #属性--成员属性 外部可以调用，并且内部方法也可以调用

self.__name = name #私有属性(对外部不可见，内部的方法可以调用)

__private_attr_name = value私有属性

def sayhi() #方法

++++++++++++++++++++++++++

__init__(self)方法:构造方法

返回值为None，强制添加返回值会报错TypeError:__init__() should return None

>>> class ball:

def __init__(self,name):

self.name = name

def kick(self):

print ('I am %s , who kick me' % self.name)

>>> a = ball('A')

>>> a.kick()

I am A , who kick me

>>> a = ball() #----->>必须添加参数、否则报错

Traceback (most recent call last):

File "<pyshell#29>", line 1, in <module>

a = ball()

TypeError: __init__() missing 1 required positional argument: 'name'

添加默认参数：

>>> class ball:

def __init__(self,name='null'):

self.name = name

def kick(self):

print ('I am %s , who kick me' % self.name)

>>> a = ball('A')

>>> a.kick()

I am A , who kick me

>>> a = ball()

>>> a.kick()

I am null , who kick me

不添加默认参数会报错：

++++++++++++++++++++++++++

1.3.3 对外部提供只读访问接口

def get_heart(self): #比较安全

return self.__heart

强制访问私有属性:

r1._Role__heart

公有属性:所有实例化的对象都可以访问的属性为公有属性(在类中直接定义)

Role.nation = 'US' 更改公有属性

+++++++++++++++++++++++++++++++++

私有变量或者函数：在python中定义私有变量或者函数只需要在变量名或函数名前加上“__”两个下划线

>>> class person():

__name = "a"

def getname(self):

return self.__name

>>> p = person()

>>> p.__name

Traceback (most recent call last):

File "<pyshell#52>", line 1, in <module>

p.__name

AttributeError: 'person' object has no attribute '__name'

>>> p.getname()

'a'

伪私有：将变量或者函数改成"_类名__变量名"的形式

>>> p._person__name

'a'

+++++++++++++++++++++++++++++++++

1.3.4 析构方法

删除实例化的实例

def __del__(self):

print("del--run")

2 继承

2.1 继承介绍

继承概念的实现方式主要有2类：实现继承、接口继承。

实现继承是指使用基类的属性和方法而无需额外编码的能力；

接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)；

多继承时--继承顺序的区别(py2中才能体现，py3全部使用广度查询的方式进行继承)

新式类，查询使用广度查询，将同级的所有类全部查询完毕才继续往上一层类中查找

经典式类，查询使用深度查询，将纵深的所有类全部查询完毕才继续同一层的其他层中查找

class 子类（基类、父类、超类）

class DerivedClassName(BaseClassName):

……

>>> class parent:

def hello(self):

print ('old jaksjd parent')

>>> class child(parent):

pass

>>> p = parent()

>>> p.hello()

old jaksjd parent

>>> c = child()

>>> c.hello()

old jaksjd paren

注意：如果子类中定义与父类同名的方法或者属性，在调用时调用自己的属性或者方法。

>>> class parent:

def hello(self):

print ('old jaksjd parent')

>>> class child(parent):

def hello(self):

print ('new jaksjd child')

>>> p = parent()

>>> p.hello()

old jaksjd parent

>>> c = child()

>>> c.hello()

new jaksjd child

注意：经典类VS新式类 #建议使用新式类

class Person(object): #new style

super

class Person: #classical style

ParentClass.__init__

#SchoolMember.__init__(self,name,age,sex) #经典类继承写法

super(Teacher,self).__init__(name,age,sex) #新式类继承写法

2.2 横向关系（组合）VS纵向关系（继承）

class tutle:

def __init__(self,x):

self.num = x

class fish:

def __init__(self,x):

self.num = x

class pool:

def __init__(self,x,y):

self.tutle = tutle(x)

self.fish = fish(y)

def print_num(self):

print('the totel of tutle is %d in the pool,the totel of fish is %d in the pool!' % (self.tutle.num,self.fish.num))

>>> pool = pool(1,10)

>>> pool.print_num()

the totel of tutle is 1 in the pool,the totel of fish is 10 in the pool!

Mix_in

绑定：

python严格要求方法需要有实例才能被调用，这种限制就是python的绑定。

2.3 内置函数

所有的类的统称为：object

2.3.1 issubclass

issubclass(class,classinfo)检查class是否是classinfo的一个子类，是则返回true

1、一个类被认为是自身的一个子类

2、classinfo可以是类对象组成的元组，只要class是其中任何一个候选类的子类，则返回true

>>> class a:

pass

>>> class b(a):

pas

>>> class c :

pass

>>> issubclass(a,b)

False

>>> issubclass(b,a)

True

>>> issubclass(a,a)

True

>>> issubclass(c,b)

False

>>> issubclass(a,object)

True

2.3.2 isinstance

isinstance(object,classinfo)检查一个实例对象object是否属于一个类classinfo，

1、如果第一个参数不是对象，则永远返回false

2、如果第二个参数不是类或者由类对象组成的元组，会抛出TypeError异常

>>> b1 = b()

>>> isinstance (b1,b)

True

>>> isinstance (b1,a)

True

>>> isinstance (b1,(a,b,c))

True

2.3.3 hassttr

attr = attribute:属性

hassttr(object,name)检查一个对象是否有指定的属性

name表示一个属性名，需要用单引号将其括起来，格式为：‘name’

>>> class C:

def __init__(self,x=0):

self.x=x

>>>

>>> c1 = C()

>>> hasattr(c1,'x')

True

>>> hasattr(c1,'y')

False

>>> hasattr(c1,x)

Traceback (most recent call last):

File "<pyshell#26>", line 1, in <module>

hasattr(c1,x)

NameError: name 'x' is not defined

getattr(object,name[,default])返回一个对象中指定的属性的值；如果指定的属性不存在，当

含有default参数时返回默认值，否则返回no attribute 'name'

>>> getattr(c1,'x')

0

>>> getattr(c1,'y')

Traceback (most recent call last):

File "<pyshell#28>", line 1, in <module>

getattr(c1,'y')

AttributeError: 'C' object has no attribute 'y'

>>> getattr(c1,'y',"您所访问的属性不存在……")

'您所访问的属性不存在……'

setattr(object,name,value)设置一个对象中指定属性的值，如果指定的属性不存在则新建属性并赋值

>>> setattr(c1,'y','fish')

delattr(object,name)删除一个对象中指定的属性，如果指定的属性不存在则抛出AttributeError

>>> getattr(c1,'y')

'fish'

>>> delattr(c1,'y')

>>> delattr(c1,'y')

Traceback (most recent call last):

File "<pyshell#36>", line 1, in <module>

delattr(c1,'y')

AttributeError: y

property(fget=None,fset=None,fdel=None,doc=None)用过属性来控制属性

>>> class C:

def __init__(self,size=10):

self.size=size

def getsize(self):

return self.size

def setsize(self,value):

self.size=value

def delsize(self):

del self.size

x=property(getsize,setsize,delsize)

>>> c1=C()

>>> c1.size

10

>>> c1.getsize()

10

>>> c1.x=18

>>> c1.getsize()

18

3 多态

多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。

那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。