class A:
@classmethod
def func1(cls): # func1就是类方法
print('类方法')
@classmethod
def func2(cls, x):
print(x)
# 调用:
A.func1()
A.func2('你好')
3)静态方法:相当于是在类中的一个普通函数
定义:在类中定义函数前加装饰器@staticmethod
怎么调用:通过类调用 -> 类.方法名()
特点:没有默认的参数
什么时候用:实现函数的功能既不需要类也不需要对象属性,就使用静态方法
class B:
@staticmethod
def func3(): # func3就是静态方法
print('静态方法')
# 调用:
B.func3()
方法在定义的时候的参数问题
# 方法在定义的时候怎么确定参数:看实现函数的功能除了类中属性以外需不需要其他额外的数据
方法的调用问题
#本质上,不管什么方法都可以用对象和类调用;
# 注意1:类也可以调用对象方法,但一般不用,因为这个时候self就必须自己传参,失去可以指向当前对象的意义。
# 注意2:对象也可以调用类方法,调用的时候cls还是指向当前类,但会消耗额外的CPU内存资源
# 最好是对象方法用对象调用,类方法和静态方法用类调用
class Person:
def __init__(self, name, tel, age=18, gender='男'):
self.name = name
self.age = age
self.tel = tel
self.gender = gender
# __repr__会在当前类的对象被打印的时候自动调用,并且打印的结果就是这个函数的返回值(返回值必须是字符串)
def __repr__(self):
return str(self.__dict__)
# 使用类的实例对象调用__dict__,会输出由类中所有实例属性组成的字典,方便查看信息(后面会讲)
p1 = Person('小明', '137')
p2 = Person('小花', '150', 20, '女')
print(p1) # {'name': '小明', 'age': 18, 'tel': '137', 'gender': '男'}
print(p2) # {'name': '小花', 'age': 20, 'tel': '150', 'gender': '女'}
查(获取对象属性的值)
print(p1.name) # 小明
2) getattr(对象, 属性名)
getattr(对象, 属性名, 默认值)
print(getattr(p1, 'name')) # 小明
# 比第一种方法好的地方是更灵活:
value = input('输入属性名:')
print(getattr(p1, value))
# 如果属性不存在,第一种方法会报错,第二种方法会在属性不存在时返回默认值
print(getattr(p1, 'height', None)) # None
增、改(属性存在就是修改,属性不存在就是新增)
p1.age = 20
print(p1) # {'name': '小明', 'age': 20, 'tel': '137', 'gender': '男'}
p1.weight = 65
print(p1) # {'name': '小明', 'age': 20, 'tel': '137', 'gender': '男', 'weight': 65}
2) setattr(对象, 属性名, 值)
setattr(p2, 'age', 30)
print(p2) # {'name': '小花', 'age': 30, 'tel': '150', 'gender': '女'}
删
del p1.gender
print(p1) # {'name': '小明', 'age': 20, 'tel': '137', 'weight': 65}
2) delattr(对象, 属性名)
delattr(p1, 'weight')
print(p1) # {'name': '小明', 'age': 20, 'tel': '137'}
class Dog:
"""狗狗类"""
num = 20
def __init__(self, name, gender='公', age=3, color='白色'):
self.name = name
self.age = age
self.gender = gender
self.color = color
def show_message(self):
print(self.name, self.gender, self.age, self.color)
@classmethod
def show_num(cls):
print('狗的数量:', cls.num)
@staticmethod
def info():
print('狗是人类的朋友')
dog = Dog('财财')
# 1.__doc__ - 获取类的说明文档(内置的类属性)
print(Dog.__doc__) # 狗狗类
# 2.__class__ - 获取对象的类型(内置的对象属性),功能和type()函数一样
print(dog.__class__) #
# 3.__name__ - 获取类名(类属性)
print(Dog.__name__) # Dog(是一个字符串)
# 4.__module__ - 获取类所在的模块的模块名(类属性)
print(Dog.__module__, list.__module__)
# 5.__dict__ - 作为类属性时,将整个类转换成一个字典,类属性作为字典的键,对应的值作为值(了解就行)
# __dict__ - 作为对象属性时,获取指定对象所有对象属性及其对应的值
print(Dog.__dict__)
print(dog.__dict__) # {'name': '财财', 'age': 3, 'gender': '公', 'color': '白色'}
# 6.__base__ - 获取指定类的父类
# __bases__ - 获取指定类的父类们
print(Dog.__bases__)
python中的运算符
# python中每一个运算符都对应一个固定的魔法方法。每次使用运算符的时候本质就是去调用对应方法。
# 某种类型的数据是否支持某种运算符,和这个类型中有没有实现运算符对应的魔法方法有关
在自己的类中重载指定运算符
class Student:
def __init__(self, name, age=18, score=0):
self.name = name
self.age = age
self.score = score
# 运算符重载:在类中定义'+'的魔法方法,使得对象可以使用'+'运算符:
# 返回值是计算结果
def __add__(self, other): # self是加号前面的数据,other是加号后面的数据
pass # 里面的规则需要用什么进行怎么的运算看你自己
# 运算符重载:'*',规则是分数变成3倍
def __mul__(self, other):
self.score *= other
return self
# 根据分数进行排序:
def __lt__(self, other):
return self.score < other.score
def __repr__(self):
return str(self.__dict__)
stu1 = Student('小明', score=90)
stu2 = Student('小花', age=20, score=80)
stu3 = Student('Tom', age=31, score=89)
print(stu2 == stu1) # 系统只默认支持比较相等的运算符
print(stu1 + stu2) # 相当于print(stu1.__add__(stu2))
print(stu2 * 3) # {'name': '小花', 'age': 20, 'score': 240}
students = [stu1, stu2, stu3]
students.sort()
print(students)