python 学习分享-面向对象2

面向对象进阶

静态方法

一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法：

class Foo:
    def __init__(self, name):
        self.name = name
    def hi(self):
        print self.name
    @staticmethod
    def add(a, b):
        print a + b
if __name__ == '__main__':
    foo01 = Foo('letian')
    foo01.hi()
    foo01.add(1,2)
    Foo.add(1, 2)

类方法

类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。类对象和实例都可以调用类方法：

class Foo:
    name = 'letian '
    @classmethod
    def hi(cls, x):
        print cls.name * x
if __name__ == '__main__':
    foo01 = Foo()
    foo01.hi(2)
    Foo.hi(3)

#代码输出
letian letian
letian letian letian

类的私有属性：

　　__private_attrs 两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
类的方法
　　在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
私有的类方法
　　__private_method 两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用slef.__private_methods

类的装饰器@property

在该类中定义三个函数，分别用作赋值、取值、删除变量

property函数原型为property(fget=None,fset=None,fdel=None,doc=None)，上例根据自己定义相应的函数赋值即可。

class Pager:
    def __init__(self,all_count):
        self.all_count=all_count
    @property
    def all_pager(self):
        a,b=divmod(self.all_count,10)
        if a==0:
            return a
        else:
            return  a+1

    @all_pager.setter
    def all_pager(self,value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print('hehe')
p=Pager(101)
ret=p.all_count#以访问类属性的方法访问对象的方法
print(ret)

class Pager:
    def __init__(self,all_count):
        self.all_count=all_count
    def f1(self):
        return 123
    def f2(self,value):
        print('======')
    def f3(self):
        print('+++++++')

    foo=property(fget=f1,fset=f2,fdel=f3)
p=Pager(101)
ret=p.foo
p.foo='alex'
print(p.foo)
del p.foo

类的专业方法

1 __init__
类似于构造函数

#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def say(self):
                print self.name
study = Study("Badboy")
study.say()

2 __del__
类似于析构函数

#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def __del__(self):
                print "Iamaway,baby!"
        def say(self):
                print self.name
study = Study("zhuzhengjun")
study.say()

3__repr__
使用repr(obj)的时候，会自动调用__repr__函数，该函数返回对象字符串表达式，
用于重建对象，如果eval(repr(obj))会得到一个对象的拷贝。

#!/usr/local/bin/python
class Study:
        def __init__(self,name=None):
                self.name = name
        def __del__(self):
                print "Iamaway,baby!"
        def say(self):
                print self.name
        def __repr__(self):
                return "Study('jacky')"
study = Study("zhuzhengjun")
study.say()
print type(repr(Study("zhuzhengjun"))) # str
print type(eval(repr(Study("zhuzhengjun")))) # instance

study = eval(repr(Study("zhuzhengjun")))

study.say()

4__str__
Python能用print语句输出内建数据类型。有时，程序员希望定义一个类，要求它的对象也能用print语句输出。Python类可定义特殊方法__str__，为类的对象提供一个不正式的字符串表示。如果类的客户程序包含以下语句：

print objectOfClass
那么Python会调用对象的__str__方法，并输出那个方法所返回的字符串。

#!/usr/local/bin/python

class PhoneNumber:
        def __init__(self,number):
                 self.areaCode=number[1:4]
                 self.exchange=number[6:9]
                 self.line=number[10:14]

        def __str__(self):
                return "(%s) %s-%s"%(self.areaCode,self.exchange,self.line)

def test():
         newNumber=raw_input("Enter phone number in the form. (123) 456-7890: \n")
         phone=PhoneNumber(newNumber)
         print "The phone number is:"
         print phone

if__name__=="__main__":
         test()

方法__init__接收一个形如"(xxx) xxx-xxxx"的字符串。字符串中的每个x都是电话号码的一个位数。方法对字符串进行分解，并将电话号码的不同部分作为属性存储。

方法__str__是一个特殊方法，它构造并返回PhoneNumber类的一个对象的字符串表示。解析器一旦遇到如下语句：

print phone

就会执行以下语句：

print phone.__str__()

程序如果将PhoneNumber对象传给内建函数str(如str(phone)),或者为PhoneNumber对象使用字符串格式化运算符%(例如"%s"%phone),Python也会调用__str__方法。

5__cmp __
比较运算符，0：等于 1：大于 -1：小于

class Study:
     def __cmp__(self, other):
         if other > 0 :
             return 1
         elif other < 0:
             return - 1
         else:
             return 0  

study = Study()
if study > -10:print 'ok1'
if study < -10:print 'ok2'
if study == 0:print 'ok3'

打印：ok2 ok3
说明:在对类进行比较时，python自动调用__cmp__方法，如-10 < 0 返回 -1，也就是说study 应该小与 -10，估打印ok2

6__getitem__
__getitem__ 专用方法很简单。象普通的方法 clear，keys 和 values 一样，它只是重定向到字典，返回字典的值。

class Zoo:
     def __getitem__(self, key):
         if key == 'dog':return 'dog'
         elif key == 'pig':return  'pig'
         elif key == 'wolf':return 'wolf'
         else:return 'unknown'  

zoo = Zoo()
print zoo['dog']
print zoo['pig']
print zoo['wolf']

打印 dog pig wolf

7__setitem__
__setitem__ 简单地重定向到真正的字典 self.data ，让它来进行工作。

class Zoo:
     def __setitem__(self, key, value):
         print 'key=%s,value=%s' % (key, value)  

zoo = Zoo()
zoo['a'] = 'a'
zoo['b'] = 'b'
zoo['c'] = 'c'
打印：
key=a,value=a
key=b,value=b
key=c,value=c

8 __delitem__
__delitem__ 在调用 del instance[key] 时调用 ，你可能记得它作为从字典中删除单个元素的方法。当你在类实例中使用 del 时，Python 替你调用 __delitem__ 专用方法。

class A:
   def __delitem__(self, key):
          print 'delete item:%s' %key  

a = A()
del a['key'] 

---

---

---

---

---

---

反射

__author__ = "LAAY"

def bulk(self):
    print("%s is yelling...." %self.name)

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

    def eat(self,food):
        print("%s is eating..."%self.name,food)

d = Dog("NiuHanYang")
choice = input(">>:").strip()

if hasattr(d,choice):
    getattr(d,choice)
else:
    setattr(d,choice,bulk) #d.talk = bulk
    func = getattr(d, choice)
    func(d)

异常处理

try:
    open("tes.txt")

except (KeyError,IndexError) as e :
    print("没有这个key",e)
except IndexError as e :
    print("列表操作错误",e)
except BaseException as e:
    print("未知错误",e)
else:
    print("一切正常")
finally:
    print("不管有没有错，都执行")

socket模块

#客户端
import socket

client = socket.socket() #声明socket类型，同时生成socket连接对象
#client.connect(('192.168.16.200',9999))
client.connect(('localhost',6969))
while True:
    msg = input(">>:").strip()
    if len(msg) == 0:continue
    client.send(msg.encode("utf-8"))
    data = client.recv(10240)
    print("recv:",data.decode())

client.close()

#服务器端

import socket
server = socket.socket()
server.bind(('localhost',6969)) #绑定要监听端口
server.listen(5) #监听

print("我要开始等电话了")
while True:
    conn, addr = server.accept()  # 等电话打进来
    # conn就是客户端连过来而在服务器端为其生成的一个连接实例
    print(conn, addr)
    print("电话来了")
    count = 0
    while True:
        data = conn.recv(1024)
        print("recv:",data)
        if not data:
            print("client has lost...")
            break
        conn.send(data.upper())
        count+=1
        if count >10:break

server.close()