python面向对象

1.类

1.1引入类

面向对象：

所谓面向对象，就是在编程的时候尽可能的去模拟真实的现实世界，按照现实世界中的逻辑去处理问题，分析问题中参与其中的有哪些实体，这些实体应该有什么属性和方法。我们如何通过调用这些实体中的属性和方法去解决问题

类：用来描述具有相同的属性和方法的对象的集合。它定义了集合中每一个对象所共有的熟悉和方法，对象是类的实例

使用class创建类

类没有创建作用域（所以不需要申明作用域）

类创建命名空间（将同名的变量隔离了）

命名：

变量名的风格：没有大写字母，单词之间，使用下划线分隔

类名风格：单词首字母大写，不使用下划线

优势：

• 不使用闭包，减少内存泄漏风险
• 不使用闭包，实现业务直接变量隔离
• 使用类，可以从外部访问内部变量
• 使用类，不会因为重复执行代码，导致数据被销毁

class a: #创建类，没有创建作用域
    n=0 #统计次数
    def f():
        print(f"{a.n=}")
        a.n+=1

class b:
    n=""
    def g():
        print(f"{b.n=}")
        b.n+="s"

n="zhangsan"

a.f()
b.g()
a.f()
b.g()
a.f()
b.g()

1.2 创建类

要素：
名字
属性（变量）
方法（函数

class hourse:
    name=""
    area=0 #面积
    room_count=0 #房子数量
    price=0 #单价

    def amount(self):
        return self.m2*self.prices

1.3 使用类

类是为了解决实际问题

面向对象是为了解决设计问题

1.4.对象

对象是按照类，生成的多个相互隔离的空间

__init__:魔法方法，双下线特殊函数，在特殊的时机，由python自动调用

• 在类实例化时，自动调用
• 接收实例化参数
• 第一个位置参数，是实例对象本身（self）
• 不应该有返回值

class hourse:
    name=""
    area=0 #面积
    room_count=0 #房子数量
    price=0 #单价

    def __init__(self,a,b,c,d): #双下线特色函数：在特殊的时机，由python自动调用
        print(self,a,b,c,d)

c1=hourse(3,4,5,6) #创建对象
c2=hourse(7,8,9,0)
c3=hourse(1,2,3,4)

如何创建一个对象：

• 通过类名()可以创建一个对象
• c1=hourse()
• c1就是通过hourse创建的实例化对象
• 在创建对象的时候会自动调用__init__方法并且把对象c1传递赋值给self
• 那么该对象c1就能获取魔法方法里面的所有实例属性

1.5.属性

概念：和变量类似，用于存储数据，可以访问

类属性：类属性在整个实例化的对象中是公用的。类属性定义在类中且在函数体之外。类属性通常不作为实例属性使用

如何修改类属性：

• 类.属性=xxx
• self.__class__.属性=xxx
• cls.属性=XXX

实例属性：实例属性，在任意方法内部，以self.变量名的的方式定义的变量。实例变量只能通过对象名访问，无法通过类名访问

#定义类：使用class关键字
#类名:使用大驼峰命名规则
class Hero:
    #在类中可以封装实例属性和实例方法
    #实例属性：需要在魔法方法（构造方法）__init__封装实例属性
    #该魔法方法会在对象被创建的时候自动执行，不需要手动调用
    #魔法方法：一般不需要手动调用，已经定义的功能方法，在某种条件下自动触发
    def __init__(self):
        #self代表对象本身，谁是对象self就是谁
        self.name="厄斐琉斯"
        self.hp=800
        self.mp=300


#通过类可以创建对象
#对象名()：实例化一个对象赋值给h1
#h1就是通过Hero类创建的对象
#对象一旦被创建，那么自动调用魔法方法__init__
#那么对象就会拥有3个实例属性：name,hp,mp
#通过对象调用实例属性 对象名.属性名
h1=Hero()
print(h1.name)
print(h1.hp)
print(h1.mp)
#一个类可以创建无数个对象
h2=Hero()
#那么对象就会拥有3个实例属性：名字，生命值，魔法值
print(h2.name)
print(h2.hp)
print(h2.mp)

如何定义实例属性：

• 在init魔法方法中进行定义实例属性
• 并且每一个属性前面都有self代表对象本身
• self代表被创建的对象本身，谁是对象谁就是self
• self.实例属性=“具体的属性值”

如何修改实例属性

• 实例.属性=xxx
• self.属性=XXX

class a: #创建类，没有创建作用域
    n=0 #类属性：统计次数
    def f(self):
        self.b="a" #实例属性
        print(f"{a.n=}")
        a.n+=1

说明：如果实例有属性，则使用自己的属性，没有属性则使用类属性

实例属性动态赋值

class Hero:
    #魔法方法，初始化实例属性，加载类时自动调用
    def __init__(self,name,hp,mp):
        self.name=name
        self.hp=hp
        self.mp=mp

    #行为封装成实例方法
    def attack(self):
        print(f"{self.name}发动一次普通攻击")

    def move(self,x,y):
        print(f"开始移动,x的坐标为{x},y的坐标为{y}")

    #方法中也可以有返回值
    def back_city(self,b="b"):
        print("执行回城操作")
        print(f"使用快捷键回城{b}")
        return 2 #代表回城的时间2秒

    #实例方法之间可以相互调用
    def a(self):
        print("我是a方法")
        #通过self.方法名()进行调用
        self.b()

    def b(self):
        print("我是b方法")

h1=Hero("武器大师贾克斯",888,666)
h1.a()
print(h1.name)
print(h1.hp)
print(h1.mp)
h1.attack()

1.6 方法

概念：类中定义的函数。类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例她的名称是self(其实取什么名字不重要，只是有这个参数就行，默认系统叫做self)

定义在类中的函数，称之为方法，因为会自动传递参数

如果某方法，不接受参数，直接访问结果（以固定的方式返回数据）
可以通过装饰器，伪装成属性，可以不加括号直接读取

class hourse:
    name=""
    area=0 #面积
    room_count=0 #房子数量
    price=0 #单价

    def __init__(self,a,b,c,d): #双下线特色函数：在特色的时机，由python自动调用
        print(self,a,b,c,d)

    @property #可以通过装饰器，伪装成属性
    def amount(self):
        return self.area*self.price


print(c2.amount) #可以不加括号直接读取

1.6.1 类方法

传递类本身

class a:
    @classmethod #此装饰器修饰的方法称为类方法
    def b(cls):
        pass

1.6.2 实例方法

传递实例对象

class Hero:
    #魔法方法，初始化实例属性，加载类时自动调用
    def __init__(self):
        self.name="岩雀"
        self.hp=900
        self.mp=300
    #行为封装成实例方法
    #类中函数就是实例方法
    #方法和函数的区别：方法定义在类中，而且第一个参数默认一定是self代表对象本身
    def attack(self):
        #在实例方法中可以使用实例属性
        #通过self.属性名进行调用
        print(f"{self.name}发动一次普通攻击")
    #方法中的参数可以使用任何类型
    #位置参数，关键字参数，默认参数，不定长参数...
    #前提是所有参数必须在self后面进行添加
    def move(self,x,y):
        print(f"开始移动,x的坐标为{x},y的坐标为{y}")
    #方法中也可以有返回值
    def back_city(self,b="b"):
        print("执行回城操作")
        print(f"使用快捷键回城{b}")
        return 2 #代表回城的时间2秒


h1=Hero()
print(h1.name)
print(h1.hp)
print(h1.mp)
#实例方法的使用：对象.方法名()
h1.move(280,390)
h1.attack()
print(h1.back_city("c"))
time=h1.back_city()
print(time)

类方法和类属性

class Hero:
    #封装类属性：类中定义的变量就是类属性
    num=777 #num就是类属性

    #魔法方法，初始化实例属性，加载类时自动调用
    #封装的实例属性
    def __init__(self,name,hp,mp):
        self.name=name
        self.hp=hp
        self.mp=mp

    #行为封装成实例方法
    #封装的实例方法
    def attack(self):
        print(f"{self.name}发动一次普通攻击")

    def move(self,x,y):
        print(f"开始移动,x的坐标为{x},y的坐标为{y}")

    #方法中也可以有返回值
    def back_city(self,b="b"):
        print("执行回城操作")
        print(f"使用快捷键回城{b}")
        return 2 #代表回城的时间2秒

    #定义类方法需要使用装饰器@classmethod
    @classmethod
    def abc(cls):
        print("类方法abc")

h1=Hero("武器大师贾克斯",888,666)

#类属性的使用
#通过对象.类属性名
print(h1.num)
#类也可以使用类属性：类名.类属性名
print(Hero.num)
#类不能直接调用实例属性和实例方法
# print(Hero.name)
# Hero.attack()

#类方法的使用：
#通过对象名.类方法名()
h1.abc()
#通过类名.类方法名()
Hero.abc()

1.6.3 静态方法

什么都不传递

class a:
    @staticmethod
    def b():
         pass

他们的区别：就是是否会自动传递参数，以及传递的值是什么

class Hero:
    #封装类属性：类中定义的变量就是类属性
    num=777 #num就是类属性

    #魔法方法，初始化实例属性，加载类时自动调用
    #封装的实例属性
    def __init__(self,name,hp,mp):
        self.name=name
        self.hp=hp
        self.mp=mp

    #定义静态方法需要使用装饰器 @staticmethod
    @staticmethod
    def sendMessage():#静态方法没有默认必带参数，跟函数相似
        print("给队友发信息")

h1=Hero("武器大师贾克斯",888,666)
#静态方法：对象和类都可以使用
h1.sendMessage()
Hero.sendMessage()

如果需要接收额外的参数，可以自由的定义

总结：

• 函数：定义在模块中，能实现功能
• 实例方法：定义在类中的函数，而且第一个形参必须是self,代表对象本身
• 类方法：定义在类中的函数，而且第一个形参必须是cls,代表类本身，使用@classmethod装饰器装饰
• 静态方法：定义在类中的函数，而且没有固定的必带形参，使用@staticmethod装饰器装饰
• 魔法方法：类中已经定义的函数，以双下划线开头和结尾，不需要手动调用，在某种条件下自动触发
• 共同点
  • 都是通过def关键字进行定义，所有函数和方法的形参及实参的传递都符合函数的基本类型使用
  • 位置参数
  • 默认参数
  • 关键字参数
  • 不定长位置参数
  • 不定长关键字参数
  • 都可以使用return

1.7 面向对象三大特征

1.7.1 封装

封装：对数据进行封装，防止被外部意外的修改或者破坏

Python约定:

• 下划线开头的（属性和方法），仅供类内部使用
• 双下线开头的（属性和方法），仅供本类使用

约定没有强制约束力，可以绕过

1. b._age=-100 #age属性：可以绕过
2. b._A__age=-100 #age属性：可以绕过

class A:
    name=""
    _age=0
    __sex='男'

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        assert  value>0
        self._age=value

    def say(self):
        print(f"I am {self.name},{self._age} year old")

a=A()
a.age=1 #age属性：可读不可写

print(a.age)
print(a.say())

class B(A):
    def b_say(self):
        print(f"I am {self.name},{self._age} years old")

b=B()
b.age=3
b._age=-100 #age属性：可以绕过
b._A__age=-100 #age属性：可以绕过

print(b.age)

1.7.2 继承

首先，继承实现了代码的复制

其次，继承创建了关系：子类的实例，也被认为是父类的实例

1.7.2.1 单继承

class A:
    name=""
    _age=0
    __sex='男'

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        assert  value>0
        self._age=value

    def say(self):
        print(f"I am {self.name},{self._age} year old")

a=A()
a.age=1 #age属性：可读不可写
print(a.age)
print(a.say())

class B(A):
    def b_say(self):
        print(f"I am {self.name},{self._age} years old")

b=B()
b.age=3
print(b.age)

print("b是B的实例对象",isinstance(b,B))
print("b是A的实例对象",isinstance(b,A))

例如：

class A:
    #定义类属性a
    a=6
    def __init__(self):
        #定义实例属性b
        self.b=7

    def q(self):
        print("调用了实例方法q")

    @classmethod
    def w(cls):
        print("调用了类方法w")

class B(A):
    pass

#继承：定义类的时候，类名(父类名)
#B类继承了A类的所有属性和方法
#通过B类创建对象b1
b1=B()
print(b1.a)
print(b1.b)
b1.q()
b1.w()

print(b1.q())#None,方法如果没有使用return返回值，那么方法调用完打印就是None空值

1.7.2.2 多继承

class A:
    #定义类属性a
    a=6
    def __init__(self):
        #定义实例属性b
        self.b=7

    def q(self):
        print("调用了A类的实例方法q")

    @classmethod
    def w(cls):
        print("调用了A类的类方法w")

class B:
    def e(self):
        print("这是B类实例方法e")
    def r(self):
        print("这是B类实例方法r")

#使用多继承，只需要在括号中写多个父类的名字即可
class C(A,B):
    pass

c1=C()
c1.w()
c1.q()
c1.e()
c1.r()

如果父类中的方法或者属性重名，优先使用离他近的类的方法

class A:
    def e(self):
        print("调用了A类的实例方法e")

class B:
    def e(self):
        print("这是B类实例方法e")


#使用多继承，只需要在括号中写多个父类的名字即可
class C(A,B):
    pass

c1=C()
c1.e() #调用了A类的实例方法e：优先继承A类

#使用魔法属性__mro__或方法mro()查看继承的先后顺序
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
print(C.mro())
#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
print(C.__mro__)

如果子类中和父类中的方法重名。优先使用子类的方法

 

1.7.3 多态

B并非一定是A的子类，但是如果B在用起来和A没有区别，那么B也可以代替A出席需要A的场合

任意一个类型，都可以代替目标类型出现

在使用的时候，数据能够按照期望的方式使用，就可以了

class A:
    name=""
    _age=0
    __sex='男'

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self,value):
        assert  value>0
        self._age=value

    def say(self):
        print(f"I am {self.name},{self._age} year old")

class B(A):
    def b_say(self):
        print(f"I am {self.name},{self._age} years old")

print("b是B的实例对象",isinstance(b,B))
print("b是A的实例对象",isinstance(b,A))

def hello(obj:A): #hello 函数需要A的实例参数作为参数
    obj.say() #因为要调用say方法

hello(b)

 1.8 数据类装饰器

可以使用对类的装饰器进行数据类的装饰

使用及特点：

• 首先需要导入dataclasses模块
• 使用dataclass装饰器
• 自动为类创建很多特殊方法，包括init魔法方法
• 不需要手动定义init魔法方法就可以直接使用
• 实例属性的另外一种定义格式

import dataclasses

@dataclasses.dataclass
class Person:
    #通过数据类定义实例属性一定要写数据类型的申明
    name:str="张三"
    age:int=18
    def playGame(self):
        if self.age>=18:
            print(f"{self.name}可以进网吧玩游戏")
        else:
            print(f"{self.name}你是未成年，不能进网吧玩游戏")

p=Person()
print(p.name)
print(p.age)
p.playGame()

1.9 练习

#1.通过类 设计一种动物，他们应该拥有不同的名字、体重、身高，每个动物都可以计算出自己的BMI

class Animal:
    name=""
    weight=0
    height=0

    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height

    def bmi(self):
        """
        bmi=体重/(身高*身高 )
        :return:
        """
        return self.weight/(self.height*self.height)

a=Animal("金毛",200,500)

b=Animal("小喵",80,150)

#2.根据面向对象的特性，创建一个可以被say函数作为参数的Cat类，使一下代码执行正确

class Dog:
    _msg="旺旺"

    def say(self):
        return  self._msg

# class Cat(Dog): #方式1：通过继承实现
#     _msg="喵喵"

class Cat:
    def say(self): #方式2：通过多态实现
        return "喵喵"

def say(obj):
    print(obj.say())

say(Dog())

say(Cat())