一 对象的析构
析构：析构函数与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数
比如：
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('hello', 10)
当我们程序执行结束后，执行了del 析构函数，输出 删除对象成功
或者删除对象时执行
p1 = People('hello', 10)
del p1二 对象str和repr方法
作用是：返回一个可以用来表示对象的可打印字符串
继续使用上面的类
class People(object):
def __init__(self, name, age):
self.name = name
self.age = age
# 两者都是对对象的字符串的显示，使用场景不同
# 如果没有 __str__时， 自动调用 __repr__方法的内容
def __str__(self):
# print(对象名) print(str(对象名))
return 'People(%s,%d)' % (self.name, self.age)
def __repr__(self):
# print(repr(对象名)) 或者交互式环境中直接：用户名
return 'People(%s)' % (self.name)
if __name__ == '__main__':
p1 = People('hello', 10)
print(p1)
print(repr(p1))
print(str(p1))
用来显示对象的信息
三 字符串的format方法
1） 通过位置填充字符串
print('name:{0},age:{1},scores:{2}'.format('westos', 10, [100, 99, 78]))
print('name:{0},age:{1},scores:{0}'.format('westos', 10))
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） 通过下标或者索引填充字符串
point = (3,4)
print("x:{0[0]}, y:{0[1]}".format(point))
4） 面向对象操作
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 __str__(self):
return 'Book(%s, %d)' %(self.name, self.state)
b = Book('python', 'guido', 1, 'IND444')
print("name:{b.name}, state:{b.state}, author:{b.state}".format(b=b))
print("name:{0.name}, state:{0.state}, author:{0.state}".format(b))
第一个输出为通过对象填充
第二个输出为通过位置填充
四 formot魔术方法
formats = {
'ymd': "{d.year}-{d.month}-{d.day}",
'mdy': "{d.month}/{d.day}/{d.year}"
}
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:
format_spec = 'ymd'
fmt = formats[format_spec] # fmt 为 {d.year}-{d.month}-{d.day}
return fmt.format(d=self)
d = date(2018, 8, 25)
print(format(d))
print(format(d, 'mdy'))
通过format方法来调整日期的输出格式
五 类内部的装饰器
property：将类方法变为类属性
class Book(object):
def __init__(self, name, author, status, bookIndex):
self.name = name
self.author = author
# 0:已借出；1：未借出
self.__status = status
self.bookIndex = bookIndex
@property # 类内部装饰器
# 将类方法变为类属性
# 使用时，若没有装饰器b.status()
# 使用时，若有装饰器b.status
def status(self): # 让其显示为可示的状态，而不是 0 或者 1
if self.__status == 0:
return '未借出'
elif self.__status == 1:
return '已借出'
else:
return '状态异常'
@status.setter
#当修改属性status时，自动执行下面的方法 b.status=0
def status(self, value): # 如果人为的更改状态的话，将其局限于 0 或者 1
if value in (0, 1):
self.__status = value
else:
return 'error value'
def __str__(self):
return 'Book(%s,%d)' % (self.name, self.__status)
b = Book('python', 'guido', 1, 'UH32970')
print(b.status)
b.status = 0
print(b.status)
将类方法变为类属性，不用再去执行，直接调用即可
六 类的切片与索引
1） 如果能允许进行索引，那么就允许进行切片
class Student(object):
def __init__(self, name, scoers):
self.name = name
self.scores = scoers
def __getitem__(self, item):
# 获取索引对应的value值
return self.scores[item]
def __setitem__(self, key, value):
# 通过索引来修改value值
self.scores[key] = value
def __delitem__(self, key):
# 通过索引来删除value值
del self.scores[key]
#
#如果能允许进行索引，那么就允许进行切片
#
#索引操作
s = Student('westos', [10, 23, 43])
print(s[0])
s[0] = 12
del s[2]
print(s.scores)
#切片操作
print(s[:3])
s[1:]=[77,99]
print(s[:])
#删除操作
del s[2:]
print(s[:])
2） key——value
class Student(object):
def __init__(self, name, scoers):
self.name = name
self.scores = scoers
def __getitem__(self, item):
# 获取key对应的value值
return self.__dict__[item]
def __setitem__(self, key, value):
# 通过key来修改value值
self.__dict__[key] = value
def __delitem__(self, key):
# 通过key来删除value值
del self.__dict__[key]
s = Student('westos', [10, 23, 43])
print(s.__dict__)
print(s['name'])
print(s['scores'])
s['name'] = 'root'
print(s['name'])
del s['name']
print(s.__dict__)
3） 重复，连接,成员操作符，for循环
from collections import Iterable
class Student(object):
def __init__(self, name, scoers):
self.name = name
self.scores = scoers
self.power = 100
# s1+s2
def __add__(self, other):
return self.power + other.power
# s1*other
def __mul__(self, other):
return self.power * other
# 成员操作符
def __contains__(self, item):
return item in self.scores
# for循环
def __iter__(self):
return iter(self.scores)
s1 = Student('westos', [29, 54, 45])
s2 = Student('root', [33, 55, 22])
# 连接
print(s1 + s2)
# 重复
print(s1 * 3)
# 成员操作符
print(s1.scores)
print(22 in s1)
print(54 in s1)
# for循环
print(isinstance(s1, Iterable))
for i in s1:
print(i)
4） 比较大小
class Student(object):
def __init__(self, name, scoers, power):
self.name = name
self.scores = scoers
self.power = power
# s1>s2
def __gt__(self, other):
return self.power > self.power
# s1>=s2
def __ge__(self, other):
return self.power >= self.power
# s1==s2
def __eq__(self, other):
return self.power == self.power
# s1<s2
def __lt__(self, other):
return self.power < self.power
# s1<=s2
__le__ = lambda self, other: self.power <= self.power
# s1!=s2
__ne__ = lambda self, other: self.power != self.power
s1 = Student('westos', [37, 44, 75], 83)
s2 = Student('root', [55, 65, 23], 73)
s3 = Student('student', [33, 43, 45], 87)
print(s1 > s2)
print(s1 >= s2)
print(s1 == s2)
print(s1 < s2)
print(s1 <= s2)
print(s1 != s2)
七 实现单例模式
class Student(object):
def __init__(self, name, scores, power):
self.name = name
self.scores = scores
self.power = power
def __call__(self, *args, **kwargs):
return "对象被调用......"
# class: 实例化对象之前执行
def __new__(cls, *args, **kwargs):
# 判断是否obj对象是否已经被创建, 如果没有被创建， 则创建，
if not hasattr(cls, 'obj'):
cls.obj = object.__new__(cls)
# 如果已经创建成功，则返回创建好的对象
return cls.obj
s1 = Student('westos1', [101,100,100], 100)
s2 = Student('westos1', [101,100,100], 100)
print(s1)
print(s2)
单例模式的意思：就是说不管多少次实例化对象，都仅且有一个对象