python面向对象编程教程_python面向对象编程

一、术语

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

类：类就是一个用关键字Class定义的模板，模板里包含多个函数，函数里实现一系列的功能。

多态：多态从字面上的意思是多种形态、多种形式。换到编程实际中就是：程序接收到1个对象，但完全不了解对象内部的实现方式

封装：封装并不等于多态，封装是指向程序中的其他部分隐藏对象的具体实现细节的原则。

继承：继承简单的说就是和现实生活中子类继承父类的内容一样。在python里是基于子类和父类而言的，子类拥有父类的属性和方法。

二、多态和封装的区别

1.封装可以不关心对象是如何构建的而直接进行使用。

2.多态可以让用户对于不知道是什么类的对象进行方法调用。

三、类和对象

1.类和对象的创建方法：

#这里创建一个类，类名为Person，具有的方法是walk()和say()

class Person: #class 类名

def walk(self): #定义方法walk()：def 函数1(参数1)：语句1

print "i can walk quickly"

def say(self,name): #定义方法say()：def 函数1(参数1)：语句1

print "hello,i am %s" %name

jachy = Person() #用Person类创建1个对象jachy：对象名 = 类名称()

jachy.walk() #jachy对象调用walk()方法

jachy.say('jachy') #jachy对象调用say()方法

注意：

1.类中的函数我们称为方法

2.类中的函数的第一个参数必须是self

面向对象和函数式编程的区别：

1.面向对象：创建对象--->通过对象执行方法

2.函数编程：执行函数

四、面向对象的三大特性：封装+继承+多态

1.封装，简单的说，将属性封装在某一个地方，以方便后续调用封装的属性

-------->先封装

class Person：

def __init__(self,name,age): #这个__init__（）称为构造方法，当类创建对象是自动就执行了此方法

self.name = name #将传进来的name封装到self中

self.age = age #再将传进来的age封装到self中

#这里self是形参，

#当执行下面的obj1 = Person('jachy',21)时，self就相当于obj1

#当执行下面的obj1 = Person('lilin',22)时，self就相当于obj2

#根据类Person创建对象obj1，

#创建的同时自动执行了类Person中的__init__方法

obj1 = Person('jachy',21) #将jachy和21封装到obj1对象汇总

obj2 = Person('lilin',22) #将lilin和22封装到obj2对象汇总

#两个属性就被封装到obj1和obj2中，

对象obj1有name='jachy'和age=21，在内存中就将name和age封装到对象里面了

对象obj2有name='lilin'和age=22，在内存中就将name和age封装到对象里面了

----->再调用:

调用分2种：1、通过对象直接调用 2.通过self间接调用

1.通过self间接调用

class Person:

def __init__(self,name,age):

self.name = name

self.age = age

def message(self):

print self.name

print self.age

#python内部会将obj1传给Person()中的self参数，即self = obj1

obj1 = Person('jachy',21)

obj1.message()

2.通过对象直接调用

class Person:

def __init__(self,name,age):

self.name = name

self.age = age

obj1=Person('jachy',21)

print obj1.name #直接调用obj1对象的属性name

print obj1.age #直接调用obj1对象的属性age

2.继承，简单的说继承就是现实生活中的父与子继承的关系，即定义了1个子类，子类可以使用父类定义的方法和属性，这个过程就是继承

--->继承模板1:单继承

class 父类名:

def func1(self):

pass

class 子类名(父类名):

pass

#创建子类对象

sub = 子类名()

#执行从父类继承的方法

sub.func1()

class Animal:

def eat(self):

print '%s eat ' %(self.name)

def sleep(self):

print '%s sleep ' %(self.name)

#定义子类Cat

class Cat(Animal):

def __init__(self,name):

self.name = name

self.sth= 'cat'

def cry(self):

print "miao--miao"

#定义1个子类Dog

class Dog(Animal):

def __init__(self,name):

self.name = name

self.sth = "dog"

def cry(self):

print "wang--wang"

#真正执行

c1 = Cat('black-cat')

c1.eat()

c2 = Dog('white-dog')

c2.eat()

--->继承模板2:多继承（分为经典继承和新式继承）

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): #最终调用bar的查找顺序：A --B --D ---C

def bar(self):

print 'A.bar'

a = A()

#首先会执行bar()方法，然后就会在与它相关的几个类去查找，一旦找到就立即停止查找，若最终都没有找到，就报错

#然后第一去A类中查找，A类中没有bar方法，则去B类；若B类没有bar方法就去D类；若D类中没有最后去C类

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'

c = A()

#首先执行bar方法，然后就去类中寻找

#因为此类是新式类，查找顺序：A---B----C ---D

a.bar()

经典类查找顺序：A---B ---D ---C(深度优先查找策略)

新式类查找顺序：A---B----C----D（广度优先查找策略）