day-14 内置属性

1.类的声明

类是拥有相同属性和相同功能的对象的集合

"""
class 类名:
类的内容
"""

2.创建对象

对象 = 类()

3.(重点！)类中的内容：对象方法、类方法、静态方法；字段、对象属性

"""
1)方法 - 怎么声明、特点、怎么调用、什么时候用
对象方法: 直接声明在类中的函数; 有默认参数self; 通过对象调用; 实现函数功能需要用到对象属性的时候
类方法:声明前加@classmethod; 有默认参数cls; 通过类调用;实现函数功能不需要对象属性，需要类相关操作的时候
静态方法:声明前加@staticmethod; 没有默认参数; 通过类调用; 既不需要对象属性，也不需要类相关操作

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

4.对象属性的增删改查

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

"""

class Person:
    number = 100

    def __init__(self):
        self.name = '小明'

    def func1(self):
        # print(Person.number)
        print(self.name)

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

    @staticmethod
    def func3():
        print(Person)
        print(Person.number)


p1 = Person()
p1.func1()
# Person.func2()
# Person.func3()



class Student(Person):

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(self.__dict__)[1:-1]

# 对象作为元素的时候的打印效果

    def __repr__(self):
        return '<'+str(self.__dict__)[1: -1]+'>'

    # def __repr__(self):
    #     return '<%s.%s object at %s>' % (self.__class__.__module__, self.__class__.__name__, hex(id(self)))

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

1.name 字段

"""
类.name - 获取类的名字
"""
print(Person.name, type(Person.name)) # Person

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)

print('p1：', p1)

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

# 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('大黄')

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 AgeError(Exception):
    def __str__(self):
        return '年龄要求是整数，并且范围在0~150!'

class Person1:
def init(self):
self._age = 0
self._week = 6

@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

@property
def week(self):
    weeks = ['周1', '周2', '周3', '周4', '周5', '周6', '周日']
    return weeks[self._week - 1]

@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.week = 1 # 本质是在调用setter对应的方法
print(p1.week) # 本质是在调用getter对应的方法

p1.age = 100
age, jieduan = p1.age
print(age, jieduan)

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

print('===============私有化==============')

===============私有化==============

class Person:
__number = 61

def __init__(self, name, age=18):
    self.name = name
    self.__age = age

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

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

p = Person('小明')
print(p.name)

print(p._Person__age)

p.message()

print(Person.__number)

p.__func1()

print(p.dict)

# 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__(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)