zoukankan      html  css  js  c++  java
  • 面向对象

    面向对象 - 元类:
    python 一切皆对象 # 类也是对象
    意义:1.可以被引用 2.可以当作函数的参数传入 3.可以当作函数的返回值 4.可以当作容器类的元素
    1.元类:
    类的类就叫元类 type
    class 定义的类 元类就是 type type(Foo) == <class 'type'>
    元类(type)--》实例化--》类(class)--》实例化--》对象
    2.定义类的两种方式:
    1.class 关键字得方式 class Foo: ...
    2.type 元类 定义类得三要素:类名,类的基类们,类得名称空间
    Chinese1=type(class_name,class_bases,class_dic)
    3.自定义元类的作用:
    1.控制类得行为:
    def __init__(self,class_name,class_bases,class_dic)
    能得到 类名,基类,类体 -- 可操作 限制类名 类体 等操作
    class Chinese(object,metaclass=Mymeta)-->过程:先到元类__init__()走一遍
    2.控制类得实例化:
    def __call__(self, *args, **kwargs):
    能得到 对象的属性
    1.造空对象 2.初始化obj(里面调用__init__()) 3.返回obj
    obj=object.__new__(self)
    self.__init__(obj,*args,**kwargs)
    return obj
    obj=Chinese('alice',12)-->过程: 先到元类__call__()走一遍
    4.自定义元类的应用:
    单例模式? eg:obj1=int(1) obj2=int(1) obj1 is obj2 == True 多个对象使用同一块内存 "优化策略"
    单例模式的实现方式:
    1.绑定给类的绑定方法:
    __instance=None
    @classmethod
    def singleton(cls):
    if not cls.__instance:
    obj=cls()
    cls.__instance=obj
    return cls.__instance
    2.利用元类实现:
    class Mymeta(type):
    def __init__(self,class_name,class_bases,class_dic):
    super().__init__(class_name,class_bases,class_dic)
    self.__instance=None

    def __call__(self, *args, **kwargs):
    if not self.__instance:
    obj = object.__new__(self)
    self.__init__(obj)
    self.__instance=obj
    return self.__instance

      1 # class Foo:
      2 #     pass
      3 # f=Foo()
      4 # print(type(f))
      5 # print(type(Foo))
      6 
      7 # g={'x':1,'y':2}
      8 # l={}
      9 # exec("""
     10 # global x,m
     11 # x=10
     12 # m=100
     13 # z=3
     14 # """,g,l)
     15 # print(g)
     16 # print(l)
     17 # -------------------------
     18 # 产生类得第一种方式:
     19 class Chinese:
     20     country='China'
     21     def __init__(self,name,age):
     22         self.name=name
     23         self.age=age
     24 
     25     def talk(self):
     26         print('%s is talking'%self.name)
     27 
     28 # obj=Chinese('alice',12)
     29 # obj.talk()
     30 # print(obj.name,obj.age)
     31 
     32 #产生类得第二种方式:
     33 class_name='Chinese'
     34 class_base=(object,)
     35 class_body="""
     36 country='China'
     37 def __init__(self,name,age):
     38     self.name=name
     39     self.age=age
     40 
     41 def talk(self):
     42     print('%s is talking'%self.name)
     43 """
     44 # class_dic={}
     45 # exec(class_body,globals(),class_dic)
     46 # # print(class_dic)
     47 # ch = type(class_name,class_base,class_dic)
     48 # obj1=ch('alice',12)
     49 # print(obj1.__dict__)
     50 # print(ch.__dict__)
     51 # print(ch)
     52 # print(obj1,obj1.name,obj1.age)
     53 
     54 #自定义元类 控制类的行为:
     55 class Mymeta(type):  #元类
     56     # print('--1--')
     57     def __init__(self,class_name,class_bases,class_dic):   # 控制类的创建
     58         # print(class_name)
     59         # print(class_bases)
     60         # print(class_dic)
     61         if not class_name.istitle():
     62             raise TypeError('类名的首字母必须大写')
     63         if '__doc__' not in class_dic or not class_dic['__doc__'].strip():
     64             raise TypeError('必须有注释,且注释不能为空')
     65 
     66         super(Mymeta, self).__init__(class_name,class_bases,class_dic)
     67 
     68     def __call__(self, *args, **kwargs):  # 控制类的实例化
     69         # print(self)
     70         # print(args)
     71         # print(kwargs)
     72         obj=object.__new__(self)           #1.造空对象
     73         self.__init__(obj,*args,**kwargs)  #2.初始化obj
     74         return obj                        #返回obj
     75 
     76 
     77 class Chinese(object,metaclass=Mymeta):
     78     '''
     79     中文人的类
     80     '''
     81     country='China'
     82     def __init__(self,name,age):
     83         print('--2--')
     84         self.name=name
     85         self.age=age
     86 
     87     def talk(self):
     88         print('%s is talking'%self.name)
     89 
     90     def __call__(self, *args, **kwargs):
     91         print(self)
     92         print(args)
     93         print(kwargs)
     94 
     95 
     96 # obj=Chinese('alice',12)   # 触发它的类的 __call__() 元类
     97 # obj(1,2,3,a=1,b=2)    # 触发它的类的 __call__()  Chinese
     98 # print(obj.__dict__)
     99 # print(Chinese.__dict__)
    100 #
    101 # print(type(Chinese))
    102 # Chinese=Mymeta(class_name,class_bases,class_dir)
    103 # print(obj.__dict__)
    104 
    105 #自定义元类的应用:
    106 
    107 # obj1=int(1)
    108 # obj2=int(1)
    109 # print(id(obj1))
    110 # print(id(obj2))
    111 # print(obj1 is obj2)  # 实现了单例模式 参数相同 多个对象 使用同一块内存 是一种优化策略
    112 
    113 # 单例模式 实现方式一:
    114 
    115 class Mymeta(type):
    116     def __init__(self,class_name,class_bases,class_dic):
    117         super().__init__(class_name,class_bases,class_dic)
    118         self.__instance=None
    119 
    120     def __call__(self, *args, **kwargs):
    121         if not self.__instance:
    122             obj = object.__new__(self)
    123             self.__init__(obj)
    124             self.__instance=obj
    125         return self.__instance
    126 
    127 
    128 
    129 class Mysql(object,metaclass=Mymeta):
    130     # __instance=None
    131     def __init__(self):
    132         self.host='127.0.0.1'
    133         self.port=3306
    134 
    135     # @classmethod
    136     # def singleton(cls):
    137     #     if not cls.__instance:
    138     #         obj=cls()
    139     #         cls.__instance=obj
    140     #     return cls.__instance
    141 
    142     def conn(self):
    143         pass
    144 
    145     def execute(self):
    146         pass
    147 
    148 # obj1=Mysql()
    149 # obj2=Mysql()
    150 # print(obj2.__dict__)
    151 # print(id(obj1))
    152 # print(id(obj2))
    153 
    154 # obj1=Mysql.singleton()
    155 # obj2=Mysql.singleton()
    156 # # print(obj1.__dict__)
    157 # print(id(obj1))
    158 # print(id(obj2))
    159 
    160 # obj1=Mysql()
    161 # obj2=Mysql()
    162 # print(id(obj1))
    163 # print(id(obj2))
    元类

    面向对象 - 软件开发:
    1.软件的开发其实一整套规范,我们所学的只是其中的一小部分,一个完整的开发过程,需要明确每个阶段的任务,
    在保证一个阶段正确的前提下再进行下一个阶段的工作,称之为软件工程
    2.面向对象的软件工程包括下面几个部分:
    1.面向对象分析(object oriented analysis ,OOA)
    2 面向对象设计(object oriented design,OOD)
    3 面向对象编程(object oriented programming,OOP)
    4 面向对象测试(object oriented test,OOT)
    5 面向对象维护(object oriendted soft maintenance,OOSM)
    3.面向对象实战 参考
    http://www.cnblogs.com/linhaifeng/articles/6182264.html
    http://www.cnblogs.com/linhaifeng/articles/7341318.html
  • 相关阅读:
    IO复用(较详细)
    关于CGI 和 PHP-FPM需要弄清的
    php内核一些常识
    python搭建web服务
    瓶颈分析
    分布式系统
    vmdk多文件合成单文件并导入
    用户登录自动调用修改网络信息脚本
    strace命令用法
    使用Nginx反向代理Docker的Asp.Net Core项目的请求
  • 原文地址:https://www.cnblogs.com/alice-bj/p/8550600.html
Copyright © 2011-2022 走看看