Day7 - 面向对象高级语法

 1 class Flight(object):
 2     def __init__(self, name):
 3         self.flight_name = name
 4 
 5     def checking_status(self):
 6         print("checking flight %s status " % self.flight_name)
 7         return 1
 8 
 9     @property
10     def flight_status(self):
11         status = self.checking_status()
12         if status == 0:
13             print("flight got canceled...")
14         elif status == 1:
15             print("flight is arrived...")
16         elif status == 2:
17             print("flight has departured already...")
18         else:
19             print("cannot confirm the flight status...,please check later")
20 
21     @flight_status.setter  # 修改
22     def flight_status(self, status):
23         status_dic = {
24             0: "canceled",
25             1: "arrived",
26             2: "departured"
27         }
28         print("\033[31;1mHas changed the flight status to \033[0m", status_dic.get(status))
29 
30     @flight_status.deleter  # 删除
31     def flight_status(self):
32         print("status got removed...")
33 
34 
35 f = Flight("CA980")
36 f.flight_status
37 f.flight_status = 2  # 触发@flight_status.setter
38 del f.flight_status  # 触发@flight_status.deleter

1 class Dog(object):
2     ‘‘‘这个类是描述狗这个对象的‘‘‘
3 
4     def func(self):
5         pass
6 
7 print(Dog.__doc__)
8 
9 #输出：这个类是描述狗这个对象的

1 class C:
2 
3     def __init__(self):
4         self.name = ‘abc‘

1 from lib.aa import C
2 
3 obj = C()
4 print obj.__module__  # 输出 lib.aa，即：输出模块
5 print obj.__class__      # 输出<class ‘ lib.aa.C‘>，即：输出类

 1 class Foo(object):
 2     def __init__(self,name):
 3         self.name =name
 4         print(‘__init__‘)
 5 
 6     def __call__(self, *args, **kwargs):
 7         print(‘__call__‘)
 8 
 9 
10 obj = Foo(‘abc‘)     # 执行 __init__
11 #输出：__init__
12 obj()              # 执行 __call__
13 #输出：__call__
14 Foo(‘abc‘)()        # 执行 __call__    
15 #输出：__init__、__call__

 1 class Province(object):
 2     country = ‘China‘
 3 
 4     def __init__(self, name, count):
 5         self.name = name
 6         self.count = count
 7 
 8     def func(self, *args, **kwargs):
 9         print(‘func‘)
10 
11 # 获取类的所有属性，不包括实例属性，即：公有属性(静态字段)、方法
12 print(Province.__dict__)
13 # 输出：{‘func‘: <function Province.func at 0x000001A21E77EC80>, ‘__dict__‘: <attribute ‘__dict__‘ of ‘Province‘ objects>, ‘country‘: ‘China‘, ‘__weakref__‘: <attribute ‘__weakref__‘ of ‘Province‘ objects>, ‘__init__‘: <function Province.__init__ at 0x000001A21E77EBF8>, ‘__doc__‘: None, ‘__module__‘: ‘__main__‘}
14 
15 obj1 = Province(‘HeBei‘, 10000)
16 obj1.func()
17 # 获取实例 obj1 的所有属性，不包括类属性
18 print(obj1.__dict__)
19 # 输出：{‘count‘: 10000, ‘name‘: ‘HeBei‘}
20 
21 obj2 = Province(‘HeNan‘, 3888)
22 obj2.func()
23 print(obj2.__dict__)
24 # 获取 对象 obj2 的成员
25 # 输出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}

1 class Foo(object):
2     def __str__(self):
3         return "__str__"
4 
5 obj = Foo()
6 print(obj)
7 # 输出：__str__

 1 __author__ = "Alex Li"
 2 
 3 
 4 class Foo(object):
 5     def __init__(self):
 6         self.data = {}
 7     def __getitem__(self, key): #获取
 8         print(‘__getitem__‘, key)
 9         return self.data.get(key)
10     def __setitem__(self, key, value):  #设置
11         print(‘__setitem__‘, key, value)
12         self.data[key] =value
13     def __delitem__(self, key): #删除
14         print(‘__delitem__‘, key)
15 
16 obj = Foo()
17 obj[‘name‘] = "abc"          # 自动触发执行 __setitem__
18 print(obj[‘name‘])  #输出：abc
19 print(obj.data)     #输出：{‘name‘: ‘abc‘}
20 del obj["sdfdsf"]           # 自动触发执行 __delitem__,删没删除看 __delitem__ 方法里有没有删除
21 result = obj[‘name‘]        # 自动触发执行 __getitem__
22 print(result)       #输出：abc
23 obj[‘k2‘] = ‘abc‘           # 自动触发执行 __setitem__
24 del obj[‘k1‘]
25 print(obj[‘name‘])  #输出：abc
26 print(obj.data)     #输出：{‘name‘: ‘abc‘, ‘k2‘: ‘abc‘}

1 class Foo(object):
2     def __init__(self, name):
3         self.name = name
4 
5 f = Foo("abc")

 1 def func(self):
 2     print(‘hello %s‘ %self.name)
 3 
 4 def __init__(self,name,age):
 5     self.name = name
 6     self.age = age
 7 # type --> 类的类
 8 Foo = type(‘Foo‘, (object,), {‘talk‘: func,
 9                        ‘__init__‘:__init__})
10 f = Foo("world",22)
11 f.talk()            #输出：hello world
12 print(type(f))      #输出：<class ‘__main__.Foo‘>
13 print(type(Foo))    #输出：<class ‘type‘>

 1 class MyType(type):
 2     def __init__(self, what, bases=None, dict=None):
 3         print("MyType __init__")
 4         super(MyType, self).__init__(what, bases, dict)
 5 
 6     def __call__(self, *args, **kwargs):
 7         print("MyType __call__")
 8         obj = self.__new__(self, *args, **kwargs)
 9         #obj.data = {"name":111}
10         self.__init__(obj, *args, **kwargs)
11 
12 class Foo(object):
13     __metaclass__ = MyType  #元类：__metaclass__，跟 MyType 关联
14 
15     def __init__(self, name):
16         self.name = name
17         print("Foo __init__")
18 
19     def __new__(cls, *args, **kwargs):  #用来创建实例的
20         print("Foo __new__")
21         #print(object.__new__(cls))
22         return object.__new__(cls) #继承父类的__new__方法，一定要用 return
23 
24 # 第一阶段：解释器从上到下执行代码创建Foo类
25 # 第二阶段：通过Foo类创建obj对象
26 # 类的生成调用顺序依次是 __new__ --> __init__ --> __call__
27 obj = Foo("Alex")
28 print(obj.name)