Python学习总结【第十一篇】：Python之面向对象及相关

面向对象基础

基础内容的两篇博文

• Python学习总结：Python之面向对象（初级篇）
• Python学习总结：Python之面向对象（进阶篇）

面向基础其他相关

1、isinstance(obj,cls)

功能：检查对象obj是否是类cls的对象

# 案例
class Foo(object):
    pass
 
obj = Foo()
 
print(isinstance(obj, Foo))
# 结果： True

2、issubclass（sub,super）

功能：检查sub类是否是super类的子类（派生类）

# 案例
class Foo(object):
    pass

class Bar(Foo):
    pass

print(issubclass(Bar, Foo))

# 结果： True

3、异常处理

3.1 异常概念

　　在编程过程中为了增加友好性，在程序出现bug时一般不会直接将错误信息显示给用户，而是显示一个提示页面，即不让程序错误直接抛给用户

try:
    pass
except Exception,ex:  # Python 2.7.x与Python 3.5.x区别
    pass

案例：获取用户输入的两个数字相加并返回结果

# Python 3.x代码
while True:
    num1 = input('num1:')
    num2 = input('num2:')
    try:
        num1 = int(num1)
        num2 = int(num2)
        result = num1 + num2
    except Exception as e:
        print('出现异常，信息如下：')
        print(e)

# Python 2.x代码
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

3.2 异常种类

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

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

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

dic = [1, 3]
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:    # ValueError能捕获到该异常
    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.3 完整的异常结构

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

3.4 主动触发异常

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

3.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

3.6 断言

Python中assert用来判断语句的真假，如果为假的话将触发AssertionError错误

assert 1 == 1
# 结果为真，无输出

assert 1 == 2
# 结果为假，输出结果如下：
Traceback (most recent call last):
  File "F:/untitled/3.py", line 19, in <module>
    assert 1 == 2
AssertionError

待补充：断言的应用场景及案例

设计模式

1、单例模式

单例：顾名思义就是单个实例

相关知识回顾：Python面向对象两个重要组成：类，实例

面向对象场景1：

如：创建三个游戏人物，分别是：

• 苍井井，女，18，初始战斗力1000
• 东尼木木，男，20，初始战斗力1800
• 波多多，女，19，初始战斗力2500

# #####################  定义类  #####################
class Person:

    def __init__(self, na, gen, age, fig):
        self.name = na
        self.gender = gen
        self.age = age
        self.fight =fig

    def grassland(self):
        """注释：草丛战斗，消耗200战斗力"""

        self.fight = self.fight - 200

# #####################  创建实例  #####################

cang = Person('苍井井', '女', 18, 1000)    # 创建苍井井角色
dong = Person('东尼木木', '男', 20, 1800)  # 创建东尼木木角色
bo = Person('波多多', '女', 19, 2500)      # 创建波多多角色

面向对象场景二：

如：创建对数据库操作的公共类

• 增
• 删
• 改
• 查

# #### 定义类 ####

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语句
        # 操作
        pass

    def create(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

    def remove(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

    def modify(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

# #### 操作类 ####

db = DbHelper()
db.create()

 实际应用场景：实现web应用程序

#!/usr/bin/env python
#coding:utf-8
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()

对于上述实例，每个请求到来，都需要在内存里创建一个实例，再通过该实例执行指定的方法。

　　那么问题来了...如果并发量大的话，内存里就会存在非常多功能上一模一样的对象。存在这些对象肯定会消耗内存，对于这些功能相同的对象可以在内存中仅创建一个，需要时都去调用

单实例就是为了解决上述问题：保证内存中仅存在一个实例

# #########单实例定义###########
class Foo:
    instance = None

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

    @classmethod
    def get_instance(cls):
        if cls.instance:
            return cls.instance
        else:
            obj = cls('alex')
            cls.instance = obj
            return obj

# #########获取实例###########
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)

对于Python单例模式，创建对象时不能再直接使用：obj = Foo()，而应该调用特殊的方法：obj = Foo.get_instance()

#!/usr/bin/env python
#coding:utf-8
from 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.__instance
        else:
            DbHelper.__instance = DbHelper()
            return DbHelper.__instance

    def fetch(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

    def create(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

    def remove(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass

    def modify(self):
        # 连接数据库
        # 拼接sql语句
        # 操作
        pass


class 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()

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