文章目录
类的定义_类和对象的关系
类的定义
对象：一个饼干
类：制造这个饼干的模具
通过类定义数据类型的属性（数据）和方法（行为）
类也是对象
类将行为和状态打包在一起
操作：
# 创造一个类
class Student: # 类名称一般是首字母大写，多个单词用驼峰原则
def __init__(self,name,score): # self:当前对象本身,必须位于第一个参数
self.name = name
self.score = score
def say_score(self): # self必须位于第一个参数
print("{0}的分数是{1}".format(self.name,self.score))
s1 = Student("gaoqi", 18)
s1.say_score()
我的小结：
class 类名称(大写首字母或驼峰):
def __init__(self, 参数1, 参数2...):
...
构造函数__init__()
对象包含的部分
- id
- type
- value
- attribute属性，init中的参数
- method 方法
init要点
第一个参数必须为self，就是指的是被构造出来的这个对象，self可以自行改成其他的aa、s
__init__()：初始化对象，就是给实例属性赋值
__new__()：创建对象，但通常不需要定义该方法
实例属性
实例属性：从属于实例对象的属性，也成为实例变量
- 使用要点：
- 一般在init方法中通过如下代码定义：
self.实例属性名 = 初始值
- 在本类中的其他实例方法中，访问：
self.实例名称
- 创建实例对象后，通过实例对象访问：
- ·
object01 = 类名()# 创建对象，调用init初始化属性 object01.实例属性名 = 值# 可以给已有属性赋值、可以添加新属性
- ·
- 一般在init方法中通过如下代码定义：
构造实例的分步骤：
class 类名称:，构造了一个类对象，内存里出现了一个“模具”对象- new方法，创建一个类对象
def __init__(self, 形参1, 形参2...):init初始化方法，把属性和方法（方法也是属性）给类对象
s1=Student(实参1,实参2...)s1.salary = 3000，对象新加的属性是从属于对象的，不影响“模具”，用模具新构造的别的对象也不会有这些属性
实例方法_内存分析方法调用过程_dir()isinstance
实例方法
实例方法是从属于实例对象的方法
定义格式：
def 方法名(self[,形参列表]):
方法语句
区别实例方法和函数：
本质一样，都是用来完成一个功能的语句块
格式很相似
方法调用，通过对象来调用s1.say_score()，从属于特定实例对象
方法定义，需要self，函数不用
要点：
定义实例方法时，第一个参数必须为self，指的就是当前的实例对象
调用实例方法的时候，不需要也不能给self传参，有解释器自动传参，self就是当前对象
实例对象的方法调用的本质
# a 通过Student类创建出来的对象a
# say_score()，Student类的方法
a.say_score() # 打字打进来的代码
Student.say_score(a) # 解释器的翻译
# 上面两行是一样的意思，解释器的思路：找到Student类，找到方法，把类
![[Pasted image 20221116110445.png]]
其它操作
dir(obj)：获得对象的所有属性、方法
obj.__dict__，对象的属性字典
pass，空语句
class Man:
pass
isinstance(对象,类型)，判断对象是不是指定类型
类对象
实例对象：通过类对象创造出来的饼干
类对象：模具本身
当解释器执行 class语句的时候，就会创建一个类对象
操作：
class Student:
pass # 空语句
print(type(Student))
print(id(Student))
Stu2 = Student # 把类对象Student的地址给了Stu2，不是创造了实例对象，圆括号才是调用
s1 = Stu2() # 通过Student创造了一个实例对象s1
print(s1)
type 本身就是一个类，模具类
type(Student)：
用type这个模具，创造一个Student类对象，根据Student模具，创建一个学生
类属性_内存分析创建类和对象的底层
类属性
类属性是从属于“类对象”的属性，也称为“类对象”，区别于实例属性，实例属性是从属于实例对象的
可以被所有实例对象共享
定义方式：
class className:
class_attr = default_value
操作：
class Student:
company = "SXT" # 类属性
count = 0 # 类属性
def __init__(self, name, score):
self.name = name
self.score = score
Student.count = Student.count + 1
def say_score(self):
print("我的公司是：",Student.company)
print(self.name,'的分数是：',self.score)
s1 = Student('gaoqi',80)
s1.say_score()
print('一共创建{0}个Student对象'.format(Student.count))
我的小结：实例的方法实际上是顺着“脐带”找回类的方法，并没有创建一个新函数
我的小结：❓为什么Student.count可以起到计数的作用？因为是类方法？什么时候清空呢？
类方法_静态方法_内存分析图示
类方法
从属于类对象的方法，
类方法通过装饰器@classmethod来定义
类方法是用来操作类对象的
定义格式：
@classmethod
def 类方法名(cls [,形参列表]): # 必须写cls，特指类对象
函数体
要点：
@classmethod必须位于方法上面一行- 第一个
cls必须有，指的就是“类对象”本身 - 调用类方法的格式：
类名.类方法名(参数列表)，参数列表中，不需要也不能给cls传值
静态方法
与“类对象”无关的方法，称为“静态方法”
与模块中定义的普通函数美欧去吧，但是放到了类的名字空间里面，需要通过类调用
格式：
@staticmethod
def 静态方法名(形参列表):
函数体
注意：静态方法和类方法都不可以访问实例对象或实例方法print(self.company)不行，print(cls.company)才可以。
我的小结：静态方法和类方法可以通过实例对象来调用（只是不能访问），因为解释器会把s1.say_score()翻译成Student.say_score(s1)，也就是会回到类对象中去找方法
__del__()析构方法和垃圾回收机制
__del__()方法称为析构方法
用于：实现对象被销毁时所需要的操作，比如：释放对象占用的资源，
举例：打开的文件资源、网络连接等
Python实现自动的垃圾回收，当对象没有被引用的时候（引用数为0），由垃圾回收期调用__del__()方法
可以通过del语句删除对象，保证调用__del__()方法
系统会自动提供该方法，一般不用自定义析构方法
# 析构方法
class Person:
def __del__(self):
print('销毁对象{0}'.format(self))
p1 = Person()
p2 = Person()
del p2
print('程序结束')
结果：
销毁对象<__main__.Person object at 0x00000206ABB76710> # del p2 销毁了p2
程序结束
销毁对象<__main__.Person object at 0x00000206ABB50ED0> # 销毁了p1
❓为什么 del p2 在销毁p2 的时候也会打印出“销毁对象”？是因为我们重新写了del方法，使del这个方法有了打印“销毁对象”的功能
❓为什么在程序结束之后还会销毁p1？是因为程序结束之后p1没有引用了吗？
__call__()方法和可调用对象
定义了call方法的对象，称为可调用对象，即该对象可以像函数一样被调用
函数也是对象
a = 30
b = 50
c = a+b
d = a.__add__(b)
aa()
obj() → __call__()
我的小结：__call__()就是()圆括号的作用
# 测试可调用方法__call__()
class SalaryAccount:
def __call__(self, salary):
print("算工资啦...")
yearSalary = salary*12
daySalary = salary//22.5 # 国家规定每个月的平均工作天数
hourSalary = daySalary//8
return dict(yearSalary=yearSalary, monthsalary=salary, daySalary=daySalary, hourSalary=hourSalary)
s = SalaryAccount() # 构造实例对象
# s = SalaryAccount(3000)
# 上面这行这样会报错
print(s(3000)) # 调用有call的实例对象
我的小结：可调用对象区别于其它对象的方法调用s1.say_score()，s(3000)是没有通过实例对象去引用方法
☑️❓s=SalaryAccount(3000)这样不行，是因为没有init方法去构造实例对象吗？是，下面这样改就可以了
# 测试可调用方法__call__()
class SalaryAccount:
def __init__(self, salary):
self.salary = salary
def __call__(self,b):
print("算工资啦...")
yearSalary = self.salary*12
daySalary = self.salary//22.5 # 国家规定每个月的平均工作天数
hourSalary = daySalary//8
return dict(yearSalary=yearSalary, monthsalary=self.salary, daySalary=daySalary, hourSalary=hourSalary,b=b)
s = SalaryAccount(3000)
print(s(2000))
结果：
算工资啦...
{'yearSalary': 36000, 'monthsalary': 3000, 'daySalary': 133.0, 'hourSalary': 16.0, 'b': 2000}
❓可调用对象有什么用啊？
我的小结：可调用对象的传参可以从实例对象那里传入，直接就是调用定义的call方法
❓一个实例对象是否可以有多个可调用方法呢？
扫一扫
22万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
