面向对象
把某个人或者事务看成一个对象。每个对象有自己的属性和方法。
类和对象
对象是由类实例化产生的
#声明一个类
class Animal:
def speak(self):
print("i can speak")
#实例化一个对象
dog = Animal()
dog.speak() # i can speak
添加和获取对象属性
class Animal:
age = 1
weight = 10
def speak(self):
print('I can speak')
dog = Animal()
dog.color = 'black' #添加颜色属性
print(dog.age) #1 #获取狗的年龄
dog.speak() # I can speak
面向对象特性
面向对象的特点：封装、继承、多态性。
继承
class Father:
_f_money = '100'
__power = 'take child' #私有属性，不会被继承
class Son(Father): #Son 继承了 Father
pass
xiaoming = Son()
print(xiaoming._f_money) # 100
print(xiaoming.__power) #会报错，Son无法继承该属性
多继承
当有相同属性时，按从左到右的优先级，优先继承
多继承时，深度优先，遇到object，向右继续遍历
class Father:
_f_money = '100'
character = '开朗'
class Mother:
_feature = 'long hair'
character = '内向'
lass Son(Father,Mother): #Son 同时继承父亲和母亲
pass
xiaoming = Son()
print(xiaoming._f_money) # 100
print(xiaoming._feature) # long hair
print(xiaoming.character) # 开朗 #优先继承左边的父亲的
print(Son.__mro__) #查看继承的顺序 # Son Father Mother object
重写
子类重写父类的同名方法和属性
class Father:
def ability(self):
print('聪明')
class Son(Father):
def ability(self): #重写父类的方法
print('普通人')
def
xiaoming = Son()
xiaoming.ability() #普通人
调用父类方法 super()
直接使用父类的类名
class Father:
def ability(self):
print('聪明')
class Son(Father):
def hiden_ability(self): #重写父类的方法
Father.ability(self) #调用父类的方法
xiaoming = Son()
xiaoming.hiden_ability() #聪明
使用super进行调用
class Father:
def __init__(self,character):
self.character = character
def say(self):
print(f'性格是{self.character}')
class Son(Father):
def __init__(self,character):
super.__init__(character)
#Father.__init__(self,character)
xiaoli = Son('活泼')
xiaoli.say() #性格是活泼
魔法方法
在特定条件下，被动调用，不是主动调用
- _init_ 初始化属性，在实例化对象的时候，会被调用
- _add_ 进行对象加法运算的时候，会被调用
- _str_ 当使用print去输出对象时
- _del_ 当对象被删除时触发
class people:
def __init__(self):
self.height = 180
self.weight = 140
def __add__(self,other):
self.height += other
self.weight += other
return self
def __str__(self):
return f'身高是{self.height},体重是{self.weight}'
def __del__(self):
print('我被删除了')
xiaoming = people()
xiaoming + 2 + 3
print(xiaoming) #身高是185,体重是145
del xiaoming # 我被删除了
成员变量 类变量
- 成员变量是在构造方法init()中定义的，通过self参数引用。
在类的外部，成员变量只能通过对象名访问。 - 类变量在类中方法之外定义的变量。
在类的外部，既可以通过类名访问，也可以通过对象名访问，被类的所有对象共享
class A:
count = 0 #类变量
def __init__(self,name):
self.name = name #成员变量
a = A('a')
print(a.count) #1
b = A('b')
print(a.name) #a
print(a.count) #2
print(b.count) #2
print(A.count) #2 #类名调用类变量
类方法 静态方法
类方法：
在类中定义，使用@classmethod进行装饰，参数填入cls静态方法
不适用类中的变量(self)，定义在类里面，使用@staticmethod进行装饰
逻辑上属于类，但和类本身没有关系。静态方法是个独立的、单纯的函数。
class A:
def __init__(self,a,b):
self.a = a
self.b = b
self.print_() #调用打印的方法
def print_(self):
print(self.a+self.b)
@classmethod #类方法
def test(1,2):
return cls(1,2)
@staticmethod #静态方法
def sayAWord()：
print("我是一个静态方法")
A.test() #3 使用类名调用类方法
