python面向对象简介_python------面向对象介绍

参考博客：http://www.cnblogs.com/alex3714/articles/5188179.html

一.面向对象介绍

class

object

封装

继承

多态

语法

属性

方法

构造函数

析构函数

私有方法，私有属性

类变量

实例变量

1.编程范式：

1）面向过程编程（Procedural Programming)：

又被称为top-down languages,程序从上到下一步步执行，从头到尾。

缺点：一次性，维护难度大。

2）面向对象编程（Object-Oriented Programming OOP）：

利用“类”和”对象“来创建各种模型来实现对真实世界的描述。

优点：使编程的维护和扩展变得简单，大大提高程序开发效率，

容易理解，团队开发变得容易。

2.面向对象编程：

1）class类：

对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象都具备的属性、共同的方法。

2) object对象：

一个对象即是一个类实例化后的实例。一个类必须经过实例化后才能在程序中调用；一个类可以实

例化多个对象，每个对象可以有不同的属性。

3）三大特性：

Encapsulation封装：在类中对数据的赋值、内部调用对外部用户是透明（用户不可见）的，

这使类变成了一个胶囊或者容器，里面包含着类的数据和方法。

Inheritance继承：一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承。

Ploymorphism多态：

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，

指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对

父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系

列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对话。

对不同类的对象发出相同的消息将会有不同的行为。

比如，你的老板让所有员工在九点钟开始工作, 他只要在九点钟的时候说：“开始工作”即可，

而不需要对销售人员说：“开始销售工作”，对技术人员说：“开始技术工作”, 因为“员工”是一个抽象的事物,

只要是员工就可以开始工作，他知道这一点就行了。至于每个员工，当然会各司其职，做各自的工作。

多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,

调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,

而引用所指向的对象可以在运行期间动态绑定。

3.定义类：

classDog:def __init__(self,name):

self.name=namedefbulk(self):print("%s : wang wang wang" %self.name)

d1= Dog("hah")

d2= Dog("hehh")

d3= Dog("jajj")

d1.bulk()

d2.bulk()

d3.bulk()

4.构造函数

class Role(object):

n = 123 #类变量

name = '我是类name'

n_list = [] #增加一个列表

#定义一个类， class是定义类的语法，Role是类名，(object)是新式类的写法，必须这样写，以后再讲为什么

def __init__(self,name,role,weapon,life_value=100,money=15000):

#构造函数

#初始化函数，在生成一个角色时要初始化的一些属性就填写在这里

#__init__中的第一个参数self,和这里的self都 是什么意思？

self.name = name #等价于 r1.name = name #实例变量(静态属性），作用域就是实例本身。

self.role = role

self.weapon = weapon

self.life_value = life_value

self.__life_value = life_value #私有属性，前面加两个下划线

self.money = money

def shot(self): # 类的方法，功能（动态属性）

print("shooting!")

print(Role.n)

r1 = Role('xiaolaizi','police','98K') #把一个类变成一个具体对象的过程叫实例化

r1.name = "小赖子" #改名

r1.bullet_prove = True #添加类中没有的一个属性

r1.n_list.append("from r1") #往类变量列表中添加内容

print(r1.n,r1.name,r1.n_list)

r2 = Role('xiaomazi','police','mini14')

print(r2.n,r2.name,r2.n_list)

5. 类变量与实例变量区别：

对象先调用实例变量，找不到再去类变量里面找。

实例变量可以修改，增加，删除 （del）。

实例变量：每个对象各自特有的属性；

类变量: 共有的属性。

6.类变量的作用及析构函数

类变量的用途：大家公用的属性，节省开销。

析构函数：在实例释放（就是自己写了 del 某某某之后）、销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接，关闭打开的临时文件。

只有你自己del r1这个实例对象，python才会销毁r1对应的内存。（哪怕是你创建了r1这个内存之后再也不用了，python

也不会去给你删除，因为他不知道你用不用，只有当你摘去r1这个门牌号，python 才会拆了这座房子）

7. 私有方法，已有属性

前面加两个下划线，只能在内部访问。

8.类的继承

1 classPeople:2 """类的继承,父类"""

3 def __init__(self,name,age):4 self.Name = name #self.name = name

5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

6

7 defeat(self):8 print("%s is eating ..." %self.Name)9

10 defsleep(self):11 print("%s is sleeping ..." %self.Name)12

13 deftalk(self):14 print("%s is talking ..." %self.Name)15

16 classMan(People):17 defpiao(self):18 print("%s is piaoing ..." %self.Name)19

20 #def sleep(self): #覆盖了父类方法

21 #print("man is sleeping ...")

22 #print("-"*20)

23

24 def sleep(self): #重构父类的方法

25 People.sleep(self) #既执行父类的方法，又执行子类的方法

26 print("+" * 20)27 print("man is sleeping ...")28

29 classWomen(People):30 defget_birth(self):31 print("%s is born a baby" %self.Name)32

33

34 m1 = Man("xiaolaizi",22)35 w1 = Women("xiaolizi",24)36 m1.eat()37 m1.piao()38 m1.sleep()39 w1.get_birth()

问题来了，那么怎么在父类的基础上只给Man类增加除了name ,age 之外的属性呢，而不影响Women子类？

1 classPeople:2 """类的继承,父类"""

3 def __init__(self,name,age):4 self.Name = name #self.name = name

5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

6

7 defeat(self):8 print("%s is eating ..." %self.Name)9

10 defsleep(self):11 print("%s is sleeping ..." %self.Name)12

13 deftalk(self):14 print("%s is talking ..." %self.Name)15

16 classMan(People):17 def __init__(self,name,age,money): #对构造函数进行重构

18 People.__init__(self,name,age)

#等价于 super(Man,self).__init__(name,age) 优点是不用写父类名（哈哈哈）

19 self.money = money

20 print("%s 一生下来就有钱。。。。" % self.Name)21

22 defpiao(self):23 print("%s is piaoing ..." %self.Name)24

25 def sleep(self): #重构父类的方法

26 People.sleep(self) #既执行父类的方法，又执行子类的方法

27 print("man is sleeping ...")28

29 classWomen(People):30 defget_birth(self):31 print("%s is born a baby" %self.Name)32 m1 = Man("xiaolaizi",22,1000)33 w1 = Women("xiaolizi",24)34 m1.eat()35 m1.piao()36 m1.sleep()37 w1.get_birth()

多继承：

1class People(object): #新式类 父类1

2 """类的继承,父类"""

3 def __init__(self,name,age):4 self.Name = name #self.name = name

5 self.Age = age #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。

6

7 defeat(self):8 print("%s is eating ..." %self.Name)9

10 defsleep(self):11 print("%s is sleeping ..." %self.Name)12

13 deftalk(self):14 print("%s is talking ..." %self.Name)15

16 class Relation(object): #父类2

17 defmake_friend(self,obj):18 print("%s is making friends with %s" %(self.Name,obj.Name))19

20

21 class Man(People,Relation): #多继承 继承的顺序从左到右

22 def __init__(self,name,age,money): #对构造函数进行重构

23 #People.__init__(self,name,age)

24 super(Man,self).__init__(name,age) #新式类的写法

25

26 self.money =money27 print("%s 一生下来就有钱。。。。" %self.Name)28

29 defpiao(self):30 print("%s is piaoing ..." %self.Name)31

32 def sleep(self): #重构父类的方法

33 People.sleep(self) #既执行父类的方法，又执行子类的方法

34 print("man is sleeping ...")35

36 classWomen(People,Relation):37 defget_birth(self):38 print("%s is born a baby" %self.Name)39 m1 = Man("xiaolaizi",22,1000)40 w1 = Women("xiaolizi",24)41 m1.make_friend(w1)

执行结果：

xiaolaizi 一生下来就有钱。。。。

xiaolaizi is making friends with xiaolizi

那么问题来了，父类2 没有构造函数，怎么就传进去参数了呢？

那是因为我们已经在父类1继承了name,age 属性（哈哈哈）