百木园-与人分享,
就是让自己快乐。

python面向对象编程

Python面向对象编程


​ 学了这么久的python面向对象编程. 现在做一个系统的总结吧. 本文将按照我学习的顺序进行模块知识点式总结. 文章篇幅较长. 可以通过标签导航栏进行跳转查阅. 后期还会补充一个案例 -> 学生选课系统 . 那么直接上代码了

1.类与对象.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/3 12:00
# @author: Maxs_hu
\"\"\"
面向对象编程:
    优点: 可拓展性高
    缺点: 编程难度提高
\"\"\"


# 创建一个类:
class StudentSchool:
    school = \'oldboy\'

    def choose_subject(self):
        print(\"please choose school\")


# 类体代码会在类定义阶段就立刻执行,会产生一个类的名称空间
# print(StudnetSchool.__dict__)
print(StudentSchool.__dict__[\'choose_subject\'](123))  # 通过名称空间去调用函数
StudentSchool.country = \'china\'  # 添加对象
# print(StudnetSchool.choose_subject(123))  # 直接调用

# 1. 类本质就是一个名称空间. 可以在此名称空间中进行增删改查. python定义调用的都是类的属性
school = StudentSchool.school  # 查
StudentSchool.school = \'池州学院\'  # 改
StudentSchool.avg = 475  # 增
del StudentSchool.avg  # 删


# 2. 后调用类产生对象. 调用类的过程称之为实例化.
# 类就像一个巨大的工厂. 可以产生不同的产品. 这里称之为一个一个的对象/实例
stu1 = StudentSchool()  # 实例化对象. 返回一个具体存在的对象实例/对象
stu2 = StudentSchool()  # 实例化对象. 返回一个具体存在的对象实例/对象

2.属性查找.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/6 9:31
# @author: Maxs_hu


class StudentCourse:
    # 数据属性
    school = \'oldBoy\'
    count = 0

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        StudentCourse.count += 1  # 想类的数据属性发生改变. 不可加上self. 要从类处开始调用. 原因在本文最后有介绍
        print(self.count)

    # 函数属性
    def choose_course(self):
        print(\'is choose course!\')


stu1 = StudentCourse(\'maxs_hu\', 10, \'m\')
print(stu1.count)
stu2 = StudentCourse(\'Mokeke\', 30, \'w\')
print(stu2.count)
# 实现了每次实例化进行计数功能

# 类属性不会被实例属性左右. 也可以说成类属性与实例属性无关.
# 那么self.count += 1实质就是self有创建了一个新的数据属性. 且创建的新的数据属性和旧的数据属性同名.
# 所以self.count只是访问到了新的数据属性的值. 原来的数据属性没有发生变化

3.绑定方法.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:08
# @author: Maxs_hu
\"\"\"
bound method
\"\"\"


class StudentCourse:
    # 数据属性
    school = \'oldBoy\'
    count = 0

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        StudentCourse.count += 1  # 想类的数据属性发生改变. 不可加上self. 要从类处开始调用

    # 函数属性
    def choose_course(self):
        print(self.name, \'is choose course!\')


stu1 = StudentCourse(\'maxs_hu\', 10, \'m\')
stu2 = StudentCourse(\'Mokeke\', 20, \'w\')

# 类中的函数属性在用类名进行访问就是一个普通函数. 该传值传值. 在对象中调用则是一个绑定方法. 不需要传值
print(StudentCourse.choose_course)  # function
print(stu1.choose_course)  # bound method

# 在对象中调用绑定方法. 每一个实例化对象手上都有一个指针. 指向类方法中的地址(好像是每次都重新开辟了一个空间)
print(id(stu1.choose_course))
print(id(stu2.choose_course))

# 绑定的效果: 绑定给谁. 就应该由谁来调用. 谁调用就会将谁作为第一个参数传入self. 将松散的数据集合在一起
# 这样传参大大减少了传参的次数. 可以调用到当前对象拥有的数据属性: self.name self.age ...
stu1.choose_course()
# 类中定义的函数. 类确实可以使用. 但是大多数情况都是绑定给对象使用的. 所以前面都默认跟一个self

4.继承与派生.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:47
# @author: Maxs_hu
\'\'\'
1、什么是继承
    继承是一种新建类的方式,新建的类称为子类,被继承的类称为父类
    继承的特性是:子类会遗传父类的属性
    强调:继承是类与类之间的关系

2、为什么用继承
    继承的好处就是可以减少代码的冗余

3、如何用继承
    在python中支持一个类同时继承多个父类
    在python3中
        如果一个类没有继承任何类,那默认继承object类
    在python2中:
        如果一个类没有继承任何类,不会继承object类

    新式类
        但凡继承了object的类以及该类的子类,都是新式类
    经典类
        没有继承object的类以及该类的子类,都是经典类

    在python3中都是新式类,只有在python2中才区别新式类与经典类

    新式类vs经典类?

\'\'\'


class Foo:
    def f1(self):
        print(\'Foo.f1\')

    def f2(self):
        print(\'Foo.f2\')
        self.f1()


class Bar(Foo):
    def f1(self):
        print(\'Bar.f1\')


# 对象查找属性的顺序: 对象自己 -> 对象的类 -> 父类 -> 父类
obj = Bar()
obj.f2()  # Foo.f2  Bar.f1
# self表示当前当前调用的对象本身

5.继承的应用.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/6 10:49
# @author: Maxs_hu

\"\"\"
继承能别用就尽量别用: 因为他是将两个甚至更多个类耦合到一起. 叫做强耦合. 与解耦合思想观念不同. 容易乱
\"\"\"


class OldboyPeople:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


class OldboyStudent(OldboyPeople):
    school = \'oldBoy\'

    def choose_course(self):
        print(self.name, \'is choosing course!\')


class TeacherStudent(OldboyPeople):
    school = \'oldBoy\'

    def __init__(self, name, age, sex, level):
        # self.name = name
        # self.age = age
        # self.sex = sex
        OldboyPeople.__init__(self, name, age, sex)  # 直接通过类调用. 相当于一个普通函数的调用
        self.level = level

    def score(self):
        print(self.name, \'is scoring now!\')


stu1 = OldboyStudent(\'maxs_hu\', 10, \'male\')
print(stu1.__dict__)  # {\'name\': \'maxs_hu\', \'age\': 10, \'sex\': \'male\'}
tea1 = TeacherStudent(\'egon\', 30, \'male\', 1)
print(tea1.__dict__)  # {\'name\': \'egon\', \'age\': 30, \'sex\': \'male\', \'level\': 1}


# 再强调一下属性的寻找顺序: 对象自己 -> 对象的类 -> 父类 -> 父类

6.组合.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/7 9:41
# @author: Maxs_hu
\"\"\"
什么是组合:
    组合就是一个类的对象具备某一个属性,该属性的值是指向另外外一个类的对象
\"\"\"


class course:
    def __init__(self, name, price, period):
        self.name = name
        self.price = price
        self.period = period

    def course_info(self):
        msg = \"\"\"
        课程名称: %s
        课程价格: %s
        课程周期; %s
        \"\"\" % (self.name, self.price, self.period)
        print(msg)


class OldboyPeople:
    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex


class OldboyStudent(OldboyPeople):
    school = \'oldboy\'

    def __init__(self, stu_id, name, age, sex):
        super(OldboyStudent, self).__init__(name, age, sex)  # 严格按照继承查找. 可以简写为super().__init__()
        self.stu_id = stu_id

    def choose_course(self):
        print(self.name, \'is choosing course!\')


class OldboyTeacher(OldboyPeople):
    school = \'oldboy\'

    def __init__(self, level, name, age, sex):
        OldboyPeople.__init__(self, name, age, sex)  # 通过类名指名道姓查找. 相当于调用普通函数. 和继承无关
        self.level = level

    def score(self, stu, num):
        stu.score = num  # 为学生设置对应的分数
        print(\"%s正在为%s打%s分\" % (stu.name, self.name, num))


# 实例化学生和老师对象
stu1 = OldboyStudent(\'maxs_hu\', 18, \'male\', 1)
tea1 = OldboyTeacher(\'egon\', 17, \'male\', 10)

# 实例化课程
Python = course(\'python\', 5999, \'5mons\')
linux = course(\'linux\', 3999, \'5mons\')
Go = course(\'go\', 6999, \'5mons\')

# 将课程和学生老师进行组合
stu1.course = Python
tea1.course = linux

# print(stu1.course.__dict__)  # {\'name\': \'python\', \'price\': 5999, \'period\': \'5mons\'}
# print(stu1.course.name, stu1.course.price, stu1.course.period)
# print(tea1.course.name, tea1.course.price, tea1.course.period)

# 组合调用
stu1.course.course_info()
tea1.course.course_info()


# 为一个学生添加很多课程. 将每一个课程详细信息都打印出来
stu1.course = []
stu1.course.append(Python)
stu1.course.append(linux)
stu1.course.append(Go)
for item in stu1.course:
    item.course_info()

7.菱形继承问题.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/7 21:08
# @author: Maxs_hu
\'\'\'
1、菱形继承
    当一个子继承多个父类时,多个父类最终继承了同一个类,称之为菱形继承

2、菱形继承的问题:
    python2区分经典类与新式类(新式类继承了object或object的子类),如果子的继承是一个菱形继承,那么经典类与形式的区别为?
        经典类下查找属性:深度优先查找 -> 一条路走到黑
        新式类下查找属性:广度优先查找 -> 最后一个找最深的类
\'\'\'


class G(object):
    # def test(self):
    #     print(\'from G\')
    pass


class E(G):
    # def test(self):
    #     print(\'from E\')
    pass


class B(E):
    # def test(self):
    #     print(\'from B\')
    pass


class F(G):
    # def test(self):
    #     print(\'from F\')
    pass


class C(F):
    # def test(self):
    #     print(\'from C\')
    pass


class D(G):
    # def test(self):
    #     print(\'from D\')
    pass


class A(B, C, D):
    def test(self):
        print(\'from A\')
    # pass


obj = A()
print(A.mro())  # python调用底层的c3算法生成的mro列表 -> 继承查找关系
# 遵循三个原则:
#   1.子类会先于父类被检查
#   2.多个父类会根据他们在列表中的位置被检查
#   3.对于下一个父类.如果存在两个合法选择.则选择第一个父类(广度优先)
obj.test()  # A->B->E-C-F-D->G->object

8.子类派生和继承父类的两种方式.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/7 22:13
# @author: Maxs_hu
\"\"\"
1. 指名道姓法: 类名.函数名() -> 和继承没有关系
2. super函数: super.方法名() -> 严格遵循mro列表的顺序
\"\"\"


class D:
    def f1(self):
        print(\"D.f1\")


class C:
    def f2(self):
        super().f1()  # 直接按照mro列表找到D类下的f1
        print(\"C.f2\")


class B(C, D):
    pass


obj = B()
print(B.mro())  # [<class \'__main__.B\'>, <class \'__main__.C\'>, <class \'__main__.D\'>, <class \'object\'>]
obj.f2()  # 从B开始调用. 所以super是从B开始查找
# D.a
# C.b

9.多态.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/7 23:16
# @author: Maxs_hu
\'\'\'
1 什么是多态
    多态指的是同一种事物的多种形态
        水-》冰、水蒸气、液态水
        动物-》人、狗、猪

2 为和要用多态
    多态性:
    继承同一个类的多个子类中有相同的方法名
    那么子类产生的对象就可以不用考虑具体的类型而直接调用功能

3 如何用
\'\'\'
import abc  # abstract


class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def speak(self):
        print(\'11111\')

    @abc.abstractmethod
    def eat(self):
        pass


# Animal() # 强调:父类是用来指定标准的,不能被实例化

class People(Animal):
    def speak(self):
        print(\'say hello\')

    def eat(self):
        pass


class Dog(Animal):
    def speak(self):
        print(\'汪汪汪\')

    def eat(self):
        pass


class Pig(Animal):
    def speak(self):
        print(\'哼哼哼\')

    def eat(self):
        pass


peo1 = People()
dog1 = Dog()
pig1 = Pig()
#
#
peo1.speak()
dog1.speak()
pig1.speak()

# def my_speak(animal):
#     animal.speak()
#
# my_speak(peo1)
# my_speak(dog1)
# my_speak(pig1)


# python多态的实例
l = [1, 2, 3]
s = \'helllo\'
t = (1, 2, 3)

print(l.__len__())
print(s.__len__())
print(t.__len__())

# def len(obj):
#     return obj.__len__()

print(len(l))  # l.__len__()
print(len(s))  # s.__len__()
print(len(t))


# python推崇的是鸭子类型,只要你叫的声音像鸭子,并且你走路的样子也像鸭子,那你就是鸭子

class Disk:
    def read(self):
        print(\'disk read\')

    def write(self):
        print(\'disk wirte\')


class Process:
    def read(self):
        print(\'process read\')

    def write(self):
        print(\'process wirte\')


class File:
    def read(self):
        print(\'file read\')

    def write(self):
        print(\'file wirte\')


obj1 = Disk()
obj2 = Process()
obj3 = File()

obj1.read()
obj1.write()

10.封装(1).py

# -*- encoding:utf-8 -*-
# @time: 2022/7/19 9:27
# @author: Maxs_hu

\"\"\"
1. 什么是封装:
    封: 属性对外的是隐藏的. 对内是开放的
    装: 申请一个名称空间. 并向名称空间中放置一系列属性

3. 如何使用封装
\"\"\"


# 怎么进行封装: 在属性以__开头

# 1. 该封装仅仅只是对语法上的变形操作
# 2. 这种语法的变形只在类定义阶段执行一次. 因为类体代码只在定义阶段检测一次
# 3. 封装是对内不对外的. 即内部可以访问. 外部无法直接访问(只能间接访问). 因为在定义阶段. 类体代码会因为封装发生一次变形
class Foo:
    __country = \'china\'  # 加上__ -> 封装 _Foo__country = \'china\'

    def __init__(self, name, age):
        self.__name = name  # self._Foo__name = name
        self.age = age

    def eat(self):
        print(\"eat...\")
        print(Foo.__country)
        print(self.__name)


Foo.eat(111)  # 通过访问eat. 从而访问到__country
# print(Foo.__country)  # 报错

peo1 = Foo(\'maxs_hu\', 18)
peo1.eat()
# print(peo1.__name)  # 报错
print(peo1.__dict__)  # _Foo__name


# 4. 如果不想让子类覆盖父类. 可以在父类(子类)前面加上一个__
class Fun:
    def __f1(self):  # _Fun__f1
        print(\'Fun.f1\')

    def f2(self):
        print(\'Fun.f2\')
        self.__f1()  # _Fun__f1


class Bar(Fun):
    def __f1(self):
        print(\'Bar.f1\')


obj = Bar()
obj.f2()  # 先调用到父类中f2函数. f2中调用__f1. self先到子类当中去找. 再到父类中找到__f1

10.封装(2).py

# -*- encoding:utf-8 -*-
# @time: 2022/7/19 9:27
# @author: Maxs_hu

\"\"\"
1. 什么是封装:
    封: 属性对外的是隐藏的. 对内是开放的
    装: 申请一个名称空间. 并向名称空间中放置一系列属性

3. 如何使用封装
\"\"\"


# 怎么进行封装: 在属性以__开头

# 1. 该封装仅仅只是对语法上的变形操作
# 2. 这种语法的变形只在类定义阶段执行一次. 因为类体代码只在定义阶段检测一次
# 3. 封装是对内不对外的. 即内部可以访问. 外部无法直接访问(只能间接访问). 因为在定义阶段. 类体代码会因为封装发生一次变形
class Foo:
    __country = \'china\'  # 加上__ -> 封装 _Foo__country = \'china\'

    def __init__(self, name, age):
        self.__name = name  # self._Foo__name = name
        self.age = age

    def eat(self):
        print(\"eat...\")
        print(Foo.__country)
        print(self.__name)


Foo.eat(111)  # 通过访问eat. 从而访问到__country
# print(Foo.__country)  # 报错

peo1 = Foo(\'maxs_hu\', 18)
peo1.eat()
# print(peo1.__name)  # 报错
print(peo1.__dict__)  # _Foo__name


# 4. 如果不想让子类覆盖父类. 可以在父类(子类)前面加上一个__
class Fun:
    def __f1(self):  # _Fun__f1
        print(\'Fun.f1\')

    def f2(self):
        print(\'Fun.f2\')
        self.__f1()  # _Fun__f1


class Bar(Fun):
    def __f1(self):
        print(\'Bar.f1\')


obj = Bar()
obj.f2()  # 先调用到父类中f2函数. f2中调用__f1. self先到子类当中去找. 再到父类中找到__f1

11.property的使用.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/19 13:24
# @author: Maxs_hu
\"\"\"
property装饰器用于将被装饰的方法伪装成一个数据属性. 在使用时可以不加上括号直接访问
\"\"\"


class Foo:
    def __init__(self, name, weight, height):
        self.name = name
        self.weight = weight
        self.height = height

    @property  # 装饰成数据属性.可以不加括号直接调用
    def bmi(self):
        return self.weight / (self.height ** 2)


obj = Foo(\'maxs_hu\', 55, 1.75)
bmi = obj.bmi
print(bmi)


# property和封装结合: 可以提供给用户相同的调用方式. 但是底层完全不同
class People:
    def __init__(self, name):
        self.__name = name  # 封装数据属性

    # 新式的写法
    @property  # 查询
    def name(self):
        return \'名字是:%s\' % self.__name

    @name.setter  # 修改
    def name(self, name):
        self.__name = name

    @name.deleter  # 删除
    def name(self):
        raise TypeError(\'不允许删除\')

    # 古老的写法
    # def check_name(self):
    #     return \'名字是:%s\' % self.__name
    #
    # def set_name(self, val):
    #     self.__name = val
    #
    # def del_name(self):
    #     raise TypeError(\'不允许删除\')
    #
    # name = property(check_name, set_name, del_name)


peo1 = People(\'maxs_hu\')
print(peo1.name)

peo1.name = \'xiaoergu\'
print(peo1.name)

del peo1.name

12.绑定方法与非绑定方法.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/19 22:20
# @author: Maxs_hu
\'\'\'
1、绑定方法
    特性:绑定给谁就应该由谁来调用,谁来调用就会将谁当作第一个参数自动传入
         《《《精髓在于自动传值》》》

    绑定方法分为两类:
        1.1 绑定给对象方法
            在类内部定义的函数(没有被任何装饰器修饰的),默认就是绑定给对象用的
        1.2 绑定给类的方法:
            在类内部定义的函数如果被装饰器@classmethod装饰,
            那么则是绑定给类的,应该由类来调用,类来调用就自动将类当作第一个参数自动传入

2、非绑定方法
    类中定义的函数如果被装饰器@staticmethod装饰,那么该函数就变成非绑定方法
    既不与类绑定,又不与对象绑定,意味着类与对象都可以来调用
    但是无论谁来调用,都没有任何自动传值的效果,就是一个普通函数



3 应用
    应该将该函数定义成绑定给类的方法
    如果函数体代码需要用外部传入的对象,则应该将该函数定义成绑定给对象的方法
    如果函数体代码既不需要外部传入的类也不需要外部传入的对象,则应该将该函数定义成非绑定方法/普通函数


\'\'\'

# class Foo:
#     @classmethod
#     def f1(cls):
#         print(cls)
#
#     def f2(self):
#         print(self)
#
#
# obj=Foo()
# print(obj.f2)
# print(Foo.f1)

# Foo.f1()
# print(Foo)


# 1、f1绑定给类的
# 了解:绑定给类的应该由类来调用,但对象其实也可以使用,只不过自动传入的仍然是类
# print(Foo.f1)
# print(obj.f1)
# Foo.f1()
# obj.f1()

# 2、f2是绑定给对象的
# obj.f2()
# Foo.f2(obj)

import settings
import uuid


class Mysql:
    def __init__(self, ip, port, net):
        self.uid = self.create_uid()
        self.ip = ip
        self.port = port
        self.net = net

    def tell_info(self):
        print(\'%s:%s\' % (self.ip, self.port))

    @classmethod  # 类绑定方法. cls就是类.
    def from_conf(cls):
        return cls(settings.IP, settings.NET, settings.PORT)  # 这是类绑定方法最常用的方式. 使用类初始化方法

    @staticmethod  # 非绑定方法. 相当于普通函数. 该传递多少参数就传递多少
    def func(x, y):
        print(\'不与任何人绑定\')

    @staticmethod
    def create_uid():
        return uuid.uuid1()


# 默认的实例化方式:类名(..)
obj = Mysql(\'10.10.0.9\', 3307, 27)
obj.tell_info()

# 一种新的实例化方式:从配置文件中读取配置完成实例化
obj1 = Mysql.from_conf()
obj1.tell_info()

# obj.func(1,2)
# Mysql.func(3,4)
# print(obj.func)
# print(Mysql.func)

# print(obj.uid)

13.补充内置方法.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/20 8:58
# @author: Maxs_hu


# isinstance -> 判断是否为该实例化
class People:
    pass


peo1 = People()
print(isinstance(peo1, People))

d = {1: \"1\"}
print(isinstance(d, dict))  # 因此不需要用type()判断数据类型. 有专门的内置方法


# issubclass -> 判断是否为子类
class Foo:
    pass


class Bar(Foo):
    pass


print(issubclass(Bar, Foo))
print(issubclass(Foo, object))  # 所有类都继承object

14.反射.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/20 9:07
# @author: Maxs_hu
\"\"\"
1. 什么是反射:
    通过字符串来操作类或者对象的属性

2. 如果使用
    hasattr
    getattr
    setattr
    delattr
\"\"\"


class People:
    country = \"china\"

    def __init__(self, name):
        self.name = name

    def eat(self):
        print(\"%s is eating\" % self.name)


peo1 = People(\'maxs_hu\')
# 通过反射寻找实例中是否有某个数据或函数属性
print(hasattr(peo1, \'country\'))  # 底层是通过字符串\'eat\'去__dict__中找是否有对应的
print(getattr(peo1, \'eat\', None))  # peo1.eat 可在后面直接加()调用 如果没找到直接返回None
print(setattr(peo1, \'country\', \'America\'))  # peo1.country = \'America\'
delattr(peo1, \'country\')  # del peo1.country
print(peo1.__dict__)


# 安排一个案例
class Mysql:
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    def get_addr(self):
        print(\'<%s: %s>\' % (self.ip, self.port))  # 多个参数的format需要加上括号

    def set_addr(self, ip, port):
        self.ip = ip
        self.port = port

    def run(self):  # 入口
        while True:
            choice = input(\'>>>\').strip()
            if hasattr(self, choice):  # 判断输入的是否为实例化对象中的属性
                attr = getattr(self, choice)
                attr()  # 直接调用方法
            else:
                print(\'不存在改命令\')


obj = Mysql(\'127.0.0.1\', 8888)
obj.run()  # 调用run()启动程序

15.自定义类的方法来控制类的功能.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/20 9:51
# @author: Maxs_hu


# __str__方法
class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 在对象被打印的时候. 自动触发应该在该方法内采集与对象self有关的信息. 然后拼成字符串返回
    def __str__(self):
        return \'<name:%s age:%s>\' % (self.name, self.age)  # 必须返回字符串类型


peo1 = People(\'maxs_hu\', 18)
peo2 = People(\'mokeke\', 28)
print(peo1)  # peo1.__str__()
print(peo2)  # peo2.__str__()


# __del__方法
# del会在对象被删除之前自动触发
class File:
    def __init__(self):
        self.f = open(\'a.txt\', \'r\', encoding=\'utf-8\')

    def __del__(self):
        # 对象会在程序结束后被自动回收. 但是控制文件开关的操作系统不会.
        # 所以这个del可以用来做系统资源回收的事情
        self.f.close()
        print(\'file is closed\')


obj = File()
# 若主动删除.则会提前回收obj. 输出file is closed.
# 不主动删除. 程序也会在结束的时候自动回收python资源
del obj
print(111)

16.元类.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/21 7:48
# @author: Maxs_hu
\"\"\"
1. 什么是元类:
    在python中一切皆对象. 那么我们用class关键字定义的类本身也是一个对象.
    负责产生该对象的类称之为元类. 即元类可以称之为类的类
    class Foo:  # Foo = 元类()
        pass

2. 为何要使用元类:
    元类是负责产生类的. 所以我们学习元类和自定义元类的目的是为了控制类的产生过程. 还可以控制对象的生产过程

\"\"\"

# 一. 知识储备 -> exec内置的用法
cmd = \"\"\"
name = \"maxs_hu\"
age = 18
print(\"->>>>>\")
def eat():
    pass
\"\"\"
local_dic = {}
exec(cmd, {}, local_dic)
print(local_dic)


# 二. 创造类的方式有两种
# 大前提: 如果说类也是对象的话. 那么用class关键字去创建类也是一个实例化的过程
# 该实例化的目的是为了得到一个类. 调用的是元类

# 方式1:使用默认的元类type
class People1:  # People = type(...)
    country = \"china\"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(\'%s is eating\' % self.name)


# 创建类的三个要素: 类名. 基类. 类的名称空间
# People = type(类名, 基类, 类的名称空间)
class_name = \"People\"
class_bases = (object,)
class_dic = {}
cmd = \"\"\"
country = \"china\"

def __init__(self, name, age):
    self.name = name
    self.age = age

def eat(self):
    print(\'%s is eating\' % self.name)
\"\"\"
exec(cmd, {}, class_dic)  # 执行内置函数. 创造名称空间
People = type(class_name, class_bases, class_dic)
print(People)  # <class \'__main__.People\'>
peo1 = People(\'maxs_hu\', 18)
peo1.eat()  # 可以正常实例化和调用


# 方式二: 使用自定义的元类
class Mymate(type):  # 继承元类type保留原有代码
    def __init__(self, class_name, class_bases, class_dic):
        print(self)  # 因为该元类实例化过后为People类. 所以self是People
        super(Mymate, self).__init__(class_name, class_bases, class_dic)  # 重写父类功能


# 分析class运行原理:
# 1. 先拿到一个字符串格式的类名class_name = \'people\'
# 2. 拿到一个类的基类们class_bases = (object,)
# 3. 执行类体代码. 拿到一个类的名称空间class_dic = {...}
# 4. 调用People = type(class_name, class_bases, class_dic)
class People(object, metaclass=Mymate):  # 由自定义的Mymeta创造的一个类 -> People = Mymeta(...)
    \"\"\"  \"\"\"
    country = \"china\"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(\"%s is eating\" % self.name)


print(People.__dict__)


# 应用 -> 使用元类实现功能
#   1. 类的代码体中必须有文档中注释
#   2. 生成自定的类名首字母必须大写
class Mymate(type):
    def __init__(self, class_name, class_bases, class_dic):
        if class_dic.get(\'__doc__\') is None or len(class_dic.get(\'__doc__\').strip()) == 0:
            raise TypeError(\'类中必须有文本注释且不能为只为空格\')
        if not class_name.istitle():
            raise TypeError(\"类名首字母必须大写\")
        super(Mymate, self).__init__(class_name, class_bases, class_dic)  # 重写父类功能


class People(object, metaclass=Mymate):
    \"\"\"这是一个People类\"\"\"
    country = \"china\"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print(\"%s is eating\" % self.name)


print(People.__dict__)


# 三. 知识储备 -> __call__的使用 -> 用于元类控制实例的对象的操作
class Bar:
    # __call__的触发是在调用实例化对象时
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)


obj = Bar()
obj(1, 2, x=3)  # 调用实例化对象时触发

17.单例模式的三种实现方式.py

# -*- encoding:utf-8 -*-
# @time: 2022/7/21 15:31
# @author: Maxs_hu
\"\"\"
1. 什么是单例模式:
    基于某种方法实例化多次得到的是实例是同一个
2. 为何使用使用单例模式:
    当实例化多次得到对象中存放的属性都一样的情况下. 应该将多个实例化对象指向同一个内存.即同一个实例
\"\"\"
import setting


# 实现单例的方式一:
# 实例化传入的数据相同. 且重复多次的实例化. 就可以使用单例模式一次实例化节省名称空间
class Mysql:
    __instance = None

    def __init__(self, ip, port):
        self.ip = ip
        self.port = port

    @classmethod  # 绑定给类的一个方法
    def from_conf(cls):
        if cls.__instance is None:  # 判断是否已经实例化
            cls.__instance = cls(setting.IP, setting.PORT)
        return cls.__instance  # 只有第一次需要实例化. 后面直接指向之前的名称空间就行


obj1 = Mysql.from_conf()
obj2 = Mysql.from_conf()
obj3 = Mysql.from_conf()
print(obj1)
print(obj2)
print(obj3)


# 实现单例的方式二(装饰器):
# 判断如果没有参数就按照默认进行实例化. 如果含有参数就按照参数实例化
def singe(cls):  # 传入被装饰的函数名
    _instance = cls(setting.IP, setting.PORT)  # 先将实例化放在这里 也可以放到类里面cls.__instance. 这样类也可以直接访问到

    def wrapper(*args, **kwargs):
        if len(args) == 0 and len(kwargs) == 0:
            return _instance
        # 如果有参数传入. 则需要按照参数重新实例化并返回
        res = cls(*args, **kwargs)
        return res

    return wrapper


@singe
class Mysql:  # Mysql = singe(Mysql)  wrapper = Mysql
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port


obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql(\'1.1.1.3\', 4323)
print(obj1)
print(obj2)
print(obj3)
\"\"\"
obj1: <__main__.Mysql object at 0x00000198D0E40F70>
obj2: <__main__.Mysql object at 0x00000198D0E40F70>
obj3: <__main__.Mysql object at 0x00000198D0E40EE0>
\"\"\"


# 实现单例的方式三(元类):
class Mymeta(type):  # 利用__init__方法在执行__call__之前将默认实例化对象造出来
    def __init__(self, class_name, class_bases, class_dic):  # self=Mysql
        super(Mymeta, self).__init__(class_name, class_bases, class_dic)
        self.__instance = self.__new__(self)  # 造出一个Mysql的空对象
        self.__init__(self.__instance, setting.IP, setting.PORT)  # 从配置文件中加载配置完成Mysql对象的初始化

    def __call__(self, *args, **kwargs):  # self=Mysql
        if len(args) == 0 and len(kwargs) == 0:  # 如果无参数传入
            return self.__instance
        # 如果有参数传入. 则需要按照参数重新实例化并返回
        obj = self.__new__(self)
        self.__init__(obj, *args, **kwargs)
        return obj


class Mysql(object, metaclass=Mymeta):  # Mysql=Mymeta(...)
    def __init__(self, ip, port):
        self.ip = ip
        self.port = port


obj1 = Mysql()
obj2 = Mysql()
obj3 = Mysql()
obj4 = Mysql(\'10.10.10.11\', 3308)

print(obj1)
print(obj2)
print(obj3)
print(obj4)

基本代码注释都是非常详细的

后期会基于面向对象实现学生选课系统...

本文来自博客园,作者:{Max},仅供学习和参考


来源:https://www.cnblogs.com/Maxs-message/p/16503122.html
本站部分图文来源于网络,如有侵权请联系删除。

未经允许不得转载:百木园 » python面向对象编程

相关推荐

  • 暂无文章