类与对象
# 类的声明,括号中表示继承自哪个类,没有的话一般都是继承自object
class Student(object):
# 类属性
age = 18
# 类似于Java中的构造方法, 给属性一些初始化值
def __init__(self, name, score, sex):
# 实例属性
self.name = name
self.score = score
# 被双下划线"__"修饰的都是private属性,不能被外部访问
self.__sex = sex
"""
类中的方法,与普通函数的区别:第一个参数永远是self,表示创建的实例本身;
外部调用方法时不需要传self
"""
def print_info(self):
print("%s,%d,%s" % (self.name, self.score, self.__sex))
"""
提供set、get方法, 用于外部使用者对属性进行修改和获取
"""
def set_sex(self, sex):
self.__sex = sex
def get_sex(self):
return self.__sex
# 创建对象,并传入类属性初始化值
s = Student("Blain", 90, "male")
s.print_info() # Blain,90,male
s.score = 95
s.print_info() # Blain,95,male
s.set_sex("female")
print(s.get_sex()) # female
# 获取对象信息
print(hasattr(s, "name")) # True
# 判断是否有属性
print(hasattr(s, "grade")) # False
# 设置属性
setattr(s, "grade", 9)
print(hasattr(s, "grade")) # True
# 没有这个属性会报错
# print(getattr(s, "address"))
# 无属性时也可以自定义返回结果
print(getattr(s, "address", "没有这个属性")) # 没有这个属性
# 获取方法信息
fn = getattr(s, "print_info")
print(fn) # <bound method Student.print_info of <__main__.Student object at 0x100686320>>
fn() # Blain,95,female
# 类属性即可以用类来获取，也可以通过实例来获取，但实例属性的优先级比类属性要高
print(Student.age) # 18
print(s.age) # 18
面向对象高级编程
使用slots
-
给一个类动态的绑定属性和方法
from types import MethodType class People(object): pass p1 = People() p2 = People() # 动态的给实例p1绑定name属性 p1.name = "Blain" # 定义一个函数作为实例方法 def set_age(self, age): self.age = age # 动态的给实例p1绑定一个方法 p1.set_age = MethodType(set_age, p1) print(p1.name) # Blain p1.set_age(18) print(p1.age) # 18 # 给一个实例绑定的方法，对另一个实例是不起作用的 # p2.set_age(19) # AttributeError: 'People' object has no attribute 'set_age' # 为了给所有实例都绑定方法，可以给class绑定方法： def set_score(self, score): self.score = score People.set_score = set_score p1.set_score(80) print(p1.score) # 80 p2.set_score(90) print(p2.score) # 90 -
限制实例的属性
class People2(object): # 用tuple定义允许绑定的属性名称 __slots__ = ("name", "age") p3 = People2() p3.name = "Tom" p3.age = 16 # p3.score = 99 # AttributeError: 'People2' object has no attribute 'score'
slots定义的属性仅对当前类实例起作用，对继承的子类是不起作用
使用@property
修改和获取属性，可以通过实例对象直接获取属性来进行修改，但若这个属性是private的话就没办法修改；然后也可以通过类对外提供的set和get方法来获取属性或修改，不过这样的话略显繁琐。有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？之前有学到装饰器（decorator）可以给函数动态加上功能，Python内置的@property装饰器就是负责把一个方法变成属性调用的
class Student(object):
@property
def score(self):
return self.__score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError("score must be integer")
if value < 0 or value > 100:
raise ValueError("score must be between 0 ~ 100")
self.__score = value
s = Student()
s.score = 30 # 这里实际转化为s.set_score(60)
print(s.score) # 30 这里实际转化为s.get_score()
s.score = 1000
print(s.score) # ValueError: score must be between 0 ~ 100
多重继承
一个类是可以继承另一个类的，但以前都是单继承，若需要“混入”额外的功能，通过多重继承就可以实现。在Python中，这种设计通常称之为MixIn
class Animal(object):
pass
class Mamal(Animal):
pass
class Bird(Animal):
pass
class RunnableMixIn(object):
def run(self):
print("可以跑的动物")
class FlyableMixIn(object):
def fly(self):
print("可以飞的动物")
class Dog(Mamal, RunnableMixIn):
pass
# 很显然，鹦鹉既属于鸟类，也具有飞的功能
class Parrot(Bird, FlyableMixIn):
pass
但在Java中，一个类只能够进行单继承，所以MixIn这种设计不适用Java。
定制类
class Student(object):
def __init__(self, name):
self.name = name
self.a, self.b = 0, 1 # 初始化两个计数器a,b
# 自定义类输入信息,有点类似于java中的toString方法, 返回用户看到的字符串
def __str__(self):
return "Student object (name: %s)" % self.name
# 当在命令行交互模式下直接调用实例变量时,会调用这个方法,返回程序开发者看到的字符串;代码一般与__str__一致
__repr__ = __str__
# 如果一个类想被用于for ... in循环,就必须实现__iter__方法
def __iter__(self):
return self # 实例本身就是迭代对象,故返回自己
# 然后for循环就会不断调用该迭代对象的__next__方法拿到循环的下一个值,直到遇到StopIteration错误时退出循环
def __next__(self):
self.a, self.b = self.b, self.a + self.b # 计算下一个值
if self.a > 20:
raise StopIteration
return self.a
# 实现此方法能够使Student像list一样通过索引获取值
def __getitem__(self, item):
a, b = 1, 1
if isinstance(item, int): # item代表的是索引
for x in range(item):
a, b = b, a + b
return a
if isinstance(item, slice): # item代表的是切片
start = item.start
stop = item.stop
if start is None:
start = 0
l = []
for x in range(stop):
if x >= start:
l.append(a)
a, b = b, a + b
return l
# 当调用不存在的属性时,Python解释器会试图调用此方法来获得属性
# 这实际上可以把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段。
def __getattr__(self, attr):
if attr == "sex":
return "Male"
raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)
# 实现此方法能够让对象像函数那样直接调用,也就是把对象看成函数,把函数看成对象,它们都是在运行期间创建出来的
# 这样一来,我们就模糊了对象和函数数的界面,那如何来判断一个变量是对象还是函数呢? 可能通callable函数
def __call__(self):
print("My name is %s" % self.name)
# print(Student("Blain")) # Student object (name: Blain)
# for n in Student("Blain"):
# print(n) # 1,1,2,3,5,8,13
s = Student("Blain")
# print(s[0]) # 1
# print(s[1]) # 1
# print(s[2]) # 2
# print(s[3]) # 3
# print(s[4]) # 5
# print(s[:5]) # [1,1,2,3,5]
# print(s.age) # AttributeError: 'Student' object has no attribute 'age'
print(callable(s)) # True
print(callable("test")) # False
使用枚举类
Enum可以把一组相关常量定义在一个class中，且class不变，而且成员也可以直接比较
from enum import Enum, unique
Month = Enum("Month", ("Jan", "Feb", "Mar", "Apr", "May", "June", "July"))
# 单独的引用一个常量
print(Month.Jan) # Month.Jan
# 枚举它的所有成员
for name, member in Month.__members__.items():
# value属性是自动赋给成员的int常量,默认是从1开始
print(name, "=>", member, ",", member.value)
# Jan => Month.Jan , 1
# Feb => Month.Feb , 2
# Mar => Month.Mar , 3
# Apr => Month.Apr , 4
# May => Month.May , 5
# June => Month.June , 6
# July => Month.July , 7
# 自定义枚举类
@unique # @unique装饰器可以帮助我们检查保证没有重复值
class Weekday(Enum):
Sun = 0 # Sun的Value被设置为0
Mon = 1
Tue = 2
Wed = 3
Thu = 4
Fri = 5
Sat = 6
d1 = Weekday.Mon
print(d1) # Weekday.Mon
print(Weekday.Mon) # Weekday.Mon
print(Weekday["Mon"]) # Weekday.Mon
print(Weekday(1)) # Weekday.Mon
print(Weekday.Mon.value) # 1
print(d1 == Weekday(1)) # True
print(d1 == Weekday.Mon) # True