Python

　

　　面向对象：　　　　

　　　　面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

　　　　类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

　　　　对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

一. 如何定义一个类

　　在进行python面向对象编程之前，先来了解几个术语：类，类对象，实例对象，属性，函数和方法。

　　类是对现实世界中一些事物的封装，定义一个类可以采用下面的方式来定义：

class className:    block

　　注意类名后面有个冒号，在block块里面就可以定义属性和方法了。当一个类定义完之后，就产生了一个类对象。类对象支持两种操作：引用和实例化。引用操作是通过类对象去调用类中的属性或者方法，而实例化是产生出一个类对象的实例，称作实例对象。比如定义了一个people类：

class people:    name = 'jack'       #定义了一个属性    #定义了一个方法    def printName(self):        print self.name

　　people类定义完成之后就产生了一个全局的类对象，可以通过类对象来访问类中的属性和方法了。当通过people.name（至于为什么可以直接这样访问属性后面再解释，这里只要理解类对象这个概念就行了）来访问时，people.name中的people称为类对象，这点和C++中的有所不同。当然还可以进行实例化操作，p=people( )，这样就产生了一个people的实例对象，此时也可以通过实例对象p来访问属性或者方法了(p.name).

　　理解了类、类对象和实例对象的区别之后，我们来了解一下Python中属性、方法和函数的区别。

　　在上面代码中注释的很清楚了，name是一个属性，printName( )是一个方法，与某个对象进行绑定的函数称作为方法。一般在类里面定义的函数与类对象或者实例对象绑定了，所以称作为方法；而在类外定义的函数一般没有同对象进行绑定，就称为函数。

 

二.属性

　　在类中我们可以定义一些属性，比如：

class people:    name = 'jack'    age = 12p = people()print p.name,p.age

　　定义了一个people类，里面定义了name和age属性，默认值分别为'jack'和12。在定义了类之后，就可以用来产生实例化对象了，这句p = people( )实例化了一个对象p，然后就可以通过p来读取属性了。

 

三.方法

　　在类中可以根据需要定义一些方法，定义方法采用def关键字，在类中定义的方法至少会有一个参数，，一般以名为'self'的变量作为该参数（用其他名称也可以），而且需要作为第一个参数。下面看个例子：

class people:    __name = 'jack'    __age = 12    def getName(self):        return self.__name    def getAge(self):        return self.__agep = people()print(p.getName(),p.getAge())

注意：　   

　　self是一个Python自动会给传值得参数

obj1.fetch('selec...') self = obj1obj2.fetch('selec...') self = obj1

 

四.类中内置的方法

　　在Python中有一些内置的方法，这些方法命名都有比较特殊的地方（其方法名以2个下划线开始然后以2个下划线结束）。类中最常用的就是构造方法和析构方法。

　　构造方法__init__(self,....)在生成对象时调用，可以用来进行一些初始化操作，不需要显示去调用，系统会默认去执行。构造方法支持重载，如果用户自己没有重新定义构造方法，系统就自动执行默认的构造方法。

　　析构方法__del__(self)在释放对象时调用，支持重载，可以在里面进行一些释放资源的操作，不需要显示调用。

1 class Person: 2     population=0 3  4     def __init__(self,name): 5         print("Person类正在实例化") 6         self.name=name 7         print("类名为",self.name) 8         self.population += 1 9 10     def __del__(self):#析构函数11         print("Person类正在析构",self.name)12         self.population -= 113 14         if self.population == 0:15             print("I am the last One")16         else:17             print("There are still",self.population,"left")18 19     def sayHi(self):20         print("Hello World",self.name)21 22     def howMany(self):23         print("We have,",self.population,"Person Now")24 25 swaroop = Person("swaroop")26 swaroop.sayHi()27 swaroop.howMany()28 29 kalam = Person("kalam")30 kalam.sayHi()31 kalam.howMany()32 33 swaroop.sayHi()34 #输出：35 36 Person类正在实例化37 类名为 swaroop38 Hello World swaroop39 We have, 1 Person Now40 Person类正在实例化41 类名为 kalam42 Hello World kalam43 We have, 1 Person Now44 Hello World swaroop45 Person类正在析构 swaroop46 I am the last One47 Person类正在析构 kalam48 I am the last One

面向对象三大特性(引用)

面向对象的三大特性是指：封装、继承和多态。

1 . 封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

第一步：将内容封装到某处

 self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1

                              当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2

所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

• 通过对象直接调用
• 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名 1 class Foo:

 

1 class Foo: 2  3     def __init__(self, name, age): 4         self.name = name 5         self.age = age 6  7 obj1 = Foo('wupeiqi', 18) 8 print(obj1.name)    # 直接调用obj1对象的name属性 9 print(obj1.age)    # 直接调用obj1对象的age属性10 11 obj2 = Foo('alex', 73)12 print(obj2.name)    # 直接调用obj2对象的name属性13 print(obj2.age)     # 直接调用obj2对象的age属性14 15 wupeiqi16 1817 alex18 73

 

 

 

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

1 class Foo: 2  3     def __init__(self, name, age): 4         self.name = name 5         self.age = age 6  7     def detail(self): 8         print(self.name) 9         print(self.age)10 11 obj1 = Foo('wupeiqi', 18)12 obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 1813 14 obj2 = Foo('alex', 73)15 obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 7816 17 wupeiqi18 1819 alex20 73

练习一：在终端输出如下信息

• 小明，10岁，男，上山去砍柴
• 小明，10岁，男，开车去东北
• 小明，10岁，男，最爱大保健
• 老李，90岁，男，上山去砍柴
• 老李，90岁，男，开车去东北
• 老李，90岁，男，最爱大保健

1 class Foo: 2      3     def __init__(self, name, age ,gender): 4         self.name = name 5         self.age = age 6         self.gender = gender 7  8     def kanchai(self): 9         print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)10 11     def qudongbei(self):12         print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)13 14     def dabaojian(self):15         print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)16 17 18 xiaoming = Foo('小明', 10, '男')19 xiaoming.kanchai()20 xiaoming.qudongbei()21 xiaoming.dabaojian()22 23 laoli = Foo('老李', 90, '男')24 laoli.kanchai()25 laoli.qudongbei()26 laoli.dabaojian()27 28 面向对象

 

2 . 继承

         面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

　　

　在python中继承中的一些特点：

　　　(1)：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。有别于C#

　　　(2)：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

　　　(3)：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

1 class F1:#父类，基类 2  3     def show(self): 4         print("show") 5  6     def foo(self): 7         print(self.name) 8  9 class F2(F1): #子类，派生类10     def __init__(self, name):11         self.name = name12 13     def bar(self):14         print("bar")15     def show(self):16         print("F2,show")17 18 obj = F2("hong")19 obj.foo()20 21 hong

1 class SchoolMember:   2     def __init__(self,name,age):   3         self.name=name   4         self.age=age   5         print(self.name,"正在实例化")   6            7     def tell(self):   8         print("Name is",self.name,"and Age is",self.age)   9           10 class Teacher(SchoolMember):  11     def __init__(self,name,age,salary):  12         SchoolMember.__init__(self, name, age)  13         self.salary=salary  14         print("教师类正在实例化")  15           16     def tell(self):  17         SchoolMember.tell(self)  18         print("工资为",self.salary)  19 t = Teacher("A",12,300)  20 t.tell()  21 #输出:22 23 A 正在实例化24 教师类正在实例化25 Name is A and Age is 1226 工资为 300