python面向对象个人总结
基础概念:
面向对象其实就是类与对象的使用。 类是模板,对象是实例。模板创建实例,实例去类里面去执行类的方法。
类的例子:
class Foo: def Bar(self): print 'Bar' def Hello(self, name): print 'i am %s' %name # 根据类Foo创建对象obj obj = Foo() obj.Bar() #执行Bar方法 obj.Hello('name') #执行Hello方法
函数式的编程方式与面向对象的编程方式:(相互比较下,python中可以一起使用。)
函数式: def kanchai(name, age, gender): print "%s,%s岁,%s,上山去砍柴" %(name, age, gender) def qudongbei(name, age, gender): print "%s,%s岁,%s,开车去东北" %(name, age, gender) def dabaojian(name, age, gender): print "%s,%s岁,%s,最爱大保健" %(name, age, gender) kanchai('小明', 10, '男') qudongbei('小明', 10, '男') dabaojian('小明', 10, '男') kanchai('老李', 90, '男') qudongbei('老李', 90, '男') dabaojian('老李', 90, '男') ------------------------------------------------------------------------------------ 面向对象: class Foo: def __init__(self, name, age ,gender): self.name = name self.age = age self.gender = gender def kanchai(self): print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender) def qudongbei(self): print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender) def dabaojian(self): print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender) xiaoming = Foo('小明', 10, '男') xiaoming.kanchai() xiaoming.qudongbei() xiaoming.dabaojian() laoli = Foo('老李', 90, '男') laoli.kanchai() laoli.qudongbei() laoli.dabaojian()
基础特性:
1.封装,直接看例子:
直接调用构造方法的属性: class Foo: def __init__(self, name, age): self.name = name self.age = age obj1 = Foo('a', 18) print obj1.name # 直接调用obj1对象的name属性 print obj1.age # 直接调用obj1对象的age属性 obj2 = Foo('b', 19) print obj2.name # 直接调用obj2对象的name属性 print obj2.age # 直接调用obj2对象的age属性 ---------------------------------------------------------------------------------- 通过self,以及动态方法间接去调用构造方法的属性: class Foo: def __init__(self, name, age): self.name = name self.age = age def detail(self): print self.name print self.age obj1 = Foo('a', 18) obj1.detail() # Python默认会将obj1传给self参数,即:obj1.detail(obj1),所以,此时方法内部的 self = obj1,即:self.name 是 a ;self.age 是 18 obj2 = Foo('b', 19) obj2.detail() # Python默认会将obj2传给self参数,即:obj1.detail(obj2),所以,此时方法内部的 self = obj2,即:self.name 是 b ;self.age 是 19
2.继承
父类与子类,也有叫基类与派生类。继承没啥好说的,就是子类继承父类,看去执行基类中的方法。
python中有经典类与新式类之间的区别。有无继承object类
经典类:
class D: def bar(self): print 'D.bar' class C(D): def bar(self): print 'C.bar' class B(D): def bar(self): print 'B.bar' class A(B, C): def bar(self): print 'A.bar' a = A() # 执行bar方法时 # 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错 # 所以,查找顺序:A --> B --> D --> C # 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了 a.bar()
新式类:
class D(object): def bar(self): print 'D.bar' class C(D): def bar(self): print 'C.bar' class B(D): def bar(self): print 'B.bar' class A(B, C): def bar(self): print 'A.bar' a = A() # 执行bar方法时 # 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错 # 所以,查找顺序:A --> B --> C --> D # 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了 a.bar()
--20160111整理个实例进去,继承的顺序。
class Base(object): def __init__(self,name): self.name = name self.Testfunc() def Testfunc(self): print 'do Base Testfunc' class Son(Base): def Testfunc(self): print 'do Son Testfunc' sonobj = Son('sonobj') -------------------------------------------------- __author__ = 'ganzl' #_*_coding:utf-8_*_ class Base(object): def Testfunc(self): print 'do Base Testfunc' class Son(Base): def __init__(self,name): self.name = name self.Testfunc() def Testfunc(self): print 'do Son Testfunc' class Base2(object): def Testfunc(self): print 'do Base2 Testfunc' class GrandSon(Base2,Son): pass #sonobj = Son('sonobj') sonobj = GrandSon('sonobj') --------------------------------------------------
3.多态,这个不是很清楚。求各位大神介绍下
类成员的介绍:
类的三个成员:
方法:普通方法,类方法,静态方法
字段:普通字段,静态字段
属性:普通属性
直接看例子:
class Foo: mono = '静态字段' #静态字段属于类 def __init__(self, name, age): self.Name = name #动态字段属于对象 self.Age = age self.__Thailand = flag #私有字段 :只能在类里访问,别人访问不了。 def eat(self): #对象可以访问动态方法 print self.Name + 'i am eating...' @staticmethod def sleep(): print '静态方法' #①加上装饰器②self去掉。这样就变成静态方法 @property #@property何时去使用:当涉及到私有字段的更改,读取,只读只写时,可用到。abc.Bar = 'XX'(赋给私有字段) def Bar(self): print self.Name #特性 return self.__Thailand def show(self): #访问私有字段,通过共有方法 abc.show() print self.__Thailand def __sha(self): #私有方法 print '我是al' def Foo2(self): #访问私有方法,通过共有方法 abc.Foo2()或者 abc._Foo__sha() self.__sha() abc = Foo('gan','20') print abc.name print Foo.mono (静态字段,尽量用类去取。不用对象去取值) print Foo.name #类不能访问动态字段 print abc.mono #对象可以访问静态字段 (其他语言是访问不了的) #执行对象的方法 abc.eat() #对象访问 #执行类的静态方法 Foo.sleep() # 类访问 #执行特性 abc.Bar #方法的访问形式 变成 字段的访问形式,访问的时候不需要再加括号 @staticmethod #为什么要用静态方法; 静态方法的使用形式(相当于函数式变成,直接调用) #直接使用类去访问方法,不需要实例化,节省内存开辟的空间:(操作数据库时) @classmethod #类方法。 def f2(cls): #只能有一个参数cls,表示的是class,并将类传入 pass
#静态方法跟类方法不用创建对象,直接访问。
新式类的属性的定义:(也要看的明白)
# ############### 定义 ############### class Goods(object): @property def price(self): print '@property' @price.setter def price(self, value): print '@price.setter' @price.deleter def price(self): print '@price.deleter' # ############### 调用 ############### obj = Goods() obj.price # 自动执行 @property 修饰的 price 方法,并获取方法的返回值 obj.price = 123 # 自动执行 @price.setter 修饰的 price 方法,并将 123 赋值给方法的参数 del obj.price # 自动执行 @price.deleter 修饰的 price 方法
公有私有的区别
上面例子也有讲到私有的概念,这里再举个例子:
公有成员,在任何地方都能访问
私有成员,只有在类的内部才能方法
私有成员和公有成员的定义不同:私有成员命名时,前两个字符是下划线。
class C: def __init__(self): self.name = '公有字段' self.__foo = "私有字段"
静态字段
公有静态字段:类可以访问;类内部可以访问;派生类中可以访问
私有静态字段:仅类内部可以访问
----------------------------------------------- class C: name = "公有静态字段" 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() # 派生类中可以访问 ----------------------------------------------- class C: __name = "私有静态字段" 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() # 派生类中可以访问 ==> 错误 -----------------------------------------------
普通字段
公有普通字段:对象可以访问;类内部可以访问;派生类中可以访问
私有普通字段:仅类内部可以访问
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. __doc__
表示类的描述信息
class Foo: """ 描述类信息,这是用于看片的神奇 """ def func(self): pass print Foo.__doc__ #输出:类的描述信息
2. __module__ 和 __class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
#!/usr/bin/env python # -*- coding:utf-8 -*- class C: def __init__(self): self.name = 'a' from lib.aa import C obj = C() print obj.__module__ # 输出 lib.aa,即:输出模块 print obj.__class__ # 输出 lib.aa.C,即:输出类
3. __init__
构造方法,通过类创建对象时,自动触发执行。
class Foo: def __init__(self, name): self.name = name self.age = 18 obj = Foo('a') # 自动执行类中的 __init__ 方法
4. __del__
析构方法,当对象在内存中被释放时,自动触发执行。
注:对象销毁的时候,做的动作,做的最后一次呐喊。一般情况用不到。def __del__(self):
class Foo: def __init__(self): pass def __del__(self): print "abc" def Go(self): print "GO" def __call__(self): print 'call' f1=Foo() f1.Go() f1() f1=Foo() #Foo()加上()就是执行构造方法 f1() #f1,对象加上(),就是执行类的__call__方法。
5. __call__(如上例子)
对象后面加括号,触发执行。
注:构造方法的执行是由创建对象触发的,即:对象 = 类名() ;而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()()
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. __str__
如果一个类中定义了__str__方法,那么在打印 对象 时,默认输出该方法的返回值。
class Foo: def __str__(self): return 'a' obj = Foo() print obj # 输出:a
8、__getitem__、__setitem__、__delitem__
用于索引操作,如字典。以上分别表示获取、设置、删除数据
#!/usr/bin/env python # -*- coding:utf-8 -*- class Foo(object): def __getitem__(self, key): print '__getitem__',key def __setitem__(self, key, value): print '__setitem__',key,value def __delitem__(self, key): print '__delitem__',key obj = Foo() result = obj['k1'] # 自动触发执行 __getitem__ obj['k2'] = 'a' # 自动触发执行 __setitem__ del obj['k1'] # 自动触发执行 __delitem__
9、__getslice__、__setslice__、__delslice__
该三个方法用于分片操作,如:列表
法用于分片操作,如:列表 #!/usr/bin/env python # -*- coding:utf-8 -*- 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[-1:1] # 自动触发执行 __getslice__ obj[0:1] = [11,22,33,44] # 自动触发执行 __setslice__ del obj[0:2] # 自动触发执行 __delslice__
10. __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 ---------------------------------------------------------------------- #!/usr/bin/env python # -*- coding:utf-8 -*- obj = iter([11,22,33,44]) while True: val = obj.next() print val ----------------------------------------------------------------------