AI（day08）类和对象的基本概念及属性和方法的常见分类和使用场景

类创建&对象创建

** 类概念：类是对一类对象的抽象，是对象的模板或蓝图。它定义了对象的属性（特征）和方法（功能）。 **
** 对象概念：对象是类的实例化，是类的实际数据存储，具有类所定义的属性和方法。 **
示例一：

#类，抽象小汽车
class Car:	# 创建 ' Car ' 类
    def __init__(self,pinpai,color,price):
        #初始化属性：类内部的全局变量，在类内部任何实例化对象方法里都可以使用
        self.pinpai = pinpai
        self.color = color
        self.price = price
    
    def run(self,speed):
        print(f'{self.pinpai}可以跑到{speed}KM/h')
        pass

car1 = Car('特斯拉','青桔','600k')		#	创建 ' car1 ' 对象，属于 ' Car ' 类
print(car1,car1.color)
car1.run(100)

输出：

<__main__.Car object at 0x00000168C37CD850> 青桔
特斯拉可以跑到100KM/h

实例二：

#类，抽象小狗
class Dog:		# 创建 ' Dog ' 类
    def __init__(self,name,color,age):
        self.name1 = name
        self.color2 = color
        self.age = age

    def eat(self,food):
        return '%s的%s在吃%s' % (self.color2,self.name1,food)

    def speak(self):
        return '我叫%s,我是一只%s' %(self.name1,self.color2)
        pass

#构建实例化对象
dog1 = Dog('京巴','橘黄色',1.5)		#	创建 ' dog1 ' 对象，属于 ' Dog ' 类
print(dog1.name1,dog1.color2,dog1.age)
print(dog1.eat('面包'))

print('=' * 50)

dog2 = Dog('泰迪','棕色',2)		#	创建 ' dog2 ' 对象，属于 ' Dog ' 类
print(dog2.name1,dog2.color2,dog2.age)
print(Dog.eat(dog2,'骨头'))

输出：

京巴 橘黄色 1.5
橘黄色的京巴在吃面包
==================================================
泰迪 棕色 2
棕色的泰迪在吃骨头

属性和方法

类属性&实例化对象属性

#类属性和实例化对象属性
class BankCard:
    #类属性：一年的利息
    interest = {3:0.008,6:0.010,9:0.015}
    def __init__(self,caedid,name,money = 0):
        #实例化对象属性
        self.cardid = caedid
        self.name = name
        self.money = money

    def getmoney(self,month = 0):
        return self.money + self.money * self.interest.get(month,0) * (month / 12)
    
card1 = BankCard('10086','李四',50000)
print(card1.cardid)

card2 = BankCard('10087','张三',60000)
print(card2.cardid)

print('我行的利率：',BankCard.interest)
print(card2.getmoney(6))

输出：

10086
10087
我行的利率： {3: 0.008, 6: 0.01, 9: 0.015}
60300.0

类方法&实例化对象方法

#类方法和实例化对象方法
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name,self.age)

    @classmethod		# 类方法
    def create(cls,info):		# cls参数引用当前类即Person，info参数代表输入的任何形式的数据
        name,age = info.split(',')		# 以 ‘ ，‘分割info参数
        return cls(name,age)

p1 = Person('张三',18)
p1.show()

print('=' * 20,'实例化对象创建便捷方式','=' * 20)
p2 = Person.create('李四,20')		# 将'李四'，'20'作为info参数传入类方法create
p2.show()

输出：

张三 18
==================== 实例化对象创建便捷方式 ====================
李四 20

静态方法

#静态方法 自己实现
class math:
    @staticmethod		# 静态方法归属于类，避免污染全局
    def sqrt(x):
        return x ** 0.5
    
    @staticmethod
    def exp2(x):
        return 2 ** x

print(math.sqrt(9))
print(math.exp2(3))

输出：

3.0
8

练习

class Person():
    species = "Homo sapiens"  # 类属性，种类 = “智人”

    def __init__(self, name):
        self.name = name  # 实例属性

    @classmethod
    def get_species(cls):
        return cls.species  # 访问类属性

    def introduce(self):
        return f"Hello, my name is {self.name}"  # 访问实例属性

# 使用类方法
print(Person.get_species())  # 输出: Homo sapiens

# 使用实例方法
person1 = Person("Alice")
print(person1.introduce())  # 输出: Hello, my name is Alice

# 尝试在类方法中访问实例属性会引发错误
try:
    print(Person.get_species().name)
except AttributeError as e:
    print(e)  # 输出: type object 'Person' has no attribute 'name'

输出：

Homo sapiens
Hello, my name is Alice
'str' object has no attribute 'name'

魔术方法

常用魔术方法

1. __init__(self, ...): 初始化对象，通常用于设置对象的属性。
2. __str__(self): 定义对象的字符串表示形式，可通过str(object)或print(object)调用。例如，您可以返回一个字符串，描述对象的属性。
3. __repr__(self): 定义对象的“官方”字符串表示形式，通常用于调试。可通过repr(object)调用。
4. __len__(self): 定义对象的长度，可通过len(object)调用。通常在自定义容器类中使用。
5. __getitem__(self, key): 定义对象的索引操作，使对象可被像列表或字典一样索引。例如，object[key]。
6. __setitem__(self, key, value): 定义对象的赋值操作，使对象可像列表或字典一样赋值。例如，object[key] = value。
7. __delitem__(self, key): 定义对象的删除操作，使对象可像列表或字典一样删除元素。例如，del object[key]。
8. __iter__(self): 定义迭代器，使对象可迭代，可用于for循环。
9. __next__(self): 定义迭代器的下一个元素，通常与__iter__一起使用。
10. __add__(self, other): 定义对象相加的行为，使对象可以使用+运算符相加。例如，object1 + object2。
11. __sub__(self, other): 定义对象相减的行为，使对象可以使用-运算符相减。
12. __eq__(self, other): 定义对象相等性的行为，使对象可以使用==运算符比较。
13. __lt__(self, other): 定义对象小于其他对象的行为，使对象可以使用<运算符比较。
14. __gt__(self, other): 定义对象大于其他对象的行为，使对象可以使用>运算符比较。
15. __call__(self, other) 是一个特殊的方法（也称为“魔法方法”），它允许一个对象像函数一样被调用。

为什么需要魔术方法

#为什么需要魔术方法
class MyNumber():
    def __init__(self,value):
        self.value = value
    #魔术方法：相加
    def __add__(self,other):
        return self.value + other.value
    #魔术方法：相乘
    def __mul__(self,other):
        return self.value * other.value
    #魔术方法：判断
    def __eq__(self,other):
        return self.value == other.value
    
num1 = MyNumber(100)
num2 = MyNumber(200)

#我需要进行算术操作：num1 + num2
print(num1 + num2)
print(num1 * num2)

num3 = MyNumber(200)
print(num2 == num3)

输出：

300
20000
True

魔术方法，构造、初始化方法（示例）

#魔术方法，构造、初始化方法
class MyClass:
    def __new__(cls,*args,**kwargs):
        print('__new__()方法被调用，创建对象')
        return super().__new__(cls)
    
    #自动调用：完成实例化对象属性的初始化，不需要返回值
    def __init__(self,value):
        print('__init__()方法被调用，初始化对象属性')
        self.value = value

#创建对象
obj = MyClass(10)
print(obj)

输出：

__new__()方法被调用，创建对象
__init__()方法被调用，初始化对象属性
<__main__.MyClass object at 0x00000168C1E9BB50>