Python的平凡之路（7）

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

 

1、静态方法、类方法、属性方法                                                                         

a 静态方法名字上归类管，实际上在静态方法里访问不了类或实例中的任意属性       

静态方法.py

 #!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-

#静态方法
class Dog(object):
    def __init__(self,name):
        self.name = name

@staticmethod #把eat方法变为静态方法,1 调用时主动传实例本身到eat 2 去掉eat()方法中的self参数
    def eat():  #例子中取的是第二种方法
        print("chenronghua  is eating")

d = Dog("chenronghua")
#d.eat(d)也是可行的,但是eat方法中要传self参数
d.eat()

                                       

 b 类方法只能访问类变量，不能访问实例变量。    

类方法.py

#!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
#类方法
#类方法只能访问类变量,不能访问实例变量
class Dog(object):
    name = "我是类变量!"
    def __init__(self,name):
         self.name = name

@classmethod #注意缩进,要和上边的构造函数保持一致
    def eat(self):
        print("%s is eating" % self.name)

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

                                                         

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

 #!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
class Dog(object):
    name = 'alex'
    def __init__(self,name):
        self.name = name
    @property #加上此方法,可以把下边的方法看成Dog类的一个属性,一次装饰有效
    def eat(self):
        print("%s is eating" %self.name)
    @classmethod #类方法
    def drink(self):
        print("%s is drinking" %self.name)
    @staticmethod
    def full(self):
        print("%s is full up" %self.name)

d = Dog("chenronghua")
#调用属性方法下的eat属性
d.eat
#调用类方法下的drink方法
d.drink()
#调用静态方法下的eat方法

d.full(d)

 

  flight.py

#!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
#对属性方法进行练习
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):
        #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 fight status...please check later")
    @flight_status.setter #修改
    def flight_status(self,status):
        status_dic = {
         0:"canceled",
         1:"arrived",
         2:"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.checking_status()
f.flight_status = 1 #触发flight_status.setter
del f.flight_status #触发flight_status.deleter

                                                             

 2、类的特殊成员方法                                                                            

a __doc__

#__doc__表示类的描述信息,对于类下的方法是无效的。
class film(object):
    """谍影重重5已经上映了,非常不错"""
    def __init__(self,name):
        self.name = name
    def func(self):
        """这个功能还没定义,只是占个位子"""
        print("it's about %s" %self.name)

print(film.__doc__)
t = film('spy')

t.func()

 

b __module__和 __class__ ，前者表示当前操作的对象在那个模块，后者表示当前操作的对象的类是什么 

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

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

f __call__对象后面加括号，触发执行

class Foo:
    def __init__(self):
        pass

def __call__(self, name,*args, **kwargs):
        self.name = name

        print('This is __call__方法:%s' %self.name)

obj = Foo()  # 执行 __init__
obj('www.we.com')  # 执行 __call__

 

g __dict__

#__dict__查看类或对象中的所有成员
class Province:
    country = 'China'

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

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

        print('func')

# 获取类的成员，即：静态字段、方法、
print(Province.__dict__)

# 输出：{'country': 'China', '__module__': '__main__', 'func': <function func at 0x10be30f50>, '__init__': <function __init__ at 0x10be30ed8>, '__doc__': None}

obj1 = Province('HeBei', 10000)
print(obj1.__dict__)
# 获取 对象obj1 的成员

# 输出：{'count': 10000, 'name': 'HeBei'}

obj2 = Province('HeNan', 3888)
print(obj2.__dict__)
# 获取 对象obj1 的成员
# 输出：{'count': 3888, 'name': 'HeNan'} 

 

h __str__

#__str__表示如果类中定义了此方法,那么在打印对象的时候,默认输出该方法的返回值
class Foo:
    def __str__(self):
        return '这是要返回的值!'

obj = Foo()
print(obj)
# 输出：这是要返回的值

 

i __getitem__ __setittm__ __delitem__

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-

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']
obj['k2'] = 'alex'

del obj['k1']

 

j __new__\ __metaclass__

（略）

 

k  动态导入模块

import importlib

 

__import__('import_lib.metaclass') #这是解释器自己内部用的

#importlib.import_module('import_lib.metaclass') #与上面这句效果一样，官方建议用这个

 

l 反射

#!/usr/bin/env python
#Author is wspikh
# -*- coding: encoding -*-
#hasattr 和 getattr都是内建函数
class A:
    def __init__(self):
        self.name = 'zhangjing'
        #self.age = 24

    def method(self):
        print("method print")

Instance = A()
print(getattr(Instance,'name','not find')) #如果Instance对象中有属性
#name则打印self.name的值,否则就打印'not find
print(getattr(Instance,'age','not find')) #如果Instance对象中有属性age则打印self.age的值,否则打印'not find'
print(getattr(A,'method','default')) #如果有方法method,就打印其地址,否则打印default
#print(getattr(A,'method','default'))() #如果有方法method,运行函数并打印None否则打印default

#hasattr getattr  setattr练习
class Employee:
    '所有员工的基类'
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        #加1
        Employee.empCount += 1

    def displayCount(self):
        print("Total Employee %d" % Employee.empCount)

    def displayEmployee(self):
        print("Name : ", self.name, "\nSalary: ", self.salary)

Xiaoxiao = Employee('Xiaoxiao', 2000)
setattr(Xiaoxiao, 'age', 21)

Tiny = Employee("Tiny", 5000)
setattr(Tiny, 'age', 23)

print("实例类的第一个对象 Xiaoxiao ");
print('Xiaoxiao 是否存在age属性：', hasattr(Xiaoxiao, 'age'))
Xiaoxiao.displayEmployee();
print("Age:", getattr(Xiaoxiao, 'age', 'not find'));
#对象中是否有SEX属性,有就返回值,没有就返回not find
print("Sex:", getattr(Xiaoxiao, 'sex', 'not find'));
print("\n")

print("实例类的第二个对象 Tiny")
print('Tiny 是否存在age属性：', hasattr(Tiny, 'age'))
Tiny.displayEmployee()
print("Age: ", getattr(Tiny, 'age', 'not find'));

print("\n")
print("Total Employee number: %d" % Employee.empCount)
print("\n")

总结：                                                                      

   1 hasattr（object，name_str） 判断一个对象里是否有对应的字符串的方法                                      

   2 getattr（），根据字符串去获取obj对象里的对应的XX方法、                                                 

   3 setattr()                                                                         

   4 dela ttr()                                                                        

 

 3、异常处理（异常是Python对象，表示一个错误）   

   try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。try子句中的代码块放置可能出现异常的语句，except子句中的代码块处理异常

如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句

异常处理.py

 #!/usr/bin/env python

#Author is wspikh
# -*- coding: encoding -*-
"""import sys,traceback
try:
    a = 1
    b = a
    c = w
except Exception as e:
    print(Exception,":",e)

try:
    a = b
    b = c
except:
    f = open('log.txt','a')
    traceback.print_exc(file=f)
    f.flush()
    f.close()
"""
try:
    fh = open('testfile','w')

    fh.write("这是一个测试文件,用于测试异常!")

except IOError:  #捕获IO异常

    #testfile的权限已经变了,所以会报错
    print("Error: 没有找到文件或读取文件失败")
else:
    print("内容写入文件成功")

    fh.close()

 

#使用raise抛出异常

#当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

#演示raise用法

try:

     s = None

     if s is None:

         print "s 是空对象"

         raise NameError     #如果引发NameError异常，后面的代码将不能执行

     print（len(s)）

except TypeError:

     print "空对象没有长度"

 

#自定义异常

#python允许程序员自定义异常，用于描述python中没有涉及的异常情况，自定义异常必须继承Exception类，自定义异常按照命名规范##以"Error"结尾，显示地告诉程序员这是异常。自定义异常使用raise语句引发，而且只能通过人工方式触发。

from __future__ import division

 

class DivisionException(Exception):

      def __init__(self, x, y):

            Exception.__init__ (self, x, y)       #调用基类的__init__进行初始化

            self.x = x

            self.y = y

 

if __name__ == "__main__":

      try:

            x = 3

            y = 2

      if x % y > 0:                               #如果大于0， 则不能被初始化，抛出异常

            print x/y

            raise DivisionException(x, y)

except DivisionException,div:                     #div 表示DivisionException的实例对象

      print "DivisionExcetion: x/y = %.2f" % (div.x/div.y)

 

二、Socket开发基础                                                                          

 1 协议类型就是地址簇                                                                           

 

 2 客户端                                                                                 

 import socket                                                                         

 client =socket.socket()                                                               

 client.connect((‘localhost’,6969))                                                    

 #client.send(b“hello world”)                                                          

 #支持中文                                                                                 

 #client.send(“我要下载A”.encode('utf-8’))                                                 

 while True:                                                                           

    msg = input(“>>>”).trip()                                                          

     client.send(msg.encode('utf-8’))                                                  

    data = client.recv(1024)                                                           

    print（“recv:”,data)                                                                

 client.close()                                                                        

 

 3 服务器                                                                                 

 import socket                                                                         

 server - socket.socket                                                                

 server.bind((‘localhost’,6969))                                                       

 server.listen(5) #监听5个                                                                

 print(“我要开始等电话了“）                                                                     

 conn,addR = server.accept() #等信息接入                                                    

  #conn就是客户端连过来而在服务器端为其生成的一个实例                                                         

   print(conn,addR)                                                                    

   print（”电话来了“）                                                                       

 while True:                                                                           

   data = conn.recv(1024)                                                              

   print(“recv:”,data)                                                                 

   conn.send(data.upper())                                                             

 server.close()