python--面向对象编程

1.

面向对象编程3个基本特性：

封装性：用户不能读取内部数据，只保留对外接口；

继承性：父类-子类，python支持多继承；

多态性：父类被子类集成后，可具有不同的状态和行为。

定义类：

class 类名[ 父类（可省略，省略时父类为object）]：

      类体

构造方法：__init__()     用来初始化实例变量

创建和使用实例变量：

class Animal():
    def __init__(self, age, sex, weight):  # 构造方法
        self.age = age  # 3个实例变量
        self.sex = sex
        self.weight = weight


# 调用构造方法
ani = Animal(2, 1, 20)
print(ani.age,ani.sex,ani.weight) #访问实例变量

类变量：所有实例共有的变量

注：不要通过 实例变量 访问 类变量，否则会在 实例变量 内 创建 新变量

class Account:

    lilv=0.2 #利率，类变量
    def __init__(self,user,amount):
        self.u=user
        self.a=amount
acc=Account('tom',1000)
print(acc.u,acc.a)  #访问实例变量
print(Account.lilv) #通过类名，访问类变量

实例方法：第一个参数为self，使用实例调用。

class Animal():
    def __init__(self, age, sex, weight):  # 构造方法
        self.age = age  # 3个成员变量
        self.sex = sex
        self.weight = weight

    def eat(self):   #实例方法
        self.weight +=2
        print('eat')
    def run(self):
        self.weight -=1
        print('run')
dog=Animal(1,'m',10)
dog.eat()
dog.run()
print(dog.weight)

结果：

类方法：通过类名调用  ，不是通过实例调用，不需要与实例进行绑定。  但是与类进行绑定，第一个参数是type类型，type类型是描述数据类型的类

注意：类方法只能访问类变量和其他类方法，不能访问实例方法

class Account:
    lilv=0.2 #利率 类变量
    def __init__(self,user,amount):
        self.u=user
        self.a=amount

    #类方法
    @classmethod                       #装饰器
    def Lilv_b(cls,amt):
        print(type(cls))
        return cls.lilv *amt #相当于Account.lilv*amt
acc=Account('tom',1000)
print(Account.Lilv_b(2))

结果：

静态方法：不与任何实例或者类进行绑定

class Account:
    lilv=0.2 #利率 类变量
    def __init__(self,user,amount):
        self.u=user
        self.a=amount

    #类方法
    @classmethod  #装饰器
    def Lilv_b(cls,amt):
        print(type(cls))
        return cls.lilv *amt #相当于Account.lilv*amt
    #静态方法
    @staticmethod
    def Lilv_jingtai(amt2):
        #return Account.lilv*2  
        return Account.Lilv_b(amt2)  #调用上面的类方法

acc=Account('tom',1000)
print(Account.Lilv_jingtai(2))  #调用静态方法

2.封装性

私有变量：变量前加双下划线(__)

class Animal():
    def __init__(self, age, sex, weight):  # 构造方法
        self.age = age  # 3个实例变量
        self.sex = sex
        self.__weight = weight  #私有变量，无法从外部访问
dog=Animal(1,'m',10)

print(dog._Animal__weight)  #非要访问 使用此方法 不建议

私有方法：

class Animal():
    def __init__(self, age, sex, weight):  # 构造方法
        self.age = age  # 3个实例变量
        self.sex = sex
        self.__weight = weight


    def __run(self):  #私有方法
        self.__weight -=1
        print('run')

    def eat(self):   #
        self.__weight +=2
        self.__run()  #调用私有方法
        print('eat')


dog=Animal(1,'m',10)

dog.eat()
print(dog._Animal__weight)

定义私有属性：

方法1

class Animal():
    def __init__(self,weight):  # 构造方法
        self.__weight = weight

    def set_weight(self, weight):
        self.__weight = weight

    def get_weight(self):
        return self.__weight


dog = Animal(10)
dog.set_weight(20)
print(dog.get_weight())

方法2：使用@property  修饰getter访问器，  @属性名.setter来修饰 setter访问器

class Animal():
    def __init__(self, weight):  # 构造方法
        self.__weight = weight

    # 规则：get访问器在前   set访问器在后
    @property
    def weight(self):
        return self.__weight

    @weight.setter
    def weight(self,weight):
        self.__weight = weight


dog = Animal(1)
dog.weight = 2   #直接用属性名
print(dog.weight)

3.继承   父类的方法 ，子类都可以用

class person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        s = 'person name:{0},age:{1}'
        return s.format(self.name, self.age)


class student(person):            #继承person
    def __init__(self, name, age, school):   #增加了一个参数
        super().__init__(name, age)  # super（）调用父类的构造方法  用于初始化
        self.school = school


T = student('tom', 11, '清华')
print(T.info())    #输出缺少学校。。。

结果：

缺少学校，此时使用方法重写

方法重写override：子类有与父类相同的方法名 且参数相同，

class person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        s = 'person name:{0},age:{1}'
        return s.format(self.name, self.age)


class student(person):
    def __init__(self, name, age, school):#增加了一个参数
        super().__init__(name, age)  # 调用父类的构造方法  用于初始化
        self.school = school
    def info(self):    #方法重写
        s = 'person name:{0},age:{1}， school：{2}'
        return s.format(self.name, self.age,self.school)

T = student('tom', 11, '清华')
print(T.info())    

输出结果：

多继承：多个父类有相同的方法时，根据传入的顺序 继承

class parent1():
    def run(self):
        return 'parent1 run'


class parent2():
    def run(self):
        return 'parent2 run'


class cli1(parent1, parent2):
    pass


class cli2(parent2, parent1):
    pass


R1 = cli1()
print(R1.run())
R2 = cli2()
print(R2.run())

结果：

多态：

多态的发生要两个前提：1，继承     2，子类方法重写

子类重写了父类的方法，表现出了不同的特性，即为多态

class jihe():
    def draw(self):
        print("几何图形")
class tuoyao(jihe):
    def draw(self):
        print('椭圆')
class sanjiao(jihe):
    def draw(self):
        print('三角')
JH=jihe()
JH.draw() #没有发生多态
TY=tuoyao()
TY.draw()  #发生多态

print(isinstance(TY,jihe))
print(isinstance(TY,tuoyao))
print(isinstance(TY,sanjiao))

注：可以使用isinstance（obj，class）判断是否属于类，输出位True 或者False

结果：

枚举类：一种标签或是一系列常量的集合，通常用于表示某些特定的有限集合，例如星期、月份、状态等。

定义：

class 枚举类名（enum.Enum）：

       枚举常亮列表

import enum

#装饰器，使枚举类 元素不重复，，不加 可重复
@enum.unique
class Weekdays(enum.Enum):  # 枚举类
    # 枚举常量列表
    Mon = 1
    Tue = 2
    Wed = 3
    Thur = 4
    Fri = 5


day = Weekdays.Fri
print(day)
print(day.name)
print(day.value)

结果：