面向对象编程
面向对象编程是一种编程方式,需要使用 “类” 和 “对象” 来实现:
类就是一个模板,模板里可以包含多个函数,函数里实现一些功能,实现对具有共同特征的事物的描述;
对象是类的实体,是一种数据类型。它不存在内存中,不能被直接操作,只有被实例化对象时,才会变的可操作。举例说明:#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Student(): #calss是关键字,表示类Student是类的名称,通常首字母大写。
s=100 #类属性,属于全局变量。
‘’’
这是一个测试类#给类添加注释
‘’’
def name(self,name): #类中的函数,第一个参数必须是self。
print 'I am %s'%name
def score(self):
print self.s #方法中调用类属性
obj=Student() #obj就是对象的实例化,可使用tyte(obj)查看其类型。
obj.name('zhangsan') #调用类的方法,输出结果为”I am zhangsan”
一、__init__初始化实例属性
python中定义了一个__init__方法,可以初始化类变量、传递类的参数,例如:
#初始化类变量#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Student():
def __init__(self): #__init__函数定义到类的开头
self.name='zhangsan' #初始化变量,在以后的函数中可以调用。
self.score=100
def print_score(self):
print '%s:%s'%(self.name,self.score) #调用self.name
f=Student()
f.print_score()
注意:self.name 变量是一个实例属性,只能在类方法中使用。
#传参#!/usr/bin/env python
# -*- coding:utf-8 -*-
class Student():
def __init__(self,a,b):
self.name=a #初始化变量,只不过赋予的不是固定值,是一个可变参数。
self.score=b
def print_score(self):
print '%s:%s'%(self.name,self.score)
f=Student('zhangsan','100') #定义参数,传递给__init__函数
f.print_score()
注意:我们没有专门调用__init__方法,只是在创建一个类的新实例的时候,把参数包括在圆括号内跟在类名后面,从而传递给__init__方法。
二、私有属性
以双下划线开头的变量,表示私有变量,受保护的,只能类本身能访问,连子类也不能访问,例如:#!/usr/bin/env python
class Info():
def __init__(self):
self.__name='zhangsan'
def say(self):
print self__name
a=Info()
print a.__name
执行以上代码会报错:AttributeError: Info instance has no attribute '__name'
事实上这是一种伪私有,例如:#!/usr/bin/env python
class Info():
def __init__(self):
self.__name='zhangsan'
def say(self):
print self__name
a=Info()
print a._Info__name #在属性前面加上_classname依然可以打印出来
注意:Python 中的以双下滑开头的类方法名,在类实例化以后会自动被概念,在其名字前加 _classname,因为名字被改了,所以自然无法用双下滑开头的名字被访问,从而达到不可进入的目的。
详细的私有属性描述,可以参考:
三、面向对象的三大特性
1.封装
通过上面的例子,可以看到面向对象编程需要两个步骤:
(1)将内容封装到某处
通过创建类、实例化对象,其实就是将内容封装到对象中了。
(2)从某处调用被封装的内容
调用被封装的内容,一般有两种情况:
#通过对象直接调用(第一个例子)
#通过self间接调用(第二个例子)
2.继承
子类继承父类的属性和方法,能够提高代码的重用。
#简单继承#!/usr/bin/env python
class Student():
def __init__(self,a,b):
self.name=a
self.score=b
def print_score(self):
print '%s:%s'%(self.name,self.score)
class One(Student):#子类:One,父类:Student
pass
f=One('zhangsan',100)
print f.name#调用父类的属性
f.print_score()#调用父类的方法
#输出结果如下:
zhangsan
zhangsan:100
#子类实例初始化
如果子类实例属性初始化了,那父类的属性和方法是不会被继承的:#!/usr/bin/env python
class Boy():
def __init__(self):
self.sex='boy'
self.height='170'
def print_mes(self):
print 'sex:%s,hei:%s'%(self.sex,self.height)
class Name(Boy):
def __init__(self): #子类初始化实例属性
self.name='zhangsan'
def print_name(self):
print 'name:%s'%self.name
f=Name()
print f.name
f.print_name()
f.print_mes()
#异常信息如下:
AttributeError: Name instance has no attribute 'sex'
没有找到父类中的属性,说明父类中的方法并没有被子类继承。
解决方法一:#!/usr/bin/env python
class Boy():
def __init__(self):
self.sex='boy'
self.height='170'
def print_mes(self):
print 'sex:%s,hei:%s'%(self.sex,self.height)
class Name(Boy):
def __init__(self):
Boy.__init__(self) #将父类的__init__方法添加到子类中
self.name='zhangsan'
def print_name(self):
print 'name:%s'%self.name
f=Name()
print f.name
f.print_name()
f.print_mes()
解决方法二:#!/usr/bin/env python
class Boy(object): #需要指定基类object(新式类)
def __init__(self):
self.sex='boy'
self.height='170'
def print_mes(self):
print 'sex:%s,hei:%s'%(self.sex,self.height)
class Name(Boy):
def __init__(self):
super(Name, self).__init__() #使用super函数(super只能用于新式类)
self.name='zhangsan'
def print_name(self):
print 'name:%s'%self.name
f=Name()
print f.name
f.print_name()
f.print_mes()
#多重继承
子类有多个父类,如果调用的属性或方法在子类中没有,就会从父类中查找。在经典类和新式类中,查找的方式不同。python3.0之后不再经典类,统一为新式类。
经典类:
默认没有父类,多继承情况下,会按照深度优先方式查找。
新式类:
有继承的类,如果没有,可以继承 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()
a.bar()
执行bar方法时:
首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去D类中找,如果D类中么有,则继续去C类中找,如果还是未找到,则报错。
所以,查找顺序:A --> B --> D --> C
在上述查找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()
a.bar()
执行bar方法时:
首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中没有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错。
所以,查找顺序:A --> B --> C --> D
在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了。
#多态class F1:
pass
class S1(F1):
def show(self):
print 'S1.show'
class S2(F1):
def show(self):
print 'S2.show'
def Func(obj):
print obj.show()
s1_obj = S1()
Func(s1_obj)
s2_obj = S2()
Func(s2_obj)
#为了让Func函数既可以执行S1对象的show方法,又可以执行S2对象的show方法,所以,定义了一个S1和S2类的父类,而实际传入的参数是:S1对象和S2对象。
从上面这个例子可以看出,相同的消息可能会送给多个不同的对象,而系统可依据对象所属类,引发对应类的方法,而有不同的行为,这就是多态的特点。