脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python面向对象编程之类的概念

Python面向对象编程之类的概念

2022-02-22 00:11一碗周 Python

这篇文章主要介绍了Python面向对象编程之类的概念，Python语言的中所有数据类型都是对象、函数是对象、模块是对象；所有类都是继承最基础的类object，面向对象编程又叫OOP，下文了解更多具体内容,需要的朋友可以参考一下

1、面向对象基本概念

1.1 万物皆对象

  • Python语言的中所有数据类型都是对象、函数是对象、模块是对象
  • Python所有类都是继承最基础的类object
  • Python语言中的数据类型的操作功能都是类方法的体现

1.2 面向对象编程

面向对象编程又叫OOP（Object-Oriented-Programming）

OOP：面向对象编程，一种编程思想，重点在于高抽象的复用代码

  • OOP把对象当做程序的基本单元，对象包含数据和操作数据的函数
  • OOP本质是把问题解决抽象为以对象为中心的计算机程序
  • OOP在较大规模或复杂项目中十分有用，OOP可以提高协作产量
  • OOP最主要的价值在于代码复用
  • OOP仅仅是一个编程方式，并非解决问题的高级方法

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

面向过程以解决问题的过程步骤为核心编写程序的方式，面向对象以问题对象构建和应用为核心编写程序的方式，所有能用OOP解决的问题，面向过程都能解决。

1.3 面向对象的特征

封装（Encapsulation） ：属性和方法的抽象，用数据和操作数据的方法来形成对象逻辑

方法的抽象：对类的属性（变量）进行定义、隔离和保护

  • 对象的抽象：对类的方法（函数）进行定义、隔离和保护
  • 目标是形成一个类对外可操作属性和方法的接口

继承：代码复用的高级抽象，用对象之间的继承关系来形成代码复用

继承是面向对象程序设计的精髓之一

  • 实现了以类为单位的高抽象级别的代码复用
  • 继承是新定义类能够几乎完全使用原有类属性与方法的过程

多态：方法灵活性的抽象，让对象的操作更加灵活、更多复用代码

参数类型的多态：一个方法能够处理多个类型的能力

  • 参数形式的多态：一个方法能够接受多个参数的能力
  • 多态是OOP的一个传统概念，Python天然支持多态，不需要特殊语法

2、Python面向对象的术语

类（Class）和对象（Object）

  • 类：逻辑抽象和产生对象的模板，一组变量和函数的特定编排
  • 对象：具体表达数据及操作的实体，相当于程序中的“变量”。包括：类对象、实例对象

类定义完成后，默认生成一个类对象，每个类唯一对应一个类对象，用于存储这个累的基本信息 类对象是type的实例，表达为type类型；

  • 实例对象（Instance Object）：Python类实例后产生的对象，简称：对象
  • 类对象全局只有一个，实例对象可以生成多个

属性：存储数据的“变量”（就是定义在类中的变量），用来描述类的一些特性参数。包括：类属性、实例属性

  • 类属性（Class Attribute）：类对象的属性，由所有实例对象共享；类内定义，在__init__函数外面。一般是类所共有的属性定义为类属性。
  • 实例属性（Instance Attribute）：实例对象的属性，一般在类中的函数中定义，实例属性可能为某个实例独有。

方法：操作数据的“方法”（就是定义在类中的变量），用来给出类的操作功能。包括：类方法、实例方法、自由方法、静态方法、保留方法

  • 类方法（Class Method）：类对象的方法，由所有实例对象共享
  • 实例方法（Instance Method）：实例对象的方法，由各实例对象独享，最常用的形式、
  • 自由方法（Namespace Method）：类中的一个普通函数，由类所在命名空间管理，类对象独享
  • 静态方法（Static Method）：类中的一个普通函数，由对象和实例对象共享
  • 保留方法（Reserved Method）：有双下划线喀什和结束的方法，保留使用。

实例化：从类到对象的过程，所有“对象”都源于某个“类”

3、Python类的构建

3.1 类的基本构建

在Python中，使用class关键字加上类名来定义类，通过缩进我们可以确定类的代码块，就如同定义函数那样。语法结构

?
1
2
3
class <类名>:
    [类描述“documentation string”]
    <语句块>

因为Python是脚本语言，定义类不限制位置，可以包含在分支或其他从属语句块中，执行是存在即可

  • 类名：可以是任何有效的标识符，一般首字母大写
  • 类描述：在类定义后首行，以独立的字符串形式定义；定义后通过<类名>.__doc__来访问

示例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TestClass:
    """这是一个测试的类"""
    print("Hello Class Object")
 
 
print(TestClass.__doc__)
print(type(TestClass))
 
'''
----输出结果----
 
Hello Class Object
这是一个测试的类
<class 'type'>
'''

类对象直接包含的语句会被执行，所有，定义类尽量不在类中直接包含语句

实例对象：实例对象是Python类最常用的方式

创建实例对象语法结构

<对象名> = <类名>([参数])

实例代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
class TestClass:
    print("一碗周")
 
 
tt = TestClass()
print(type(tt))
'''
----输出结果----
 
一碗周
<class '__main__.TestClass'>
'''

3.2 类的构造函数

概念:

  • 类的构造函数用于从类创建实例对象的过程
  • 类的构造函数为实例对象创建提供了参数输入方式
  • 类的构造函数为实例属性的定义和赋值提供了支持

Python中使用预定义的__init__()作为构造函数

语法结构:

?
1
2
3
4
class ClassName:
    def __init__(self,[参数1]， [参数2]， ...[参数n]):
        <语句块>
    ...

实例代码:

?
1
2
3
4
5
6
7
class TestClass:
    def __init__(self, name):
        print(name)
 
 
text1 = TestClass("张三")  # 张三
text2 = TestClass("李四")  # 李四

通过构造函数__init__可以为Python提供参数

**__init__()**的使用说明

参数：第一个参数约定是self,表示类实例自身，其他参数是实例参数（self是内部使用的，默认保留，其他用户输入的参数放到self后面）

函数名：Python解释器内部定义，由双下划线 (__) 开始和结束

返回值：构造函数没有返回值，或返回为None，否则产生TypeError异常

**self**在类定义内部代表类的实例

  • slef是Python面向对象中约定的一个类参数
  • self代表类的实例，在类内部，self用于组合访问实例相关的属性和方法
  • 相比，类名代表类对象本身

3.3 类的属性

属性是类内部定义的变量，语法结构如下：

?
1
2
3
4
5
class ClassName:
    <类属性名> = <类属性初值>
    def __init__(self,[参数1]， [参数2]， ...[参数n]):
        self.<实例属性名> = <实例属性初值>
    ...
  • 访问类属性：<类名>.<类属性>或者<对象名>.<类属性>
  • 访问实例属性：<对象名>.<实例属性>

实例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
class TestClass:
    count = 0  # 类属性
 
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = name
        TestClass.count += 1  # 实例化一次 count+1
 
 
students1 = TestClass("张三", "18")
students2 = TestClass("李四", "19")
print("总数：", TestClass.count)  # 总数： 2
print(students1.name, students2.name)  # 张三 李四

3.4 类的方法

（1）实例方法：实例方法是类内部定义的函数，与实例对象无关，语法结构

?
1
2
3
class ClassName:
    def <方法名>(self, <参数列表>):
        ...

 <方法名>(<参数列表>)的方式使用实例方法的定义第一个参数是self

实例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TestClass:
    def __init__(self, number):
        self.number = number
 
    def sum_number(self):  # 实例方法
        sum_num = 0
        for i in range(self.number + 1):  # 因为循环不会到最后一个数字
            sum_num += i
        return sum_num
 
 
number1 = TestClass(100)
number2 = TestClass(10)
print(number1.sum_number())  # 5050
print(number2.sum_number())  # 55

（2）类方法：类方法是与类对象相关的函数，有所有实例对象共享，语法结构↓

?
1
2
3
4
class ClassName:
    @classmethod
    def <方法名>(cls, <参数列表>):
        ...

<方法名>(<参数列表>)或者<类名>.<方法名>(<参数列表>)的方式使用，类方法至少包含一个参数，表示类对象，建议用@classmethod是装饰器，类方法定义所必须

类方法只能操作类属性和其他类方法，不能操作实例属性和实例方法。

实例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class TestClass:
    sum_num = 0
 
    def __init__(self, number):
        self.number = number
 
    def sum_number(self):
        for i in range(self.number + 1):  # 因为循环不会到最后一个数字
            TestClass.sum_num += i
        return TestClass.sum_num
 
    @classmethod
    def test(cls):  # 类方法
        test_value = TestClass.sum_num * 2
        return test_value
 
 
value1 = TestClass(100)
print(value1.sum_number())  # 5050
print(value1.test())  # 10100

（3）自有方法：自有方法是定义在类名空间中的普通函数，语法格式如下：

?
1
2
3
class ClassName:
    def <方法名>(<参数列表>):
        ...

.<方法名>(<参数列表>)的方式使用，<类名>表示命名空间。自有方法不需要self或cls这类参数，可以没有参数。自有方法只能操作类属性和类方法，不能操作实例属性和实例方法。自由方法的使用只能使用<类名>

严格的说自由方法不是一个方法，只是一个定义在类中的函数

实例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class TestClass:
    sum_num = 0
 
    def __init__(self, number):
        self.number = number
 
    def sum_number(self):
        for i in range(self.number + 1):  # 因为循环不会到最后一个数字
            TestClass.sum_num += i
        return TestClass.sum_num
 
    def test():  # 自由方法
        test_value = TestClass.sum_num * 2
        return test_value
 
 
def test_out():  # 等于上面的那个自由方法
    test_out_value = TestClass.sum_num * 2
    return test_out_value
 
 
value = TestClass(100)
print(value.sum_number())  # 5050
print(TestClass.test())  # 10100
print(test_out())  # 10100

定义来类中的自由方法也可以定义到外面

（4）静态方法：定义在类中的普通函数，能够被所有实例对象共享

?
1
2
3
4
class ClassName:
    @staticmethod
    def <方法名>(<参数列表>):
        ...

.<方法名>(<参数列表>)或者<类名>.<方法名>(<参数列表>)的方式使用静态方法也可以没有参数，可以理解为可以使用对象名调用的自有方法。 @staticmethod是装饰器，静态方法定义所必需的，静态方法同自由方法一样，只能操作类属性和类方法，不能操作实例属性和实例方法，不同的是可以通过<类名>或<对象名>。

示例代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class TestClass:
    sum_num = 0
 
    def __init__(self, number):
        self.number = number
 
    def sum_number(self):
        for i in range(self.number + 1):  # 因为循环不会到最后一个数字
            TestClass.sum_num += i
        return TestClass.sum_num
 
    @staticmethod  # 静态方法装饰器
    def test():
        test_value = TestClass.sum_num * 2
        return test_value
 
 
value = TestClass(100)
print(value.sum_number())  # 5050
print(TestClass.test())  # 10100
print(value.test())  # 10100

（5）保留方法：有双下划线喀什和结束的方法，保留使用。语法结构↓

?
1
2
3
class ClassName:
    def <保留方法名>(<参数列表>):
        ...

保留方法一般都对应类的某种操作，在使用操作符的时候调用是Python解释器中保留的方法

到此这篇关于Python面向对象编程之类的概念的文章就介绍到这了,更多相关Python面向对象编程之类的概念内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://juejin.cn/post/7023376907966103560

  • Python
  • 类
  • 面向对象编程

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图