面向对象

定义类

# 定义类->自定义类(由程序员创建的类)
# python创建的list类
# class list(object):

# 开发 王者荣耀 ，我想创建一个悟空(对象)->类(英雄类)->类型(Hero)

# 自定义类
# class 标识这一个类

# 三种类的的创建方式都是在python2.x产生的
# object 是所有类的父类
# 02 是后期产生的
# 01 02 叫经典类，它们都是没有父类(基类)的
# 03 叫新式类

# 在python3.x中 无论写01 02 03哪种方式，都是继承object类
# 但是在python2.x中它是区分01 02 相同，而03是有父类的

# 01
class Hero:
    pass
# 02
class Hero():
    pass
# 03
class Hero(object):
    pass

创建对象

# 自定义一个悟空英雄对象
# 自定义一个英雄类
# 自定义类名 一般遵循的是大驼峰
class  Hero(object):
    # 定义一个方法(实例方法、或者对象方法)
    # 实例方法的第一个参数self
    # 实例方法 下划线或者小驼峰(公司要求)
    def move(self):
        print("英雄会走")

# 使用自定义类创建一个对象
wukong = Hero()
# 调用英雄类中的方法(想要使用其类中的方法，要使用这个类创建一个对象，使用对象调用其类里面的方法)
wukong.move()

添加和获取对象属性

# 自定义一个悟空对象
# 他会走(方法和行为，他有名字:悟空，年龄500,血量3000，攻击力400(属性和特征))

# 自定义一个英雄类
class Hero(object):
    # 方法(实例 或者 对象)
    def move(self):
        # self是谁，哪个对象调了这个方法，self就是那个对象
        print(id(self))
        print("英雄会走")

# 无论使用对象调用其类的方法或是属性，都是使用“点”语法
# 使用类创建对象
wukong = Hero()
# 执行下对象方法
wukong.move()
# 给对象添加属性
# 名字
wukong.name= "悟空"
# 年龄
wukong.age = 500
# 血量
wukong.hp = 3000
# 攻击力
wukong.atk = 400

# 获取对象身上的属性
print(wukong.name, wukong.age, wukong.hp, wukong.atk)


# 什么时候才可以给对象添加属性？
# 先要有对象才可以给这个对象添加属性

# 如何查看一个类创建的多个对象，是否是一个对象呢？
# print(wukong)
#  <__main__.Hero object at 0x00000252E13A0780>  ->16进制
# 保存到内侧中，需要开辟内存空间(底层是二进制(0,1))
# 创建 猪八戒
# zhubajie = Hero()
# print(zhubajie)
# 如果想查看10进制
print(id(wukong))
# print(id(zhubajie))

# 在类的外面使用的是对象名
# 在类的方法里面使用的是self
# 对象名 和self 本身就是一个人


# 了解  逢x进1
# 二进制 0 1
# 十进制 0 1 2 ... 9
# 16进制 0 1 2 ... ABCDEF

在方法类通过self获取获取属性

#自定义一个狗类，来创建各种名字叫旺财的狗，年龄5 皮色 黑色，会吃骨头
# 自定义一个类
class Dog(object):
    # 方法
    def eat(self):
        print("狗吃骨头")
    # 自定义一个方法，完成打印对象属性
    def info(self):
        print(self.name, self.age, self.color)

# 自定义一个旺财对象
wangcai = Dog()
wangcai.eat()
# 给对象添加属性
wangcai.name = "旺财"
wangcai.age = 5
wangcai.color = "黑色"

# 获取对象属性
# print(wangcai.name, wangcai.age, wangcai.color)
# 使用对象名调用类中的对象方法
wangcai.info()

# 在类的外面使用，使用的是对象名.属性名
# 在类的实例方法内部，使用的是self.属性名(self == 调用这个方法的对象)

__init__方法

# 自定义一个狗类
class Dog(object):

    # 构造方法
    # 在python中使用_开头，并以_结尾的称之为魔法方法
    # 魔法方法是python提供给我们的
    # object的提供的魔法方法
    # 在特殊的情况下(python可以监听到你使用自己的类创建一个对象)，被python执行
    # 在自定义类(程序员自己写的类)中实现(重写)魔法方法，做自己特有的事情
    # 注意：当走进_init_方法的时候，对象已经创建成功
    def __init__(self):
        print("_init_")
        # 给对象的属性赋值
        self.name = "旺财"
        self.age = 5
        self.color = "灰色"

    # 会吃骨头
    def eat(self):
        print("会吃骨头")
    # 定义一个方法
    def info(self):
        print("名字:%s"% self.name)
        print("年龄:%s" % self.age)
        print("毛色:%s" % self.color)
        print("="*30)

# 通过自定义的类创建狗 -> 对象
# 特征，叫的名字都是旺财，年龄都是5岁，毛色都是灰色
wangcai1 = Dog()
# input("到了吗")
# 添加属性
# wangcai1.name = "旺财"
# wangcai1.age = 5
# wangcai1.color = "灰色"
# 调用对象方法
wangcai1.info()

wangcai2 = Dog()
# 添加属性
# wangcai2.name = "旺财"
# wangcai2.age = 5
# wangcai2.color = "灰色"
# # 调用对象方法
wangcai2.info()

wangcai3 = Dog()
# 添加属性
# wangcai3.name = "旺财"
# wangcai3.age = 5
# wangcai3.color = "灰色"
# 调用对象方法
wangcai3.info()

有参数的__init__方法

# 自定义一个狗类
class Dog(object):

    # 构造方法
    def __init__(self, new_name, new_age, new_color="白色"):
        # 给对象的属性赋值
        self.name = new_name
        self.age = new_age
        self.color = new_color

    # 会吃骨头
    def eat(self):
        print("会吃骨头")
    # 定义一个方法
    def info(self):
        print("名字:%s"% self.name)
        print("年龄:%s" % self.age)
        print("毛色:%s" % self.color)
        print("="*30)

# 创建旺财
wangcai = Dog("旺财", 5)
wangcai.info()
# 创建斗牛犬
douniu = Dog("斗牛犬", 4)
douniu.info()

__str__()方法

# 自定义一个英雄类
class Hero(object):

    # 构造方法
    def __init__(self, name, hp, atk):
        # 设置属性的值
        self.name = name
        self.hp = hp
        self.atk = atk

    # 打印信息
    # def info(self):
    #     print(self.name, self.hp, self.atk)

    # 实现下父类已有的魔法方法
    # 不可以添加参数(形参)
    # 会返回一个字符串
    # 追踪对象属性信息变化
    def __str__(self):
        return "名字:%s 血量:%d 攻击力:%d" % (self.name, self.hp, self.atk)

# 悟空
wukong = Hero("悟空", 4000, 400)
# wukong.info()
# 默认情况下 打印的是对象的16进制地址
# 如果类中实现了__str__方法 如果打印对象名 会输出的是__str__方法中的返回值(字符串)
print(wukong)

# __str__一般用于程序员开发调试代码

__del__()方法

# 自定义一个英雄类
class Hero(object):

    # 构造方法
    def __init__(self, name):
        # 设置属性值
        self.name = name

    # 输出一个字符串(追踪对象属性信息变化)
    def __str__(self):
        return "名字:%s" % self.name
    # 监听对象销毁会走的方法
    def __del__(self):
        print("再见")

# 创一个对象
# gailun = Hero("盖伦")
# 程序员杀死对象
# del gailun

# input("停在这里")

# python中是自动内存管理

# 创一个对象
gailun = Hero("盖伦")
gailun1 = gailun
gailun2 = gailun
# 引用计数问题
del gailun
del gailun1
del gailun2

input("停在这里")

# python中是自动内存管理

单继承

# 自定义一个师傅类
class Master(object):

    # 构造方法
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    # 擅长做煎饼果子
    def make_cake(self):
        print("按照<%s>制造煎饼果子" % self.kongfu)

# 创建一个李师傅 对象
lishifu = Master()
print(lishifu.kongfu)
lishifu.make_cake()

# 自定义一个徒弟类
# 子类继承了父类，就拥有了父类的"方法"和"属性"
# 子类拥有了父类的属性，是因为子类使用了父类的__init__(对属性赋值的地方)
class Prentice(Master):
    pass

# 自定义一个大猫
damao = Master()
print(damao.kongfu)
damao.make_cake()

多继承

# 自定义一个师傅类-(古法)
class Master(object):

    # 构造方法
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    # 擅长做煎饼果子
    def make_cake(self):
        print("按照<%s>制造煎饼果子" % self.kongfu)

    # 大烟袋
    def dayandai(self):
        print("大烟袋")

# 自定义一个新东方-(现代)
class School(object):

    # 构造方法
    def __init__(self):
        self.kongfu = "现代古法煎饼果子配方"

    # 擅长做煎饼果子
    def make_cake(self):
        print("按照<%s>制造煎饼果子" % self.kongfu)

    # 小烟袋
    def xiaoyandai(self):
        print("小烟袋")

# 自定义一个徒弟类
# (School, Master)哪个类在这最前面就执行该类的方法
class Prentice(Master, School):
    pass

# 自定义一个大猫
damao = Prentice()
# 为什么会打印的第一个父类的属性->古法煎饼果子配方？
# 如果两个父类的方法名(__init__)相同
print(damao.kongfu)
# 如果两个父类的方法名相同，子类会执行第一个父类
damao.make_cake()
# 如果两个父类的方法名相同。子类会分别执行
damao.dayandai()
damao.xiaoyandai()

子类重写父类的同名属性和方法

# 自定义一个师傅类-(古法)
class Master(object):

    # 构造方法
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    # 擅长做煎饼果子
    def make_cake(self):
        print("按照<%s>制造煎饼果子" % self.kongfu)


# 自定义一个新东方-(现代)
class School(object):

    # 构造方法
    def __init__(self):
        self.kongfu = "现代古法煎饼果子配方"

    # 擅长做煎饼果子
    def make_cake(self):
        print("按照<%s>制造煎饼果子" % self.kongfu)


# 自定义一个徒弟类
# (School, Master)哪个类在这最前面就执行该类的方法
class Prentice(Master, School):
    # pass
    # 构造函数
    def __init__(self):
        self.kongfu = "猫式煎饼果子配方"

     # 擅长做煎饼果子
    # 子类继承了父类，子类重写父类已有的方法
    # 重写：子类继承父类，做自己特有的事情
    def make_cake(self):
        print("按照<%s>制作煎饼果子" % self.kongfu)

# 自定义对象  大猫
# 如果子类的方法名(子类已经重写父类的方法)和父类相同的时候，默认会使用子类的方法
# 为什么会使用子类的属性(kongfu)，子类重写了父类已有的__init__方法
damao = Prentice()
damao.make_cake()

子类调用父类的同名属性和方法

# 自定义师傅类-古法
class Master(object):
    # 方法
    def make_cake(self):
        print("古法煎饼果子")

# 自定义师傅类-现代
class School(object):
    # 方法
    def make_cake(self):
        print("现代煎饼果子")

# 自定义一个徒弟类
class Prentice(Master, School):
    # 方法
    def make_cake(self):
        print("猫式煎饼果子")
    # 古法
    def old_cake(self):
        # 如果子类重写了父类已有的方法
        # 但是子类还想用父类的同名方法
        # 解决方案:父类名.对象方法名(self)
        Master.make_cake(self)
    # 现代
    def new_cake(self):
        # 同上
        School.make_cake(self)

# 自定义一个对象 大猫
damao = Prentice()
# 猫式
damao.make_cake()
# 古法
damao.old_cake()
# 现代
damao.new_cake()

super()的使用

# 自定义师傅类-古法
class Master(object):
    # 方法
    def make_cake(self):
        print("古法煎饼果子")

# 自定义师傅类-现代
class School(object):
    # 方法
    def make_cake(self):
        print("现代煎饼果子")

# 自定义一个徒弟类
class Prentice(Master, School):
    # 方法
    def make_cake(self):
        print("猫式煎饼果子")
        Master.make_cake(self)
        School.make_cake(self)
    # 古法
    def old_cake(self):

        # 01方式(单和多继承都适用)
        # Master.make_cake(self)

        # super默认会调用第一个父类的方法(适用于单继承或只想使用第一个父类的方法)

        # 02方式 ,适用于新式类
        # 格式：super(子类类名,self).父类方法名()
        # super(Prentice, self).make_cake()

        # 03方式(适用于新式类),是02方式的简写
        super().make_cake()
    # 现代
    def new_cake(self):
        # School.make_cake(self)
        super().make_cake()


# 自定义一个对象 大猫
damao = Prentice()
# 猫式
damao.make_cake()
# 古法
# damao.old_cake()
# 现代
# damao.new_cake()

私有属性和私有方法

# 自定义一个师傅类
class Master(object):

    # 构造方法
    def __init__(self):
        # 配方
        self.kongfu = "古法配方"
        # 添加一个属性
        # 如果一个属性的名字开头是两个下划线，就代表这个属性私有
        self.__money = 10000

    # 制造煎饼果子
    def make_cake(self):
        print("古法煎饼果子赚了%d元" % self.__money)
        # 在类的里面是可以使用的
        # print(self.__money)
        # self.__hellop__ython()

    # 私有的实例方法
    # 私有的作用：高大尚
    def __hellop__ython(self):
        print("我爱python")

# 自定义一个对象
lishifu = Master()
print(lishifu.kongfu)
# 如果一个属性私有后，就不能使用对象调用这个属性(类的外面使用)
# print(lishifu.__money)
lishifu.make_cake()
# lishifu.__hellop__ython()


# 自定义一个师傅类
class Master(object):

    # 构造方法
    def __init__(self):
        # 配方
        self.kongfu = "古法配方"
        # 添加一个属性
        # 如果一个属性的名字开头是两个下划线，就代表这个属性私有
        self.__money = 10000

    # 制造煎饼果子
    def make_cake(self):
        print("古法煎饼果子")

    # 私有的实例方法
    # 私有的作用：高大尚
    def __hellop__ython(self):
        print("我爱python")

# 自定义一个类 ，继承师傅类
class Prentice(Master):
    pass

damao = Prentice()
print(damao.kongfu)
damao.make_cake()
# 子类继承了父类，如果父类额属性或者方法私有后，将不会被继承

修改私有属性值

# 自定义一个人类
class Person(object):

    def __init__(self):

        self.name = "小明"
        self.age = 20

    # 定义一个方法(获取属性的值，一般方法名使用get)
    def get_age(self):
        return self.__age

    # 定义一个方法(对属性赋值的时候，一般方法名中使用set)
    def set_age(self, new_age):
        self.__age = new_age

# 间接的修改私有属性的值，和获取私有属性的值
# 对象
xiaoming = Person()
# print(xiaoming.name)

# 01 使用对象调用私有属性，完成打印age的值
print(xiaoming.get_age())
# 02 使用对象设置私有属性的值
xiaoming.set_age(30)

# 测试
print(xiaoming.get_age())

类属性和实例属性

# 自定义一个类
class Person(object):
    # 国家
    country = "中国"

    def __init__(self, name, age):
        # 实例属性(对象属性)
        self.name = name
        self.age = age


# xiaoming = Person("小明", 20)
#
# 使用实例属性: 对象名.实例属性名
# print(xiaoming.name)

# 修改实例属性: 对象名.实例属性名 = 值
# xiaoming.name = "小明明"
# print(xiaoming.name)

# 使用类属性
# 01: 类名.类属性名
# print(Person.country)
# 02: 对象名.类属性名
# xiaoming = Person("小明", 20)
# print(xiaoming.country)


# 修改类属性
# 01: 类名.类属性名 = 值
# Person.country = "中华"
# print(Person.country)

# 02: 不存在(对象名.类属性名 = 值)
# xiaoming = Person("小明", 20)
# # python认为你是给对象设置实例属性(只是和类属性名相同而已)
# xiaoming.country = "中华"
# print(xiaoming.country)
# print(Person.country)


# 关于类属性 内存问题
# xiaoming1 = Person("小明1", 20)
# xiaoming2 = Person("小明2", 20)
# 类属性python只会开辟一份内存(他是代表这个类的属性这个类python中只有一个)
# print(id(xiaoming1.country))
# print(id(xiaoming2.country))
# print(id(Person.country))


# 类属性好处???
# 为了节约内存
# 为了后期业务需求更改 可以提高开发效率
# 自定义一个类
class Person(object):
    # 国家
    # country = "中国"
    def __init__(self, name, age, country):
        # 实例属性(对象属性)
        self.name = name
        self.age = age
        self.country = country

类方法

# 自定义一个类
class Person(object):

    # 类属性(私有)
    __country = "中国"


    # 定义类方法
    # 获取私有类属性的值
    # cls = 类名
    # 修饰器
    @classmethod
    def get_country(cls):
        return cls.__country

    # 修改私有类属性的值
    @classmethod
    def set_county(cls, new_county):
        cls.__country = new_county

# 01：类名.类方法(调用类方法)
# print(Person.get_country())

# Person.set_county("中华")
# print(Person.get_country())

# 02：对象名.类方法(调用方法)
xiaoming = Person()
# 调用类方法
print(xiaoming.get_country())
xiaoming.set_county("中华")
print(xiaoming.get_country())

静态方法

# 值自定义类
class Person(object):

    # 私有类的属性(国籍)
    __country = "中国"

    # 构造方法
    def __init__(self):

        self.name = "小明"
        # 私有
        self.__age = 20

    # 实例方法(对象方法)获取私有属性
    def get_age(self):
        return self.__age

    # 实例方法(对象方法)修改私有属性
    def set_age(self, new_age):
        self.__age = new_age

    #类方法
    @classmethod
    def get_country(cls):
        return cls.__country

    # 类方法
    # 修改类方法
    @classmethod
    def set_country(cls, new_country):
        cls.get_country = new_country

    # 静态方法
    @staticmethod
    def hello():
        print("今天天气不错")

# 使用静态方法
# 01：类名.静态方法名
# Person.hello()

'''
python中类中的方法总结：

- 实例方法(对象方法) -> 场景最多
    - 定义格式：def 实例方法名(self):
    - 调用格式：对象名.实例方法名()
    - 使用场景：在方法中需要self
    
- 类方法 -> 对私有属性取值或者赋值
    - 定义格式：@classmethod
                def 类方法名(cls):
    - 调用格式：类名.类方法名() 或者 对象名.类方法名()
    - 使用场景：在方法中需要cls(类名)
    
- 静态方法 -> 一般不用
    -定义格式：@staticmethod
                def 静态方法名():
    - 调用格式：类名.类方法名() 或者 对象名.类方法名()
    - 使用场景：在方法中不需要self，也不需要cls  
'''

__new__()方法

# 自定义一个人类
class Person(object):

    # 监听python使用其类创建对象,并返回对象 -> __init__
    def __new__(cls, *args, **kwargs):
        print("__new__")
        # return object.__new__(cls)

    # 构造方法(监听python使用其类创建对象完成，给这个对象设置属性)
    def __init__(self):
        print("__init__")
        self.name = "小明"

    # 监听对象属性信息变化
    def __str__(self):
        return "名字:%s" % self.name

    # 监听对象销毁
    def __del__(self):
        print("再见")

# 创建一个对象
xiaoming = Person()
print(xiaoming)

# None 空值类型
# <class 'NoneType'>
print(type(None))

单例模式

# 单例模式 在程序中这个类创建出来的对象 只有一个(也就是占用一份内存地址)
# 单例模式 也只会走一次__init__方法(保证这个单例对象的属性也是唯一的)(name=小明 age=20)
# 合理的使用内存(避免内存浪费)
class Person(object):

    # 定义一个类属性  保存这个类创建的对象
    __instance = None
    # 定义一个类属性 判断是否是第一次走init方法
    __is_first = True
    # 创建对象
    # 重写new方法 是为了完成单例模式中的对象地址唯一
    def __new__(cls, *args, **kwargs):
        # 判断是否通过这个类创建过对象
        # 如果没有值需要创建
        if not cls.__instance:
            # 创建对象保存起来
            cls.__instance = object.__new__(cls)

        # 如果有值直接返回
        return cls.__instance

    def __init__(self, name, age):
        # 判断是否是第一次
        if Person.__is_first:
            # 赋值一次
            self.name = name
            self.age = age
            # 设置类属性is_first 为False
            Person.__is_first = False

    # def make(self):
    #
    #     hm = HMTest()
    #     hm.my_func(20, 30)


# 创建对象
xiaoming = Person("小明", 20)
print(xiaoming.name)
xiaohong = Person("小红", 21)
print(xiaohong.name)
xiaoyang = Person("小阳", 22)
print(xiaoyang.name)
#
print(xiaoming.name, xiaohong.name, xiaoyang.name)


# num = None
# # 如果不为none 也就是真
# if not num:
#     print("测试")


# 单例的好处?
class HMTest(object):
    def my_func(self, a, b):
        return a + b


# 在程序中 需要计算多次求和操作 比如1000次 可以省掉999分内存
# 每次使用
# 实例化一个对象
# hm = HMTest()
# hm.my_func(10, 20)

# 为了节约内存