python 第六课笔记

 

1、面向对象引子

　　你现在是一家游戏公司的开发人员，现在需要你开发一款叫做<人狗大战>的游戏，你就思考呀，人狗作战，那至少需要2个角色，一个是人，一个是狗，且人和狗都有不同的技能，比如人拿棍打狗，狗可以咬人，怎么描述这种不同的角色和他们的功能呢？你搜罗了自己掌握的所有技能，写出了下面的代码来描述这两个角色：

 

def person(name,age,sex,job):
    data = {
     'name':name,
     'age':age,
     'sex':sex,
     'job':job
    }
  
    return data
  
def dog(name,dog_type):
    data = {
        'name':name,
        'type':dog_type
    }
    return data

　　

上面两个方法相当于造了两个模子，游戏开始，你得生成一个人和狗的实际对象吧，怎么生成呢？

d1 = dog("李磊","京巴")
  
p1 = person("严帅",36,"F","运维")
  
p2 = person("林海峰",27,"F","Teacher")

　　

两个角色对象生成了，狗和人还有不同的功能呀，狗会咬人，人会打狗，对不对? 怎么实现呢, 想到了，可以每个功能再写一个函数，想执行哪个功能，直接调用就可以了，

def bark(d):
    print("dog %s:wang.wang..wang..."%d['name'])
  
  
def walk(p):
    print("person %s is walking..." %p['name'])
 
 
d1 = dog("李磊","京巴")
p1 = person("严帅",36,"F","运维")
p2 = person("林海峰",27,"F","Teacher")
 
walk(p1)
bark(d1)

　　

上面的功能实现的简直是完美！但是仔细玩耍一会，你就不小心干了下面这件事：

def person(name,age,sex,job):
    def walk(p):
        print("person %s is walking..." % p['name'])
  
    data = {
        'name':name,
        'age':age,
        'sex':sex,
        'job':job,
        'walk':walk
    }
  
    return data
  
def dog(name,dog_type):
  
  
    def bark(d):
        print("dog %s:wang.wang..wang..."%d['name'])
    data = {
        'name':name,
        'type':dog_type,
        'bark':bark
    }
  
    return data
 
d1 = dog("李磊","京巴")
p1 = person("严帅",36,"F","运维")
p2 = person("林海峰",27,"F","Teacher")
 
d1['bark'](p1) #把人的对象传给了狗的方法

　　

你是如此的机智，这样就实现了限制人只能用人自己的功能啦。但，我的哥，不要高兴太早，刚才你只是阻止了两个完全不同的角色之前的功能混用，但有没有可能，同一个种角色，但有些属性是不同的呢？比如，大家都打过cs吧，cs里有警察和恐怖份子，但因为都是人，所以你写一个角色叫 person(), 警察和恐怖份子都可以互相射击，但警察不可以杀人质，恐怖分子可以，这怎么实现呢？你想了说想，说，简单，只需要在杀人质的功能里加个判断，如果是警察，就不让杀不就ok了么。没错，这虽然解决了杀人质的问题，但其实你会发现，警察和恐怖分子的区别还有很多，同时又有很多共性，如果在每个区别处都单独做判断，那得累死。

总结：需要通过面向对象的知识解决更为复杂的一些关系描述。

2、面向过程编程

1、编程范式

　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。两种最重要的编程范式分别是面向过程编程和面向对象编程。

2、面向过程编程(Procedural Programming)

　　Procedural programming uses a list of instructions to tell the computer what to do step-by-step. 面向过程编程依赖 - 你猜到了- procedures，一个procedure包含一组要被进行计算的步骤，面向过程又被称为top-down languages，就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

①举个典型的面向过程的例子，数据库备份，分三步，连接数据库，备份数据库，测试备份文件可用性，代码如下：

def db_conn():
    print("connecting db...")
  
  
def db_backup(dbname):
    print("导出数据库...",dbname)
    print("将备份文件打包，移至相应目录...")
  
def db_backup_test():
    print("将备份文件导入测试库，看导入是否成功")
  
  
def main():
    db_conn()
    db_backup('my_db')
    db_backup_test()
  
  
  
if __name__ == '__main__':
    main()

　　

　　这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改，举个例子，如果程序开头你设置了一个变量值为1 ，但如果其它子过程依赖这个值为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程，那就会发生一连串的影响，随着程序越来越大，这种编程方式的维护难度会越来越高。所以我们一般认为，如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护的，那还是用面向对象最方便了。

 

3、面向对象概念介绍

1、面向对象编程

　　OOP(Object-Oriented Programming)编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

2、Class类

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

3、Object对象

　　一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同。

 

4、面向对象特性

1、封装(Encapsulation )

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

封装的作用：

         防止对象的数据被随意修改

         使外部程序不需要关注对象内部的构造，只需要通过此对象对外提供的接口进行直接访问即可

2、继承(Inheritance)

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

　　通过父类-->子类的方式以最小代码量的方式实现，不同角色的共同点和不同点的同时存在。

3、多态(Polymorphism )

　　多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

　　编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。
对不同类的对象发出相同的消息将会有不同的行为。比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物, 只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。

5、面向对象介绍

       对于编程语言的初学者来讲，OOP不是一个很容易理解的编程方式，大家虽然都按老师讲的都知道OOP的三大特性是继承、封装、多态，并且大家也都知道了如何定义类、方法等面向对象的常用语法，但是一到真正写程序的时候，还是很多人喜欢用函数式编程来写代码，特别是初学者，很容易陷入一个窘境就是“我知道面向对象，我也会写类，但我依然没发现在使用了面向对象后，对我们的程序开发效率或其它方面带来什么好处，因为我使用函数编程就可以减少重复代码并做到程序可扩展了，为啥子还用面向对象？”。对于此，我个人觉得原因应该还是因为你没有充分了解到面向对象能带来的好处，今天我就写一篇关于面向对象的入门文章，希望能帮大家更好的理解和使用面向对象编程。

无论用什么形式来编程，我们都要明确记住以下原则：

1. 1.        写重复代码是非常不好的低级行为
2. 2.        你写的代码需要经常变更

　　开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。

 

　　如果你把一段同样的代码复制、粘贴到了程序的多个地方以实现在程序的各个地方调用这个功能，那日后你再对这个功能进行修改时，就需要把程序里多个地方都改一遍，这种写程序的方式是有问题的，因为如果你不小心漏掉了一个地方没改，那可能会导致整个程序的运行都出问题。因此我们知道在开发中一定要努力避免写重复的代码，否则就相当于给自己再挖坑。

 

　　还好，函数的出现就能帮我们轻松的解决重复代码的问题，对于需要重复调用的功能，只需要把它写成一个函数，然后在程序的各个地方直接调用这个函数名就好了，并且当需要修改这个功能时，只需改函数代码，然后整个程序就都更新了。

 

　　其实OOP编程的主要作用也是使你的代码修改和扩展变的更容易，那么小白要问了，既然函数都能实现这个需求了，还要OOP干毛线用呢？呵呵，说这话就像，古时候，人们打仗杀人都用刀，后来出来了枪，它的主要功能跟刀一样，也是杀人，然后小白就问，既然刀能杀人了，那还要枪干毛线，哈哈，显而易见，因为枪能更好更快更容易的杀人。函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改。

 

       相信大家都打过CS游戏吧，我们就自己开发一个简单版的CS来玩一玩。先从人物角色下手，角色很简单，就俩个，恐怖份子、警察，他们除了角色不同，其它基本都一样，每个人都有生命值、武器等。咱们先用非OOP的方式写出游戏的基本角色

 

#role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
  
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100

 上面定义了一个恐怖份子Alex和一个警察Jack,但只2个人不好玩呀，一干就死了，没意思，那我们再分别一个恐怖分子和警察吧，

#role 1
name = 'Alex'
role = 'terrorist'
weapon = 'AK47'
life_value = 100
money = 10000
  
#rolw 2
name2 = 'Jack'
role2 = 'police'
weapon2 = 'B22'
life_value2 = 100
money2 = 10000
  
#role 3
name3 = 'Rain'
role3 = 'terrorist'
weapon3 = 'C33'
life_value3 = 100
money3 = 10000
  
#rolw 4
name4 = 'Eric'
role4 = 'police'
weapon4 = 'B51'
life_value4 = 100
money4 = 10000

　　

 4个角色虽然创建好了，但是有个问题就是，每创建一个角色，我都要单独命名，name1,name2,name3,name4…，后面的调用的时候这个变量名你还都得记着，要是再让多加几个角色，估计调用时就很容易弄混啦，所以我们想一想，能否所有的角色的变量名都是一样的，但调用的时候又能区分开分别是谁？ 

 

当然可以，我们只需要把上面的变量改成字典的格式就可以啦。

roles = {
    1:{'name':'Alex',
       'role':'terrorist',
       'weapon':'AK47',
       'life_value': 100,
       'money': 15000,
       },
    2:{'name':'Jack',
       'role':'police',
       'weapon':'B22',
       'life_value': 100,
        'money': 15000,
       },
    3:{'name':'Rain',
       'role':'terrorist',
       'weapon':'C33',
       'life_value': 100,
       'money': 15000,
       },
    4:{'name':'Eirc',
       'role':'police',
       'weapon':'B51',
       'life_value': 100,
       'money': 15000,
       },
}
  
print(roles[1]) #Alex
print(roles[2]) #Jack

　　

以后调用这些角色时只需要roles[1],roles[2]就可以啦，角色的基本属性设计完了后，我们接下来为每个角色开发以下几个功能

1. 1.        被打中后就会掉血的功能
2. 2.        开枪功能
3. 3.        换子弹
4. 4.        买枪
5. 5.        跑、走、跳、下蹲等动作
6. 6.        保护人质（仅适用于警察）
7. 7.        不能杀同伴
8. 8.        。。。

我们可以把每个功能写成一个函数，类似如下：

def shot(by_who):
    #开了枪后要减子弹数
    pass
def got_shot(who):
    #中枪后要减血
    who[‘life_value’] -= 10
    pass
def buy_gun(who,gun_name):
    #检查钱够不够,买了枪后要扣钱
    pass

　　

         继续按照这个思路设计，再完善一下代码，游戏的简单版就出来了，但是在往下走之前，我们来看看上面的这种代码写法有没有问题，至少从上面的代码设计中，我看到以下几点缺陷：

       每个角色定义的属性名称是一样的，但这种命名规则是我们自己约定的，从程序上来讲，并没有进行属性合法性检测，也就是说role 1定义的代表武器的属性是weapon, role 2 ,3,4也是一样的，不过如果我在新增一个角色时不小心把weapon 写成了wepon , 这个程序本身是检测不到的

       terrorist 和police这2个角色有些功能是不同的，比如police是不能杀人质的，但是terrorist可能，随着这个游戏开发的更复杂，我们会发现这2个角色后续有更多的不同之处，但现在的这种写法，我们是没办法把这2个角色适用的功能区分开来的，也就是说，每个角色都可以直接调用任意功能，没有任何限制。

       我们在上面定义了got_shot()后要减血，也就是说减血这个动作是应该通过被击中这个事件来引起的,我们调用get_shot()，got_shot（）这个函数再调用每个角色里的life_value变量来减血。但其实我不通过got_shot()，直接调用角色roles[role_id][‘life_value’] 减血也可以呀，但是如果这样调用的话，那可以就是简单粗暴啦，因为减血之前其它还应该判断此角色是否穿了防弹衣等，如果穿了的话，伤害值肯定要减少，got_shot()函数里就做了这样的检测，你这里直接绕过的话，程序就乱了。因此这里应该设计成除了通过got_shot(),其它的方式是没有办法给角色减血的，不过在上面的程序设计里，是没有办法实现的。 

现在需要给所有角色添加一个可以穿防弹衣的功能，那很显然你得在每个角色里放一个属性来存储此角色是否穿了防弹衣，那就要更改每个角色的代码，给添加一个新属性，这样太low了，不符合代码可复用的原则

 

       上面这4点问题如果不解决，以后肯定会引出更大的坑，有同学说了，解决也不复杂呀，直接在每个功能调用时做一下角色判断啥就好了，没错，你要非得这么霸王硬上弓的搞也肯定是可以实现的，那你自己就开发相应的代码来对上面提到的问题进行处理好啦。但这些问题其实能过OOP就可以很简单的解决。 

之前的代码改成用OOP中的“类”来实现的话如下：

class Role(object):
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name = name
        self.role = role
        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')  #生成一个角色

　 先不考虑语法细节，相比靠函数拼凑出来的写法，上面用面向对象中的类来写最直接的改进有以下2点：

l  代码量少了近一半

l  角色和它所具有的功能可以一目了然看出来

 

4、面相对象实例化过程

1、类的语法

class dog(object):   #用class定义类
    "dog class"     #对类的说明
 
    def __init__(self,name):   #构造函数或者是构造方法，也可以叫初始化方法
        self.name = name
    def sayhi(self):    #类方法
        "sayhi funcation"    #对类方法的说明
        print("hello,i am a dog,my name is ",self.name)
 
d = dog("alex")   #定义一个d的对象，叫实例
d.sayhi()    #调用实例的方法

　　

2、self关键字

       这个self是什么鬼？为什么在执行sayhi函数时，上面的self.name可以在函数中被调用？如下图：

 

 

 其实self 这个关键字相当于实例化对象本身(self相当于d)，在实例化过程中，把自己传进去了，我们队上面的两行做一下解释：

 

3 函数__init__()

　　在类中__init__()函数叫构造函数，又叫构造方法，也可以叫初始化函数。它的作用就是初始化实例时，初始化传入实例的的默认值。如果不写__init__(),就会调用的默认为空的__init__(),说白了，这个方法不管你写不写，都会调用，而且，一旦实例化就会调用。

 

class dog(object):
  "dog class"
  def __init__(self,name):  #构造方法，不写调用默认的构造方法
    self.name = name 
   def eat(self,food):
    print("hello,i am a dog , my name is %s " % self.name)

d = dog("alex")
d.eat("hotdog")

#输出
hello,i am a dog , my name is alex

　　

       其实self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去。

 

4、成员变量和参数

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name   #类的成员变量
                
    def sayhi(self):
        print("the dog {0} is sayhi".format(self.name))
 
    def eat(self,food):   #传入一个参数,参数名：food
        print("the dog name is {0},it like food is {1}".format(self.name,food))
 
d = dog("alex") #实例化对象
d.sayhi()   #调sayhi方法
d.eat("hotdog")  #调eat方法
 
#输出
the dog alex is sayhi
the dog name is alex,it like food is hotdog

　　

①很多人产生疑问，为什么eat方法里面会传入一个food的参数名呢？而这个为什么不能再其他方法里面用呢？而self.name就可以呢？

因为food它只是作为eat方法的一个参数，不是类的成员变量，只能在自己的方法里面使用，而self.name是类的成员变量，它是类的属性，所以可以被调用。

②为什么类的每一个方法第一个参数都是self呢？

是因为类在实例化的时候，需要把实例对象本身传进来，好去调用对象本身的属性和方法。

5 修改对象的属性

class dog(object):
    "dog class"
 
    def __init__(self,name,age):
        self.name = name  
        self.age = age
 
    def sayhi(self,update_age):  #传入一个update_age参数
        self.age = update_age   #修改对象的age属性
 
d = dog("alex",18)
d.sayhi(22)  #第1次在类的方法中修改
print(d.age)  
d.age = 19   #第2次在类外面修改
print(d.age)
 
#输出
22
19

　　

 

注：就是说在类的方法中或者类的外面都可以修改类的属性

4、定义私有属性

       说明：之前我们说，我们可以访问类的属性，也可以随意修改类的属性，但是类属性一旦被定义成私有的，对外是不可以被访问的，也是不可以随意被改变的。

4.1 定义私有属性

class dog(object):
    "dog class"

    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.__sex = "man"  #定义私有属性__sex

    def sayhi(self,update_age):
        self.age = update_age
 
d = dog("alex",18)
print(d.__sex) #访问私有属性__sex

　　

输出

Traceback (most recent call last):

  File "D:/PythonStudy3.5/untitled/test/day6/ddd123.py", line 14, in <module>

    print(d.__sex) #访问私有属性__sex

AttributeError: 'dog' object has no attribute '__sex'

 

       私有属性是不可以访问的，更不可以修改。

4.2 get方法访问私有属性

       虽然我们外部不能访问私有属性，但是我们在类内部可以访问私有属性，所以我们用如下方法，访问私有属性

 

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name
        self.__sex = "man"  #定义私有属性sex
 
    def get_sex(self):  #定义get方法
        return self.__sex   #返回私有属性sex值
 
d = dog("alex")
d_sex = d.get_sex()  #调用实例对象d的get_sex()方法获取私有属性sex
print(d_sex)
 
#输出
man

　

 

注：这种方法只能访问私有属性，但是不能更改私有属性

4.3 强制访问私有属性

上面的方法只能访问，但是不能修改，下面这种方法就更为暴力，可以访问也可以修改，就是：对象名._类名__属性名

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name
        self.__sex = "man"  #定义私有方法sex
 
d = dog("alex")
print(d._dog__sex)  #访问私有属性sex
d._dog__sex = "woman"  #修改私有属性sex
print(d._dog__sex) #打印修改后的值
#输出
man
woman

　　

4.4、总结

       定义私有属性：self.__private_attr_name = private_attr_name

强制访问私有属性：对象名._类名__属性名(d._dog__sex)

对外提供只读接口访问：

def get_sex(self):

　　return self.__sex

 

5、类的公有属性

       有人觉得，在__init__()构造方法中，除了私有属性，其他的都是公有属性了，其实这是一个错误的结论，并不是定义在__init__()初始化方法中的属性是公有属性(除私有属性)，那什么是公有属性呢？

 

定义：指的是所属这个类的所有对象，都可以访问的属性，叫做公有属性。

 

5.1、公有属性

说明：在类中直接定义的，可以提供这个类所属的所有对象都可以访问的属class dog(object):

class dog(object):
    "dog class"
    nationality = "JP"   #定义公有属性nationality
    def __init__(self,name):
        self.name = name

d1 = dog("alex")
d2 = dog("sanjiang")
print(d1.nationality,d2.nationality)  #所有的成员变量都可以访问

输出 ('JP', 'JP')

　　

这边有个小疑问，d1.name,d2.name也可以访问，也可以修改，为什么不能叫公有属性呢？代码如下

class dog(object):
    "dog class"
 
    nationality = "JP"
 
    def __init__(self,name):
        self.name = name
 
d1 = dog("alex")
d2 = dog("sanjiang")
print(d1.name,d2.name)
 
#输出
alex sanjiang

　　

很明显，上面的name是每个对象的属性，并不是共享，而是独立的。

5.2 类访问公有属性

说明：公有属性不仅可以通过所属类的所有对象访问，还可以通过类本身直接访问和修改

class dog(object):
    "dog class"
 
    nationality = "JP"  #定义公有属性
 
    def __init__(self,name):
        self.name = name
 
d1 = dog("alex")
d2 = dog("sanjiang")
print(dog.nationality)  #访问公有属性
dog.nationality = "US"  #修改公有属性
print(dog.nationality)
 
#输出
JP
US

　

5.3 公有属性特性

说明：公有属性不是私有属性，它提供所有对象访问和修改，那我们其中有一个对象正在修改公共属性发生什么变化呢？或者类本身直接修改了公共属性，又放生什么变化呢？

class dog(object):
    "dog class"
 
    nationality = "JP"
 
    def __init__(self,name):
        self.name = name
 
d1 = dog("alex")
d2 = dog("sanjiang")
print("firsthand change...")
print(d1.nationality,d2.nationality)
print("brfore change ...")
d1.nationality = "CN"    #对象的d1修改公共属性得值
print(d1.nationality,d2.nationality)
print("after change ....")
dog.nationality = "US"    #dog类本省修改公共属性的值
print(d1.nationality,d2.nationality)
 
#输出
firsthand change...
JP JP
brfore change ...
CN JP          #d1对象的公共属性被修改了
after change ....
CN US    #d1对象的公共属性值没有随着类本身的公共属性值修改而修改

　　

l  对象d1去访问nationality属性时，如果在成员属性中找不到，就会找公共属性，也就是说自己的属性找不到就去找父亲的属性

l  d1.nationality="CN" 相当于在自己对象内部又重新创建了一个新的局部变量，这个局部变量已经脱离了class本身，跟这个类已经没有半毛钱关系了，只是名字一样而已，如果不改，还是找全局的。

 

5.4 公有属性和方法的疑惑

　　从上面我们可以看出公有属性只有一个，而且是在没有定义对象的时候，就已经存在，那么类中的方法是不是每调用一次，就会生成一个？答案是肯定不会的。

　　就是说，你去实例化然后调用sayhi方法，只是拿着这块内存中的数据去调公有的sayhi方法而已，并不是有多个。

 

6、析构函数

析构函数定义：在实例销毁的时候调用的函数

class dog(object):
    "dog class"
 
    def __init__(self,name):
        self.name = name
 
    def sayhi(self):
        print("the dog {0} is sayhi".format(self.name))
 
    def __del__(self):     #定义析构函数
        print("del.....run...")
 
d = dog("alex")
del d
import time
time.sleep(5)
 
#输出
del.....run...

　　

 

①析构函数说明时候调用呢？

其实每一个对象都是一个应用，就像每一个房间都有门牌号一样， 只要这个对象的引用被清空时，就会自动执行，就像上面的del d,其实python中有自动垃圾回收机制，会定时去的去回收一些被清空的应用，而析构函数就是在引用被清空之后会自动执行

②析构函数的作用？

比如说server端接受很多客户端的连接，当你手动屏蔽你的sever端的时候，这个时候客户端还在正常的连接，如果sever端用类写的，你就可以delete server端的同时，在__del__()写一些东西，说去close掉很多客户端的连接。说白了，析构函数就是做一些程序的收尾工作。

 

转载于:https://www.cnblogs.com/meihan/p/7493703.html