python -- 类中--内置方法

Posted 2021-01-26 帅小伙

isinstance 和  issubclass

isinstance(obj,b)  检查是否obj是否是类b的对象

class A(object):pass
class B(A):pass
b=B()
print(isinstance(b,B))  #如果b是B的对象  就返回True,反之False
print(isinstance(b,A))  #如果b是A的对象  就返回True,反之False

issubclass(A,B)  检测B是否继承A

class A(object):pass
class B(A):pass
print(issubclass(B,A))  #如果B继承A   就返回True,反之Fasle

类的内置方法

1)改变对象的字符串显示 __str__,__repr__

自定制格式化字符串 __format__

format_dict={
    ‘nat‘:‘{obj.name}-{obj.addr}-{obj.type}‘,#学校名-学校地址-学校类型
    ‘tna‘:‘{obj.type}:{obj.name}:{obj.addr}‘,#学校类型:学校名:学校地址
    ‘tan‘:‘{obj.type}/{obj.addr}/{obj.name}‘,#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return ‘School(%s,%s)‘ %(self.name,self.addr)
    def __str__(self):
        return ‘(%s,%s)‘ %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec=‘nat‘
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School(‘oldboy1‘,‘北京‘,‘私立‘)
print(‘from repr: ‘,repr(s1))
print(‘from str: ‘,str(s1))
print(s1)

‘‘‘
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()    <--#__str__的备胎
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
‘‘‘
print(format(s1,‘nat‘))
print(format(s1,‘tna‘))
print(format(s1,‘tan‘))
print(format(s1,‘asfdasdffd‘))

View Code

class B:

     def __str__(self):
         return ‘str : class B‘  ------%s

     def __repr__(self):
         return ‘repr : class B‘------%r


b=B()
print(‘%s‘%b)
print(‘%r‘%b)

%s和%r

2)__del__

析构方法,当对象在内存中被释放,自动触发执行.

注意:此方法一般无需定义,因为python是一门高级语言.

class Foo:
    def __del__(self):
            print(‘执行我了‘)
 f=Foo()
del  f
print(‘---->‘)
#输出结果
执行我了
---->

View Code

3)item系列

__getitem__\__setitem__\__delitem__

class Foo:
    def __init__(self,name):
        self.name=name

    def __getitem__(self, item):
        print(self.__dict__[item])   #直接生成字典

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print(‘del obj[key]时,我执行‘)
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print(‘del obj.key时,我执行‘)
        self.__dict__.pop(item)

f1=Foo(‘sb‘)
print(f1.name)
f1[‘age‘]=18
f1[‘age1‘]=19
del f1.age1
del f1[‘age‘]
f1[‘name‘]=‘alex‘
print(f1.__dict__)

View Code

4)__new__    __init__(实例化      构造方法(单例模式))/  初始化方法

class A:
    def __init__(self):
        self.x = 1
        print(‘in init function‘)
    def __new__(cls, *args, **kwargs):
        print(‘in new function‘)
        return object.__new__(A, *args, **kwargs)------提供了一个类实例化的时候提供的一个所需要的内存空间

a = A()
print(a.x)

View Code

5)__call__　(对象后面加括号,触发执行)

注意:构造方法的执行是由创建对象触发的,即:对象 = 类名():而对于__call__方法的执行是由对象后加括号触发的　,即:对象() 或者 类()

class Student():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # def call(self):pass
    def __call__(self, *args, **kwargs):
        print(‘调用我啦‘)
alex = Student(‘alex‘,83)-----执行__init__
alex()    ----执行__call__

View Code

6)__len__  (len(对象))

class A:
    def __init__(self):
        self.a = 1
        self.b = 2
        self.c = 1

    def __len__(self):
        return len(self.__dict__)------查的长度
a = A()
print(len(a))

View Code

7)__hash__   (每次执行__hash__都会改变,在一次执行的过程中对同一个值的hash结果总是不变的)

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __hash__(self):
        return hash(str(self.a)+str(self.b))
a = A()
print(hash(a))

View Code

8)__eq__( 判断)

class A:
    def __init__(self):
        self.a = 1
        self.b = 2

    def __eq__(self,obj):
        if  self.a == obj.a and self.b == obj.b:
            return True
a = A()
print(a)
b = A()
print(b)
print(a == b)

View Code

9)__iter__和__next__(这两个方法用于将一个对象模拟成序列)

class Num:
    def __init__(self, max_num):
        self.max_num = max_num
        self.count = 0
        
    def __iter__(self):
        return self

    def __next__(self):
        if self.count < self.max_num:
            self.count += 1
            return self.count
        else:
            raise StopIteration(‘已经到达临界‘)
        
num = Num(10)
for i in num:
    print(i)  # 循环打印1---10

View Code

10)__getattr__\__setattr__\__delattr__(访问,设置和删除)

class Student:
    def __getattr__(self, item):
        print(‘访问一个不存在的属性时候触发‘)
        return ‘不存在‘

    def __setattr__(self, key, value):
        print(‘设置一个属性值的时候触发‘)
        # self.key = value  # 这样会无限循环
        self.__dict__[key] = value

    def __delattr__(self, item):
        print(‘删除一个属性的时候触发‘)
        if self.__dict__.get(item, None):
            del self.__dict__[item]

stu = Student()
stu.name = ‘zlw‘  # 设置一个属性值的时候触发
print(stu.noexit)  # 访问一个不存在的属性时候触发 , 返回‘不存在‘
del stu.name  # 删除一个属性的时候触发

View Code

11)__getattribute__(属性访问截断器)

属性查找顺序:

实例的 getattribute-->实例对象字典--.实例所在类字典--->实例所在类的父类(MRO顺序)字典-->实例所在类的getattr--->报错

class People:
    a = 200

class Student(People):
    a = 100

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

    def __getattr__(self, item):
        print(‘没有找到:‘, item)

    def __getattribute__(self, item):
        print(‘属性访问截断器‘)
        if item == ‘a‘:
            return 1
        return super().__getattribute__(item)

stu = Student(1)
print(stu.a)  # 1

View Code

12)__enter__和__exit__

class MySQL:
    def connect(self):
        print(‘启动数据库连接，申请系统资源‘)

    def execute(self):
        print(‘执行sql命令，操作数据‘)

    def finish(self):
        print(‘数据库连接关闭，清理系统资源‘)

    def __enter__(self):  # with的时候触发，并赋给as变量
        self.connect()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):  # 离开with语句块时触发
        self.finish()

with MySQL() as mysql:
    mysql.execute()
    
# 结果:
# 启动数据库连接，申请系统资源
# 执行sql命令，操作数据
# 数据库连接关闭，清理系统资源

View Code

13)__doc__  (类的描述信息)

class Foo:
    """ 描述类信息，这是用于看片的神奇 """

    def func(self):
        pass

print Foo.__doc__
#输出：类的描述信息

View Code

14)__module__ 和__class__(  当前操作的对象在那个模块当前操作的对象的类是什么)

from lib.aa import C

obj = C()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

View Code

class FranchDeck:
    ranks = [str(n) for n in range(2,11)] + list(‘JQKA‘)
    suits = [‘红心‘,‘方板‘,‘梅花‘,‘黑桃‘]

    def __init__(self):
        self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
                                        for suit in FranchDeck.suits]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, item):
        return self._cards[item]

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

deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))

from random import shuffle
shuffle(deck)
print(deck[:5])

纸牌游戏

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

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(84):
    p_lst.append(Person(‘egon‘,i,‘male‘))

print(p_lst)
print(set(p_lst))

面试题

希望大家多多关注,多多评论!!!