回顾
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__)
