面向对象 类

  1 #__author:  Administrator
  2 #date:  2016/9/23
  3 """
  4 class Foo:
  5 
  6     def __init__(self, name, age):
  7         self.name = name
  8         # self.age = age
  9         self.__age = age # 私有，外部无法直接访问
 10 
 11     def show(self):
 12         return self.__age
 13 
 14 
 15 obj = Foo(‘alex‘, 19)
 16 print(obj.name)
 17 # obj.age
 18 # print(obj.__age)
 19 ret = obj.show()
 20 print(ret)
 21 """
 22 
 23 """
 24 class Foo:
 25     __v = ‘123‘
 26 
 27     def __init__(self):
 28         pass
 29     def show(self):
 30         return Foo.__v
 31     @staticmethod
 32     def stat():
 33         return Foo.__v
 34 # print(Foo.__v)
 35 # ret = Foo().show()
 36 # print(ret)
 37 
 38 ret = Foo.stat()
 39 print(ret)
 40 """
 41 """
 42 class Foo:
 43     def __f1(self):
 44         return 123
 45 
 46     def f2(self):
 47         r = self.__f1()
 48         return r
 49 
 50 obj = Foo()
 51 ret = obj.f2()
 52 print(ret)
 53 """
 54 
 55 """
 56 class F:
 57     def __init__(self):
 58         self.ge = 123
 59         self.__gene = 123
 60 
 61 class S(F):
 62     def __init__(self,name):
 63         self.name = name
 64         self.__age = 18
 65         super(S, self).__init__()
 66 
 67     def show(self):
 68         print(self.name)
 69         print(self.__age)
 70         print(self.ge)
 71         print(self.__gene)
 72 
 73 s = S(‘alex‘)
 74 s.show()
 75 """
 76 
 77 """
 78 class Foo:
 79     def __init__(self):
 80         print(‘init‘)
 81 
 82     def __call__(self, *args, **kwargs):
 83         print(‘call‘)
 84 
 85 # obj = Foo()
 86 # obj()
 87 Foo()()
 88 """
 89 # s = "123"
 90 # # s = str(‘123‘)
 91 #
 92 # i = int(s)
 93 # print(i,type(i))
 94 
 95 """
 96 class Foo:
 97 
 98     def __init__(self):
 99         pass
100 
101     def __int__(self):
102         return 1111
103 
104     def __str__(self):
105         return ‘alex‘
106 
107 obj = Foo()
108 print(obj, type(obj))
109 
110 # int,对象，自动执行对象的 __int__方法，并将返回值赋值给int对象
111 r = int(obj)
112 print(r)
113 i = str(obj)
114 print(i)
115 
116 """
117 """
118 class Foo:
119 
120     def __init__(self,n,a):
121         self.name =n
122         self.age =a
123 
124     def __str__(self):
125         return ‘%s-%s‘ %(self.name,self.age,)
126 
127 obj = Foo(‘alex‘, 18)
128 print(obj) #print(str(obj)) str(obj)   obj中__str__，并获取其返回值
129 """
130 """
131 class Foo:
132 
133     def __init__(self, name,age):
134         self.name = name
135         self.age = age
136 
137     def __add__(self, other):
138         # self = obj1 (alex,19)
139         # other = obj2(eric,66)
140         # return self.age + other.age
141         #return Foo(‘tt‘,99)
142         return Foo(obj1.name, other.age)
143 
144     def __del__(self):
145         print(‘析构方法‘) # 对象被销毁（）时，自动执行
146 
147 obj1 = Foo(‘alex‘, 19)
148 obj2 = Foo(‘eirc‘, 66)
149 
150 r = obj1 + obj2
151 # 两个对象相加时，自动执行第一个对象的的 __add__方法，并且将第二个对象当作参数传递进入
152 print(r,type(r))
153 """
154 
155 
156 """
157 class Foo:
158     def __init__(self, name,age):
159         self.name = name
160         self.age = age
161         self.n = 123
162 
163 # obj = Foo(‘alex‘, 18)
164 #
165 # d = obj.__dict__
166 # print(d)
167 
168 # ret = Foo.__dict__
169 # print(ret)
170 """
171 
172 # li = [11,22,33,44]
173 # li = list([11,22,33,44])
174 #
175 # li[3]
176 # #
177 #
178 # li[3] = 666
179 #
180 # del li[2]
181 
182 """
183 class Foo:
184 
185     def __init__(self, name,age):
186         self.name = name
187         self.age = age
188 
189     def __getitem__(self, item):
190         return item+10
191 
192     def __setitem__(self, key, value):
193         print(key,value)
194 
195     def __delitem__(self, key):
196         print(key)
197 li = Foo(‘alex‘, 18)
198 r= li[8] # 自动执行li对象的类中的 __getitem__方法，8当作参数传递给item
199 print(r)
200 
201 li[100] = "asdf"
202 
203 del li[999]
204 """
205 """
206 class Foo:
207 
208     def __init__(self, name,age):
209         self.name = name
210         self.age = age
211 
212     def __getitem__(self, item):
213         # return item+10
214         # 如果item是基本类型：int，str，索引获取
215         # slice对象的话，切片
216         if type(item) == slice:
217             print(‘调用这希望内部做切片处理‘)
218         else:
219             print(item.start)
220             print(item.stop)
221             print(item.step)
222             print(‘调用这希望内部做索引处理‘)
223 
224     def __setitem__(self, key, value):
225         print(key,value)
226 
227     def __delitem__(self, key):
228         print(key)
229 
230 li = Foo(‘alex‘, 18)
231 li[123]
232 li[1:4:2]
233 
234 li[1:3] = [11,22]
235 
236 del li[1:3]
237 
238 # class Slice:
239 #     def __init__(self,a,b,c):
240 #         self.start = a
241 #         self.end = b
242 #         self.step = c
243 # obj = Slice(1,4,2)
244 # li[999] = "alex"
245 #
246 # del li[234]
247 """
248 """
249 class Foo:
250 
251     def __init__(self, name,age):
252         self.name = name
253         self.age = age
254 
255     def __iter__(self):
256         return iter([11,22,33])
257 li = Foo(‘alex‘, 18)
258 # 如果类中有 __iter__ 方法，对象=》可迭代对象
259 # 对象.__iter__() 的返回值： 迭代器
260 # for 循环，迭代器，next
261 # for 循环，可迭代对象，对象.__iter__()，迭代器，next
262 # 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
263 # 2、循环上一步中返回的对象
264 for i in li:
265     print(i)
266 """
267 # li = [11,22,33,44]
268 # li= list([11,22,33,44])
269 # for item in li:
270 #     print(item)
271 
272 """
273 class MyType(type):
274     def __init__(self,*args, **kwargs):
275         # self=Foo
276         print(123)
277         pass
278 
279     def __call__(self, *args, **kwargs):
280         # self=Foo
281         r = self.__new__()
282 
283 
284 #
285 
286 class Foo(object,metaclass=MyType):
287     def __init__(self):
288         pass
289 
290     def __new__(cls, *args, **kwargs):
291         return ‘对象‘
292 
293     def func(self):
294         print(‘hello wupeiqi‘)
295 
296 obj = Foo()
297 
298 
299 
300 
301 
302 class Bar:
303     def __init__(self):
304         print(123)
305 
306 
307 obj = Bar()
308 """
309 
310 """
311 while True:
312     try:
313         # 代码块，逻辑
314         inp = input(‘请输入序号：‘)
315         i = int(inp)
316     except Exception as e:
317         # e是Exception对象，对象中封装了错误信息
318         # 上述代码块如果出错，自动执行当前块的内容
319         print(e)
320         i = 1
321     print(i)
322 """
323 #li = [11,22]
324 #li[999] # IndexError
325 # int(‘qwe‘) # ValueError
326 """
327 def fun():
328     ret = 0
329     try:
330         li = [11, 22]
331         li[1]
332         int(‘w3r‘)
333 
334     except IndexError as e:
335         print(‘IndexError‘,e)
336     except ValueError as e:
337         print(‘ValueError‘,e)
338     except Exception as e:
339         print(‘Exception‘,e)
340     else:
341         ret = 1
342         print(‘elese‘)
343     finally:
344         print(‘....‘)
345 
346     return ret
347 r = fun()
348 if r == 0:
349     print(‘500‘)
350 else:
351     pass
352 
353 """
354 """
355 class F:
356     def __init__(self):
357         self.__a = 132
358 
359     def show(self):
360         # print(self.__a)
361         return self.__a
362 
363 class S(F):
364     def __init__(self):
365         self.name = 123
366         super(S, self).__init__()
367 
368 obj = S()
369 r = obj.show()
370 print(r)
371 """
372 """
373 try:
374     # int(‘asdf‘)
375     # 主动出发异常
376     # raise Exception(‘不过了...‘)
377 except Exception as e:
378     print(e)
379 
380 def db():
381     # return True
382     return False
383 
384 def index():
385     try:
386         r = input(">>")
387         int(r)
388 
389 
390         result = db()
391         if not result:
392             r = open(‘log‘,‘a‘)
393             r.write(‘数据库处理错误‘)
394             # 打开文件，写日志
395             #raise Exception(‘数据库处理错误‘)
396     except Exception as e:
397         str_error = str(e)
398         print(str_error)
399         r = open(‘log‘, ‘a‘)
400         r.write(str_error)
401         # 打开文件，写日志
402 
403 index()
404 """
405 
406 
407 """
408 class OldBoyError(Exception):
409 
410     def __init__(self, msg):
411         self.message = msg
412 
413     def __str__(self):
414         return self.message
415 
416 # obj = OldBoyError(‘xxx‘)
417 # print(obj)
418 try:
419     raise OldBoyError(‘我错了...‘)
420 except OldBoyError as e:
421     print(e)# e对象的__str__()方法，获取返回
422 
423 """
424 
425 # assert 条件,断言，用于强制用户服从，不服从就报错，可补货，一般不补货
426 # print(23)
427 # assert 1==2
428 # print(456)
429 
430 
431 """
432 class Foo:
433     def __init__(self, name,age):
434         self.name = name
435         self.age = age
436 
437     def show(self):
438         return  "%s-%s " %(self.name,self.age)
439     def __int__(self):
440         return 123
441     def __str__(self):
442         return ‘uuu‘
443 obj = Foo(‘alex‘, 18)
444 
445 r = int(obj) # r = 123
446 u = str(obj)
447 b = ‘name‘
448 """
449 
450 
451 # getattr
452 # hasattr
453 # setattr
454 # delattr
455 # 通过字符串的形式操作对象中的成员
456 
457 # func = getattr(obj, ‘show‘)
458 # print(func)
459 # r = func()
460 # print(r)
461 
462 # print(hasattr(obj, ‘name‘))
463 # obj.k1
464 # setattr(obj, ‘k1‘, ‘v1‘)
465 # print(obj.k1)
466 # obj.name
467 # delattr(obj, ‘name‘)
468 # obj.name
469 
470 # 去什么东西里面获取什么内容
471 # inp = input(‘>>>‘)
472 # v = getattr(obj, inp)
473 # print(v)
474 
475 
476 
477 """
478 obj.name
479 b = "name"
480 obj.b # obj.name
481 """
482 # b = "name"
483 # obj.__dict__[‘name‘]
484 # obj.__dict__[b]
485 
486 # if b == ‘name‘:
487 #     obj.name
488 
489 
490 """
491 class Foo:
492 
493     stat = ‘123‘
494 
495     def __init__(self, name,age):
496         self.name = name
497         self.age = age
498 
499 # 通过字符串的形式操作对象中的成员
500 r = getattr(Foo, ‘stat‘)
501 print(r)
502 """
503 
504 """
505 import s2
506 
507 
508 # r1 = s2.NAME
509 # print(r1)
510 # r2 = s2.func()
511 # print(r2)
512 
513 r1 = getattr(s2, ‘NAME‘)
514 print(r1)
515 
516 r2 = getattr(s2, ‘func‘)
517 result = r2()
518 print(result)
519 
520 cls = getattr(s2, ‘Foo‘)
521 print(cls)
522 obj = cls()
523 print(obj)
524 print(obj.name)
525 """
526 """
527 import s2
528 inp = input(‘请输入要查看的URL：‘)
529 if hasattr(s2, inp):
530     func = getattr(s2, inp)
531     result = func()
532     print(result)
533 else:
534     print(‘404‘)
535 """
536 
537 # class Foo:
538 #     def __init__(self, name,age):
539 #         self.name = name
540 #         self.age = age
541 
542 # obj = Foo() # obj对象，obj也成为Foo类的 实例，（实例化）
543 # obj1 = Foo()
544 # obj2 = Foo()
545 # obj3 = Foo()
546 
547 # 单例，用于使用同一份实例（对象）
548 """
549 class Foo:
550     def __init__(self, name,age):
551         self.name = name
552         self.age = age
553 
554     def show(self):
555         print(self.name,self.age)
556 
557 v = None
558 
559 while True:
560     if v:
561         v.show()
562     else:
563         v = Foo(‘alex‘, 123)
564         v.show()
565 """
566 class Foo:
567 
568     __v = None
569 
570     @classmethod
571     def get_instance(cls):
572         if cls.__v:
573             return cls.__v
574         else:
575             cls.__v = Foo()
576             return cls.__v
577 
578 # 不要在使用 类()
579 obj1 = Foo.get_instance()
580 print(obj1)
581 obj2 = Foo.get_instance()
582 print(obj2)
583 obj3 = Foo.get_instance()
584 print(obj3)