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语言中的数据结构

1. struct stuct{
3.     int age;
5.     char name[10];
7.     double salary;
9. }

复制代码

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

1. class Student:
3.     company ="XXXXX"#类属性
5.     count =0#类属性
7.     def init (self,name,score):
9.         self.name =name#实例属性
11.         self.score = score
13.         Student.count =Student.count+1
15.     def say_score(self):#实例方法
17.         print("我的学校是:",Student.company)
19.         print(self.name,'的分数是:',self.score)

复制代码

四、类 

   类可以看做是一个模版，大概图纸，系统根据类的定义来造出对象。
  造一个汽车，类就是这个图纸，规定了汽车的详细信息，然后根据图纸将汽车造出来。
    概念:
          具有相同活动状态以及属性的一类物体的统称. 类一般是比较抽象的.不可以直接利用。 
  属性和方法 

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

   定义类的语法格式 ：
          class 类名：
            类体
  

• 类名必须符合“标识符”的规则；一般规定，首字母大写，多个单词利用“驼峰原则”。
  
• 类体中我们可以定义属性和方法
  
• 属性用来形貌数据，方法(即函数)用来形貌这些数据相关的操作
  

  对象完备内存结构 

           类是抽象的，也称之为“对象的模板”。我们必要通过类这个模板，创建类的实例对象，然后才能利用类定义的功能。
  
          我们前面说过一个Python对象包含三个部分：id（identity辨认码）、type（对象类型）、value（对象的值）。
  

五、 实例属性和实列方法

5.1、实例属性

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

• 实例属性一般在__init__()方法中通过如下代码定义：
  self.实例属性名 = 初始值
  
• 在本类的其他实例方法中，也是通过self进行访问： self.实例属性名
  
• 创建实例对象后，通过实例对象访问：
  obj01 = 类名() #创建和初始化对象，调用__init__()初始化属性
  obj01.实例属性名 = 值 #可以给已有属性赋值，也可以新加属性
  

1. class Dog:  
2.     def __init__(self, name):  
3.         self.name = name  # 实例属性  
5. dog = Dog("Buddy")  
6. print(dog.name)  # 输出: Buddy

复制代码

5.2、实列方法

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

• 定义实例方法时，第一个参数必须为self。和前面一样，self指当前的实例对象。
  
• 调用实例方法时，不必要也不能给self传参。self由解释器主动传参
  

1. class Dog:  
2.     def bark(self):  
3.         return "Woof!"  
5. dog = Dog()  
6. print(dog.bark())  # 输出: Woof!

复制代码

函数和方法的区别 
   

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

   实例对象的方法调用本质

   
  

• dir(obj)可以得到对象的所有属性、方法
  
• obj.__dict__ 对象的属性字典
  
• pass 空语句
  
• isinstance（对象,类型） 判断“对象”是不是“指定类型”
  

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

6.1、类对象

   当解释器实行class语句时，就会创建一个类对象
  通过类定义的对象，可以直接调用类的属性和方法。

1. class Student:
2.   pass  #空语句
3. print(type(Student))#<class 'type'>
4. print(id(Student))#1504815125008
5. Stu2 = Student
6. s1 = Stu2()
7. print(s1)#<__main__.Student object at 0x0000015E5EE32F90>

复制代码

6.2、类属性

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

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

复制代码

6.3、类方法

   通过 @classmethod 装饰器定义，接受类作为第一个参数（通常是 cls）
    @classmethod
def 类方法名(cls  [，形参列表]) ：
    方法体 
    @classmethod必须位于方法上面一行
  第一个cls必须有；cls指的就是“类对象”本身
  调用类方法格式：类名.类方法名(参数列表)。 参数列表中，不必要也不能给cls传值
  类方法中访问实例属性和实例方法会导致错误
  子类继续父类方法时，传入cls是子类对象，而非父类对象(⚠讲完继续再说) 

1. class Student:
2.   school='高等学府'  #类属性
3.   
4.   @classmethod
5.   def printschool(cls):
6.     print(cls.school)
7.   
8. Student.printschool()

复制代码

6.4、静态方法

   Python中允许定义与“类对象”无关的方法
    “静态方法”和在模块中定义平凡函数没有区别，只不过“静态方法”放到了“类的名字空间内里”，必要通过“类调用”。 
    @staticmethod
def 静态方法名([形参列表]) ：
    方法体 
    @staticmethod必须位于方法上面一行
  调用静态方法格式：类名.静态方法名(参数列表)
  静态方法中访问实例属性和实例方法会导致错误 

1. class Student:
2.   school='高等学府'  #类属性
4.   @staticmethod
5.   def add(a, b): # 静态方法
6.     print("{0}+{1}={2}".format(a,b,(a+b)))
7.     return a+b
8.    
9. Student.add(20,30)

复制代码

七、私有属性和私有方法

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

• 通常我们约定，两个下划线开头的属性是私有的(private)。其他为公共的(public)。
  
• 类内部可以访问私有属性(方法)
  
• 类外部不能直接访问私有属性(方法)
  
• 类外部可以通过_类名__私有属性(方法)名”访问私有属性(方法)
  

  7.1、私有属性

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

1. class Person:  
2.     def __init__(self, name):  
3.         self.__name = name  # 私有属性  
5.     def get_name(self):  
6.         return self.__name  
8. p = Person("Eve")  
9. print(p.get_name())  # 输出: Eve

复制代码

7.2、私有方法

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

1. class Example:  
2.     def __private_method(self):  
3.         return "This is private."  
5.     def call_private(self):  
6.         return self.__private_method()  
8. ex = Example()  
9. print(ex.call_private())  # 输出: This is private.

复制代码

八、方法

8.1、__init__()方法

   初始化对象，我们必要定义构造函数__init__()方法。构造方法用于实行“实例对象的初始化工作”，即对象创建后，初始化当前对象的相关属性，无返回值。
    名称固定，必须为：__init__()
  
  第一个参数固定，必须为：self。 self指的就是刚刚创建好的实例对象
  
  构造函数通常用来初始化实例对象的实例属性
  
  通过“类名(参数列表)”来调用构造函数。调用后，将创建好的对象返回给相应的变量
  
  __init__()方法：初始化创建好的对象，初始化指的是：“给实例属性赋值”
  
  假如我们不定义__init__方法，系统会提供一个默认的__init__方法。假如我们定义了带参的__init__方法，系统不创建默认的__init__方法

1. class Person:  
2.     def __init__(self, name, age):  
3.         self.name = name  
4.         self.age = age  
6. p = Person("Alice", 30)  
7. print(p.name, p.age)  # 输出: Alice 30

复制代码

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

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

1. class Person:  
2.     def __new__(cls, *args, **kwargs):  
3.         print("Creating instance...")  
4.         return super().__new__(cls)  
6.     def __init__(self, name, age):  
7.         self.name = name  
8.         self.age = age  
10. p = Person("Bob", 25)  # 先调用__new__，然后调用__init__

复制代码

8.3、__del__()方法

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

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

复制代码

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

复制代码

8.4、__call__()方法

   使得一个对象实例可以像函数一样被调用。 
    Python 中，凡是可以将 () 直策应用到自身并实行，都称为可调用对象。
  
可调用对象包括自定义的函数、Python 内置函数、以及本节所讲的实例对象。
  
定义了__call__()的对象，称为“可调用对象”，即该对象可以像函数一样被调用。
  
该方法使得实例对象可以像调用平凡函数那样，以“对象名()”的形式利用。

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

复制代码

8.5、__str__()方法

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

1. # 定义一个类: Date
2. class Date(object):
4.     # 定义 __init__函数用于初始化对象
5.     def __init__(self, year=0, month=1, day=1):
6.         self.year = year
7.         self.month = month
8.         self.day = day
10.     # 定义一个显示时间的函数
11.     def ShowDate(self):
12.         print(f"{self.year}年:{self.month}月:{self.day}日")#2025年:1月:15日
14.     def __str__(self):  # 返回一个字符串
15.         msg = f"{self.year}年:{self.month}月:{self.day}日"
17.         return msg#2025年:1月:15日
18.    
20. d1 = Date(2025, 1, 15)
21. # 打印时间:
22. print(f"{d1}")
23. # 由于用户编写了 __str__函数,所以在打印的时候会直接调用__str__
24. # 函数
25. d1.ShowDate()

复制代码

九、方法的特性

9.1、方法没有重载

   Python中方法没有重载。
            在其他一些语言(好比：Java)中，可以定义多个重名的方法，只要包管方法签名唯一即可。方法签名包含3个部分：方法名、参数数量、参数类型。
  
        Python中，方法的的参数没有声明类型（调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python中是没有方法的重载的。  

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

复制代码

9.2、方法的动态性

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

1. #测试方法的动态性
2. class Person:
3.     def work(self):
4.         print("努力上班！")
6. def play_game(self):
7.     print("玩游戏")
9. def work2(s):
10.     print("好好工作，努力上班！")
13. Person.play = play_game
14. Person.work = work2
16. p = Person()
17. p.play()#玩游戏
18. 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类型的对象

1. obj = None
2. obj2 = None
3. print(type(None))#<class 'NoneType'>
4. print(id(None))#140704111757152
5. print(id(obj))#140704111757152
6. print(id(obj2))#140704111757152

复制代码

十二、头脑导图

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。