面向对象基本知识：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用（可以将多函数中公用的变量封装到对象中）
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
面向对象类成员
一、变量
变量包括：类变量和实例变量，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，
类变量：属于类
实例变量：属于实例
class Role(object): #类变量，在内存中仅保存一份 ac = None def __init__(self,name,role,weapon,life_value): #实例变量，保存在各个实例中 self.name = name self.role = role self.weapon = weapon self.life_value = life_value def buy_gun(self,weapon): print("%s is buying [%s]" %(self.name,weapon)) self.weapon = weapon p1 = Role("p1",'police','b12',100) t1 = Role("t1",'tufei','b11',100) t2 = Role("t2",'tufei','b13',100) t3 = Role("t3",'tufei','b14',100) #实例赋值，将创建新的变量给实例 p1.ac = "China Brand" t1.ac = "US Brand" #类变量赋值，实例中没有创建该变量，继续使用类变量赋的值 Role.ac = "JP Brand" print("p1:",p1.weapon,p1.ac) print("t1:",t1.weapon,t1.ac) print("t2:",t2.weapon,t2.ac) print("t3:",t3.weapon,t3.ac)
由上述代码可以看出【实例变量需要通过对象来访问】【类变量可以通过类访问】，在使用上可以看出类变量和实例变量的归属是不同的。其在内容的存储方式类似如下图：
由上图可知：
- 类变量在内存中只保存一份
- 实例变量在每个实例中都要保存一份
应用场景： 通过类创建实例时，如果每个对象都具有相同的变量，那么就使用类变量。
二、方法
方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
- 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
- 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
- 静态方法：由类调用；无默认参数；
class Foo: def __init__(self, name): self.name = name def ord_func(self): """ 定义普通方法，至少有一个self参数 """ # print self.name print('普通方法') @classmethod #类方法，不能访问实例变量 def class_func(cls): """ 定义类方法，至少有一个cls参数 """ print('类方法') @staticmethod #静态方法，只是放在类下面，不能访问类和实例属性 def static_func(): """ 定义静态方法 ，无默认参数""" print('静态方法')
相同点：对于所有的方法而言，均属于类（非对象）中，所以，在内存中也只保存一份。
不同点：方法调用者不同、调用方法时自动传入的参数不同。
三、属性
如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。
对于属性，有以下三个知识点：
- 属性的基本使用
- 属性的两种定义方式
class foo(object): def __init__(self,name): self.name = name self.num = None #属性，将普通方法变成属性 @property def total_num(self): return self.num @total_num.setter def total_num(self,num): self.num = num print("total number is:",self.num) @total_num.deleter def total_num(self): print("total number got deleted") del self.num
#实例化 d = Animal("who") #调用属性
print(d.total_num) #属性赋值
d.total_num = 3 #删除属性
del d.total_num #报错num已经被删除
print(d.total_num)
由属性的定义和调用要注意一下几点：
- 定义时，在普通方法的基础上添加 @property 装饰器；
- 定义时，属性仅有一个self参数
- 调用时，无需括号
方法：obj.func()
属性：obj.total_num
注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象
属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。
四、类的私有化
类的所有成员都有两种形式：
- 公有成员，在任何地方都能访问
- 私有成员，只有在类的内部才能方法
定义不同：私有成员命名时，前两个字符是下划线。（特殊成员除外，例如：__init__、__call__、__dict__等）
class Animal(object): def __init__(self, name): self.name = name #公有变量 self.__num = None #私有变量
访问限制：只有在类的内部可以访问。。。
class C(object): __name = "私有类变量" def func(self): print(C.__name) class D(C): def show(self): print(C.__name) #AttributeError: type object 'C' has no attribute '_D__name' #print(D.__name) #AttributeError: type object 'D' has no attribute '_D__name' C.__name #类访问，出错 obj = C() obj.func() #类内部可以访问 obj_son = D() #无法继承私有类属性 obj_son.show() #派生类访问，出错
class E(object): def __init__(self): self.__foo = "私有实例变量" def func(self): print(self.__foo) #类内部访问 class F(E): def show(self): print(self.__foo) #派生类访问 obj2 = E() obj2.__foo #通过对象直接访问，出错 print(obj2._E__foo) #访问私有实例变量 obj2.func() #类内部访问 obj2_son = F() obj2_son.show() #派生类中访问，出错
方法、属性的访问于上述方式相似，即：私有成员只能在类内部使用，无法被继承
ps：非要访问私有属性的话，可以通过 对象._类__属性名
五、类的特殊成员
class foo(object): """ __doc__显示类的描述信息 """ def __init__(self): """ 注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ； """ self.name = None self.age = None self.sq = [] def __call__(self): """ __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()() """ print("__call__") def __str__(self): """ 如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。 :return: """ return "啥" def __iter__(self): """ 用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__ """ return iter(self.sq) def __del__(self): pass #def __new__(self): """ __new__方法接受的参数虽然也是和__init__一样，但__init__是在类实例创建之后调用，而 __new__方法正是创建这个类实例的方法。 一般不用使用这个方法，否则你将无法实例化对象 """ #pass
#实例化对象 f = foo() #自动执行__init__方法 f() #：对象() 或者 类()()调用__call__ foo()() #调用call方法 print(f.__doc__) #显示类的描述信息 print(f.__dict__) #类或对象中的所有成员 print(f) #方法输出__str__方法定义的返回值 for i in f:print(i) #类型内部定义了 __iter__，可以迭代
#test.py
import foo
obj = foo()
print(obj.__module__) # 表示当前操作的对象在那个模块
print(obj.__class__) # 表示当前操作的对象在那个类
print(isinstance(obj,foo))
__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，即：输出类
__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'}
__iter__
用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
class Foo(object): pass obj = Foo() for i in obj: print i # 报错：TypeError: 'Foo' object is not iterable
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __iter__(self): pass obj = Foo() for i in obj: print i # 报错：TypeError: iter() returned non-iterator of type 'NoneType'
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __init__(self, sq): self.sq = sq def __iter__(self): return iter(self.sq) obj = Foo([11,22,33,44]) for i in obj: print i
以上步骤可以看出，for循环迭代的其实是 iter([11,22,33,44]) ，所以执行流程可以变更为
#!/usr/bin/env python # -*- coding:utf-8 -*- obj = iter([11,22,33,44]) for i in obj: print i
六、反射
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')
反射实例
import sys class Webserver(object): def __init__(self,host,port): self.host = host self.port = port def start(self): print("Server is starting...") def stop(self): print("Server is stopping...") def restart(self): self.stop() self.start() #def test_run(name): # print("test running...",name) def test_run(self,name): #定义函数，setter添加该函数至实例方法 print("test running...",name,self.host) if __name__ == "__main__":
server = Webserver("1.1.1.1",9999) server2 = Webserver("2.2.2.2",9999)
#第三种实现 反射 if hasattr(server,sys.argv[1]): #判断sys.argv[1]是否在对象server中 func = getattr(server,sys.argv[1]) #获取server.method内存地址 func() #执行server.method()
setattr(server,"run",test_run) #在该实例 server 中,添加方法 run 方法名，test_run 函数，无法为方法自动传入self #server.run("koka") #执行添加不带self参数的test_run，无法调用实例变量 server.run(server,"koka") #执行添加self参数的test_run,调用的时候需要手动添加实例
setattr(server,"root","koka") #该在实例中添加变量，同上 print(server.root) #调用实例变量
#print(server2.root) #其他实例无法调用
delattr(Webserver,'start') #删除类中的start方法
print(server.restart())
""" 判断用户输入是否存在实例 #第一种实现 一个一个输出匹配 if sys.argv[1] == "start": 执行server.start() #第二种实现 定义字典查找 cmd_dic ={ "start":server.start, "stop":server.stop } if sys.argv[1] in cmd_dic: cmd_dic[sys.argv[1]]() """
结论：反射是通过字符串的形式操作对象相关的成员。一切事物都是对象！！！
更多内容请参考：http://www.cnblogs.com/wupeiqi/articles/5017742.html
七、异常处理
在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是现实一个提示的页面，通俗来说就是不让用户看见大黄页！！！
try: pass except Exception,ex: pass
常用的内建异常类
Exception 所有异常类的基类
AttributeError 特性引用或赋值失败时引发
IOError 试图打开不存在文件（报或其他情况）时引发
IndexError 在使用序列中不存在的索引时引发
KeyError 在使用映射中不存在的键是引发
NameError 在找不到名字（变量）时引发
SyntaxError 在代码为错误形式时引发
TypeError 在内建操作或者函数应用于错误类型的对象时引发
ValueError 在内建操作或者函数应用于正确类型的对象，但是该对象使用不合适的值时引发
ZeroDivisionError 在除法或者模除操作的第二个参数为0时引发
try..except
万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：
try: s = input('Enter something --> ') except EOFError: print(' Why did you do an EOF on me?') sys.exit() # exit the program except Exception: # 对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行 print(' Some error/exception occurred.') # here, we are not exiting the program
手动触发异常
Raise IndexError
如果捕捉到异常，但是有想重新引发它（也就是说要传递异常参数），那么可以调用不带参数的异常（还能在捕捉到异常的时候显示的提供具体异常）
多个异常语句
s1 = 'hello' try: int(s1) except KeyError as e: print('键错误') except IndexError as e: print('索引错误') except Exception as e: print('错误')
try..finally
try: f = open('poem.txt') while True: # our usual file-reading idiom line = f.readline() if len(line) == 0: break time.sleep(2) print(line) finally: f.close() print('Cleaning up...closed the file') class MyException(Exception): pass try: print("normal code here") except MyException: print("MyException encoutered") else: print "No exception”
自定义异常
class MyException(Exception): pass try: #some code here raise MyException except MyException: print("MyException encoutered")