day14总结

property

1. 内置类属性
   创建类的时候，系统默认为我们添加的类的属性

class Person:
    """人类"""
    # 类的字段
    number = 61
    # 对象属性
    def __init__(self, name, age=0, gender='女'):
        self.name = name
        self.age = age
        self.gender = gender

    def object_func(self):
        print('对象方法：' + self.name)

    @classmethod
    def class_func(cls):
        print('类方法：', cls.number)

    @staticmethod
    def static_func():
        print('静态方法')

    # 系统自带的魔法方法，可以定制当前类的对象的打印内容，实现这个函数的时候要求有一个字符串类型的返回值
    # 影响单独打印对象的效果
    def __str__(self):
        return str

    #对象作为元素的时候的打印效果
    def __repr__(self):
        return str(self.__dict__)


p1 = Person('小明', 18, '男')
persons = [p1, Person('小花', 20)]
print(persons)
# 1.__name__  字段
"""
类.__name__  -  获取类的名字
"""
print(Person.__name__, type(Person.__name__))

# 2.__doc__  字段
"""
类.__doc__  -  获取类的说明文档
"""
print(Person.__doc__)

# 3.__class__  对象属性
"""
对象.__class__  -  获取对象对应的类（你这个对象是哪个类的对象）
"""
print(p1.__class__)

# 4.__dict__  字段和对象属性
"""
类.__dict__  -  获取类中所有的字段和对应的值，以字典返回（了解）
对象.__dict__  -  获取对象中所有的属性和对应的值，以字典的形式返回（掌握）
"""
print(Person.__dict__)
print(p1.__dict__)

# 5.__module__  字段
"""
类.__module__  -  获取指定的类声明在哪个模块中，返回模块名（获取类所在的模块的__name__属性的值）
"""
print(Person.__module__)

# 6.__bases__  字段
"""
类.__bases__  -  返回当前类的所有父类
"""
print(Person.__bases__)

class A(Person, int):
    pass
print(A.__bases__)

2. slots魔法
   可以通过给slots字段赋值来约束当前类有哪些对象属性；
   当在类中给slots赋值后，当前类的对象的dict属性无效

class Dog:
    __slots__ = ('name', 'age')
    def __init__(self, name, age=0):
        self.name = name
        self.name = age


dog = Dog('大黄',)
dog.name = '小白'

# print(dog.__dict__)  AttributeError: 'Dog' object has no attribute '__dict__'

privateAndProtect

1. 高级语言
   在很多的高级面向对象语言中，会将属性和方法分为公开的（在类的外部可以使用），私有的（只能在类的内部使用，不能被继承），
   受保护的（只能在类的内部使用，可以被继承）三类
2. Python
   python中类的内容全部都是公开的，私有和公开都只是约定
   1)私有化 - a.内容只能在类的内部使用，不能再外面使用。（效果）
   b.在类中的方法或者属性名前加‘’，那么对应的属性和方法就会变成私有的。（怎么私有化）
   c.当声明类的时候在名字前加‘’，内部会在这个基础前面再加‘类名’。 （私有化的本质）
   2)属性保护 - 可以通过在对象属性名前加‘’，把这个属性标记成受保护类型；为了告诉别人这个属性在使用的时候，不要直接使用而是通过getter和setter来使用
   a.getter - 获取对象的属性值之前想要干点别的事情，那么就给这个属性值添加getter
   第一步：在对应的属性名前加‘’
   第二步：在@property后面声明一个函数，这个函数没有参数，有一个返回值，并且函数名是属性名去掉‘’
   第三步：获取属性值的时候，通过对象.属性名去掉下划线取获取属性的值

b.setter - 给属性赋值前干别的事情，就给这个属性添加‘setter’。（想要添加setter必须先有getter）
第一步：在对应的属性名前加‘’
第二步：在@getter属性名.setter后面声明一个函数，这个函数需要一个参数，没有返回值，并且函数名是属性名去掉‘’
第三步：给属性赋值的时候，通过‘对象.属性名去掉下划线=值’的方式赋值

3.抛出异常
a.语法
raise 异常类型

b.说明：
raise - 关键字
异常类型 - 可以是系统提供的异常类型，也可以自定义异常类型（必须继承Exception）

4.自定义异常类型：写一个类继承Exception，然后重写str方法来自定义错误信息

class WeekError(Exception):
    def __str__(self):
        return '星期的值只能是1到7的整数'


# ===========受保护=========
class Person1:
    def __init__(self):
        self.age = 0
        self._week = 1

    @property
    def week(self):
        weeks = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
        return weeks[self._week - 1]

    @week.setter
    def week(self, x):
        if not isinstance(x, int):
            raise ValueError
        elif not 1 <= x <= 7:
            raise WeekError
        self._week = x


p1 = Person1()
p1.age = 100
p1.age = 1000
p1.age = 'abc'

p1.week = 7  # 本质是在调用setter对应的方法
print(p1.week)  # 本质是在调用getter对应的方法

# 练习：给age属性添加getter和setter，获取年龄的时候拿到年龄值，和这个年龄对应的阶段；
# 给 age赋值的时候，必须是整数，并且范围在0-150之间，如果不满足要求报错：AgeError
class AgeError(Exception):
    def __str__(self):
        return '年龄有误'

class People:
    def __init__(self, age=0):
        self._age = age

    @property
    def age(self):
        if self._age < 18:
            return self._age, '未成年'
        elif self._age < 30:
            return self._age, '成年'
        elif self._age < 50:
            return self._age, '中年'
        else:
            return self._age, '老年'

    @age.setter
    def age(self, x):
        if not isinstance(x, int):
            raise AgeError
        elif not 0 <= x <= 150:
            raise AgeError
        self._age = x


p2 = People()
p2.age = 42
age, jieduan = p2.age
print(age, jieduan)







# ===========私有化==========
print('========私有化=======')
class Person:
    __number = 60
    def __init__(self, name, age=19):
        self.name = name
        self.__age = age

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


p = Person('小明')
# print(p.__age)  AttributeError: 'Person' object has no attribute '__age'
p.message()
print(p._Person__age)

inherit

1. 什么是继承：让子类直接拥有父类所有的的属性和方法
   父类 - 被继承者，子类 - 继承者
   Python中所有的类都是直接或间接的继承object
2. 怎么继承
   class 子类名（父类1，父类2...）
   类的内容
3. 子类中添加内容
   1)添加字段和方法直接添加

class Person(object):
    number = 61

    def __init__(self, name, age=0, gender='男'):
        # name = '小花'
        self.name = name
        self.age = age
        self.gender = gender
        self.__num = '0001'

    def fun1(self):
        print('Person对象方法:', self.name)

    @classmethod
    def func2(cls):
        print(cls.number)

    @staticmethod
    def func3():
        print('func3')


class Student(Person):
    flag = '学生！'

    def __init__(self, name):
        # name = '小花'
        # 在子类的方法中去调用父类的方法，父类中必须要有值的属性，super后面的init里要有形参传值
        super().__init__(name)     #  super().__init__('小花')
        self.study_id = 'stu001'

    def fun1(self):
        super().fun1()
        print('子类的,func1')

    def study(self):
        print('%s在学习' % self.name)


stu = Student('小花')
print(stu.__dict__)
# 使用父类继承下来的属性和方法
print(Student.number)
print(stu.name)
stu.fun1()
Student.func2()
Student.func3()


# 使用自己的属性和方法
print(Student.flag)
stu.study()


print(Person.__bases__)