面向对象独有功能、动静态方法、继承、名字查找顺序、经典类与新式类、派生方法

2022/7/27 23:23:13

编程Tag： 继承 对象 面向对象 查找 class name 静态方法 self __

本文主要是介绍面向对象独有功能、动静态方法、继承、名字查找顺序、经典类与新式类、派生方法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

目录
  • 一、对象独有的功能
  • 二、动静态方法
    • 1.绑定给对象的方法
    • 2.绑定给类的方法
    • 3.调用静态方法
  • 三、面向对象三大特性之继承
    • 1.继承的含义
    • 2.继承的目的
    • 3.继承的操作
  • 四、继承本质
    • 1.什么时候可以用继承
    • 2.使用继承
  • 五、名字的查找顺序
    • 1.不继承的情况下名字的查找顺序
    • 2.单继承的情况下名字的查找顺序
    • 3.多继承的情况下名字的查找顺序
      • 3.1.非菱形继承
      • 3.2.菱形继承
  • 六、经典类与新式类
  • 七、派生方法

一、对象独有的功能

image-20220727145921275

'''
针对对象独有的方法 我们无法真正实现
    1.如果在全局则不是独有的
    2.如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
    定义在类中的函数默认是绑定给对象的（相当于是对象独有的方法）
    哪个对象来调用，就把哪个对象当作第一个参数传进去，然后就会那这个对象进行做一些操作，间接的实现了对象独有的方法
    定义在类中的函数，我们称之为方法，以后我们听到别人说方法，就是再说类中的函数
    是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
'''

---------------------在全局，所有的都可以使用，所以也不能称为是独有方法------------------------
class Person:
    h_type = '人类'

    # 独有的数据
    def __init__(self, name):
        self.name = name

    # 定义在类中的函数，我们称之为方法
    def shopping(self):
        print('正在口红试色！！', self)
        # 正在口红试色！！ <__main__.Person object at 0x000001CCC4428370>
        print(self.name, '正在口红试色！！')
        # kerry 正在口红试色！！

# 这么写也是给p1独有的方法，但是不推荐，func1在全局，所有人都可以使用，所以也不能称为是独有方法
p1 = Person('kerry')
def func1():
    print('from func1')
p1.func1 = func1
p1.func1()
p2 = Person('aimy')
def func2():
    print('from func2')

------------------定义在类中的函数默认是绑定给对象的（相当于是对象独有的方法）----------------
class Person:
    h_type = '人类'

    # 独有的数据
    def __init__(self, name):
        self.name = name

    # 定义在类中的函数，我们称之为方法
    def shopping(self):
        print('正在口红试色！！', self)
        # 正在口红试色！！ <__main__.Person object at 0x000001CCC4428370>
        print(self.name, '正在口红试色！！')
        # kerry 正在口红试色！！

'''
针对对象独有的方法 我们无法真正实现
    1.如果在全局则不是独有的
    2.如果在类中则是公共的
python解释器针对上述问题添加了一个非常牛的特性
    定义在类中的函数默认是绑定给对象的（相当于是对象独有的方法）
'''
p1 = Person('kerry')
p2 = Person('aimy')
p1.shopping()  # 本质上是这么调的 shopping(p1)
'''
正在口红试色！！ <__main__.Person object at 0x000001BE0D3F3A60>
kerry 正在口红试色！！
'''
p2.shopping()  # 本质上是这么调的 shopping(p2)
'''
正在口红试色！！ <__main__.Person object at 0x000001BE0D42F310>
aimy 正在口红试色！！
'''
'''
哪个对象来调用，就把哪个对象当作第一个参数传进去，然后就会那这个对象进行做一些操作，间接的实现了对象独有的方法
定义在类中的函数，我们称之为方法，以后我们听到别人说方法，就是再说类中的函数
是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
'''
# 如何理解绑定二字---->只针对对象
# Person.shopping()  # TypeError: shopping() missing 1 required positional argument: 'self'
# 只是给对象设置的功能，类不能使用，需要自传，而且是必须传一个对象
p3 = Person('lisa')
Person.shopping(p3)  # lisa 正在口红试色！！


# 例题

class Person:
    h_type = '人类'

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

    def shopping(self, a, b):
        print('正在口红试色！！', self)
        print(self.name, '正在口红试色！！')


# 1.如果是对象去调用方法需要传入俩个参数
p1 = Person('jason')
p1.shopping(1, 2)
# 2.如果是对象去调用方法需要传入三个参数
Person.shopping(p1, 1, 2)

二、动静态方法

1.绑定给对象的方法

'''
专门针对在类体中编写的函数
1.绑定给对象的方法
    直接在类体代码中编写即可
     特征：对象调用会自动将对象当做第一个参数传入
          类调用则有几个形参就传几个实参
'''
class Student:
    school = '厦门大学'
    def study(self):
        print('大一新生Kerry报道！！')

2.绑定给类的方法

'''
2.绑定给类的方法
    需要在函数的上面写一个装饰器 @classmethod,内置的，直接拿来用就好
'''

class Student:
    classroom = '盘丝洞'

    @classmethod  # 装饰器语法糖
    def attract(cls):
        print('蜘蛛精出没！！', cls)
stu1 = Student()
# 调用绑定给类的方法
Student.attract()  # 蜘蛛精出没！！ <class '__main__.Student'>
print(Student)  # <class '__main__.Student'>
# 绑定给类的时候，类在调用方法的时候会自动将类当作第一个参数传给方法，此时cls是用来接收类的 attract(Student)
stu1.attract()  # 蜘蛛精出没！！ <class '__main__.Student'>
# 绑定给类的时候,用对象调用会自动将产生该对象的类当做第一个参数传入  attract(Student)

3.调用静态方法

'''
3.调用静态方法
	不管是用类调用还是对象调用，有几个形参就调几个实参
'''
class Classroom:
    classroom = '盘丝洞'

    @staticmethod  # 装饰器语法糖
    def room_num(a, b):
        print('门牌号：110')


cls1 = Classroom()
# 类的
Classroom.room_num(1, 2)  # 门牌号：110
# 对象的
cls1.room_num(1, 2)  # 门牌号：110

三、面向对象三大特性之继承

'''面向对象三大特性分别是：继承（最常见）、封装、多态'''

1.继承的含义

现实中：用来描述人与人直接资源的关系
	eg：儿子继承父亲的财产，拥有了父亲所有的资源
编程中：用来描述类与类之间数据的关系
	eg：类A继承类B,类A可以使用类B所有的数据和功能
---拿来主义---

2.继承的目的

现实生活中继承就是合法的占有别人的财产
	eg：爸爸妈妈的财产
编程世界中继承就是为了节省代码编写
	eg：可以继承一个类，也可以继承多个类

3.继承的操作

'''
结构语法：
class 类名(继承的父类)
	pass
1.定义类的时候在类名后加括号
2.括号内填写你需要继承的类名
3.括号内可以填写多个父类 逗号隔开即可

我们将被继承的类称之为: 父类或基类或超类
我们将继承类的类称之为: 子类或派生类
ps:平时最常用的就是父类和子类
'''

class Father:
    money = 100000000000000
    def run(self):
        print('几百万的豪车')
class Son(Father):
    pass
print(Son.money)  # 100000000000000


class F1:
    name = 'from f1'
class F2:
    name = 'from f2'
class F3:
    name = 'from f3'
class MyClass(F1,F2,F3):
    pass
ps:目前掌握从左到右查找每个父类中的属性即可

image-20220727165050609

四、继承本质

1.什么时候可以用继承

image-20220727190716674

2.使用继承

class Teacher:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

    def teach_course(self):
        print('老师正在手舞足蹈的讲课')
class Student(Teacher):
    # def __init__(self,name,age,gender):
    #     self.name = name
    #     self.age = age
    #     self.gender = gender

    def teach_course(self):
        print('同学们正在打瞌睡，昨晚又去做贼了')
# stu1 = Student()  # TypeError: __init__() missing 3 required positional arguments: 'name', 'age', and 'gender'
'''
    在有__init__的时候（不论是直接有还是间接有），这个类在加括号的时候都会自动出发这个方法然后运行，那么在这个时候就要必须传入设置的形参
'''
stu1 = Student('kerry', 18, 'famale')
print(stu1)  # <__main__.Student object at 0x00000140514B3A60>
print(stu1.__dict__)  # {'name': 'kerry', 'age': 18, 'gender': 'famale'}

将多个类共同的数据或功能抽取出来形成一个基类

image-20220727171556302

继承的关系

image-20220727171627042

抽象:将多个类共同的数据或功能抽取出来形成一个基类
继承:从上往下白嫖各个基类里面的资源
"""
对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体
ps:类和父类最主要的功能其实就是节省代码
"""
一定要掌握继承的本质 这样以后你才会在代码中自己定义出子类父类

五、名字的查找顺序

1.不继承的情况下名字的查找顺序

'''不继承的情况下名字的查找顺序,先从对象自身查找 没有的话 再去产生该对象的类中查找'''
class Student:
    school = '厦门大学'
    def choice_course(self):
        print('正在选课')
stu1 = Student()
print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的 厦门大学
'''
涉及到一个对象在查找名字，底层会有一个固定的流程
先从对象自己的名称空间里找，如果没有的话再去产生这个对象的类里面找
'''
stu1.school = '北京大学'  # 在自身的名称空间中产生了新的school
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
print(stu1.school)  # 北京大学
print(Student.school)  # 厦门大学
# 对象	>>>	类

2.单继承的情况下名字的查找顺序

'''单继承的情况下名字的查找顺序,先从对象自身查找 然后是产生该对象的类 然后是一个个父类'''
class A:
    name = 'from A'
class B(A):
    name = 'from B'
class C(B):
    name = 'from C'

class MyClass(C):
    name = 'from MyClass'

obj = MyClass()
obj.name = '我不困！！'
print(obj.name)  # 我不困！！

3.多继承的情况下名字的查找顺序

'''多继承的情况下名字的查找顺序'''
非菱形继承(最后不会归总到一个我们自定义类上)
深度优先(每个分支都走到底 再切换)
菱形继承(最后归总到一个我们自定义类上)
广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)
ps:结合群内截图理解即可
也可以使用类点mro()方法查看该类产生的对象名字的查找顺序

3.1.非菱形继承

image-20220727184329563

3.2.菱形继承

image-20220727184207169

六、经典类与新式类

__bases__:查看当前这个类继承了哪些父类,只会看到第一层级的类
__base__:拿一个

经典类
	不继承object或其子类的类(什么都不继承)
新式类
	继承了object或其子类的类
"""
在python3中所有的类默认都会继承object
	也就意味着python3里面只有新式类
在python2中有经典类和新式类
	由于经典类没有核心的功能 所以到了python3直接砍掉了
	
以后我们在定义类的时候  如果没有想要继承的父类 一般推荐以下写法
    class MyClass(object):
        pass
目的是为了兼容python2
"""
以后写代码针对object无需关心 知道它的存在即可

七、派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能称之为派生
'''用别人的方法，但是不够用，想基于别人的方法进行扩展'''

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

class Teacher(Person):
    def __init__(self,name,age,gender,level):
        # Person.__init__(self,name,age,gender)  # 先调用父类的方法
        '''
        super().__init__(name,age,gender)  # super专门用于子类调用父类的方法
        变相的调用了下面这三句话
            self.name = name
            self.age = age
            self.gender = gender
        '''
        super().__init__(name,age,gender)  # super专门用于子类调用父类的方法
        self.level = level  # 自己再补充一些

class Student(Person):
    pass


这篇关于面向对象独有功能、动静态方法、继承、名字查找顺序、经典类与新式类、派生方法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程