达内 python 是一种更纯粹的面向对象

达内 python 是一种更纯粹的面向对象

概述：

面向过程：根据业务逻辑从上到下写垒代码

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强…

python类在2.7中区分类(经典类和新式类)，3.x后不再使用。

创建类和对象

#定义一个类

class A:

#定义类的函数

def funa(self):

pass

def funb(self,name):

pass

#定义一个类的对象

obj=A()

obj.funa()

obj.funb('hell word')

self是绑定在类中的，必须有的一个参数。

调用

类的特点：

一、封装

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

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

将内容封装到某处

从某处调用被封装的内容

如何封装：

class A:

def __init__(self,name,age):

self.name=name

self.age=age

obj1=A(name='cai',age=25)

#调用

obj1.name

obj1.age

obj2=A(name='ren',age=24)

obj2.name

obj2.age

self 是一个形式参数

当执行 obj1 = Foo(‘wupeiqi’, 18 ) 时，self 等于 obj1

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

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

如何调用：

通过对象直接调用

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

class A:

def __init__(self，name,age):

self.name=name

self.age=age

#定义一个类的对象

obj=A(name='jack',age=26)

#直接调用格式：对象加属性

obj.name

通过self间接调用

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

class A:

def __init__(self,age,name):

self.name=name

self.age=age

def show(self):

print self.name

print self.age

obj=A(name='jack',age=25)

#间接调用

obj.show()

2.继承

子类继承父类

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法

class animal:

def eat(self):

3 print "%s,eat"%self.name

4 def drink(self):

5 print "%s,drink"%self.name

6 def shit(self):

7 print "%s,shit"%self.name

8 def pee(self):

9 print "%s,pee"%self.name

10 class cat(animal):

11 def __init__(self,name):

12 self.name=name

13 self.bread='cat'

14 def cry(self):

15 print "miao miao"

16 class dog(animal):

17 def __init__(self,name):

18 self.name=name

19 self.bread='dog'

20 def crazy(self):

21 print "wang wang"

22 obj1=cat('cat')

23 obj1.eat()

24 obj2=dog('dog')

25 obj2.eat()

26 obj3=cat('jack dog')

27 obj3.eat()

经典类和新式类

那么问题又来了，多继承呢？

是否可以继承多个类

如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

当类是经典类时，多继承情况下，会按照深度优先方式查找

当类是新式类时，多继承情况下，会按照广度优先方式查找

那么如何判定一个类是经典类还是新式类？

第一种方法：经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

第二种方法：

#定义一个经典类，返回值为classobj

class a:

pass

#定义一个新式类，新式类集成的参数是类的对象，返回值为type

class b(object):

pass

#父是class a，如果他的祖先是class b则是一个新式类；如果他的祖先是class a则为经典类。

class c(a):

pass

#经典类的多继承

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()

# 执行bar方法时

# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

# 所以，查找顺序：A --> B --> D --> C

# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

a.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()

# 执行bar方法时

# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

# 所以，查找顺序：A --> B --> C --> D

# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了

a.bar()

类的定义

属性和方法定义

属性

类的属性和实例的属性

class Chinese(person):

nation=china#类的属性，共有的

def __init__(self,name):

self.name=name#实力属性，特殊的，因个体不同而变化的

属性的可见性：

共有属性

私有属性，Python并没有真正的私有属性。

私有属性的定义：__name改名换姓；_name，意义在于唤起用户注意

class chinese:

nation='chian'

def __init__(self,id,name):

self._id=id#没有换名字，没有改变，直接用self._id调取，但不能够改变内容

self.__name=name#没有被保护，可用.__dict__查看，只是改名字，可以改变内容

def fun(self,msg):

print self.__name,msg

访问属性

直接访问，不推荐，因为函数已经被封装

自定义get读操作，set写方法

通过属性装饰器

@***seter

@***delet

#!/user/bin/python

#-*-coding:utf-8-*-

class a:

nation='china'

def __init__(self,id,name):

self._id=id

self.__name=name

def func(self,msg):

print self.__name,msg

def getid(self):

return self._id

def setid(self,id):

self._id=id

@property

def name(self):

return self.__name

@name.setter

def name(self,name):

self.__name=name

@name.deleter

def name(self):

del self.__name