Python类和对象

努力码代码的小赵

已于 2024-04-16 14:19:57 修改

阅读量736

点赞数 26

文章标签： python java 服务器

于 2024-04-15 18:11:49 首次发布

本文链接：https://blog.csdn.net/m0_46811353/article/details/137786726

版权

对象完整内存结构
在这里插入图片描述

1. init()构造方法

构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值
init() 的规范：
1.名称固定，必须为： init()
2.第一个参数固定，必须为： self 。 self 指的就是刚刚创建好的实例对象
3.构造函数通常用来初始化实例对象的实例属性，如下代码就是初始化实例属性： name 和 score
4.通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。比如： s1 = Student(‘张三’, 80)
5.init() 方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
6.如果我们不定义 init 方法，系统会提供一个默认的 init 方法。如果我们定义了带参的 init 方法，系统不创建默认的 init 方法

2.new()方法

new() 方法: 用于创建对象，但我们一般无需重定义该方法

3.实例属性和实例方法

3.1实例属性

实例属性是从属于实例对象的属性，也称为“实例变量”。他的使用有如下要点：
1.实例属性一般在 init() 方法中通过如下代码定义：self.实例属性名 = 初始值
2.在本类的其他实例方法中，也是通过 self 进行访问：self.实例属性名
3.创建实例对象后，通过实例对象访问：
obj01 = 类名() #创建和初始化对象，调用 init() 初始化属性
obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

3.2实例方法

实例方法是从属于实例对象的方法。实例方法的定义格式如下：

def  方法名(self [, 形参列表])：
 函数体

方法的调用格式：对象.方法名([实参列表])
要点：
1.定义实例方法时，第一个参数必须为 self 。和前面一样， self 指当前的实例对象。
2.调用实例方法时，不需要也不能给 self 传参。 self 由解释器自动传参
实例对象的方法调用本质：
在这里插入图片描述
其他操作：
dir(obj)：可以获得对象的所有属性、方法

a=Student()
print(dir(a))

obj.dict ：对象的属性字典

print(a.__dict__)

isinstance（对象,类型） 判断“对象”是不是“指定类型”,是的话返回True，否则返回False

print(a.instance(a,Student))

4.类对象、类属性、类方法、静态方法

4.1类对象

我们在前面讲的类定义格式中， class 类名：。实际上，当解释器执行
class 语句时，就会创建一个类对象

class Student:
    pass    #空语句
print(type(Student))
print(id(Student))
Stu2 = Student
s1 = Stu2()
print(s1)
#执行结果：
#<class 'type'>
#51686328
#<__main__.Student object at
#0x0000000002B5FDD8>

我们可以看到实际上生成了一个变量名就是类名 Student 的对象。我
们通过赋值给新变量 Stu2 ，也能实现相关的调用。说明，确实创建
了“类对象”。

4.2类属性

类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从
属于类对象，可以被所有实例对象共享。
在类中或者类的外面，我们可以通过：类名.类变量名来读写
类属性的定义方式：

class  类名：
 类变量名= 初始值

内存分析实例对象和类对象创建过程
以以下代码为例：

class Student:
    company = "尚学堂"  # 类属性
    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('高淇', 80)  # s1是实例对象，自动调用__init__()方法
s2 = Student('张三', 70)
s1.say_score()
print('一共创建{0}个Student对象'.format(Student.count)) 
#执行结果：
class Student:
    company = "尚学堂"  # 类属性
    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('高淇', 80)  # s1是实例对象，自动调用__init__()方法
s2 = Student('张三', 70)
s1.say_score()
print('一共创建{0}个Student对象'.format(Student.count)) 
#执行结果：
#我的公司是： 尚学堂
#高淇 的分数是： 80
#一共创建2个Student对象

首先class会在堆上创建一个Student类对象，栈上会有一个Student的引用指向Student类型对象，然后s1根据Student类型对象在堆上新建了一个s1的Student对象，栈上会有一个s1的引用指向堆上的s1对象，s2也是如此
在这里插入图片描述

4.3类方法

类方法是从属于“类对象”的方法。类方法通过装饰器 @classmethod 来定
义，格式如下：

@classmethod
def  类方法名(cls [，形参列表]) ：
 方法体

要点：
1.@classmethod 必须位于方法上面一行
2.第一个 cls 必须有； cls 指的就是“类对象”本身
3.调用类方法格式：类名.类方法名(参数列表) 。参数列表中，不需要也不能给 cls 传值
4.类方法中访问实例属性和实例方法会导致错误
5.子类继承父类方法时，传入 cls 是子类对象，而非父类对象

4.4静态方法

Python中允许定义与“类对象”无关的方法，称为“静态方法”。
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”
静态方法通过装饰器@staticmethod来定义，格式如下：

@staticmethod
def  静态方法名([形参列表]) ：
 方法体

要点：
1.@staticmethod 必须位于方法上面一行
2.调用静态方法格式：类名.静态方法名(参数列表)
3.静态方法中访问实例属性和实例方法会导致错误

5.del方法 (析构函数)和垃圾回收机制

1.del() 称为“析构方法”，用于实现对象被销毁时所需的操作。比如：释放对象占用的资源，例如：打开的文件资源、网络连接等。
2.Python实现自动的垃圾回收，当对象没有被引用时（引用计数为0），由垃圾回收器调用 del() 。
3.我们也可以通过 del语句删除对象，从而保证调用 del() 。系统会自动提供 __del__方法，一般不需要自定义析构方法。

#析构函数
class Person:
   def __del__(self):
       print("销毁对象：{0}".format(self))
p1 = Person()
p2 = Person()
del p2
print("程序结束")
#执行结果：首先创建p1、p2对象，然后del p2对象，此时会自动调用析构，所以会有打印：销毁对象：<__main__.Person object at 0x02175610>。然后再执行print("程序结束")，由于p1没有手动del，所以会由垃圾回收器自动调用析构，打印:销毁对象：<__main__.Person object at 0x021755D0>
#销毁对象：<__main__.Person object at 0x02175610>
#程序结束
#销毁对象：<__main__.Person object at 0x021755D0>

6.call 方法和可调用对象

1.Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。
2 可调用对象包括自定义的函数、Python 内置函数、以及本节所讲的可调用对象。
3 定义了 call() 的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
4 该方法使得实例对象可以像调用普通函数那样，以“对象名()”的形式使用。

def f1():
   print("f1")
f1()   #本质也是调用了__call__()方法
class Car:
   def __call__(self, age,money):
       print("__call__方法")
       print("车龄：{0},金额：{1}".format(age,money))
f2 = Car()
f2(3,200000)    #像调用函数那样调用，本质也是调用了__call__()
#执行结果：
#f1
#车龄：3,金额：200000

7.方法的动态性

Python是动态语言，我们可以动态的为类添加新的方法，或者动态
的修改类的已有的方法

#测试方法的动态性
class Person:
    def work(self):
        print("努力上班！")
def play_game(s):
	print("玩游戏")
def work2(s):
    print("好好工作，努力上班！")
Person.play = play_game#给Person新增 play_game 方法
Person.work = work2#将Person的work()用work2()替换
p = Person()
p.play()
p.work()

Person 动态的新增了 play_game 方法，以及用 work2 替换了 work 方法
注意：
play_game()和work2()中都有个参数，因为需要传递self，如果没有这个参数就会报错，接收不了self参数

Python中没有方法重载，定义多个同名方法，只有最后一个有效。
因为在Python中，方法的的参数没有声明类型，参数的数量也可以由可
变参数控制。因此，Python中是没有方法的重载的。

8.私有属性和私有方法

Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别
关于私有属性和私有方法，有如下要点：
1.通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
2.类内部可以访问私有属性(方法)
3.类外部不能直接访问私有属性(方法)
4.类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)
示例：

#测试私有属性、私有方法
class Employee:
    __company = "百战程序员" #私有.通过dir查到_Employee__company
    def __init__(self,name,age):
    	self.name = name
	    self.__age = age#私有实例属性
    def say_company(self):
        print("我的公司是：",Employee.__company)          #类内部可以直接访问私有属性
        print(self.name,"的年龄是：",self.__age)
        self.__work()
    def __work(self): #私有实例方法，通过dir可查到_Employee__work
        print("工作！好好工作，好好赚钱，娶个媳妇！")
p1 = Employee("高淇",32)
print(p1.name)
print(dir(p1))              #
p1.say_company()
print(p1._Employee__age)      #通过这种方式可以直接访问到私有属性 。通过dir可以查到属性：_Employee__age
#print(p1.__age)           #直接访问私有属性，报错
#p1.__sleep()             #直接访问私有方法，报错
#执行结果：
#高淇
#['_Person__age', '_Person__leg_num','_Person__sleep', '__class__', '__delattr__','__dict__', '__dir__', '__doc__', '__eq__','__format__', '__ge__','__getattribute__','__gt__', '__hash__', '__init__','__init_subclass__','__le__', '__lt__','__module__', '__ne__', '__new__','__reduce__', '__reduce_ex__', '__repr__','__setattr__', '__sizeof__', '__str__','__subclasshook__', '__weakref__', 'name','say_age']
#腿的数目： 2
#高淇 的年龄是： 18
#睡觉
#18
#从打印的 Person 对象所有属性我们可以看出。私有属性 __age 在实际存储时是按照 _Person__age 这个属性来存储的。这也就是为什么我们不能直接使用 __age 而可以使用 _Person__age 的根本原因

9.@property 装饰器

作用：@property 可以将一个方法的调用方式变成“属性调用”。@property 主要用于帮助我们处理属性的读操作、写操作

#测试@property
class Employee:
   def __init__(self,name,salary):
       self.name = name
       self.__salary = salary
   @property               #相当于salary属性的getter方法
   def salary(self):
        print("月薪为{0},年薪为{1}".format(self.__salary,(12*self.__salary)))
        return self.__salary;
   
   @salary.setter
   def salary(self,salary):    #相当于salary属性的setter方法
       if(0<salary<1000000):
           self.__salary = salary
       else:
           print("薪水录入错误！只能在0-1000000之间")
emp1 = Employee("高淇",100)
print(emp1.salary)
emp1.salary = -200#由于salary()使用了@property修饰，所以可以直接像属性一样调用，不需要加()

10.关于None

10.1 None是什么

1.与C和JAVA不同，python中是没有 NULL 的，取而代之的是 None 。
2.None 是一个特殊的常量，表示变量没有指向任何对象。
3.在Python中， None 本身实际上也是对象，有自己的类型 NoneType 。
4.你可以将 None 赋值给任何变量，但我们不能创建 NoneType 类型的对象
5.None不是False，None不是0，None不是空字符串。None和任何其他的数据类型比较永远返回False。

10.2 None和其他类型的比较：

None和其他任何类型比较都会返回False：

a = None
if a is None and a==None:
    print("a是None")             #会执行
if a==False or a==0:
    print("None不等于False")       #不会被打印

空列表、空字符串、0之间的比较：
1、if语句判断时,空列表[]、空字典{}、空元组()、0等一系列代表空和无的对象会被转换成False

a=[];b=();c={};d="";e=0;f=None
if (not a) and (not b) and (not c) and
(not d) and (not e) and (not f):
    print("if判断时，空列表[]、空字符串、0、None等代表空和无的对象会被转换成False")

2、== 和 is 判断时，空列表、空字符串不会自动转成 False

a=[];b=();c={};d="";e=0;
if (a==False or d==False):
    print("==时，空列表、空字符串不是False！")   #不会执行
if(e==False):
    print("==时，0会转成False")

努力码代码的小赵

关注

26
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
1
评论
Python类和对象

首先class会在堆上创建一个Student类对象，栈上会有一个Student的引用指向Student类型对象，然后s1根据Student类型对象在堆上新建了一个s1的Student对象，栈上会有一个s1的引用指向堆上的s1对象，s2也是如此。() 称为“析构方法”，用于实现对象被销毁时所需的操作。“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”构造方法用于执行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
复制链接

扫一扫