#定义类
#Student这种数据类型被视为一个对象,这个对象拥有name和score这两个属性(Property)。
#如果要打印一个学生的成绩,首先必须创建出这个学生对应的对象
#然后,给对象发一个print_score消息,让对象自己把自己的数据打印出来
#给对象发消息实际上就是调用对象对应的关联函数,我们称之为对象的方法(Method)
class Student(object):
#(object),表示该类是从哪个类继承下来的,通常,如果没有合适的继承类,就使用object类,这是所有类最终都会继承的类。
def __init__(self,name,score):
#self必不可少,必须位于其他形参的前面。
#当py调用这个__init__()方法来创建实例时,将自动传入self
#其本身是一个指向实例本身的引用,让实例能够访问类中的属性和方法。
self.name=name
self.score=score
#变量被关联到当前创建的实例
def print_score(self):
print('%s:%s' % (self.name,self.score))
def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >= 60:
return 'B'
else:
return 'C'
#在类中定义的函数只有一点不同,就是第一个参数永远是实例变量self,并且,调用时,不用传递该参数。
#除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。
bart=Student('Bart Simpson',59) #有了__init__方法,在创建实例的时候,必须传入与__init__方法匹配的参数
lisa=Student('Lisa Simpson', 87)
bart.print_score() #Bart Simpson:59
lisa.print_score() #Lisa Simpson:87
bart.score=100
bart.print_score() #Bart Simpson:100
print(bart.name) #Bart Simpson
#和静态语言不同,Python允许对实例变量绑定任何数据,
#也就是说,对于两个实例变量,虽然它们都是同一个类的不同实例,但拥有的变量名称都可能不同
bart.age=8
print(bart.age) #8 此处与C++中不同,允许实例绑定任何数据,而不要求一定是先定义的属性,但是该属性不会影响到其他对象的属性
#print(lisa.age) #报错误:AttributeError: 'Student' object has no attribute 'age'
#如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,
#在Python中,实例的变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问
class Student2(object):
def __init__(self, name, score):
self.__name = name #私有变量(必须是两个下划线)
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))
bart2=Student2('Bart Simpson',59)
lisa2=Student2('Lisa Simpson', 87)
bart2.print_score() #Bart Simpson:59
lisa2.print_score() #Lisa Simpson:87
#print(bart2.__name) #错误 AttributeError: 'Student2' object has no attribute '__name'
#但是仍然可以为对象重新绑定一个属性
bart2.__name='Hello'
print(bart2.__name) #Hello 此时应当是新建了一个属性,因此要避免为对象的属性随意赋值
#如果外部代码要获取name和score可以给Student类增加get_name和get_score这样的方法
#如果又要允许外部代码修改score,可以再给Student类增加set_score方法,在方法中,可以对参数做检查,避免传入无效的参数
class Student3(object):
def __init__(self, name, score):
self.__name = name
self.__score = score
def print_score(self):
print('%s: %s' % (self.__name, self.__score))
def get_grade(self):
if self.score >= 90:
return 'A'
elif self.score >= 60:
return 'B'
else:
return 'C'
def get_name(self):
return self.__name
def get_score(self):
return self.__score
def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError('bad score')
bart3=Student3('Bart Simpson',59)
bart3.__name='Hello'
print(bart3.__name) #Hello
#这个__name变量和class内部的__name变量不是一个变量!
#内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给bart新增了一个__name变量
print(bart3.get_name()) #Bart Simpson 内部的属性__name
#继承
class Animal(object):
def run(self):
print('Animal is running……')
class Dog(Animal):
def run(self): #子类的run()覆盖了父类的run()
print('Dog is running……')
class Cat(Animal):
def run(self):
print('Cat is running……')
Animaler=Animal()
Animaler.run() #Animal is running……
Doger=Dog()
Doger.run() #Dog is running……
Cater=Cat()
Cater.run() #Cat is running……
#多态 由于Animal类型有run()方法,因此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的run()方法
#对于一个变量,我们只需要知道它是Animal类型,无需确切地知道它的子类型,就可以放心地调用run()方法,
#而具体调用的run()方法是作用在Animal、Dog、Cat还是Tortoise对象上,由运行时该对象的确切类型决定,
#这就是多态真正的威力:调用方只管调用,不管细节,
#而当我们新增一种Animal的子类时,只要确保run()方法编写正确,不用管原来的代码是如何调用的。这就是著名的“开闭”原则:
#对扩展开放:允许新增Animal子类;
#对修改封闭:不需要修改依赖Animal类型的run_twice()等函数。
def run_twice(x):
x.run()
x.run()
run_twice(Animaler) #Animal is running…… Animal is running……
run_twice(Doger) #Dog is running…… Dog is running……
run_twice(Cater) #Cat is running…… Cat is running……
#静态语言 vs 动态语言
#对于静态语言(例如Java)来说,如果需要传入Animal类型,则传入的对象必须是Animal类型或者它的子类,否则,将无法调用run()方法。
#对于Python这样的动态语言来说,则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了:
class Timer(object):
def run(self):
print('Start...')
time=Timer()
time.run() #Start...
run_twice(time) #Start... Start...即不要求一定为run_twice传入Animal类型的对象
#判断对象的类型
#(1)type()
print(type(123)) #<class 'int'>
print(type('123')) #<class 'str'>
print(type(None)) #<class 'NoneType'>
print(type(abs)) #<class 'builtin_function_or_method'>
print(type(Animal)) #<class 'type'>
print(type(123)==type(345)) #True
print(type(123)==int ) #True
print(type('123')==str ) #True
print(type('123')==type(123)) #False
#如果要判断一个对象是否是函数怎么办?可以使用types模块中定义的常量:
import types
print(type(run_twice)==types.FunctionType) #True
print(type(abs)==types.BuiltinFunctionType) #True
print(type(lambda x:x*x) ==types.LambdaType) #True
print(type((x for x in range(10)))==types.GeneratorType) #True
#(2)使用isinstance()
print(isinstance(Animaler,Animal)) #True
print(isinstance(Doger,Dog)) #True
print(isinstance(Cater,Dog)) #False
print(isinstance(Doger,Animal)) #True
print(isinstance(Animaler,Dog)) #False
print(isinstance('a', str)) #True
print(isinstance(b'a', bytes)) #True
#还可以判断一个变量是否是某些类型中的一种
print(isinstance([1, 2, 3], (list, tuple))) #True
print(isinstance((1, 2, 3), (list, tuple))) #True
#(3)使用dir可以获得一个对象的所有属性和方法,它返回一个包含字符串的list
print(dir('ABC'))
#['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getat
#tribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__'
#, '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setat
#tr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', '
#expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'isl
#ower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'pa
#rtition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
#'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
#属性配合getattr()、setattr()以及hasattr(),我们可以直接操作一个对象的状态:
class MyObject(object):
def __init__(self):
self.x = 9
def power(self):
return self.x * self.x
return self.x * self.x
obj = MyObject()
print(hasattr(obj,'x')) #True
print(obj.x) # 9
setattr(obj, 'y', 19) # 设置一个属性'y'
print(hasattr(obj, 'y')) # 有属性'y'吗? True
print(getattr(obj, 'y')) # 19
print(getattr(obj, 'z', 404))#可以传入一个default参数,如果属性不存在,就返回默认值 404
fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
print(fn()) #81
#实例属性和类属性
#给实例绑定属性的方法是通过实例变量,或者通过self变量:
class Student4(object):
def __init__(self, name):
self.name = name
s = Student4('Bob')
s.score = 90
#如果Student类本身需要绑定一个属性,可以直接在class中定义属性,这种属性是类属性,归Student类所有,
#通过实例可以访问该属性,当通过实例为该属性进行赋值时,属于实例的属性的值变化,但是属于类的属性的值不变,
#当通过类直接为该属性赋值,就会改变其值
class Student4(object):
name = 'Student4' #相当于C++中的static静态成员变量
#定义了一个类属性后,这个属性虽然归类所有,但类的所有实例都可以访问到。
s = Student4() # 创建实例s
print(s.name) #Student4 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性
print(Student4.name) # Student4 打印类的name属性
s.name = 'Michael' # 给实例绑定name属性
print(s.name) #Michael 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性
print(Student4.name) #Student4 但是类属性并未消失,用Student.name仍然可以访问
del s.name # 如果删除实例的name属性
print(s.name) #Student4 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了
Student4.name='Bob'
print(Student4.name) #Bob 直接为类的变量赋值,就会改变