面向对象化（封装，继承，多态）

面向过程，
面向函数，reduce（add,[1,2,3]）
面向对象
面向对象的三大特性: 封装, 继承, 多态
先看这个例子

##定义类的过程
class Animal: ##__init__构造函数，当实例化时会自动取调用##self实质上是实例化的对象本身 def __init__(self,name,age,weight):##类的属性self.name=nameself.age=ageself.weight=weight# 析构函数; 一般用作类的清理工作，自动调用;def __del__(self):print "delete........"
##实例化对象的过程 cat使实例化的一个对象，实例化的属性name,age,weight
cat=Animal('fentiao',10,13)
print cat.name
print cat.age
print cat
---->>结果
fentiao
10
13
<__main__.Animal instance at 0x7fb31c2033f8>
delete........

定义一个类

经典类的格式python2.x
class 类名:def __init__(self):self后可以跟类的属性
变量名=类名(添加类的属性)

类名后面有括号的类,称为新式类;python2.xpython3.x
括号里面的内容是父类的名称;程序中,所有类的父类都是 object;
class Animals(object):pass
print Animals
<class '__main__.Animals'>

方法的调用，一般方法函数名建议使用动词
类的方法 ==== 函数在类中定义的函数叫做方法 ;
类的方法中, python 解释器要求第一个形参必须是 self

import random
import time
class Animal:def __init__(self,name,age,weight):self.name=nameself.age=ageself.weight=weightdef eat(self):print 'eating...'time.sleep(random.random())self.weight+=1print "%s now weight:%s" %(self.name,self.weight)def play(self):print 'playing...'time.sleep(random.random())self.weight-=1print "%s now weight:%s" % (self.name, self.weight)def __del__(self):print '清理中...'
cat = Animal('fentiao',10,12)
print cat.name , cat.age,cat.weight
cat.eat()
cat.play()
del cat
---->>结果
fentiao 10 12
eating...
fentiao now weight:13
playing...
fentiao now weight:12
清理中...

封装,封装实际上是把数据封装到某个地方, 以后再去调用被封装在某处的内容或者数据;

封装数据
调用封装数据
通过对象直接调用;
通过self间接调用

class People():def __init__(self,name,age,gender):self.name=nameself.age=ageself.gender=genderdef goHome(self):print '%s,%s岁,%s,辍学回家' %(self.name,self.age,self.gender)def kanChai(self):print '%s,%s岁,%s,上山去砍柴' % (self.name, self.age, self.gender)def quXiFu(self):print '%s,%s岁,%s,开车娶媳妇' % (self.name, self.age, self.gender)laoli =People('老李',18,'男')
laoli.quXiFu()
xiao=People('校思浩',22,'男')
xiao.kanChai()
tang=People('唐浩',10,'女')
tang.goHome()

继承

-父类和子类; 基类和派生类;
-注意: 类的属性名和方法名不同相同;
-建议:
-属性名用名词;eg:name, age, weight;
-方法名建议用动词; eg: eat, drink, get_weight;

第一种情况，子类不存在__init__函数

class Animal(object):def __init__(self,name,age,weight):self.name=nameself.age=ageself.weight=weightdef eat(self):print 'eating...'def play(self):print 'playing...'##Cat: 子类，/派生类; Animal:父类/基类;
# 子类不存在__init__函数， 调用父类的；
# 子类存在__init__函数， 调用子类的；
class Cat(Animal):passjumao = Cat('jumao',12,14)
print jumao
jumao.play()
---->>
<__main__.Cat object at 0x7f387cb14f50>
playing...

第二种情况:存在__init__函数,执行报错，子类Cat存在__ini__函数，而且参数有两个self和country，很明显子类没有调用Animal父类，

如果子类存在构造函数有想调用父类构造函数怎么办？第一种继承方法：可维护性低
-Animal.init(self,name,age,weight)


class Animal(object):def __init__(self,name,age,weight):self.name=nameself.age=ageself.weight=weightdef eat(self):print 'eating...'def play(self):print 'playing...'
class Cat(Animal):def __init__(self,name,age,weight,country):Animal.__init__(self,name,age,weight)self.name = nameself.age = ageself.weight = weightself.country=countryjumao = Cat('jumao',12,14,'CHINA')
print jumao.name,jumao.age,jumao.country
jumao.play()
---->>
jumao 12 CHINA
playing...

第二种继承方法：可维护性高

class Animal(object):def __init__(self,name,age,weight):self.name=nameself.age=ageself.weight=weightdef eat(self):print 'eating...'def play(self):print 'playing...'
class Cat(Animal):def __init__(self,name,age,weight,country):super(Cat,self).__init__(name,age,weight)self.country=countryjumao = Cat('jumao',12,14,'CHINA')
print jumao.name,jumao.age,jumao.country
jumao.play()
--->>
jumao 12 CHINA
playing...

多继承

新式类多继承时，继承算法是广度优先; 查看方式A.mro()
A - (B,C) -D

经典类多继承时，继承算法是深度优先;

新式类

class D(object):def test(self):print "D test"class C(D):def test(self):print "C test"class B(D):pass# def test(self):#     print "B test"class A(B,C):pass# def test(self):#     print "A test"a=A()
a.test()
print A.mro()
--->>结果：A首先继承B的属性，但是B此时为空，没有构造函数，与时去继承C，最后执行C的__init__函数，A.mro()是继承的一个顺序
C test
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <type 'object'>]

经典类：没有*.mro()属性

class D():def test(self):print "D test"class C(D):def test(self):print "C test"class B(D):pass# def test(self):#     print "B test"class A(B,C):pass# def test(self):#     print "A test"a=A()
a.test()
--->>结果，A没有构造函数，所以第一时间会去继承B的构造函数，B为空，接着深度挖掘去继承B的父类D的属性，
D test

多态:当父类和子类有相同的方法时, 调用优先执行子类的方法;

实验说明1：子类和父类doc方法共存，调用子类doc方法

class Student(object):def __init__(self,name='xiaoming',score=300):self.name=nameself.__score = scoredef doc(self):print '这时父类doc方法'class MathStudnet(Student):passdef doc(self):print '这时子类doc方法'
a=MathStudnet('xiaoli',50)
print a.name
a.doc()
---->>结果
xiaoli
这时子类doc方法

实验说明2：子类无doc方法共存，调用父类doc方法

class Student(object):def __init__(self,name='xiaoming',score=300):self.name=nameself.__score = scoredef doc(self):print '这时父类doc方法'class MathStudnet(Student):passa=MathStudnet('xiaoli',50)
print a.name
a.doc()
---->>结果：
xiaoli
这时父类doc方法

类属性（一）

class Animal(object):"""Animal class"""passprint Animal.mro()
print Animal.__name__
print Animal.__bases__
print Animal.__doc__,'\n'
print "*"*20+"分割线"+"*"*20,'\n'cat = Animal()print cat.__class__
print cat.__module__---->>结果：
[<class '__main__.Animal'>, <type 'object'>]
Animal
(<type 'object'>,)
Animal class ********************分割线******************** <class '__main__.Animal'>
__main__

关于module

在Package/package01/module01中定义Animal新式类

在modelu02中导入该模块，查看cat类模块名

两个特别的函数（魔术函数）：repr(self):和str(self):

__repr__(self):调试时自动调用，__str__(self):打印对象时自动调用

class Animal(object):def __init__(self,name):self.name = namedef __repr__(self):"""调试时自动调用, a = Animal("xxx")   a:return:"""return "Animals:%s" %(self.name)def __str__(self):"""打印对象时，自动调用"""return  "%s" %(self.name)a = Animal('fentiao')print a

实验：

class Animal(object):def __init__(self,name):self.name=namedef __repr__(self):return '据说调试时自动调用它__repr__(self)'def __str__(self):return '据说打印时自动调用它__str__(self):'dog = Animal('habagou')
print dog
---->>结果
据说打印时自动调用它__str__(self):