Python面向对象编程第四天（共七天）

1.内置方法的具体使用

     内置方法分为生命周期方法（我们后面讲解）与其他内置方法（上篇文章最后提到的方法）。

1.1 信息格式化操作

     在这里我们首先定义一个初始化函数，并通过传两个参数的方式来得到每个实例不同的属性。同时我们定义了一个字符串方法，如果没有这个方法的话，那么p1会直接打印出来p1的地址，而不是p1的内容。

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

    def __str__(self):
        return "这个人的姓名是%s，这个人的年龄是：%（self.name,self.age）"

    def __repr__(self):
        return"123"

p1 = Person("sz",18)
# print(p1.name)
# print(p1.age)
print(p1)

p2 = Person("张三",19)
print(p2.name)
print(p2.age)

     通过repr()的方式直接获得p1的本质信息，首先p1会查找str方法，并打印自身相关属性，如果没有str方法，那么会查找repr方法，并打印repr里的返回值，如果这两个方法都没有的话，就返回p1的地址。str方法主要是面对用户，而repr方法更多是在开发中调式使用。通过eval()将repr方法再次转换为相关对象。

print(repr(p1))

import datetime

t = datetime.datetime.now()
print(t)
print(repr(t))

tmp = repr(t)

result = eval(tmp)

1.2 调用操作

     __call__使得”对象”具备当作函数，来调用的能力。

     当我们调用p（）时，直接会报错，但是当我们定义一个__call__函数时，p（）会找到并调用该函数，其中args中的内容保存在元组中，以键值对的形式的内容存储在kwargs中。

class Person:
    def __call__(self, *args, **kwargs):
        print("xxx",args,kwargs)

p = Person()

p(123,456,789,name = "sz")

     利用__call__函数来执行偏函数的功能。我们首先定义一个初始化函数，同时将p_type参数传给self.p_type这个属性，同时再定义一个调用方法，创建一个新函数，这个新函数首先相当于继承了钢笔的参数，我们只用传入颜色参数就行了。

class PenFactory:

    def __init__(self,p_type):
        self.p_type = p_type
    def __call__(self, p_color):
        print("创建了一个%s这个类型的画笔，它是%s颜色 "%(self.p_type,p_color))
gangbiF =PenFactory("钢笔")
gangbiF("红色")
gangbiF("绿色")
gangbiF("黄色")

qianbiF = PenFactory("铅笔")
qianbiF("红色")
qianbiF("黄色")
qianbiF("绿色")

1.3 索引操作

      索引操作的作用是可以对一个实例对象进行索引操作，分为两步，一是实现三个内置方法，二是可以以索引的形式操作对象。

     首先通过初始化方法来定义一个字典，利用__setitem__内置方法来增加新的属性，利用__getitem__内置方法来返回该键值对内容，最后利用__delitem__来删除相关键值对，每个内置方法的调用方式是不同的，也是特定的。

class Person:
    def __init__(self):
        self.cache = {}

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

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

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

p = Person()
p["name"] = "sz"

print(p["name"])

del p["name"]

print(p.cache)

1.4 切片操作

     切片操作可以对一个实例对象进行切片操作，统一由“索引操作“进行管理。

     这里我们首先定义一个__setitem__方法，同时调用了它的内置属性，由于解释器会识别这个方法，所以运行出来自然就是切片。我们首先做的操作是赋值，然后调用这个切片，但是需要有__getitem__这个方法，传入这个方法的item就是切片了。

class Person:
    def __setitem__(self, key, value):
        print(key,value)
        print(key.start)
        print(key.stop)
        print(key.step)

    def __getitem__(self, item):
        print("getitiem",item)

    def __delitem__(self, key):
        print("delitem",key)

p = Person()
p[0:4:2] = [1,2]

p[0:5:2]

1.5 比较操作

     比较操作的作用是可以自定义对象”比较大小，相等以及真假”规则。

     我们通过调用函数__eq__来判断类的属性是否相等，而且在这里只会判断age属性，并不会收到后面height属性的影响。我们这里判断的是不相等，如果没有__ne__方法的话，它会用__eq__  的反方法来比较，也是能比较的，如果这里有__ne__方法，那么直接通过__ne__方法来判断是否相等。

     我们这里只列举了等于，大于，大于等于和不等的方法。

class Person:
    def __init__(self,age,height):
        self.age = age
        self.height = height
    
    def __eq__(self, other):
        print(other)
        return self.age ==other.age
    
    def __ne__(self,other):
        print("xxx")
    def __gt__(self,other): #大于
        pass
    def __ge__(self,other): # 大于等于
        pass
    
p1 = Person(18,190)
p2 = Person(18,180)

print(p1 != p2)

     如果对于反向操作的比较符，只定义了其中一个方法，但是用的是另外一种比较运算，那么解释器会采用调换参数的方式来进行调用该方法。但是不支持叠加操作。

1.6 遍历操作

     我们还是通过__getitem__这个内置方法才能进行查询功能，对其内容进行遍历输出。当我们设定的大于六时，此时会抛出异常。

class Person:
    def __init__(self):
        self.result = 1
    def __getitem__(self, item):
        self.result +=1
        if self.result >=6:
            raise StopIteration("停止遍历")
        return self.result

p = Person()

for i in p:
    print(i)

     __iter__内置方法的优先级更高，并且在返回时会返回迭代器。然后再调用迭代器里的内置方法__next__。

def __iter__(self):
    print("iter")
    return iter([1,2,3,4,5])
def __next__(self):
    retuen self

文章来源于互联网:Python面向对象编程第四天（共七天）

相关推荐: 打卡信奥刷题（1785）用C++实现信奥 P8804 [蓝桥杯 2022 国 B] 故障

P8804 [蓝桥杯 2022 国 B] 故障 题目描述 在软件或系统开发中，我们会遇到各种各样的故障。为了从故障现象反推故障原因，工程师们会总结一种叫做相关性矩阵的二维表格，来表示故障原因与故障现象之间的关系。比如: 其中每行表示一种故障原因，每一列表示一种…