一.内的属性,私有化,继承,抛出异常
1.内置类属性
__ dict ， class __, __ name __, __ doc __, __ module __, __ bases __
__ slots __
魔法方法: __ str __, __ repr __
2.私有化、getter和setter
getter - 希望获取对象的值之前做点儿别的事情的时候使用
@property
def 去掉属性的下划线(self):
return 值
setter - 希望给对象的属性赋值前要做点儿别的事情的时候使用
@getter名.setter
def 去掉属性的下划线(self, x):
带属性的下划线 = 值
3.继承
class 子类(父类):
内的内容
(重点)类中方法的调用过程：先看当前类中是否有对应的方法，如果没有就去父类找，父类没有再父类的父类，
以此类推，如果找到object还没找到才报错。
在哪个类中先找到就直接调用对应的方法
super的使用: 可以在子类的对象方法和类方法中去通过'super(). '的方式去调用父类的对象方法和类方法. super().func1()
4.抛出异常
raise 异常类型
"""
class SelfError(Exception):
def __str__(self):
return '描述错误！'
raise SelfError
class Person:
def __init__(self, name, age=0, gender='男'):
self.name = name
self.age = age
self.gender = gender
@classmethod
def func1(cls):
print('Person的静态方法')
class Student(Person):
def __init__(self, name):
super().__init__(name)
self.id = '001'
@classmethod
def func1(cls):
print('Student的静态方法')
super().func1()
stu = Student('小明')
Student.func1()
二.运算符重载
import copy
1.什么是运算符重载
"""
1)python中所有的类型都是类，所有的数据都是类的对象
2)python中使用运算符的时候，实质会去调用这个运算符对应的魔法方法;
类的对象是否支持相应的运算符，就看这个类中有没有实现对应的魔法方法.
"""
class Animal:
def shout(self):
print('叫唤')
pass
class Dog(Animal):
def shout(self):
print('汪汪')
pass
class Cat(Animal):
def shout(self):
print('喵喵')
pass
class Student:
def __init__(self, name, age=0, score=0):
self.name = name
self.age = age
self.score = score
def __repr__(self):
return str(self.__dict__)
_ _ add _ _是+的魔法方法，self代表+前面的数据，other代码+后面的数据，返回值是运算结果
def __add__(self, other):
# self = stu1, other = stu2
return self.age+other.age
* 的魔法方法
def __mul__(self, other):
stus = []
for _ in range(other):
stus.append(copy.copy(self))
return stus
> 的魔法方法
注意: > 和 < 的魔法方法只需要实现一个，另外一个自动支持
def __gt__(self, other):
return self.score > other.score
def main():
stu1 = Student('小明', 20, 80)
stu2 = Student('小花', 18, 90)
# stu1+stu2 --> stu1.__add__(stu2)
print('两个学生相加:', stu1 + stu2)
students = stu1*4
students[0].name = '小花'
print(students)
print(stu1 > stu2)
print(stu1 < stu2)
students2 = [stu1, stu2]
students2.sort()
# print(students2)
print(max(students2))
三.内存管理机制
1.内存可以分为栈区间和堆区间，栈上的内存是系统自动开辟自动释放，堆上的内存需要手动开辟、手动释放。
在python中堆上的内存空间会通过python提供的内存管理机制自动管理
2.内存管理机制
1）内存开辟
python中所有的变量都是保存在栈区间的，并且所有的变量保存的都是数据的地址；所有的对象(数据)都是保存在堆区间的。
变量赋值的原理: 先在堆中开辟空间将数据存起来，然后再将地址返回给变量(通用)；
如果数据是数字或者字符串，会先在内存中查看之前是否已经存储过这个输入，
如果存储过直接返回之前的地址，没有存储过才会开辟空间存数据
2）内存的释放(垃圾回收机制)
python中的每一个对象都有一个默认的属性来保存这个对象的引用计数。
(看这个对象的地址被多个变量或者数据存储；如果一个变量存了一个对象的地址，我们就说这个变量是这个对象的引用)
一个对象是否销毁就看这个对象的引用计数是否为0，只要为0就会被销毁
- getrefcount(对象) -> 获取对象的引用计数
"""
from sys import getrefcount
def main():
# 1.变量赋值原理
list1 = {'a': 10}
list2 = {'a': 10}
print(id(list1), id(list2))
num1 = 'abc'
num2 = 'abc'
print(id(num1), id(num2))
# 2.引用计数
list3 = [1, 2, 3]
list4 = list3
print(getrefcount(list3), getrefcount(list4))
list4 = 10
print(getrefcount(list3))
list3 = 100
print(getrefcount(list3))
# def yt_getcount(obj):
# # obj = list3
# return 获取obj的引用计数
if __name__ == '__main__':
main()
