面向对象

面向对象

特性 class  object

封装、继承、多态

语法:属性、方法

构造函数(在实例化时做一些类的起始化的做事 该函数是用以传参数

析构函数(在实例释放、销毁的时候自动执行的、平常用于一些了却工作,如:关闭部分数据库链接,关闭打开的临时文件
 当程序执行完事后, 析构__del__(self)自动举行内存销毁,或者在程序执行中,若是要绝迹一个实例时,手动通过
del r1就会删掉变量名,然后析构函数就会自行销毁内存 )

个体方法(函数)、 私有总体性(变量)  私有:表示只可以协调访问,旁人无法访问

民用属性:就是经过self.__life_value
=life_value 添加三个下划线
就会将该变量隐藏,外面访问不了,唯有在类中才得以更改
   给类中函数添加六个__就会成为私有方法

类变量(我们共用属性,节省开销 不需要复制四个)、实例变量(表示具体对象的每个属性)

图片 1图片 2

1 class person():
2     cn ="中国" 
3     """与下面的cn ="china"功能相同,但是 类变量cn ="中国"
4     只需要在类中复制一份就可以,但是cn="china"有几个人需要
5     实例化就需要复制几分到每个人所定义的内存中去,就要消耗很多内存"""
6     def __init__(self,name,sex,age,job,cn ="china"):
7         self.name =''
8         pass

View Code

面向对象编程

OOP编程是使用“类”和“对象”来创造各样模型来落实对真正世界的叙说,使用面向对象编程的案由一方面是因为它可以使程序的保安和壮大变得更简便,并且可以大大提升程序支付功能,此外,基于面向对象的主次能够使它人越来越容易了然你的代码逻辑,从而使集体开发变得更从容。

面向对象的多少个基本特性如下

Class 类
一个类即是对一类具有同样属性的目的的架空、蓝图、原型。在类中定义了这些目的的都富有的性能(variables(data))、共同的点子

Object 对象 
一个目的即是一个类的实例化后实例,一个类必须经过实例化后得以在先后中调用,一个类可以实例化四个对象,每个对象亦可以有不同的属性,就像人类是指所有人,每个人是指现实的靶子,人与人往日有共性,亦有不同

Encapsulation 封装
在类中对数码的赋值、内部调用对外表用户是不可见的,这使类成为了一个胶囊或器皿,里面富含着类的数量和措施

Inheritance 继承

一个类可以派生出子类,在这多少个父类里定义的性能、方法自动被子类继承

Polymorphism 多态
多态是面向对象的重要特点,简单点说:“一个接口,多种兑现”,指一个基类中派生出了不同的子类,且每个子类在此起彼伏了同一的艺术名的同时又对父类的不二法门做了不同的兑现,这就是如出一辙种东西表现的有余造型。
编程其实就是一个将具体世界举行抽象化的长河,多态就是抽象化的一种显示,把一密密麻麻切实事物的共同点抽象出来,
再经过这一个抽象的东西, 与不同的现实性事物进行对话。
对不同类的对象发出同样的音信将会有两样的作为。比如,你的小业主让拥有职工在九点钟最先工作,
他只要在九点钟的时候说:“起头工作”即可,而不需要对销售人士说:“先河销售工作”,对技术人员说:“起首技术工作”, 因为“员工”是一个空洞的事物, 只假设职工就足以起始工作,他领略这点就行了。至于每个职工,当然会融合,做独家的干活。

多态允许将子类的对象当作父类的目标使用,某父类型的引用指向其子类型的靶子,调用的艺术是该子类型的艺术。这里引用和调用方法的代码编译前就曾经控制了,而引用所指向的靶子可以在运作期间动态绑定

无论用什么形式来编程,我们都要明确记住以下原则:

1、写重复代码是非常不好的低级行为

2、你写的代码需要经常变更 

类的基本知识(私有方法、构造函数、析构函数)

图片 3图片 4

 1 class Role(object):
 2     n =123 #这个变量称为类变量 存在于类的内存里  不实例化类也能使用 通过 role.n
 3     n_list=[]
 4     """如果在Role中有一个列表,通过r1.n_list.append("from r1")
 5      和r1.n_list.append("from r1") 再打印r1.n_list,或者r2.n_list,
 6      或者Role.n_list 最后的结果都是 ['from r1', 'from r2']
 7      因为都是通过append()追加,它们的变量名相同,也就是内存地址也是同一个,
 8     故而结果相同
 9     """
10     name ="类中name"
11     def __init__(self, name, role, weapon, life_value=100, money=15000):
12         """   self 就是为了存储下面的r1变量,下面的变量就为局部变量
13         名字叫:构造函数  内存中的东西在不用的情况下,会清除,所以通过赋给一个变量,那么就一直不会清除,在实例化时做一些类的初始化的工作 该函数是用于传参数
14  """
15         self.name = name #该值是赋给了实例   故而:该变量称之为实例变量(静态属性)  作用域就是实力本身
16         self.role = role
17         self.weapon = weapon
18         self.__life_value = life_value # 加个__就会变成私有属性
19         self.money = money
20 
21     def shot(self):#其他函数调用类role的时候,仍然用到的是r1这个变量
22         print("shooting...")
23 
24     def __del__(self): #析构函数  当程序执行完后执行该函数,
25         # 或者中途通过del r1就会直接删除r1变量名,然后析构函数就会直接销毁内存
26         print("%s:彻底死掉……" %self.name)
27     # def got_shot(self):
28     #     print("ah...,I got shot...")
29     def got_shot(self):#谁调用got_shot 谁就是参数self
30         print("%s:ah...,I got shot..." % self.name )# r1.name 等价于self.name
31     def buy_gun(self, gun_name):#这三个函数都称之为类的方法(动态属性)
32         print("just bought %s" % gun_name)
33 
34 r1 = Role('Alex', 'police', 'AK47') #把一个类变成一个具体对象的过程的实例化(初始化一个类,造了一个对象)
35 r1.name ="zhangsan"#可以再次赋值修改变量
36 r1.bullet_protect=True#添加新的属性  但是r2没有这个属性,因为只给r1添加了
37 r1.n ='改变变量' #并不是将类变量改变,而是在实例中直接生成了一个n这个变量的值,根据变量查找范围,先查找实例化的变量所以n会发生变化
38 r1.n_list.append("from r1")
39 #print(r1.weapon)
40 #del r1.weapon #删掉了r1的这个属性 对r2没有什么影响
41 r2 = Role('Jack', 'terrorist', 'B22')  #生成一个角色   实例化成一个对象也叫role类的实例
42 r1.got_shot() # 有class内部转成了role.got_gun(r2) 故而 等价于:role.got_shot()
43 r2.n_list.append("from r2")
44 print(r1.n,r1.name,r1.bullet_protect)#在实例化后,找一个变量之后,会从实例变量开始查找,然后再从类变量中找
45 
46 print(r2.name,r2.weapon,r2.n)
47 Role.n ="abc"
48 print(r1.n,r2.n_list)#  运行结果:改变变量 abc 只对r2有影响,对r1没有影响 因为r1自己有值
49 print(Role.n_list)

View Code

类的继续

图片 5图片 6

 1 #class People:# 经典类
 2 class People(object):#新式类的写法
 3     def __init__(self,name,age):
 4         self.name =name
 5         self.age =age
 6         self.friends =[]
 7     def eat(self):
 8         print("%s is eating ……"%self.name)
 9     def sleep(self):
10         print("%s is sleeping……"%self.name)
11     def talk(self):
12         print("%s is talking……"%self.name)
13 class Relation():
14     def make_friends(self,obj):#obj就是对象,就是将其与前面的谁调用make_friends有关联
15         print("%s make friends with %s"%(self.name,obj.name))
16         self.friends.append(obj) #即使改名字,这里也会跟着变化,这里是添加了关系
17 class Man(People,Relation): #两个字类之间不能相互继承 即Man不能和Woman相互继承 因为两者本来就不是同一所以才产生两个类
18     def __init__(self,name,age,money): #首先要将父类中的参数写入其中,并且将要添加的参数也写入其中
19        # People.__init__(self,name,age) # 将People中的构造函数应用到Man中  还是执行父类中的方法
20         super(Man,self).__init__(name,age)#等价于People.__init__(self,name,age) 万一以后将继承父类改了名字,只需要改上那个父类名就可以
21         self.money =money #对man中添加的值进行初始化    Woman中没有该参数
22         print("%s have %s yuan money" %(self.name,self.money))
23    
24  def smoke(self):
25         print("%s is smoking……"%self.name)
26     def sleep(self): #在子类中修改父类中的方法
27         #People.sleep(self) #经典类的写法
28         super(Man, self).sleep()#等价于上面   新式类的写法
29         print("Man is sleep……")
30     def play_bastball(self):
31         print("%s is playing bastball……"%self.name)
32 
33 class Woman(Relation,People):#多继承,是从左向右逐步进行,如果第一个已经将参数接收过来,第二个类直接使用即可,如果第一个没有将参数接收,第二个接受了参数,那么在没有接受第二个类之前就运行了第一个类,那也就 将报错
34     def birth(self):
35         print("%s is born the baby……"%self.name)
36     def wash(self):
37         print("%s is washing……"%self.name)
38 
39 m1 =Man("zhangsan",26,100)
40 # m1.sleep()
41 # m1.talk()
42 #m1 =Man("zhangsan",26)
43 # m1.money= "10元"
44 # print(m1.money,m1.sleep,m1.talk)
45 w1 =Woman("hehua",28)
46 # w1.wash()
47 # w1 .birth()
48 m1.make_friends(w1)
49 w1.name ="wangwu"
50 print(m1.friends[0].name) #通过实验可知:obj将两者联系起来了
51 print(m1.friends[0]) #如果前面的self.friends.append(obj.name)那么
52 # m1和w1就会失去联系,此时只是对应一个字符串

View Code

经典类和新式类继承顺序问题

新式类 class A(object):  经典类  class A:

在如下中的继承中,对于继承中构造函数的执行__init__(self):

在python2.x中经典类是按深度优先来进行的,新式类是按广度优先来继承的

在python3.x中经典类和新式类都是统一按照广度优先来继承的

 

相关文章