Python 面向对象编程进阶

组合

class SchoolMember(object):
    def __init__(self,addr,tel):
        self.name = addr
        self.age = tel
    def tell(self):
        pass
class Student(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        print("Student :",self.name,self.age,self.sex)

class Teacher(SchoolMember):
    def __init__(self,addr,tel,student_obj): #
        super(Teacher,self).__init__(addr,tel)
        self.salary = addr
        self.coures = tel
        self.school_obj = student_obj

school = SchoolMember("北京",13800000000)
student = Student("alex",33,"MF")
teacher = Teacher("北京",13800000000,student)

print(teacher.school_obj.name)
teacher.school_obj.tell()

静态方法

只是名义上归类管理，实际上在静态方法里访问不了类或实例中的任何属性

通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法，什么是静态方法呢？其实不难理解，普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法

class Dog(object):
    def __init__(self,name):
        self.name = name
    @staticmethod   #实际上跟类没什么关系了
    def eat(self):
        print("%s is eating %s" %(self.name,"bb"))

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

类方法　　

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是， 类方法只能访问类变量，不能访问实例变量

class Dog(object):
    n = 333
    def __init__(self,name):
        self.name = name
    #@staticmethod   #实际上跟类没什么关系了
    @classmethod
    def eat(self):
        print("%s is eating %s" %(self.n,"bb"))

    def talk(self):
        print("%s is talking" %self.name)
d = Dog("aa")
d.eat()

属性方法　　

　属性方法的作用就是通过@property把一个方法变成一个静态属性

class Dog(object):
    n = 333
    def __init__(self,name):
        self.name = name
        self.__food = None
    @property       #@attribute
    def eat(self):
        print("%s is eating %s" %(self.name,self.__food))
    @eat.setter
    def eat(self,food):
        print("set to food:",food)
        self.__food = food
    @eat.deleter
    def eat(self):
        del self.__food
        print("删完了")
    def talk(self):
        print("%s is talking" %self.name)
d = Dog("aa")
d.eat="bb"
d.eat
del d.eat

类的特殊成员方法

1. __doc__　　表示类的描述信息

class Foo:
    """ 描述类信息"""

    def func(self):
        pass

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

　　

2. __module__ 和  __class__ 

　　__module__ 表示当前操作的对象在那个模块

　　__class__     表示当前操作的对象的类是什么

3. __init__ 构造方法，通过类创建对象时，自动触发执行。

4.__del__

　析构方法，当对象在内存中被释放时，自动触发执行。

5. __call__ 对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

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

print(Dog.__dict__) #打印类里的所有属性，不包括实例变量

print(d.__dict__)　  #打印类里的实例变量，不包括类属性

class Dog(object):
    '''sadf asdf '''
    n = 333
    def __init__(self,name):
        self.name = name
        self.__food = None
    #@staticmethod   #实际上跟类没什么关系了
    #@classmethod
    @property       #@attribute
    def eat(self):
        print("%s is eating %s" %(self.name,self.__food))
    @eat.setter
    def eat(self,food):
        print("set to food:",food)
        self.__food = food
    @eat.deleter
    def eat(self):
        del self.__food
        print("删完了")
    def talk(self):
        print("%s is talking" %self.name)
d = Dog("aa")

print(Dog.__dict__)
print(d.__dict__)
#输出
{'__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>, 'n': 333, '__doc__': 'sadf asdf ', '__module__': '__main__', '__init__': <function Dog.__init__ at 0x006AE300>, 'talk': <function Dog.talk at 0x006AE390>, 'eat': <property object at 0x006A6F90>}
#输出
{'name': 'aa', '_Dog__food': None}

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

class Foo:

    def __str__(self):
        return 'alex li'

obj = Foo()
print obj
# 输出：alex li

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'] = 'alex'   # 自动触发执行 __setitem__
del obj['k1']

　　

反射

hasattr(obj,name_str) #判断一个对象里是否有对应的name_str字符串的方法映射

getattr(obj,name_str) #根据字符串去获取obj对象里的对应的方法的内存地址

setattr(obj,"y",z),is equivalent(相当于) （to） ``x.y = v''

 

异常处理

try:
    print(info["aaa"])
except KeyError as e:
    print("位置错误")
except IndexError as e:
    print("biebiaocuowu",e)
except (IndexError,KeyError) as e:  #当两种错误，有统一的处理可以写一起
    print("统一错误",e)
except Exception as e:  #抓住所有错误 ，不建议用
    print("处错了",e)           #只能自己找
except Exception:         #位置错误,用在最后面，抓未知的错误
    print("未知错误")
else:       #没有错误时，执行这个
    print("一切正常")
finally:
    print("不管有没有错都执行")

自定义异常

class AlexException(Exception):
    def __init__(self,msg):
        self.message = msg
    def __str__(self):
        return self.message
try:
    raise AlexException ("我是异常")
except AlexException as e:
    print(e)

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

Socket 编程

• TCP服务端

1. 创建套接字，绑定套接字到本地IP与端口
2. 开始监听连接
3. 进入循环，不断接受客户端的连接请求
4. 然后接收传来的数据，并发送给对方数据
5. 传输完毕后，关闭套接字

• TCP客户端

1. 创建套接字，连接远端地址
2. 连接后发送数据和接收数据
3. 传输完毕后，关闭套接字
   

多个用户交互

 import socket
 server = socket.socket()
 server.bind(('localhost',6868))#绑定要监听的端口
 server.listen()#监听
 while True:
     print("我要开始等电话了")
     conn,addr = server.accept()#等待接收
     print(conn,addr)
     #conn就是客户端连过来而在服务器端为其生成的一个连接实例
     print("电话来了")
     while True:
         data = conn.recv(1024)
         print("recv:",data.dacode())
         if not data:
             print("client has lost...")
             break
         conn.send(data.upper())
 server.close()

服务器端

 import socket
 #客户端
 client = socket.socket()#声明socket类型，同时生成socket连接对象
 client.connect(('localhost',6868))
 while True:
     info_input = input(">>>请输入").strip()
     if len(info_input) == 0 :
         continue
     client.send(info_input.encode("utf-8"))#python3中只能传字节
     data = client.recv(1024)
     print("recv:",data.decode())
 client.close()

客户端

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