1. Double bottom method

Definition: double down method is a special method. It is a method with special significance provided by the interpreter. Double down method is mainly used by python source code programmers. We try not to use double down method in development, but in-depth study of double down method is more conducive to reading source code.

(1) call: different double methods have different triggering methods.

< 1 > len -- len() trigger

class A(object):

    def __init__(self,name):
        self.name = name
        print("Triggered__init__")

    def __len__(self):     # len() trigger
        print("Walk here")
        return len(self.name)    # Return len ("xqrqwr") str__
        # There must be a return value, and the type of the return value must be integer

a = A("xqrqwr")
print(len(a))

# str
a = "12345"      # An instance of str
lst = [1,2,3,4,4,5,5,5,5] # list is an instance of this class
print(len(a))
print(len(lst))

< 2 > hash - hash() trigger

class A(object):

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __hash__(self):  # hash()
        hash({1,2,345})  # Variable data class, non data type
        return 1
        # There must be a return value. The return value must be of integer type.

a = A("meet",25)
print(hash(a))

< 3 > STR -- print or str() trigger

class A:

    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __str__(self):   # print triggers str()
        print(111)
        return f"Full name:{self.name} Age:{self.age} Gender:{self.sex}"
        # There must be a return value of type string


a = A("mee",20,"male")
a1 = A("mee1",200,"Man 1")
str(a)
print(a)
print(a1)


# The following comparison:
a = A("mee",20,"male")
a1 = A("mee2",200,"female")

print(f"Full name:{a.name} Age:{a.age} Gender:{a.sex}")   # "Name: meet age: 20 gender: male"
print(f"Full name:{a1.name} Age:{a1.age} Gender:{a1.sex}")  # "Name: meet2 age: 200 gender: female"

< 4 > PRR -- print or% r trigger

class A:

    def __init__(self):
        pass


    def __repr__(self):   # print trigger% r
        print(1111)
        return "Heaven devil"

    def __str__(self):   # STR priority is higher than repr. If both exist, only execute str.
        return "Xiaoyuan"

a = A()
print("%r"%(a))

< 5 > Call - triggered when an object is called. The object is followed by parentheses, that is, object () or class () ()

class A:

    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):  # call called on object ()__
        print("Walk me")
        print(*args, **kwargs)

a = A()
a()

< 6 > EQ equals

class A(object):

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __eq__(self, other):     #  a == a1
        if self.name == other.name:
            return True
        else:
            return False

a = A("mee",56)
a1 = A("mee",108)

print(a == a1)

< 7 > del construction method, when the object is released in memory, the execution will be triggered automatically.

In general, this method does not need to be defined. Because python is a high-level language, programmers do not need to care about the allocation and release of memory when using it. Because the allocation and release of memory are all performed by the python interpreter class, so the call of destructor is automatically triggered by the interpreter when garbage collection.

class A:
    def __init__(self):
        pass

    def __del__(self):    del trigger
        print("Execute me on delete")

a = A()

import time
time.sleep(5)
del a

a = 1
b = a
a = b

Garbage collection mechanism:
    # 80  5/s
    #Reference count
    #Mark clear
    #Bag recycling bag 1: 10 2/h bag 2: 5/3 4h bag 3: 3 20h

The < 8 > item series can operate instance methods like Dictionaries

dic["key"] = value
del dic["key"]
dic["key"]

class A:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        print(self.__dict__)
        print(self.__dict__[item])  # What you get is a dictionary.

    def __setitem__(self, key, value):
        self.__dict__[key] = value

    def __delitem__(self, key):
        del self.__dict__[key]

a = A("meet",58)
a["sex"] = "male"
a["sex"]
del a["sex"]
print(a.__dict__)

< 9 > new mode (factory mode)

Single instance mode is a common software design mode. In its core structure, there is only one special class called singleton class. The single instance mode can ensure that there is only one instance of a class in the system and the instance is easy to be accessed by the outside world, so it is convenient to control the number of instances and save system resources. If you want to have only one object of a certain class in the system, the singleton pattern is the best solution.

class A(object):

    def __init__(self,name):  # Initialization
        self.name = name
        print("I am__init__,Go ahead of me.")

    def __new__(cls, *args, **kwargs):
        print("I am__new__,Go ahead of me.")
        return "La La La"

a = A("meet")
print("Who am I?:",a)

class A(object):

    def __init__(self,name):  # Initialization
        self.name = name
        print("I am__init__,Go ahead of me.")

    def __new__(cls, *args, **kwargs):
        obj = object.__new__(A)
        print("Where am i?:",obj)
        return obj                   # obj == __init__()

a = A("meet")
print("Who am I?:",a)

class A(object):

    def __init__(self,name): # Initial knowledge
        self.name = name


    def __new__(cls, *args, **kwargs):
        obj = object.__new__(A)   # The call is "new" in the object class. Only "new" in the object class can create a space.
        return obj   #essence: obj == __init__()     return __init__()  # Trigger init method


a = A("mee")  # a is the memory address of the object
a1 = A("Heaven devil")  # a is the memory address of the object
a2 = A("Tianyang")  # a is the memory address of the object
print(a.name)
print(a1.name)
print(a2.name)

# Execute the new method first and then the init method

class A:
    __a = None  #__a =  0x000001F346079FD0

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if cls.__a is None:
            obj = object.__new__(cls)
            cls.__a = obj
        return cls.__a

a = A("mee",123)  # Address 0x000001F346079FD0
a1 = A("Heaven devil",11)
print(a.name)
print(a1.name)

Singleton mode: no matter how many times it is created, the same memory space is used

Module import, handwritten singleton mode

What happens when an object is instantiated:

Create the object and open up the object space.__

Automatically execute the init method, implicitly passing the object address to self

Encapsulate object properties into object space

2. Context

(1)__ enter__

(2)__ exit__

class my_open:

    def __init__(self,file,mode="r",encoding="utf-8"):
        self.file = file
        self.mode = mode
        self.encoding = encoding

    def __enter__(self):
        self.f = open(self.file,self.mode,encoding=self.encoding)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(exc_type,exc_val,exc_tb) # When there's no mistake, it's None.
        self.f.close()


with my_open("a.txt") as ffff:
    for i in ffff:
        print(i)
print(ffff.read(1111))
print(ffff.read())