Python编程-面向对象基础与入门到实践一书的内容拓展

Python编程-面向对象基础与入门到实践一书的内容拓展

通过编程，模拟现实生活中的事物编程，叫做面向对象编程，此过程也叫做实例化编程

简单类的创建

class Test():
    def __init__ (self,id):
        self.id = id

    def print_id(self):
        print(self.id)

这里建立了一个名为test的类，其中有两个函数，__init__与print_id,有一个数据成员id

• __init__函数

__init__是一种特殊方法，用于创建类时的初始化，其中带有两个参数self与id,其中__init__初始化类对象时，将参数全部自动传递给self（无需我们手动传参）,self相当于为每个对象划定了一个用于存放数据成员的位置，保证每个对象的数据成员独立且不受干扰，需要注意的是**self必须放置在最前面**，而后面的id就是我们需要传递的参数，并且它的数量是任意的（需要多少个，参数就写多少个）

• 成员函数访问数据

在一个类中的成员函数使用对应对象的数据成员时，必须要使用self获取对应的数据成员，如self.id

熟悉c++的同学应该看出来了，这和c++的构造函数是类似的

• 拓展思维

既然成员是函数（虽然类中叫方法），那么能否使用关键字实参，默认值与不定参数呢？当然是可以的，后文实验源码将会写到

__init__的使用

我们先看如下代码：

class Base():
    def fun(self):
        self.a = 1
        self.data = 2
    
    def print_all(self):
        print(self.id, self.data)

op = Base()
op.print_all()

我们定义了上述代码，通过运行我们会发现，这几行代码是没有办法运行的，解释器会丢出以下错误：

可以看到，解释器提示我们，缺少了对应的属性，原因就是因为我们没有使用__init__来创建对应的self数据，类中并没有存储我们的id与data，但是没有该方法，代码能不能跑呢，答案是可以，如下的特殊情况：

class Base():
    def fun(self,x,y):
        return x,y
    
op = Base()
print(op.fun(1,2))

可以看到运行是正常的，但是我们进行类创建时最好加上__init__,不然实例化将失去意义

此处注意一个细节，建立无参类的对象时需要加上(),例如 op = Base()

创建与访问对象

class Test():
    def __init__ (self,id_):
        self.id = id_
        self.age = 16

    def print_id(self):
        print(self.id)

a = Test(11)
a.print_id()
a.id = 12
print(a.id)
print(a.age)

我们的__init__函数中传入了一个id_,所以传入了一个参数11,而我们要访问对应对象的数据或函数成员则需要.运算符,同理要修改某一成员时，也需要用.运算符操作，并且我们还可以为对象指定默认参数，如上述代码中的self.age = 16

子类继承

通常一个大类下可能有，多个有差异的子类，此时则需要继承操作，我们注意到，前面的Test的对象后面有一个括号，在未进行继承时该括号可以省略

无参构造的继承

class Base():
    def __init__(self):
        self.id = 1
        self.data = 2

    def print_all(self):
        print(self.id, self.data)

class Dome(Base):
    def __init__(self):
        super().__init__()
        self.a = 3

    def print_all(self):
        print(self.id, self.data, self.a)

object = Dome()
object.print_all()

如上代码中的无参数类继承，这里需要提出几个关键点：

• 在C++中在继承时无参数基类是可以省略派生类与基类的构造，但是python不能够省略
• 派生类的super().__init__()也不能省略，它是用来链接基类与派生类的，省略后将无法从基类继承

对于第二点有以下情况，当我们不使用基类继承成员时能否省略super().__init__()呢？我们运行以下代码：

class Base():
    def __init__(self):
        print("yes")  # 我们加入了基类构造提示
        self.id = 1
        self.data = 2

    def print_all(self):
        print(self.id, self.data)

class Dome(Base):
    def __init__(self):
        # super().__init__()  # 将之注释掉
        self.a = 3

    def print_all(self):
        print(self.a)

object = Dome()
object.print_all()

通过上述代码运行结果可知，此代码并没有进行继承操作，仅仅只是输出了a的值，即class Dome(Base)失去意义，如果我们取消注释，那么它又将正常继承

有参构造的继承

class Base():
    def __init__(self, id, data):
        self.id = id
        self.data = data

    def print_all(self):
        print(self.id, self.data)


class Dome(Base):
    def __init__(self, id, data, a):
        super().__init__(id, data)
        self.a = a

    def print_all(self):
        print(self.id, self.data, self.a)


object = Dome(1, 2, 3)
object.print_all()

如上述代码，我们在子类Dome的括号内填入基类的的名字，Dome中的第一个__init__用于初始化传入派生类的值super函数用于连接基类与派生类，其后跟随的__init__用于向基类传递参数，并且不加self（作为实参，调用基类的__init__），并且在为基类构造时，派生类的构造函数参数数量至少要大于或等于基类参数的数量，否则将构建失败

重写基类成员

有时候我们需要对于派生类与基类的不同之处做出不同的行为，但是为了保证代码的可读性，我们要派生类调用同名函数，于是我们有以下操作：

class Base():
    def __init__ (self,id_):
        self.id = id_

    def print_id(self):
        print(self.id)

class Dome(Base):
    def __init__ (self,id_):
        super().__init__(id_)
        self.a = 12
        
    def print_id(self):
        print(self.a)

object = Dome(11)
object.print_id()

运行上述代码，使用与基类中同名的函数得到子类中a的值

在子类中调用基类方法

class Base():
    def __init__ (self,id_):
        self.id = id_

    def print_id(self):
        print(self.id)

class Dome(Base):
    def __init__ (self,id_):
        super().__init__(id_)
        self.a = 12
        
    def print_id(self):
        super().print_id()

object = Dome(11)
object.print_id()

运行上述代码，使用与基类中同名的函数得到基类中id的值

多继承的super参数处理

class BaseClass:
    def __init__(self, base_param):
        self.base_param = base_param
        print("BaseClass constructor with base_param:", self.base_param)

class Mixin1(BaseClass):
    def __init__(self, mixin1_param, **kwargs):
        super().__init__(**kwargs)  # 调用父类的构造函数
        self.mixin1_param = mixin1_param
        print("Mixin1 constructor with mixin1_param:", self.mixin1_param)

class Mixin2(BaseClass):
    def __init__(self, mixin2_param, **kwargs):
        super().__init__(**kwargs)  # 调用父类的构造函数
        self.mixin2_param = mixin2_param
        print("Mixin2 constructor with mixin2_param:", self.mixin2_param)

class MyClass(Mixin1, Mixin2):
    def __init__(self, base_param, mixin1_param, mixin2_param):
        super().__init__(base_param=base_param, mixin1_param=mixin1_param, mixin2_param=mixin2_param)
        print("MyClass constructor")

# 创建实例
obj = MyClass(base_param="BaseParam", mixin1_param="Mixin1Param", mixin2_param="Mixin2Param")

在这个例子中，每个类的构造函数都接收一些参数，并使用 super().__init__(**kwargs) 来调用父类的构造函数。在 MyClass 中，通过使用 super() 来确保调用了 Mixin1 和 Mixin2 的构造函数，并传递了适当的参数。

类的嵌套

总所周知python中套娃是非常普遍的，通常情况下，我们在构建一个实例时，实例的属性是非常复杂的，我们为了简化代码，需要为某些特定属性建立一个类：

class build:
    def __init__(self):
        self.time = 1998
    
    def print_time(self):
        print(self.time)

class Base:
    def __init__ (self,id_):
        self.id = id_
        self.build = build()

    def print_id(self):
        print(self.id)


ob = Base(22)
ob.build.print_time()

如上，我们为Base类建立了一个嵌套的子类build，用于存储建立的时间，但是访问time时时我们需要注意：要通过Base对象去访问build中的成员print_time

类的访问权限

Python中对类中数据的访问权限并没有C++那样严格，可以暂时认为只有私有与公有两种权限（先暂时这样理解，后文将细说）

公有权限

class Test:
    def __init__(self,a):
        self.a = a

    def print_(self):
        print(self.a)


object = Test(22)
print(object.a)
object.a = 33
print(object.a)

如上，定义一个简单的类，然后访问并且修改它，可以看到修改成功，即按上述代码进行编写代码，所有数据都是公有的，外界可以修改

私有权限

class Test:
    def __init__(self,a):
        self.__a = a

    def print_(self):
        print(self.__a)

ob = Test(22)
print(ob.__a)

先看如上错误代码，我们运行后可以发现会抛出如下错误：

它会提示我们，Test类中没有这个属性，原来我们在成员前加上__后解释器对数据成员进行了一个类似于重命名的操作，不同版本的解释的方式也不同，如果我们要强行访问，也可以想办法找到对应解释器的重构规则进行访问，一般这类成员我们通过成员方法进行访问

class Test:
    def __init__(self,a):
        self.__a = a

    def print_(self):
        print(self.__a)

ob = Test(22)
ob.print_()

需要注意的是：

• 类似于__init__这类前后带有双下划线的，在python中是特殊的变量，可以直接访问
• 从上面可知，python中的权限实际上是没有限制的，只要你有对应的访问方式
• 和C++类似，python的方法和C++的函数一样是可以作为私有成员的，如下套娃代码

class Test:
    def __init__(self,a):
        self.__a = a

    def __print_(self):
        print(self.__a)
    
    def printf(self):
        self.__print_()

ob = Test(22)
ob.printf()

保护权限

python中实际上是没有保护权限的，但是有一种约定俗成的规定，即在变量前加 _,这类成员实际上仍然是公有的，但是约定为保护成员

class Test:
    def __init__(self,a):
        self._a = a

    def print_(self):
        print(self._a)


object = Test(22)
print(object._a)
object.a = 33
print(object._a)

通过上述讲解，我们可以将继承进行拓展，即在继承时，实际上是继承了所有成员，但是由于我们不知道对应变量的变量名，而变得难以访问对应成员

单类模块使用

和函数一样，python也支持将类装进一个模块，我们建立一个Test模块进行使用

# test.py
class Test:
    def __init__(self,a):
        self._a = a

    def print_(self):
        print(self._a)

这个模块包含了一个Test类，其中有一个数据成员_a和一个函数print_

使用该模块可以通过如下引入：from [模块文件名] import [对应类名]

则引入方式为 from test import Test

多类模块的引入

通常在构建项目时，会建立多个类的模块，可能会包含多个同等地位的类，子类嵌套或继承，此时引入方式和上述仍然一致：

# test.py
class Test_one:
    def __init__(self,a):
        self._a = a

    def print_(self):
        print(self._a)


class Test_two:
    def __init__(self,a):
        self._a = a

    def print_(self):
        print(self._a)

如上建立同等地位的类，我们的访问方式没有太多变化：

from test import Test_one
from test import Test_two

访问带有子类嵌套的类模块

# test.py
class Test_one:
    def __init__(self, x, y):
        self.a = x
        self.b = Test_two(y)

    def print_(self):
        print(self.a)


class Test_two:
    def __init__(self, x):
        self.a = x

    def print_(self):
        print(self.a)

定义类如上，接下来我们进行访问：

from test import Test_one

object = Test_one(22, 33)
print(object.a, object.b.a)

我们注意到运行是正常的，即python在引入带子类的类Test_one后初始化其对象时，会自动创建其子类，但是并没有自动为文件引入模块中的子类，即如下操作是错误的：

from test import Test_one

object = Test_two(22)

访问带有继承类模块

# test.py
class Base():
    def __init__(self, id, data):
        self.id = id
        self.data = data

    def print_all(self):
        print(self.id, self.data)

class Dome(Base):
    def __init__(self, id, data, a):
        super().__init__(id, data)
        self.data = data
        self.a = a

    def print_all(self):
        print(self.id, self.data, self.a)

建立如上模块，进行以下操作：

from test import Dome

object = Dome(1, 2, 3)
object.print_all()

正常运行，并且访问带有继承类模块时，导入其派生类不会自动导入基类

还有一点，类模块和函数一样也是可以取别名的，就像以下操作：

from test import Dome as d

object = d(1, 2, 3)
object.print_all()

其他导入情况

我们经常会遇到下述情况：

• 使用同一模块中的所有类
• 使用同一模块中的两个或两个以上的类

这方面和函数类似，我们依次介绍

使用同一模块中的所有类

from test import *

此操作将取出该模块中所有类，并且不使用.运算符操作

格式：from [模块名] import *

import test

此操作导入了整个模块，需要使用.运算符操作

格式：import [模块名]

类与函数混合模块的导入

在python中可以将函数与类放在同一模块下，如下：

# test.py
class Base():
    def __init__(self, id, data):
        self.id = id
        self.data = data

    def print_all(self):
        print(self.id, self.data)


class Dome(Base):
    def __init__(self, id, data, a):
        super().__init__(id, data)
        self.data = data
        self.a = a

    def print_all(self):
        print(self.id, self.data, self.a)

def hello_world():
    print(("hello World").title())

但是我们使用时仍然是一致的：

from test import *

object = Dome(1, 2, 3)
object.print_all()

hello_world()

实验源码

# Chicken.py
class Person:
    def __init__(self, name, time, *show): # 不定参数
        self.name = name
        self.time = time

    def print_all(self):
        print(self.name, self.time)


class PersonShow(Person):
    def __init__(self, name, time, *show):
        super().__init__(name=name, time=time) # 关键字实参
        self.showList = []
        for i in range(0, len(show)):
            self.showList.append(show[i])

    def print_all(self):
        byte_str = bytes.fromhex('e894a1e5be90e59da4')
        string = byte_str.decode('utf-8')
        print("我是练习时长"+str(self.time)+"的个人练习生"+str(self.name))
        print("喜欢", self.showList)
        if self.name == string:
            print("鸡 你 太 美")
        print("喜欢的话 请多多为我投票吧")

from Chicken import *

if __name__ == "__main__" :
    player = PersonShow("蔡徐坤","两年半","唱","跳","RAP","篮球")
    player.print_all()

所有类的超类object

在Python中，所有的类都直接或间接地继承自object类，类似于Java中的Object类。不过在Python 3中一般不需要显式继承object，因为所有的类默认就是新式类。与Java的Object类类似，Python中的object类也提供了一些通用的方法，这些方法可以在自定义类中使用或者覆盖：

1. __str__()方法： 类似于Java中的toString()方法，它返回对象的字符串表示形式。

def __str__(self):
    return "This is a custom object"

2. __eq__()方法： 用于比较两个对象是否相等。默认的实现是比较对象的身份标识（identity），即是否指向同一内存地址。可以根据实际需要覆盖该方法。

def __eq__(self, other):
    if isinstance(other, MyClass):
        return self.some_value == other.some_value
    return False

3. __hash__()方法： 返回对象的哈希码值。与Java中的hashCode()类似，用于在散列表等数据结构中使用。

def __hash__(self):
    return hash(self.some_value)

4. __repr__()方法： 返回对象的“官方”字符串表示，通常是一个可以用来重建对象的表达式。

def __repr__(self):
    return f"MyClass({self.some_value})"

这些方法在Python中的使用与Java中的Object类的方法类似，但是命名方式略有不同。在Python中，双下划线（__）表示特殊方法（也称为魔法方法或魔术方法），用于实现类的特殊行为。

注意事项和建议与Java类似：

• __eq__()和__hash__()一致性： 如果两个对象通过__eq__()方法相等，那么它们的__hash__()值应该相等，以确保在使用散列表等数据结构时能够正确地工作。

• __str__()和__repr__()可读性： 类似于Java中的toString()方法，这两个方法的实现应该返回清晰、简洁且可读性强的字符串。

魔术方法

你可能注意到了，上述出现的所有方法均以两个短横线开始或结束，这便是python中的魔术方法，它们大多数都来自object类，下面是一些常见的魔术方法参考表格：

魔术方法	描述
__init__(self, ...)	初始化对象，在创建对象时调用
__del__(self)	删除对象时调用
__str__(self)	返回对象的字符串表示
__repr__(self)	返回对象的“官方”字符串表示，用于开发和调试
__len__(self)	返回对象的长度，使用内置的len()函数时调用
__getitem__(self, key)	定义获取元素的行为，例如obj[key]
__setitem__(self, key, value)	定义设置元素的行为，例如obj[key] = value
__delitem__(self, key)	定义删除元素的行为，例如del obj[key]
__iter__(self)	定义迭代器的行为，使对象可迭代
__next__(self)	定义迭代器的next方法，返回下一个迭代值
__contains__(self, item)	定义成员测试行为，例如item in obj
__call__(self, ...)	实例对象可调用，类似函数调用的行为
__eq__(self, other)	定义相等比较的行为，例如obj == other
__ne__(self, other)	定义不相等比较的行为，例如obj != other
__lt__(self, other)	定义小于比较的行为，例如obj < other
__le__(self, other)	定义小于等于比较的行为，例如obj <= other
__gt__(self, other)	定义大于比较的行为，例如obj > other
__ge__(self, other)	定义大于等于比较的行为，例如obj >= other
__add__(self, other)	定义加法行为，例如obj + other
__sub__(self, other)	定义减法行为，例如obj - other
__mul__(self, other)	定义乘法行为，例如obj * other
__truediv__(self, other)	定义真除法行为，例如obj / other
__floordiv__(self, other)	定义整除法行为，例如obj // other
__mod__(self, other)	定义取模行为，例如obj % other
__pow__(self, other[, modulo])	定义幂运算行为，例如obj ** other
__enter__(self)	在进入with语句块时调用，用于资源的初始化和分配
__exit__(self, exc_type, exc_value, traceback)	在离开with语句块时调用，用于资源的释放和清理
__setattr__(self, name, value)	在设置属性时调用，例如obj.attr = value
__getattr__(self, name)	在获取不存在的属性时调用，例如obj.nonexistent_attr

类属性使用

在Python中，类属性是属于类而不是类的实例的属性。它们是在类定义中声明的变量，而不是在类的实例中创建的。所有属于类的实例共享相同的类属性。

class CarClass:
    # 类属性
    num_wheels: int = 4

    def __init__(self, make, model) -> None:
        # 实例属性
        self.make = make
        self.model = model

if __name__ == "__main__":
    # 创建两个 Car 实例
    car_one: CarClass = CarClass("Toyota", "Camry")
    car_two: CarClass = CarClass("Honda", "Accord")

    # 访问实例属性
    print(car_one.make)  # 输出: Toyota
    print(car_two.model)  # 输出: Accord


    # 访问类属性（使用类名或实例都可以）
    print(CarClass.num_wheels)  # 输出: 4
    print(car_one.num_wheels)  # 输出: 4
    print(car_two.num_wheels)  # 输出: 4


    # 修改类属性（注意这会影响所有实例）
    CarClass.num_wheels = 6

    # 检查修改后的类属性
    print(CarClass.num_wheels)  # 输出: 6
    print(car_one.num_wheels)  # 输出: 6
    print(car_two.num_wheels)  # 输出: 6

需要注意的是：类属性不会被实例化给每个对象，而是被所有该类的实例所共享。当你创建一个类属性时，它属于类本身，而不是类的实例。所有通过该类创建的实例都可以访问和共享相同的类属性。

在Python中，实例在访问属性时首先查找实例本身是否有该属性，如果没有，它会继续查找类的属性。这就是为什么实例可以访问类属性的原因。

实例属性遮蔽

接下来考虑以下问题：

我们在 CarClass.num_wheels = 6 前增加一行代码 car_one.num_wheels = 233，此时运行代码将会的出什么结果呢？

当你运行 car_one.num_wheels = 233时，它会创建一个新的实例属性 num_wheels，而不是修改类属性。这是因为在 Python 中，如果你为实例赋值一个属性，它会在实例上创建一个同名的属性，而不会影响到类属性。这就是实例属性遮蔽

self引用实例对象

在 Python 中，self 是一个惯例，用于表示对象实例本身。它是在类的方法中作为第一个参数传递的，但在调用该方法时不需要显式传递。self 提供了一种引用对象实例属性和方法的方式

但是self 的命名并不是强制的，你可以使用其他名称，但 self 是一个广泛接受的约定，因此建议在大多数情况下使用它（不推荐自己定义，应使用self或团队，公司的约定）。如以下不推荐的自定义示例：

class TestClass:
    def __init__(my_self, value):
        my_self.value = value

    def printf(my_self):
        print(my_self.value)


obj = TestClass(233)
obj.printf()