标签：27 静态方法 继承 子类 self py 父类 class def

今日学习内容

• 动态方法和静态方法
• 面向对象的三大特性（继承）
• 属性查找
• 多继承问题

动态方法与静态方法

# 动态方法
	1.绑定给对象的方法
	class Student:
        school = '金职院'
        # 动态方法(绑定给对象的方法)
        def run(self):
            print(self)
        # 动态方法(绑定给类的方法)
        @classmethod
        def eat(cls):
            print(cls)
        # 静态方法(普普通通的函数)
        @staticmethod
        def speak(a):
            print(a)
	obj1 = Student()  # 空对象  
    # 类调用绑定给对象的方法:有几个参数就需要传几个参数
    Student.run(123)  # 123
    # 对象调用绑定给对象的方法:会自动将对象当做第一个参数传入
    obj1.run()
    
    2.绑定给类的方法
    class Student:
      @classmethod
      def eat(cls):
        prtin(cls)
  	# 类调用绑定给类的方法:会自动将类当做第一个参数传入
    print(Student)  # <class '__main__.Student'>
    Student.eat()  # <class '__main__.Student'>
    # 对象调用绑定给类的方法:也不需要传参 会讲产生该对象的类自动当做第一个参数传入
    obj1.eat()  # <class '__main__.Student'>
    
    
# 静态方法
静态方法就是：定义在类中，并且使用 @staticmethod 修饰器修饰，没有 cls 和 self 参数限制的方法我们称之为静态方法
	class Student(object):
        # 类的属性
        name = '小亮'
    	@staticmethod
      	def get_name(a):
     		print(a)
    obj1 = Student()
'在静态方法中，不会涉及到类中的方法和属性的操作，可以理解为将静态方法寄存在该类的命名空间中' 
	1.普普通通的函数:无论谁来调都必须传固定的参数个数
    # 类调用静态方法:要自己传值
    Student.get_name(123)
    # 对象调用静态方法:要自己传值
    obj1.get_name(123)

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

面向对象的三大特性: 继承, 封装, 多态
'其中最重要的是继承'

# 继承
	-面向对象中的继承和现实生活中的继承相同
    -代码中就是子类借用父类的行为
    -子类继承父类可以直接使用父类的属性或者方法
    -子类也称为派生类，父类也称为是基类
# 多继承
	子类只能继承公有属性和公有方法，一个子类可以继承多个父类，但是父类的方法、属性重复时，只能继承第一个父类中的方法、属性（具体看多继承、多层继承）
# 继承的意义
	避免重复操作，提升代码复用程度
# 继承的基本使用
	"""
		class A(B):  
			pass
	我们将被继承的类称为:父类或者基类     B
  继承别人的类称为:子类或者派生类			 A
	"""
  在python中一个类可以同时继承多个父类
	class B:
        pass
    class C:
        pass
    class D:
        pass
  	class A(B,C,D):
      pass

继承的分类

# 单继承
定义: 子类只继承一个父类的继承叫单继承
总结: 子类继承父类，子类里面没有的方法可以使用父类的方法，如果子类也提供了和父类相同的方法，那么使用就是子类的方法（就是说优先使用子类自己的方法）

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def show(self):
        print(self.name, self.age)
    def show_info(self):
        print("人类")

# 相对于Person类来说，Student类就是子类，Person类就是父类
class Student(Person):  # 小括号里面放的都是父类，只写一个父类的是单继承
    def show_info(self):
        print("学生类")

# 创建学生（字类）对象
student = Student("李四", 20)
student.show()  # 调用继承自父类的方法
student.show_info()  # 调用自己的方法，父类和字类都有的方法，优先使用自己的（也可以说是：重写了父类方法）

      
# 多继承
定义: 子类可以继承多个父类，可以使用多个父类里面的属性或者方法
总结: 子类继承多个父类，多个父类放到小括号里面，使用逗号','隔开

# 定义动物类
class Animal(object):
    def eat(self):
        print("动物在吃饭")
    def sleep(self):
        print("动物在睡觉") 

# 定义鱼类
class Fish(object):
    def swim(self):
        print("鱼儿在游泳")
    def sleep(self):
        print("鱼儿在睡觉")    

# 定义鲨鱼类
class Shark(Fish, Animal):  
    def attack(self):
        print("鲨鱼在攻击其他鱼类")

# 创建鲨鱼对象
shark = Shark()
shark.attack()  # 调用自己的方法    
shark.swim()  # 调用父类Fish的方法
shark.eat()  # 调用父类Animal的方法

# 获取Shark类的类继承顺序
result = Shark.mro()
print(result)
# [<class '__main__.Shark'>, <class '__main__.Fish'>, <class '__main__.Animal'>, <class 'object'>]

# 在Flash和Animal中都有sleep，但是继承顺序Fish在前，所以使用Fish中的slee方法
shark.sleep()  
# 找了一圈都没有kill方法，报错
# shark.kill()

继承的本质

抽象:抽象即提取类似的部分,由下往上抽取相同特征
继承:就是从代码中自上而下的获取资源
'''
对象:数据与功能的结合体
类:多个对象相同数据和功能的结合体
父类:多个类相同数据和功能的结合体
'''
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}学生正在学习')
stu1 = Student('jason', 18, 'male')

名字的查找顺序

首先牢牢记住一点:
'''名字的查找顺序永远都是,先从当前对象自身开始查找'''
查找顺序也分好几种情况下
ps: '名称空间'
# 不继承的情况下
	名字的查找顺序是:
  	先从对象自己的名称空间中查找,没有则去类里面的名称空间查找
    	对象	>>>	类
  '''注意设置值的情况下是在自身的名称空间中添加或者修改数据'''
  
# 单继承的情况下
	名字的查找顺序是
  	先从对象自己的名称空间中查找,没有择去产生对象的类中查找
    如果类中没有没有并且类有父类则去父类中查找,有其他父类还可以继续找
    	对象	>>>	类	>>> 父类(多个)
class A:
      def f1(self):
          print('from A.f1')
      def f2(self):
          print('from A.f2')
          self.f1()  '''以后看到self点东西 一定要问自己self是谁'''
    class MyClass(A):
       def f1(self):
            print('from MyClass.f1')
    obj = MyClass()
    obj.f2()
    # 执行的方法分别是A里面的f2和MyClass里面的f1

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

菱形和非菱形问题object不参与图形构建

非菱形继承的情况下

父类中名字的查找顺序就是按照继承时从左往右依次查找
   	如果多个父类还有分类 那么遵循"深度优先"
  		ADBECF

菱形继承的情况下

父类中名字的查找顺序就是按照继承时从左往右依次查找
   	如果多个父类还有分类 那么遵循"广度优先"
	ADBECFM

派生类

如果自己写的子类需要使用父类的方法,并且还需要基于该方法做扩展
这样的子类我们称之为派生类(本质还是子类,就是比父类多了额外方法)      
可以使用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,salary):
# 用了Person类里面的__init__方法之后
 	super(Teacher,self).__init__(name,age,gender) 
    # 子类调用父类的方法 完整语法
    super().__init__(name,age,gender)  
        # 子类调用父类的方法 精简语法
        # 自己还要添加一个额外的东西
    self.level = level
    self.salary = salary

class Student(Person):
    def '__init__(self,name,age,gender,stu_id,class_id):'
    
        # 用了Person类里面的__init__方法之后
        super().__init__(name, age, gender)
        # 自己还要添加一个额外的东西
        self.stu_id = stu_id
        self.class_id = class_id
        
t1 = Teacher('jason',18,'male','满级',3.1)
s1 = Student('kevin',28,'female',1302010201,2)
print(t1.__dict__)
print(s1.__dict__)

怎么说呢，有点迷糊，还需要好好理解上课讲的内容

标签：27,静态方法,继承,子类,self,py,父类,class,def
来源： https://www.cnblogs.com/kazz/p/16113869.html

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