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.定义类：

class Dog:def __init__(self,name):self.name = namedef bulk(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 = roleself.weapon = weaponself.life_value = life_valueself.__life_value = life_value  #私有属性，前面加两个下划线self.money = moneydef 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 class People:
 2     """类的继承,父类"""
 3     def __init__(self,name,age):
 4         self.Name = name        #self.name = name
 5         self.Age = age        #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。
 6
 7     def eat(self):
 8         print("%s is eating ..." % self.Name)
 9
10     def sleep(self):
11         print("%s is sleeping ..." % self.Name)
12
13     def talk(self):
14         print("%s is talking ..." % self.Name)
15
16 class Man(People):
17     def piao(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 class Women(People):
30     def get_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 class People:
 2     """类的继承,父类"""
 3     def __init__(self,name,age):
 4         self.Name = name        #self.name = name
 5         self.Age = age        #Age是变量名，age是参数名。可以不一样，但是一般 都写一样的。
 6
 7     def eat(self):
 8         print("%s is eating ..." % self.Name)
 9
10     def sleep(self):
11         print("%s is sleeping ..." % self.Name)
12
13     def talk(self):
14         print("%s is talking ..." % self.Name)
15
16 class Man(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     def piao(self):
23         print("%s is piaoing ..." % self.Name)
24
25     def sleep(self):          #重构父类的方法
26         People.sleep(self)    #既执行父类的方法，又执行子类的方法
27         print("man is sleeping ...")
28
29 class Women(People):
30     def get_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()

多继承：

 1 class 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     def eat(self):
 8         print("%s is eating ..." % self.Name)
 9
10     def sleep(self):
11         print("%s is sleeping ..." % self.Name)
12
13     def talk(self):
14         print("%s is talking ..." % self.Name)
15
16 class Relation(object):   #父类2
17     def make_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 = money
27         print("%s 一生下来就有钱。。。。" % self.Name)
28
29     def piao(self):
30         print("%s is piaoing ..." % self.Name)
31
32     def sleep(self):          #重构父类的方法
33         People.sleep(self)    #既执行父类的方法，又执行子类的方法
34         print("man is sleeping ...")
35
36 class Women(People,Relation):
37     def get_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 属性（哈哈哈）

转载于:https://www.cnblogs.com/bltstop/p/9649424.html

python------面向对象介绍相关推荐

Python面向对象介绍
面向对象编程(Object-orientedProgramming,简称OOP)是一种包装代码的方法. 听说过Python中一切都是对象的说法吗?Python作为面向对象的编程语言,有一切皆对象的说法 ...
Python面向对象——面向对象介绍、实现面向对象编程、定义类、再调用类产生对象、总结__init__方法、查找顺序
文章目录面向对象介绍实现面向对象编程一:先定义类二:再调用类产生对象总结__init__方法查找顺序面向对象介绍 ''' 面向过程:核心是"过程"二字过程的终极奥义就 ...
简单明了的介绍了python面向对象编程
Python面向对象编程在本文中,您将学习Python中的OOP的以下基本概念: Python类对象实例定义和使用方法 OOP继承什么是面向对象编程(OOP)? 面向对象编程(Object-o ...
这可能是Python面向对象编程的最佳实践
作者 | 崔庆才来源 | 进击的Coder(ID:FightingCoder) Python 是支持面向对象的,很多情况下使用面向对象编程会使得代码更加容易扩展,并且可维护性更高,但是如果你写的多了 ...
初学Python——面向对象编程
一.面向对象 or 面向过程? 编程范式: 编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程 , 一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所 ...
python软件界面-python软件界面介绍(python软件介绍)
python软件界面介绍 1.接口初始化当我们使用pycharm工具时,我们将遇到的第一个问题是,在进行各种配置后界面变得混乱时,我们该怎么办?我们应该还原,那么如何还原初始设置? 尽管此工具是从e ...
python语言简介-Python语言介绍
原标题:Python语言介绍 Python简介 Python 是一个高层次的结合了解释性.编译性.互动性和面向对象的脚本语言. Python 的设计具有很强的可读性,相比其他语言经常使用英文关键字,其 ...
python编程基础是什么-Python面向对象编程基础解析（一）
1.什么是面向对象面向对象(oop)是一种抽象的方法来理解这个世界,世间万物都可以抽象成一个对象,一切事物都是由对象构成的.应用在编程中,是一种开发程序的方法,它将对象作为程序的基本单元. 2.面向 ...
python语言介绍-00-python语言介绍
以下为摘录的python的介绍 Python是一种解释型语言.这就是说,与C语言和C的衍生语言不同,Python代码在运行之前不需要编译.其他解释型语言还包括PHP和Ruby. Python是动态类型 ...
python介绍和用途-python应用领域介绍
python应用领域介绍Python作为一种功能强大且通用的编程语言而广受好评,它具有非常清晰的语法特点,适用于多种操作系统,目前在国际上非常流行,正在得到越来越多的应用. 下面就让我们一起来看看它的 ...

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

python------面向对象介绍相关推荐

最新文章

热门文章