Python：面向对象编程

一:什么是面向对象？

1:什么是面向对象编程（类）？ 

• 利用（面向）对象（属性与方法）去进行编码的过程   
• 自定义对象数据类型就是面向对象中的类（class）的概念
• 以人举个例子：

2：类的定义与使用

• 类的定义 （以Person为类名举例）self：必传参数
  
• 类的使用
                     

 3：类的参数self

• self是类函数中的必传参数，且必须放在第一个参数位置
• self是一个对象，他代表实例化的自身变量
• self可以直接通过点来定义一个变量       #    seldf.name = "xiaoming"
• self中的变量与含有self参数的函数可以在类中的任何一个函数内随意调用
• 非函数中定义的变量在定义的时候不用self

4：类的构造函数

• 类的构造函数的格式  :  _init_()  在类实例化时会自动调用

  def _init(self):
      self.data=[]
  

• _init_()方法可以有参数，参数通过_init_()传递到类的实例化操作上

  class Complex:
      def __init__(self, realpart, imagpart):
          self.r = realpart
          self.i = imagpart
  x = Complex(3.0, -4.5)
  print(x.r, x.i)   # 输出结果：3.0 -4.5

   

5：私有函数与私有变量 

1. 什么是私有函数私有变量

• 无法被实例化后的对象调用的类中的函数与变量
• 类内部可以调用私有函数与变量
• 只希望类内部业务调用使用，不希望被使用者调用

     2.私有函数与私有变量的定义方法

• 在变量或函数前添加_(2个下横线)，变量或函数名后边无需添加

6：python中封装的概念

将不对外的私有属性或方法通过可对外使用的函数而使用（类中定义私有的，只有类内部使用，外部无法访问）

class Parent（object）:
    def __hello(self,data):
        print("hello % s" data)
    def helloworld(self):
        self.hello("world")
if __name__=="_main_":
    p = Parent()
    p.helloworld()

 7:装饰器

• 也是一种函数
• 可以接受函数作为参数
• 可以返回函数
• 接收一个函数，内部对其处理，然后返回一个新函数，动态的增强函数功能
• 将c函数在a函数中执行，在a函数中可以选中执行或不执行c函数，也可以对c函数的结果进行二次加工处理 

装饰器的用法

将被调用的函数直接作为参数传入装饰器的外围函数括弧
将装饰器与调用函数绑定在一起
@符号+装饰器函数放在被调用的函数的上一行，被调用的函数正常定义，只需要直接调用被执行函数即可

def check_str(func):
    def inner(*args,**kargs):
        result=func(*args,**kwargs)
        if result == "ok"
           return "result is %s" % result
        else:
           return " result is failed: % s" % result
    return inner
@check_str
def test(data):
    return data

result =  test("no")
print(result)

result = test("ok")
print(result)

类的常用装饰器

• classmethod
• staticmethond
• property

 

                 

 

类的继承

子类会继承父类的属性和方法

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

输出：ken 说: 我 10 岁了，我在读 3 年级

多继承

要注意括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

方法重写

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

输出：调用子类方法 调用父类方法

 

@@@@@@@@@@@@@@@@@@@@@