面向对象2
注
一.面向对象动态与静态方法
1.动态方法
#绑定给对象方法
class Student: # 定义一个类(Student)类名
def run(self): # 定义函数(run)参(self)
print(self) # 展示(打印)传的值(实参)
Student.run(123) # 类调用绑定给对象的方法:有几个参数就需要传几个参数
# 对象调用绑定给对象的方法:会自动将对象当做第一个参数传入
obj1 = Student() # 类Student产生对象() 赋予变量名obj1
obj1.run()
----------------------------------------------------------------
# 绑定给类
class Student:
@classmethod
def out(cls):
print(cls)
print(Student)
# <class '__main__.Student'>
Student.out()
# <class '__main__.Student'>
p1 = Student()
p1.out()
# <class '__main__.Student'>
小总结
"""
用过上述：总结以下几点
1.绑定对象时
类调用类里（名称空间属性）时
所需要的参数有几个需要传几个
2.对象调用类里的（名称空间属性）时
不需要传实参，会自动将对象当做第一个参数传入
----------------------------------------
3.绑定给类的方法通过 @classmethod
类调用类里（名称空间属性）时
会自动将类当做第一个参数传入
4.对象调用类里的（名称空间属性）时
不需要传实参，会自动将类当做第一个参数传入
"""
2.静态方法
class Student:
@staticmethod
def out(func_name):
print(func_name)
Student.out('jason')
p1 = Student()
p1.out('jason')
小总结
"""
静态的关键字(@staticmethod)
类调用类里（名称空间属性）时
必须自己传值
对象调用类里的（名称空间属性）时
也必须传值
"""
二.面向对象特征
"""
面向对象三大特征：继承，封装，多态
"""
1.继承
# 1.子承父业（继承家产）
# 2.面向对象中：继承（其他类）可以减少本层类（代码冗余）提升开发效率
# 3.也可以继承多个类
"类嘛，类是多个对象(相同)数据和功能的结合体"
例
class out:
pass
# 被继承人out 里有个pass属性（20E）
# 我们将被继承人称为：父类 或者 基类
class outer(out)
pass
# 继承人outer 继承了out里的pass属性（20E）
# 我们将继承人称为： 子类 或者 派生类
2.继承的本质
# 1.抽象:由下往上抽取相同特征
# 2.继承:由上往下直接白嫖资源
例
class Person:
def __init__(self, name, age, ):
self.name = name
self.age = age
class Teacher(Person):
def teach(self):
print(f'{self.name}老师讲到了生物学')
class Student(Person):
def study(self):
print(f'{self.name}学生聚精会神')
p1 = Teacher('杰瑞', 8)
p2 = Student('汤姆', 12)
p1.teach()
p2.study()
# 杰瑞老师讲到了生物学
# 汤姆学生聚精会神
小总结
"""
通过例题总结：
1.Teacher.继承了Person里公共的功能
2.Student.继承了Person里公共的功能
3.分别调用了公共功能里name实现自身功能
"""
# 两个子类继承了同一个父类里的功能
三.名字的查找顺序
1.不继承查找名字顺序：
对象 >>> 类
# 先从对象内（名称空间）查找
# 没有则去类的（名称空间）查找
2.继承查找名字顺序
对象 >>> 类 >>> 父类
# 先从对象内（名称空间）查找
# 没有则去类的（名称空间）查找
# 没有就父类（名称空间）查找
例
class A: # 定义了类A
def f1(self): # F1是类A里的函数
print('from A.f1')
def f2(self): # F2也是类A里的函数
print('from A.f2')
self.f1() # 又调用了F1
class MyClass(A): # 继承了A里的F1，F2
def f1(self): # 本身有一个F1
print('from MyClass.f1')
obj = MyClass() # 赋予对象obj
obj.f2()
# 因为MyClass继承了A所以可以调用A里的函数
# obj 调用了F2 所以先看
# 1.先看对象本身没有
# 2.去类里看也没有
# 3.去父类找有
# 4.执行F2
# 5.执行完毕后边跟一个F1
# 6.别急在回来从MyClass对象找
# 7.没有在从MyClass类中找
# 8.类中有f1直接调用
3.多继承的情况下
# 1.在python2中存在经典类与新式类
# 2.在python3中只有新式类
'区分的关键在于是否继承了一个默认的object(双下方法只是名字没有功能)类'简称'obj'
# 新式类:直接或者间接继承了object或者其子类的类
# 经典类:不继承任何的类
class A:
pass
print(A.__bases__)
(<class 'object'>,)# python3是空的
python2 也是空的
"""
有时候我们在定义类的时候会习惯性的写
class MyClass(object):
pass
目的为了兼容python2和python3
"""
例
# 多情况继承
class A:
name = 'A'
pass
class B:
name = 'B'
pass
class C:
name = 'C'
pass
class MyClass(A,B,C):
pass
obj = MyClass()
print(obj.name)
# 1.结果是 name = A
# 2.根据继承多个父类ABC
# 3.从作到右查找
例
class M:
name = 'M'
pass
class D(M):
name = 'D'
pass
class E(M):
name = 'E'
class F(M):
name = 'F'
class A(D):
name = 'A'
pass
class B(E):
name = 'B'
pass
class C(F):
name = 'C'
pass
class MyClass(A,B,C):
pass
obj = MyClass()
print(obj.name)
4.菱形与非菱形
# 1..菱形继承：
# 父类中名字的查找顺序就是按照继承时从左往右依次查找
# 如果多个父类还有分类 那么遵循"广度优先"
# A绑定D如果A没有name那么找A绑定的D
# D没有绑定的name 那么顺序查找 B依次往下推
# 如果'ABCDEF'里都没name那么最后在去M里面找
# AD BE CF M
--------------------------------------------------------------
# 2.非菱形继承
# 父类中名字的查找顺序就是按照继承时从左往右依次查找
# 如果多个父类还有分类 那么遵循"深度优先"
# A绑定D如果A没有name那么找A绑定的D
# D没有绑定的name 那么顺序查找 B依次往下推
# AD BE CF
四.派生类
例
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', '7', '5W')
s1 = Student('kevin', 28, 'female', 12138, 1)
print(t1.__dict__)
print(s1.__dict__)
总结
"""
1.如果自己写的子类需要使用父类的方法 并且还需要基于该方法做扩展
2.这样的子类我们称之为派生类(本质还是子类)
3.那么可以使用super关键字来实现
"""
# 1.通过继承获得父类里的形参
# 2.其他子类重复父类形参并额外添加其他形参
# 3.通过super().__init__（）去重父类形参
# 4.子类在去添加一些额外的形参
# 5.调用传参时候一并传入即可
# 6.目的是减少代码冗余，提高效率
# 7__dict__查看全部字典
五.派生功能前瞻
例
class MyClass(list):
def append(self,args):
if args == 123:
print('数字123不能追加')
return
super(MyClass, self).append(args)
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)
总结
# 1.创建一个类绑定是list（列表）
# 2.现在obj1被MyCalss赋予成一个对象
obj1 = MyClass()
# 3.可以通过addend给列表内传值
# 4.值传到了类的名称空间里也就是函数内
# 5.函数内接收后会出现一个if判断
# 6.关键在于return 返回值 后如果没有值
# 7.默认为None 也就是说args == 123
# 8.你传入123 就返回None
# 9.然后if条件不管成立不成立都会执行
# 10.super再次添加额外功能
# 11.从新循环MyCalss空列表
# 12 self需要传参的形参不传就是空列表
# 13.然后append(args)接受实参
'可能没那么清晰~~~~~~~~见谅 个人见解'
