Python下魔术方法的理解及应用

#######魔术方法的应用#######

 

 

 

## 魔术方法之构造函数_析构函数

 

# 构造函数_析构函数

class People(object):
    def __init__(self,name,age):
        # 把属性和对象名绑定在一起， 便于访问对象的属性.
        self.name =name
        self.age= age
        print('创建对象成功')
    #  析构函数, 当你删除对象时， 自动调用的方法。
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print('删除对象成功')

if __name__ =="__main__":
    p1 =People('kebo', 24)

运行结果：

可以看出在实例化后自动会执行__del__方法。

 

 

## str 与 repr 方法 (对象的字符串显示)

class People(object):
    def __init__(self, name, age):
        # 把属性和对象名绑定在一起， 便于访问对象的属性.
        self.name = name
        self.age = age
        print('创建对象成功')

    #  析构函数, 当你删除对象时， 自动调用的方法。
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print('删除对象成功')

    #  __str__和__repr__都是对对象的字符串显示， 使用场景不同.
    # 如果没有__str__的时候， 自动调用__repr__方法的内容.
    def __str__(self):
        return 'People(%s, %d)' % (self.name, self.age)

    def __repr__(self):
        # print(repr(对象名))  或者交互式环境中直接： 对象名
        return "People(%s)" % (self.name)


if __name__ == "__main__":
    p1 = People('kebo', 24)
    print(p1)
    print(p1.__str__())

 

class People(object):
    def __init__(self, name, age):
        # 把属性和对象名绑定在一起， 便于访问对象的属性.
        self.name = name
        self.age = age
        print('创建对象成功')

    #  析构函数, 当你删除对象时， 自动调用的方法。
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print('删除对象成功')

    #  __str__和__repr__都是对对象的字符串显示， 使用场景不同.
    # 如果没有__str__的时候， 自动调用__repr__方法的内容.
    # def __str__(self):
    #     return 'People(%s, %d)' % (self.name, self.age)

    def __repr__(self):
        # print(repr(对象名))  或者交互式环境中直接： 对象名
        return "People(%s)" % (self.name)


if __name__ == "__main__":
    p1 = People('kebo', 24)
    print(p1)
    print(p1.__str__())

 

 

## 字符串的format方法以及format魔术方法

- 字符串的format方法;

1 通过位置填充字符串

print("name:{0}, age:{1}, scores:{2}".format('kobe', 24, [8, 24, 81]))
print("name:{0}, age:{1}, scores:{0}".format('kobe', 10))
print("name:{0}, id:{1:.2f}".format('kobe', 3.1415926))

2 通过key值填充字符串

d = {'max': 100, 'min': 10}
print("MAX: {max}, MIN:{min}".format(max=100, min=10))
print("MAX: {max}, MIN:{min}".format(**d))

3 面向对象操作

class Book(object):
    def __init__(self, name, author, state, bookindex):
        self.name = name
        self.author = author
        self.state = state
        self.bookindex = bookindex

    def __repr__(self):
        return "Book(%s, %d)" % (self.name, self.state)


b = Book('python', 'houzeyu', 1, '24&8')
print(b)

print("Name:{0.name}, State:{0.state}, Author:{0.author}".format(b))
print("Name:{b.name}, State:{b.state}, Author:{b.author}".format(b=b))

 

- format 魔术方法

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    # format方法: format(对象名)时自动调用
    def __format__(self, format_spec=None):
        if not format_spec:
            return  "%s-%s-%s" %(self.year, self.month, self.day)
        else:
            if format_spec == 'ymd':
                return  "%s-%s-%s" %(self.year, self.month, self.day)
            elif format_spec == 'dmy':
                return   "%s/%s/%s" %(self.day, self.month, self.year)
            else:
                return  "error format"
d = Date(2019, 9, 5)
print(format(d))
print(format(d, 'ymd'))
print(format(d, 'dmy'))

 

 

 

## 类的内部装饰器

 

- @property

1)

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        self.__state = state
        self.bookIndex = bookIndex
    # 将类方法变成类属性
    # 使用时, 没有装饰器b.state()
    # 使用时, 有装饰器b.state
    @property
    def state(self):
        if self.__state == 0:
            return '已借出'
        elif self.__state == 1:
            return '未借出'
        else:
            return "状态异常"

    # 当修改属性state时, 自动执行下面的方法; b.state = 10
    @state.setter
    def state(self, value):
        # if value == 0 or value == 1:
        if value in (0, 1):
            # 更新书籍的状态
            self.__state = value

    @state.deleter
    def state(self):
        print("is deleteing......")

    def __str__(self):
        return 'Book(%s, %d)' % (self.name, self.__state)


b = Book('python', 'guido', 1, '1122334')
# print(b.state)
#
# # 1). 书籍的状态可以人以改变， 并不能限制只能为0或者1；
#   2). 书籍状态如何友好的显示?
# b.state = 10
# print(b.state)

# 3). 问题解决, 但是调用比较复杂, 可读性不高.
# print(b.get_state())
# print(b.set_state(10))
# print(b.get_state())


# 4).
print(b.state)
b.state = 0
print(b.state)

del b.state

2)

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0：'已借出' 1:'未借出'
        self.__state = state
        self.bookIndex = bookIndex

    def get_state(self):
        if self.__state == 0:
            return  '已借出'
        elif self.__state == 1:
            return  '未借出'
        else:
            return  "状态异常"

    def set_state(self, value):
        # if value == 0 or value == 1:
        if value in (0,1):
            # 更新书籍的状态
            self.__state = value

    def del_state(self):
        print("is deleteing......")

    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.__state)

    state = property(fget=get_state, fset=set_state, fdel=del_state)

b = Book('python', 'guido', 1, '1122334')
# print(b.state)
#
# # 1). 书籍的状态可以人以改变， 并不能限制只能为0或者1；
#   2). 书籍状态如何友好的显示?
# b.state = 10
# print(b.state)

# 3). 问题解决, 但是调用比较复杂, 可读性不高.
# print(b.get_state())
# print(b.set_state(10))
# print(b.get_state())


# 4).
print(b.state)
b.state = 0
print(b.state)

del  b.state

 

 

## 类的切片与索引

 

- 切片与索引

1)通过索引操作

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    # 支持索引; s[index]
    def __getitem__(self, index):
        return self.scores[index]

    # s[索引] = 修改的值
    def __setitem__(self, index, value):
        self.scores[index] = value

    # del s[索引]
    def __delitem__(self, index):
        del self.scores[index]


s = Student('houzeyu', [8, 24, 81, 60])

print(s[0])
print(s[2])

s[3]= 35000
print(s[3])
print(s.scores)
del s[1]
print(s.scores)
# 可以获取所有的属性为key值, 以及对应的value值, 并封装为一个字典返回.
print(s.__dict__)

运行结果:

 

2)通过字典操作

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    # 支持索引; s[key]
    def __getitem__(self, key):
        # print("获取索引对应的value值")
        return self.__dict__[key]

    # s[key] = 修改的值
    def __setitem__(self, key, value):
        self.__dict__[key] = value

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


s = Student('houzeyu', [8, 24, 81, 60])
print(s['name'])
print(s['scores'])

s['name'] = 'kobe'
print(s['name'])

s['scores'] = [1, 2, 3, 4]
print(s['scores'])

del s['name']
print(s)

 

3) 切片

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    def __getitem__(self, key):
        return self.scores[key]

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

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


s = Student('houzeyu', [8, 24, 81, 60])
print(s[1:3])
s[1:3] = [0, 0]
print(s[:])
del s[2:]
print(s[:])

 

 

## 重复与连接及成员操作符

 

from collections import Iterable


class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
        self.power = 100

    # obj1 + obj2
    def __add__(self, other):
        # 更新self对象的power属性值；
        self.power = self.power + other.power
        return self

    # obj1 * 3
    def __mul__(self, other):
        return self.power * other

    # 成员操作符； item in obj1
    def __contains__(self, item):
        return item in self.scores

    # 可以for循环迭代
    def __iter__(self):
        return iter(self.scores)

    def __repr__(self):
        return "Student:%s, %s" % (self.name, self.power)


s1 = Student('kobe', [101, 100, 100])
s2 = Student('james', [100, 100, 100])
s3 = Student('curry', [100, 100, 100])

print(s1.power + s2.power + s3.power)
print(s1*5)
print(200 in s1)

 

 

 

## 类方法与静态方法

 

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    # echo普通方法, 默认情况下会传递对象给echo
    def echo(self):
        return "%s %s %s" % (self.year, self.month, self.day)

    # 默认传递类本身给这个方法;
    @classmethod
    def as_string(cls, s):
        print(cls)
        month, day, year = s.split('/')
        d = cls(year, month, day)
        return d
    #  默认python解释器不会传递任何参数
    @staticmethod
    def is_valid(s):
        # 批量将年月日转换成整形(列表生成式， map)
        month, day, year = map(int, s.split('/'))
        return 0 < month <= 12 and 0 < day <= 31 and 1 < year < 9999

print(Date.as_string('12/10/2019').echo())
s = '10/10/2018'
print(Date.is_valid(s))

 

 

 

## 面向对象的反射机制

 

- hasattr, getattr, setattr, delattr

class Student(object):
    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def get_score(self):
        return "score"

    def get_grade(self):
        return 'grade'


s1 = Student("kobe", 81)
# hasattr: 判断对象是否包含对应的属性或者方法名;
print(hasattr(s1, 'name'))
print(hasattr(s1, '__age'))  # 私有属性， 私有方法， 是不能判断的；
print(hasattr(s1, 'score'))

print(hasattr(s1, 'get_score'))
print(hasattr(s1, 'set_score'))

# getattr: 用于返回对象的属性值或者方法名对应的方法体;
print(getattr(s1, 'name'))
print(getattr(s1, '__age', 'no attr'))
print(getattr(s1, 'get_score', 'no method'))  # 获取方法名， 如果要执行方法， 直接调用即可
print(getattr(s1, 'set_score', 'no method'))  # 获取方法名， 如果要执行方法， 直接调用即可

# setattr:
# 修改某个属性的值
setattr(s1, 'name', 'james')
print(getattr(s1, 'name'))

# 添加某个属性及对应的值;
setattr(s1, 'score', 100)
print(getattr(s1, 'score'))


# 修改方法
def get_score1():
    return "这是修改的方法内容"


setattr(s1, 'get_score', get_score1)
print(getattr(s1, 'get_score')())


def set_score():
    return "这是添加的方法"


# 添加方法
setattr(s1, 'set_score', set_score)
print(getattr(s1, 'set_score')())

# delattr
delattr(s1, 'name')
print(hasattr(s1, 'name'))

print(hasattr(s1, 'set_score'))
delattr(s1, 'set_score')
print(hasattr(s1, 'set_score'))

 

 

 

 

###########################