<15>python学习笔记——类和面向对象

面向对象的特性：

class

一个类即使对一类拥有相同属性的对象的抽象，蓝图，原型。类就是模板。在类中定义了这些对象都具备的属性，共同方法。

object（即叫对象，又叫实例）

一个对象即是一个类的实例化后的实例。一个类必须实例化才能调用。

一个类可以实例化多个对象。

Encapsulation封装

在类中对数据的赋值，内部调用对外部用户是透明的，里面包含着类的数据和方法。

Inheritance 继承

一个类可以派生出子类，这个父类里定义的属性，方法自动被子类继承。

Polymorphism多态

一个接口，多种实现。

一个基类中派生出不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是一种食物表现出的多种形态。

————类，类对象，实例对象

>>> 
>>> #类
>>> class C:
	count = 0

	
>>> #类对象
>>> C.count
0
>>> #实例化（相当于造了一个对象，初始化一个类）
>>> c = C()
>>> c.count
0
>>> 

#构造函数

def __init__(self,...)

#在实例化时做一些类的初始化的工作

实例变量（静态属性）：默认先找实例变量，找不到再找类变量

构造函数里的变量，作用域是实例本身

类变量：

写在类中，构造函数前的类内部公共变量。节省内存开销。

类的方法（动态属性）：

类中的方法，功能

私有方法，私有属性

外部无法直接访问，只能内部访问和修改，只能通过内部方法接口访问。

对象的特有属性

类中没有的公共属性，对象自行创建的。

析构函数

在实例释放，销毁的时候自动执行，通常用于做一些收尾工作，如关闭数据库，和打开的一些文件。

def __del__(self):

class Dog:
    name = 'dodo' #类变量
    def __init__(self,name,life):##构造函数
        self.name = name ##实例变量（静态属性）
        self.__life__ = life##私有属性

    def bulk(self):#类方法（动态属性）
        print('%s :wang,wang ,wang' % self.name)
    def __run__(self):#私有方法
        print('run')


d1 = Dog('drag',100) ##d1是对象（实例化）
d2 = Dog('looss')

d1.bulk()##调用类方法
d2.bulk()

————封装

使用私有属性私有方法隐藏不需对外部分。

————继承

格式：

class  子类名（父类名）

子类会重写父类方法，实现子类特有方法

class Animal:
    def __init__(self,name,color):
        self.name =name
        self.color = color
        print('myName %s'% name+'----'+color)
       
    def Howl(self):
        print('ahohohoahoho')

    def run(self):
        print('run fly.....')

class Dog(Animal):
    pass

class Cat(Animal):
    def Howl(self):
        print('miaomiaomoiao....')


d =Dog('dog','yellow')
d.Howl()
d.run()

c = Cat('cat','flower')
c.Howl()
c.run()
    

=========================== RESTART: G:/animal.py ===========================
myName dog----yellow
ahohohoahoho
run fly.....
myName cat----flower
miaomiaomoiao....
run fly.....
>>> 

子类对父类的构造函数重构

先重构，把父类的取过来。单独写出子类特有的部分。

class Animal:
    name = 'dodo' #类变量
    def __init__(self,name,life):##构造函数
        self.name = name ##实例变量（静态属性）
        self.__life__ = life##私有属性

    def bulk(self):#类方法（动态属性）
        print('%s :wang,wang ,wang' % self.name)
    def __run__(self):#私有方法
        print('run----run----run----')
    def go(self):
        self.__run__()

class Dog(Animal):
    def __init__(self,name,life,color): ##对父类构造函数的重构
        Animal.__init__(self,name,life) ##继承父类共有部分
        self.color = color##构造子类特有部分，增加自有属性
        print('%s is:%s' %(self.name,self.color))

    def bite(self): ##子类特有方法
        print('bite~~')

d1 = Dog('drag',100,'black') ##d1是对象（实例化),传入父类公共参数的同时，需要传入子类特有参数

d1.bulk()##调用父类方法
d1.bite() ##调用子类特有方法
d1.go()##通过调用父类go方法而调用父类私有方法__run__

子类调用父类的方法，可以：

1/ 调用未绑定的父类方法

绑定概念：Python严格要求方法需要有实例才能被调用。

2/使用super函数

————支持多重继承

>>> 
>>> class Base1:
	def foo1(self):
		print('I am foo1')

		
>>> class Base2:
	def foo2(self):
		print('I am foo2')


>>> class C(Base1,Base2):
	def foo3(self):
		print('I am C!')
		
>>> c = C()
>>> c.foo1()
I am foo1
>>> c.foo2()
I am foo2
>>> c.foo3()
I am C!
>>> 

————多态

一种接口多种实现。多态的作用就是为了实现一个目的——接口重用。

————静态方法，类方法，属性方法

静态方法：@staticmethod只是在类中的一个函数，实际上跟类没有了关系，所以也不能调用类变量。@staticmethod 截断了函数和类的关系。

类方法：@classmethod 类方法只能访问类变量，不能访问实例变量

属性方法：@property 把一个方法变成一个静态属性。不用加括号调用。

self是什么：

相当于java的this

————————————————————————————————————

————组合

把类的实例化放到新类里，新类就把旧类组合进去了

把几个没有继承关系的类放在一起。

class Turtle:
    def __init__(self):
        self.num = x

class Fish:
    def __init__(self):
        self.num = y

class Pool:
    def __init__(self,x,y):
        self.Tuitle = Turtle(x)
        self.Fish = Fish(y)

    def print_num(self):
        print('水池中有乌龟%d只，小鱼%d条'% （self.Turtle.num,self.Fish.num）)

————————————————————

———— 一些BIF

issubclass(class,classinfo)

返回True,或者False

第一个参数是第二个参数的子类，返回True

第二个参数可以是一个元组

isinstance(object,classinfo)

返回True,或者False

检查一个实例对象是否属于一个类的（第二个参数）。

第二个参数可是类和元组

hasattr(object,name)

返回True,或者False

测试一个对象里面是否有指定的属性（第二个参数name是属性名）

>>> 
>>> class C:
	def __init__(self,x=0):
		self.x=x

		
>>> c1 =C()
>>> hasattr(c1,'x')
True
>>> 

getattr(object,name[,default])

返回对象指定的属性值，如果指定属性不存在，返回设置的可选属性

>>> 
>>> class C:
	def __init__(self,x=0):
		self.x = x

>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所访问的属性不存在')
'所访问的属性不存在'
>>> 

setattr(object,name,value)
设定对象中指定属性的值，如果不存在就新建一个字符串属性

>>> class C:
	def __init__(self,x=0):
		self.x = x

		
>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所访问的属性不存在')
'所访问的属性不存在'

>>> setattr(c1,'y','longsi')
>>> getattr(c1,'y')
'longsi'
>>> 

delattr(object,name)
删除对象中指定的属性，属性不存在则抛出异常

提供一个对外的接口x，内部属性的重新设置不影响使用感受

>>> 
>>> class C:
	def __init__(self,x=0):
		self.x = x

		
>>> c1 =C()
>>> getattr(c1,'x')
0
>>> getattr(c1,'y','所访问的属性不存在')
'所访问的属性不存在'
>>> 
>>> setattr(c1,'y','longsi')
>>> getattr(c1,'y')
'longsi'
>>> 
>>> delattr(c1,'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):
		self.size = value
	def delSize(self):
		del self.size
	x = property(getSize,setSize,delSize)

	
>>> c1 = C()
>>> c1.getSize()
10
>>> c1.x
10