1.访问权限
私有的：在类的外部不可以使用，也不可以继承
保护的：在类的外部不可以使用，可以继承
公开的:在类的外部可以使用，也可以被继承
2.Python中属性和方法的访问权限只有公开，但是提供了另一种私有化的方式。
3.Python中在属性或者方法名前加,就可以降属性或者方法私有化，只能两个下划线开头，不能结尾
私有的属性和方法只能在类的内部使用，不能在类的外面使用
4.Python私有化的原理
在名字前是的属性和方法在家'_类名'去保存属性和方法
class Person:
num =31
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self,food):
print('%s吃%s'%(self.name,food))
@classmethod
def show_num(cls):
print('人类的数量：%d'%cls.num)
@staticmethod
def func1():
print('wqwqwqqwqwqwqwqwqwqwqw')
def main():
p1 = Person('曾令鹏',18)
1.应用场景
getter：获取对象属性的值之前想要做点别的事情，就给这个属性添加getter
setter：给对象属性赋值之前想要做点别的事情，就给这个属性添加setter
2.getter
第一步：声明属性的时候在属性名前加_
第二步：声明一个函数（函数没有除了self以外的参数，要是要有返回值。返回值就是获取属性拿到的值）
@property
def 去掉的属性名（self）：
做点别的事情
返回属性的值
第三步：在类的外部通过对象.去掉的属性去获取相关的属性
3.setter --想要添加setter必须先有getter
第一步：声明属性的时候在属性名前加_
第二步：声明函数（函数除了self以外还需要一个参数，没有返回值。这儿的参数代表给属性赋的值）
@属性名去掉.setter
def 去掉的属性名（self，参数）：
做点别的事情
给属性赋值
第三步：在类的外部通过对象.去掉的属性去给相关属性赋值
注意：通过不带的属性给属性赋值实质是在调用setter对应的函数
通过不带_的水性来获取属性的值实质是在调用getter对应的函数
class Person:
def __init__(self, name=''):
self.name = name
self._age = 0
self._week = 1
# 添加getter
@property
def week(self):
if self._week < 7:
return '星期%d' % self._week
elif self._week:
return '星期天'
@property
def age(self):
return self._age
@age.setter
def age(self, value):
if not isinstance(value, int):
raise ValueError
if not (0 <= value <= 150):
raise ValueError
self._age = value
def main():
p1 = Person
p1.age = 233
print(p1.age)
1.一个类继承另外一个类，其中会产生产生继承者和被继承者。这儿的继承者叫子类，被继承者叫父类或者超类
继承就是让子类直接拥有父类的方法和属性
2.怎么继承
a.语法：
class 类名（父类）：
类的内容
说明：
a.Python中所有的类都是直接或者间接继承自object（基类）
b.Python中的继承支持多继承，父类列表可以有多个类，多个类之间用逗号隔开
**注意：a.slots的值继承后没有效果
b.在类中给slots_赋值后，当前类的对象不能使用dict;但是这个类的子类对象可以使用dict
只是dict中没有从父类继承下来的属性，只有在子类中添加的对象属性
c.如果父类没有给slots赋值，直接给子类的slots，无效
多继承：多继承的时候，多个父类中的所有方法都可以继承，只是对象属性只能继承第一个父类的
class Person(object):
num =52
def __init__(self,name='',age=0,sex='男'):
self.name = name
self.age = age
self.sex=sex
def eat(self,food):
print('%s在吃%s'%(self.name,food))
@classmethod
def show_num(cls):
print(cls.num)
class Student(Person):
pass
def main():
s1 =Student
print(s1.__dict__)
==========================添加方法==============================
1.添加方法
直接在子类中声明新的方法
子类可以使用父类的属性和方法，但是父类不能使用子类中添加的方法
2.重写方法
在子类中重新实现父类的方法 --完全重写
保留父类的功能在子类中添加新的功能 -部分重写（在子类方法中通过super（）.的方式调用父类方法
3.类中函数的调用过程
回到函数声明的位置：先看当前类中是否有方法，如果有就直接调用当前类中的方法，
如果有就调用，没有就看父类中是否有，如果父类中也没有就看父类的父类
直到找到object类，还是没有就报错
=============================添加属性===========================
1.类的字段
直接在子类声明新的字段
class Person(object):
num =52
def __init__(self,name='',age=0,sex='男'):
self.name = name
self.age = age
self.sex=sex
def eat(self,food):
print('%s在吃%s'%(self.name,food))
@classmethod
def show_num(cls):
print(cls.num)
class Student(Person):
def study(self):
print('%s在写代码'%self.name)
def eat(self):
super
@classmethod
def show_num(cls): #完全重写
print('xuesheng%s'%cls.num)
def main():
s1 = Student('曾令鹏')
s1.study()
添加对象属性：
对象属性其实是通过继承init方法继承下来的
class Animal:
def __init__(self):
self.age = 0
self.color = '灰色'
class Dog():
def __init__(self, name):
# 调用父类的init方法来继承父类的对象属性
super().__init__()
self.name = name
def main():
pass
1.运算符重载
通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符
class Student():
def __init__(self,name,age,score):
self.name = name
self.age = age
self.score = score
实现'+'对应的魔法方法，让两个学生对象能够进行+操作
self和other的关系：self+other
def __add__(self, other):
return self.age + other.age
def main():
stu1 =Student('小明',18,97)
stu2 = Student('小花',19,87)
print(stu1+stu2) #print(stu1.__add__(stu2))
if __name__ == '__main__':
main()
内存管理
1.数据的存储
内存分为栈区间和堆区间：从底层看栈区间的内存开辟和释放是系统自动管理的，堆区间是由程序员通过代码开辟和释放的
从Python语言角度，堆区间的内存开辟和释放是系统自动管理的，堆区间的内存关键也已经封装好了
a.Python中变量本身是存在栈区间的，函数调用过程是在栈区间；对象都是存在堆区间（Python中所有的数据都是对象）
b.Python中变量赋值过程：现在堆区间开辟空间将数据存起来，然后将数据对应的地址存到栈区间的变量中
数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是检测之前有没有存储过这个数据，如果有就用这个地址，没有就开辟
2.内存释放（垃圾回收机制）原理：
Python中的每个对象都有一个属性叫引用计数，表示当前对象的引用个数。判断一个对象是否销毁，就看对象的引用计数是否为0
为0的销毁，不为0的就不销毁
getrefcount函数(对象)：获取对象的引用计数
from sys import getrefcount#
def main():
list1 = [1,2]
#使用不同的变量存对象地址会增加引用计数
list2 = list1
print(getrefcount(list1))
pass
