面向对象（进阶篇）、异常处理、单例模式

类的成员

类的成员分为三大类：

　　1,字段 静态字段（每个对象都有一份时用）、普通字段（每个对象都不的数据时用）

　　2,方法 静态方法（无需使用对象封装的内容）、类方法、普通方法（使用对象中的数据）

　　3,特性 普通特性（将方法伪造成字段）

通过类访问：静态字段、静态方法、类方法

通过对象访问：普通字段、普通方法，类方法

class Provice:
    #静态字段：在类中；在内存中只保存一份
    country = "中国"



    def __init__(self,name):
        temp = "xxx"
        #普通字段，在对象中；在每个对象中都要保存一份
        self.name = name

    #普通方法，类中
    def show(self):
        print('show')

    #类方法
    @classmethod
    def xxoo(cls):  #类名
        print('xxoo')
        # print('xxoo',cls)

    #静态方法
    @staticmethod
    def xo(arg1,arg2):
            print('xo')

    def start(self):
        temp = "%s sb" %self.name
        return temp

    #特性，将方法伪造成一种字段
    @property
    def end1(self):
        temp = "%s sb" % self.name
        return temp

    @end1.setter  #类名+setter 修改参数
    def end1(self,value):

        # print(value)
        self.name = value

obj = Provice("123")
print(obj.end1)
obj.end1 = "456"
print(obj.end1)

obj = Provice('alex')
print(obj.end1)
obj.end1 = "123"
print(obj.end1)


obj = Provice('alex')
#print(obj.name)
ret1 = obj.start()
ret2 = obj.end1
print(ret1)
Provice.xo(1,2)  #执行静态方法
Provice.xxoo()   #执行类方法
hebei = Provice("河北")
henan = Provice("河南")
#1,自己去访问自己的成员
#2,除了类中的方法

print(Provice.country)
obj = Provice('alex')
obj.show()

总结：

快速判断，是类执行还是对象执行：

　　1，有self  对象执行

　　2，无self  类调用

调用方法：

　　普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；

　　类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；

　　静态方法：由类调用；无默认参数；

特性：

　　定义时，普通方法的基础上添加 @property

　　定义时，属性仅有一个self参数

　　调用时，无需括号

 成员修饰符

公共成员，在任何地方都能访问

私有成员，只有在类的内部才能访问；私有成员命名，前两个字符使下划线（特殊成员除外）。

1,静态字段

a，公有静态字段：类可以访问；类内部可以访问；派生类中可以访问

实例：

class C:

    name = "hello"

    def func(self):
        print(C.name)

class D(C):

    def show(self):
        print(C.name)


C.name         # 类访问

obj = C()
obj.func()     # 类内部可以访问

obj_son = D()
obj_son.show() # 派生类中可以访问

b，私有静态字段：仅类内部可以访问；

实例：

class Foo:
    # xo = "xo"
    __ox = "ox"  #只能被内部取到，不能被外部取到
    def fetch(self):
        print(Foo.__ox)
#
obj = Foo()
obj.fetch()

2，普通字段

公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问

class C:

    def __init__(self):
        self.foo = "公有字段"

    def func(self):
        print(self.foo)  #类内部访问

class D(C):

    def show(self):
        print(self.foo) #　派生类中访问

obj = C()

obj.foo     # 通过对象访问
obj.func()  # 类内部访问

obj_son = D()
obj_son.show()  # 派生类中访问

私有普通字段：仅类内部可以访问

class C:

    def __init__(self):
        self.__foo = "私有字段"

    def func(self):
        print(self.foo)#类内部访问

class D(C):

    def show(self):
        print(self.foo)#派生类中访问

obj = C()

obj.__foo     # 通过对象访问    ==> 错误
obj.func()  # 类内部访问        ==> 正确

obj_son = D()
obj_son.show()  # 派生类中访问  ==> 错误

类的特殊成员

1，__init__

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

class Annimal:
    def __init__(self):
        print('A构造方法')
        self.ty = "动物"

class Cat(Annimal):
    def __init__(self):
        print('B构造方法')
        self.n = "猫"

        super(Cat,self).__init__()  #super().__init__()执行父类的构造方法
        #Annimal.__init__(self)  #这样也行，但不推荐

#类后面加括号自动执行
#数据初始化
c = Cat()
print(c.__dict__)

2,__del__

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

class Foo:

    def __del__(self):
        pass

 

3，__call__

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

class Foo:
    def __init__(self):  #构造方法，通过类创建对象，自动触发执行
        print('init')
    def __call__(self, *args, **kwargs):  #对象加括号，触发执行
        print('call')
        return 1

r = Foo()()  #对象后面加括号，触发执行
print(r)

4，__getitem__、__setitem__、__delitem__

该三个方法用于分片操作

用于索引操作，如字典。以上分别表示获取、设置、删除数据

class Foo:
    def __getitem__(self, item):  #获取
        print(item)

    def __setitem__(self, key, value):  #设置
        print(key,value)

    def __delitem__(self, key):  #删除
        print(key)

r = Foo()             #__init__

r['sdkjfwien']       #__getitem__
r['hh'] = 123         #__setitem__
del r['hhgdajjfada'] #__delitem__
print(Foo.__dict__)  #__dict__  获取类或对象中的所有成员

5，__getslice__、__setslice__、__delslice__

用于分片操作

class Foo(object):

    def __getslice__(self, i, j):
        print ('__getslice__',i,j)

    def __setslice__(self, i, j, sequence):
        print ('__setslice__',i,j)

    def __delslice__(self, i, j):
        print ('__delslice__',i,j)

obj = Foo()

obj[0:1]                  # 自动触发执行 __getslice__
obj[0:1] = [11,22,33,44]    # 自动触发执行 __setslice__
del obj[0:2]               # 自动触发执行 __delslice__

 

6,__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'}

7，__doc__

表示类的描述信息

class Foo:
    """
    这个类的注释

     """

    def func(self):
        pass

print Foo.__doc__
#输出：类的描述信息

8，__module__ 和  __class__ 

__module__ 表示当前操作的对象在那个模块

__class__     表示当前操作的对象的类是什么

class C:

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

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

index.py

9，__str__

如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class Foo:

    def __str__(self):
        return 'hello'


obj = Foo()
print obj
# 输出：hello

异常处理

1,异常基础

try:
    pass
except Exception,ex:
    pass

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

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)

2，异常种类

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 = ["wupeiqi", 'alex']
try:
    dic[10]
except IndexError as e:
    print(e)

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

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

万能异常是Exception，他可以捕获任意异常

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

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

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

3，异常其他结构

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

4，主动触发异常

try:
    raise Exception('错误了。。。')
except Exception as e:
　　#封装了错误信息的对象
    print(e)

5，自定义异常

class Foo:
    def __init__(self,arg):
        self.xo = arg

    def __str__(self):
        return self.xo
obj = Foo('出错了...')
print(obj)

&

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

 单例模式

单例，顾名思义单个实例

实例：

面向对象场景一：

class ConnectionPool:

    __instance = None

    def __init__(self):
        self.ip = "1.1.1.1"
        self.port = 3306
        self.pwd = "123123"
        self.username = 'xxxx'
        #去连接
        self.conn__list = [1,2,3,4,5,6,7,8,9,10]

    @staticmethod
    def get_instance():
        if ConnectionPool.__instance:
            return ConnectionPool.__instance
        else:
            #创建一个对象，并将对象赋值给静态字段__instance
            ConnectionPool.__instance = ConnectionPool()
            return ConnectionPool.__instance

obj1 = ConnectionPool.get_instance()
print(obj1)
obj2 = ConnectionPool.get_instance()
print(obj2)
obj3 = ConnectionPool.get_instance()
print(obj3)

面向对象场景二：

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

• 增
• 删
• 改
• 查

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

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 ConnectionPool:

    __instance = None

    def __init__(self):
        self.ip = "1.1.1.1"
        self.port = 3306
        self.pwd = "123123"
        self.username = 'xxxx'
        # 去连接
        self.conn_list = [1,2,3,4,5,6,7,8,9, 10]

    @staticmethod
    def get_instance():
        if ConnectionPool.__instance:
            return ConnectionPool.__instance
        else:
            # 创建一个对象，并将对象赋值给静态字段 __instance
            ConnectionPool.__instance = ConnectionPool()
            return ConnectionPool.__instance

    def get_connection(self):
        # 获取连接
        import random
        r = random.randrange(1,11)
        return r

def index():
    # p = ConnectionPool()
    # print(p)
    p = ConnectionPool.get_instance()
    conn = p.get_connection()
    return "iiiiiii" + str(conn)

def news():
    return 'nnnnnnn'

def RunServer(environ, start_response):
    start_response(status='200 OK', headers=[('Content-Type', 'text/html')])

    url = environ['PATH_INFO']
    if url.endswith('index'):
        ret = index()
        return ret
    elif url.endswith('news'):
        ret = news()
        return ret
    else:
        return "404"


if __name__ == '__main__':
    httpd = make_server('', 8008, RunServer)
    print("Serving HTTP on port 8008...")
    httpd.serve_forever()

详细参考：http://www.cnblogs.com/wupeiqi/articles/5017742.html

　　　　　http://www.cnblogs.com/wupeiqi/p/4766801.html