Python之路：面向对象及相关

其他相关

一、isinstance(obj, cls)

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

1 class Foo(object):
2     pass
3  
4 obj = Foo()
5  
6 isinstance(obj, Foo)

二、issubclass(sub, super)

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

1 class Foo(object):
2     pass
3  
4 class Bar(Foo):
5     pass
6  
7 issubclass(Bar, Foo)

三、异常处理

1、异常基础

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

通俗来说就是不让用户看见大黄页！！！

1 try:
2     pass
3 except Exception,ex:
4     pass

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
实例：IndexError
dic = {'k1':'v1'}
try:
    dic['k20']
except KeyError, e:
    print e
实例：KeyError
s1 = 'hello'
try:
    int(s1)
except ValueError, e:
    print e
实例：ValueError

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

1 # 未捕获到异常，程序直接报错
2  
3 s1 = 'hello'
4 try:
5     int(s1)
6 except IndexError,e:
7     print e

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

  
1 s1 = 'hello'
2 try:
3     int(s1)
4 except IndexError,e:
5     print e
6 except KeyError,e:
7     print e
8 except ValueError,e:
9     print e

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

 

1 s1 = 'hello'
2 try:
3     int(s1)
4 except Exception,e:
5     print e

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

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

1 s1 = 'hello'
2 try:
3     int(s1)
4 except KeyError,e:
5     print '键错误'
6 except IndexError,e:
7     print '索引错误'
8 except Exception, e:
9     print '错误'

3、异常其他结构

 1 try:
 2     # 主代码块
 3     pass
 4 except KeyError,e:
 5     # 异常时，执行该块
 6     pass
 7 else:
 8     # 主代码块执行完，执行该块
 9     pass
10 finally:
11     # 无论异常与否，最终执行该块
12     pass

4、主动触发异常

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

5、自定义异常

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

6、断言

1 # assert 条件
2  
3 assert 1 == 1
4  
5 assert 1 == 2

四、反射

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：

检查是否含有某成员、获取成员、设置成员、删除成员。

 1 class Foo(object):
 2  
 3     def __init__(self):
 4         self.name = 'wupeiqi'
 5  
 6     def func(self):
 7         return 'func'
 8  
 9 obj = Foo()
10  
11 # #### 检查是否含有成员 #### 
12 hasattr(obj, 'name')
13 hasattr(obj, 'func')
14  
15 # #### 获取成员 #### 
16 getattr(obj, 'name')
17 getattr(obj, 'func')
18  
19 # #### 设置成员 #### 
20 setattr(obj, 'age', 18)
21 setattr(obj, 'show', lambda num: num + 1)
22  
23 # #### 删除成员 #### 
24 delattr(obj, 'name')
25 delattr(obj, 'func')

详细解析：

当我们要访问一个对象的成员时，应该是这样操作：

 1 class Foo(object):
 2  
 3     def __init__(self):
 4         self.name = 'alex'
 5  
 6     def func(self):
 7         return 'func'
 8  
 9 obj = Foo()
10  
11 # 访问字段
12 obj.name
13 # 执行方法
14 obj.func()
那么问题来了？
a、上述访问对象成员的 name 和 func 是什么？ 
答：是变量名
b、obj.xxx 是什么意思？ 
答：obj.xxx 表示去obj中或类中寻找变量名 xxx，并获取对应内存地址中的内容。
c、需求：请使用其他方式获取obj对象中的name变量指向内存中的值 “alex”
class Foo(object):
 
    def __init__(self):
        self.name = 'alex'
 
# 不允许使用 obj.name
obj = Foo()
View Code

答：有两种方式，如下：

class Foo(object):

    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'

# 不允许使用 obj.name
obj = Foo()

print obj.__dict__['name']
方式一
class Foo(object):

    def __init__(self):
        self.name = 'alex'

    def func(self):
        return 'func'

# 不允许使用 obj.name
obj = Foo()

print getattr(obj, 'name')
方式二
from wsgiref.simple_server import make_server

class Handler(object):

    def index(self):
        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 8000..."
    httpd.serve_forever()
Web框架实例

 

 结论：反射是通过字符串的形式操作对象相关的成员。一切事物都是对象！！！

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys


def s1():
    print 's1'


def s2():
    print 's2'


this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')
反射当前模块成员
 1 #!/usr/bin/env python
 2 class Foo(object):
 3     staticField = "old boy"
 4     def __init__(self):
 5         self.name = 'wupeiqi'
 6     def func(self):
 7         return 'func'
 8     @staticmethod
 9     def bar():
10         return 'bar'
11 print(getattr(Foo, 'staticField'))
12 print(getattr(Foo, 'func'))
13 print(getattr(Foo, 'bar'))

模块也是对象

#!/usr/bin/env python
# -*- coding:utf-8 -*-

def dev():
    return 'dev'
home.py
 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3  
 4 """
 5 程序目录：
 6     home.py
 7     index.py
 8  
 9 当前文件：
10     index.py
11 """
12  
13  
14 import home as obj
15  
16 #obj.dev()
17  
18 func = getattr(obj, 'dev')
19 func() 

设计模式

一、单例模式

单例，顾名思义单个实例。

首先来回顾下面向对象的内容：

python的面向对象由两个非常重要的两个“东西”组成：类、实例

面向对象场景一：

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

  • 苍井井，女，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)      # 创建波多多角色
View Code

面向对象场景二：

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

  • 增
  • 删
  • 改
  • 查
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()
View Code

 

实例：结合场景二实现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()
View Code

铛铛 铛铛 铛铛铛铛铛，单例模式出马，单例模式用来保证内存中仅存在一个实例！！！

通过面向对象的特性，构造出单例模式：

# ########### 单例类定义 ###########
class Foo(object):
 
    __instance = None
 
    @staticmethod
    def singleton():
        if Foo.__instance:
            return Foo.__instance
        else:
            Foo.__instance = Foo()
            return Foo.__instance
 
# ########### 获取实例 ###########
obj = Foo.singleton()

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

#!/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()
Web应用实例-单例模式

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

posted @ 2017-02-23 19:39  失落的黎明  阅读(277)  评论(0)  编辑  收藏  举报