python7：面向对象

Posted 2020-10-03

什么是面向对象
# 面向对象的程序设计思想：核心是对象二字，对象就是一个事物，没有的事物可以被创造，不要考虑过程，考虑的是对象
# 对象：一个事物的特征和技能唯一标识一个对象，系统是一个个的对象组成的，程序的发展是有对象之间的交互，扩展行很强
# 把设计程序看成是创造世界，那么程序员就是上地，任何不存在的对象都能被创造，更加注重对现实世界的模拟
# 优点：扩展性强，优点就是用途
# 缺点：无法预知程序的发展，只知道程序的对象的属性
# 类即种类，类别，对象是特征和技能的结合体，那么类就是一系列相似的对象
# 特征和技能的结合体
# 在现实世界中：现有的一个个具体存在的对象，总结这些对象的相似之处，才有的类，
# 在程序中：先定义类，后使用类，类是用来生成对象的一个工具，
# 定义类一定是站在某一个角度进行区分
# 第一阶段：显示中的对象——>现实中类
# obj1：
#     特征：
#         学校=oldboy
#         名字=李大炮
#         年纪=18
#         性别=女
#     技能：
#         学习
#         吃饭
# obj2：
#     特征：
#         学校=oldboy
#         名字=张全蛋
#         年纪=28
#         性别=男
#     技能：
#         学习
#         吃饭
# obj3：
#     特征：
#         学校=oldboy
#         名字=牛榴弹
#         年纪=18
#         性别=女
#     技能：
#         学习
#         吃饭
# 显示中的老男孩学生类：
#   相似的特征
#     学校=oldboy
#    相似的技能
#     学习
#     吃饭
class OldboyStudent:#定义类
    school=‘oldboy‘#定义特征，数据属性，静态属性
    def learn(self):#定义技能，函数属性，这俩都是类的属性，动态属性
        print(‘is learning‘)
    def eat(self):
        print(‘is eating‘)
#在类中，变量定义的是类的特征，函数定义的是技能
#类体的代码在类定义阶段就会执行，在类中，类体的代码不只局限与变量和函数，还可以有其他的代码
#在类定义的时候，有名字存在，会产生名称空间，查看名称空间，以字典形式产生,查看名称空间和变量的值,这是查看的是函数的内存地址，加()可以运行
# 以及函数的内存地址
print(OldboyStudent.__dict__)
print(OldboyStudent.__dict__[‘school‘])
print(OldboyStudent.__dict__[‘learn‘])
#python访问类的属性的做法：
print(OldboyStudent.school) #查看类的属性
print(OldboyStudent.learn)#learn一定不能加上（），加了（）就是找到并且调用
OldboyStudent.learn()#仍然是一个函数，符合函数所有的规则
OldboyStudent.school=‘OLD‘#更改类的属性
del OldboyStudent.school #删除类的属性
OldboyStudent.school=‘111111‘#增加类的属性
OldboyStudent.__dict__#查看类的属性
#程序中的类是为了产生程序中的对象
####################################对象############################
print(callable(OldboyStudent))#是可调用对象,使用类产生对象
# 产生程序中的对象:类名+括号，调用类，产生类的实际存在的对象，类是虚拟的东西，调用之后产生了一个真的对象，这个过程就是实例化，产生的对象就是这个类的实例
obj1=OldboyStudent()#加上（）之后有返回值，一样的特征就存在类中，不一样的存到各自的对象中
obj2=OldboyStudent()
obj3=OldboyStudent()
#############################init######################################
class OldboyStudent:
    school=‘oldboy‘
    def __init__(self,name,age,sex):#定义类自己的特征
        self.name=name #等号右边是参数，左边是属性，使用init初始化对象
        self.age=age
        self.sex=sex
    def learn(self):
        print(‘is learning‘)
    def eat(self):
        print(‘is eating‘)
obj1 = OldboyStudent(‘李大炮‘,‘18‘,‘女‘)
#init只在实例化时执行，没有自己的特征的对象是空对象，产生空对象之后执行
#1、先产生一个空对象
#2、触发init，把函数中的参数，连同自己一同传进去
print(obj1.__dict__)#查看类的独有的属性，返回结果是字典
obj2 = OldboyStudent(‘张全蛋‘,‘28‘,‘男‘)
print(obj2.__dict__)
obj3 = OldboyStudent(‘牛榴弹‘,‘18‘,‘女‘)
print(obj3.__dict__)
###########################对象的属性###############################
obj1.name
obj1.name=‘大炮‘
obj1.__dict__#使用字典的方式访问对象的私有属性，想操作字典一样操作属性，
#字典有的方法，这种都有,比如：obj1.__dict__.pop(‘name‘)，#曾删改查的操作同理
类体中可以存在任何的代码，
class OldboyStudent:
    school=‘oldboy‘
    def __init__(self,name,age,sex):#定义类自己的特征
        if not isinstance(name.str):
            raise TyoeError(‘类型错误‘)
        self.name=name #等号右边是参数，左边是属性，使用init初始化对象
        self.age=age
        self.sex=sex
    def learn(self):
        print(‘is learning‘)
#init中有任意的代码，但是在init中只能return None,不能返回其他的。
########################对象的属性查找#################################
#1、类的数据属性
print(obj1.name,obj1.age) #查看私有的
print(obj1.school)#查看相同的属性
print(obj2.school)
print(obj3.school)
#对象可以访问的类的数据属性，这里的id都是相同的，类的数据属性是共享给对象的
#2、类的函数属性,对象可以访问类的函数数据，得到的是绑定方法，内存中只加载一次，有一个对象就绑定给他，这样1、绑定可以节省内次年
#   2、在多个对象绑定的时候，每一个对象产生的结果和使用的方法都是自己的，谁绑定就操作谁，相互之间不影响
print(obj1.learn)
print(obj2.learn)
print(obj3.learn)
#绑定方法的特殊之处：绑定给谁就由谁来调用，谁来调用就把谁当作第一个参数传进去
#由对象触发的，都是绑定方法，是绑定方法，都会把自己作为第一个参数传进去
#python3 中数据类型就是一个类。
#查找顺序：在对象自己有一个数据属性，类也有一个数据属性，那么有限在对象中找，自己没有在在类中找
#如果该类的，所有的由这个类产生的对象都被更改，
#但是在类和对象的名称空间外部的名称空间，比如全局名称空间，就无法查找。
#属性就两种：类的属性，对象的属性
#类内部的函数，绑定方法的那种一定要穿self参数。
########################################继承###################################
# 继承的功能：
# 1、减少类之间的代码重复
# 2、继承是类和类之间的关系，是什么是什么的关系、：人是动物，人的类和动物的类就是一种继承的关系
# 3、派生出的子类，以自己的属性为准
# 4、在子类派生出来的新的属性，可以这一指名道姓的调用父类的方法
# OldboyStudent.__init__(),这种方式本身和继承没有关系，只是调用了一个函数的功能而已，即时没有继承个关系，也可以这样使用
##################################组合####################################
#组合：
# 当一个对象有多个属性来自多个类的时候使用组合的方式，精髓在于定一个了一个空列表，然后
#使用了一个新的类去生成了一个对象，把这个对象追加进那个空雷列表中，组合的使用场景是谁有谁的关系。
######################################################################
#1、 集成的原理：类1调用了类2，类2集成了类3 类1还集成了类4，类4上边还有类，这样类1的属性的查找顺序
#是从左边开始找，类2中没有，去类2 的父类中去找，然后从右边在找，没找一根，把这个全部找完
#然后在去别的地方找。
# 可恶的菱形问题，类1调用了类2 类3 类4 ， 2 3 4 都调用的5，这时候先去2 3 4 中找，没有的话再去5中找
# 如果 2 3 4上还有一层，就先把这一根找完，再找其他的。这是经典类，新式类是先找一层，然后在找另外一层。
#查看类的调用关系MRO列表
OldboyStudent.mro()#存的就是调用关系
#############################子类调用父类################################
# 子类中调用父类的方法
#1、指名道姓
#2、super
# sum()._init_调用父类的方法，指名道姓的放吧要传self，但是super不用
################################绑定和非绑定#################################
# 绑定方法和非绑定方法，上边说的绑定方法是绑定给对象，那么能够绑定给类吗？
#绑定给谁，就是是谁来调用，谁调用就是要hi把谁当作第一个参数穿进去
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
coon=Mysql(‘127.0.0.1‘,‘3306‘)
#从配置文件中读取参数
import settings
class Mysql:
    def __init__(self,host,port):
        self.host=host
        self.port=port
    @classmethod#有了这个，当类在调用的时候，会把类当作参数穿进去，对象也可以调用，但是传的就是对象了
    def from_conf(cls):
        return cls(settings.HOST,settings.PORT)
coon=Mysql(‘127.0.0.1‘,‘3306‘)
@staticmethod #和谁都不绑定
def liu():
    return  str(hhh)
#这样就是在类中定义了一个普通的函数