python第十八天

class Student:
    def __init__(self, name, tel, study_id='0001', score=0):
        self.name = name
        self.tel = tel
        self.study_id = study_id
        self.score = score

    # 在打印一个对象的时候，系统会自动用这个对象去调用__repr__方法，并且获取这个方法的返回值。返回值是什么就打印什么（返回值必须是字符串）
    def __repr__(self):
        # 打印哪个对象，self就是谁
        return f'<{str(self.__dict__)[1:-1]}>'


p1 = Student('张三', '120', '0005', 60)
print(p1)

# 1.查   -   获取对象属性的值
"""
对象.属性
getattr(对象, 属性名)
"""


# 2.增/改
""""
对象.属性 = 值
setattr(对象，属性名，值)
"""
# 属性存在就是改
# 属性不存在就是增加


# 3.删
"""
del 对象.属性
delattr(对象，属性名)
"""

# 1.方法
"""
1）对象方法
怎么定义:直接定义
怎么调用：对象.方法名（）
特点：self
什么时候用：如果实现函数的功能需要用到对象属性，那么这个函数就定义成对象方法

2）类方法
怎么定义:在定义函数前加装饰器@classmethod
怎么调用：类.方法名（）
特点：有个默认参数cls，这个参数在调用的时候不用传参，系统会自动将当前类传给cls
什么时候用：实现函数的功能在不需要对象属性的前提下需要类就使用类方法

3）静态方法
怎么定义:在定义函数前加装饰器@staticmethod
怎么调用：类.方法名()
特点：没有默认参数（相当于类中的普通函数）
什么时候用：实现函数的功能在不需要对象属性的前提下不需要类就使用静态方法
"""


class Student:
    num = 100

    def __init__(self, name='张三'):
        self.name = name

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

    @classmethod
    def func2(cls):
        # cls=Student
        print(f'cls: {cls}')
        print('类方法')
        # 当前类能做的cls都可以做
        stu1 = Student()
        stu2 = cls()
        print(stu1, stu2)
        print(cls.num)

    @staticmethod
    def func3():
        print('静态方法')
        print(Student.num)

    @staticmethod
    def func4():
        print('你好吗？')


print('Student:', Student)
Student.func2()
Student.func3()

s = Student()
s.func1()

class Person:
    """
    人类
    """
    num = 61

    def __init__(self, name='张三', age=18, gender='男'):
        self.name = name
        self.age = age
        self.gender = gender

    def eat(self, food='面条'):
        print(f'{self.name}在吃{food}')

    @classmethod
    def message(cls):
        print(f'人类目前的数量是：{cls.num}')

    @staticmethod
    def destroy():
        print('人类破坏环境！')


p1 = Person()
# 1.类.__doc__     -   获取类的说明文档
print(Person.__doc__)

# 2.类.__module__    -   获取指定类所在的模块
print(Person.__module__)  # __main__   当前模块

# 3.对象.__class__    -   获取指定对象对应的类型，和type（对象）功能一样
print((10).__class__)
print(Person.__class__)

# 4.类.__name__  -   获取类名
print(Person.__name__)
print(print.__name__)

# 5.
# 类.__dict__    -   将类转换成字典，key是字段名，值是字段对应的值
# 对象.__dict__    -   将对象转换成字典，对象属性名作为key，属性值作为value
print(Person.__dict__)
print(p1.__dict__)

# 6.
# 类.__base__    -   获取指定类的父类
# 类.__bases__   -   获取指定类所有的父类
# object是python中所有类的基类
print(Person.__base__)   # <class 'object'> object是基类

import time
# 1.getter和setter
"""
1）getter
什么时候用：在获取对象属性前，如果要别的什么事情，就可以给这个属性添加getter
怎么用：
第一步：在需要添加getter的属性的属性名前加_
第二步：在@property后面定义一个函数，
        函数名就是属性名去掉_
        函数没有参数，需要一个返回值（返回值就是获取这个属性真正得到的结果）
第三步：通过对象获取属性的时候，属性不需要带_

2）setter    -   添加setter之前必须先添加getter
什么时候用：如果要给某个对象属性赋值之前做别的什么事情，就给这个属性添加setter
怎么用：
第一步：在需要添加setter的属性的属性名前加_
第二步：在装饰器@getter名.setter后面定义一个函数：
        函数名就是属性名去掉_
        函数有一个参数（这个参数指向的是赋值的时候赋的值），没有返回值
第三步：通过对象给属性赋值的时候，属性不需要带_
"""

# 练习：给Person添加属性age， 要求：age中保存年龄值，获取age属性的时候得到的是
# 这个年龄值对应的阶段状态：儿童(0~4)、少年(5~12)、青年(13~28)、
# 壮年(29~40)、中年(41~55)、老年(55以上)


class Person:
    def __init__(self):
        self._birth = 1823828290
        self._age = 19
        self.gender = '男'

    @property
    def birth(self):
        t1 = time.localtime(self._birth)
        ts = time.strftime('%Y-%m-%d', t1)
        return ts

    @property
    def age(self):
        if self._age <= 4:
            return '儿童'
        elif self._age <= 12:
            return '少年'
        elif self._age <= 28:
            return '青年'
        elif self._age <= 40:
            return '壮年'
        elif self._age <= 55:
            return '中年'
        else:
            return '老年'

    @age.setter
    def age(self, value):
        print(f'value:{value}')
        if type(value) != int:
            raise ValueError
        if value < 0 or value > 150:
            raise ValueError
        self._age = value


p1 = Person()
print(p1.birth)    # 本质是用p1去调用birth方法，获取这个方法的返回值
print(p1.age)      # p1.age()
p1.gender = '女'
p1.gender = 100
p1.gender = [10, 20, 30]
p1.age = 123      # 本质：p1.age(123)

# 1.访问权限
"""
1）三种访问权限
公开的：公开的属性和方法在类的内部、外部都可以用，并且可以被继承
保护的：保护的属性和方法在类的内部可以使用，外部不能用，但是可以被继承
私有的：私有的属性和方法在类的内部可以用，外部不能用，不能被继承

python中的属性和方法只有一种访问权限：公开的，所谓的私有化其实是假的
私有化方法：在属性名和方法名前加__（注意：只能是两个__开头，不能再用__结尾）
"""


class Person:
    num = 100
    __info = '动物'

    def __init__(self):
        self.name = '张三'
        self.__age = 18

    def func0(self):
        print(self.__age)

    @staticmethod
    def func1():
        print(Person.num)
        print(Person.__info)

    @staticmethod
    def __func2():
        print('你好，世界!')


print(Person.num)
# print(Person.__info)

Person.func1()

p1 = Person()
p1.func0()
# print(p1.__age)

# Person.__func2()


print(p1.__dict__)
# print(p1._Person__age)
# Person._Person__func2()

# 1.运算符
"""
python在使用运算符的时候本质是在调用运算符对应的方法。
每个运算符对应的方法的方法名是固定的，不同类型的数据在参与相同运算的时候，会调用不同类中对应的方法。

某个类型的数据是否支持某种运算，就看这个数据对应的类型中有没有实现这个运算符对应的方法
"""


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

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

    # self指向+前面的数据，other指向+后面的数据, 函数返回值就是运算结果
    def __add__(self, other):
        return self.name + other.name

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

    def __mod__(self, other):
        pass

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


p1 = Person()
p2 = Person('小花', 28, '女')


print(p1 + p2)    # 本质： p1.__add__(p2)
print(p1 * 4)
print(p1 % p2)

# 练习：将ps中的元素按照年龄的大小从小到大排序
p1 = Person()
p2 = Person('小花', 28, '女')
p3 = Person('张三', 20, '男')
p4 = Person('老王', 25, '男')
ps = [p1, p2, p3, p4]
print(ps)

# 方法一：添加<的魔法方法
# ps.sort()
# print(ps)

# 方法二：匿名函数进行排序
ps.sort(key=lambda item: item.age)
print(ps)