面向对象

练习的代码

std1 = {'name':'Michael', 'score':98}
std2 = {'name':'Bob', 'score':81}
def print_score(std):
    print('%s: %s' %(std['name'], std['score']))
print_score(std1)

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    #__init__方法的第一个参数永远是self，表示创建的实例本身
    def print_score(self):
        print('%s:%s' % (self.name, self.score))
bart = Student('bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
print('______________')
bart.print_score()
lisa.print_score()

class Student(object): #object表示Student类是从object类继承来的
    pass
bart = Student()
print(bart)
print(Student)
bart.name = 'Bart Simpson'
print(bart.name)

class Teacher(object):
    def __init__(self, name, subject):
        self.name = name
        self.subject = subject
    def print_subject(self):
        print('%s:%s' % (self.name, self.subject))
t = Teacher('wangxin', 'math')
t.print_subject()

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_name(self, name):
        self.__name = name
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')
    def print_score(self):
        print('%s:%s' % (self.__name, self.__score))
bart = Student('bart Simpson', 59)
lisa = Student('Lisa Simpson', 87)
#变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名
#双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：
bart._Student__score = 98
bart.print_score()
#有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

class Animal(object):
    def run(self):
        print('Animal is running……')
class Dog(Animal):
    def run(self):
        print('Dog is running……')
    def eat(self):
        print('Eating meat……')
class Cat(Animal):
    pass
dog = Dog()
dog.run()
cat = Cat()
cat.run()
#对真正的文件对象，它有一个read()方法，返回其内容。
# 但是，许多对象，只要有read()方法，都被视为“file-like object“。
# 许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。

class Timer(object):
    def run(self):
        print('Start……')
t1 = Timer()
t1.run()

t = type(123)
print(t)
t = type('str')
print(t)
t = type(None)
print(t)

t = type(abs)
print(t)
print(type(123) == type(456))
print(type(123) == int)
print(type('abc') == str)
#判断基本数据类型可以直接写int，str等，但如果要判断一个对象是否是函数怎么办？可以使用types模块中定义的常量：
import types
def fn():
    pass
print(type(fn) == types.FunctionType)
print(type(abs) == types.BuiltinFunctionType)
print(type(lambda x:x) == types.LambdaType)
print(type((x for x in range(10))) == types.GeneratorType)
#判断某个变量是否是某些类型中的一种
t = isinstance([1, 2, 3], (list, tuple))
print(t)
t = isinstance((1, 2, 3), (list, tuple))
print(t)
#如果要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list，
# 比如，获得一个str对象的所有属性和方法：
t = dir('ABC')
print(t)

#类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。
# 在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，
# 它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：
print(len('ABC'))
print('ABC'.__len__())
t = 'ABC'.lower()
print(t)
#我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法：
class MyDog(object):
    def __len__(self):
        return 100
dog = MyDog()
print(len(dog))

class MyObject(object):
    def __init__(self):
        self.x = 9
    def power(self):
        return self.x * self.x
obj = MyObject()
print(hasattr(obj, 'x'))
print(obj.x)
print(hasattr(obj, 'y'))
#给obj对象设置一个属性y
setattr(obj, 'y', 19)
print(hasattr(obj, 'y'))

print(getattr(obj, 'y'))
print(obj.y)
#可以在getattr中传入一个default参数，如果属性不存在，就返回默认值
print(getattr(obj, 'z', 404))
t = hasattr(obj, 'power')
print(t)
t = getattr(obj, 'power')
print(t())
sum = obj.x + obj.y
print(sum)
sum = getattr(obj, 'x') + getattr(obj, 'y')
print(getattr(obj, 'x'))
print(getattr(obj, 'y'))
print(sum)

#假设我们希望从文件流fp中读取图像，我们首先要判断该fp对象是否存在read方法，如果存在，则该对象是一个流，如果不存在，则无法读取。hasattr()就派上了用场。
#def readImage(fp):
#    if hasattr(fp, 'read'):
#        return readData(fp)
#    return None
class Student(object):
    def __init__(self, name):
        self.name = name
s = Student('Bob')
s.score = 90
#当我们定义了一个类属性后，这个属性虽然归类所有，但类的所有实例都可以访问到。
class Student(object):
    name = 'Student'
s = Student()
print(s.name)#  # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
print(Student.name)#打印类的name属性
s.name = 'Michael'
print(s.name)
print(Student.name)
del s.name
print(s.name)