020-Python面向对象-方法相关补充

话不多说，上代码，看结果。

print('2.6、方法相关补充##############################')
# 私有化方法
# 私有方法
# def __方法():
# 	pass
# 注意   不要定义 "_类名__方法名" 这种方法

class M:

    def __m(self):
        print("/*-/-*")


p = M()
# p.__m   # AttributeError: 'M' object has no attribute '__m'

print('2.6.1、内置特殊方法##############################')
# 生命周期方法(后面补充)
print('2.6.1.1、信息格式化操作##############################')
# __str__方法
# 作用   一个对象的描述字符串, 更加方便用户阅读, 对用户更友好
# 触发方式   print 打印一个对象时   str() 函数时
# 格式
# def __str__(self):
# 	return "描述信息"

# repr方法
# 作用  一个对象的描述字符串, 更加方便机器处理, 对机器更友好(开发人员查看)
# 触发方式  在交互模式下, 直接执行某个变量, 就会输出对应信息   repr() 函数时
# 格式
# def __repr__(self):
# 	return "描述信息"
# 注意  一般情况下, 应满足如下等式  obj == eval(repr(obj))   或者描述一个实例详细的信息(类名等等)


class Xiong:

    def __init__(self, name1, name2):
        self.animal1 = name1
        self.animal2 = name2

    def __str__(self):
        return '狗熊岭里有两只熊: %s, %s' % (self.animal1, self.animal2)

    def __repr__(self):
        return '两只熊: %s, %s' % (self.animal1, self.animal2)


z = Xiong('熊大', '熊二')
print(z, type(z))
print(str(z), type(str(z)))
print(repr(z))

import datetime

tim = datetime.datetime.now()
print(tim)
print(str(tim))
print(repr(tim))
print(eval(repr(tim)))

print('2.6.1.2、调用操作##############################')
# __call__方法
# 作用  使得“对象”具备当做函数，来调用的能力
# 使用
# 1. 实现实例方法 __call__
# 2. 那么创建好的实例, 就可以通过函数的形式来调用  实例(参数)
# 应用场景   有点类似于之前所讲的"偏函数"的应用场景  可以将"常变参数"和"不常变参数"进行分离

class Zhanguo:

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

    def __call__(self, person):
        print('国家是%s, 人物有%s' % (self.country, person))


qin = Zhanguo('秦国')
qin('秦始皇')
qin('张仪')

yan = Zhanguo('燕国')
yan('荆轲')
yan('太子丹')

print('2.6.1.3、索引操作##############################')
# 作用   可以对一个实例对象进行索引操作
# 步骤
# 1. 实现三个内置方法
# 	设置元素的方法  def __setitem__(self, key, value):
# 	获取元素的方法  def __getitem__(self, item):
# 	删除元素的方法  def __delitem__(self, key):
# 2. 可以以索引的形式操作对象
# 	增/改  p[1] = 666   p["name"] = "xxx"
# 	查  p["name"]  p[1]
# 	删  del p["name"]   del p[1]
class Xi:

    def __init__(self):
        self.dic = {}

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

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

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


xi = Xi()
xi['姓名'] = '唐僧'
print(xi['姓名'])
print(xi.dic)
del xi['姓名']
print(xi.dic)

print('2.6.1.4、切片操作##############################')
# 作用   可以对一个实例对象进行切片操作
# 步骤
# Python3.x  统一由"索引操作"进行管理
# def __setitem__(self, key, value):
# def __getitem__(self, item):
# def __delitem__(self, key):


class List:

    def __init__(self):
        self.items = [0, 1, 2, 3, 4, 5, 6, 7, 8]

    def __setitem__(self, key, value):
        if isinstance(key, slice):
            self.items[key] = value
            # self.items[key.start: key.stop: key.step] = value

    def __getitem__(self, item):
        return item

    def __delitem__(self, key):
        print('****', key)


lis = List()
print(lis[0: 5: 2])
lis[0: 7: 2] = ['a', 'b', 'c', 'd']
print(lis.items)
del lis[0: 2: 1]

print('2.6.1.5、比较操作##############################')
# 作用  可以自定义对象 "比较大小, 相等以及真假" 规则
# 步骤
# 实现6个方法
# 相等  __eq__   不相等  __ne__   小于 __lt__  小于或等于 __le__  大于 __gt__  大于或等于  __ge__
# 注意
# 如果对于反向操作的比较符, 只定义了其中一个方法,但使用的是另外一种比较运算
# 那么, 解释器会采用调换参数的方式进行调用该方法
# 例如   定义了 "小于" 操作   x < y   使用 x > y   会被调换参数, 调用上面的 "小于操作"
# 但是, 不支持叠加操作   例如  定义了 "小于" 和 "等于" 操作  不能使用 x <= y


class S:
    def __init__(self, power, level):
        self.power = power
        self.level = level

    def __eq__(self, other):
        return self.level == other.level

    def __lt__(self, other):
        print(self.power, other.power)
        return self.power < other.power


s1 = S(1200, 10)
s2 = S(1500, 10)
print(s1 == s2)
print(s1 < s2)
print(s1 > s2)
# print(s1 <= s2)  # TypeError: '<=' not supported between instances of 'S' and 'S'


# 使用装饰器, 自动生成"反向" "组合"的方法
# 步骤
# 1. 使用装饰器装饰类   @functools.total_ordering
# 2. 实现
# > 或 >= 或 < 或 <= 其中一个   实现 ==

import functools


@functools.total_ordering
class D:
    def __init__(self, power, level):
        self.power = power
        self.level = level

    def __eq__(self, other):
        return self.level == other.level

    def __lt__(self, other):
        print(self.power, other.power)
        return self.power < other.power

    # 上下文环境中的布尔值
    # __bool__
    def __bool__(self):
        return self.power <= 1


s1 = D(150, 10)
s2 = D(120, 10)
print(s1 == s2)
print(s1 < s2)
print(s1 > s2)
print(s1 <= s2)
if not s1:
    print('真的')

print('2.6.1.6、遍历操作##############################')
# 怎样让创建的对象可以使用for in 进行遍历?
# 实现__getitem__方法
# 优先级低
# 每次for in 获取数据时, 都会调用这个方法


class E:
    def __init__(self):
        self.i = 0

    def __getitem__(self, item):
        self.i += 1
        if self.i >= 3:
            raise StopIteration("停止遍历")
        return self.i


e = E()
for i in e:
    print(i)


# 实现__iter__方法
# 优先级高
# 这个方法, 必须返回一个"迭代器";  即, 具备"__iter__"和"__next__"方法
# 当for in 遍历这个对象时, 会调用这个__iter__方法返回的迭代器对象的__next__方法
# 怎样让我们自己创建的对象可以使用next函数进行访问?
# 实现__next__方法
class F:
    def __init__(self):
        self.i = 10

    def __iter__(self):
        return self

    def __next__(self):
        self.i += 1
        if self.i >= 13:
            raise StopIteration("停止遍历")
        return self.i


f = F()
print(next(f))
for i in f:
    print('^', i)

import collections
print(isinstance(f, collections.Iterator))
print(isinstance(f, collections.Iterable))

# 补充
# 1. __iter__方法可以恢复迭代器的初始化值, 复用迭代器
# 2. "可迭代" 与 "迭代器"必须实现的方法
# 3. iter方法的使用


class O:
    def __init__(self):
        self.i = 10

    def __iter__(self):
        self.i = 10
        return self

    def __next__(self):
        self.i += 1
        if self.i >= 13:
            raise StopIteration("停止遍历")
        return self.i


o = O()
ot = iter(o)
print(ot)
for i in ot:
    print(i)


class P:
    def __init__(self):
        self.i = 100
        self.i1 = 1000

    def __iter__(self):
        self.i = 100
        self.i1 = 1000
        return self

    def __next__(self):
        self.i += 1
        if self.i >= 105:
            raise StopIteration("停止遍历")
        return self.i

    def __call__(self, *args, **kwargs):
        self.i1 += 1
        if self.i1 >= 1003:
            raise StopIteration("停止遍历")
        return self.i1


p = P()
pt = iter(p)
ptt = iter(p, 1003)
print(pt)
print(pt is p)  # 二者地址一样
for i in pt:
    print(i)

for i in ptt:
    print('///', i)

结果如下图



就先这样，遇到别的再补充。