方法,属性查找,继承

1. 动态方法与静态方法

# 动态方法
# 方式一:绑定给对象的方法
class Student:
    def run(self):
        print(self)


# 类调用绑定给对象的方法:有几个参数就需要传几个参数
Student.run(123)
# 对象调用绑定给对象的方法:会自动将对象当做第一个参数传入
student_obj1 = Student()
student_obj1.run()


# 方式二:绑定给类的方法
class Student:
    @classmethod
    def python_cat(cls):
        print(cls)


# 类调用绑定给类的方法:会自动将类当做第一个参数传入
print(Student)
student_obj1 = Student()
Student.python_cat()
# 对象调用绑定给类的方法:也不需要传参 会讲产生该对象的类自动当做第一个参数传入
student_obj1.python_cat()  # <class '__main__.Student'>


# 静态方法
class Student:
    @staticmethod
    def speak_python_cat(a):
        print(a)


# 1.普普通通的函数:无论谁来调 都必须传固定的参数个数
# 类调用静态方法:要自己传值
Student.speak_python_cat(123)
# 对象调用静态方法:要自己传值
student_obj1 = Student()
student_obj1.speak_python_cat(321)

 

 

2. 面向对象特性之继承

"""
面向对象有三大特性 其中最重要的就是继承!!!
继承、封装、多态
"""
# 继承的含义
# 面向对象中继承则是用来描述类与类之间数据的从属关系
# 如: 实生活中继承是用来描述人与人之间资源的从属关系, 那么就可以拥有父亲的一切(别墅、豪车...)
# 继承的目的
# 面向对象中通过继承可以减少代码冗余,提升开发效率, 同样也支持多继承
# 现实生活中通过继承可以快速的积累财富少奋斗N多年,并且可以多继承
# 面向对象中通过继承可以减少代码冗余
# 继承的基本使用
"""
    class A(B):  
        pass
我们将被继承的类称为:父类或者基类     B
继承别人的类称为:子类或者派生类             A
"""


# 在python中一个类可以同时继承多个父类
class B:
    pass


class C:
    pass


class D:
    pass


class A(B, C, D):
    pass


# 抽象: 由下往上抽取相同特征
# 继承: 由上往下直接白嫖资源
"""
在面向对象编程中 其实类和父类的主要功能都是用来减少代码冗余的

对象:数据与功能的结合体
类:多个对象相同数据和功能的结合体
父类:多个类相同数据和功能的结合体
"""


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


class Teacher(Person):
    def teach(self):
        print(f'{self.name}老师正在讲课')


class Student(Person):
    def study(self):
        print(f'{self.name}学生正在学习')


student_obj1 = Student('dragon', 20, 'male')
student_obj1.study()

 

 

3. 名字的查找

# 不继承的情况下
# 名字的查找顺序是
# 先从对象自己的名称空间中查找
# 没有则去类里面的名称空间查找
# 对象 >> > 类
'''注意设置值的情况下是在自身的名称空间中添加或者修改数据'''


# 单继承的情况下
# 名字的查找顺序是
# 先从对象自己的名称空间中查找
# 没有择取产生对象的类中查找
# 如果还没有并且类有父类则去父类中查找
# 以此往复下去!!!
# 对象 >> > 类 >> > 父类
# 经典案例


class A:
    def A1(self):
        print('from A1')

    def A2(self):
        print('from A2')
        self.A1()
        '''以后看到self点东西 一定要问自己self是谁'''


class MyClass(A):
    def A1(self):
        print('from MyClass.f1')


obj = MyClass()
obj.A2()
# 执行的方法分别是A里面的f2和MyClass里面的f1


# 多继承的情况下(了解)
"""
在python2中存在经典类与新式类
在python3中只有新式类
    区分的关键在于是否继承了一个默认的object类
        新式类:直接或者间接继承了object或者其子类的类
        经典类:不继承任何的类
"""


class A:
    pass


print(A.__bases__)
"""
有时候我们在定义类的时候会习惯性的写
class MyClass(object):
    pass
为了兼容python2和python3
"""
# 强度: 研究菱形和非菱形问题object不参与图形构建
# 非菱形继承的情况下
# 父类中名字的查找顺序就是按照继承时从左往右依次查找
# 如果多个父类还有分类
# 那么遵循
"深度优先"


# 执行顺序:A->D->B->E->C
class B():
    def python_cat(self):
        print('B')


class C():
    def python_cat(self):
        print('C')


class D(B):
    def python_cat(self):
        print('D')


class E(C):
    def python_cat(self):
        print('E')


class A(D, E):
    def python_cat(self):
        print('A')


A_obj1 = A()
A_obj1.python_cat()


# 菱形继承的情况下
# 父类中名字的查找顺序就是按照继承时从左往右依次查找
# 如果多个父类还有分类
# 那么遵循
# "广度优先"
# 执行顺序:A->D->B->E->C->M
class M():
    def python_cat(self):
        print('M')


class B(M):
    def python_cat(self):
        print('B')


class C(M):
    def python_cat(self):
        print('C')


class D(B):
    def python_cat(self):
        print('D')


class E(C):
    def python_cat(self):
        print('E')


class A(D, E):
    def python_cat(self):
        print('A')


A_obj1 = A()
A_obj1.python_cat()
'''名字的查找顺序永远都是 先从当前对象自身开始查找'''

 

 

4. 派生类

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


class Teacher(Human):
    def __init__(self, name, age, salary, subject):
        # 用了Human类里面的__init__方法之后
        # super(Teacher,self).__init__(name,age)  # 子类调用父类的方法 完整语法
        super().__init__(name, age)  # 子类调用父类的方法 精简语法
        # 自己还要添加一个额外的东西
        self.salary = salary
        self.subject = subject


class Student(Human):
    def __init__(self, name, age, student_id, subject):
        # 用了Human类里面的__init__方法之后
        super().__init__(name, age)
        # 自己还要添加一个额外的东西
        self.student_id = student_id
        self.subject_id = subject


"""
如果自己写的子类需要使用父类的方法 并且还需要基于该方法做扩展
这样的子类我们称之为派生类(本质还是子类)      
    那么可以使用super关键字来实现
"""
t1 = Teacher('dragon', 58, 500, '英语')
s1 = Student('cat', 20, 10101010001, '数学')
print(t1.__dict__)
print(s1.__dict__)

 

 

5. 派生功能前瞻

index_list = [1, 2, 3, 4, 11, 22, 33, 44]


class append_index(list):
    def append(self, args):
        if args in index_list:
            print(f'数字{args}不让你进行追加')
            return
        super(append_index, self).append(args)


obj1 = append_index()
obj1.append(1)
obj1.append(11)
obj1.append(111)
print(obj1)