Day16-面向对象2
一、 私有化
1、 属性和方法的访问权限
私有的:在类的外部不可以使用,也不可以继承
保护的:在类的外部不可以继承,可以继承
公开的:在类的外部可以使用,也可以被继承
2、 python的私有化
python中属性和方法的访问权限只有公开,但是提供了另一种私有化的方式
python中在属性或者方法名前加'',就可以将属性或者方法变成私有的(注意:不能''结尾)
私有的属性和方法只能在类的内部使用,不能再类的外面使用
3、 python私有化的原理
在名字前是'_'的属性和方法前在加'类名'去保存属性和方法
class Person:
num = 61
__num2 = 62
def __init__(self, name = '张三', age=0, __sex='男'):
self.name = name
self.age = age
self.__sex = __sex
def eat(self, food):
print(self.name, food)
@classmethod
def show_num(cls):
print('人类的数量:%d' % cls.num)
@staticmethod
def func1():
print('人类要保护大自然!')
def main():
p1 =Person()
print(Person.num)
print(p1.name)
p1.eat('面条')
Person.func1()
print(p1._Person__sex)
if __name__ == '__main__':
main()
二、getter和setter
1、 应用场景。
getter:获取对象属性的值之前想要做点儿别的是事情,就给这个属性添加getter
setter:给对象属性赋值之前想要做点儿别的事情,就给这个属性添加setter
2 、 getter
第一步: 声明属性的时候,在属性名前加''
第二步: 声明函数(函数没有除了self以外的参数,但是要有返回值。返回值就是获取属性拿到的值)
@property
def 去掉下划线的属性名(self):
做点别的事情
返回属性的值
第三步:在类的外部通过 对象.取消的属性去获取相关的属性
3、 setter - 想要添加setter必须先要有getter
第一步:声明属性的时候在属性名前加_
第二步:声明函数(函数除了self以外还需要一个参数,没有返回值。这儿的参数代表属性赋的值)
@属性名去掉.setter
def 去掉的属性名(self,参数):
做点别的事情
给属性赋值
第三步:在类的外部通过对象.去掉_的属性去给相关属性赋值
class Person:
def __init__(self, name=''):
self.name = name
self._age = 0
self._week = 1 # 前面有_的不能直接调用
# 添加getter
@property
def age(self):
return self._age
# 给age添加setter
@age.setter
def age(self, value):
if not isinstance(value, int):
raise ValueError
if not 0 <= value <= 150:
raise ValueError
self._age = value
@property
def week(self):
if self._week < 7:
return '星期%d' % self.week
else:
return '星期天'
def main():
p1 = Person('小明')
p1.age = 100
print(p1.age)
p1.age = 2333
p1.age = 'sjd'
# 这个操作实质是在调用week函数
# 通过不带_的属性来获取属性的值实质是在调用getter对应的函数
print(p1.week)
if __name__ == '__main__':
main()
三、继承
1、 什么是继承
一个类继承另外一个类,其中会产生继承者和被继承者。这儿的继承者叫子类,被继承者叫父类或者超类
继承就是让子类直接拥有父类的方法和属性
2、 怎么继承
class 类名(父类列表):
类的内容
说明:
a. python中所有的类都是直接或间接继承自基类object
class 类名: ====> class 类名(object):
b. python中的继承支持多继承,父类列表中可以有多个类,多个类之间有逗号隔开
3、 能继承哪些东西:所有的属性和方法都能够继承
注意:slots的值不会继承
在类中给slots赋值后,当前类的对象不能使用dict;但是这个类的子类对象可以使用dict,
只是dice中没有从父类继承下来的属性,只有在子类中添加的对象属性
如果父类没有给slots赋值,直接给子类slots无效
class Person(object):
num = 61
__slots__ = ('name', 'age', 'sex', '__face')
def __init__(self, name='', age=0, sex='男'):
self.name = name
self.age = age
self.sex = sex
self.__face = 60
def eat(self, food):
print('%s在吃%s' % (self.name, food))
@classmethod
def shw_num(cls):
print('人类的数量:%d' % cls.num)
class Student(Person):
pass
def main():
print(Student.num)
stu = Student()
print(stu.name)
stu.eat('串串')
if __name__ == '__main__':
main()
四、添加属性和方法
=====================添加方法======================
1、 添加方法
直接在子类中声明新的方法
2、 重写方法
在子类中重新实现父类的方法 - 完全重写
保留父类的功能在子类中添加新的功能 - 部分重写(在子类方法中通过'super().'的方式调用父类方法)
3、 类中函数的调用过程
回到函数声明的位置:先看当前类中是否有方法,如果有就直接调用当前类中的方法;没有就去看父类有没有这个方法;
如果父类中也没有就看父类的父类中有没有……直到找到object类,如果object中也没有就报错。
=====================添加属性======================
1、 类的字段
直接在子类中只能声明新的字段
class Person(object):
num = 61
__slots__ = ('name', 'age', 'sex', '__face')
def __init__(self, name='', age=0, sex='男'):
self.name = name
self.age = age
self.sex = sex
self.__face = 60
def eat(self, food):
print('%s在吃%s' % (self.name, food))
@classmethod
def shw_num(cls):
print('人类的数量:%d' % cls.num)
class Student(Person):
# 添加方法
def study(self):
print('%s在写代码' % self.name)
@classmethod
def func1(cls):
print('子类的类方法')
@classmethod
def shw_num(cls):
print('学生的数量:%d' % cls.num)
def main():
p1 =Person('张三')
stu1 = Student('李四')
# 子类可以使用父类的属性和方法,但是父类不能使用子类中添加的属性和方法
Student.func1()
Person.shw_num()
Student.shw_num()
if __name__ == '__main__':
main()
添加对象属性
对象属性其实是通过继承init方法继承下来的
class Animal:
def __init__(self, age):
self.age = age
self.color = '灰色'
class Dog(Animal):
def __init__(self, name, age):
super().__init__(age)
self.name = name
def main():
dog1 = Dog('123', 3)
print(dog1.age)
dog2 = Dog('旺财', 3)
print(dog2.name)
if __name__ == '__main__':
main()
# 练习
# 声明人类,有属性,年龄,性别
# 声明学生类,有属性,年龄,性别,学号,分数
# 要求:创建人的对象的时候名字必须赋值,性别可以赋值也可以不赋值,年龄可以不赋值
# 创建学生对象的时候名字可以赋值可以不赋值,学号必须赋值,分数和性别、年龄不能赋值
class Person:
def __init__(self, name, sex='无'):
self.name = name
self.age = 20
self.ex = sex
class Student(Person):
def __init__(self, id, name='暂无'):
super().__init__(name)
self.id = id
self.score = 99
s1 = Student(1)
print(s1.id)
五、运算符重载
1、 什么是运算符重载
通过实现类中相应的魔法方法让当前类的对象支持相应的运算符
注意:python中所有的数据类型都是类,所有的数据都是对象
class Student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
# 实现‘+’对应的魔法方法,让两个学生对象能够进行‘+’操作
# self和other的关系:self + other ====> self.__add__(other)
# 返回值就是运算结果
def __add__(self, other):
return self.age + other.age
def __mul__(self, other):
return self.name * other
# 注意:大于和小于运算符只重载一个方法
def main():
stu1 = Student('小花', 18, 90)
stu2 = Student('小花', 18, 90)
print(stu1 == stu2)
print(stu1 + stu2)
print(stu1 * 3)
if __name__ == '__main__':
main()
六、内存管理
内存管理
1、 数据的存储
内存分为栈区间和堆区间;栈区间内存的开辟和释放是系统自动管理的,堆区间的内存是由程序员通过代码开辟(malloc)和释放的
从python语言较低,栈区间内存的开辟和释放是系统自动管理的,堆区间的内存关键也已经封装好了,
程序员也不需要写代码来开辟空间和释放空间。
a. python中变量本身是存在栈区间的,函数调用过程是在栈区间;对象(python中所有的数据都是对象)都是存在堆区间。
b. 变量赋值过程:先堆区间开辟空间将数据存起来,然后后将数据对应的地址存到栈区间的变量中。
数字和字符串比较特殊,赋值的时候不会直接开辟空间,而是先检测之前有没有存储过这个数据,如果有就用之前的数据地址。
2、 内存释放(垃圾回收机制)原理:
python中的每个对象都有一个属性叫‘引用计数’,表示当前对象引用的个数,判断一个对象是否销毁,就看对象的引用计数是否为0.
为0的就销毁,不为0的就不销毁。
# getrefcount(对象) - > 获取对象的引用计数
from sys import getrefcount
def main():
list1 = [1, 2]
print(getrefcount(list1))
# 使用不同的变量存对象地址会增加引用计数
list2 = list1
print(getrefcount(list2))
if __name__ == '__main__':
main()