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''

import sys
cc = sys.modules['__main__']    # 查看自己的模块
def af():
    print("af_1111")
def bf():
    print("bf_2222")
name = "jack"

while True:
    aa = input(">>>:")
    if hasattr(cc,aa):
        func = getattr(cc,aa)
        # print(func)   # 反射自己模块中的变量
        # func()        # 反射自己模块中的函数

class Teacher(object):
    aa=[("查看学生信息",'show_student'),('查看讲师信息','show_teacher')]
    def show_student(self):
        print("show_student_11")
    def show_teacher(self):
        print("show_teacher_22")
    @classmethod
    def func(cls):
        print("hahah")
while True:
    abc = Teacher()
    for i in Teacher.aa:
        print(str(Teacher.aa.index(i))+".",i[0])
    aa2 = input(">>>:")
    if aa2.isdigit():
        aa2 = int(aa2)
    else:
        print("""请输入整数""")
        continue
    if hasattr(abc,Teacher.aa[aa2][1]):
        func = getattr(abc,Teacher.aa[aa2][1])
        func()
        break


class cc:
    dd = {"1":"fc","2":"fa"}
    def fc(self):
        print("fc_1111")
    def fa(self):
        print("fa_222")
    @classmethod
    def ff(cls):
        print("没有这个参数")
cab = cc()
cccc = input(">>:")
print(type(cccc))

if hasattr(cab,cc.dd[cccc]):
    fun = getattr(cab,cc.dd[cccc])
    fun()
else:
    fun = setattr(cab,cc[cccc],cc.ff)
    fun()

class cc:
    dd = {"1":"fc","2":"fa"}
    def fc(self):
        print("fc_1111")
    def fa(self):
        print("fa_222")
    @classmethod
    def ff(cls):
        print("没有这个参数")
cab = cc()
cccc = input(">>:")

if hasattr(cab,cc.dd[cccc]):
    fun = getattr(cab,cc.dd[cccc])
    fun()
else:
    fun = setattr(cab,cc[cccc],cc.ff)
    fun()

异常处理

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