面向对象

类

class Person:
    name = '小明'  # 定义类属性
    age = 20
    def eat(self):  # 定义类方法
        print("正在吃饭")
    def run(self):
        print("正在跑步")
p = Person()
p.run()
p.eat()
print("{},今年{}岁,大口吃饭".format(p.name, p.age))

类的实例

#类里面用def定义的函数就是实例方法
class test:
    def run(self):  # 这里的self是占位的意思，可以任意字符
        print("好好吃饭")
t = test()
t.run()

类属性

class类里面设置的变量即为类属性

实例属性

在类的实例中定义的变量，例：self.name=”实例属性”

实例中初始化方法

#在实例初始化的时候自动调用的
class Person:
     def __init__(self): #定义初始化方法
         self.name="大黄" #类中的全局实例属性
         self.color="yellow"
p = Person()
print(p.name,p.color)
#自定义传参
class Person:
     def __init__(self,name,color): #定义初始化方法
         self.name=name #类中的全局实例属性
         self.color=color
p = Person("大黄","yellow")
print(p.name,p.color)

self 相当于实例本身在实例化的时候自动调用实例本身

self 和对象指向的内存地址是同一个

self 只有在类中定义 实例方法才有意义

self 的名字可以任意更改

常见的魔术方法

继承

将多个类中共有的方法，提取到一个父类里面，子类调用父类就叫继承

单继承

class all():
    def eat(self):
        print("吃饭")
    def sleep(self):
        print("睡觉")
class cat(all):
    def mmj(self):
        print("小猫叫了")
class dog(all):
    def wwj(self):
        print("小狗叫了")
cat = cat()
dog = dog()
print("*"*40+"小狗")
dog.wwj()
dog.eat()
dog.sleep()
print("*"*40+"小猫")
cat.mmj()
cat.eat()
cat.sleep()

多继承

多继承从左到右依次查找，先找平级，再找二级

class D:
    def eat(self):
        print("this is D")
class C(D):
    def eat(self):
        print("this is C")
class B(D):
    pass
class A(B,C):
    pass
a = A()
a.eat()
print(A.__mro__)    #查看继承传递过程
# 结果：this is C
# 顺序是：(<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class 'object'>)

重写和调用父类

在子类中弄一个和父类一样的方法，及达到重写的目的

class f():
    def __init__(self,name,color):
        print("%s狗是%s"%(name,color))
    def bark(self):
        print("父类大狗汪汪叫")
class z(f):
    def __init__(self,name,color): #重写父类
        f.__init__(self,name,color) #调用父类方法
    def bark(self):
        print("子类小狗嗷呜嗷呜叫")
z=z("柯基","白色")
z.bark()

多态

类方法

@classmethod 修饰的实例方法 第一个参数是cls

静态方法

@staticmethod 修饰的实例方法 不需要定义参数

静态方法不会涉及类中的方法和属性操作

导入

私有化属性

私有化属性只能在内部使用

私有化属性也不能被继承

class Person():
    def __init__(self):
        self.__name="李四" #__关键字  私有化方式
        self.age=18

私有化方法

在方法名前边加上 __ 跟私有化属性效果一样

property 属性函数用于访问私有类

单例模式

确保某一个类只有一个实例存在

class database():
    def __new__(cls,*args,**kwargs):
        # cls._instance=cls.__new__(cls) 如果使用自身new方法就会造成死循环
        if not hasattr(cls, '_instance'):
            cls._instance = super().__new__(cls,*args,**kwargs)
        return cls._instance
d1=database()
d2=database()
print(id(d1),id(d2))

异常处理

try:
    可能会报错的语句
except 错误类型 (as 别名):
    如果出错要执行的语句
else:
    若没有出错执行的语句
finally：
    无论是否出错都要执行的语句
#------------------------------------------例子
try:
    print(b)
except Exception as msg: #万能错误类型
    print(msg)

动态添加属性方法

types库 用于实例类添加属性

#只有实例对象才需要types库  其他的对象直接添加
import types
def run(self):
    self.name="李四"
    self.go="跑步"
    print("{}在{}，遇见了一只{}岁的小{}猫".format(self.name,self.go,cat.age,cat.color))
class cat():
    def __init__(self):
        self.age=2
        self.color="红"
cat=cat()
cat.run=types.MethodType(run,cat)
#其他对象添加方式
#cat.run=run
cat.run()

slots 用于限定类中所能用的变量属性

slots限定以后类对象存储将不再是dict字典类型，节约内存速度更快

# slots 限定属性不会传递给子类 但子类如果定义了 则子类的限定值=父类的限定+子类的限定
class cat():
    __slots__=("name","age") #这里限定了cat类中只能用name,age两个变量属性
    def __str__(self):
        return("{}........{}".format(self.name,self.age))
cat=cat()
cat.name="李四"
cat.age=20
print(cat)
cat.eat="榴莲"
print(cat)