面向对象编程 && Python3

最新推荐文章于 2025-07-15 10:18:17 发布

原创最新推荐文章于 2025-07-15 10:18:17 发布 · 531 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

Python基础专栏收录该内容

11 篇文章

订阅专栏

本文详细探讨了Python3的面向对象编程特性，包括成员变量、成员方法、权限修饰符、类方法和静态方法的区别、构造方法、继承与多态。还介绍了Python中的静态类方法和静态方法的独特之处。

面向对象编程 && Python3

Python面向对象编程区别于Java面向对象编程的小细节。
python3面向对象编程的具体资料可以通过如下链接查看，并且该文档的质量相当较高。(http://www.runoob.com/python3/python3-class.html)
若是有一天忘记了，可以回顾查看一下代码示例帮助回顾！

成员变量 && 成员方法

标准的class类定义，成员变量，成员方法定义且使用如下所示：

class Animal:
    def __init__(self, name, age):
        """"成员变量定义"""
        self.animal_name = name
        self.animal_age = age

    def to_string(self):
        """"成员方法定义"""
        print("动物的名字叫做：%s, 动物的年龄为：%d"
              % (self.animal_name,self.animal_age))


animal = Animal("Tom", 5)

"""以类似于java的toString方法进行比较。"""
animal.to_string()

运行结果为：动物的名字叫做：Tom, 动物的年龄为：5。

很显然由于python不需要对变量进行数据类型声明就可以使用的特性，完全可以在外部添加成员变量，或者叫做为类进行属性的添加，比如：

animal = Animal("John", 3)
animal.address = "北京"

"""以类似于java的toString方法进行比较。"""
print("动物的住址在：%s, " % animal.address,end="")
animal.to_string()

运行结果为： 动物的住址在：北京, 动物的名字叫做：John, 动物的年龄为：3。

权限修饰符 && 伪权限修饰

python也有对变量的权限修饰符，但是明显与Java的不一样，Java可以通过反射强行使用私有的变量以及方法，但是python的完全不需要那么复杂，因为它只是对私有的变量以及变量名称多加了一些东西，我们可以利用其追加变化后的名称进行数据的调用。

在Python的面向对象编程中有以下几种下划线的使用方法.
__test_group__、 _test_group 、 __test_group 、 test_group_.
- 第一种是有特殊功能的函数，除了经常使用的几种，一般不建议使用
- 第二种使用之后不能被当做模块导入.
- 第三种是伪权限修饰符，本质上是将变量名称重构，防止被使用，但是仍然是可以使用的.
- 第四种没有特殊功能可以随便使用，一般的使用情况为防止与已知的文件名or模块重名而使用的.

class Animal:
    def __init__(self, name, age):
        """"成员变量定义"""
        self.__animal_name = name # 使用两根连续的下划线，成员变量私有化.
        self.animal_age = age

    def to_string(self):
        """"成员方法定义"""
        print("动物的名字叫做：%s, 动物的年龄为：%d"
              % (self.__animal_name,self.animal_age))

    def __to_private_string(self): # 使用两根连续的下划线，成员方法私有化.
        """"成员方法定义"""
        print("我是私有的方法！","动物的名字叫做：%s, 动物的年龄为：%d"
              % (self.__animal_name,self.animal_age))


animal = Animal("John", 3)

"""以类似于java的toString方法进行比较。"""
# 显然与private修饰的成员变量一样，可以通过类中的非私有方法在外部调用.
# 虽然private修饰的私有成员变量在外部亦可以通过反射强行使用，但是一般情况下是不可以的。
animal.to_string()
print("--------this-is-dividing-line!---------")
print("私有变量--动物名称：%s" % animal._Animal__animal_name)
# 调用私有的成员方法，本质上是伪私有。
# 也就是说python对方法名进行了出来，可以调用处理后的方法名称进行调用私有方法名称.
animal._Animal__to_private_string() # 对象后追加_Animal接私有方法名称.

运行结果为：

动物的名字叫做：John, 动物的年龄为：3
--------this-is-dividing-line!---------
私有变量--动物名称：John
我是私有的方法！ 动物的名字叫做：John, 动物的年龄为：3

“静态变量” && 静态方法

python是没有Java的类似的静态变量的；
但是有一个类变量，类似于Java的静态变量；
但是有有些区别，区别在于Java的可以修改影响到该类的此静态变量，但是python的并不会.

class Animal:
    count = 0

    def __init__(self, name, age):
        """"成员变量定义"""
        self.animal_name = name
        self.animal_age = age
        Animal.count += 1

    def to_string(self):
        """"成员方法定义"""
        print("动物的名字叫做：%s, 动物的年龄为：%d"
              % (self.__animal_name,self.animal_age))


Cat = Animal("Tom", 5)
Dog = Animal("John", 3)
print("测试Dog.count数值：% d." % Dog.count)
print("测试Cat.count数值：% d." % Cat.count)
Dog.count = 10
print("重新测试Cat.count数值：% d." % Cat.count)
print("重新测试Dog.count数值：% d." % Dog.count)

# 查看类变量的值，结果为2，显然与Java的不一样。
print("Animal.count：%d." % Animal.count)

Animal.count = 0
print("Animal.count>>>：%d." % Animal.count)

运行结果为：

测试Dog.count数值： 2.
测试Cat.count数值： 2.
重新测试Cat.count数值： 2.
重新测试Dog.count数值： 10.
Animal.count：2.
Animal.count>>>：0.

类方法与类的静态方法到底有什么区别问题？

有博文介绍如下：https://www.cnblogs.com/ScvQ/p/7054513.html
最后文章的总结部分认为类的静态方法不能继承，实际上是类方法，类的静态方法仍然可以被继承，亦可以被重写的.

# 测试类方法与静态方法
class Animal:
    def __init__(self, name, age):
        """"成员变量定义"""
        self.animal_name = name
        self.animal_age = age

    @classmethod
    def class_string(cls):
        """"成员方法定义"""
        print("我是动物类")

    @staticmethod
    def static_string():
        print("我是原生测试组static_string.")


class Dog(Animal):
    @classmethod
    def class_string(cls):
        print("我是狗类.")

    @staticmethod
    def static_string():
        print("我是修改的测试组static_string.")

DemoDog = Dog("Tom",8)
DemoDog.class_string()
DemoDog.static_string()
print(">"*30)
Animal.class_string()
Animal.static_string()

结果如下：

我是狗类.
我是修改的测试组static_string.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
我是动物类
我是原生测试组static_string.

其中类的静态方法其实完全可以将其移除类部分，单独作为一个逻辑部分，我想使用类的静态方法的目的可能正如java中的静态代码块一样吧，只是为了在使用该类的模块是否进行初始化吧!

构造方法 && 内部方法

python提供一些内部的方法，比如__init__; str; __del__等。

在ubuntu操作系统中，terminal交互模式下，可以通过创建一个对应的数据类型，在dir()即可查看具体的内置函数。

比如： list_abc = [] , dir(list_abc)！即可…

__str__方法：

class Animal:
    def __init__(self, name, age):
        """"成员变量定义"""
        self.animal_name = name
        self.animal_age = age

    def __str__(self):
        """"成员方法定义"""
        return("动物的名字叫做：%s, 动物的年龄为：%d"
              % (self.animal_name,self.animal_age))


Cat = Animal("Tom", 5)
print(Cat)

运行结果为： 动物的名字叫做：Tom, 动物的年龄为：5 !

"_name_"的调用

保证函数在本python模块下可以直接执行，但是被导入方式时候避免执行。

if __name__ == "__main__":
	print("被"if __name__ == "__main__":"语句包括的部分.")
	print("主模块下执行，但是作为导入模块时候是不执行的.")

继承 && 多态

对比与Java，最大的区别在于可以多继承，其余的多态与Java的完全一致。

class Animal(object):
    def __init__(self, name, age):
        self.animal_name = name
        self.animal_age = age

    def run(self):
        print("奔跑！")

    def sleep(self):
        print("动物睡觉！")


class Creature(object):
    # def __init__(self, name, age):
    #     self.creature_name = name
    #     self.creature_age = age

    def eat(self):
        print("进食！")

    def drink(self):
        print("饮水！")

    def sleep(self):
        print("生物睡觉！")


class Mankind(Animal, Creature):
    def eat(self):
        print("人类吃熟食！")


li_ming = Mankind("LiMing", 18);
# 继承！
li_ming.sleep()
li_ming.run()

# override重写！
li_ming.eat()

运行结果为：

动物睡觉！
奔跑！
人类吃熟食！

显然可以多继承继承，继承的顺序按照括号内从左往右的顺序依次查找对应函数，若找到，则执行对应方法，不再继续找下去，若没有则一直下去，直到报错！

查看方式：

print("显示加载顺序:", Mankind.__mro__)

结果为：

显示加载顺序: (<class '__main__.Mankind'>, <class '__main__.Animal'>, <class '__main__.Creature'>, <class 'object'>)

静态类方法 && 静态方法

这个是python3的独有特性：

class Animal():
    count_num = 0

    def __init__(self, name, age):
        """"成员变量定义"""
        self.animal_name = name
        self.animal_age = age
        Animal.count_num += 1

    # 静态方法，与类属性 && 类的实例皆无关.
    @staticmethod
    def run():
        print("奔跑！")

    # 类方法，一般结合类属性，与类的实例无关.
    @classmethod
    def count(cls):
        print ("创建对象次数：%d" % cls.count_num)


Dog = Animal("Dog", 5)
Cat = Animal("Cat", 3)
Animal.run()

# 类变量，适用范围为，类有关系，实例无关系.
print(Animal.count_num)

# 类方法.
Animal.count()

运行结果为：

奔跑！
2
创建对象次数：2