August 1-day15-Python面向对象2

内置类属性

• 内置类属性：python中每个类都拥有内置的类属性
  _name_
  _doc_
  _dict_
  _module_
  _bases_

class Cat:
    """猫类"""
    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('猫的数量：%d'% cls.number)

if __name__ == '__main__':
    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__)

结果：
Cat
猫类
{'__module__': '__main__', '__doc__': '猫类', 'number': 0, '__init__': , 'run': , 'shout': , 'get_number': , '__dict__': , '__weakref__': }
{'name': '小花', 'color': 'white'}
__main__
(,)

私有化

• python中类中的属性和方法的私有化：直接在属性名或者方法名前加'_'（命名的以‘_’开头）
• 属性或者方法私有：在外部不能直接使用，可以在类的内部使用

class Person:
    __number = '我是类字段'
    """人类"""
    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):
        return 'py1805'+ str(random.randint(1, 50)).rjust(3, '0')

    def creat(self, name):
        stu = Student(name)
        stu.study_id = self.__creat_id()
        return stu
if __name__ == '__main__':
    p1 = Person('张山', 30)
    p1.name = '李四'
    # 修改不了年龄，因为他是私有化，只能内部修改
    p1.__age = 25
    # print(p1.name, p1.__age)
    p1.show_age()

    Person.get_number()

    # 私有化的原理：在内部在私有的名字前加了前缀'_类名'
    print(p1.__dict__)

结果：
20
李四再跑
我是类字段
{'name': '李四', '_Person__age': 30, '__age': 25}

getter和setter用法

属性假的私有化：声明对象属性的时候，在属性名前面加一个'_',来告诉别人这个属性不可以直接使用。
要通过getter和setter来获取属性的值和修改属性的值

1. getter：获取属性的值

@property
def 属性名(去掉下划线)（self）：
    return 返回值

• 如果在获取对象的某个属性前需要再干点儿别的事情，就给属性添加getter

2. setter： 给属性赋值

• 一个属性必须要有getter，才能添加setter

@属性名(去掉下划线).setter
def 属性名(去掉下划线)（self,value）：
     给属性名赋值可以加条件
     self._属性名 = value

• 如果在获取对象的某个属性前需要再干点儿别的事情，就给属性添加getter

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,asd):
        self._name = asd

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

    # 给属性_score添加setter
    @score.setter
    def score(self, asdd):
        self._score = asdd

if __name__ == '__main__':
    stu1 = Student()

    stu1._name = '老鬼'
    # print(stu1._name)

    # 添加getter和setter
    stu1.name = '老王'
    print(stu1.name)

    # 添加getter和setter
    # stu1._score = 20
    stu1.score = 20
    print(stu1.score)

结果：
老王
20

小练习

• 给一个json文件，将里面的data对应的值取出来存为两个对象

import json

def data_load():
    with open('./data.json','r',encoding='utf-8') as  f:
        content = json.load(f)
    return content["data"]

class Data:
    def __init__(self):
        self.type="type"
        self.text = "text"
        self.user = "user_id"
        self.name = "text"
        self.screen_name = "screen_name"
        self._width = 0
        self._height = 0
        self._themes = None

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

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

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

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

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

    @classmethod
    def creat_data(cls,dict1):
        # 声明对象
        data = cls()
        for key in dict1:
            #处理特殊情况
            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__':
    datas = []
    for dict1 in data_load():
        #通过字典创建对象
        data = Data.creat_data(dict1)
        # 将创建对象存起来
        datas.append(data)
    print(datas[0].text)

结果：
胡萝卜造型的可爱多功能雨伞，了解一下

类的继承

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

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

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

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

2. 能继承哪些内容
   继承：直接拥有父类的属性和方法（继承后父类的属性和方法还是存在的）
   a.对象的属性和方法、类的字段和类方法、静态方法都可以继承（私有的继承无意义--不能继承）
   b._slost_的值不会被继承
   c.getter和setter会被继承

class Person:
    """人类"""
    __slots__ = ('name','age','sex','__hight','_face')

    def __init__(self):
        self.name = ''
        self.age = 0
        self.sex = '男'
        self.__hight = '高'
        self._face = '帅'
    #吃饭方法
    def eat(self):
        print('%s在吃饭'%self.name)
    number = 10
    @classmethod
    def get_number(cls):
        print('人类数量：%s'%cls.number)

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

class Student(Person):
    """学生类"""
    pass

if __name__ == '__main__':
    stu1 = Student()

    stu1.name = '张山'
    print(stu1.name,stu1.sex)

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

    stu1.sex = '女'
    print(stu1._face)
    print(stu1.sex)

结果：
张山 男
10
人类数量：10
人类破坏地球
{}
帅
女