第四周Day3 —— Python面向对象

第四周 Day 3 —— Python面向对象

一、方法

1. 对象方法

1. 怎么定义：直接定义在类中的函数。

2. 怎么调用：通过对象调用。

3. 特点：有默认参数self，self在调用的时候不用传参，系统自动将当前对象传给self。

4. 什么时候使用：如果实现函数的功能需要对象属性就使用对象方法（对象方法中的self可以用来提供需要所有的对象属性）。

2. 类方法

1. 怎么定义:在类中定义函数前加装饰器@classmethod。

2. 怎么调用：通过类调用。

3. 特点：自带参数cls，cls在调用的时候也不需要传参，系统会自动将当前类传给cls（谁调用就指向谁）。

4. 什么时候使用：实现函数功能在不需要对象属性的时候需要类，就使用类方法。

3. 静态方法

1. 怎么定义：在类中定义函数前加装饰器@staticmethod。

2. 怎么调用：通过类调用。

3. 特点：没有默认参数。

4. 什么时候使用：实现函数的功能既不需要类也不需要对象属性就使用静态方法。

class A:
    # func1是对象方法
    def func1(self):
        print('对象方法')


    @classmethod
    def func2(cls):
        print('类方法', cls)

    @classmethod
    def func3(cls, x):
        print(x)


    @staticmethod
    def func4():
        print('静态方法')


print(A)       # <class '__main__.A'>
A.func2()      # 类方法 <class '__main__.A'>
A.func3(10)    # 10
A.func4()      # 静态方法

二、方法在定义的时候的参数问题

​ 看实现函数的功能除了类中属性以外需不需要额外的数据，需要几个。

class Person:
    def __init__(self, name):
        self.name = name


    def eat(self, food):
        print(f'{self.name}今天吃了{food}')

三、方法的调用问题

1. 本质上，不管什么方法都可以用对象和类调用。

注意：

1. 类可以调用对象方法，但是self就必须自己传参，失去可以指向当前对象的意义。

2. 对象可以调用类方法，调用的时候cls还是指向当前类，但是会消耗额外的cpu资源和内存资源。

四、对象属性的增删改查

​ __repr__会在当前类的对象被打印的时候自动调用，并且打印结果就是这个函数的返回值。（返回值必须是字符串）

class Person:
    def __init__(self, name, tel, age=18, gender='男'):
        self.name = name
        self.age = age
        self.tel = tel
        self.gender = gender

    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}>'


p1 = Person('小明', '110')
p2 = Person('小花', '120')

print(p1)      # <'name': '小明', 'age': 18, 'tel': '110', 'gender': '男'>

1. 查（获取对象属性的值）

1. 对象.属性

   print(p1.name)            
   

2. getattr(对象, 属性名, 默认值)

   print(getattr(p1, 'name'))         # 小明
   print(getattr(p1, 'height', 0))    # 0   height属性不存在，返回默认值0
   

2. 增、改

1. 对象.属性 = 值

   print('修改前', p1.age)     # 修改前 18
   p1.age = 20
   print('修改后', p1.age)     # 修改后 20
   p1.weight = 65
   print('增加后', p1.weight)  # 增加后 65
   

2. setattr(对象, 属性名, 值)

   setattr(p1, 'age', 30)
   print(p1.age)             # 30
   setattr(p1, 'height', 170)
   print(p1.height)          # 170
   

3. 删

1. del 对象.属性

   del p1.gender
   print(p1)     # <'name': '小明', 'age': 30, 'tel': '110', 'weight': 65, 'height': 170>
   

2. delattr(对象, 属性名)

   delattr(p1, 'weight')
   print(p1)     # <'name': '小明', 'age': 30, 'tel': '110', 'height': 170>
   

五、内置类的属性

class Dog:
    """狗类"""
    num = 20

    def __init__(self, name, age=3, color='白色', gender='公'):
        self.name = name
        self.gender = gender
        self.age = age
        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('狗是人类的朋友！')

1. __doc__

​ 获取类的说明文档。

dog = Dog('馒头')
print(Dog.__doc__)    # 狗类

2. __class__

​ 获取对象的类型（对象属性），功能和type()函数一样。

print(dog.__class__)      # <class '__main__.Dog'>
print(type(dog))          # <class '__main__.Dog'>

3. __name__

​ 获取类名（类属性）。

print(Dog.__name__)       # Dog

4. __module__

​ 获取类所在的模块的模块名。

print(Dog.__module__)     # __main__

5. __dict__

​ 获取指定类所有类属性及其对应的值（以字典的形式返回）

print(Dog.__dict__)   # {'__module__': '__main__', '__doc__': '狗类', 'num': 20, '__init__': <function Dog.__init__ at 0x0000015D51066048>, 'show_message': <function Dog.show_message at 0x0000015D51066620>, 'show_num': <classmethod object at 0x0000015D5106D198>, 'info': <staticmethod object at 0x0000015D5106D1D0>, '__dict__': <attribute '__dict__' of 'Dog' objects>, '__weakref__': <attribute '__weakref__' of 'Dog' objects>}

print(dog.__dict__)  # {'name': '馒头', 'gender': '公', 'age': 3, 'color': '白色'}

6. __base__和__bases__

​ __base__：获取指定类的父类。

​ __bases__：获取指定类的父类们。

print(Dog.__bases__)     # (<class 'object'>,)
print(Dog.__base__)      # <class 'object'>

六、运算符重载

1. Python中的运算符

​ python中每一个运算符都对应一个固定的魔法方法，每次使用运算符的时候本质就是调用对应方法。

​ 某种类型的数据是否支持某种运算和这个类型中有没有实现运算符对应的魔法方法有关。

2. 在自己的类中重载指定运算符

class Student:
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score


    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}>'

    def __add__(self, other):
        return self.score + other.score


    def __lt__(self, other):
        return self.age < other.age


stu1 = Student('小明', age=18, score=90)
stu2 = Student('小红', age=12, score=80)
stu3 = Student('小花', age=22, score=89)
print(stu1 != stu2)      # 默认支持比较相等于    True

print(stu1 + stu2)       # 170
students = [stu1, stu2, stu3]
students.sort()
print(students)          
# [<'name': '小红', 'age': 12, 'score': 80>, <'name': '小明', 'age': 18, 'score': 90>, <'name': '小花', 'age': 22, 'score': 89>]