day13 面向对象基础2

01 内置类属性

内置类属性：python中每个类都拥有内置的类属性

__name__
__doc__
__dict__
__module__
__bases__

class Animal:
    """动物类"""
    pass
class Cat(Animal):

    """说明文档：猫类"""
    number = 0
    def __init__(self,name='',color=''):
        self.name = name
        self.color = color

    def run(self):
        print('%s在跑'% self.name)

    @staticmethod
    def shout():
        print('喵~')

    @classmethod

    def get_number(cls):
        print('猫的数量：%s' % cls.number)

if __name__ == '__main__':
    pass

    cat1 = Cat('小花', 'white')

    """
    1. 类.__name__
    获取类的名字（字符串）
    """
    print(Cat.__name__)


    """
    2. 类.__doc__
    获取类的说明文档
    """
    print((Cat.__doc__))


    """
    3. 类.__dict__   获取类中所有的类属性和对应的值，以键值对的形式存到字典里
       对象.__dict__  将对象的属性和对应的值，转换成自字典的元素（常用，记住）
    """
    print(Cat.__dict__)
    print(cat1.__dict__)


    """
    4. 类.__module__：获取当前类所在模块的名字
    """
    print(Cat.__module__)


    """
    5.类.__bases__: 获取类的父类
    """
    print(Cat.__bases__)

02 私有化

"""
python中类中的属性和方法私有化：直接在属性名或者方法名前加上__（命名的以'__'开头）
属性或者方法四有：在外部不能直接使用,可以在类的内部使用
"""

import random
class Person:
    """私有的类字段"""
    __number = 61
    def __init__(self, name='', age=0):
        self.name = name
        self.__age = age

    def show_age(self):
        print('%d'% (self.__age - 10))
        self.__run()

    # 私有的对象方法，只能在类的内部调用
    def __run(self):
        print('%s在跑'% self.name)

    # 私有的类方法
    @classmethod
    def __get_number(cls):
        print(cls.__number)


class Student:
    def __init__(self,name):
        self.name = name
        self.study_id = ''

    def __creat_id(self):
        'py1805'+ str(random.randint(1, 50)).rjust(3, '0')

    def creat(self, name):
        stu =  Student(name)
        stu.studay_id = self.__creat_id()
        return stu



if __name__ == '__main__':
    p1 = Person('张三', 30)
    p1.name = '李四'
    # p1.age = 28
    # print(p1.name, p1.age)
    p1.show_age()
    # print(Person.__number)
    # Person.__get_number()

私有化的原理：在内部的私有的名字前加了前缀'_类名'

03 getter 和 setter

属性假的私有化：声明对象属性的时候，在属性名前面加一个'_'，来告诉别人这个数次那个不可以直接使用

要通过getter和setter来获取属性和修改属性的值

1.getter：获取属性的值
@property
def 属性名（去掉下划线）（self）：
return 返回值
如果在获取对象的某个属性前需要再干点儿别的事情，就给属性添加getter

2.setter： 给属性赋值
一个属性必须要有getter，才能添加setter
@属性名（去掉下划线）.setter
def 属性名去掉下划线（self ，变量名）：
给带下划线的属性赋值
如果再给对象的某个属相赋值前需要再干点儿别的事情，就给属性添加setter

class Student:
    """学生类"""
    def  __init__(self):
        # 声明属性的时候前面加一个'_'是为了告诉别人这个属性不能直接使用
        self._name = ''
        self._score = 0
        self._age = 0

    # 给属性_name添加getter
    @property
    def name(self):
        return self._name

    # 给属性_name 添加setter
    @name.setter
    def name(self, name):
        self._name = name

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, score):
        self._score = score

    @property
    def age(self):
        return str(self._age)+'岁'

    @age.setter
    def age(self, age):
        if age >= 150 or age <= 0:
            print('赋值错误')
            # raise 抛出异常 ：raise 错误类型
            raise ValueError
            self._age = None
            return
        self._age = age



if __name__ == '__main__':
    stu1 =Student()
    # 不添加getter和setter
    stu1._name = '张三'
    print(stu1._name)

    #添加getter和setter
    stu1.name = '李四'
    print(stu1.name)

    stu1.score = 95
    print(stu1.score)

    stu1.age = 100

    print(stu1.age)

04 类的继承

子类：继承者
父类（超类）：被继承者

1.怎么继承
python中类是可以继承的，并且支持多继承

class 类名（父类列表）：
'''类的说明文档'''
属性
方法

说明：python中所有的类默认继承Python中的基类：object

2.能继承哪些内容
继承:直接拥有父类的属性和方法（继承父类的属性和方法还是存在的）

a.对象的属性和方法，类的字段和类的方法，静态方法都可以继承（私有的继承无意义---不能继承）
b.__slots__的值不会被继承
c.getter 和setter 会被继承

class Person:
    """人类"""
    def __init__(self):
        self.name = ''
        self.age = 0
        self.sex = '男'
        self.__lenght = 0
        self._face = 0


    def eat(self):
        print('%s在吃饭' % self.name)

    # 类字段
    number = 61

    @classmethod
    def get_number(cls):
        print('人类数量%s' % cls.number)

    @staticmethod
    def hurt_earth():
        print('人类破坏地球')

class Student(Person):
    """学生类"""
    def study(self):
        pass




if __name__ == '__main__':

    stu = Student()
    stu.name = '张三'
    print(stu.name, stu.age, stu.sex)

    stu.eat()
    print(stu.__dict__)

    print(Student.number)
    Student.get_number()
    Student.hurt_earth()

05 练习

import json

def download_data():
    with open('./data.json', 'r', encoding='utf-8') as f:
        content = json.load(f)
        return content['data']
class Data:
    """数据类"""
    def __init__(self):
        self.type = ''
        self.text = ''
        self.user_id = ''
        self.name = ''
        self.screen_name = ''
        self._width = 0
        self._height = 0
        self._themes = None

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, width):
        self._width = int(width)

    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, height):
        self._height = int(height)

    @property
    def themes(self):
        if not self._themes:
            return '无'
        return self._themes

    # 根据字典创建对象
    @classmethod
    def creat_data(cls, dict1):
        data = cls()
        for key in dict1:  # 拿到每一个key值
            # print(key)
            if key == 'width':
                data.width = dict1[key]
                continue
            if key == 'height':
                data.height = dict1[key]
                continue
            if key == 'themes':
                data._themes = dict1[key]
                continue
            data.__setattr__(key, dict1[key])
        return data


if __name__ == '__main__':
    print(download_data())
    datas = []

    for dict1 in download_data():  # 拿到列表中的每一个元素（字典）
        print(dict1, type(dict1))
        # 通过字典创建对象
        data = Data.creat_data(dict1)

        # 将创建的对象存起来
        datas.append(data)
    print(datas[1].text)

image.png