一、面向对象简介
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.对象
将不同类型的数据、方法（即函数）放到一起，就是对象。比如：
class Student: company ="XXXXX"#类属性 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 类名：
类体
类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词使用“驼峰原则”。
类体中我们可以定义属性和方法
属性用来描述数据，方法(即函数)用来描述这些数据相关的操作
对象完整内存结构
类是抽象的，也称之为“对象的模板”。我们需要通过类这个模板，创建类的实例对象，然后才能使用类定义的功能。
我们前面说过一个Python对象包含三个部分：
id（identity识别码）、type（对象类型）、value（对象的值）。
五、 实例属性和实列方法
5.1、实例属性
实例属性是从属于实例对象的属性，也称为“实例变量”。
实例属性一般在
__init__()方法中通过如下代码定义：
self.实例属性名 = 初始值在本类的其他实例方法中，也是通过
self进行访问：self.实例属性名创建实例对象后，通过实例对象访问：
obj01 = 类名()#创建和初始化对象，调用__init__()初始化属性
obj01.实例属性名 = 值#可以给已有属性赋值，也可以新加属性
class Dog:
def __init__(self, name):
self.name = name # 实例属性
dog = Dog("Buddy")
print(dog.name) # 输出: Buddy5.2、实列方法
实例方法是从属于实例对象的方法。
定义实例方法时，第一个参数必须为
self。和前面一样，self指当前的实例对象。调用实例方法时，不需要也不能给
self传参。self由解释器自动传参
class Dog:
def bark(self):
return "Woof!"
dog = Dog()
print(dog.bark()) # 输出: Woof!函数和方法的区别
- 都是用来完成一个功能的语句块，本质一样。
- 方法调用时，通过对象来调用。方法从属于特定实例对象，普通函数没有这个特点
- 直观上看，方法定义时需要传递self，函数不需要
实例对象的方法调用本质
dir(obj)可以获得对象的所有属性、方法
obj.__dict__对象的属性字典
pass空语句
isinstance（对象,类型）判断“对象”是不是“指定类型”
六、类对象、类属性、类方法、静态方法
6.1、类对象
当解释器执行
class语句时，就会创建一个类对象通过类定义的对象，可以直接调用类的属性和方法。
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、类属性
类属性是从属于“类对象”的属性，也称为“类变量”。由于，类属性从属于类对象，可以被所有实例对象共享。
在类中或者类的外面，我们可以通过：
类名.类变量名来读写
class Student:
school= "高等学府" # 类属性
count = 0 # 类属性
def __init__(self, name, score):
self.name = name # 实例属性
self.score = score
Student.count = Student.count + 1
def say_score(self): # 实例方法
print("我的学校是：", Student.school)#我的学校是： 高等学府
print(self.name, '的分数是：', self.score)#张三 的分数是： 80
s1 = 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是子类对象，而非父类对象(⚠讲完继承再说)
class Student:
school='高等学府' #类属性
@classmethod
def printschool(cls):
print(cls.school)
Student.printschool()
6.4、静态方法
Python中允许定义与“类对象”无关的方法
“静态方法”和在模块中定义普通函数没有区别，只不过“静态方法”放到了“类的名字空间里面”，需要通过“类调用”。
@staticmethod
def 静态方法名([形参列表]) ：
方法体
@staticmethod必须位于方法上面一行
调用静态方法格式：类名.静态方法名(参数列表)
静态方法中访问实例属性和实例方法会导致错误
class Student:
school='高等学府' #类属性
@staticmethod
def add(a, b): # 静态方法
print("{0}+{1}={2}".format(a,b,(a+b)))
return a+b
Student.add(20,30)
七、私有属性和私有方法
Python对于类的成员没有严格的访问控制限制，这与其他面向对象语言有区别。
通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
类内部可以访问私有属性(方法)
类外部不能直接访问私有属性(方法)
类外部可以通过
_类名__私有属性(方法)名”访问私有属性(方法)
7.1、私有属性
以两个下划线开头的属性，不能被外部直接访问。
class Person:
def __init__(self, name):
self.__name = name # 私有属性
def get_name(self):
return self.__name
p = Person("Eve")
print(p.get_name()) # 输出: Eve7.2、私有方法
以两个下划线开头的方法，仅在类内部可用。
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__方法
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
print(p.name, p.age) # 输出: Alice 30Python中的self相当于C++中的self指针，JAVA和C#中的this关键字。Python中，self必须为构造函数的第一个参数，名字可以任意修改。但一般惯例，都叫做self
8.2、__new__()方法
这是一个静态方法，用于创建并返回一个新对象。通常在自定义实例化过程时重写。
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__方法，一般不需要自定义析构方法。
#析构函数
class Person:
def __del__(self):
print("销毁对象：{0}".format(self))#销毁对象：<__main__.Person object at 0x0000015E5F06E330>
p1 = Person()
p2 = Person()
del p2
print("程序结束")#程序结束
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 f8.4、__call__()方法
使得一个对象实例可以像函数一样被调用。
Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。
可调用对象包括自定义的函数、Python 内置函数、以及本节所讲的实例对象。
定义了__call__()的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
该方法使得实例对象可以像调用普通函数那样，以“对象名()”的形式使用。
def f1():
print("f1")
f1() #本质也是调用了__call__()方法
class Car:
def __call__(self, age,money):
print("__call__方法")#__call__方法
print("车龄：{0},金额：{1}".format(age,money))#车龄：3,金额：200000
f2 = Car()
f2(3,200000) #像调用函数那样调用，本质也是调用了__call__()
8.5、__str__()方法
__str__函数的功能是返回一个字符串,这个字符串是当调用print函数进行打印的时候,会自动打印__str__函数的返回值。
# 定义一个类: Date
class Date(object):
# 定义 __init__函数用于初始化对象
def __init__(self, year=0, month=1, day=1):
self.year = year
self.month = month
self.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中没有方法的重载。定义多个同名方法，只有最后一个有效
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是动态语言，我们可以动态的为类添加新的方法，或者动态的修改类的已有的方法
#测试方法的动态性
class Person:
def work(self):
print("努力上班！")
def play_game(self):
print("玩游戏")
def work2(s):
print("好好工作，努力上班！")
Person.play = play_game
Person.work = work2
p = 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类型的对象
obj = None
obj2 = None
print(type(None))#<class 'NoneType'>
print(id(None))#140704111757152
print(id(obj))#140704111757152
print(id(obj2))#140704111757152十二、思维导图
