一、昨日内容复习
1.类：拥有相同属性和相同功能的对象的集合（抽象）
属性 -> 存储数据(对象属性，类的字段)
功能 -> 方法(对象方法,类方法和静态方法)
class 类名(父类):
类的内容
2.对象: 类的实例（具体）
对象 = 类名()
3.构造方法和init方法
构造方法: 声明类的时候，系统会自动创建一个函数，这个函数的函数名和类名一样。这个方法就是构造方法。
构造的作用就是创建对象，并且自动的去调用init方法
init方法：a.系统在创建对象的时候自动调用。
b.可以有除了self以外的其他参数，如果要给这些参数传参，需要使用构造方法来传
c.需要给类添加对象属性
- 构造方法给init方法传参的原理:
# 伪代码
# def Person():
# obj = malloc(4)
# obj.__init__()
# return obj
# 构造方法给init方法传参的原理
# def dog_init(name, age, sex):
# print(name, age, sex)
#
# def Dog(*args, **kwargs):
# dog_init(*args, **kwargs)
#
# Dog('abc', 23, sex='男')
4.对象方法: 直接声明在类中的函数就是对象方法，有默认参数self，并且要通过对象,调用的时候不用给self传参
对象.对象方法,系统会将前面的对象传递给对象方法中的self
5.对象的属性
a.声明在init方法中
b.self.属性 = 值
要通过对象去使用（增删改查）
6.类的字段(类的属性)
声明在类中，函数的外面的变量；通过类来使用(不管在哪儿用)
7.对象.__dict__
二、类方法和静态方法
类中方法：对象方法、类方法和静态方法
1.对象方法：
a.直接声明在类中
b.自带参数self
c.通过对象来调用
2.类方法：
a.将函数声明在@classmethod后面的函数就是类方法
b.自带参数cls(cls在函数调用的时候不用传参，系统会自动将调用这个方法的类赋给它)
c.通过类来调用
3.静态方法：
a.声明在@staticmethod后面的函数就是静态方法
b.没有自带参数
c.通过类来调用
4.怎么选择使用哪种方法（重点！！！）：
对象方法：如果实现函数的功能需要用到对象的属性，那么就把这个函数声明成对象方法
静态方法和类方法：实现函数的功能不需要用到对象的属性，就可以使用静态方法或者类方法
类方法：在不使用对象属性的前提下，需要使用类
静态方法：既不需要对象的属性，也不需要类
class Person:
num = 61
# 声明一个类方法
@classmethod
def destory(cls):
# cls指向的是当前类，调用这个方法的类可以做的事情，cls都能做
print('cls:', cls, cls.num)
p2 = cls()
print('人类破坏环境')
# 声明一个静态方法
@staticmethod
def func1():
print(Person.num)
p3 = Person()
print(p3)
print('人类的静态方法')
Person.destory()
print(Person)
print(Person.num)
p1 = Person()
class Student(Person):
pass
Student.func1()
Student.destory()
Person.func1()
Person.destory()
# cls: <class '__main__.Person'> 61
# 人类破坏环境
# <class '__main__.Person'>
# 61
# 61
# <__main__.Person object at 0x00000000024D6588>
# 人类的静态方法
# cls: <class '__main__.Student'> 61
# 人类破坏环境
# 61
# <__main__.Person object at 0x00000000024D6630>
# 人类的静态方法
# cls: <class '__main__.Person'> 61
# 人类破坏环境
class Math:
pi = 3.1415926
@classmethod
def circle_area(cls, radius):
return cls.pi * radius ** 2
@staticmethod
def sum(num1, num2):
return num1 + num2
class Number:
def __init__(self):
self.value = 0
self.type = int
self.id = None
@staticmethod
def max():
return 100
@staticmethod
def min():
return -100
num = Number()
num.value = 1000
print(Number.max()) # 100
三、私有化
类中的内容默认都是公开的(在类的外面可以使用)
1.私有化
将类的内容在类的外面隐藏
在类中的方法名或者属性名前加两个下划线
私有的方法和属性，只能在类的内部使用，不能在类的外部使用
2.私有的原理
python中没有真正的私有化（没有从访问权限上去限制内容的访问）
私有的原理就是在私有的属性名或者方法名前加前缀'_类名'，来阻止外部直接通过带两个下划线的名字去使用私有属性和方法
class Person:
# 私有字段
__num = 61
def __init__(self, name, age):
self.name = name
# 私有的对象属性
self.__age = age
def show_age(self):
print(self.__age)
self.__func1()
# 私有的对象方法
def __func1(self):
print('私有对象方法')
p1 = Person('小明', 23)
print(p1.name)
# print(p1.age) # AttributeError: 'Person' object has no attribute 'age'
# print(p1.__age) # AttributeError: 'Person' object has no attribute 'age'
p1.show_age()
# 23
# 私有对象方法
# p1.__func1() # AttributeError: 'Person' object has no attribute 'age'
print(p1.__dict__) # {'name': '小明', '_Person__age': 23}
print(p1._Person__age) # 23
四、getter和setter
1.什么时候需要添加对象属性的getter和setter
如果希望在通过对象.属性获取属性的值之前，再干点儿别的事情，就可以给这个属性添加getter
如果希望在通过对象.属性给属性赋值之前，再干点儿别的事情，就可以给这个属性添加setter
2.怎么添加setter和getter
getter:
a.在属性名前加_
b.添加属性对应的getter
@property
def 属性名去掉_(self):
函数体 --> 会对属性的值进行处理后返回相应的结果（必须要有返回值）
c.使用属性的值的时候，不通过带下划线的属性名去使用，而是通过没有下划线的属性去使用
注意：对象.不带下划线的属性 --> 调用getter对应的函数
自己备注的：（property是去掉调用函数时的括号，并且将函数返回值作为函数名的值）
setter:
如果要添加setter,必须要先添加getter
a.添加setter
@getter名.setter
def 属性名去掉_(self,参数):
做别的事情
self.属性名 = 处理后的值
class Number:
def __init__(self):
self._value = 0
# 通过0-6保存星期几
self._week = 0
self.type = int
self.id = None
@property
def value(self):
return self._value
@value.setter
def value(self, x):
if not -100<=x<=100:
raise ValueError
self._value = x
# _week的getter
@property
def week(self):
if self._week == 0:
return '星期天'
elif self._week == 1:
return '星期一'
elif self._week == 2:
return '星期二'
elif self._week == 3:
return '星期三'
elif self._week == 4:
return '星期四'
elif self._week == 5:
return '星期五'
elif self._week == 6:
return '星期六'
"""
isinstance(值, 类) --> 判断指定的值是否是指定类型（返回值是bool）
"""
@week.setter
def week(self, value):
if not isinstance(value, int):
raise ValueError
if not 0<=value<=6:
raise ValueError
self._week = value
@staticmethod
def max():
return 100
@staticmethod
def min():
return -100
num = Number()
print(num.week) # 星期天 # num.week实质是在通过num对象调用getter对应的对象方法week
print(num._week) # 0
# num.week = '1' # ValueError
num.week = 1 # num.week = 值 实质是通过num对象去调用setter对应的week方法
# num.week = 10 # ValueError
# num.value = 1000 # ValueError
练习：
class Person:
def __init__(self):
self.name
self.age
赋值时要求age的值只能在0-150之间，超过范围报错；获取age的值的时候，返回年龄值，并且返回这个年龄对应的阶段和值
class Person:
def __init__(self):
self.name = ''
self._age = 18
@property
def age(self):
if 0<=self._age<=3:
return '年龄：' + str(self._age) + ', 阶段：婴儿'
elif 4<=self._age<=12:
return '年龄：' + str(self._age) + ', 阶段：儿童'
elif 13<=self._age<=17:
return '年龄：' + str(self._age) + ', 阶段：少年'
elif 18<=self._age<=29:
return '年龄：' + str(self._age) + ', 阶段：青年'
elif 30<=self._age<=59:
return '年龄：' + str(self._age) + ', 阶段：中年'
elif 60<=self._age<=150:
return '年龄：' + str(self._age) + ', 阶段：老年'
@age.setter
def age(self, value):
if not 0<=value<=150:
raise ValueError
self._age = value
age1 = random.randint(0,150)
p1 = Person()
p1.age = age1
print(p1.age)
# p2 = Person()
# p2.age = 151 # ValueError
