1. 实例方法
方法：在类的作用域里面定义的函数，就叫做方法
__init__也是一个方法，称为初始化方法，也可以称为初始化函数
把带有self固定参数的方法叫做实例方法，这个方法是属于实例的
实例方法的调用，只能由实例调用，类不能调用实例方法
调用格式：
对象.方法（）
class Mobile:
can_call = True
# 初始化方法
def __init__(self,brand,color):
self.brand = brand
self.color = color
# 实例方法
def sell(self,price):
print('某部手机被卖了')
def call(self):
print('某部手机正在打电话')
def take_picture(self):
print('某部手机正在拍照')
mobile = Mobile('apple','白色')
mobile.call()
Mobile.call()运行结果：
当方法有参数时，遵循和普通函数一样的规则，该传参的传参
__init__只有返回值None，其他方法的返回值和普通函数的返回值规则一样
class Mobile:
can_call = True
# 初始化方法
def __init__(self,brand,color):
self.brand = brand
self.color = color
# 实例方法
def sell(self,price):
print(f'某部手机被卖了，卖了{price}元')
mobile = Mobile('apple','白色')
result = mobile.sell(3000)
print(f'result值是：{result}') # 因为实例方法没有return,所以result的值是None
运行结果：
某部手机被卖了，卖了3000元
result值是：None
class Mobile:
can_call = True
# 初始化方法
def __init__(self,brand,color):
self.brand = brand
self.color = color
# 实例方法
def sell(self,price,discount=1): # 设置了位置参数和默认参数
print(f'某部手机被卖了，卖了{price*discount:.0f}元')
return price*discount # 因为有了返回值，所以result就不是None
mobile = Mobile('apple','白色')
result = mobile.sell(3000,0.8) # 默认参数传值了，就按传的值计算
print(f'result值是：{result:.0f}')运行结果：
某部手机被卖了，卖了2400元
result值是：2400
在类的里面，一个实例方法调用另一个实例方法，格式：self.方法()
在类的里面，实例方法调用实例属性，格式：self.实例属性
class Mobile:
can_call = True
# 初始化方法
def __init__(self,brand,color):
self.brand = brand
self.color = color
# 实例方法
def sell(self):
print('某部手机被卖了')
def call(self):
print('某部手机正在打电话')
# 调用record方法
self.record()
def take_picture(self):
# 调用实例属性
print(f'一部{self.brand}手机正在拍照')
def record(self):
print('正在录音')
mobile = Mobile('apple','白色')
mobile.call()
mobile.take_picture()运行结果：
某部手机正在打电话
正在录音
一部apple手机正在拍照
2. 类方法
类方法：就是类可以调用的方法（注意是写在类里面的）
格式：
@classmethod
def 方法名称（cls）:
内容
class Mobile:
can_call = True
def __init__(self,brand,color):
self.brand = brand
self.color = color
def sell(self,price):
print('某部手机被卖了')
def call(self):
print('某部手机正在打电话')
# 调用record方法
self.record()
def take_picture(self):
# 调用实例属性
print(f'一部{self.brand}手机正在拍照')
def record(self):
print('正在录音')
@ classmethod
def texting(cls):
print('可以发短信')
mobile = Mobile('apple','白色')
Mobile.texting() # 类调用类方法
mobile.texting() # 实例调用类方法运行结果：
可以发短信
可以发短信
总结：
类方法：类可以调用，实例也可以调用
实例方法：实例可以调用 ，类不可以调用
3. 静态方法
静态方法：没有固定参数，和类、对象没有直接关联，只是一个普通函数，放在类里面方便管理
格式：
@staticmethod
def 方法名称（）:
内容
class Mobile:
can_call = True
def __init__(self,brand,color):
self.brand = brand
self.color = color
def sell(self,price):
print('某部手机被卖了')
def call(self):
print('某部手机正在打电话')
def take_picture(self):
print(f'一部{self.brand}手机正在拍照')
def record(self):
print('正在录音')
@ classmethod
def texting(cls):
print('可以发短信')
@ staticmethod
def package():
print('正在打包手机')
mobile = Mobile('apple','白色')
Mobile.package()
mobile.package()
运行结果：
正在打包手机
正在打包手机
4. 为什么要用类和对象
普通函数就可以做类和对象的功能，为什么选择用类和对象呢？下面举个栗子，就会明白了
# 使用函数编写过程和调用
name = 'lucy'
sexy = '公'
age = 1
def eating(name,sexy,age):
print(f'{name}正在吃狗粮，他的性别是{sexy},年龄是{age}')
def bark(name,sexy,age):
print(f'{name}正在叫，他的性别是{sexy},年龄是{age}')
def bath(name,sexy,age):
print(f'{name}正在洗澡，他的性别是{sexy},年龄是{age}')
eating(name,sexy,age)
bark(name,sexy,age)
bath(name,sexy,age)
# 使用类编写和调用
class Dog():
def __init__(self,name,sexy,age):
self.name = name
self.sexy = sexy
self.age = age
def eating(self):
print(f'{self.name}正在吃狗粮，他的性别是{self.sexy},年龄是{self.age}')
def bark(self):
print(f'{self.name}正在叫，他的性别是{self.sexy},年龄是{self.age}')
def bath(self):
print(f'{self.name}正在洗澡，他的性别是{self.sexy},年龄是{self.age}')
dog = Dog('乐乐','母',2)
dog.eating()
dog.bark()
dog.bath()运行结果：
lucy正在吃狗粮，他的性别是公,年龄是1
lucy正在叫，他的性别是公,年龄是1
lucy正在洗澡，他的性别是公,年龄是1
乐乐正在吃狗粮，他的性别是母,年龄是2
乐乐正在叫，他的性别是母,年龄是2
乐乐正在洗澡，他的性别是母,年龄是2
总结：虽然类封装的过程比较麻烦，但调用时省事，不用每次都传参数了