python之路，day7-面向对象变成

本篇内容：

　　面向对象、类方法、属性方法

　　类的特殊方法

　　反射

异常处理

Socket开发基础

一、面向对象高级语法部分

静态方法：

#@staticmethod只是名义上归类管理，实际上跟类没什么关系

class Dog(object):

    def __init__(self,name):
        self.name = name

    @staticmethod #把eat方法变为静态方法
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("user")
d.eat()

　　上面的调用会出以下错误，说是eat需要一个self参数，但调用时却没有传递，没错，当eat变成静态方法后，再通过实例调用时就不会自动把实例本身当作一个参数传给self了。

1. 调用时主动传递实例本身给eat方法，即d.eat(d)

2. 在eat方法中去掉self参数，但这也意味着，在eat中不能通过self.调用实例中的其它变量了

class Dog(object):

    def __init__(self,name):
        self.name = name

    @staticmethod
    def eat():
        print(" is eating")

d = Dog("user")
d.eat()

二、类方法

#@classmethod

只能访问类变量，不能访问实例变量

class Dog(object):
    name = "类变量"
    def __init__(self,name):
        self.name = name

    @classmethod
    def eat(self):
        print("%s is eating" % self.name)

d = Dog("user")
d.eat()

#执行结果：

类变量 is eating

三、属性方法

#@proprty 把一个方法变成一个静态属性
#@eat.setter 更改属性
#@eat.deleter 删除属性

class Dog(object):

    def __init__(self,name):
        self.name = name

    @property
    def eat(self):
        print(" %s is eating" %self.name)

d = Dog("user")
d.eat
#输出结果：
user is eating

列：

 class Flight(object):
     def __init__(self,name):
         self.flight_name = name

     def checking_status(self):
         print("checking flight %s status " % self.flight_name)
         return  1

     @property
     def flight_status(self):
         status = self.checking_status()
         if status == 0 :
             print("flight got canceled...")
         elif status == 1 :
             print("flight is arrived...")
         elif status == 2:
             print("flight has departured already...")
         else:
             print("cannot confirm the flight status...,please check later")

 f = Flight("CA980")
 f.flight_status

列2：@proerty.setter装饰器再装饰一下，需要写一个新方法， 对这个flight_status进行更改。

class Flight(object):
    def __init__(self,name):
        self.flight_name = name

    def checking_status(self):
        print("checking flight %s status " % self.flight_name)
        return  1

    @property
    def flight_status(self):
        status = self.checking_status()
        if status == 0 :
            print("flight got canceled...")
        elif status == 1 :
            print("flight is arrived...")
        elif status == 2:
            print("flight has departured already...")
        else:
            print("cannot confirm the flight status...,please check later")

    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
: "canceled",
:"arrived",
: "departured"
        }
        print("\033[31;1mHas changed the flight status to \033[0m",status_dic.get(status) )

    @flight_status.deleter  #删除
    def flight_status(self):
        print("status got removed...")

f = Flight("CA980")
f.flight_status
f.flight_status =  2 #触发@flight_status.setter
del f.flight_status #触发@flight_status.deleter

注意以上代码里还写了一个@flight_status.deleter, 是允许可以将这个属性删除

四：类的特殊成员

#类的特殊成员方法
1、__doc__ 表示类的描述信息

class Foo:
    """ 描述类信息，这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出：类的描述信息

2、__module__   表示从哪个模块导入的
   __class__ 表示当前操作的对象的类是

class C:

    def __init__(self):
        self.name = 'liudong'

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

3、__init__ 构造方法，通过类创建对象时，自动触发执行。
4、__del__
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的
5. __call__ 对象后面加括号，触发执行
注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class Foo:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):

        print '__call__'

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

6. __dict__ 查看类或对象中的所有成员

7.__str__ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:

    def __str__(self):
        return 'liudong'

obj = Foo()
print obj
# 输出：liudong

8.__getitem__、__setitem__、__delitem__

用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__',key)

    def __setitem__(self, key, value):
        print('__setitem__',key,value)

    def __delitem__(self, key):
        print('__delitem__',key)

obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'liudong'   # 自动触发执行 __setitem__
del obj['k1'] 

9. __new__ \ __metaclass__

class Foo(object):

    def __init__(self,name):
        self.name = name

f = Foo("liudong")

上述代码中，obj 是通过 Foo 类实例化的对象，其实，不仅 obj 是一个对象，Foo类本身也是一个对象，因为在Python中一切事物都是对象。

如果按照一切事物都是对象的理论：obj对象是通过执行Foo类的构造方法创建，那么Foo类对象应该也是通过执行某个类的 构造方法 创建。

print type(f) # 输出：<class '__main__.Foo'>     表示，obj 对象由Foo类创建
print type(Foo) # 输出：<type 'type'>              表示，Foo类对象由 type 类创建

所以，f对象是Foo类的一个实例，Foo类对象是 type 类的一个实例，即：Foo类对象 是通过type类的构造方法创建。

那么，创建类就可以有两种方式：

a)普通方法：

class Foo(object):

    def func(self):
        print 'hello liudong'

b)特殊方法：

def func(self):
    print 'hello liudong'

Foo = type('Foo',(object,), {'func': func})
#type第一个参数：类名
#type第二个参数：当前类的基类
#type第三个参数：类的成员

#加上构造方法：

def func(self):
    print("hello %s"%self.name)

def __init__(self,name,age):
    self.name = name
    self.age = age
Foo = type('Foo',(object,),{'func':func,'__init__':__init__})

f = Foo("liudong",22)
f.func()

那么问题来了，类默认是由 type 类实例化产生，type类中如何实现的创建类？类又是如何创建对象？

答：类中有一个属性 __metaclass__，其用来表示该类由 谁 来实例化创建，所以，我们可以为 __metaclass__ 设置一个type类的派生类，从而查看 类 创建的过程。

class MyType(type):

    def __init__(self, what, bases=None, dict=None):
        print("--MyType init---")
        super(MyType, self).__init__(what, bases, dict)

    def __call__(self, *args, **kwargs):
        print("--MyType call---")
        obj = self.__new__(self, *args, **kwargs)

        self.__init__(obj, *args, **kwargs)

class Foo(object):

    __metaclass__ = MyType

    def __init__(self, name):
        self.name = name
        print("Foo ---init__")

    def __new__(cls, *args, **kwargs):
        print("Foo --new--")
        return object.__new__(cls)

# 第一阶段：解释器从上到下执行代码创建Foo类
# 第二阶段：通过Foo类创建obj对象
obj = Foo("liudong")

metaclass 详解文章：http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python 得票最高那个答案写的非常好

五、 反射：

通过字符串映射或修改程序运行时的状态、属性、方法, 有以下4个方法

1、getattr(object, name, default=None)

def getattr(object, name, default=None): # known special case of getattr
    """
    getattr(object, name[, default]) -> value

    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
    When a default argument is given, it is returned when the attribute doesn't
    exist; without it, an exception is raised in that case.
    """
    pass

2、hasattr(object,name)

判断object中有没有一个name字符串对应的方法或属性

3、setattr(x, y, v)

def setattr(x, y, v): # real signature unknown; restored from __doc__
    """
    Sets the named attribute on the given object to the specified value.

    setattr(x, 'y', v) is equivalent to ``x.y = v''

4、delattr(x, y)

def delattr(x, y): # real signature unknown; restored from __doc__
    """
    Deletes the named attribute from the given object.

    delattr(x, 'y') is equivalent to ``del x.y''
    """

反射代码示例：

class Foo(object):
    def __init__(self):
        self.name='abc'
    def func(self):
        return 'func'
obj = Foo()

hasattr(obj,'name')
hasattr(obj,'finc')

getattr(obj,'name')
getattr(obj,'func')

setattr(obj,'liudong',18)
setattr(obj,'show',lambda num: num + 1)

delattr(obj,'name')
delattr(obj,'func')

动态导入模块：

import importlib

__import__('import_lib.metaclass') #这是解释器自己内部用的
#importlib.import_module('import_lib.metaclass') #与上面这句效果一样，官方建议用这个

六、异常处理：

参考 http://www.cnblogs.com/wupeiqi/articles/5017742.html

七、Socket编程：

参考：http://www.cnblogs.com/wupeiqi/articles/5040823.html