python03 面向对象的编程01

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python03 面向对象的编程01相关的知识,希望对你有一定的参考价值。

话不多说,直接进入正文:

我个人所了解的有2种,还有个函数式编程的概念模模糊糊(大概是把常用的代码封装成一个函数,重复调用即可,先认为就是这样吧)
1 面向对象:面向对象是把所有的事务物当作独立的对象(建立对象对的目的不是为完成一个步骤,而是为了描述这个些对象在整个解决问题的步骤中的行为),处理问题过程中所思考的是各个对象之间的关系(JAVA,python)。
 
2 面向过程:根据事务的逻辑分析出解决问题所需要步骤,再用函数一步一步的去实现这些步骤,使用的时候一个个依次调用就行了。(C语言是典型的代表)
 
无论用什么形式来编程,我们都要明确记住以下原则:
 
  1. 写重复代码是非常不好的低级行为
  2. 你写的代码需要经常变更 
 
面向对象和面向过程的资料参考: 猛戳这里
 
 
用代码去了解
 
简单了解了什么是面向对象和面向过程的编程思想后,那么就开始用代码去了解。
 
简单的业务内容:
    对CPU,内存,磁盘使用率监控,使用率超过90%报警。
 
当我们刚接触python这门语言的时候,作为小白,根据这个业务逻辑肯定是挨个挨个的去判断(面向过程的思想),然后去发送报警信息,那么就有了下面的代码:
 
while True:
  if cpu.usage > 90:
        mail(CPU报警)    #(假设mail这里是一个发送邮件的功能,我们直接在括号内输入要发送的内容就行了)
  if mem.usage > 90:
        mail(内存报警)
  if disk.usage > 90:
        mail(磁盘报警)

 但是随着知识的增长,此时我们学习了函数,了解到了函数式编程,那么可以把代码精简如下:

def judge_usage(name,content):        #把判断功能和发送功能做成一个函数,直接传参就行了
  if name > 90:
        mail(content)

judge_usage(cpu.usage,cpu报警)         #那么我们调用的时候直接传入内存,CPU,磁盘的使用率就行了。

 

好了到此为止我们觉得这个代码就行了,最起码把代码精简了,省去了重复的代码。
那么今天我们就来学习下 --> 面向对象的编程

 

 

说道面向对象,那么不得不提类和对象,那么在python里面什么类,什么是对象。
 
类:一堆方法的集合,但是这些方法之间又有联系。
对象:类实例化后的结果就是对象
 
咱们也得知道,通过实例化后的对象可以执行类里面的一些方法。
 
代码例子:
#面对对象的编程  OOP
class Role(object):                                 #通过class这个关键字来创建一个类,Role表示这是类的名字,(object)是新式类的写法 必                        须这么写(以后再说原因),表示继承object类,3.0以上的版本最好都写上。  
  def __init__(self,name,role,gun,life_value):    #__init__用函数的话说这里就是Role类的初始化函数,使用类的专业名词就是说构造方法,在类                    实例化的时候会默认执行。,这里的self表示为对象本身,而对象又是在实例化的时候创建的
    self.name=name                              #把name赋值给self.name
    self.role=role
    self.gun=gun
    self.life_val=life_value

  def buy_gun(self,gun_name):                     #定义了一个buy_gun的方法
    print("%s buy %s"%(self.name,gun_name))
    self.gun=gun_name

 

我们这样使用这个类:
p1=Role(lisi,police,AK47,100)
print(P1 ,p1.buy_gun(xxx))

#其实上面那语句  " p1=Role(‘lisi‘,‘police‘,‘AK47‘,100) " 等价于这句   Role(p1,‘lisi‘,‘police‘,‘AK47‘,100),p1的所在的位置就对应的是self。这么做的目的就在于把‘lisi‘,‘police‘,‘AK47‘,100和p1关联起来

 

 
说清楚点就是:实际上我们执行上面实例化的语句时做了两件事情
1 在内存开辟空间,指向p1这个变量名。
2 开始实例化了,调用了Role这个类,并且执行了__init__这个构造方法,相当于Role.__init__(p1,‘lisi‘,‘police‘,‘AK47‘,100),注意看,p1占用了self的位置,为啥会这样,其实这么做的目的就在于把‘lisi‘,‘police‘,‘AK47‘,100和刚才开辟的变量名p1关联起来,也许你就会问了,为啥要关联起来,如果不关联起来,那么这4个参数就没有跟谁了,解释器就会报错了。
3 所以说,p1=Role(‘lisi‘,‘police‘,‘AK47‘,100)这样一运行后,self.name = name ,self.role = role ...... 就把‘lisi‘,‘police‘,‘AK47‘,100 这4个值放入了p1这个内存空间里面。
到此你也许会问为啥在第二个方法里面buy_gun还有个self呢?那么现在就解答你的问题。
虽然我们在实例化的时候把传入了那几个参数和p1关联起来了,但是我们在调用这个bug_gun方法的时候,需要告诉buy_gun,从谁那里获取信息,怎么去获取,于是把p1传给self,这样buy_gun才能够去访问p1的信息,所以能够打印出self.name(p1.name)来,其实最简单的回答就是调用方法的时候,这个方法得知道who are you。do you understand?? i think you will answer i do!!
好了,说了那么多,我们总结下出以下2点:
  1. 上面的这个p1=Role(‘lisi‘,‘police‘,‘AK47‘,100)动作,叫做类的“实例化”, 就是把一个虚拟的抽象的类,通过这个动作,变成了一个具体的对象了, 这个对象就叫做实例
  2. 刚才定义的这个类体现了面向对象的第一个基本特性,封装,其实就是使用构造方法将内容封装到某个具体对象中,然后通过对象直接或者self间接获取被封装的内容
 
类的变量和实例的变量
 
class aa(object):
    x=0
def __init__(self,name):
  self.name=name
def buy_some(self,goods_name):
  print("%s buying %s"%(self.name,goods_name))

bb=aa(bb)
cc=aa(cc)
aa.name=AK47
print(aa.weapon -->,aa.name)
dd=aa(lisi)
aa.x="AA‘s thing"
aa.c=ccccccccc
aa.name=AA
bb.x=first
bb.c=xxxxxxx
bb.buy_some(lumia1020)
print(bb.c-->,bb.c)
#print(‘bb name--‘,bb.name)
cc.buy_some(Nokia N1)
print(cc c -->,cc.c)

 

从上面的代码中可以观察到
1 在类里面的初始化方法__init__(),只有在调用的时候才才会创建self.name这个变量,倘若没有调用,那么直接运行aa.name是会报错的,
因为self.name是属于实例的变量(也叫成员属性,实例的属性),存在实例的内存中,不属于类的变量
2 在类里面的变量x,在类没有被调用的也是存在的,存在类的内存里,所以aa.x是可以的
3 aa这个类里面的buy_some方法,他是在aa这个类的内存里面的,不是在实例的内存里面的,所以实例每次调用这个buy_some方法的时候,都得
去类里面调用,并且告诉这个方法调用者的信息(其实就是实例的变量,buy_some第一个参数就是self,就是用来接受调用者信息的)。那会有人问了,为什么
不在每个实例化的过程中把buy_some方法都添加到实例内存中的,这样的话buy_some方法就在实例内存中,就不用在调用buy_some这个方法的告诉这个方法调
用者的信息,显然这个想法是错误的,为啥,因为函数对于外面是封闭的,所以调用buy_some的时候还得告诉调用者的信息,并且这样在每个实例中添加相同的
方法,那样只会占据更多的内存。那又有人会问了,我们可以把全局变量在buy_some这个方法中写死,如刚才实例化成的bb,cc,但是这里有个问题是,写死的
前提必须这个全局变量存在,但是没有实例化之前这个变量又是不存在的,所以这里是一个非常矛盾的问题。说了这么多就是想说明这点,类里面的方法除了构
造方法之外,都在类的内存里面,调用类里面的方法的时候必须告诉这个方法 调用者的信息

把上面3句话说精简点就是:
1 类的变量可以随时访问,实例的变量只有在实例化之后才能访问
2 类里面的方法除了构造方法之外,都在类的内存里面,调用类里面的方法的时候必须告诉这个方法 调用者的信息
3 倘若在类变量xx=None, 那么实例化之后,实例.xx=‘something‘相当于把xx=‘something‘放入了实例的内存里,如果直接实例.xx,就等于直接取类的变量。
 
 
 
类的继承
继承也是类的一大特性,它可以使用现有类的所有功能,并无需重新编写原来的类的情况下对这些功能进行扩展。
在这里我们要了解两个概念 :
-------------------------------------------
父类(也有人称超类,基类):被继承的类。
子类(也有人称派生类):通过继承创建的类。
-------------------------------------------
继承的过程,也就是从一般到特殊的过程。要实现继承,可以通过“继承”(Inheritance)和“组合”(Compostion)来实现。
继承是从一般到特殊的过程:父类是定义一般的方法,而子类是有特殊的方法,所以这就是从一般到继承的过程。
一般情况下一个子类只有一个基类,要实现多重继承,可以通过多级继承来实现。
我们看如下代码:


class animal(object):
  def __init__(self,name):
    self.name=name

  def eat(self):
    print("%s eating!!"%self.name)

  def drink(self):
    print("%s drink!!"%self.name)
  def sleep(self):
    print("%s sleep!!"%self.name)
  def discharge(self):
    print("%s discharge!!"%self.name)

class people(animal):                #这里开始继承animal类
  def __init__(self,name,hair,thought):
    super(people,self).__init__(name)        #super 是用来解决多重继承问题的,咱们后面会讲到
    self.hair=hair
    self.thought=thought

  def whether_thought(self):
    print("He‘s name is %s ,and he can thought(%s) as people!!"%(self.name,self.thought))

class monkey(animal):
  def __init__(self,name,hair,climb):
    super(monkey,self).__init__(name)
    self.climb = climb
  def whether_climb(self):
    print("he is monkey and he‘s name is %s,he can climb(%s)"%(self.name,self.climb))

p1=people(ljf,black,yes)            
p1.whether_thought()                #p1可以调用属于自己的方法,但是无法调用monkey的whether_climb的方法
print(p1.hair)                    
p1.eat()                            #p1可以调用父类eat的方法

m1=monkey(wukong,yellow,can climb)
m1.whether_climb()
m1.drink()                        #m1可以调用父类的drink方法

 

 
 
 
 
 
 
 
 

 

 

以上是关于python03 面向对象的编程01的主要内容,如果未能解决你的问题,请参考以下文章

VSCode自定义代码片段9——JS中的面向对象编程

Python面向对象编程03:类继承和其衍生术语

Python面向对象编程03:类继承和其衍生术语

Python中的面向对象编程(类编程)由简单到复杂的示例代码

Python学习第三天(面向对象编程)01

Python入门-6面向对象编程:01面向对象和面向过程区别-对象的进化