python面向对象其他相关-异常处理-反射-无忧网

1.isinstance(obj, cls)

检查是否obj是否是类 cls 的对象

2.issubclass(sub, super)

检查sub类是否是 super 类的派生类

n1 = 10
a1 = "123"print type(n1)
print type(a1)
print isinstance(n1,int)            #判断n1是否属于int类型,正确返回Trueprint‘-->‘,isinstance(n1,str)      #判断n1是否属于str类型,正确返回Trueclass A:
    passclass B(A):
    pass
a = B()
print isinstance(a,A)
print isinstance(a,B)
print issubclass(B,A)   #检查B类是不是A类的派生类print issubclass(A,B)


执行结果：
<type ‘int‘>
<type ‘str‘>
True
--> False
True
True
True
False

3.异常处理

异常基础：

            try
            :
    
            pass
            except
             Exception,e:
    
            print e  #打印出异常内容pass

实例：

            while
             True:
    num1 = raw_input(‘num1:‘)
    num2 = raw_input(‘num2:‘)
    try:
        num1 = int(num1)    #将输入内容转换为int类型
        num2 = int(num2)
        result = num1 + num2
    except Exception, e:
        print‘出现异常，信息如下：‘#当输入不为int类型，捕获异常print e

#运行
num1:1
num2:2
num1:d
num2:
3出现异常，信息如下：
invalid literal for int() with base 10: ‘d‘
num1:1.1
num2:2
出现异常，信息如下：
invalid literal for int() with base 10: ‘31.1‘

在实际应用中，我们可能需要捕获一些特定的异常，最后的时候才捕获所有异常类型

#常用异常AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError 输入/输出异常；基本上是无法打开文件
ImportError 无法引入模块或包；基本上是路径问题或名称错误
IndentationError 语法错误（的子类） ；代码没有正确对齐
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
ValueError 传入一个调用者不期望的值，即使值的类型是正确的

IndexError示例：

dic = ["ares", ‘aaaa‘]
try:
    dic[10]
except KeyError,e:
    print e

#执行结果报错为
  File "XXX", line 6, in <module>
    dic[10]
IndexError: list index out of range

#更改捕获的错误类型
dic = ["ares", ‘aaaa‘]
try:
    dic[10]
except IndexError, e:
    print e

#此时运行就捕获到了错误类型
list index out of range

KeyError示例：

dic = {‘k1‘:‘v1‘}
try:
    dic[‘k2‘]
except KeyError, e:
    print e

#捕获到的错误类型‘k2‘

ValueError示例：

s1 = ‘hello‘try:
    int(s1)
except ValueError, e:
    print e

#捕获到的错误
invalid literal for int() with base 10: ‘hello‘

如果是单纯的定义一个异常，则如果程序中出现其他异常就会报错，此时，我们可以捕获已知的异常类型，对于未知的异常类型可以用万能异常 Exception捕获。

s1 = ‘hello‘try:
    int(s1)
except KeyError,e:
    print‘键错误‘except IndexError,e:
    print‘索引错误‘except Exception, e:
    print‘错误‘

异常结构：

try:
    #逻辑代码passexcept IndexError,e:
    passexcept Exception,e:
    passelse:
    #逻辑串中未出现异常passfinally:
    #释放资源，断开连接#永远执行,逻辑代码执行完之后执行pass

有时我们可能想要主动触发异常，方法如下

try:
    raise Exception(‘错误了。。。‘)
except Exception,e:
    print e

#输出结果
错误了。。。

自定义异常：

#自定义异常class OwnerError(Exception):
    def__init__(self,msg=None):
        self.message = msg
    def__str__(self):
        if self.message:
            return self.message
        else:
            return‘Owner Error‘try:
    raise OwnerError(‘erroreroor‘)
except Exception,e:
    print e

#输出内容
erroreroor

断言：

# assert 条件assert 1 == 1
assert 1 == 2

#不太清楚，先记下

重头戏，反射来了。。。。。

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

示例1：输入不同url来实现不同跳转

#home.py函数def dev():
    return"home/dev"def index():
    return"home/index"def login():
    return"home/login"def logout():
    return"home/logout"#调用home模块import home
#输入不同url跳转
#第一种实现方式,使用if/else做判断print"-------------------->"while True:
    url = raw_input("input url:")
    if url == "home/dev":
        ret = home.dev()
        print ret
    elif url == "home/index":
        ret = home.index()
        print ret
    elif url == "home/login":
        ret = home.login()
        print ret
    elif url == "home/logout":
        ret = home.logout()
        print ret
    else:
        print"404"#运行结果
-------------------->
input url:home/dev
home/dev
input url:home/login
home/login
input url:home/sad
404

可以看到，上述代码已经基本实现了我们的需求，即输入不同url来进行不同的跳转，但是，如果url有上万个，这么方式显然是不可取的，那么，应该怎么办呢？？？

其实，将上述代码稍作修改即可：

#第二种实现方式，使用getattr函数做反射import home
print"-------------------->"while True:
    url = raw_input("input url:")
#对输入的url从/进行切割，例如输入home/dev，那么controller即为home，function为dev
    controller,function = url.split(‘/‘)    
    #function为字符串#去某个函数（模块）中找函数，字符串函数名，若果有则获取函数
    func = getattr(home,function)
    ret = func()
    print ret

实例2：

#getattr,setattr,deleattr,hasattr,对内存某一个容器的元素做操作,只对内存做更改
#找到home文件，加载到内存import home
print dir(home)
print hasattr(home,‘dev‘)   #判断home里是否存在dev方法print hasattr(home,‘devv‘)
print getattr(home,‘dev‘)   #取出home里是否存在dev方法
setattr(home,‘ares‘,‘single‘)       #设置ares成员print dir(home)
setattr(home,‘ares‘,lambda x:x+1)
print dir(home)
delattr(home,‘ares‘)        #删除ares成员print dir(home)

#执行结果
[‘__author__‘, ‘__builtins__‘, ‘__doc__‘, ‘__file__‘, ‘__name__‘, ‘__package__‘, ‘dev‘, ‘index‘, ‘login‘, ‘logout‘]
True
False
<function dev at 0x00000000027A1978>
[‘__author__‘, ‘__builtins__‘, ‘__doc__‘, ‘__file__‘, ‘__name__‘, ‘__package__‘, ‘ares‘, ‘dev‘, ‘index‘, ‘login‘, ‘logout‘]
[‘__author__‘, ‘__builtins__‘, ‘__doc__‘, ‘__file__‘, ‘__name__‘, ‘__package__‘, ‘ares‘, ‘dev‘, ‘index‘, ‘login‘, ‘logout‘]
[‘__author__‘, ‘__builtins__‘, ‘__doc__‘, ‘__file__‘, ‘__name__‘, ‘__package__‘, ‘dev‘, ‘index‘, ‘login‘, ‘logout‘]

实例3：

class Foo:
    atatic_name = ‘ares‘def__init__(self):
        self.name = ‘ares‘def show(self):
        pass
    @staticmethod
    def static_show():
        pass
    @classmethod
    def class_show(self):
        passprint Foo.__dict__.keys()
print hasattr(Foo,‘static_show‘)
obj = Foo()
print obj.__dict__print obj.__dict__[‘name‘]      #将获取obj对象中的name变量指向内存中的值 “ares”print hasattr(obj,‘name‘)
print hasattr(obj,‘show‘)
print getattr(obj,‘name‘)       #将获取obj对象中的name变量指向内存中的值 “ares”#执行结果
[‘atatic_name‘, ‘__module__‘, ‘static_show‘, ‘show‘, ‘class_show‘, ‘__doc__‘, ‘__init__‘]
True
{‘name‘: ‘ares‘}
ares
True
True
ares

web框架实例，可在浏览器执行localhost:8001/xxx：

from wsgiref.simple_server import make_server
def RunServer(environ, start_response):
    start_response(‘200 OK‘, [(‘Content-Type‘, ‘text/html‘)])
    url = environ[‘PATH_INFO‘]
    temp = url.split(‘/‘)[1]            #获取http://localhost:8001/login的login字符串import home
    is_exist = hasattr(home, temp)      #去home模块中检查是否含有指定的函数if is_exist:                        #如果存在指定函数
        func = getattr(home, temp)      #获取函数
        ret = func()                    #执行函数并获取返回值return ret                     #将函数返回值相应给请求者else:
        return‘404 not found‘if__name__ == ‘__main__‘:
    httpd = make_server(‘‘, 8001, RunServer)
    print"Serving HTTP on port 8001..."
    httpd.serve_forever()

一切事物皆对象，类是对象，模块也是对象！

单例模式：

demo：

from wsgiref.simple_server import make_server
class DbHelper(object):
    def__init__(self):
        self.hostname = ‘1.1.1.1‘
        self.port = 3306
        self.password = ‘pwd‘
        self.username = ‘root‘def fetch(self):
        # 连接数据库# 拼接sql语句# 操作return‘fetch‘def create(self):
        # 连接数据库# 拼接sql语句# 操作return‘create‘def remove(self):
        # 连接数据库# 拼接sql语句# 操作return‘remove‘def modify(self):
        # 连接数据库# 拼接sql语句# 操作return‘modify‘class Handler(object):
    def index(self):
        # 创建对象
        db = DbHelper()
        db.fetch()
        return‘index‘def news(self):
        return‘news‘def RunServer(environ, start_response):
    start_response(‘200 OK‘, [(‘Content-Type‘, ‘text/html‘)])
    url = environ[‘PATH_INFO‘]
    temp = url.split(‘/‘)[1]
    obj = Handler()
    is_exist = hasattr(obj, temp)
    if is_exist:
        func = getattr(obj, temp)
        ret = func()
        return ret
    else:
        return‘404 not found‘if__name__ == ‘__main__‘:
    httpd = make_server(‘‘, 8001, RunServer)
    print"Serving HTTP on port 8001..."
    httpd.serve_forever()

上述实例，每个请求到来，都需要在内存里创建一个实例，再通过该实例执行指定的方法。如果并发量大的话，内存里就会存在非常多功能上一模一样的对象。存在这些对象肯定会消耗内存，对于这些功能相同的对象可以在内存中仅创建一个，需要时都去调用，这么可以省下不少的内存。

单实例模式就是用来解决这个问题的，单例模式用来保证内存中仅存在一个实例！！！

对于Python单例模式，创建对象时不能再直接使用：obj = Foo()，而应该调用特殊的方法：obj = Foo.singleton() ，上述代码可以修改成

#!/usr/bin/env python
#coding:utf-8from wsgiref.simple_server import make_server

# ########### 单例类定义 ###########class DbHelper(object):

    __instance = None

    def__init__(self):
        self.hostname = ‘1.1.1.1‘
        self.port = 3306
        self.password = ‘pwd‘
        self.username = ‘root‘

    @staticmethod
    def singleton():
        if DbHelper.__instance:
            return DbHelper.__instanceelse:
            DbHelper.__instance = DbHelper()
            return DbHelper.__instancedef fetch(self):
        # 连接数据库# 拼接sql语句# 操作passdef create(self):
        # 连接数据库# 拼接sql语句# 操作passdef remove(self):
        # 连接数据库# 拼接sql语句# 操作passdef modify(self):
        # 连接数据库# 拼接sql语句# 操作passclass Handler(object):

    def index(self):
        obj =  DbHelper.singleton()
        print id(single)
        obj.create()
        return‘index‘def news(self):
        return‘news‘def RunServer(environ, start_response):
    start_response(‘200 OK‘, [(‘Content-Type‘, ‘text/html‘)])
    url = environ[‘PATH_INFO‘]
    temp = url.split(‘/‘)[1]
    obj = Handler()
    is_exist = hasattr(obj, temp)
    if is_exist:
        func = getattr(obj, temp)
        ret = func()
        return ret
    else:
        return‘404 not found‘if__name__ == ‘__main__‘:
    httpd = make_server(‘‘, 8001, RunServer)
    print"Serving HTTP on port 8001..."
    httpd.serve_forever()

总结：单利模式存在的目的是保证当前内存中仅存在单个实例，避免内存浪费！

原文：http://www.cnblogs.com/aresxin/p/5046923.html

【说明】：本文章由站长整理发布，文章内容不代表本站观点，如文中有侵权行为，请与本站客服联系(QQ:254677821)！

python面向对象其他相关-异常处理-反射

相关教程推荐

其他课程推荐