面向对象三大特性： 封装、继承、多态。
python中默认就支持了多态。所以不用关注多态的知识点。我们主要的知识点就放在封装和继承上，封装和继承是基本的知识。
1、创建简单的类和对象。
class foo(): def foo_test(self): print ('This is foo.foo_test') f = foo() f.foo_test() # This is foo.foo_test # 先创建了一个foo类，这个类中只有一个foo_test方法。 # f = foo() 是把foo类实例化成了一个f对象。 # f.foo_test() 是f调用了foo_test方法。这是在执行foo类中的foo_test方法。
class foo(): def foo_test(self,arg): print (arg) f = foo() f.foo_test('test_arg') # test_arg # 向foo_test方法传递arg的参数。
class foo(): def foo_test(self,arg): print (self,arg) f = foo() print (f) f.foo_test('test1') f2 = foo() print (f2) f2.foo_test('rr3r3') # <__main__.foo object at 0x03894110> # <__main__.foo object at 0x03894110> test1 # <__main__.foo object at 0x038941F0> # <__main__.foo object at 0x038941F0> rr3r3 #
在执行 print (f)的时候，时可以看到f这个对象的内存地址的。当f.foo_test('test1')掉用foo_test时，我们在foo_test函数内也打印self。这时的self内存地址和f这个对象的内存地址一致。所以说明self是调用这个方法的对象。
同样的在f2这个对象的内存地址也说明了self。实例化的对象，self就是哪个对象。
2、在类中创建方法
构造方法就是当实例化一个对象时，就默认执行的方法。
class foo(): def __init__(self): self.test = 'error' print ('internal month') def foo_test(self,arg): print (self.test) print (arg) f = foo() f.test = '123' f.foo_test('arg_') # internal month # error # arg_ # 在实例化foo对象时，这个__init__内部方法是默认执行的。这个init就是构造方法。
在这例子中，当执行f = foo()时，就会执行foo类中的__init__方法。这个__init__方法就是构造方法。
其中f.test是通过对象想类中的方法传递参数。
最后我们调用了foo_test方法，并向他传递了arg_参数。
3、面向对象三大特性 - 封装
class foo(): def __init__(self,name,age,gender): # 把初始化时的，name,age,gender都封装到类中。 self.name = name self.age = age self.gender = gender def show(self,arg): print (self.name,self.age,self.gender,arg) xiaoming = foo('小明','10','男') xiaoming.show('上山去砍柴') xiaoming.show('开车去东北') xiaoming.show('最爱大保健') zhangsan = foo('张三','10','男') zhangsan.show('上山去砍柴') zhangsan.show('开车去东北') zhangsan.show('最爱大保健') # 小明 10 男 上山去砍柴 # 小明 10 男 开车去东北 # 小明 10 男 最爱大保健 # 张三 10 男 上山去砍柴 # 张三 10 男 开车去东北 # 张三 10 男 最爱大保健
在这个例子中，我们就将name,age,gender这些相同的参数通过构造方法封装到了foo这个类中。所以在之后的show中才能直接调用。
4、面向对象三大特性 - 继承
class foo(): def show(self): print ('foo.show') class foo_1(foo): def foo_1_show(self): print ('foo_1.foo_1_show') test_obj = foo_1() test_obj.show()
# foo.show
foo_1这个类在定义的时候就继承了foo类。所以在执行test_obj.show()方法时，执行了父类中的show方法，因为foo_1这个类中没有show方法。
class foo(): def show1(self): print ('foo.show1') class foo2(foo): def show_1(self): super(foo2,self).show1() #有两种调用父类中的方法,推荐用这种方法 # foo.show1(self) print ('foo2.show1') test_obj = foo2() test_obj.show_1() # foo.show1 # foo2.show1
class foo(): def show(self): print ('foo.show') class foo_1(foo): def foo_1_show(self): print ('foo_1.foo_1_show') def show(self): print ('foo_1.show') test_obj = foo_1() test_obj.show() # foo_1.show
我们在foo_1定义了与父类相同名称的方法，这时父类的方法就不生效了。就会执行子类中的show方法。
首先是当继承了多个父类时，我们要先从左到右的顺序查找。
class f2(): def show(self): print ('f2.show') class f1(f2): def show1(self): print ('f1.show') class ff1(): def show(self): print ('ff1.show') class sun(f1,ff1): pass obj = sun() obj.show() # f2.show
这里说的从左到右的查找顺序是说，在继承的时候class sun(f1,ff1): 。这行代码中f1在ff1左边。
在说一种情况
在这样的继承中查找方法的顺序应该是，先在f1、f2中查找。如果没有在从ff1中查找，如果ff1中也没有再找最后的根f3。
class f3(): def show(self): print ('f3.show') class f2(f3): def show1(self): print ('f2.show') class f1(f2): def show1(self): print ('f1.show') class ff1(f3): def show(self): print ('ff1.show') class sun(f1,ff1): pass obj = sun() obj.show() # ff1.show
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。