一、私有化
1.属性和方法的访问权限
私有的：在类的外部不可以使用，也不可以继承
保护的：在类的外部不可以使用，可以继承
公开的：在类的外部可以使用，也可以被继承
2.python的私有化
python中属性和方法的访问权限只有公开，但是提供了另一种私有化的方式。
python中在属性或者方法名前加 _ _，就可以将属性或者方法变成私有的(注意：只能两 _ _ 开头，不能 _ _ 结尾)
私有的属性和方法只能在类的内部使用，不能在类的外面使用
3.python私有化的原理
在名字前是 _ _ 的属性和方法前再加 ' _ 类名 ' 去保存属性和方法
class Person:
num = 61
__num2 = 62
def __init__(self, name='张三', age=0):
self.name = name
self.age = age
self.__sex = '男'
def eat(self, food):
print(self.__sex)
print(self.name, food)
self.__run()
def __run(self):
print('%s在跑步' % self.name)
@classmethod
def show_num(cls):
print('人类的数量:%d, %d' % (cls.num, cls.__num2))
@staticmethod
def func1():
print('人类要保护大自然!')
def main():
p1 = Person()
print(Person.num)
# print(Person.__num2)
print(p1.name)
# print(p1.__sex)
print(p1._Person__sex)
p1.eat('面条')
# p1.run()
Person.show_num()
Person.func1()
print(p1.__dict__)
if __name__ == '__main__':
main()
二、getterAndSetter(了解)
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 = 7 # 属性名前有_，使用属性的时候不要直接用
@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
# 给week添加getter
@property
def week(self):
if self._week < 7:
return '星期%d' % self._week
else:
return '星期天'
@week.setter
def week(self, value):
self._week = value
def main():
p1 = Person('小明')
# 通过不带_的属性给属性赋值实质是在调用setter对应的函数
p1.age = 45
p1.age = 3
# 这个操作实质是在调用week函数
# 通过不带_的属性来获取属性的值实质是在调用getter对应的函数
print(p1.week)
p1.week = 4
if __name__ == '__main__':
main()
三、inherit
1.什么是继承
一个类继承另外一个类，其中会产生继承者和被继承者。这儿的继承者叫子类，被继承者叫父类/超类
继承就是让子类直接拥有父类的方法和属性
2.怎么继承
语法：
class 类名(父类列表):
类的内容
说明：
a.python中所有的类都是直接或者间接继承自基类object
class 类名: ===> class 类名(object):
b.python中的继承支持多继承， 父类列表中可以有多个类，多个类之间用逗号隔开
3.能继承哪些东西: 所有的属性和方法都能够继承
注意：a. _ _ slots _ _ 的值继承后没有效果
b.在类中给 _ _ slots _ _ 赋值后，当前类的对象不能使用 _ _ dict _ _ ;但是这个类的子类对象可以使用 _ _ dict _ _,
只是 _ _ dict _ _ 中没有从父类继承下来的对象属性，只有在子类中添加的对象属性
c.如果父类没有给 _ _ slots _ _ 赋值，直接给子类的 _ _ slots _ _，无效！
class Person(object):
num = 61
# __slots__ = ('name', 'age', 'sex', '__face')
def __init__(self,name='zhangsan', 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 show_num(cls):
print('人类的数量:%d' % cls.num)
class Student(Person):
# __slots__ = ('name', 'age', 'sex', '__face')
pass
#
def main():
# Student.num = 20
print(Student.num)
stu = Student()
print(stu.name)
# print(stu.__dict__)
# print(stu.__face)
stu.eat('海底捞')
Student.show_num()
p1 = Person()
# print(p1.__dict__)
# p1.score = 100
stu.score = 100
print(stu.score)
print(stu.__dict__)
if __name__ == '__main__':
main()
四、添加属性和方法
1.添加方法
直接在子类中声明新的方法
2.重写方法
在子类中重新实现父类的方法 - 完全重写
保留父类的功能在子类中添加新的功能 - 部分重写（在子类方法中通过'super().'的方式调用父类方法）
3.类中函数的调用过程
回到函数声明的位置：先看当前类中是否有方法，如果有就直接调用当前类中的方法；没有就去看父类中有没有这个方法；
如果父类中也没有就看父类的父类中有没有....直到找到object类，如果object中也没有就报错！
=====================添加属性======================
1.类的字段
直接在子类中声明新的字段
class Person(object):
num = 61
def __init__(self,name='zhangsan', 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 show_num(cls):
print('人类的数量:%d' % cls.num)
class Student(Person):
num2 = 100
# 添加方法
def study(self):
print('%s在写代码' % self.name)
@classmethod
def func1(cls):
print('我是学生类的类方法')
@staticmethod
def func2():
print('我是学生类的静态方法')
@classmethod
def show_num(cls):
print('学生数量:%d' % cls.num)
def eat(self, food):
super().eat(food)
print('吃饱了')
def main():
p1 = Person('张三')
stu1 = Student('李四')
stu1.study()
Student.func1()
# 子类可以使用父类的属性和方法，但是父类不能使用子类中添加的属性和方法
# Person.func2()
Person.show_num()
Student.show_num()
stu1.eat('包子')
print(Student.num2)
if __name__ == '__main__':
main()
五、添加对象属性
添加对象属性:
对象属性其实是通过继承init方法继承下来的
class Animal:
def __init__(self, age):
self.age = age
self.color = '灰色'
class Dog(Animal):
def __init__(self, name, age):
# 调用父类的init方法来继承父类的对象属性
super().__init__(age)
self.name = name
class Cat(Animal):
pass
练习：
声明人类有属性：名字、年龄、性别
声明学生类有属性：名字、年龄、性别、学号、分数
要求：创建人的对象的时候名字必须赋值，性别可以赋值也可以不赋值，年龄不能赋值；
创建学生对象的时候名字可以赋值可以不赋值，学号必须赋值，分数和性别、年龄不能赋值
class Person:
def __init__(self, name, sex='男'):
self.name = name
self.age = 0
self.sex = sex
class Student(Person):
def __init__(self, id, name='张三'):
super().__init__(name, '女')
self.id = id
self.score = 0
def main():
# 情景一：直接继承，不添加
# dog1 = Dog()
# print(dog1.age)
dog2 = Dog('才才', 3)
print(dog2.name)
print(dog2.age, dog2.color)
if __name__ == '__main__':
main()
六、运算符重载
1.什么是运算符重载
通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符
注意：python中所有的数据类型都是类; 所有的数据都是对象
class Student(object):
def __init__(self, name='', age=0, score=0):
self.name = name
self.age = age
self.score = score
def __repr__(self):
return '<' + str(self.__dict__)[1:-1] + '>'
# 实现'+'对应的魔法方法，让两个学生对象能够进行+操作
# self和other的关系： self+other ==> self.__add__(other)
# 返回值就是运算结果
def __add__(self, other):
# a.支持Student+Student:
return self.age + other.age
# b.支持Student+数字
# return self.age + other
# self * other
# 将other当成数字
def __mul__(self, other):
return self.name * other
# self和other都是学生对象
# 注意：大于和小于运算符是需要重载一个就行
def __gt__(self, other):
return self.score > other.score
def main():
stu1 = Student('小花', 18, 90)
stu2 = Student('夏明', 20, 78)
stu3 = Student('小红', 17, 99)
# 所有类的对象都支持'=='和'!='运算
print(stu1 == stu2)
print(stu1 + stu2) # print(stu1.__add__(stu2))
# print(stu1 > stu2)
# print(stu1 < stu2)
print(stu1 * 2) # print(stu1.__mul__(2))
students = [stu1, stu2, stu3]
print(students)
students.sort()
print(students)
if __name__ == '__main__':
main()
八、内存管理
1.数据的存储
内存分为栈区间和堆区间；从底层来看，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存是由程序员通过代码开辟(malloc)和释放的
从python语言角度，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存关键也已经封装好了,
程序员也不需要写代码来开辟空间和释放空间
a.python中变量本身是存在栈区间的，函数调用过程是在栈区间; 对象都是存在堆区间(python中所有数据都是对象)
b.变量赋值过程：先堆区间开辟空间将数据存起来， 然将数据对应的地址存到栈区间的变量中。
数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，
如果有就用之前的数据的地址
2.内存释放(垃圾回收机制)原理：
python中的每个对象都有一个属性叫'引用计数',表示当前对象的引用的个数。判断一个对象是否销毁就看对象的引用计数是否为0；
为0的就销毁，不为0的就不销毁。
getrefcount函数：
getrefcount(对象) -> 获取对象的引用计数
from sys import getrefcount
def main():
list1 = [1, 2]
print(getrefcount(list1)) # 2
# 使用不同的变量存对象地址会增加引用计数
list2 = list1
print(getrefcount(list1)) # 3
[1, list1]
print(getrefcount(list1)) # 3
# def func1(obj):
# print(getrefcount(list1))
#
# func1(list1)
print(getrefcount(list1))
list1 = []
print(getrefcount(list2)) # 2
del list2
# print(getrefcount(list2)) # UnboundLocalError
# def getrefcount(obj):
# obj = list1
# 获取obj的引用计数
bullets = [{'x': 10, 'y': 20}, {'x': 30, 'y': 10}, {'x': 100, 'y': 200}]
del bullets[2]
bullets.pop(0)
if __name__ == '__main__':
main()