#你写代码时什么使用面向对象

        #处理比较复杂的角色之间的关系

        #例如QQ好友和陌生人,淘宝卖家买家商品,公司学校的人事管理

    #代码的清晰度更高,无论是开发者调用者都能明确分辨自己的方法

    #代码有可拓展性,可读性,复用性

#类型和类的关系

    #类型和自定义类的关系,类型和类是一个东西

    #type(obj) obj是一个对象,他的type就是类型

#怎么创建一个类

    #class 类名  语法级别的python解释器读到这句话时

    #类也是被创建出来的,type创建类,type(cls)=type

#type(obj)的结果就是这个对象所属的类

#type(类)的结果就是创建这个类的元类,大多数情况下就是type除非你指定metaclass

#类:直接加载进去了,不像函数调用才加载

    #静态属性/字段/变量

    #动态属性/方法

#python一切皆对象

    #基础数据类型都是对象

#怎么创建一个对象

    #类名() 实例化

    #__new__()创造一个对象的空间,一些简单的初始化

#对象

    #可以通过指针找到类的空间中的内容

    #对象本身储存了一些只属于对象的属性

    #类创建对象的过程就是实例化的过程

#组合: 什么有什么的关系

    #一个对象作为另一个对象的属性

#继承:什么是什么的关系

    #单继承/多继承

        #单继承:如果子类的对象调用某个方法,子类有调子类,子类没有找父类,一直找,到object为止然后报错

        #子类有还想调父类:

            #super(子类,self).方法名(除了self以外的参数)

            #父类名:父类名.方法名(self)

        #在任何类中调用的方法,都要自行分辩一些self是谁的对象?

        #多继承:新式类默认继承object,py3都是新式类.经典类不继承object

    #经典类,新式类

        #新式:广度优先,c3算法

            #mro方法看继承顺序

            #super().func()类的内部不用传子类名和self

        #经典:深度优先

            #没有mro

            #super(子类名,self).func()必须传子类名和Self

    #子类和父类:节省代码

#抽象类和接口类

        #不能被实例化

        #规范子类当中必须实现某个方法

        #有原生实现抽象类的方法,但没有原生实现接口类的方法

        #java只支持单继承 父类的方法可以实现

        #java里,接口interface是支持多继承的规范,接口里的所有方法只能写pass

        #也就是说抽象类就是单继承,接口类是多继承,这主要出现在java里

#鸭子类型:

    #例如有序列index特点的类,那么说这些类都是鸭子类型

#多态:处处是多态

    #一种类型的多种形态 多个子类去继承父类,那么每个子类都是这个父类的一种形态

    #java

        # def func(int arg1,str arg2)#对于java来说,传入对象需要有类型

        #如果不知道传什么类,可以创建一个共同的父类,把父类传进来.这就是java里多态的应用

    #python

        #因为所有的对象的类都有object类,可以说object类是所有的父类,所以说py里处处是多态

#封装

    #广义的封装:把方法属性封装在一个类里,定义一个规范来描述一类事物

    #狭义的封装:私有化 只能在类的内部访问

    #__静态变量,私有方法,私有对象属性,私有类方法,私有静态方法

    #内存中存储__类名__名字

    #为什么在类的内部可以使用双下划线访问?在类的内部使用,你就知道在哪个类中

    #在子类中可以访问父类的私有变量吗?不行!不能被继承

#装饰器函数之property

    #他是内置函数,能帮你将类中的方法伪装成属性,特性!

    # 调用方法的时候不需要主动加括号,让程序的逻辑性更合理

    #@方法名.setter 装饰器,修改被property装饰的属性的时候会调用被这个装饰器装饰的方法,除了self参数外还有一个值是修改的参数

    #@方法名.deleter装饰器,当要删除被property装饰的属性的时候会调用被这个装饰器装饰的方法

#一个计算圆的例子

class Circle:

    def __init__(self,r):

        self.r=r

    @property

    def area(self):#这个方法计算结果本身就是一个属性,但这个属性会随着类/对象的基本变化而变化

        return 3.14*self.r**2

c=Circle(5)

print(c.area)

#类方法的装饰器,也是内置函数  classmethod

    #不用对象命名空间的内容,而用到了类命名空间的变量(静态属性),或类方法类属性

    #使用类名调用,默认传类名做第一个参数

#staticmethod静态方法的装饰器 内置函数

#如果一个类的方法,既不需要用到self里的资源,也不用cls资源,相当于一个普通函数.但基于某个原因,仍要把方法放到类里,这时就需要将方法变成静态方法

    #你完全想用面向对象编程,所有的函数都必须写到类里

    #某个功能确确实实是这个类的方法,确确实实没有用到与这个类有关的资源

#例如学生和管理员都需要登陆,又不想占用学生和管理员的资源

class Person:

    @staticmethod

    def login():

        pass

class Student(Person):pass

class Manager(Person):pass

#反射:从某个指定的命名空间里,用字符串数据类型的变量名来获取变量的值

#类名反射 静态属性 类方法 静态方法

#对象方式 对象属性 方法

#模块 模块中的方法

#自己模块的反射,例如(此处不完整,需要等到模块部分的补充)

 import  sys

 mymodoule=sys.modules['__main__']

 getattr(mymodoule,'变量名')

#hasattr/getattr/setattr/delattr

#参数

    #(命名空间,'变量名')

    #setattr(命名空间,'变量名'新的值)

#变量名 你只能拿到一个字符串的版本

    #从文件里拿

    #交互拿:input/网络传输

#内置方法/魔术方法/双下方法

#__名字__ 不能直接调用

#通过内置函数/面向对象中的特殊语法/python提供的语法糖调用

#简化了语法的语法操作就是语法糖

#__call__ 在类写装饰器时必须用

#__new__ 在实例化过程中,最先执行的方法,在init之前,创造对象.使用new可以创建单例类

#__init__在实例化中,new执行之后

#__len__要求obj必须实现__len__方法,要求这个方法的返回值必须是int

#__str__要求必须实现了__str__,要求这个方法返回值必须是str

#双下repr方法:是__str__的备胎,如果有str就会先执行str,并且使用str返回值.如果没有__str__,那么所有的这些都会执行__repr__

    # 对应repr(obj),%r.

class A:

    def __init__(self,name):

        self.name=name

    def __repr__(self):

        return self.name

    def __str__(self):

        return '**%s**self.name'

a=A('Alex')

print(a)

print(str(a),repr(a))

#析构方法:释放空间

 class File():

     def __init__(self,file_path):

         self.f=open(file_path)

     def read(self):

         self.f.read(1024)

     def __del__(self):

         self.f.close()#析构方法,释放创建对象时的一些资源

f=File('文件名')

 f.read()

#python内部的指令可以被垃圾回收机制执行,但有些情况不行,所以得手动

#close可以理解是关闭python,而del是释放操作系统资源.因为py没权力管系统

#不管主动被动,这个f总被清掉,被清掉就触发__del__,触发就会归还操作系统资源

#这里代码让其先手动触发del,在自动执行垃圾回收,是防止垃圾回收不完全导致有资源没有被清理,容易出错

#某对象借用操作系统资源,还要通过析构方法归还回去.包括文件资源,网络资源

#with close比open close要不稳定,with不能100%处理异常