面向对象 - 元类/软件开发 - 总结

面向对象 - 元类:
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
posted @ 2018-03-12 17:44  Alice的小屋  阅读(205)  评论(0编辑  收藏  举报