Python----Python高级（面向对象：对象，类，属性，方法）

一、面向对象简介

Python完全采用了面向对象的思想，是真正面向对象的编程语言，完全支持面向对象的基本功能，例如：继承、多态、封装等。

Python中，一切皆对象。python数据类型、函数等，都是对象。

面向对象（Object oriented Programming，OOP）编程的思想主要是针对大型软件设计而来的。

面向对象编程使程序的扩展性更强、可读性更好，使编程可以像搭积木一样简单。

面向对象编程将数据和操作数据相关的方法封装到对象中，组织代码和数据的方式更加接近人的思维，从而大大提高了编程的效率。

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

二、面向过程和面向对象思想

面向对象和面向过程是相辅相成的

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

        面向过程和面向对象都是对软件分析、设计和开发的一种思想

        它指导着人们以不同的方式去分析、设计和开发软件

        C语言是一种典型的面向过程语言，Java是一种典型的面向对象语言

面向对象和面向过程总结：

        都是解决问题的思维方式，都是代码组织的方式。

        面向过程是一种“执行者思维"，解决简单问题可以使用面向过程

        面向对象是一种“设计者思维”，解决复杂、需要协作的问题可以使用面向对象

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

        宏观上：通过面向对象进行整体设计

        微观上：执行和处理数据，仍然是面向过程

2.1、面向过程思想

面向过程适合简单、不需要协作的事务，重点关注如何执行

案列1 ：

开车

案列2：

把大象装冰箱

面向过程编程是一种以过程为中心的编程规范,程序需要经过一系列的过程来解决问题。

这种方式强调的的是算法与数据分离，所有的操作都是通过函数,或者过程来完成的。

2.2、面向对象思想

面向对象(Oriented-Object)思想更契合人的思维模式。

案列1：

汽车的组成

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

三、面向对象的发展

面向对象编程（OOP）是一种编程范式，强调通过“对象”来组织软件设计。它的发展历程可以追溯到20世纪60年代，随着计算机科学的进步而逐渐演变

1. 早期概念（1960年代）

Simula（1962）：被广泛认为是第一个面向对象的编程语言，由挪威计算机科学家Ole-Johan Dahl和Kristen Nygaard开发。Simula引入了类和对象的概念，主要用于模拟和工程应用。

2. Smalltalk（1970年代）

Smalltalk（1972）：由艾伦·凯（Alan Kay）及其团队开发，Smalltalk是第一个完整的面向对象语言，推广了许多OOP理念，如消息传递、动态类型和图形用户界面（GUI）。

3. 语言的演变（1980年代）

C++（1983）：由Bjarne Stroustrup开发，C++在C语言的基础上添加了面向对象的特性，使之能够进行更复杂的软件工程。C++使得OOP在业界的应用得到了广泛推广。
Objective-C（1980年代）：结合了C语言与Smalltalk的OOP特性，成为Apple开发macOS和iOS应用的主要语言。

4. OOP的广泛应用（1990年代）

Java（1995）：由Sun Microsystems推出的Java语言进一步推广了面向对象的思想，特别是在互联网时代。Java的平台无关特性和强大的标准库使其迅速普及。
Python（1991）：虽然Python是一种多范式语言，但其内置的OOP支持使得面向对象的编程成为Python的重要特性之一。

5. 当代OOP（21世纪）

设计模式的普及：在软件工程领域，设计模式成为解决常见问题的标准方法，进一步增强了面向对象方法的应用。
新的编程范式：随着编程语言的发展，现在许多语言实现了多范式支持，如函数式编程和面向对象编程的结合（例如Scala和JavaScript）。

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

1.简单数据

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

2.C语言中的数组

将同类型的数据放到一起。比如：整数数组[20,30,40]，浮点数数组[10.2, 11.3, 12.4]，字符串数组：[“aa”,”bb”,”cc”]

⚠️上面的[20,30,40]不是python中的列表，是C语言中的数组

3.C语言中的结构体

将不同类型的数据放到一起，是C语言中的数据结构
struct stuct{int age;char name[10];double salary;}

4.对象

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

python">class Student:company ="XXXXX"#类属性count =0#类属性def init (self,name,score):self.name =name#实例属性self.score = scoreStudent.count =Student.count+1def say_score(self):#实例方法print("我的学校是:",Student.company)print(self.name,'的分数是:',self.score)

四、类

类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象。

造一个汽车，类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。

概念:

具有相同运动状态以及属性的一类物体的统称. 类一般是比较抽象的.不可以直接使用。

属性和方法

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

定义类的语法格式：

class 类名：
类体

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

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

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

对象完整内存结构

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

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

五、实例属性和实列方法

5.1、实例属性

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

实例属性一般在__init__()方法中通过如下代码定义：

self.实例属性名 = 初始值

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

创建实例对象后，通过实例对象访问：

obj01 = 类名() #创建和初始化对象，调用__init__()初始化属性

obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性

python">class Dog:  def __init__(self, name):  self.name = name  # 实例属性  dog = Dog("Buddy")  
print(dog.name)  # 输出: Buddy

5.2、实列方法

实例方法是从属于实例对象的方法。

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

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

python">class Dog:  def bark(self):  return "Woof!"  dog = Dog()  
print(dog.bark())  # 输出: Woof!

函数和方法的区别

都是用来完成一个功能的语句块，本质一样。
方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点
直观上看，方法定义时需要传递self，函数不需要

实例对象的方法调用本质

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

obj.__dict__ 对象的属性字典

pass 空语句

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

六、类对象、类属性、类方法、静态方法

6.1、类对象

当解释器执行class语句时，就会创建一个类对象

通过类定义的对象，可以直接调用类的属性和方法。

python">class Student:pass  #空语句
print(type(Student))#<class 'type'>
print(id(Student))#1504815125008
Stu2 = Student
s1 = Stu2()
print(s1)#<__main__.Student object at 0x0000015E5EE32F90>

6.2、类属性

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

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

python">class Student:school= "高等学府" # 类属性count = 0 # 类属性def __init__(self, name, score):self.name = name # 实例属性self.score = scoreStudent.count = Student.count + 1def say_score(self): # 实例方法print("我的学校是：", Student.school)#我的学校是： 高等学府print(self.name, '的分数是：', self.score)#张三 的分数是： 80s1 = Student('张三', 80) # s1是实例对象，自动调用__init__()方法
s2 = Student('李四', 70)
s1.say_score()
print('一共创建{0}个Student对象'.format(Student.count))#一共创建2个Student对象

6.3、类方法

通过 @classmethod 装饰器定义，接受类作为第一个参数（通常是 cls）

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

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

第一个cls必须有；cls指的就是“类对象”本身

调用类方法格式：类名.类方法名(参数列表)。参数列表中，不需要也不能给cls传值

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

子类继承父类方法时，传入cls是子类对象，而非父类对象(⚠讲完继承再说)

python">class Student:school='高等学府'  #类属性@classmethoddef printschool(cls):print(cls.school)Student.printschool()

6.4、静态方法

Python中允许定义与“类对象”无关的方法

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

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

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

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

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

python">class Student:school='高等学府'  #类属性@staticmethoddef add(a, b): # 静态方法print("{0}+{1}={2}".format(a,b,(a+b)))return a+bStudent.add(20,30)

七、私有属性和私有方法

Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。

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

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

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

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

7.1、私有属性

以两个下划线开头的属性，不能被外部直接访问。

python">class Person:  def __init__(self, name):  self.__name = name  # 私有属性  def get_name(self):  return self.__name  p = Person("Eve")  
print(p.get_name())  # 输出: Eve

7.2、私有方法

以两个下划线开头的方法，仅在类内部可用。

python">class Example:  def __private_method(self):  return "This is private."  def call_private(self):  return self.__private_method()  ex = Example()  
print(ex.call_private())  # 输出: This is private.

八、方法

8.1、init()方法

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

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

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

构造函数通常用来初始化实例对象的实例属性

通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量

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

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

python">class Person:  def __init__(self, name, age):  self.name = name  self.age = age  p = Person("Alice", 30)  
print(p.name, p.age)  # 输出: Alice 30

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

8.2、new()方法

这是一个静态方法，用于创建并返回一个新对象。通常在自定义实例化过程时重写。

python">class Person:  def __new__(cls, *args, **kwargs):  print("Creating instance...")  return super().__new__(cls)  def __init__(self, name, age):  self.name = name  self.age = age  p = Person("Bob", 25)  # 先调用__new__，然后调用__init__

8.3、del()方法

析构函数和垃圾回收机制

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

Python实现自动的垃圾回收，当对象没有被引用时（引用计数为0），由垃圾回收器调用__del__()。

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

系统会自动提供__del__方法，一般不需要自定义析构方法。

python">#析构函数
class Person:def __del__(self):print("销毁对象：{0}".format(self))#销毁对象：<__main__.Person object at 0x0000015E5F06E330>p1 = Person()
p2 = Person()
del p2
print("程序结束")#程序结束

python">import time# 定义一个类: 打开一个文件,并且对文件进行相应的操作
class FILE(object):# 定义一个__init__函数def __init__(self, file):# 打开一个file的文件,并且可以进行读写操作self.file = open(file, 'w+')def write(self):print("开始对文件进行写操作")def read(self):print("开始对文件进行读操作")# 定义一个 __del__函数用于析构的时候进行资源回收def __del__(self):print("开始进行析构函数__del__函数")self.file.close()f = FILE("./demo.txt")
time.sleep(4)
# python语言中提供了使用删除对象的关键字 del
del f

8.4、call()方法

使得一个对象实例可以像函数一样被调用。

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

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

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

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

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

8.5、str()方法

__str__函数的功能是返回一个字符串,这个字符串是当调用print函数进行打印的时候,会自动打印__str__函数的返回值。

python"># 定义一个类: Date
class Date(object):# 定义 __init__函数用于初始化对象def __init__(self, year=0, month=1, day=1):self.year = yearself.month = monthself.day = day# 定义一个显示时间的函数def ShowDate(self):print(f"{self.year}年:{self.month}月:{self.day}日")#2025年:1月:15日def __str__(self):  # 返回一个字符串msg = f"{self.year}年:{self.month}月:{self.day}日"return msg#2025年:1月:15日d1 = Date(2025, 1, 15)
# 打印时间:
print(f"{d1}") 
# 由于用户编写了 __str__函数,所以在打印的时候会直接调用__str__
# 函数
d1.ShowDate()

九、方法的特性

9.1、方法没有重载

Python中方法没有重载。

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

Python中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python中是没有方法的重载的。

python">#Python中没有方法的重载。定义多个同名方法，只有最后一个有效
class Person:def say_hi(self):print("hello")def say_hi(self,name):print("{0},hello".format(name))p1 = Person()#p1.say_hi()    #不带参，报错：TypeError: say_hi() missing 1 required positional argument: 'name'p1.say_hi("张三")#张三,hello

9.2、方法的动态性

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

python">#测试方法的动态性
class Person:def work(self):print("努力上班！")def play_game(self):print("玩游戏")def work2(s):print("好好工作，努力上班！")Person.play = play_game
Person.work = work2p = Person()
p.play()#玩游戏
p.work()#好好工作，努力上班！

十、属性和类的命名

10.1、属性和方法命名

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

__xxx__：系统定义的特殊成员

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

10.2、类编码风格

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

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

每个类，应紧跟“文档字符串”，说明这个类的作用

可以用空行组织代码，但不能滥用。在类中，使用一个空行隔开方法；模块中，使用两个空行隔开多个类

十一、None对象

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

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

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

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

python">obj = None
obj2 = None
print(type(None))#<class 'NoneType'>
print(id(None))#140704111757152
print(id(obj))#140704111757152
print(id(obj2))#140704111757152