ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

【python基础】第34回 继承和查找顺序

2022-07-27 20:03:39  阅读:173  来源: 互联网

标签:name python self 34 继承 查找 对象 print class


目录

1. 对象独有的功能

1.1 代码演示

class Person:
    h_type = '人类'
    def __init__(self,name):  # 让对象拥有独有的数据
        self.name = name
    # 定义在类中的函数  我们称之为方法
    def eat(self):  # 是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
        print('%sz正在干饭'%self.name)

    def others(self,a,b):
        print('other哈哈哈')
# 针对对象独有的方法 我们没法真正实现
# 1. 如果在全局则不是独有的
# 2. 如果在类中则是公开的
# python解释器针对上述问题添加了一个非常牛的特性, 定义在类中的函数默认是绑定给对象的(相当于是对象独有的方法)
p1 = Person('jason')
p1.eat()  # set(p1)
p2 = Person('kevin')
p2.eat()

1.2 绑定

p3 = Person('oscar')
Person.eat(p3)

1.3 多个参数

p1 = Person('jason')
p1.others(1, 2)
Person.others(p1,1,2)

2. 动静态方法

2.1 绑定给对象的方法

直接在类体代码中编写即可,对象调用会自动将对象当做第一个参数传入,类调用则有几个形参就传几个实参

class Student:
    school = '清华大学'
    # 绑定给对象的方法
    def run(self):  # self 用于接收对象
        print('绑定对象', self)

stu1 = Student
print(stu1.run)  # <function Student.run at 0x000002D814B28700>

2.2 绑定给类的方法

class Student:
    school = '清华大学'
    # 绑定给对象的方法
    def run(self):  # self 用于接收对象
        print('绑定对象', self)

    @classmethod  # 绑定给类的方法
    def eat(cls):  # cls用于接收类
        print('绑定类', cls)
# 调用绑定类的方法
Student.eat()  # 类调用会自动将类当做第一个参数传入  eat(Student)
stu1.eat()  # 对象调用会自动将产生该对象的类当做第一个参数传入  eat(Student)

2.3 静态方法

class Student:
    school = '清华大学'
    # 绑定给对象的方法
    def run(self):  # self 用于接收对象
        print('绑定对象', self)

    @classmethod  # 绑定给类的方法
    def eat(cls):  # cls用于接收类
        print('绑定类', cls)

    @staticmethod  #静态方法
    def sleep(a, b):  # 无论谁来调用都必须按照普普通通的函数传参方式
        print('静态方法')
# 调用静态方法
stu1 = Student
Student.sleep(1,2)  # 静态方法
stu1.sleep(1,2)  # 静态方法

3. 面向对象三大特性之继承

3.1 三大特性

  1. 继承
  2. 封装
  3. 多态

3.2 继承的含义

  1. 在现实生活中继承其实就是用来描述人与人之间资源的关系。eg:儿子继承父亲的财产(拥有了父亲所有的资源)
  2. 在编程世界里继承其实就是用来描述类与类之间数据的关系。eg:类A继承类B(拥有了类B里面所有的数据和功能)

3.3 继承的目的

  1. 现实生活中继承就是想占有别人的财产。eg:亲身父亲 干爹 干妈
  2. 编程世界里继承就是为了节省代码编写。eg:可以继承一个类 也可以继承多个类

3.4 继承的操作

3.4.1 语法结构

# 语法结构
class 类名(类名):
    pass
  1. 定义类的时候在类名后加括号
  2. 括号内填写你需要继承的类名
  3. 括号内可以填写多个父类 逗号隔开即可
  4. 我们将被继承的类称之为: 父类或基类或超类
  5. 我们将继承类的类称之为: 子类或派生类
    ps:平时最常用的就是父类和子类

3.4.2 多个父类查找

从左到右查找每个父类中的属性即可

class MyClass(F1,F2,F3):
    pass

3.4.3 继承的本质

  1. 抽象:将多个类共同的数据或功能抽取出来形成一个基类
  2. 继承:从上往下白嫖各个基类里面的资源
对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体
ps:类和父类最主要的功能其实就是节省代码

4. 名字的查找顺序

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

先从对象自身查找,没有的话,再去产生该对象的类中查找(对象自身 >>> 类)

class Student:
    school = '清华大学'
    def choice(self):
        print('选课')

stu1 = Student()
print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的 清华大学
stu1.school = '北京大学'  # 自身的名称空间中产生了新的school
# 对象点名并写了赋值符号和数据值,那么操作的肯定是自己的名称空间
print(stu1.school)  # 北京大学
print(Student.school)  # 清华大学

4.2 单继承的情况下名字1的查找顺序

先从对象自身查找,然后是产生该对象的类 然后是一个个父类(对象 >>> 类 >>> 父类)

class A:
    name = 'from A'  # B pass 打印A name   from A
class B(A):
    # name = 'from B'  # C pass 打印B name   from B
    pass
class C(B):
    # name = 'from C'  # 有name 打印出 from C
    pass
obj = C()
# obj.name = '打印'   # 打印
print(obj.name)
class A:
    def func1(self):
        print('from A func1')
    def func2(self):
        print('from A func2')
        self.func1()  # # obj.func1()
class B(A):
    def func1(self):
        print('from B func1')
obj = B()
obj.func2()

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

  1. 非菱形继承(最后不会归总到一个我们自定义类上)深度优先(每个分支都走到底 再切换)

class D:
    name = 'from D'
class E:
    name = 'from E'
class F:
    name = 'from F'
class A(D):
    name = 'from A'
class B(E):
    name = 'from B'
class C(F):
    name = 'from C'
class My(A, B, C):
    pass

obj = My()
print(obj.name)


2. 菱形继承(最后归总到一个我们自定义类上)广度优先(前面几个分支都不会走最后一个类 最后一个分支才会走)

5. 经典类与新式类

5.1 经典类

不继承object或其子类的类(什么都不继承)

5.2 新式类

继承了object或其子类的类

5.3 python2 和 python3

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

6. 派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能>>>:派生 (super())

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.level = level


class MyClass(list):
    def append(self, value):
        if value == 'jason':
            print('jason 不能追加')
            return
        super().append(value)


obj = MyClass()
obj.append(111)
obj.append(222)
obj.append('jason')
obj.append(333)  # [111, 222, 333]
print(obj)

标签:name,python,self,34,继承,查找,对象,print,class
来源: https://www.cnblogs.com/cainiaozhy/p/16526126.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有