内置方法

class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period
    def __str__(self):
        ‘‘‘打印这个对象的时候 自动触发__str__‘‘‘
        ‘‘‘使用%s进行字符串的拼接的时候 自动触发__str__‘‘‘
        return ‘%s,%s,%s‘%(self.name,self.price,self.period)

python = Course(‘python‘,25000,‘6 months‘)
print(python)              #python,25000,6 months
print(‘course %s‘%python)  #course python,25000,6 months
print(f‘course {python}‘)  #course python,25000,6 months

class Course:
    def __init__(self,name,price,period):
        self.name = name
        self.price = price
        self.period = period

    def __repr__(self):   # 备胎
        return ‘%s,%s,%s‘%(self.name,self.price,self.period)

    def __str__(self):
        return self.period

python = Course(‘python‘,25000,‘6 months‘)
print(python)              #6 months  
print(‘course %s‘%python)  #course 6 months
print(f‘course {python}‘)  #course 6 months
print(repr(python))        #python,25000,6 months
print(‘course %r‘%python)  #course python,25000,6 months

class Foo:
    def __new__(cls, *args, **kwargs):
        print(‘in new‘)   # 先执行   in new
        obj = object.__new__(cls)
        print(obj)        # <__main__.Foo object at 0x000001CF7E75D780>
        return obj

    def __init__(self):
        print(‘init‘,self)    # 后执行  init <__main__.Foo object at 0x000001CF7E75D780>
Foo()

# 实例化一个Foo的对象
    # 先开辟一块儿空间,使用的是Foo这个类内部的__new__
        # 如果我们的Foo类中是没有__new__方法的
        # 调用object类的__new__方法了

class Foo(object):
    def __new__(cls, *args, **kwargs): # cls永远不能使self参数,因为self在之后才被创建
        obj = object.__new__(cls)   # self是在这里被创造出来的
        print(‘new : ‘,obj)  #new :  <__main__.Foo object at 0x000002150A77D128>
        return obj
    def __init__(self):
        print(‘init‘,self)  #init <__main__.Foo object at 0x000002150A77D128>

Foo()
# 在使用self之前,都还有一个生产self的过程
    # 就是在内存中开辟一块属于这个对象的空间,并且在这个空间中存放一个类指针
    # 以上就是__new__做的所有事情

class A:pass
a1 = A()
a2 = A()
print(a1)  #<__main__.A object at 0x0000019B72F8AFD0>
print(a2)  #<__main__.A object at 0x0000019B72F8D048>
#不同的内存地址

class A:
    __flag = None
    def __new__(cls, *args, **kwargs):
        if cls.__flag is None:  #实例化一次以后，__flag不再是None 
            cls.__flag = object.__new__(cls)
        return cls.__flag

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

a1 = A(‘alex‘,84)
print(a1)     #<__main__.A object at 0x000001A26908D9E8>
a2 = A(‘alex‘,83)
print(a2)     #<__main__.A object at 0x000001A26908D9E8>
a3 = A(‘alex‘)
print(a3)     #<__main__.A object at 0x000001A26908D9E8>
print(a1.age) #83

# 保证一个类无论 被实例化多少次,只开辟一次空间,始终使用的是同一块内存地址

import time
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        # 只和del obj语法有关系,在执行del obj之前会来执行一下__del__中的内容
        print(‘执行我啦‘)

a = A(‘alex‘,84)
print(a.name)    #alex
print(a.age)     #84
# del a   # 这个变量已经没了
time.sleep(1)    #停顿一秒后执行 __del__  打印初‘执行我了’

import time
class A:
    def __init__(self,path):
        self.f = open(path,‘w‘)
    def __del__(self):
        ‘‘‘归还一些操作系统的资源的时候使用‘‘‘
        ‘‘‘包括文件\网络\数据库连接‘‘‘
        self.f.close()


a = A(‘userinfo‘)
time.sleep(1)

lass A:
    def call(self):
        print(‘in call‘)
    def __call__(self, *args, **kwargs):
        print(‘in __call__‘)

A()()        #in __call__
obj = A()
obj()       #in __call__
obj.call()  #in call

class File:
    def __enter__(self):
        print(‘start‘)

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(‘exit‘)

with File():
    print(‘wahaha‘)

class myopen:
    def __init__(self,path,mode=‘r‘):
        self.path = path
        self.mode = mode

    def __enter__(self):
        print(‘start‘)
        self.f = open(self.path,mode=self.mode)
        return self.f

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
        print(‘exit‘)

with myopen(‘userinfo‘,‘a‘) as f:  #as f 就是__enter__ 的返回值
    f.write(‘hello,world‘)

#在执行写入‘hello,world’之前运行 __enter__ 即打开文件，打印‘start’，之后执行__exit__ 关闭文件，打印‘exit’

class MypickleDump:
    def __init__(self,path,mode = ‘ab‘):
        self.path = path
        self.mode = mode

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

    def dump(self,obj):
        pickle.dump(obj,self.f)

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

with MypickleDump(‘pickle_file‘) as obj:
    obj.dump({1,2,3,4})

with MypickelLoad(‘pickle_file‘) as obj:
   for i in  obj.loaditer():
       print(i)

import time
class Timer:
    def __enter__(self):
        self.start = time.time()
    def __exit__(self, exc_type, exc_val, exc_tb):
        print(time.time() - self.start)

def func():
    print(‘wahaha‘)
    time.sleep(1)
    print(‘qqxing‘)


with Timer():
    func()