Analysis of implementation methods of Python extended built-in types

This article mainly introduces the method of extending built-in types in Python, and analyzes the specific implementation techniques of Python embedded built-in type extensions and subclass extensions in the form of examples. Friends in need can refer to this article

The example describes how Python implements extending built-in types. Share it with everyone for your reference, the details are as follows:

Introduction

In addition to implementing new types of object methods, sometimes we can also use Extend Python built-in types to support other types of data structures, such as adding queue insertion and deletion methods to lists. In response to this problem, this article introduces two methods of extending Python's built-in types by combining examples of implementing collection functions: extending types by embedding built-in types and extending types by subclassing.

Extension by embedding built-in types

The following example implements a collection object by using the list object as an embedded type, and adds some operator overloading. This class wraps Python's lists, as well as additional set operations.

class Set:
  def __init__(self, value=[]): # Constructor
    self.data = [] # Manages a list
    self.concat(value)
  def intersect(self, other): # other is any sequence
    res = [] # self is the subject
    for x in self.data:
      if x in other: # Pick common items
        res.append(x)
    return Set(res) # Return a new Set
  def union(self, other): # other is any sequence
    res = self.data[:] # Copy of my list
    for x in other: # Add items in other
      if not x in res:
        res.append(x)
    return Set(res)
  def concat(self, value): # value: list, Set...
    for x in value: # Removes duplicates
      if not x in self.data:
        self.data.append(x)
  def __len__(self):     return len(self.data) # len(self)
  def __getitem__(self, key): return self.data[key] # self[i]
  def __and__(self, other):  return self.intersect(other) # self & other
  def __or__(self, other):  return self.union(other) # self | other
  def __repr__(self):     return 'Set:' + repr(self.data) # print()
if __name__ == '__main__':
  x = Set([1, 3, 5, 7])
  print(x.union(Set([1, 4, 7]))) # prints Set:[1, 3, 5, 7, 4]
  print(x | Set([1, 4, 6])) # prints Set:[1, 3, 5, 7, 4, 6]

Extending types by subclassing

Starting from Python 2.2, all built-in types Subclasses such as list, str, dict and tuple can be created directly. This allows you to customize or extend built-in types through user-defined class statements: subclass the type name and customize it. An instance of a subtype of a type can be used anywhere the original built-in type can appear.

class Set(list):
  def __init__(self, value = []):   # Constructor
    list.__init__([])        # Customizes list
    self.concat(value)        # Copies mutable defaults
  def intersect(self, other):     # other is any sequence
    res = []             # self is the subject
    for x in self:
      if x in other:        # Pick common items
        res.append(x)
    return Set(res)         # Return a new Set
  def union(self, other):       # other is any sequence
    res = Set(self)         # Copy me and my list
    res.concat(other)
    return res
  def concat(self, value):       # value: list, Set . . .
    for x in value:         # Removes duplicates
      if not x in self:
        self.append(x)
  def __and__(self, other): return self.intersect(other)
  def __or__(self, other): return self.union(other)
  def __repr__(self):    return 'Set:' + list.__repr__(self)
if __name__ == '__main__':
  x = Set([1,3,5,7])
  y = Set([2,1,4,5,6])
  print(x, y, len(x))
  print(x.intersect(y), y.union(x))
  print(x & y, x | y)
  x.reverse(); print(x)

The above is the detailed content of Analysis of implementation methods of Python extended built-in types. For more information, please follow other related articles on the PHP Chinese website!