2020-10-23-面向对象2

day18-面向对象2

对象属性的增删改查

class Student:
    def __init__(self,name,tel,study_id='0001',score=60):
        self.name = name
        self.tel = tel
        self.study_id = study_id
        self.score = score
    # 打印一个对象的时候，系统会自动用这个对象去调用__repr__方法，并且获取这个防范的返回值
    # 返回值是什么就打印什么（返回值必须是字符串）
    def __repr__(self):
        # 打印那个对象，self就是谁
        # return f'姓名：{self.name} 电话：{self.tel}'
        return f'<{str(self.__dict__)[1:-1]}>'
    
stu1 = Student('小明'，'120'，score=60)
stu2 = Student('张三'，'110'，'0002',18)
print(stu1)
# <'name': '小明', 'tel': '120', 'study_id': '0001', 'score': 90>

# 1.查
"""
对象.属性
getattr(对象，属性名)
"""
# 1）getattr 可以做到动态获取属性的值
print(getattr(stu1,'name'))  # 小明
# value = input('请输入要获取的属性的姓名：')
# print(getattr(stu1,value))

print(stu1.height) # 会报错
print(getattr(stu1,'height'))  # 不存在也会报错
print(getattr(stu1,'height'，180))  # 不存在会返回指定的值

#2.增/改
"""
对象.属性 = 值
setattr(对象，属性，值)
"""
#修改
stu1.name = '小红'
print(stu1)
setattr(stu1,'tel','119')
# 属性不存在就是增加
stu1.height = 180
setattr(stu1,'height','180')

#3.删除 - 删除对象属性
"""
del 对象.属性
delattr(对象，属性)
"""
del stu1.score
print(stu1)
dalattr(stu1,'study_id')

类方法和对象方法

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

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

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

"""

class Student:
    def func1(self):
        print('对象方法')
    @classmethod
    def func(cls):
        print('类方法')
    @staticmethod
    def func3():
        print('静态方法')

Student.func()
Student.func3()
stu1 = Student()
stu1.func1()

内置属性

class Person:
    num = 61
    def __init__(self,name='张三'，age=18,gender='男')
    	self.name = name
        self.age = age
        self.gender = gender
    def eat(self):
        print('在吃东西')
        
# 1.类.__doc__  - 获取类的说明文档
print(Person.__doc__)
print(list.__doc__)

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

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

# 4.类.__name__  - 获取类的类名

datas = ['abc',0.23,45,-123]
for data in datas:
    with open(f'files\{data.__class__.__name__}.txt,'a',encoding='utf-8') as f:
              f.write(str(data))

# 5.类.__dict__  - 将类转换成字典，key是字段名，值是字段对应的值
#   对象.__dict__   - 将对象转换成字典，属性名作为key,属性值作为value
# 6.
# 类.__base__  - 获取指定类的父类
# 类.__bases__  - 获取指定类所有的父类
# object是python中所有类的基类
print(Person.__base__)  # <class 'object'>
print(Person.__bases__)  # (<class 'object'>,)

getattr 和 setattr

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

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

class Person:
    def __init__(self,gender='男'):
        self._birth = 18022423.3
        self.gender = gender

    @property
    def birth(self):
        t1 = time.localtime(self._birth)
        ts = time.strftime('%Y-%m-%d',t1)
        return ts
    
per = Person()
# 本质是用per去调用birth方法，获取这个方法的返回值
print(per.birth)  # 1970-07-28


class Person:
   def __init__(self,):
        self._age = 45

   @property
   def age(self):
        if 0 <= self._age <= 4:
            return '儿童'
        elif 5 <= self._age <= 12:
            return '少年'
        elif 13 <= self._age <= 28:
            return '青年'
        elif 29 <= self._age <= 40:
            return '壮年'
        elif 41 <= self._age <= 55:
            return '老年'
        else:
            return None
   @age.setter
   def age(self,value):
       if type(value) != int:
           raise  ValueError
       if value < 0 or value > 150:
           raise ValueError
       self._age = value
    
per1 = Person()
print(per1.age)
#  本质：per1.age(123)
per1.age = 123

私有化

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

python中的属性和方法只要一种访问权限：公开的，所谓的私有化其实是假的
私有化的方法：在属性名和方法名前加__
"""

class Person:
    num = 61
    __info = '动物'
    def __init__(self):
        pass
    @staticmethod
    def func1():
        print(Person.__info)


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

运算符重载

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

某个类型的数据，是否支持某种运算，就看这个数据对应的类型中有没有实现这个运算符对应的方法
"""
class Person:
    def __init__(self,name='小明',age=18,sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
    def __repr__(self):
        return f'<{str(self.__dict__)[1:-1]}>'

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

# 练习：将ps中的元素按照年龄的大小从小到大排序
p1 = Person()
p2 = Person('小花', 28, '女')
p3 = Person('张三', 20, '男')
p4 = Person('老王', 25, '男')
ps = [p1, p2, p3, p4]
# print(ps)
# 1
# ps.sort()
# print(ps)
# 2.
result = sorted(ps,key=lambda x: x.age)
print(result)