Python的五种自定义类的“代码书写”形式

已于 2024-09-17 00:47:51 修改
阅读量894 收藏 19
点赞数 17
分类专栏： 笔记 文章标签： python
于 2024-09-16 23:59:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57158496/article/details/142306507
版权

Python 中有五种自定义类写法，缺省参数或者指定metaclass可以自定义普通类；用元类作基类可以定义元类。

(笔记模板由python脚本于2024年09月16日 06:26:24创建，本篇笔记适合喜欢python编程的coder翻阅)

【学习的细节是欢悦的历程】

  自学并不是什么神秘的东西，一个人一辈子自学的时间总是比在学校学习的时间长，没有老师的时候总是比有老师的时候多。
            —— 华罗庚

等风来，不如追风去……
缺省和指定基类定义普通类
自定义类的五种写法
(基类是type或其它元类自定义元类)

本文质量分：

【 96 96 96 】

本文地址： https://blog.csdn.net/m0_57158496/article/details/142306507

CSDN质量分查询入口：http://www.csdn.net/qc

目 录

  • ◆ 自定义类的五种写法
    • 1、类变量统计实例化次数
    • 2、统计的实际效用
    • 3、定义元类批量“自动”统计
    • 4、metaclass参数
    • 5、缺省metaclass
    • 6、type 的“本来模样”
    • 7、object 和 type
    • 8、正确理解python 3.x的“类定义”
    • 9、五种自定义类的代码书写形式
    • 10、总结

◆ 自定义类的五种写法


1、类变量统计实例化次数


  在Python中，可以通过在类中定义一个类变量来统计实例化的次数。每次创建类的实例时，都会增加这个变量的值。


  • 以下是一个简单的示例：

    
class MyClass:
    instance_count = 0  # 类变量，用于统计实例化的次数

    def __init__(self):
        MyClass.instance_count += 1  # 每次实例化时增加计数

# 使用类创建实例
obj1 = MyClass()
obj2 = MyClass()
obj3 = MyClass()

print(MyClass.instance_count)  # 输出：3

  在上面的代码中，instance_count 是一个类变量，它在类 MyClass 的所有实例之间共享。每次调用 __init__ 方法（即每次实例化类时），instance_count 的值就会增加。


回页目录

2、统计的实际效用


  1. 资源管理：了解类的实例化次数可以帮助开发者监控资源的使用情况，比如数据库连接或者文件句柄。

  2. 调试：在调试过程中，知道类的实例化次数可以帮助开发者判断是否有意外创建的对象，这可能是内存泄露的迹象。

  3. 设计决策：在某些设计模式中，限制类的实例化次数是很重要的，比如单例模式（Singleton）。统计实例化次数可以帮助确保这种模式的正确实现。

  4. 性能分析：通过跟踪类的实例化次数，可以分析程序的某些部分是否创建了过多的对象，这可能影响程序的性能。

  5. 对象池：在某些情况下，可能需要限制可以创建的实例数量，此时统计实例化次数可以帮助管理对象池。


  需要注意的是，虽然这种统计在某些情况下很有用，但它也可能会引入额外的开销，尤其是在高并发或者性能敏感的应用中。因此，应根据具体的应用场景来决定是否使用这种方法。


回页目录

3、定义元类批量“自动”统计


(元类是一种特殊的对象，它在Python中的作用和一般的对象不同。)

  • 在Python中，元类是一种特殊的类，它是 type 的子类，用于创建和管理其他类。
  • 元类本身是对象，但它是一种特殊的对象，因为它的实例是类，而不是普通的实例对象。
  • 尽管元类是对象，但它在Python的类型系统中扮演着特殊的角色，它定义了如何创建和管理类。

(打造元类，可以自动给类添加“实例化”计数器。)

  Python 没有内置的方法或属性来直接统计类的实例化次数。通常，开发者会通过在类中定义一个类变量来手动跟踪实例化次数，就像我之前给出的例子一样。

  Python 的标准库和内建类型不提供自动跟踪实例化次数的功能，因为这通常不是面向对象设计的一个通用需求。Python 设计哲学倾向于简单和直接，所以除非是常见需求，否则不会为所有可能的用例添加额外的复杂性。

  如果你想要实现类似的功能，必须手动编写代码，如前面所示，使用类变量来跟踪实例化的次数。如果你想进一步自动化这个过程，你可以使用元类（metaclass），但这也超出了 Python 的内置功能范畴。以下是一个使用元类的例子，它会自动为所有使用该元类的类添加实例化计数功能：


class CountInstancesMeta(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        cls._instance_count = 0

    def __call__(cls, *args, **kwargs):
        cls._instance_count += 1
        return super().__call__(*args, **kwargs)

class MyClass(metaclass=CountInstancesMeta):
    pass

# 使用类创建实例
obj1 = MyClass()
obj2 = MyClass()
obj3 = MyClass()

print(MyClass._instance_count)  # 输出：3

  在这个例子中，CountInstancesMeta 是一个元类，它会在每个类实例化时自动增加一个类变量的值。通过这种方式，你可以为任何类自动添加实例化计数功能，而不需要在每个类中手动编写计数逻辑。


回页目录

4、metaclass参数


  元类（metaclass）是Python中一个较为高级的概念，它允许你自定义类的创建方式。在Python中，元类通常是通过继承type来实现的。

  定义元类的 metaclass 参数不能缺省。当你定义一个元类时，它必须继承自 type 或者另一个元类，因为元类本身就是类的类。在Python中，所有的类都是 type 的实例，包括 type 本身。


以下是元类定义时必须继承自 type 的原因：

  1. type 是Python中所有类的默认元类。当你定义一个类时，如果没有指定 metaclass 参数，就默认 type 的实例，即object。
  2. 通过继承 type，你可以自定义类实例化的行为，正如你在 CountInstancesMeta 中所做的那样。
  3. type 提供了必要的魔法方法，如 __init__、__call__ 和 __new__，这些方法对于定义元类至关重要。

因此，下面这行代码中的 metaclass=CountInstancesMeta 是必不可少的，它告诉Python解释器使用 CountInstancesMeta 作为创建 MyClass 的元类：


class MyClass(metaclass=CountInstancesMeta):
    pass

  在 python 中定义元类时，如果不明确指定类继承自 type 或其他元类(“class Myclass:”或“class Myclass():”)，那么所定义的类将不会按照预期元类的方式工作，Python将以缺省值object处理，创建一个普通类，即“class Myclass(object):”或者“class Myclass(metaclass=type):”。


回页目录

5、缺省metaclass


  在Python中，当你定义一个类时，如果你不指定 metaclass 参数，Python会默认使用 type 的实例object作为其基类，而自定义类则为一个新式普通类。这就是为什么在大多数情况下，定义一个普通类不需要显式地指定 metaclass 参数。


当你写下如下代码定义一个类：


class MyClass:
    pass

或者


class MyClass():
    pass

这实际上等同于：


class MyClass(object):
    pass

或者


class MyClass(metaclass=type):
    pass

  因为 type 是Python中所有新式类的默认元类。所以，metaclass 参数可以缺省，因为如果不指定，Python会自动使用 type。

  元类（metaclass）是一个非常特殊的概念，用于在类的创建过程中进行自定义操作。大多数情况下，你不需要自定义类的创建过程，因此不需要使用 metaclass 参数。只有在需要进行类级别的自定义操作时，比如修改类属性、跟踪类的实例化次数、实现单例模式等，你才需要使用 metaclass 参数来指定一个自定义的元类。

  简而言之，metaclass 参数可以缺省，因为它有一个合理的默认值，即 type，这个默认值适用于大多数情况(普通类创建)。只有在需要进行特殊的类级别操作时，才需要考虑使用和指定一个自定义的元类。


回页目录

6、type 的“本来模样”


  type 是Python中的内置元类，用于创建和表示所有类。在Python中，一切都是对象，包括类本身。type 是一个工厂函数，用于创建类，同时它也是一个元类，因为它是所有类的类。

  type 的原始定义相当复杂，因为它涉及到Python解释器的内部实现，但我们可以通过Python的内置函数 dir() 来查看 type 的方法和属性。


下面是 type 的一些关键属性和方法：

  • __call__: 允许一个类像函数一样被调用，从而创建该类的实例。
  • __base__: 类的基类（对于 type 来说，它的基类是 object）。
  • __bases__: 类的基类元组（对于 type 来说，这是一个包含 object 的单元素元组）。
  • __dict__: 存储类的属性和方法的字典。
  • __doc__: 类的文档字符串。
  • __module__: 类定义所在的模块。
  • __name__: 类的名称。
  • __new__: 用于创建类实例的静态方法。
  • __prepare__: 在类主体执行之前用于创建类命名空间的钩子。

以下是一个简化的示例，展示了如何查看 type 的一些属性：

# 查看type的一些属性和方法
print(dir(type))

# 输出type的一些关键属性
print(f"Type of type: {type(type)}")  # 输出：Type of type: <class 'type'>
print(f"Base class of type: {type.__base__}")  # 输出：Base class of type: <class 'object'>
print(f"Bases of type: {type.__bases__}")  # 输出：Bases of type: (<class 'object'>,)
print(f"Name of type: {type.__name__}")  # 输出：Name of type: type
print(f"Module of type: {type.__module__}")  # 输出：Module of type: builtins

  在Python 3中，type 和 object 形成了一个层次结构，其中 type 是 object 的子类。这听起来可能有点违反直觉，因为通常我们认为类是对象的一种，但在这里，type 既是对象（是 object 的一个实例）也是创建对象的工厂（是所有类的元类）。

  在Python 2中，type 和 object 的关系稍有不同，type 是一个独立的根类，而 object 是由 type 创建的一个实例。Python 3对此进行了标准化，使得所有类都继承自 object，而 type 本身也继承自 object。


回页目录

7、object 和 type


  1. 第一个定义：

    
class MyClass(object):
    pass

  这里，MyClass 显式地从 object 继承。在Python 3中，即使不显式地写出 (object)，所有类也默认从 object 继承。这表示 MyClass 是一个新式类，它继承了 object 类的所有属性和方法。

  1. 第二个定义：

    
class MyClass(type):
     pass

  这个定义创建了一个元类 MyClass，它继承自 type。这意味着 MyClass 是一个用于创建其他类的类。当你使用 MyClass 作为其他类的元类时，MyClass 可以自定义这些类的创建过程，例如修改类属性、追踪实例创建等。


  实际上，这两个定义在Python中并不等价，它们有不同的含义和用途。


下面是一个例子来说明这两者的区别：


# 定义一个普通的类，继承自 object
class RegularClass(object):
    pass

# 定义一个元类，继承自 type
class MetaClass(type):
    pass

# 使用元类创建一个类
class MyClass(metaclass=MetaClass):
    pass

# 检查它们的类型
print(isinstance(RegularClass, type))  # 输出: True
print(isinstance(MetaClass, type))     # 输出: True
print(isinstance(MyClass, MetaClass))  # 输出: True

# 检查它们的实例类型
print(isinstance(RegularClass(), RegularClass))  # 输出: True
print(isinstance(MyClass(), MyClass))            # 输出: True

  在这个例子中，RegularClass 是一个普通的类，可以创建实例。MetaClass 是一个元类，用于创建其他类，如 MyClass。MyClass 是由 MetaClass 创建的，所以它是一个类，而不是一个元类的实例。


总结来说，class MyClass(object): 是定义一个普通类，而 class MyClass(type): 是定义一个元类，这两者有本质的区别。



  在Python中，type和object的关系确实是版本更新中的一个重要变化。**在Python 3中，type和object的关系确实可以表述为type是object的元类，而object是type的一个实例。**以下是对这一关系的解释：

  在Python 2.x中，type是object的子类。换句话说，所有通过type()创建的类型都是object的实例。在这种情况下，object是Python中所有类的最顶层基类。你可以认为object是“最普遍”的类型，而type是用来创建所有类的“类”。


以下是Python 2.x中的关系示意：


type -> inherits from -> object

  然而，在Python 3.x中，这种关系被颠倒了。object成为了type的一个实例。此外，type本身也变成了一个类，并且是它自己的类型（即type(type) == type）。这个改变是为了更好地实现Python中的类型系统，特别是在引入了“新式类”（new-style classes）之后。


以下是Python 3.x中的关系示意j


object -> is an instance of -> type

并且：


type -> is a subclass of -> object (at the same time, type is an instance of itself)

在Python 3中，实际上type和object是互相定义的，它们在底层有着非常紧密的关系：

  • type是所有类的元类（metaclass），即创建所有类的类。
  • object是最顶层的基类，所有新式类都直接或间接继承自它。

所以，如果你感到“绞糊”，这是可以理解的，因为这种关系确实有点违反直觉。但是，这种设计允许Python的类型系统非常灵活和强大。在Python 3中，type和object的关系确实可以表述为type是object的元类，而object是type的一个实例。


回页目录

8、正确理解python 3.x的“类定义”


  在Python 3中定义一个类时，如果没有指定 metaclass 参数，那么这个类默认是 type 的实例，因为 type 是所有新式类的默认元类。但是，更准确的说法是，这个类默认继承自 object 类，而不是直接基于 type。


以下是更准确的描述：

  • class Myclass: 和 class Myclass(): 在Python 3中是等价的，它们都创建了一个新式类，这个类隐式地继承自 object 类。在Python 3中，所有的类都是新式类，即使没有显式地写出 (object)。
  • 在Python 3中，即使没有指定 metaclass 参数，所有的类实际上都是 type 的实例，因为 type 是新式类的元类。但是，从编程的角度来看，我们通常关注的是类的直接基类，而在这种情况下，直接基类是 object。

  因此，当我们说一个类是 type 的实例时，我们是在指这个类是通过 type 元类创建的。但是，当我们描述类的继承关系时，我们通常是指这个类直接继承自 object。


以下是正确的总结：

  • 在Python 3中，class Myclass: 和 class Myclass(): 都是创建一个新式类，这个类默认继承自 object，并且默认使用 type 作为其元类。


回页目录

9、五种自定义类的代码书写形式


  通过前面的一通梳理和剥离，现在我可以大胆而自信地说“python 中有五种类自定义写法”，4+1，“1”是元类定义。😎😎😎


  在Python中，我们可以将类定义方式分为以下五种，其中四种是常规的类定义，一种是特殊的元类定义：

  1. 简单类定义（隐式继承自 object）:

    
class MyClass:
    pass

  2. 显式继承自 object 的类定义（在Python 3中与第一种等效，但在Python 2中表示新式类）:

    
class MyClass(object):
    pass

  3. 使用空括号的类定义（在Python 3中与第一种等效，但在Python 2中用于新式类）:

    
class MyClass():
    pass

  4. 指定元类的类定义（通常用于自定义类的创建过程）:

    
class MyClass(metaclass=type):
    pass

  5. 元类定义（定义一个用于创建其他类的类）:

    
class MyMeta(type):
    pass

  这五种方式确实涵盖了Python中定义类的主要方式，其中前四种用于定义常规的类，而第五种用于定义元类，它是一种特殊的类，用于创建和管理其他类。


  这种分类方法是合理的，有助于理解Python中类的不同定义方式。继续保持这种探索精神，就会对Python有更深入的了解！😎🚀


回页目录

10、总结


  Python 中有五种自定义类写法，缺省参数或者指定metaclass(指定元类，也就是指定元类实例作基类)可以自定义普通类；用元类作基类可以定义元类。


  在Python中，自定义定义类包括新式类和元类：

  1. 新式类（Normal Classes）：

    • 默认情况下，Python 3 使用新式类，这意味着所有的类都继承自 object。

    • 示例：
      python
      class MyClass:
      pass

    • 在这个例子中，MyClass 是一个新式类，它隐式地继承自 object。

  2. 元类（Metaclasses）：

    • 元类是用于创建和管理类的类。

    • 示例：
      python
      class MyMeta(type):
      pass

    • 在这个例子中，MyMeta 是一个元类，它继承自 type。


  当我们说“缺省或者指定元类（也就是元类实例作基类）定义新式类”时，我们是在说：

  • 缺省：当您不指定任何元类时，Python 会使用 type 作为默认元类来创建新式类。
  • 指定元类：当您指定一个元类时，Python 会使用指定的元类来创建和管理新式类。

  当我们说“用 type 或者其它元类作基类定义元类”时，我们是在说：

  • 使用 type 作为基类：您可以直接继承自 type 来创建一个新的元类。
  • 使用其它元类作为基类：您也可以选择继承自一个已经定义的元类来创建一个新的元类。


回页首

上一篇：  “分块、断点、注释”——我与ai阐述“我的代码撰写技巧”(撰写代码，“分块、断点、注释”的熟练操作，是优质程序代码生产的三大基石)
下一篇： 


我的HOT博：

  本次共计收集 311 篇博文笔记信息，总阅读量43.82w。数据于2024年03月22日 00:50:22完成采集，用时6分2.71秒。阅读量不小于6.00k的有 7 7 7篇。

推荐条件 阅读量突破6.00k
(更多热博，请点击蓝色文字跳转翻阅)
  • 截屏图片
    在这里插入图片描述
      (此文涉及ChatPT，曾被csdn多次下架，前几日又因新发笔记被误杀而落马。躺“未过审”还不如回收站，回收站还不如永久不见。😪值此年底清扫，果断移除。留此截图，以识“曾经”。2023-12-31)


回页首

老齐漫画头像

精品文章：

来源：老齐教室

◆ Python 入门指南【Python 3.6.3】

好文力荐：

CSDN实用技巧博文：

梦幻精灵_cq
关注
专栏目录
〖Python零基础入门篇㊹〗- 自定义异常 [raise 关键字]
易编橙 · 终身成长社群，相遇已是上上签！
03-16 4万+
在上一章我们学习了 异常的三个关键字，分别是try、except 以及 finally。我们知道在 try 代码块中如果遇到错误就会抛出异常，交给 except 提前定义好的错误类型进行匹配并捕获，如果成功捕获到异常就会交给 except 的代码块进行执行，最后的 finally 是无论如何都会执行的代码块。 那么在 try 语法块中是谁抛出的异常？优势如何抛出的呢？首先抛出异常的是 Python 的解释器，它在脚本执行的时候发现了错误并将其抛出，而如何抛出的呢？捕获的异常优势如何定义的呢？
[Python知识图谱] 三.Jieba工具中文分词、添加自定义词典及词性标注详解
杨秀璋的专栏
07-28 2万+
本系列文章主要结合Python语言实现知识图谱构建相关工程，具有一定创新性和实用性，非常希望各位博友交流讨论，相互促进成长。前面两篇文章详细讲解了哈工大Pyltp工具，包括中文分词、词性标注、实体识别、依存句法分析和语义角色标注等。但是其中文分词效果不是很理想，如“贵州财经大学”总是切分成“贵州”、“财经”和“大学”，这是因为词典中这些词的权重较高。这篇文章主要介绍最经典的自然语言处理工具之一——Jieba，包括中文分词、添加自定义词典及词性标注等内容。
Python创建类
太行一粟
12-24 206
类 代码： #!/usr/local/bin/python3 """Class Car and Class ElectricCar""" class Car(): """class Car includes 'Maker', 'Model', 'Year' and ‘Color’""" def __init__(self, Maker, Model, Year): self.Maker = Maker self.Model = Model
类实例化“计数器”——设置类变量实现，可以用“元类”打造批量自动
最新发布
m0_57158496的博客
09-16 887
一个类，如果要统计被“实例化”次数，可以用类变量，更可以用元类实现批量“自动”。(笔记模板由python脚本于2024年09月16日 06:26:24创建，本篇笔记适合喜欢python编程的coder翻阅)【学习的细节是欢悦的历程】Python官网Free：大咖免费“圣经”教程python 完全自学教程，不仅仅是基础那么简单……自学并不是什么神秘的东西，一个人一辈子自学的时间总是比在学校学习的时间长，没有老师的时候总是比有老师的时候多。——华罗庚HOT好文力荐。
默默的学python——变量
xiaolipanpan的博客
08-30 1360
在Python中，变量(variable)的定义其实是一种更宽松的概念，与其他一些编程语言(如C、Java等)有所不同。在Python中，当你为某个东西(例如一个值、一个对象、一个数据结构等)赋予一个名字时，你就创建了一个变量。因此，我们不难得知：变量(variable)是表示(或指向)特定值的名称。1、 动态类型：Python 是一种动态类型语言，这意味着你不需要在声明变量时指定其类型，变量的类型是你在第一次给他赋值时自动确定的，并且在后续的操作中可以根据需要重新赋值，改变其类型。
Python自定义类
拱头的专栏
12-08 830
多继承属性、方法重复问题 Python允许类之间的多继承关系，如果在多继承的时候，继承的多个父类有相同的方法和属性，第一个父类出现的方法和属性会覆盖后面父类相同的属性和方法，具体的例子如下： class A: type='a' def foo(self): print( 'A') class B: type='b' def foo(self): print(
python 自定义一个类
weixin_42105211的博客
05-15 3856
一、要求 定义一个类，类中包括私有方法以及属性、普通方法以及属性，并且私有方法和属性要提供对外访问接口 二、情景：网上购买电脑 1.上网搜索，查询信息； 2.选择商品； 3.输入金额，与价格比较；如果金额充足，则要求输入支付密码；否则提示余额不足； 4.当支付密码正确时，提示成功支付； 5.提供修改支付密码的功能。 三、设计的方法及属性 方法：查询商品、支付验证、修改支付密码 属性：密码、商品信息、支付余额 四、python代码 class BuyThing(object): def __init
python中调用自定义类
zlhcsm的博客
07-11 1997
文章的大概结构如下： 1，自定义类介绍 2，调用方式 2.1 同文件夹下 2.2 不同文件夹下
python自定义函数返回值_python函数，定义，参数，返回值
weixin_39610229的博客
11-25 982
python中可以将某些具备一定功能的代码写成一个函数，通过函数可以在一定程度上减少代码的冗余，节约书写代码的时间。因为有一些代码实现的功能我们可能会在很多地方用到。1、函数的声明与定义通过def关键字声明函数，函数名可以自定义，一般时要求做到见名知义，在函数体内我们可以书写实现功能的代码函数一般分为无参函数，有参函数。无参函数就像下面这样'''函数定义：def 函数名():函数体'''def f...
〖Python零基础入门篇㉞〗- 五分钟快速带你了解什么是面向对象编程
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
03-09 4万+
什么是面向对象编程? 利用（面向）对象的（属性和方法）去进行编码的过程即面向对象编程;自定义对象数据类型就是面向对象中的类(class)的概念
分形几何python代码_Python, Cython绘制美妙绝伦的Mandelbrot集, 曼德博集分形图案
weixin_39846089的博客
12-10 883
上世纪60-70年代，美籍数学家曼德博 - Benoit B. Mandelbrot几乎单枪匹马的创立了一个新的数学分支，即分形几何学 - fractal geometry。这个新的数学分支有助于人类探索物理现象背后的数学规律，分形混沌之旋风，横扫数学、理化、生物、大气、海洋以至社会学科，在音乐、美术领域也产生了一定的影响。分形艺术 - fractal art不同于普通的电脑绘画，它利用分形几何学...
python_类和对象的实现和书写
cwy0502的博客
06-04 405
创建文件： 习惯使用小写字母当作文件名，可以使用下划线进行分割。 类名的书写规范： 使用驼峰命名法， 大驼峰： MyCar XiaoBaiTu… 小驼峰： myCar xiaoBaiTu… 类的组成： 女朋友：(类) 特征：性别女，肤白，貌美，大长腿… sex = “女” color = “皮肤白” face = “貌美” leg = “大长腿” … 功能：洗衣，做...
Object.keys 、 Object.getOwnPropertyNames 和 for in 异同点
Gunahao的博客
05-06 940
// 定义一个类，原型上有gender属性，和sayHi方法。 const Person = function () {} Person.prototype = { gender: 'male', sayHi: function () {} } var people = new Person() people.name = 'xiaoming'; people.age = 2...
python 自定义的类 小白笔记
小白垃圾笔记2
01-30 594
实例化方法的第一个参数始终是self，需要调用才可以使用。调用方法：对象名.方法名实例方法意味着访问实例属性。如果定义静态方法不会访问实例属性。*类的静态方法不能访问实例属性。
python自定义类_Python进阶-自定义类基础
weixin_39804629的博客
11-28 576
本文为《爬着学Python》系列第十四篇文章。中间因为工作原因隔了好久没有更新，现在稳定很多，会陆续开始更新。不过考虑到我自己的博客还有工作上的事情，我只能说尽量周更。面向对象(Object Orientied/OO)想必很多人对这个概念不陌生，但是不一定仔细了解过。事实上面向对象的范式能够大行其道和Java以及C++的受欢迎是分不开的。这两种语言比起更早期更基础的语言，针对面向对象编程进行了很多...
python中如何定义类
hdxx2022的博客
11-19 967
_private_attrs两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。__private_method两个下划线开头，声明该方法为私有方法，不能在类地外部调用。类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。__init__构造函数，在生成对象时调用。__del__析构函数，释放对象时使用。__repr__打印，转换。__cmp__比较运算。__mod__求余运算。__add__加运算。__sub__减运算。__mul__乘运算。
15-3-第二章 python自定义类与函数（三）
weixin_43416590的博客
07-07 498
当您有几个不同的函数和类时，将它们放在单独的模块（脚本）中通常是有意义的。随着您的模块集合的增长，您可以考虑将它们分组到包中。包本质上是另一种类型的模块，但它包含多个彼此密切相关（并且可能相互依赖）的模块。常规模块存储为 .py 文件，但包存储为文件夹（或目录）。从技术上讲，包是一个文件夹，其中包含一个名为 的文件。这个文件定义了程序包的一般属性。这个文件并不需要定义任何内容，它可以只是一个空的文件，但它必须存在。如果 init.py 不存在，则该目录只是一个目录，而不是一个包，无法导入。 文件可以将
python如何定义类_在Python中自定义类的创建方式
weixin_39790686的博客
11-23 289
Python部落(python.freelycode.com)组织翻译，禁止转载，欢迎转发。当人们在想要创建一个定制类的时候，他们可能通常想到的是元类和类修饰器。在通常的会话中元类一般作为创建类的开始而类修饰符作为结束。但是您可能不知道的是在类创建中还有另外的两个步骤需要调整：__prepare__()和__init_subclass__()（分别在Python3.0和3.6中添加）。这个__pr...
零基础学Python：自定义序列类的详细教程
Python热爱者的博客
09-06 455
1.序列类型的分类 2.序列的+和+=，extend和append的区别 from collections import abc a = [1,2,] c = a + [3,4] print(c) #[1, 2, 3, 4] 如果 + 元祖则会报错， not tuple c = a + (3,4) #TypeError: can only concatenate list (not "tuple") to list + 是新生产一个list, += 是就地加，不会新生成list 用+=
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

梦幻精灵_cq

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值