Python学习心路历程-day6

时间 2019-11-09

标签 python 学习心路历程 day6 day 栏目 Python 繁體版

原文原文链接

学习内容：python

1. 面向对象编程介绍数据库

2. 类的语法编程

3. 封装app

4. 继承ide

5. 多态模块化

1. 面向对象编程介绍 函数

OOP编程是利用“类”和“对象”来建立各类模型来实现对真实世界的描述，使用面向对象编程的缘由一方面是由于它可使程序的维护和扩展变得更简单，而且能够大大提升程序开发效率，另外，基于面向对象的程序可使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。学习

面向过程编程和面向对象编程：ui

面向过程编程：使用一系列的指令告诉计算机怎么一步步执行
基本设计思路就是程序一开始是着手解决一个大的问题，而后把一个大的问题分解成不少小问题或子过程
面向对象编程：
OOP编程是利用“类”和“对象”来建立各类模型来实现对真实世界的描述
世界万物皆对象。
只要是对象，就确定属于某种类
只要是对象，就肯有属性

面向对象的几个核心特性以下：编码

Class 类
　　一个类便是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具有的属性（variables(data)）、共同的方法。

Object 对象
　　一个对象便是一个类的实例化后实例，一个类必须通过实例化后方可在程序中调用，一个类能够实例化多个对象，每一个对象亦能够有不一样的属性，就像人类是指全部人，每一个人是指具体的对象，人与人以前有共性，亦有不一样。

Encapsulation 封装
　　在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

nheritance 继承
　　一个类能够派生出子类，在这个父类里定义的属性、方法自动被子类继承。

Polymorphism 多态
　　态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不一样的子类，且每一个子类在继承了一样的方法名的同时又对父类的方法作了不一样的实现，这就是同一种事物表现出的多种形态。
　　编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再经过这个抽象的事物, 与不一样的具体事物进行对话。
　　对不一样类的对象发出相同的消息将会有不一样的行为。好比，你的老板让全部员工在九点钟开始工做, 他只要在九点钟的时候说：“开始工做”便可，而不须要对销售人员说：“开始销售工做”，对技术人员说：“开始技术工做”, 由于“员工”是一个抽象的事物, 只要是员工就能够开始工做，他知道这一点就好了。至于每一个员工，固然会各司其职，作各自的工做。
　　多态容许将子类的对象看成父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象能够在运行期间动态绑定。

名词术语：

类(Class):

用来描述具备相同的属性和方法的对象的集合。它定义了该集合中每一个对象所共有的属性和方法。对象是类的实例。

类变量:

类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体以外。

对象:

一个对象便是一个类的实例化后的实例，一个类必须通过实例化后方可在程序中调用，一个类能够实例化多个对象，每一个对象亦能够有不一样的属性。

实例变量:

定义在方法中的变量，只做用于当前实例的类。

方法:

类中定义的函数。（动态属性）

属性:

类变量、实例变量、方法都是属性，变量是静态属性，方法是动态属性

实例化:

建立一个类的实例，类的具体对象。

2.类的语法

用class语句来建立一个新类，class以后为类的名称并以冒号结尾

class liangwei:
    print("我是一个类")

构造方法

class Role(object):  #定义一个类
    def __init__(self): #初始化，构造方法，调用类的时候自动执行的函数
        pass

上面的这个__init__()叫作初始化方法(或构造方法)，在类被调用时，这个方法(虽然它是函数形式，但在类中就不叫函数了,叫方法)会自动执行，进行一些初始化的动做。

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=15000): ##定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法
        self.name = name　　　　　　　　　　　　　　##初始化函数，在生成一个角色时要初始化的一些属性就填写在这里
        self.role = role　　　　　　　　　　　　　　####self.name = r1.name
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    def shot(self):
        print("shooting...")
    def got_shot(self):
        print("ah...,I got shot...")
    def buy_gun(self,gun_name):
        print("just bought %s" %gun_name)
r1 = Role('Alex','police','AK47') #生成一个角色，也便是生成一个实例（对象）
r2 = Role('Jack','terrorist','B22')  #生成一个角色，生成一个实例（对象）咱们看到，上面的建立角色时，咱们并无给__init__传值，程序也没未报错，是由于，类在调用它本身的__init__(…)时本身帮你给self参数赋值了，

r1 = Role('Alex','police','AK47’) #此时self 至关于 r1 , Role(r1,'Alex','police','AK47’)

r2 = Role('Jack','terrorist','B22’)#此时self 至关于 r2, Role(r2,'Jack','terrorist','B22’

例：

#!/usr/bin/env python
#_*_ coding:utf-8 _*_
class Dog:

n = 123   #类变量，公用的属性
　　def __init__(self,name): #构造函数 　　 

　　#self表明d1，self就是为了接受d1，d1（self）其实就是接收的变量值的内存地址，下面函数调用（self）的时候就是把变量传进去（内存地址） 

　　#self：谁调用就是指谁（d1或者d2或者d3） #d1 = Dog（“al”）---->Dog(“d1”,”al”)， 
　　　　self.name = name #实例变量（静态属性），赋值给实例，做用域就是实例自己 

　　def bulk(self): #self接收d1（Dog）   
　　　　””” Bulk：类的方法（动态属性） ”””

　　　　print("%s 汪~汪~汪" %(self.name)) #self.name ===d1.name  
d1 = Dog("旺旺") #只是生成一个dog，并无动做,旺旺是传给了类里面init函数里的变量
d1.name = “旺旺2” #能够更名 
d1.fafagagag = “test” #能够添加一个新的属性 
del d1.name 删除d1的name属性，下面就不能调用了
d2 = Dog("小黑")
d3 = Dog("豆豆")
d1.bulk() #动做 d2.bulk() 

#执行输出： # 旺旺 汪~汪~汪 # 小黑 汪~汪~汪 

#注：变量的顺序，现找实例变量，后找类变量，若是有实例变量就用实例变量，若是没有实例变量，就用类变量

析构函数（方法）

在实例释放、销毁的时候自动执行的，一般用于作一些收尾工做，如关闭一些数据库链接，关闭打开的临时文件

def __del__(self):    #析构函数，收尾工做，自动执行
    pass

例：

  1 #_*_ coding:utf-8 _*_
  2 class Role(object):
  3     def __init__(self,name,role,weapon,life_value=100,money=15000):
  4         #构造函数
  5         #在实例化时作一些类的初始化的工做
  6         self.name = name
  7         self.role = role
  8         self.weapon = weapon
  9         self.life_value = life_value
 10         self.money = money
 11     def __del__(self):    #析构函数，收尾工做，自动执行
 12         print("%s 死了"%self.name)
 13     def shot(self):
 14         print("shooting...")
 15 
 16     def got_shot(self):
 17         print("%s: ah...,I got shot..."%self.name)
 18 
 19     def buy_gun(self,gun_name):
 20         print("just bought %s" %gun_name)
 21 
 22 r1 = Role('Alex','police','AK47')   #生成一个角色
 23 r1.buy_gun("AAA")
 24 r1.got_shot()
 25 r2 = Role('Jack','terrorist','B22')  #生成一个角色
 26 r2.got_shot()
 27 
 28 执行结果：
 29 just bought AAA
 30 Alex: ah...,I got shot...   #在这析构函数并无执行，由于程序还在执行，r1实例还在内存中，没有释放！ 若是想中枪就死，须要在r1执行完后（r1.got_shot()后面）加上del r1
 31 Jack: ah...,I got shot...
 32 Alex 死了
 33 Jack 死了

私有属性&私有方法

　　私有属性：只能内部（类的内部）调用，外面调用不了（r1调用不了）

　　私有方法：和私有属性是同样的。

  1 # _*_ coding:utf-8 _*_
  2 class Role(object):
  3     def __init__(self,name,role,weapon,life_value=100,money=15000):
  4         #构造函数
  5         #在实例化时作一些类的初始化的工做
  6         self.name = name
  7         self.role = role
  8         self.weapon = weapon
  9         self.__life_value = life_value   #私有属性
 10         self.money = money
 11     def __shot(self):       #私有方法
 12         print("shooting...")
 13     def show_status(self):    #只能这样调用
 14         print("%s:life_vale"%self.__life_value)
 15     def got_shot(self):
 16         self.__shot()     #调用私有方法
 17 r1 = Role('A','police','AK47')   #生成一个角色)
 18 r1.got_shot()
 19 #r1._Role__shot()
 20 print(r1.show_status())
 21 r2 = Role('Jack','terrorist','B22')  #生成一个角色
 22 r2.got_shot()

静态方法

  1 # _*_ coding:utf-8 _*_
  2 __author__ = 'XS'
  3 class Dog(object):
  4     def __init__(self,name,food):
  5         self.name = name
  6         self.food = food
  7     # @staticmethod
  8     #静态方法，使下面的类的方法变成一个单纯的函数（使函数跟类没什么关系了，只是仍是须要这个类调用）
  9     #下面的函数不能调用类的变量，也不能调用self。
 10     # @classmethod  #类方法
 11     def eat(self):
 12         print("%s is eating %s"%(self.name,self.food))
 13     # def eat():
 14     #     print("%s is eating %s"%("A","food"))
 15 d = Dog("A","B")
 16 d.eat()
 17 # d = Dog("A","B")
 18 # d.eat()

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

  1 # _*_ coding:utf-8 _*_
  2 class Dog(object):
  3     # name = "zs"
  4     # food = "qiezi"
  5     def __init__(self,name,food):
  6         self.name = name
  7         self.food = food
  8     # @classmethod  #类方法,只能访问类变量，不能访问实例变量
  9     def eat(self):
 10         print("%s is eating %s"%(self.name,self.food))
 11 d = Dog("A","B")
 12 d.eat()

属性方法

  1 # _*_ coding:utf-8 _*_
  2 class Dog(object):
  3     def __init__(self,name):
  4         self.name = name
  5         # self.__food = None
  6     def eat(self):
  7         print("%s is eating %s"%(self.name,"88"))
  8     # @property    # 属性方法,变成一个属性后就不能经过括号传参数了
  9     # def eat(self):
 10     #     print("%s is eating %s"%(self.name,self.__food))
 11     # @eat.setter  #和属性方法对应，用于给属性方法传参数
 12     # def eat(self,food):
 13     #     print "set to food:",food
 14     #     self.__food = food
 15     # @eat.deleter
 16     # def eat(self):
 17     #     del self.__food
 18     #     print("delete")
 19 
 20 d = Dog("A")
 21 d.eat()
 22 # d.eat
 23 # d.eat = "baozi"
 24 # d.eat
 25 #
 26 # del d.eat  #属性方法默认不能删除,须要@eat.deleter
 27 # d.eat

3. 封装

防止数据被随意修改，使外部程序不须要关注对象内部的构造（逻辑结构)，只须要经过此对象对外提供的接口进行直接访问便可。

  1 class Dog(object):
  2 
  3     def __init__(self,name,food):#构造函数，构造方法，==初始化方法
  4         self.NAME = name
  5         self.FOOD = food
  6         self.__getj = 'big'
  7         self.__test = '123'
  8     def sayhi(self):#类的方法（类的具体方法）
  9         print("hello,ni shuo de dui.",self.NAME)
 10     def get_getj(self):
 11         return self.__getj
 12     def eat(self):
 13         print("%s is eating %s"%(self.NAME,self.FOOD))
 14     def __del__(self):
 15         print("del...run....")
 16 
 17 
 18 d = Dog("a1",'haochide')#Dog(d,"a1") #实例化后产生的对象叫实例（当前类的实例）
 19 d2 = Dog("a2",'pi')
 20 
 21 d.sayhi()
 22 d2.sayhi()
 23 d.eat()
 24 d2.eat()
 25 print(d.get_getj())
 26 
 27 print(d._Dog__test)
 28 
 29 def shot2():
 30     print("buhuia")
 31 
 32 d.sayhi = shot2
 33 d.sayhi()
 34 # print(d.test)

4.继承

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可使用现有类的全部功能，并在无需从新编写原来的类的状况下对这些功能进行扩展。

经过继承建立的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程，就是从通常到特殊的过程。

要实现继承，能够经过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类能够继承多个基类。可是通常状况下，一个子类只能有一个基类，要实现多重继承，能够经过多级继承来实现。

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

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

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

在考虑使用继承时，有一点须要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一我的，Manager 也是一我的，所以这两个类均可以继承 Person 类。可是 Leg 类却不能继承 Person 类，由于腿并非一我的。

抽象类仅定义将由子类建立的通常属性和方法。

OO开发范式大体为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

例1：

  1 class  People:
  2     def __init__(self,name,age):
  3         self.name = name
  4         self.age = age
  5     def eat(self):
  6         print("%s is eating...."%self.name)
  7     def talk(self):
  8         print("%s is talking..."%self.name)
  9     def sleep(self):
 10         print("%s is sleeping...."%self.name)
 11 class Man(People):    #继承People类
 12     pass
 13 m1 = Man("A","20")     #由于Man是继承People，因此调用Man的时候须要传和People同样的参数
 14 m1.eat()

例2：

  1 #_*_ coding:utf-8 _*_
  2 class  People(object):
  3     def __init__(self,name,age):
  4         self.name = name
  5         self.age = age
  6     def eat(self):
  7         print("%s is eating...."%self.name)
  8     def talk(self):
  9         print("%s is talking..."%self.name)
 10     def sleep(self):
 11         print("%s is sleeping...."%self.name)
 12 class Man(People):
 13     def __init__(self,name,age,money):     #重构父类方法
 14     #由于继承的父类People，父类里面有name和age属性，因此这里也要加
 15     #实例化的时候传的参数先到这里
 16         # People.__init__(self,name,age)    #把父类的执行一遍(调用父类),经典类写法
 17         super(Man,self).__init__(name,age)  #调用父类，和上面的同样，新式类写法
 18         self.money = money         #name和age 都在父类里面定义了，这里只须要money
 19         print("%s 一出生就有%s money"%(self.name,self.money))
 20     def piao(self):
 21         print("%s is piaoing....."%self.name)
 22 class Woman(People):
 23     def get_birth(self):
 24         print("%s is born a baby...."%self.name)
 25 m1 = Man("A","20","100")
 26 m1.eat()
 27 m1.piao()
 28 
 29 w1 = Woman("B",26)
 30 w1.get_birth()

例3：

  1 #!_*_coding:utf-8_*_
  2 class SchoolMember(object):
  3     members = 0 #初始学校人数为0
  4     def __init__(self,name,age):
  5         self.name = name
  6         self.age = age
  7 
  8     def  tell(self):
  9         pass
 10 
 11     def enroll(self):
 12         '''注册'''
 13         SchoolMember.members +=1
 14         print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))
 15 
 16     def __del__(self):
 17         '''析构方法'''
 18         print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
 19 class Teacher(SchoolMember):
 20     def __init__(self,name,age,course,salary):
 21         super(Teacher,self).__init__(name,age)
 22         self.course = course
 23         self.salary = salary
 24         self.enroll()
 25 
 26 
 27     def teaching(self):
 28         '''讲课方法'''
 29         print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))
 30 
 31     def tell(self):
 32         '''自我介绍方法'''
 33         msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
 34         print(msg)
 35 
 36 class Student(SchoolMember):
 37     def __init__(self, name,age,grade,sid):
 38         super(Student,self).__init__(name,age)
 39         self.grade = grade
 40         self.sid = sid
 41         self.enroll()
 42 
 43 
 44     def tell(self):
 45         '''自我介绍方法'''
 46         msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
 47         print(msg)
 48 
 49 if __name__ == '__main__':
 50     t1 = Teacher("Alex",22,'Python',20000)
 51     t2 = Teacher("TengLan",29,'Linux',3000)
 52 
 53     s1 = Student("Qinghua", 24,"Python S12",1483)
 54     s2 = Student("SanJiang", 26,"Python S12",1484)
 55 
 56     t1.teaching()
 57     t2.teaching()
 58     t1.tell()

多继承

例1：

  1 #_*_ coding:utf-8 _*_
  2 class  People(object):
  3     def __init__(self,name,age):
  4         self.name = name
  5         self.age = age
  6     def eat(self):
  7         print("%s is eating...."%self.name)
  8     def talk(self):
  9         print("%s is talking..."%self.name)
 10     def sleep(self):
 11         print("%s is sleeping...."%self.name)
 12 class Relation(object):
 13     def make_friends(self,obj):
 14         print("%s is making friends with %s" %(self.name,obj.name))   #name在下面类里面继承父类的时候传进去
 15 class Man(People,Relation):      #在Man构造的时候生成了name，下面调用的时候先执行的Man，而后在执行父类的方法
 16     #子类有构造函数（__init__），因此继承的顺序没有关系，若是子类没有构造函数，继承的顺序是有关系的，由于没有构造函数变量就会传到父类里面，一个父类里面没有就去另外一个父类里面找
 17     def __init__(self,name,age,money):     #重构父类方法
 18     #由于继承的父类People，父类里面有name和age属性，因此这里也要加
 19     #实例化的时候传的参数先到这里
 20         # People.__init__(self,name,age)    #把父类的执行一遍(调用父类),经典类写法
 21         super(Man,self).__init__(name,age)  #调用父类，和上面的同样，新式类写法
 22         self.money = money         #name和age 都在父类里面定义了，这里只须要money
 23         print("%s 一出生就有%s money"%(self.name,self.money))
 24     def piao(self):
 25         print("%s is piaoing....."%self.name)
 26 class Woman(People,Relation):
 27     def get_birth(self):
 28         print("%s is born a baby...."%self.name)
 29 m1 = Man("A","22","50")
 30 w1 = Woman("B","22")    #Woman继承的People，因此须要传2个参数
 31 m1.make_friends(w1)      #obj = w1 --》0bj.name == w1.name

经典类和新式类的区别

广度优先：先找D，D没有就找B，B没有找C，C没有找A

深度优先：先找D，D没有就找A，A没有在去找C

  1 #_*_ coding:utf-8 _*_
  2 class A:
  3     def __init__(self):
  4         print("A")
  5 class B(A):    #B继承A
  6     pass
  7     # def __init__(self):
  8     #     print("B")
  9 class C(A):  #C继承A
 10     pass
 11     # def __init__(self):
 12     #     print("C")
 13 class D(B,C): #D继承B，C
 14     pass
 15     # def __init__(self):
 16     #     print("D")
 17 obj = D()

Python2：经典类是按深度优先查询，新式类是按广度优先继承的

python3：经典类和新式类都是统一按广度优先来继承的

继承实例（学校）

实例功能，教师教学，学生缴费

  1 # _*_ coding:utf-8 _*_
  2 class School(object):
  3     def __init__(self,name,addr):
  4         self.name = name
  5         self.addr = addr
  6         self.students = []
  7         self.teachers = []
  8         self.staffs = []
  9     def enroll(self,stu_obj):
 10         print("为学员%s办理注册手续"%stu_obj.name)    #stu_obj是个实例,学员须要实例化，实例化后就能够获得名字
 11         self.students.append(stu_obj)               #添加到列表中的都是实例，打引：print（stu_obj[0].name）
 12     def hire(self,staff_obj):
 13         self.staffs.append(staff_obj)   #添加到列表中的都是实例，打引列表中的值：print（staff_obj[0].name==staff_obj.name）
 14         print("雇佣新员工%s" %staff_obj.name)
 15 class SchoolMember(object):
 16     def __init__(self,name,age,sex):
 17         #学生和老师类都须要继承schoolMember类，老师和学生都有name、age。。。
 18         #下面老师和学生类继承schoolMember类，就能够少写属性了（self.name = name）
 19         self.name = name
 20         self.age = age
 21         self.sex = sex
 22     def tell(self):
 23         pass
 24 class Teacher(SchoolMember):
 25     def __init__(self,name,age,sex,salary,course):  #重构父方法，教师除了name等，还有salary和course（课程）
 26         super(Teacher,self).__init__(name,age,sex)   #继承父类已经实现了的（变量/属性）
 27         self.salary = salary                           #本身的变量（属性）
 28         self.course = course
 29     def tell(self):      #重构tell方法
 30         print('''
 31         ---- info of Teacher：%s ----
 32         name:%s
 33         Age:%s
 34         Sex:%s
 35         Salary:%s
 36         Course:%s
 37         '''%(self.name,self.name,self.age,self.sex,self.salary,self.course))
 38 
 39     def teach(self):            #教师的特性方法
 40         print("%s is teaching course [%s]"%(self.name,self.course))
 41 
 42 class Student(SchoolMember):
 43     def __init__(self,name,age,sex,stu_id,grade):
 44         super(Student,self).__init__(name,age,sex)   ##继承父类已经实现了的（变量),
 45         self.stu_id = stu_id                #本身的变量（属性）
 46         self.grade = grade
 47     def tell(self):      #重构tell方法
 48         print('''
 49         ---- info of Student：%s ----
 50         name:%s
 51         Age:%s
 52         Sex:%s
 53         Stu_id:%s
 54         Grade:%s
 55         '''%(self.name,self.name,self.age,self.sex,self.stu_id,self.grade))
 56     def pay_tuition(self,amount):   #定义学生本身的方法
 57         print("%s has paid tuition for $ %s"%(self.name,amount))
 58 
 59 #开始实例化
 60 #先实例化一个学校
 61 school = School("清华","中关村")    #School类里面构造函数的时候须要2个参数
 62 
 63 t1 = Teacher("Oldboy",56,"Man",20000,"Linux")
 64 t2 = Teacher("Alex",22,"Man",3000,"Python")
 65 
 66 s1 = Student("A",30,"MF",1001,"Python")
 67 s2 = Student("B",20,"Woman",1002,"Linux")
 68 
 69 
 70 t1.tell()
 71 s1.tell()
 72 school.hire(t1)
 73 school.enroll(s1)
 74 school.enroll(s2)
 75 
 76 print(school.students)
 77 print(school.staffs)
 78 
 79 school.staffs[0].teach()
 80 
 81 for stu in school.students:
 82     stu.pay_tuition(5000)

View Code

5.多态

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

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

Pyhon 不少语法都是支持多态的，好比 len(),sorted(), 你给len传字符串就返回字符串的长度，传列表就返回列表长度。

例：

  1 # _*_ coding:utf-8 _*_
  2 class Animal:     #定义一个动物类
  3     def __init__(self,name):
  4         self.name = name
  5     # def talk(self):
  6     #     pass
  7     # @staticmethod     #静态方法
  8     # def duotai(obj):
  9     #     obj.talk()
 10 class Cat(Animal):
 11     def talk(self):
 12         print("%s is miao"%self.name)
 13 class Dog(Animal):
 14     def talk(self):
 15         print("%s is wang"%self.name)
 16 
 17 # def duotai(obj):    #定义一个多态接口，传一个obj参数
 18 #     obj.talk()
 19 d = Dog("A")
 20 d.talk()
 21 
 22 c = Cat("B")
 23 c.talk()
 24 
 25 # duotai(d)
 26 # duotai(c)
 27 
 28 
 29 # Animal.duotai(d)
 30 # Animal.duotai(c)