< 返回技术文档列表

Python面向对象编程之怎么理解类的概念

发布时间:2021-11-07 00:42:29⊙投诉举报

这篇文章主要讲解了“Python面向对象编程之怎么理解类的概念”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Python面向对象编程之怎么理解类的概念”吧!

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关键字加上类名来定义类,通过缩进我们可以确定类的代码块,就如同定义函数那样。语法结构

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

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

  • 类名:可以是任何有效的标识符,一般首字母大写

  • 类描述:在类定义后首行,以独立的字符串形式定义;定义后通过<类名>.__doc__来访问

示例代码

class TestClass:
    """这是一个测试的类"""
    print("Hello Class Object")


print(TestClass.__doc__)
print(type(TestClass))

'''
----输出结果----

Hello Class Object
这是一个测试的类
<class 'type'>
'''

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

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

创建实例对象语法结构

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

实例代码:

class TestClass:
    print("一碗周")


tt = TestClass()
print(type(tt))
'''
----输出结果----

一碗周
<class '__main__.TestClass'>
'''

3.2 类的构造函数

概念:

  • 类的构造函数用于从类创建实例对象的过程

  • 类的构造函数为实例对象创建提供了参数输入方式

  • 类的构造函数为实例属性的定义和赋值提供了支持

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

语法结构:

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

实例代码:

class TestClass:
    def __init__(self, name):
        print(name)


text1 = TestClass("张三")  # 张三
text2 = TestClass("李四")  # 李四

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

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

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

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

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

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

  • slefPython面向对象中约定的一个类参数

  • self代表类的实例,在类内部,self用于组合访问实例相关的属性和方法

  • 相比,类名代表类对象本身

3.3 类的属性

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

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

  • 访问实例属性:<对象名>.<实例属性>

实例代码

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)实例方法:实例方法是类内部定义的函数,与实例对象无关,语法结构

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

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

实例代码

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)类方法:类方法是与类对象相关的函数,有所有实例对象共享,语法结构↓

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

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

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

实例代码

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)自有方法:自有方法是定义在类名空间中的普通函数,语法格式如下:

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

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

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

实例代码

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)静态方法:定义在类中的普通函数,能够被所有实例对象共享

class ClassName:
    @staticmethod
    def <方法名>(<参数列表>):
        ...

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

示例代码

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)保留方法:有双下划线喀什和结束的方法,保留使用。语法结构↓

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

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

感谢各位的阅读,以上就是“Python面向对象编程之怎么理解类的概念”的内容了,经过本文的学习后,相信大家对Python面向对象编程之怎么理解类的概念这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是血鸟云,小编将为大家推送更多相关知识点的文章,欢迎关注!


/template/Home/Zkeys/PC/Static