Day13-课堂笔记-面向对象

1.内置类属性

python中每个类都用有的内置类属性
name:获取类的名字
doc:获取类的说明文档
dict:
对象.dict
将对象的属性和对应的值，转换成字典的元素(常用，记住)
注意：当我们通过slots去约束对象的属性后，对象dict属性不能使用。
类.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_numbers(cls):
        print('猫的数量：%d'% cls.number)

if __name__ == '__main__':
    cat1=Cat('小花','white')
    cat1 = Cat('小人', 'black')
    '''
    1.__name__
    获取类的名字
    '''
    print(Cat.__name__)
    '''
    2.类__doc__
    获取类的说明文档
    '''
    print(Cat.__doc__)
    '''
    3.__dict__
    对象.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': init at 0x000002B19A7FA8C8>, 'run': , 'shout': , 'get_numbers': , 'dict': dict' of 'Cat' objects>, 'weakref': weakref' of 'Cat' objects>}
{'name': '小人', 'color': 'black'}
main
(,)

2.私有化

• python中类中的属性和方法的私有化：直接在属性名或者方法名前加__
  (命名以'__'开头)
• 属性或者方法私有：在外部不能直接使用，可以在类的内部使用
  *私有化的原理：在内部私有化的名字前面加了前缀'__'

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)
import random
class Student:
    def __init__(self,name):
        self.name=name
        self.study_id=''
    @classmethod
    def __creat_id(cls):        'py1805'+str(random.randint(1,50)).rjust(3,'0')
    @classmethod
    def creat(cls,name):
        stu= Student(name)       stu.study_id=cls.__creat_id()
        return stu
if __name__ == '__main__':
    p1=Person('张三',30)
    p1.name='李四'
    p1.__age=34
    # print(p1.name,p1.age)
    p1.show_age()
    # p1.run()
    # Person.get_number()
    print(p1.__dict__)

结果：

20
李四在跑
{'name': '李四', '_Person__age': 30, '__age': 34}

3.getter和setter

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

1）getter

• getter：获取属性的值
• 格式：
  @property
  def 属性名(去掉下划线)(self)
  return 返回值
  如果在获取对象的某个属性前需要干的别的事情，就给属性添加getter

2）setter

*setter：给属性赋值，一个属性必须要有getter,才能添加setter。
*格式：
@属性.setter
def 属性(去掉下划线)(self,变量名)
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,value):
        stu1._name=value
    @property
    def age(self):
        return str(self._age)+'岁'
    @ age.setter
    def age(self,age):
        if age>=150 or age<0:
            print('输入有误,age要求0-150的值')
            # raise ValueError  #抛出异常
            self._age=None
            return
        self._age = age
    @property
    def score(self):
        return self._score
    @score.setter
    def score(self,score):
        self._score=score
if __name__ == '__main__':
    stu1=Student()
    stu1._name='张三'
    stu1._score=80
    stu1.name='李四'
    print(stu1.name)
    stu1.age=100
    print(stu1.age)

结果：

李四
100岁

练习：

import json
class Dict:
    def __init__(self):
        self._type=''
        self.text=''
        self.user_id=''
        self.name=''
        self.screen_name=''
        self._width=''
        self._height=''
        self._themes=''
    @property
    def width(self):
        return self._width
    @width.setter
    def width(self,width):
        if width.isnumeric():
            self._width=int(width)
        self._width=width

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

    @height.setter
    def height(self, height):
        if height.isnumeric():
            self._height = int(height)
        self._height= height
    @property
    def themes(self):
        if self._themes:
            return self._themes
        else:
            return '无'

    @themes.setter
    def themes(self, themes):
        self._themes = themes

    @property
    def type(self):
        return self._type

    @type.setter
    def type(self, type):
        if type.isnumeric():
            self._type = int(type)
        self._type = type
    # 方法二：
    @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
            if key=='type':
                data.type=dict1[key]
                continue
            data.__setattr__(key,dict1[key])
        return data
if __name__ == '__main__':
    dict5=Dict()
    dict4 = Dict()
    with open('./data.json','r',encoding='utf-8') as f:
        dict=json.load(f)
        list1=dict['data']
        dict2=list1[0]
        dict3=list1[1]
        # 方法-：
        dict4.type=dict2['type']
        dict4.text = dict2['text']
        dict4.user_id =dict2['user_id']
        dict4.name = dict2['name']
        dict4.screen_name = dict2['screen_name']
        dict4.width = dict2['width']
        dict4.height = dict2['height']
        dict4.themes = dict2['themes']

        dict5.type = dict3['type']
        dict5.text = dict3['text']
        dict5.user_id = dict3['user_id']
        dict5.name = dict3['name']
        dict5.screen_name = dict3['screen_name']
        dict5.width = dict3['width']
        dict5.height = dict3['height']
        dict5.themes = dict3['themes']
        print(dict4.type,dict4.text,dict4.user_id,dict4.name,dict4.screen_name,dict4.width\
              ,dict4.height,dict4.themes)
        print(dict5.type, dict5.text, dict5.user_id, dict5.name, dict5.screen_name, dict5.width \
              , dict5.height, dict5.themes)
        d=Dict()
        datas=[]
        # 方法二：
        for dict1 in list1:
            # 得到一个对象
            data=d.creat_data(dict1)
            # 返回对象列表
            datas.append(data)
        print(datas[1].type)

结果：

41 胡萝卜造型的可爱多功能雨伞，了解一下 21088861 蒙面女侠Y 蒙面女侠Y 360 636 无
41 水陆两栖，自由变换，还不快来围观一下吗！ 15262111 共醉江湖 共醉江湖 1024 576 无
41

5.继承

子类：继承者
父类(超类)：被继承者

1）基础

python中类是可以继承的，并且支持多继承

class 类名(父类):
    """类的说明文档"""
    属性
    方法

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

2)能继承哪些内容

继承：直接拥有父类的属性和方法(继承后父类的属性和方法还是存在的)

• 对象的属性和方法都可以继承 、类的字段、类的方法和静态方法都可以继承(私有的继承无意义-->可当做不能继承)
• slots的值不会被继承
• getter和setter会被继承
• 如果父类设置了slots,子类对象也不能使用dict

class Person:
    '''人类'''
    number=34
    def __init__(self):
        self.name=''
        self.age=0
        self.sex='男'
        self.__length=0
        self._len1 = 0
    @property
    def len1(self):
        return self._len1
    @len1.setter
    def len1(self,len1):
        self._len1=len1
    def eat(self):
        print('%s在吃饭'% self.name)
    @classmethod
    def get_number(cls):
        print('有%d人'% cls.number)
    @staticmethod
    def hurt_earth():
        print('人类破坏地球')
class Student(Person):
    '''学生类'''
    pass
if __name__ == '__main__':
    stu=Student()
    stu.name='小明'
    stu.eat()
    print(stu.name,stu.age)
    print(stu.number)
    stu.get_number()
    stu.hurt_earth()
    print(stu.__dict__)
    stu.len1=100
    print(stu.len1)

结果：

小明在吃饭
小明 0
34
有34人
人类破坏地球
{'name': '小明', 'age': 0, 'sex': '男', '_Person__length': 0, '_len1': 0}
100