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服务端

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

TCP客户端

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

多个用户交互

 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

秒客网

Python 面向对象编程进阶

组合

静态方法

类方法

属性方法

类的特殊成员方法

1. doc　　表示类的描述信息

2. module 和 class

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

4.del

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

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

8.getitem、setitem、delitem

Socket 编程

多个用户交互

相关文章

Python 面向对象编程进阶

组合

静态方法

类方法

属性方法

类的特殊成员方法

1. __doc__ 表示类的描述信息

2. __module__ 和 __class__

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

4.__del__

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

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

8.__getitem__、__setitem__、__delitem__

Socket 编程

多个用户交互

相关文章

类方法　　

属性方法　　

1. doc　　表示类的描述信息

2. module 和 class

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

4.del

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

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

8.getitem、setitem、delitem