day017-面向对象

1，方法

1)对象方法
怎么定义：直接定义在类中的函数
怎么调用：通过对象调用
特点：有默认参数self，self在调用的时候不用传参，系统自动将当前对象传给self
什么时候用：如果实现函数的功能需要对象属性就使用对象方法（对象方法中的self可以用来提供需要所有的对象属性）

2)类方法
怎么定义：在类中定义函数前加装饰器@classmethod
怎么调用：通过类调用
特点：自带参数cls，cls在调用的时候也不需要传参，系统会自动将当前类传给cls（谁调用就指向谁）
什么时候用：实现函数功能在不需要对象属性的时候需要类，就使用类方法。

3)静态方法
怎么定义：在类型定义函数前加装饰器@staticmethod
怎么调用：通过类调用
特点：没有默认参数
什么时候用：实现函数的功能既不需要类也不需要对象属性就使用静态方法

class A:
    num = 19

    # func1是对象方法
    def func1(self):
        print('对象方法', self)
        print(A.num)

    # func2和func3都是类方法
    @classmethod
    def func2(cls):
        print('类方法', cls)

    @classmethod
    def func3(cls, x):
        print(x, A.num)

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


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

# 2.方法在定义的时候的怎么确定参数?
# 看实现函数的功能除了类中属性以外需不需要额外的数据需要几个
class Person:
    def __init__(self, name):
        print('init')
        self.name = name

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


p = Person('k')

# 3.方法的调用问题
# (1)本质上，不管什么方法都可以用对象和类调用
a = A()
a.func1()
# A.func1(100)    # 注意：类可以调用对象方法，但是self就必须自己传参，失去可以指向当前对象的意义

A.func2()
print('=============')
a.func2()    # 注意：对象可以调用类方法，调用的时候cls还是指向当前类。但是会消耗额外的cpu资源和内存资源

A.func4()
a.func4()    # 注意：对象可以调用类方法，调用的时候cls还是指向当前类。但是会消耗额外的cpu资源和内存资源


class Math:
    pi = 3.1415926

    @staticmethod
    def sum(num1, num2):
        return num2 + num1


new_dict = dict.fromkeys('abcs')
print(new_dict)

2，对象属性的增删改查

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__)
        return f'<{str(self.__dict__)[1:-1]}>'


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

print(p1)    # print(p1)  == print(p1.__repr__())
print(p2)   # <'name': '小花', 'age': 20, 'tel': '120', 'gender': '女'>

# 1.查（获取对象属性的值）
# a. 对象.属性
# b. getattr(对象, 属性名) / getattr(对象, 属性名, 默认值)
print(p1.name)
print(getattr(p1, 'name'))

value = 'name'
# print(p1.value)     # 报错！
print(getattr(p1, value))

# print(p1.height)    # AttributeError: 'Person' object has no attribute 'height'
print(getattr(p1, 'height', 170))   # 170

# 2.增、改
# a. 对象.属性 = 值
# b. setattr(对象, 属性名, 值)
print('修改前:', p1)
p1.age = 20
print('修改后:', p1)

p1.weight = 65
print('增加后:', p1)

setattr(p1, 'age', 30)
print(p1)

setattr(p1, 'height', 170)
print(p1)

# 3.删
# a. del 对象.属性
# b. delattr(对象, 属性名)
del p1.gender
print(p1)

delattr(p1, 'weight')
print(p1)

stu1 = {'name': '小明', 'age': 23, 'tel': '110'}
stu2 = {'name': '小明', 'age': 18, 'tel': '120'}


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


stu11 = Student('小红', '120')
stu12 = Student('小明', '110', 12)

3，运算符重载

from copy import copy
# 1.python中的运算符
# python中每一个运算符都对应一个固定的魔法方法。每次使用运算符的时候本质就是去调用对应方法。
# 某种类型的数据是否支持某种运算和这个类型中有没有实现运算符对应的魔法方法有关
12 + 20   # 12.__add__(20)

'abc'+'123'     # 'abc'.__add__('123')


# 2.在自己的类中重载指定运算符
class Student:
    def __init__(self, name, age=18, score=0):
        self.name = name
        self.age = age
        self.score = score

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

    # ================运算符重载===================
    def __lt__(self, other):
        return self.score < other.score

    # self是+前面的数据，other是+后面的数据; 返回值是计算结果
    def __add__(self, other):
        # return self.score + other.score
        return [self, other]

    def __mul__(self, other):
        return [copy(self) for _ in range(other)]


stu1 = Student('小明', score=90, age=40)
stu2 = Student('小红', age=20, score=80)
stu3 = Student('Tom', age=31, score=89)
print(stu1 != stu2)   # 默认支持比较相等于

print(stu1 + stu2)     # 相当于： print(stu1.__add__(stu2))
print(stu1 + stu3)

result = stu1*3     # stu1.__mul__(3)
print(result)

# del stu1.name
# print(result)

# 按年龄排序
students = [stu1, stu2, stu3]
students.sort()
print(students)

4，内置类的属性

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('狗是人类的朋友！')


dog = Dog('财财')

# 1. __doc__   -  获取类的说明文档(类属性)
print(Dog.__doc__)		# 狗类
print(int.__doc__)

# 2.__class__   -   获取对象的类型(对象属性)，功能和type()函数一样
print(dog.__class__)   # <class '__main__.Dog'>
print(type(dog))       # <class '__main__.Dog'>

# 3.__name__    -   获取类名(类属性)
print(Dog.__name__)    # 'Dog'

# 将列表中的元素分类保存在文件。
data = [12, 12.34, 'abc', 'ancm', (10, 20), 23, 'name', True, True, False]
for x in data:
    file_name = type(x).__name__
    with open(f'./files/{file_name}.txt', 'a', encoding='utf-8') as f:
        f.write(str(x)+',')

# 4.__module__  -   获取类所在的模块的模块名(类属性)
print(Dog.__module__, int.__module__, list.__module__)

# 5.
# __dict__    -   获取指定类所有的类属性及其对应的值（以字典的形式返回） （了解）
# __dict__   -    获取指定对象所有的对象属性及其对应的值
print(Dog.__dict__)
print(dog.__dict__)   # {'name': '财财', 'gender': '公', 'age': 3, 'color': '白色'}

# 6.
# __base__  -   获取指定类的父类
# __bases__ -   获取指定类的父类们
print(Dog.__bases__)   # (<class 'object'>,)