回顾

1.类的声明
类是拥有相同属性和相同功能的对象的集合
'''
class 类名：
类的内容

'''
2.创建对象
对象 = 类（）

3.（重点）类中的内容：对象方法、类方法、静态方法；字段、对象属性
'''
1）方法 -- 怎么声明、特点、怎么调用、什么时候用
对象方法：直接声明在类中的函数；有默认参数self；通过对象调用；实现函数功能需要用到对象属性的时候。
类方法：声明前加@classmethod；有默认参数cls；通过类调用；实现函数功能不需要对象属性，需要类相关操作的时候
静态方法：声明前加@staticmethod；没有默认参数；通过类调用；既不需要对象属性，也不需要类相关操作

2）属性 -- 怎么声明、怎么使用、什么时候用
字段：声明在类里面，函数的外面；通过类来使用；不会因为对象不同而不同的属性声明成字段
对象属性：以'self.属性 = 值'的形式声明在init方法中；通过对象使用；会因为对象不同而不同的属性声明成对象属性

'''
4.对象属性的增删改查
'''
对象.属性/getattr() -- 查
对象.属性 = 值/setattr() -- 增、改
del 对象.属性/delattr() -- 删

属性

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

class Person:
    '''人类'''
    # 类的字段
    number = 61
    # 对象属性
    def __init__(self, name, age, 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(self.__dict__)
'''
    # 对象作为元素的时候的打印效果
    def __repr__(self):
        return 'abc'


p1 = Person('小明', 18, '男')


print('p1:',p1)

persons = [p1,Person('小花',20)]
print(persons)

1).name 字段
'''
类.name -- 获取类的名字
'''

print(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)

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

class Dog:
    #__slots__ = ('name','age','gender','name1')

    def __init__(self, name, age=0):
        self.name = name
        self.age = age
        self.gender = '公'


dog = Dog('大黄')
dog.name1 = '小白'
#dog.x = 12
print(dog.__dict__)

私人、保护

'''
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 WeekValueError(Exception):
    def __str__(self):
        return '星期的值只能是1-7的整数！'

# raise WeekValueError

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

    @property
    def week(self):
        return '星期一'

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

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

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

练习：给age属性添加getter和setter，获取年龄的时候拿到年龄值，和这个年龄对应的阶段给age赋值的时候，必须是整数，并且范围在0-120。如果不满足要求报错：AgeError

class AgeError(Exception):
    def __str__(self):
        return '年龄必须是整数，并且范围在0-120！'

class Person2:
    def __init__(self):
        self._age = 0

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


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

p2 = Person2()
p2.age = 100
print(p2.age)



# ================私有化==============
class Person:
    def __init__(self, name, age=10):
        self.name = name
        self.__age = age

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


p = Person('小明')
print(p.name)
#p.message()
#print(p.__age)
print(p._Person__age)

继承

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

class Person(object):
    number = 61
    def __init__(self):
        self.name = '小明'
        self.age = 18
        self.gender = '男'

    def fun1(self):
        print(self.name)

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

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


class Student(Person):
    flag = '学生！'
    def __init__(self):
        # 在子类的方法中调用父类的属性
        super().__init__()
        self.study_id = 'stu0001'
    pass

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