动态方法与静态方法

动态方法

# 1.绑定给对象的方法


class Programmer:

    def run(self):
        print(self)


Programmer.run('app')  # app
# 对象调用绑定给对象的方法:自动将对象当做第一个参数传入
obj1 = Programmer()
obj1.run()


# 2. 绑定给类的方法


class Programmer:
    @classmethod
    def delete(cls):
        print(cls)


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

静态方法

class Programmer:
    @staticmethod
    def debug(a):
        print(f'正在调试{a}')


# 1.普通的函数: 不管怎么调用，都必须传固定的参数
# 类调用静态方法:要自己传值
Programmer.debug('app')
# 对象调用静态方法:要自己传值
obj1 = Programmer()
obj1.debug('a shop app')

面向对象的三大特性之一:继承

面向对象有三大特性:继承、封装、多态

继承的含义

现实生活中继承是用来描述人与人之间资源的从属关系
eg:子女继承父母的财产，土地
面向对象中继承则是用来描述类与类之间数据的从属关系
eg:类A继承了类B，类A就可以调用类B中所有的数据和功能

继承的目的

现实生活中通过继承可以快速的积累财富，并且可以继承多人的财产
面向对象中通过继承可以减少代码冗余，提升开发效率，同样也可以多继承

继承的基本使用

class A(B):
pass
我们将被继承的类称为:父类或者基类
继承的类称为:子类或者派生类
python中一个类可以同时继承多个父类
class A(B,C,D，E):
pass

继承的本质

在面向对象编程中，类继承父类能减少代码冗余

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


class Java_programmer(Programmer):
    def work(self):
        print(f'{self.name}正在加班')


class python_programmer(Programmer):
    def resign(self):
        print(f'{self.name}被裁员了')


programmer_one = python_programmer('jackson', 35, 'male', 60000)
print(programmer_one.__dict__)  # {'name': 'jackson', 'age': 35, 'gender': 'male', 'salary': 60000}
programmer_one.resign()  # jackson被裁员了

属性查找

不继承的情况下

名字的查找顺序是:
先从对象自己的名称空间中查找,找不到再去类里面的名称空间查找
对象--->类

单继承的情况下

名字的查找顺序是:
先从对象自己的名称空间中查找,没有就去产生对象的类中查找
还没有并且类有父类则去父类中查找
对象--->类--->父类

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

    def f2(self):
        print('from A.f2')
        self.f1()

    def f3(self):
        print('from A.f3')
        self.f2()


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

    def f2(self):
        print('from MyClass.f2')


obj = MyClass()
obj.f3()  # from A.f3 from MyClass.f2

派生类

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


class Boss(Person):
    def __init__(self, name, age, gender, level, salary):
        # 用了Person类里面的__init__方法之后
        # super(Teacher,self).__init__(name,age,gender)  # 子类调用父类的方法,完整语法
        super().__init__(name, age, gender)  # 子类调用父类的方法,精简语法
        # 子类还可以添加额外的数据
        self.level = level
        self.salary = salary


class Staff(Person):
    def __init__(self, name, age, gender, staff_id, staff_age):
        # 用了Person类里面的__init__方法之后
        super().__init__(name, age, gender)
        # 子类还可以添加额外的数据
        self.staff_id = staff_id
        self.staff_age = staff_age


b1 = Boss('musk', 40, 'male', '10', 0)
s1 = Staff('jerry', 28, 'female', 1001, 8)
print(b1.__dict__)  # {'name': 'musk', 'age': 40, 'gender': 'male', 'level': '10', 'salary': 0}
print(s1.__dict__)  # {'name': 'jerry', 'age': 28, 'gender': 'female', 'staff_id': 1001, 'staff_age': 8}