Python之面向对象

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 = 12

p = 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.__age

p = people()
print(p.getName(),p.getAge())

注意：　   

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

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

四.类中内置的方法

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

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

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

class Person:
population=0

def __init__(self,name):
print("Person类正在实例化")
self.name=name
print("类名为",self.name)
self.population += 1

def __del__(self):#析构函数
print("Person类正在析构",self.name)
self.population -= 1

if self.population == 0:
print("I am the last One")
else:
print("There are still",self.population,"left")

def sayHi(self):
print("Hello World",self.name)

def howMany(self):
print("We have,",self.population,"Person Now")

swaroop = Person("swaroop")
swaroop.sayHi()
swaroop.howMany()

kalam = Person("kalam")
kalam.sayHi()
kalam.howMany()

swaroop.sayHi()
#输出：

Person类正在实例化
类名为 swaroop
Hello World swaroop
We have, 1 Person Now
Person类正在实例化
类名为 kalam
Hello World kalam
We have, 1 Person Now
Hello World swaroop
Person类正在析构 swaroop
I am the last One
Person类正在析构 kalam
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:

class Foo:

def __init__(self, name, age):
self.name = name
self.age = age

obj1 = Foo('wupeiqi', 18)
print(obj1.name)    # 直接调用obj1对象的name属性
print(obj1.age)    # 直接调用obj1对象的age属性

obj2 = Foo('alex', 73)
print(obj2.name)    # 直接调用obj2对象的name属性
print(obj2.age)     # 直接调用obj2对象的age属性

wupeiqi
18
alex
73

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

执行类中的方法时，需要通过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('wupeiqi', 18)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Foo('alex', 73)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

wupeiqi
18
alex
73

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

• 小明，10岁，男，上山去砍柴
• 小明，10岁，男，开车去东北
• 小明，10岁，男，最爱大保健
• 老李，90岁，男，上山去砍柴
• 老李，90岁，男，开车去东北
• 老李，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()

面向对象

2 . 继承

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

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

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

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

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

class F1:#父类，基类

def show(self):
print("show")

def foo(self):
print(self.name)

class F2(F1): #子类，派生类
def __init__(self, name):
self.name = name

def bar(self):
print("bar")
def show(self):
print("F2,show")

obj = F2("hong")
obj.foo()

hong

class SchoolMember:
def __init__(self,name,age):
self.name=name
self.age=age
print(self.name,"正在实例化")

def tell(self):
print("Name is",self.name,"and Age is",self.age)

class Teacher(SchoolMember):
def __init__(self,name,age,salary):
SchoolMember.__init__(self, name, age)
self.salary=salary
print("教师类正在实例化")

def tell(self):
SchoolMember.tell(self)
print("工资为",self.salary)
t = Teacher("A",12,300)
t.tell()
#输出:

A 正在实例化
教师类正在实例化
Name is A and Age is 12
工资为 300