zoukankan      html  css  js  c++  java
  • Python3 面向对象编程

    小案例:

    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    # Author:Bert
    import sys
    
    class Role(object):
    
        n="Role_n"  #这是类变量
        list= []
        def __init__(self,name,role, weapon, life_value=100, money=15000):
            """
            构造函数;在实例化时做一些类的初始化的工作
            self 相当于传role 对象
            """
            self.name=name #role1.name=name实例变量(静态属性),作用域就是实例本身
            self.role=role
            self.weapon=weapon
            self.__life_value=life_value  #在变量前面加 __ 变成私有属性,只有class里面才可以访问
            self.money=money
    
        def show_life_value(self):
            print("通过class内部方法调用私有属性:%s的血量%s" %(self.name,self.__life_value))
    
        def __private(self):
            print("私有方法只有class内部的方法可以调用,必须用self")
    
        def shot(self):
            """ 类的方法 (动态属性) """
            sys.stdout.write("%s通过class内shot方法调用私有方法__private:")
            self.__private()
    
        def buy_gun(self, gun_name):
            print("%s购买%s" % (self.name, gun_name))
    
        def __del__(self):
            """在实例释放、销毁的时候自动执行的,通常用于做一些收尾工作, 如关闭一些数据库连接,关闭打开的临时文件"""
            print("析构函数,%s自动销毁"%(self.name))
    
    role1 = Role("Jack","98K","terrorist")
    role1.buy_gun("M416自动步枪")
    role1.n = "Jack_n"  #相当于给role1 这个实例 新增一个实例变量n
    role1.list.append("Jack_list") #实例对象修改类里面的字典、列表等复杂的数据类型,其实就是修改类里面的
    del role1.weapon   #删除实例属性 用 del
    role1.show_life_value()# 通过调用class的方法调用私有属性
    role1.shot() #通过内部方法调用私有方法
    print(role1.n,",",role1.list)
    
    role2 = Role("Jone","AK47","police")
    role2.n = "Jone_n"
    role2.list.append("Jone_list")
    print(role2.n,",",role2.list)
    print(Role.n,",",Role.list)

    运行结果:

    Jack购买M416自动步枪
    通过class内部方法调用私有属性:Jack的血量100
    %s通过class内shot方法调用私有方法__private:私有方法只有class内部的方法可以调用,必须用self
    Jack_n , ['Jack_list']
    Jone_n , ['Jack_list', 'Jone_list']
    Role_n , ['Jack_list', 'Jone_list']
    析构函数,Jack自动销毁
    析构函数,Jone自动销毁
    

     面向对象的三大特性之一继承

    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    # Author:Bert
    
    #class Person: #经典类
    class Person(object): #新式类
        """  新式类与经典类 主要体现在多继承的顺序方面  Python3 广度优先  Python2 经典类 深度优先,新式类 广度优先"""
        """ 定义一个父类 """
        def __init__(self,name,age):
            self.name=name
            self.age=age
            self.friends=[]
    
        def eat(self):
            print("%s 正在吃饭......"%(self.name))
        def talk(self):
            print("%s正在说话....."%(self.name))
    
    class Relation(object):
        def makfriends(self,obj):
            print("%s和%s在交朋友...."%(self.name,obj.name))
            self.friends.append(obj)
    
    class Man(Person,Relation):
        """子类继承父类Person
        多继承,中间用逗号隔开
        """
        def __init__(self,name,age,job):
            """ 父类构造方法的重构 """
            super(Man, self).__init__(name, age)
            """ 利用super()重构可以提高代码可修改行  另一种写法 Person.__init__(self,name,age) """
            self.job=job
    
        def play_game(self):
            """ Man 的方法"""
            print("%s 正在玩游戏......"%(self.name))
    
        def talk(self):
            """ 子类重写父类的方法 """
            print("%s已经重写了父类的talk方法"%(self.name))
    
    class Woman(Person):
        """子类继承父类Person"""
    
        def huazhuang(self):
            """ Woman 的方法"""
            print("%s 正在化妆......"%(self.name))
    
        def talk(self):
            """ 重写父类方法,但保留父类方法的内容,添加新功能 """
            super(Woman, self).talk()
            """另一种 Person.talk(self)"""
            print("%s给父类talk方法添加了新功能...."%self.name)
    
    man = Man("Jack",25,"Python") #实例化一个Man
    woman = Woman("Like",24) ##实例化一个Woman
    
    man.eat() #man 调用父类方法
    man.play_game() #man 调用自己独有的方法
    man.talk()  #man 调用改写后的父类方法
    man.makfriends(woman)
    print("man的朋友:",man.friends[0])
    
    woman.eat() #woman 调用父类方法
    woman.huazhuang() #woman 调用自己独有的方法
    woman.talk()  #woman 调用改写后的父类方法
    

      运行结果:

    Jack 正在吃饭......
    Jack 正在玩游戏......
    Jack已经重写了父类的talk方法
    Jack和Like在交朋友....
    man的朋友: <__main__.Woman object at 0x0000029232431780>
    Like 正在吃饭......
    Like 正在化妆......
    Like正在说话.....
    Like给父类talk方法添加了新功能....
    

    深度优先与广度优先的图解

      广度优先的顺序为:A-B-C-D-E-F-G-H-I

      深度优先的顺序为:A-B-D-E-I-C-F-G-H

    面向对象的三大特性之一多态

    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    # Author:CarsonLi
    
    class Animal(object):
        def __init__(self,name):
            self.name = name
    
        def talk(self):
            print("..................")
    
        @staticmethod
        def animal_talk(obj):
            obj.talk()
    
    class Dog(Animal):
        def talk(self):
            print("%s正在叫:汪汪汪..." % (self.name))
    
    class Cat(Animal):
        def talk(self):
            print("%s正在叫:喵喵喵..." % (self.name))
    
    dog = Dog("金毛")
    cat = Cat("波斯猫")
    
    """ 一个接口的多种实现 """
    Animal.animal_talk(dog)
    Animal.animal_talk(cat)
    

      运行结果:

    金毛正在叫:汪汪汪...
    波斯猫正在叫:喵喵喵...
    

      

  • 相关阅读:
    android工程混淆和反编译
    php+列出目录文件
    php+大文件管理
    支持粘贴图片的富文本编辑器
    web上传整个文件夹
    文件夹管理
    断点续传
    超大文件上传方案
    ueditor+word粘贴上传
    java+大文件上传
  • 原文地址:https://www.cnblogs.com/bert227/p/9347405.html
Copyright © 2011-2022 走看看