本文主要是介绍面向对象2，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
内容概要
- 面向对象三大特性之继承
- 继承的本质
- 名字的查找顺序
- 派生类
- 继承下的派生实际应用
- 面向对象三大特性之封装
- property
- 面向对象三大特性之多态
内容详情
"""面向对象有三大特性继承、封装、多态 其中最重要的就是继承"""
# 继承的含义
现实生活中继承是用来描述人与人之间资源的从属关系
eg:儿子继承父亲 那么就可以拥有父亲的一切(别墅、豪车...)
面向对象中继承则是用来描述类与类之间数据的从属关系
eg:类A继承了类B 那么类A就可以使用类B中所有的数据(数据、功能...)
# 继承的目的
现实生活中通过继承可以快速的积累财富少奋斗N多年 并且可以多继承
eg:可以认多个爹 磅多个富婆
面向对象中通过继承可以减少代码冗余 提升开发效率 同样也支持多继承
eg:类A可以继承多个类同时拥有多个类里面的代码使用权
# 继承的基本使用
"""
class A(B):
pass
我们将被继承的类称为:父类或者基类 B
继承别人的类称为:子类或者派生类 A
"""
在python中一个类可以同时继承多个父类
class A(B,C,D):
pass
ps:到此先理解继承的含义 之后会研究查找顺序
抽象:由下往上抽取相同特征
继承:由上往下直接白嫖资源
"""
在面向对象编程中 其实类和父类的主要功能都是用来减少代码冗余的
对象:数据与功能的结合体
类:多个对象相同数据和功能的结合体
父类:多个类相同数据和功能的结合体
"""
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')
# 不继承的情况下
名字的查找顺序是
先从对象自己的名称空间中查找 没有则去类里面的名称空间查找
对象 >>> 类
'''注意设置值的情况下是在自身的名称空间中添加或者修改数据'''
# 单继承的情况下
名字的查找顺序是
先从对象自己的名称空间中查找 没有择取产生对象的类中查找
如果还没有并且类有父类则去父类中查找 以此往复下去!!!
对象 >>> 类 >>> 父类
经典案例
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或者其子类的类
经典类:不继承任何的类
"""
class A:
pass
print A.__bases__ # 空的
print(A.__bases__) # (<class 'object'>,)
"""
有时候我们在定义类的时候会习惯性的写
class MyClass(object):
pass
为了兼容python2和python3
"""
强调:研究菱形和非菱形问题object不参与图形构建
非菱形继承的情况下
父类中名字的查找顺序就是按照继承时从左往右依次查找
如果多个父类还有分类 那么遵循"深度优先"
ADBECF
菱形继承的情况下
父类中名字的查找顺序就是按照继承时从左往右依次查找
如果多个父类还有分类 那么遵循"广度优先"
ADBECFM
#############################################
'''名字的查找顺序永远都是 先从当前对象自身开始查找'''
#############################################
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__)
"""
如果自己写的子类需要使用父类的方法 并且还需要基于该方法做扩展
这样的子类我们称之为派生类(本质还是子类)可以使用super关键字来实现
"""
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) # [333, 222]
import datetime
import json
class MyJsonEncoder(json.JSONEncoder):
def default(self, o):
# 形参o就是即将要被序列化的数据对象
# print('重写了', o)
'''将o处理成json能够序列化的类型即可'''
if isinstance(o,datetime.datetime):
return o.strftime('%Y-%m-%d %X')
elif isinstance(o, datetime.date):
return o.strftime('%Y-%m-%d')
return super().default(o) # 调用父类的default(让父类的default方法继续执行 防止有其他额外操作)
d1 = {'t1': datetime.datetime.today(), 't2': datetime.date.today()}
res = json.dumps(d1, cls=MyJsonEncoder)
print(res)
"""
TypeError: Object of type 'datetime' is not JSON serializable
json不能序列化python所有的数据类型 只能是一些基本数据类型
json.JSONEncoder
1.手动将不能序列化的类型先转字符串
{'t1': str(datetime.datetime.today()), 't2': str(datetime.date.today())}
2.研究json源码并重写序列化方法
研究源码发现报错的方法叫default
raise TypeError("Object of type '%s' is not JSON serializable" % o.__class__.__name__)
我们可以写一个类继承JSONEncoder然后重写default方法
"""
# 封装的含义
将类中的某些名字'隐藏'起来 不让外界直接调用
隐藏的目的是为了提供专门的通道去访问 在通道内可以添加额外的功能
# 代码实操
class Student(object):
school = '清华大学'
__label = '逆来顺受' # 由于python崇尚自由 所以并没有真正的隐藏 而是自动转换成了特定的语法
def __init__(self, name, age):
self.name = name
self.age = age
def choose_course(self):
print('%s正在选课'%self.name)
stu1 = Student('jason', 18)
print(stu1.school) # 清华大学
print(stu1.name) # jason
print(stu1.age) # 18
print(stu1.__label) # 报错
print(Student.__dict__) # '_Student__label': '逆来顺受'
print(Student._Student__label) # 逆来顺受
print(stu1._Student__label) # 逆来顺受
"""
如何封装名字
在变量名的前面加上两个下划线__
封装的功能只在类定义阶段才能生效!!!
在类中封装其实也不是绝对的 仅仅是做了语法上的变形而已
__变量名 >>> _类名__变量名
我们虽然指定了封装的内部变形语法 但是也不能直接去访问
看到了就表示这个属性需要通过特定的通道(接口)去访问
"""
class Student(object):
__school = '清华大学'
def __init__(self, name, age):
self.__name = name
self.__age = age
# 专门开设一个访问学生数据的通道(接口)
def check_info(self):
print("""
学生姓名:%s
学生年龄:%s
""" % (self.__name, self.__age))
# 专门开设一个修改学生数据的通道(接口)
def set_info(self,name,age):
if len(name) == 0:
print('用户名不能为空')
return
if not isinstance(age,int):
print('年龄必须是数字')
return
self.__name = name
self.__age = age
stu1 = Student('jason', 18)
stu1.check_info()
stu1.set_info('jasonNB',28)
stu1.check_info()
stu1.set_info('','haha') # 用户名不能为空
"""
将数据隐藏起来就限制了类外部对数据的直接操作，然后类内应该提供相应的接口来允许类外部间接地操作数据，接口之上可以附加额外的逻辑来对数据的操作进行严格地控制
目的的是为了隔离复杂度，例如ATM程序的取款功能,该功能有很多其他功能组成
比如：插卡、身份认证、输入金额、打印小票、取钱等，而对使用者来说,只需要开发取款这个功能接口即可,其余功能我们都可以隐藏起来
"""
# property就是将方法伪装成数据
"""
可扩扩展:
体质指数（BMI）=体重（kg）÷身高^2（m）
"""
有时候很多数据需要经过计算才可以获得
但是这些数据给我们的感觉应该属于数据而不是功能
BMI指数>>>:应该属于人的数据而不是人的功能
class Person(object):
def __init__(self, name, height, weight):
self.__name = name
self.height = height
self.weight = weight
@property
def BMI(self):
# print('%s的BMI指数是:%s' % (self.name, self.weight / (self.height ** 2)))
return '%s的BMI指数是:%s' % (self.__name, self.weight / (self.height ** 2))
p1 = Person('jason', 1.83, 77)
# p1.BMI() # 22.9
print(p1.BMI) # 22.9
p2 = Person('eason',1.90,85)
# p2.BMI() # 23.5
print(p2.BMI) # 23.5
p3 = Person('xd',1.85,100)
# p3.BMI() # 29.2
print(p3.BMI) # 29.2
p4 = Person('xd',1.5,34)
# p4.BMI() # 15.1
print(p4.BMI) # 15.1
# 什么是多态
一种事物的多种形态
eg:水 固态 液态 气态
动物 猫、狗、猪
# 多态性
class Animal(object):
def speak(self):
pass
class Cat(Animal):
def speak(self):
print('喵喵喵')
class Dog(Animal):
def speak(self):
print('汪汪汪')
class Pig(Animal):
def speak(self):
print('哼哼哼')
"""
上述场景下 虽然体现了事物的多态性 但是并没有完整的体现出来
因为现在不同的形态去叫 需要调用不同的方法 不够一致
只要你是动物 那么你想要说话 就应该调用一个相同的方法 这样便于管理
"""
c1 = Cat()
d1 = Dog()
p1 = Pig()
c1.speak()
d1.speak()
p1.speak()
"""面向对象的多态性其实在很早之前就已经接触过了"""
# s1 = 'hello world'
# l1 = [1, 2, 3, 4]
# d1 = {'name': 'jason', 'pwd': 123}
# print(len(s1))
# print(len(l1))
# print(len(d1))
"""
多态性的好处在于增强了程序的灵活性和可扩展性，比如通过继承Animal类创建了一个新的类，实例化得到的对象obj，可以使用相同的方式使用obj.speak()
面向对象的多态性也需要python程序员自己去遵守 虽然python推崇的是自由 但是也提供了强制性的措施来实现多态性 不推荐使用
"""
import abc
指定metaclass属性将类设置为抽象类，抽象类本身只是用来约束子类的，不能被实例化
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod # 该装饰器限制子类必须定义有一个名为talk的方法
def talk(self): # 抽象方法中无需实现具体的功能
pass
class Person(Animal): # 但凡继承Animal的子类都必须遵循Animal规定的标准
def talk(self):
pass
p1=Person() # 若子类中没有一个名为talk的方法则会抛出异常TypeError，无法实例化
"""
由多态性衍生出一个理论
鸭子类型理论：只要你看着像鸭子 走路像鸭子 说话像鸭子 那么你就是鸭子!!!
"""
# 鸭子类型的实战案例
"""
在linux系统中有一句话>>>:一切皆文件!!!
内存可以存取数据
硬盘可以存取数据
...
那么多有人都是文件
"""
class Memory(object):
def read(self):
pass
def write(self):
pass
class Disk(object):
def read(self):
pass
def write(self):
pass
# 得到内存或者硬盘对象之后 只要想读取数据就调用read 想写入数据就调用write 不需要考虑具体的对象是谁
这篇关于面向对象2的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
