t between 0 ~ 100!')
self._score = value
s = Student()
s.score = 60 # OK,实际转化为s.set_score(60)
s.score # OK,实际转化为s.get_score()
s.score = 9999 # error
(3). 多重继承MixLn的设计
MixIn的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个MixIn的功能,而不是设计多层次的复杂的继承关系
class Animal(object):
pass
class Bird(Animal):
pass
class Parrot(Bird):
pass
# 此时我们需要加入额外的功能fly
# 先定义好fly的类
class Flyable(object):
def fly(self):
print('Flying...')
# 同时继承两个类
class Parrot(Bird, Flyable):
pass
(4). 定制个性化类
1): __str__
和 __repr__
让打印的object更漂亮:
__str__
: 用print打印
__repr__
: 直接输入对象名
class Student(object):
# 加下划线
def __init__(self, name):
self.__name = name
def __str__(self):
msg = 'Student name is' + self.__name
return msg
__repr__ = __str__
s = Student()
print(s) # 打印出 Student name is.....
s # 效果跟上面的一样
2): __iter__
将类定义成类似list或者tuple那种,可以用于for循环的作用
class Fib(object):
def __init__(self):
self.a, self.b = 0, 1 # 初始化两个计数器a,b
def __iter__(self):
return self # 实例本身就是迭代对象,故返回自己
def __getitem__(self, n):
if isinstance(n, int): # n是索引
a, b = 1, 1
for x in range(n):
a, b = b, a + b
return a
if isinstance(n, slice): # n是切片
start = n.start
stop = n.stop
if start is None:
start = 0
a, b = 1, 1
L = []
for x in range(stop):
if x >= start:
L.append(a)
a, b = b, a + b
return L
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 100000: # 退出循环的条件
raise StopIteration()
return self.a # 返回下一个值
for i in Fib():
print(n) # 1,1,2,3,5,.......,75025
# 因为__getitem__的作用,可以index某个值
f = Fib()
f[0] # 1
# 也可以切片
print(f[0:5]) # 1,1,2,3,5
3): __call__
直接在实例本身上调用的一种构造方法
class Student(object):
def __init__(self, name):
self.name = name
def __call__(self):
print('My name is %s.' % self.name)
s = Student('Michael')
s() # My name is Michael.
- 实例进行直接调用就好比对一个函数进行调用一样,所以你完全可以把对象看成函数,把函数看成对象
4) 枚举类Enum
定义常量
from enum import Enum, unique
# unique保证没有重复值
@unique
class Weekday(Enum):
Sun = 0 # Sun的value被设定为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
# 访问枚举类
print(Weekday.Mon) # Weekday.Mon
print(Weekday.Mon.value) # 1
print(Weekday(1))) # # Weekday.Mon
5) type()
动态创建类Class
type()
函数既可以返回一个对象的类型,又可以创建出新的类型
type()和Class()的功能是一样的
要创建一个class对象,type()函数依次传入3个参数:
- class的名称;
- 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
- class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。
def fn(self, name='world'): # 先定义函数
print("hello", name)
Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
4. 错误处理
(4.1).try-catch->有错误后就结束了不执行以后的
try:
print('try...')
r = 10 / int('a')
print('result:', r)
except ValueError as e:
print('ValueError:', e)
except ZeroDivisionError as e:
print('ZeroDivisionError:', e)
finally:
print('finally...')
print('END')
try...
except: division by string
finally...
END
用try
来运行这段代码,如果执行出错,则后续代码不会继续执行,而是直接跳转至错误处理代码,即except
语句块,执行完except
后,如果有finally
语句块,则执行finally
语句块,至此,执行完毕。
(4.2).logging->有错误了打印完信息后继续执行
import logging
def foo(s):
return 10 / int(s)
def bar(s):
return foo(s) * 2
def main():
try:
bar('0')
except Exception as e:
logging.exception(e)
main()
print('END')
# 结果
ERROR:root:division by zero
Traceback (most recent call last):
File "err_logging.py", line 13, in main
bar('0')
File "err_logging.py", line 9, in bar
return foo(s) * 2
File "err_logging.py", line 6, in foo
return 10 / int(s)
Zer