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)
结果: