九,Python面向对象 {面向对象的概述与底层,类,对象,属性,方法.静态方法,魔法方法等}

凡梦_leo

于 2024-09-13 20:11:09 发布

阅读量775

点赞数 13

分类专栏： python 文章标签： python 开发语言面向对象大数据前端后端单片机

本文链接：https://blog.csdn.net/qq_55006020/article/details/142212627

版权

python 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

学习：知识的初次邂逅
复习：知识的温故知新
练习：知识的实践应用

十八,__del__析构函数与垃圾回收机制

一,本章简介

python面向对象

面向过程
面向对象
类
属性
方法
实例
静态方法
动态方法
魔法方法一

回顾前面的知识

pyhthon学习路线:

前置:
pyhton的概述
pyhton环境安装;
基础:
注释
标识符
关键字
变量
数据类型
输入
输出
运算符
控制语句
选择分支
循环结构
序列(容器)
字符串
列表
元组
字典
集合
函数
函数的定义与调用
函数的底层
参数的传递
参数的类型
匿名函数lambda
递归函数
嵌套函数
全局变量与局部变量
LEGB规则
面向对象

前面的知识详情见我前面的博客 python专栏:

https://blog.csdn.net/qq_55006020/category_12365311.html?spm=1001.2014.3001.5482

二,面向对象简介

Python完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。
Python中，一切皆对象。我们在前面学习的数据类型、函数等，都是对象

面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型软件设计而来的。
面向对象编程使程序的扩展性更强、可读性更好，使编程可以像搭积木一样简单。
面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。

❤️ Python 支持面向过程、面向对象、函数式编程等多种编程范式。

三,面向过程和面向对象思想

1,面向过程和面向对象的区别:

面向过程和面向对象的区别

面向过程和面向对象都是对软件分析、设计和开发的一种思想 , 它指导着人们以不同的方式去分析、设计和开发软件。C 语言是一种典型的面向过程语言，Java 是一种典型的面向对象语言

2,面向过程是什么？

面向过程适合简单、不需要协作的事务，重点关注如何执行。面向过程时，我们首先思考“ 怎么按步骤实现？ ” 。

先做这个-----在做这个-----最后做这个-----最终得到结果

比如:把大象放进冰箱需要几步?

打开冰箱-------放进大象-----关闭冰箱

比如:把长颈鹿放进冰箱需要几步?

打开冰箱-----取出大象-----放进长颈鹿-----关闭冰箱

3,面向对象是什么？

面向对象 (Oriented-Object) 思想更契合人的思维模式。我们首先思考的是" 怎么设计这个事物？ ” 。比如思考造车，我们就会先思考 “ 车怎么设计？” ，而不是 “ 怎么按步骤造车的问题 ” 。这就是思维方式的转变

底盘+轮胎+发动机+内饰==组成一台汽车

面向对象可以帮助我们从宏观上把握、从整体上分析整个系统。但是，具体到实现部分的微观操作（就是一个个方法），仍然需要面向过程的思路去处理

总结:

我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程！

4,面向对象和面向过程总结

都是解决问题的思维方式，都是代码组织的方式。
面向过程是一种“执行者思维"，解决简单问题可以使用面向过程
面向对象是一种“设计者思维”，解决复杂、需要协作的问题可以使用面向对象

面向对象离不开面向过程：

宏观上：通过面向对象进行整体设计
微观上：执行和处理数据，仍然是面向过程

四,对象的进化

随着编程面临的问题越来越复杂，编程语言本身也在进化，从主要处理简单数据开始，随着数据变多进化“ 数组 ” ；数据类型变复杂，进化出了“ 结构体 ” ；处理数据的方式和逻辑变复杂，进化出了 “ 对象” 。

简单数据像30,40 ， 50.4 等这些数字，可以看做是简单数据。最初的计算机编程，都是像这样的数字。

C 语言中的数组将同类型的数据放到一起。比如：整数数组 [20,30,40] ，浮点数数

组 [10.2, 11.3, 12.4] ，字符串数组： [“aa”,”bb”,”cc”]。

C 语言中的结构体将不同类型的数据放到一起，是C 语言中的数据结构。

对象将不同类型的数据、方法（即函数）放到一起，就是对象

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)

五,类的定义

说白了类其实就是图纸

类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。我们要造一个汽车，怎么样造？类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。

类：我们叫做 class 。对象：我们叫做 object , instance ( 实例 ) 。以后我们说某个类的对象，某个类的实例。是一样的意思。

六,属性和方法

我们通过类定义数据类型的属性（数据）和方法（行为） , 也就是说，“ 类将行为和状态打包在一起 ” 。

对象是类的具体实体，一般称为 “ 类的实例 ” 。类看做 “ 饼干模具 ” ，对象就是根据这个“ 模具 ” 制造出的 “ 饼干 ” 。

从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属性值（不共享状态）。更具体一点：“ 方法代码是共享的，属性数据不共享 ” 。

Python 中， “ 一切皆对象 ” 。类也称为 “ 类对象 ” ，类的实例也称为“ 实例对象 ” 。

七,面向对象快速入门

定义类的语法格式如下：

 class  类名：
     类体

要点如下：

1 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。

2 类体中我们可以定义属性和方法

3 属性用来描述数据，方法(即函数)用来描述这些数据相关的操作

class 类名:
	def 方法名():
		属性1 = 值1
		属性2 = 值2
		...
	
	def 方法名2():
		执行代码1
		执行代码2
		...

一个标准的学生类,涵盖实例属性,实例方法,实例对象

class Student:
  def __init__(self,name,score): #构造方法第一个参数必须为self
    self.name = name     #实例属性
    self.score = score

  def say_score(self):      #实例方法
    print(f'姓名是:{self.name},分数为:{self.score}')

s1 = Student('张三',80) #s1是实例对象，自动调用__init__()方法
s1.say_score()  #姓名是:张三,分数为:80

pass 为空语句。就是表示什么都不做，只是作为一个占位符存在。当你写代码时，遇到暂时不知道往方法或者类中加入什么时，可以先用pass 占位，后期再补上。

八,对象完整内存结构

类是抽象的，也称之为“对象的模板”。我们需要通过类这个模板，创建类的实例对象，然后才能使用类定义的功能。

我们前面说过一个 Python 对象包含三个部分： id （ identity 识别码）、 type （对象类型）、 value （对象的值）。

九,init初始化方法

初始化对象，我们需要定义构造函数 __init__() 方法。构造方法用于执行“ 实例对象的初始化工作 ” ，即对象创建后，初始化当前对象的相关属性，无返会值

__init__() 的要点如下：

名称固定，必须为： __init__()

第一个参数固定，必须为： self 。 self 指的就是刚刚创建好的实例对象

构造函数通常用来初始化实例对象的实例属性，如下代码就是初始化实例属性： name 和 score

通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量。比如： s1 = Student('张三', 80)

__init__() 方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”

如果我们不定义 __init__ 方法，系统会提供一个默认的 __init__ 方法。如果我们定义了带参的 __init__ 方法，系统不创建默认的 __init__ 方法

❤️ Python 中的 self 相当于 C++ 中的 self指针， JAVA或者javasript 和 C# 中的 this 关键字。Python 中， self 必须为构造函数的第一个参数，名字可以任意修改。但一般惯例，都叫做 self

比如修改self 改:

class Student:
  def __init__(徐萍,name,score): #构造方法第一个参数必须为self
    徐萍.name = name     #实例属性
    徐萍.score = score

  def say_score(徐萍):      #实例方法
    print(f'姓名是:{徐萍.name},分数为:{徐萍.score}')

s1 = Student('张三',80) #s1是实例对象，自动调用__init__()方法
s1.say_score()  #姓名是:张三,分数为:80

十,new创建对象方法

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

十一,实例属性

实例属性是从属于实例对象的属性，也称为 “ 实例变量 ” 。他的使用

有如下几个要点：

实例属性一般在 __init__() 方法中通过如下代码定义： self.实例属性名 = 初始值

在本类的其他实例方法中，也是通过 self 进行访问： self.实例属性名

创建实例对象后，通过实例对象访问： obj01 = 类名() # 创建和初始化对象，调用 __init__() 初始化属性 obj01.实例属性名 = 值 # 可以给已有属性赋值，也可以新加属性

class Student:
  def __init__(self,name,score): #构造方法第一个参数必须为self
    self.name = name     #实例属性
    self.score = score

  def say_score(self):      #实例方法
    print(f'姓名是:{self.name},分数为:{self.score}')

s1 = Student('张三',80) #s1是实例对象，自动调用__init__()方法
s1.say_score()  #姓名是:张三,分数为:80
s1.sex='男'
print(s1.sex) #男

十二,实例方法

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

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

函数体

方法的调用格式如下：对象.方法名([实参列表])

定义实例方法时，第一个参数必须为 self 。和前面一样， self 指当前的实例对象。

调用实例方法时，不需要也不能给 self 传参。 self 由解释器自动传参

函数和方法的区别

1 都是用来完成一个功能的语句块，本质一样。

2 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点

3 直观上看，方法定义时需要传递self，函数不需要

dir(obj) 可以获得对象的所有属性、方法

obj.__dict__ 对象的属性字典

pass 空语句

isinstance（对象,类型）判断 “ 对象 ” 是不是 “ 指定类型 ”

十三,类对象

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

class Student:
    pass

print(type(Student))  #<class 'type'>
print(id(Student))  #1512828622464

s1=Student
s2=Student()   #<__main__.Student object at 0x000001800F0ABF40>
print(s1,s2) #<class '__main__.Student'>

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


class Student:
    pass

print(type(Student))  #<class 'type'>
print(id(Student))  #1765368767936
print(id(Student()))  #1698718466000

s1=Student
s2=Student()   #<__main__.Student object at 0x000001800F0ABF40>
print(s1,s2) #<class '__main__.Student'>

print(id(s1))  #1765368767936
print(id(s2)) #1698718466000
s3=Student()
print(id(s3))  #2142607884048  创建的第二个类对象  地址发生改变

十四,类属性

类属性是从属于 “ 类对象 ” 的属性，也称为 “ 类变量 ” 。由于，类属性从属于类对象，可以被所有实例对象共享。

class S:
    a=0
    def __init__(self,b):
        self.b=2
    def see(self):
        S.a=2
        self.b=1
        print(S.a,self.b)

print(S)  #类
print(S(1)) #类的实例 类对象
print(S.a) #类属性
print(S(2).see()) #实例方法
s1=S(2)
print(s1.b) #实例属性

类属性的定义方式：

class 类名：

类变量名 = 初始值

在类中或者类的外面，我们可以通过：类名.类变量名来读写

十五,内存分析实例对象和类对象创建过程

class S2:
    company='凡梦1'
    count=0
    def __init__(self,name,score):
        self.name=name
        self.score=score
        S2.count =S2.count+1
    def say(self):
        print(f'我的名称是{self.name}')
        print(f'我的分数是{self.score}')
        
s1=S2('徐萍',90)
s2=S2('凡梦',89)
s1.say()  #我的名称是徐萍 我的分数是90
print(S2.count)  #2 创建了2个实例

十六,类方法

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

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

要点如下：

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

类方法使用测试

class Stu(object):
    cp='xxx'
    @classmethod
    def printcp(cls):
        print(cls.cp)

Stu.printcp()  #xxx

十七,静态方法

Python 中允许定义与 “ 类对象 ” 无关的方法，称为 “ 静态方法 ” 。

“ 静态方法 ” 和在模块中定义普通函数没有区别，只不过 “ 静态方法 ” 放到了“ 类的名字空间里面 ” ，需要通过 “ 类调用 ” 。

类的静态方法,其实通俗来说:在你名下,但是与你无关

静态方法通过装饰器 @staticmethod 来定义，格式如下：

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

要点如下：

@staticmethod 必须位于方法上面一行

调用静态方法格式：类名.静态方法名(参数列表)

静态方法中访问实例属性和实例方法会导致错误

#静态方法
class Stu(object):
    cp='xxxx'
    def my_add(a,b):
        return a+b
    @staticmethod
    def my_jian(a,b):
        return a-b
print(Stu.my_add(1,2))  # 静态方法直接调用
print(Stu.my_jian(2,1))  #1  #添加静态方法的装饰器用法

十八,del析构函数与垃圾回收机制

__del__ ()称为析构方法.用于实现对象被销毁时所需的操作;比如释放对象占用的资源;例如打开的文件资源,网络连接等;

python 实现自动的垃圾回收,当对象没有被引用的时候(引用计时为0),由垃圾回收器调用__del__()

我们也可以通过del语句删除对象,从而保证调用__del__()

系统会自动调用__del__(),一般不需要自定义析构方法

# 1.定义类
class Car:
    def __init__(self,brand):
        self.brand = brand

    def __del__(self):
        print("=========__del__===========")

# 2.创建对象
car = Car("BMW")
# 删除 -内存
# del car   # 注释
print(car.brand)
# 3.查看del
# 注意: 为了能更方便的查看del效果, 建议使用 del xx语法

==总结：==

（1）当使用【del 对象名】时，自动调用了__del__()方法；

（2）注意：当程序执行结束时，Python垃圾回收器会自动销毁内存垃圾，此时会自动调用__del__()方法。

十九,call 方法和可调用对象

Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。

可调用对象包括自定义的函数、 Python 内置函数、以及本节所讲的实例对象。

定义了 __call__() 的对象，称为 “ 可调用对象 ” ，即该对象可以像函数一样被调用。

该方法使得实例对象可以像调用普通函数那样，以 “ 对象名 ()” 的形式使用。

def f1():
    print('heihei')
f1() #本质也是调用了 __call__()方法

class Car:
    def __call__(self, *args, **kwargs):
        print('__call__()方法')
        print(f'{args}')
c=Car()  #
c(2) #__call__()方法  (2,)

二十,方法没有重载

如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。

建议：不要使用重名的方法！ Python 中方法没有重载。

在其他一些语言 ( 比如： Java) 中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含3 个部分：方法名、参数数量、参数类型。

Python 中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可

变参数控制。因此， Python 中是没有方法的重载的。

def f1():
    print(111)
def f1():
    print(222)

f1() #222

class C1:
    def f1(self):
        print(111)
    def f1(self):
        print(222)
C1().f1() #222

二十一,方法的动态性

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

class Person:
    def work(self):
        print('好好上班')
def work2():
    print('好好学习,认真工作')
def game():
    print('玩游戏')

Person.game=game
Person.work=work2

Person.work()  #好好学习,认真工作
Person.game()  #玩游戏

我们可以看到， Person 动态的新增了 play_game 方法，以及用 work2 替换了 work 方法

二十二,私有属性和私有方法

Python 对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。关于私有属性和私有方法，有如下要点：

1 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。

2 类内部可以访问私有属性(方法)

3 类外部不能直接访问私有属性(方法)

4 类外部可以通过 _类名__私有属性(方法)名 ”访问私有属性(方法)

私有属性

class S:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self,name):
        self.__name = name
    def set_age(self,age):
        self.__age = age


s1=S('凡梦',18)
# print(s1.name) #报错 不允许访问  这是一个私有属性
print(s1.get_name()) #凡梦 通过这个方式可以访问
print(s1._S__name)  #凡梦
print(s1._S__age)  #18 通过这种方式也可以获取私有属性

从打印的 S 对象所有属性我们可以看出。私有属性 __age 在实际存储时是按照 _S__age 这个属性来存储的。这也就是为什么我们不能直接使用 __age 而可以使用 _S__age 的根本原因。

二十三,@property 装饰器

@property 可以将一个方法的调用方式变成 “ 属性调用 ” 。

@property 主要用于帮助我们处理属性的读操作、写操作。对于某一个属性，我们可以直接通过： emp1.salary = 30000

如上的操作读操作、写操作。但是，这种做法不安全。比如，我需要限制薪水必须为 1 - 10000 的数字。这时候，我们就需要通过使用装饰器 @property 来处理。

class Emoyoole():
    def __init__(self,name,salay):
        self.name = name
        self.__salay = salay
    #
    @property  #把一个方法当做一个属性来用
    def salay(self):
        return self.__salay

    def get_salay(self,sal):
        if sal <=50000:
             self.__salay=sal
             return  self.__salay
        else:
            print('薪资过高')

emp1 = Emoyoole('凡梦','100000')
# print(emp1.salay())  #'100000'
# emp1.salay=20000
print(emp1.get_salay(80000))

二十四,属性和方法命名总结

xxx ：保护成员，不能用 from module import * 导入，只有类对象和子类对象能访问这些成员。

__xxx__ ：系统定义的特殊成员

__xxx ：类中的私有成员，只有类对象自己能访问，子类对象也不能访问。（但，在类外部可以通过对象名. _类名__xxx 这种特殊方式访问。 Python 不存在严格意义的私有成员）

二十五,类编码风格

1 类名首字母大写，多个单词之间采用驼峰原则。

2 实例名、模块名采用小写，多个单词之间采用下划线隔开

3 每个类，应紧跟“文档字符串”，说明这个类的作用可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类

二十六,关于None和判断的总结

1,None是什么？

None是什么？

1 与C和JAVA不同，python中是没有 NULL 的，取而代之的是 None 。

2 None 是一个特殊的常量，表示变量没有指向任何对象。

3 在Python中， None 本身实际上也是对象，有自己的类型 NoneType 。

4 你可以将 None 赋值给任何变量，但我们不能创建 NoneType 类型的对象

obj = None
obj2 = None
print(type(None))
print(id(None))
print(id(obj))
print(id(obj2))

⚠️ None 不是 False ， None 不是 0 ， None 不是空字符串。 None和任何其他的数据类型比较永远返回False 。

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")       #不会被打印

学习：知识的初次邂逅
复习：知识的温故知新
练习：知识的实践应用

凡梦_leo

关注

13
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录