类和魔术方法，例如__str__等方法快速了解

已于 2024-02-18 19:59:38 修改
阅读量846 收藏 17
点赞数 18
分类专栏： python语言学习 文章标签： python 开发语言
于 2024-02-14 13:24:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Timmy9991/article/details/136005865
版权

“师傅领进门，修行在个人”      

        本帖子在于让大家快速知道魔术方法是怎么个情况，同时又不让介绍魔术方法又变得太过与抽象。所以本文主要通过例子去介绍魔术方法，并且着重介绍几个类别的魔术方法，但不会追求面面俱到，把所有魔术方法都介绍一遍。学习这种事情，用到的时候再查也是一种策略。

以下是我们常见的一个类的例子：

class dog:

        def __init__(self, name , age):

                self.name = "tom"

                self.age = 5

        def speak(self, words = "wo, wo, wo"):

                print(words)

        def jump(self, ):

                pass

        这个类定义一条狗，对这个类进行实例化之后，Python会自动首先执行类里面的__init__(self, name, age) 方法，对吧。不信？ 你debug试试。这里的__init__()方法其实就是魔术方法之一。

        所谓魔术方法就是在类中的，在python中预定义了的名称的方法。这些预定义名称都是在python中约定好了的，被占用了名称的方法。例如最常见的__init__()方法，对吧。你如果指定了一个方法叫这个名字，那python默认这就是初始化功能的方法，会在实例化过程自动首先执行。

        在python里面还有许多带双下划线的名称已经被python内部预订好了。这些名字只能做特定一类功能实现的方法名字。

注意，我下面写的a, b 全是你要定义的类名称，非一般的变量名。

例如__format__()        

        当使用formation(a)函数的时候会自动调用a这个类中的__format__方法

        __str__()

        当使用例如pycharm这种IDE工具去执行print(a)这个函数的时候，会自动调用a类中的__str__方法，当然，前提是你已经在a中写好了这个方法

        __add__()

        当使用a + b这种语句的时候，python会自动在 + 符号的左侧的a类中调用a的__add__（self, other）方法, 这里的other参数就是等待被传入的 b

        __sub__()

        当使用a - b这种语句的时候，python会自动在 - 符号的左侧的a类中调用a的__sub__（self, other）方法, 这里的other参数就是等待被传入的 b

        __mul__()

        当使用a * b这种语句的时候，python会自动在 * 符号的左侧的a类中调用a的__mul__（self, other）方法, 这里的other参数就是等待被传入的 b

        __floordiv__()

        当使用a // b这种语句的时候，python会自动在 // 符号的左侧的a类中调用a的__floordiv__（self, other）方法, 这里的other参数就是等待被传入的 b。这个方法就是将除法的结果向下取整数。

        

        不仅仅是一批上面的这种算术运算符方法，还有一些事比较用途的方法。如

       __eq__()

        当使用a == b这种语句的时候，python会自动在 == 符号的左侧的a类中调用a的__eq__（self, other）方法, 这里的other参数就是等待被传入的 b

        __gt__()

        大于测试方法。使用>运算符时调用该方法。根据对称性规则，如果你只需要与同类的对象进行比较，则不需要实现此方法。

        以上都是一些方法的列举，方法有很多，可以查一些资料。

        以上的这些方法，会在使用特殊函数等操作于某个类的时候，这某个类中的特定的魔术方法会被自动调用。例如这里我定义了一个point类。

class dog:

    def __init__(self,d):
        self.d = d

    def __repr__(self):    # 这个魔术方法仅在用IDLE窗口中交互时，才会调用这个方法。

        return 'dog(' + str(self.d) + ')'

    def __gt__(self, other):

        if type(other) == dog:
            return self.d > other.d
        else:
            return self.d > other

    def __lt__(self, other):
        if type(other) == dog:
            return self.d < other.d
        else:
            return self.d < other
    def __str__(self):   
         s = "tom"
         return s

        先别管这个类里面的__lt__等你不太熟悉的方法。看看这个__str__()的方法，这个方法就是在运行print（dog(5)）这种语句的时候，python会自动调用dog中的__str__()方法，从而打印出“tom”。

        好了，看完这个打印实例化的类的例子之后，我们再看一些例子。就是将整数与类进行排序。有的人肯定会好奇，整数与类怎么排序呢？首先，理解这一点的关键在于，整数在python中是对象，类在python中也是对象，一切皆对象嘛！第二点关键在于，当使用sort()这个函数的时候，python会自动调用dog类中的__lt__()和__gt__()方法来比较dog类中能够与整数发生比较的“量”与整数的大小关系。例如上述的__lt__()方法中，会将dog类中的实例变量self.d与整数进行比较。

        好了，下面就是例举的代码和运行结果。最好你自己去debug一下，印象深刻。

d1, d5, d10 = dog(1), dog(5), dog(10)
a_list = [50, dog(5), 100, dog(1), -20, dog(10), 3]
a_list.sort()
print(a_list)

>>[-20, dog(1), 3, dog(5), dog(10), 50, 100]

        好了，到了这里，以上的内容就是给你一个快速的，在整体上对魔术方法有所了解的介绍。对于目前只想有个大概了解的你，可以先不用往下看，以后有时间你再看也不迟。下面的内容是对魔术方法进行更加详细的分类，以及各种类别的魔术方法是如何运行的。内中会牵涉到一些针对特定问题的特定内容。例如反向方法，有点懵没事，后面你就懂了。

比较方法

        这些魔术方法是在遇到>，<， >=， <=，==这样的符号的时候，会被自动调用。在一个类中至少应该实现相等比较的方法。

        我不想像一般的书籍那样先对一个一个的魔术方法区用文字介绍，或者列一个表格集中介绍。这样的话，对于新手来说，会让人懵逼，效率很低。我先列出一个类的例子。然后再类中的各个方法里面用注释来介绍，这样好理解一些。

class dog:

    def __init__(self, n):
        self.n = n

    def __cmp__(self, other):
        """
        该方法已经被python3.0或者更高版本丢弃了。在2.0版本中的方法，
        这个方法是通过返回-1、0或者1来分别实现小于、等于、大于的功能的
        """
        pass

    def __eq__(self, other):
        """
        使用==运算符时候，会自动调用这个方法来测试两边内容是否相等
        方法返回True或者False
        如果没有在你的类里面定义这个方法，则python会使用is运算符
        """
        return self.n == other.n

    def __ne__(self, other):
        """
        在使用！=运算符的时候，python调用该方法测试内容是否不相等。
        该方法返回True或者False。如果没有你在你的类里面没有定义这个方法，
        python将会自动调用__eq__方法，然后取结果的相反值。因此，一般情况下，
        实现__eq__方法就足够了。
        """
        return self.n != other.n

    def __lt__(self, other):
        """
        当使用<运算符号时候，python调用这个方法。
        如果只用于对包含同类对象的集合进行排序，实现本方法就足够了。
        如果要对包含不同类对象的集合进行排序，还需要实现__gt__方法。
        """
        return self.n < other.n

    def __gt__(self, other):
        """
        当使用<运算符号时候，python调用这个方法。
        如果只用于对包含同类对象的集合进行排序，则不需要这个方法。
        如果要对包含不同类对象的集合进行排序，一定要这个方法。后面我会举一个计算例子让大家看到
        """
        return self.n > other.n

    def __le__(self, other):
       """
       使用<=运算符时候，调用该方法。即使实现了__eq__和__lt__方法，也不会自动提供__le__方法。
       原则上，每个比较运算符都必须在类中分别实现。
       不过对于相同类对象进行比较，即使没有定义这个方法，如果有定义了后面的__ge__方法，
       则可以通过__ge__方法来获得__le__方法同等的效果。
       """
       return self.n <= other.n

    def __ge__(self, other):
        """
        使用>=运算符时候，调用该方法。
        即使实现了__eq__和__gt__方法，也不会自动提供__ge__方法。
        原则上，每个比较运算符都必须在类中分别实现。
        不过,对于相同类对象进行比较，即使没有定义这个方法，如果有定义了前面的__le__方法，
        则可以通过__le__方法来获得__le__方法同等的效果。
        说白了，如果对于同一个类，__le__和__ge__只要有一个就行了。
        """
        return self.n >= other.n

运行下面的打印

print(dog(2) < dog(3))
print(dog(2) > dog(3))
print(dog(2) == dog(3))
print(dog(2) != dog(3))

得结果

True
False
False
True

        好了，为了能够使得dog类能够直接和整数或者浮点数进行比较，可以把dog改造成如下的类。这个类和上面的dog类的区别在于添加了一些if判断语句，判断作比较的另外一个对象是否和dog是同一类型的对象，不是的话，就直接用dog内部的实例变量与整数或者浮点数进行比较。

class dog:

    def __init__(self, n):
        self.n = n

    def __cmp__(self, other):
        """
        该方法已经被python3.0或者更高版本丢弃了。在2.0版本中的方法，
        这个方法是通过返回-1、0或者1来分别实现小于、等于、大于的功能的
        """
        pass

    def __eq__(self, other):
        """
        使用==运算符时候，会自动调用这个方法来测试两边内容是否相等
        方法返回True或者False
        如果没有在你的类里面定义这个方法，则python会使用is运算符
        """
        if isinstance(other, dog):
            return self.n == other.n
        else:
            return self.n == other

    def __ne__(self, other):
        """
        在使用！=运算符的时候，python调用该方法测试内容是否不相等。
        该方法返回True或者False。如果没有你在你的类里面没有定义这个方法，
        python将会自动调用__eq__方法，然后取结果的相反值。因此，一般情况下，
        实现__eq__方法就足够了。
        """
        return self.n != other.n

    def __lt__(self, other):
        """
        当使用<运算符号时候，python调用这个方法。
        如果只用于对包含同类对象的集合进行排序，实现本方法就足够了。
        如果要对包含不同类对象的集合进行排序，还需要实现__gt__方法。
        """
        if isinstance(other, dog):
            return self.n < other.n
        else:
            return self.n < other

    def __gt__(self, other):
        """
        当使用<运算符号时候，python调用这个方法。
        如果只用于对包含同类对象的集合进行排序，则不需要这个方法。
        如果要对包含不同类对象的集合进行排序，一定要这个方法。后面我会举一个计算例子让大家看到
        """
        if isinstance(other, dog):
            return self.n > other.n
        else:
            return self.n > other

    def __le__(self, other):
        """
        使用<=运算符时候，调用该方法。即使实现了__eq__和__lt__方法，
        也不会自动提供__le__方法。
        原则上，每个比较运算符都必须在类中分别实现。
        不过对于相同类对象进行比较，即使没有定义这个方法，如果有定义了后面的__ge__方法，
        则可以通过__ge__方法来获得__le__方法同等的效果。
        """
        if isinstance(other, dog):
            return self.n <= other.n
        else:
            return self.n <= other

    def __ge__(self, other):
        """
        使用>=运算符时候，调用该方法。
        即使实现了__eq__和__gt__方法，也不会自动提供__ge__方法。
        原则上，每个比较运算符都必须在类中分别实现。
        不过,对于相同类对象进行比较，即使没有定义这个方法，如果有定义了前面的__le__方法，
        则可以通过__le__方法来获得__le__方法同等的效果。
        说白了，如果对于同一个类，__le__和__ge__只要有一个就行了。
        """
        if isinstance(other, dog):   
            return self.n >= other.n
        else:
            return self.n >= other

打印一些结果

print(dog(2) < 3)
print(dog(2) <= 3)
print(dog(2) >= 3)

结果：

True
True
False
 

好了，我们试着用一下sort()函数来对一个既包含整数，也包含dog实例化类的列表进行排序。

d5,d1,d10 = dog(5), dog(1), dog(10)
a_list = [50,d5, 100, d1, -20, d10, 3]
a_list.sort()
print(a_list)

结果是

[-20,
 <__main__.dog at 0x1a17741ce20>,    # 就是dog(5)
 3,
 <__main__.dog at 0x1a17741cd90>,    # 就是dog(1)
 <__main__.dog at 0x1a17741cee0>,    # 就是dog(10)
 50,
 100]

算术运算符方法

我还是通过写出一个类作为例子来说明这种魔术方法

class point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        """
        加法。当出现“+”符号的时候，python会自动调用此方法。
        other就是对右侧操作数的引用
        没有这个方法的时候，就会自动调用__radd__方法
        """
        newx = self.x + other.x
        newy = self.y + other.y
        return point(newx, newy)

    def __sub__(self, other):
        """
        类似上述描述，你懂的
        """
        dx = self.x - other.x
        dy = self.y - other.y
        return (dx ** 2 + dy ** 2) ** 0.5

    def __mul__(self, n):
        """
        类似上述加法描述，你懂的
        """
        newx = self.x * n
        newy = self.y * n
        return point(newx, newy)

    def __str__(self):
        """
        为了打印方便，这里定义一个能够被print调用的方法
        没有这个方法的时候，pthon会自动调用下面的__repr__方法
        你可以自己去掉这个方法试试
        """
        s = str(self.x) + ', ' + str(self.y)
        return s

    def __repr__(self):
        s = "point(" + str(self.x) + ', ' + str(self.y) + ')'
        return s

运行下面代码

pt1 = point(10, 15)
pt2 = point(0, 5)
x = pt1 + pt2
print(x)

出现一下结果

>>10, 20

        其实，算术运算符方法不止加法，减法，乘法等，还有向下取整数__floordiv__(), 普通除法__truediv__(), 求除数和余数__divmod__, 幂运算__pow__.

        好了，下面介绍一元算术方法

一元算术方法

        同样地，还是举例子，不过只是在上面的point类里面加入一些一元算术方法而已。如下，是更加完整的类。

class point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        """
        加法。当出现“+”符号的时候，python会自动调用此方法。
        other就是对右侧操作数的引用
        没有这个方法的时候，就会自动调用__radd__方法
        """
        newx = self.x + other.x
        newy = self.y + other.y
        return point(newx, newy)

    def __sub__(self, other):
        """
        类似上述描述，你懂的
        """
        dx = self.x - other.x
        dy = self.y - other.y
        return (dx ** 2 + dy ** 2) ** 0.5

    def __mul__(self, n):
        """
        类似上述加法描述，你懂的
        """
        newx = self.x * n
        newy = self.y * n
        return point(newx, newy)

    def __str__(self):
        """
        为了打印方便，这里定义一个能够被print调用的方法
        没有这个方法的时候，pthon会自动调用下面的__repr__方法
        你可以自己去掉这个方法试试
        """
        s = str(self.x) + ', ' + str(self.y)
        return s

    def __repr__(self):
        s = "point(" + str(self.x) + ', ' + str(self.y) + ')'
        return s

    def __neg__(self):
        """
        取负值
        """
        newx = -self.x
        newy = -self.y
        return point(newx, newy)

    def __trunc__(self):
        """
        去掉小数部分，只取整数部分，注意要和向上取整和向下取整区别开来。
        """
        newx = self.x.__trunc__()
        newy = self.y.__trunc__()
        return point(newx, newy)

运行下面代码

pt1 = point(3,4)
pt2 = -pt1
print(pt2)

结果是

-3, -4

再运行下面代码

import math
pt3 = point(5.3, 5.6)
print(math.trunc(pt3))

结果是

5, 5

        和其他类型的算术方法一样，一元算术方法还有一元正号__pos__, 绝对值__abs__, 按位求反__invert__, 将值转换为布尔值__bool__, 按照精度舍入__round__, 向下舍入__floor__, 向上舍入__ceil__。这些方法分别对应于当用这些函数或者符号的时候会被采用：+， abs()， ~， bool(), round(), math.floor(), math.ceil()。

反向方法

        所谓反向方法就是当正向方法如__add__(), __mul__()等未在左边对象中被定义或者这些方法在左侧对象被调用并在运行过程中出现NotImplemented的时候（类似于报错，但不是报错）才会被调用，是用来“补救”调用左侧对象中的方法过程中出现了障碍后的一种备选方案。

这里我依然举例子。

class point:
    
    def __init__(self, x, y,z):
        self.x = x
        self.y = y
        self.z = z
        
    def __str__(self):
        s = str(self.x)+", " + str(self.y)+", " +str(self.z)
        return s
    
    def __repr__(self):
        s = "point(" + str(self.x) + "," + str(self.y)+ "," + str(self.z) + ")"
        return s
    
    def __add__(self, other):
        if type(other) == point:
            new_x = self.x + other.x
            new_y = self.y + other.y
            new_z = self.z + other.z
        else:
            new_x = self.x + other
            new_y = self.y + other
            new_z = self.z + other 
        return new_x, new_y, new_z
    
    def __radd__(self, other):
        new_x = self.x + other
        new_y = self.y + other
        new_z = self.z + other 
        return new_x, new_y, new_z
    
    def __sub__(self,other):
        if type(other) == point:
            new_x = self.x - other.x
            new_y = self.y - other.y
            new_z = self.z + other.z
        else:
            new_x = self.x - other
            new_y = self.y - other
            new_z = self.z - other 
        return new_x, new_y, new_z

    def __rsub__(self,other):

        new_x = other - self.x
        new_y = other - self.y
        new_z = other - self.z
        return new_x, new_y, new_z
    
    def __mul__(self, other):
        if isinstance(other, point):
            new_x = self.x * other.x
            new_y = self.y * other.y
            new_z = self.z * other.z
            return point(new_x,new_y,new_z)
        elif isinstance(other, (int, float)):
            new_x = self.x * other
            new_y = self.y * other
            new_z = self.z * other
            return point(new_x,new_y,new_z)
        else:
            return NotImplemented
        
    def __rmul__(self, other):
        if isinstance(other, (int, float)):
            new_x = self.x * other
            new_y = self.y * other
            new_z = self.z * other
            return point(new_x, new_y, new_z)
        else:
            return NotImplemented

        这里我先介绍一下当运行3 + point(1,2,3) 语句时候，是怎么运行的。首先python会实例化point这个类自不必说，然后python会自动调用+左边的对象3中的__add__方法，python会发现其整数不能与point进行相加运算的。然后python就去调用右侧对象中的__radd__方法，这样就能够如常进行了。上述分析对于__rmul__， __rsub__等这样的方法是一样的。例如对于3 * point(1,2,3)这样的情况。

好了运行上面的 3 + point(1,2,3) 语句结果如下。

(4, 5, 6)

运行上面的 3 * point(1,2,3) 结果如下。

point(3,6,9)

就地运算符

        这份方法很简单，我快速介绍一下。

__iadd__(self, other)    遇到 += 符号时候被调用

__isub__(self, other)    遇到 -= 符号时候被调用

__imul__(self, other)    遇到 *= 符号时候被调用

__idiv__(self, other)    遇到 /= 符号时候被调用

__igrounddiv__(self, other)    遇到 //= 符号时候被调用

__imod__(self, other)    遇到 %= 运算符时候被调用

__ilshift__(self, other)    遇到 <<= 运算符时候被调用

__irshift__(self, other)    遇到 >>= 运算符时候被调用

__iand__(self, other)    遇到 &= 运算符时候被调用

__ior__(self, other)    遇到 |= 运算符时候被调用

__ixor__(self, other)    遇到 ^= 运算符时候被调用

__ipow__(self, other, [, modulo])    遇到 ** 运算符时候被调用

详细说明__iadd__()方法是如何被定义的如下

def __iadd__(self, other):

        self.x += other.x

        self.y += other.y

        return self

def __imul__(self, other):

        self.x *= other

        self.y *= other

        return self

        没错，你看到的就是这些方法会返回实例对象self本身。

好了，其他种类的魔术方法还有

转换方法

集合类方法

__iter__和__next__方法

        这里不再详述，遇到了，今后再自行百度等。相信要是熟悉了上面的一些魔术方法，其他的魔术方法应该很快能够从总体上去把握和理解。

Timmy9991
关注
  • 18
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
PHP魔术方法__GET、__SET使用实例
10-25
主要介绍了PHP魔术方法__GET、__SET使用实例,本文在代码中做了详细的注释,需要的朋友可以参考下
PHP 5.3新增魔术方法__invoke概述
10-25
主要介绍了PHP 5.3新增魔术方法__invoke,需要的朋友可以参考下
python类：magic魔术方法
皮皮blog
02-21 5420
http://blog.csdn.net/pipisorry/article/details/50708812魔术方法是面向对象Python语言中的一切。它们是你可以自定义并添加“魔法”到类中的特殊方法。它们被双下划线环绕（比如__init__或__lt__）。在Python中，我们可以通过”魔术方法”使自定义的class变得强大、易用。例如当我们想定义一个可迭代的类对象的时候，就可以去实现”__
python __reduce__魔法方法_Python魔法方法指南
weixin_39973271的博客
11-28 281
(译)Python魔法方法指南简介本指南归纳于我的几个月的博客，主题是 魔法方法 。什么是魔法方法呢？它们在面向对象的Python的处处皆是。它们是一些可以让你对类添加“魔法”的特殊方法。它们经常是两个下划线包围来命名的（比如 __init__ ， __lt__ ）。但是现在没有很好的文档来解释它们。所有的魔法方法都会在Python的官方文档中找到，但是它们组织松散。而且很少会有示例（有的是无聊的...
python特殊函数之__call__函数的作用
AI浩
08-23 2008
将一个类实例也可以变成一个可调用对象。
PHP魔术方法之__call与__callStatic使用方法
10-19
主要介绍了PHP魔术方法之__call与__callStatic方法,需要的朋友可以参考下
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1450
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
GLM+vLLM 部署调用
qq_38915354的博客
06-13 1122
vLLM 框架是一个高效的大型语言模型（LLM）推理和部署服务系统
2024 年最新基于 LLOneBot NT 框架搭建 QQ 机器人详细教程（更新中）
唤醒手腕的博客
06-14 572
llonebot（LLOneBot）是一个与OneBot（也称为CQHTTP）协议兼容的机器人框架，它允许开发者使用不同的编程语言（如Python、Go、JavaScript等）编写机器人应用，并与各种支持 OneBot 协议的聊天平台（如QQ、Telegram、Discord等）进行交互。onebot 11 背景。
第9章 类
最新发布
我走的每一步都算数
06-17 608
让一个类继承另一个类后，就可以添加区分子类和父类所需的新属性和新方法了。class Car:class ElectricCar(Car): # 继承Carself.battery = 85 # 新属性mycar = ElectricCar(2024, 'Au', 'A7') # 创建实例mycar.prt_battery() # 新方法熟悉Python 提供的选项，这样才能确定哪种组织方式是最佳的，并能理解别人开发的项目。
找出Python潜在的编程问题
svygh123的专栏
06-13 1048
Pylint 是一个非常强大的静态代码分析工具，主要用于检查 Python 代码的语法错误、代码风格问题以及潜在的编程错误。它是 Open Source Initiative 认证的开源软件，由 Logilab 团队开发维护。
LeetCode | 28.找出字符串中第一个匹配项的下标 KMP
编程菜鸟的学习记录
06-14 299
LeetCode | 28.找出字符串中第一个匹配项的下标 KMP
python迁移数据教程
2402_85292291的博客
06-13 663
if os.path.isfile(src_item_path): dest_item_path = os.path.join(dest_folder, item) shutil.copy2(src_item_path, dest_item_path) # 如果item是目录，递归调用migrate_data函数。2. 准备源文件夹和目标文件夹： 在您的计算机上创建两个文件夹，分别为源文件夹（source_folder）和目标文件夹（destination_folder）。将您希望迁移的数据放入源文件夹。
YesPMP探索Python在生活中的应用，助力提升开发效率
YesPMP20的博客
06-13 793
Python是一种简单易学、高效强大的编程语言，正变成越来越多人选择的热门技能。学习Python不仅可以提供更多就业机会，还能让自己在职场更加有竞争力，那可以去哪里拓展自己的技能呢？
每日一题42：最小化字符串长度
m0_63227758的博客
06-14 453
创建集合s = set() # 创建一个空集合s = {1, 2, 3} # 创建一个包含元素 1, 2, 3 的集合s = set([1, 2, 3]) # 通过列表创建集合# 添加和删除元素s.add(4) # 向集合中添加元素 4s.remove(3) # 从集合中删除元素 3，如果元素不存在则会引发 KeyErrors.discard(2) # 从集合中删除元素 2，如果元素不存在也不会报错# 集合运算intersection = s1 & s2 # 交集。
深入理解Python多进程
这家伙很懒，什么都没有留下
06-12 736
本文深入介绍了Python多进程编程的基础概念、实现原理、使用方法以及实战案例。通过本文的学习，读者可以全面理解和掌握Python多进程编程的相关知识，并能够在实际项目中应用多进程技术来提高程序的执行效率。需要注意的是，虽然多进程技术能够带来性能上的提升，但也会带来一些额外的问题和复杂性，如进程间通信、进程同步等。因此，在使用多进程技术时，需要根据实际情况进行权衡和选择。
paddleocr实验过程
mddCSDN的博客
06-11 405
切割后的数据在train_data中，注意切割后的数据前缀默认是当前目录，因此建议切割数据在liunx中进行。或者修改下面--datasetRootPath中的default。如果在Win中切割，放入liunx中训练。1、打开tmux窗口启动，这样断开连接后台可以继续训练。2、根据需求修改配置文件，如输出名称，数据集位置，注意暂时不要改吧epoch，训练容易报错。建议在liunx中指定。
Python基础速成
weixin_74163644的博客
06-11 428
文件操作 文件读取 with open语法 文件写入 注意事项 文件追加 异常、模块与包 捕获异常 捕获方法 捕获传递 模块的导入与自定义 定义 导入方式 自定义 测试模块 注意事项 python包 定义 操作 第三方包 定义 pip指令安装包
请实现一个类，并在类中实现魔术方法__str__代码
06-10
好的，下面是一个简单的 Python 类，并在其中实现了魔术方法 `__str__`： ```python class MyClass: def __init__(self, name): self.name = name def __str__(self): return f"My name is {self.name}" # ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值