标签：
类的成员分为三大类：
1,字段 静态字段（每个对象都有一份时用）、普通字段（每个对象都不的数据时用）
2,方法 静态方法（无需使用对象封装的内容）、类方法、普通方法（使用对象中的数据）
3,特性 普通特性（将方法伪造成字段）
通过类访问：静态字段、静态方法、类方法
通过对象访问：普通字段、普通方法，类方法
1 class Provice: 2 #静态字段：在类中；在内存中只保存一份 3 country = "中国" 4 5 6 7 def __init__(self,name): 8 temp = "xxx" 9 #普通字段，在对象中；在每个对象中都要保存一份 10 self.name = name 11 12 #普通方法，类中 13 def show(self): 14 print(‘show‘) 15 16 #类方法 17 @classmethod 18 def xxoo(cls): #类名 19 print(‘xxoo‘) 20 # print(‘xxoo‘,cls) 21 22 #静态方法 23 @staticmethod 24 def xo(arg1,arg2): 25 print(‘xo‘) 26 27 def start(self): 28 temp = "%s sb" %self.name 29 return temp 30 31 #特性，将方法伪造成一种字段 32 @property 33 def end1(self): 34 temp = "%s sb" % self.name 35 return temp 36 37 @end1.setter #类名+setter 修改参数 38 def end1(self,value): 39 40 # print(value) 41 self.name = value 42 43 obj = Provice("123") 44 print(obj.end1) 45 obj.end1 = "456" 46 print(obj.end1) 47 48 obj = Provice(‘alex‘) 49 print(obj.end1) 50 obj.end1 = "123" 51 print(obj.end1) 52 53 54 obj = Provice(‘alex‘) 55 #print(obj.name) 56 ret1 = obj.start() 57 ret2 = obj.end1 58 print(ret1) 59 Provice.xo(1,2) #执行静态方法 60 Provice.xxoo() #执行类方法 61 hebei = Provice("河北") 62 henan = Provice("河南") 63 #1,自己去访问自己的成员 64 #2,除了类中的方法 65 66 print(Provice.country) 67 obj = Provice(‘alex‘) 68 obj.show()
总结：
快速判断，是类执行还是对象执行：
1，有self 对象执行
2，无self 类调用
调用方法：
普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
静态方法：由类调用；无默认参数；
特性：
定义时，普通方法的基础上添加 @property
定义时，属性仅有一个self参数
调用时，无需括号
公共成员，在任何地方都能访问
私有成员，只有在类的内部才能访问；私有成员命名，前两个字符使下划线（特殊成员除外）。
a，公有静态字段：类可以访问；类内部可以访问；派生类中可以访问
实例：
1 class C: 2 3 name = "hello" 4 5 def func(self): 6 print(C.name) 7 8 class D(C): 9 10 def show(self): 11 print(C.name) 12 13 14 C.name # 类访问 15 16 obj = C() 17 obj.func() # 类内部可以访问 18 19 obj_son = D() 20 obj_son.show() # 派生类中可以访问
b，私有静态字段：仅类内部可以访问；
实例：
1 class Foo: 2 # xo = "xo" 3 __ox = "ox" #只能被内部取到，不能被外部取到 4 def fetch(self): 5 print(Foo.__ox) 6 # 7 obj = Foo() 8 obj.fetch()
公有普通字段：对象可以访问；类内部可以访问；派生类中可以访问
1 class C: 2 3 def __init__(self): 4 self.foo = "公有字段" 5 6 def func(self): 7 print(self.foo) #类内部访问 8 9 class D(C): 10 11 def show(self): 12 print(self.foo) # 派生类中访问 13 14 obj = C() 15 16 obj.foo # 通过对象访问 17 obj.func() # 类内部访问 18 19 obj_son = D() 20 obj_son.show() # 派生类中访问
私有普通字段：仅类内部可以访问
1 class C: 2 3 def __init__(self): 4 self.__foo = "私有字段" 5 6 def func(self): 7 print(self.foo)#类内部访问 8 9 class D(C): 10 11 def show(self): 12 print(self.foo)#派生类中访问 13 14 obj = C() 15 16 obj.__foo # 通过对象访问 ==> 错误 17 obj.func() # 类内部访问 ==> 正确 18 19 obj_son = D() 20 obj_son.show() # 派生类中访问 ==> 错误
构造方法，通过类创建对象时，自动触发执行。
1 class Annimal: 2 def __init__(self): 3 print(‘A构造方法‘) 4 self.ty = "动物" 5 6 class Cat(Annimal): 7 def __init__(self): 8 print(‘B构造方法‘) 9 self.n = "猫" 10 11 super(Cat,self).__init__() #super().__init__()执行父类的构造方法 12 #Annimal.__init__(self) #这样也行，但不推荐 13 14 #类后面加括号自动执行 15 #数据初始化 16 c = Cat() 17 print(c.__dict__)
析构方法，当对象在内存中被释放时，自动触发执行
class Foo: def __del__(self): pass
对象后面加括号，触发执行。
1 class Foo: 2 def __init__(self): #构造方法，通过类创建对象，自动触发执行 3 print(‘init‘) 4 def __call__(self, *args, **kwargs): #对象加括号，触发执行 5 print(‘call‘) 6 return 1 7 8 r = Foo()() #对象后面加括号，触发执行 9 print(r)
该三个方法用于分片操作
用于索引操作，如字典。以上分别表示获取、设置、删除数据
1 class Foo: 2 def __getitem__(self, item): #获取 3 print(item) 4 5 def __setitem__(self, key, value): #设置 6 print(key,value) 7 8 def __delitem__(self, key): #删除 9 print(key) 10 11 r = Foo() #__init__ 12 13 r[‘sdkjfwien‘] #__getitem__ 14 r[‘hh‘] = 123 #__setitem__ 15 del r[‘hhgdajjfada‘] #__delitem__ 16 print(Foo.__dict__) #__dict__ 获取类或对象中的所有成员
用于分片操作
1 class Foo(object): 2 3 def __getslice__(self, i, j): 4 print (‘__getslice__‘,i,j) 5 6 def __setslice__(self, i, j, sequence): 7 print (‘__setslice__‘,i,j) 8 9 def __delslice__(self, i, j): 10 print (‘__delslice__‘,i,j) 11 12 obj = Foo() 13 14 obj[0:1] # 自动触发执行 __getslice__ 15 obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ 16 del obj[0:2] # 自动触发执行 __delslice__
类或对象中的所有成员
1 class Province: 2 3 country = ‘China‘ 4 5 def __init__(self, name, count): 6 self.name = name 7 self.count = count 8 9 def func(self, *args, **kwargs): 10 print ‘func‘ 11 12 # 获取类的成员，即：静态字段、方法、 13 print Province.__dict__ 14 # 输出：{‘country‘: ‘China‘, ‘__module__‘: ‘__main__‘, ‘func‘: <function func at 0x10be30f50>, ‘__init__‘: <function __init__ at 0x10be30ed8>, ‘__doc__‘: None} 15 16 obj1 = Province(‘HeBei‘,10000) 17 print obj1.__dict__ 18 # 获取 对象obj1 的成员 19 # 输出：{‘count‘: 10000, ‘name‘: ‘HeBei‘} 20 21 obj2 = Province(‘HeNan‘, 3888) 22 print obj2.__dict__ 23 # 获取 对象obj1 的成员 24 # 输出：{‘count‘: 3888, ‘name‘: ‘HeNan‘}
表示类的描述信息
class Foo: """ 这个类的注释 """ def func(self): pass print Foo.__doc__ #输出：类的描述信息
__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
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)
1 AttributeError 试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x 2 IOError 输入/输出异常；基本上是无法打开文件 3 ImportError 无法引入模块或包；基本上是路径问题或名称错误 4 IndentationError 语法错误（的子类） ；代码没有正确对齐 5 IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5] 6 KeyError 试图访问字典里不存在的键 7 KeyboardInterrupt Ctrl+C被按下 8 NameError 使用一个还未被赋予对象的变量 9 SyntaxError Python代码非法，代码不能编译(个人认为这是语法错误，写错了） 10 TypeError 传入对象类型与要求的不符合 11 UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量， 12 导致你以为正在访问它 13 ValueError 传入一个调用者不期望的值，即使值的类型是正确的 14 15 常用异常
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(‘错误‘)
try: # 主代码块 pass except KeyError,e: # 异常时，执行该块 pass else: # 主代码块执行完，执行该块 pass finally: # 无论异常与否，最终执行该块 pass
try: raise Exception(‘错误了。。。‘) except Exception as e:
#封装了错误信息的对象 print(e)
1 class Foo: 2 def __init__(self,arg): 3 self.xo = arg 4 5 def __str__(self): 6 return self.xo 7 obj = Foo(‘出错了...‘) 8 print(obj)
&
1 class WupeiqiException(Exception): 2 3 def __init__(self, msg): 4 self.message = msg 5 6 def __str__(self): 7 return self.message 8 9 try: 10 raise WupeiqiException(‘我的异常‘) 11 except WupeiqiException,e: 12 print e
1 # assert 条件 2 3 assert 1 == 1 4 5 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
标签：
原文地址：http://www.cnblogs.com/kongqi816-boke/p/5556723.html
