Python

目录

• Python - 面对对象(其他相关,异常处理,反射,等..)
  • 一、isinstance(obj, cls)
  • 二、issubclass(sub, super)
  • 三、异常处理
    • 1. 异常处理
    • 2.异常种类
    • 3.异常其他结构
    • 4.主动触发异常
    • 5.自定义异常
    • 6.断言
  • 四、反射
  • 五. 单例模式

Python - 面对对象(其他相关,异常处理,反射,等..)

一、isinstance(obj, cls)

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

class Foo(object):
    pass
 
obj = Foo()
 
isinstance(obj, Foo)

二、issubclass(sub, super)

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

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
issubclass(Bar, Foo)

三、异常处理

1. 异常处理

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！

try:
    pass
except Exception,ex:
    pass

需求：将用户输入的两个数字相加

while True:
    num1 = raw_input('num1:')
    num2 = raw_input('num2:')
    try:
        num1 = int(num1)
        num2 = int(num2)
        result = num1 + num2
    except Exception, e:
        print '出现异常，信息如下：'
        print e

2.异常种类

python中的异常种类非常多，每个异常专门用于处理某一项异常！！！

常用的异常

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

实例

dic = ["wupeiqi", 'alex']
try:
    dic[10]
except IndexError, e:
    print e


dic = {'k1':'v1'}
try:
    dic['k20']
except KeyError, e:
    print e

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

对于上述实例，异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

 未捕获到异常，程序直接报错
 
s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e

所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：

s1 = 'hello'
try:
    int(s1)
except IndexError,e:
    print e
except KeyError,e:
    print e
except ValueError,e:
    print e

万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：

s1 = 'hello'
try:
    int(s1)
except Exception,e:
    print e

接下来你可能要问了，既然有这个万能异常，其他异常是不是就可以忽略了！

答：当然不是，对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。

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

3.异常其他结构

try:
    # 主代码块
    pass
except KeyError,e:
    # 异常时，执行该块
    pass
else:
    # 主代码块执行完，执行该块
    pass
finally:
    # 无论异常与否，最终执行该块
    pass

4.主动触发异常

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

5.自定义异常

class WupeiqiException(Exception):
 
    def __init__(self, msg):
        self.message = msg
 
    def __str__(self):
        return self.message
 
try:
    raise WupeiqiException('我的异常')
except WupeiqiException,e:
    print e

6.断言

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

四、反射

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

class Foo(object):
 
    def __init__(self):
        self.name = 'wupeiqi'
 
    def func(self):
        return 'func'
 
obj = Foo()
 
# #### 检查是否含有成员 ####
hasattr(obj, 'name')
hasattr(obj, 'func')
 
# #### 获取成员 ####
getattr(obj, 'name')
getattr(obj, 'func')
 
# #### 设置成员 ####
setattr(obj, 'age', 18)
setattr(obj, 'show', lambda num: num + 1)
 
# #### 删除成员 ####
delattr(obj, 'name')
delattr(obj, 'func')

类是对象

class Foo(object):
 
    staticField = "old boy"
 
    def __init__(self):
        self.name = 'wupeiqi'
 
    def func(self):
        return 'func'
 
    @staticmethod
    def bar():
        return 'bar'
 
print getattr(Foo, 'staticField')
print getattr(Foo, 'func')
print getattr(Foo, 'bar')

反射也是对象

#!/usr/bin/env python
# -*- coding:utf-8 -*-
 
"""
程序目录：
    home.py
    index.py
 
当前文件：
    index.py
"""
 
 
import home as obj
 
#obj.dev()
 
func = getattr(obj, 'dev')
func() 

五. 单例模式

设计模式之单例模式

单例设计模式是怎么来的？
在面向对象的程序设计中，当业务并发量非常大时，那么就会出现重复创建相同的对象，每创建一个对象就会开辟一块内存空间，而这些对象其实是一模一样的，那么有没有办法使用得内存对象只创建一次，然后再随处使用呢？单例模式就是为了解决这个问题而产生的。

实现方式：
１、创建一个类静态字段（类变量）__instance
２、创建一个静态函数，通过函数的逻辑判断 __instance 是否已存在，如不存在就将对象值赋于__instance，即__instance = 类(),否则直接返回__instance，也即创建的对象都是一样的
３、使用单例模式创建对象时直接通过类调用静态函数创建即可

#普通模式
class A(object):
    def __init__(self,name,male):
        self.name = name
        self.name = male

#实例化多个对象
obj1 = A('ben','boy')
obj2 = A('min','girl')
obj3 = A('miao','boy')
##打印内存地址，可以看到内存地址都是不一样的
print id(obj1),id(obj2),id(obj3)

#单例模式
class A(object):
    __instance = None
    def __init__(self,name,male):
        self.name = name
        self.name = male
    @staticmethod
    def create_obj():
        if not A.__instance:
            A.__instance = A('ben','boy')
            return A.__instance
        else:
            return A.__instance

#单例模式实例化多个对象
obj1 = A.create_obj()
obj2 = A.create_obj()
obj3 = A.create_obj()
##打印内存地址，可以看到内存地址都是一样的
print id(obj1),id(obj2),id(obj3)

result :

1 >>> #普通模式
 2 ... class A(object):
 3 ...     def __init__(self,name,male):
 4 ...         self.name = name
 5 ...         self.name = male
 6 ... 
 7 >>> #实例化多个对象
 8 ... obj1 = A('ben','boy')
 9 >>> obj2 = A('min','girl')
10 >>> obj3 = A('miao','boy')
11 >>> ##打印内存地址，可以看到内存地址都是不一样的
12 ... print id(obj1),id(obj2),id(obj3)
13 140230687882448 140230687882512 140230687882576
14 >>> 
15 >>> #单例模式
16 ... class A(object):
17 ...     __instance = None
18 ...     def __init__(self,name,male):
19 ...         self.name = name
20 ...         self.name = male
21 ...     @staticmethod
22 ...     def create_obj():
23 ...         if not A.__instance:
24 ...             A.__instance = A('ben','boy')
25 ...             return A.__instance
26 ...         else:
27 ...             return A.__instance
28 ... 
29 >>> #单例模式实例化多个对象
30 ... obj1 = A.create_obj()
31 >>> obj2 = A.create_obj()
32 >>> obj3 = A.create_obj()
33 >>> ##打印内存地址，可以看到内存地址都是一样的
34 ... print id(obj1),id(obj2),id(obj3)
35 140230687882832 140230687882832 140230687882832
36 >>>