python learning OOP1.py

class Student(object):

    # 构造函数
    # 第一个参数永远是 self 表示一个实例本身，但是传参的时候不需要传
    # 在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    # 可以用 self 来表示类似 this 指针的作用
    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))


bart = Student('Bart', 59)
lisa = Student('Lisa', 89)
bart.print_score()
lisa.print_score()

# class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的
# 通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。
# 创建实例是通过类名+()实现的
# 可以自由地给一个实例变量绑定属性，比如，给实例bart绑定一个name属性：

bart.sno = 111500206
print(bart.sno)


# 继承与多态

class Animal(object):
    def run(self):
        print("Animal is running.")



class Dog(Animal):
    def run(self):
        print("Dog is running.")


class Cat(Animal):
    def run(self):
        print("Cat is running")


dog = Dog()
dog.run()

cat = Cat()
cat.run()



# 判断一个变量是否是某个类型可以用isinstance()判断：
a = [1,2,3]
print(isinstance(a, list))
print(isinstance(dog, Animal))
print(isinstance(dog, Dog))

print(isinstance(dog,Animal)) # 子类实例也是基类的实例

def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())
run_twice(Dog())
run_twice(Cat())

# 如果以后新增 Animal 的子类，则不需要对 run_twice 进行任何修改
# 这就是著名的“开闭”原则：对扩展开放：允许新增Animal子类；对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly...')

run_twice(Tortoise())


# Tip：

'''
对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。

对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了

这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
'''


# 获得对象信息
# 判断对象类型，使用type()函数：

print(type(123))
print(type('str'))
print(type(abs))
print(type(a))
print(type(dog))

print(type(123) == type(456))
print(type(123) == int)

# 判断一个对象是否是函数

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)

# 对于class的继承关系来说 ，可以使用isinstance()函数判断class的类型

class Husky(Dog):
    def run(self):
        print("Husky is running")

a = Animal()
d = Dog()
h = Husky()
print('isinstance test')
print(isinstance(h, Husky))
print(isinstance(d, Dog) and isinstance(d, Animal))
print(isinstance(d, Husky))

# isinstance  也可以当 type 有类似用法

print(isinstance('a', str))

# 还可以判断一个变量是否是某些类型中的一种

print(isinstance([1,2,3],(list,tuple)))
print(isinstance((1,2),(list,tuple)))

# 如果要获得一个对象的所有属性和方法，可以使用dir()函数

print(dir('ABC'))
print(dir(h))


'''

类似__xxx__的属性和方法在Python中都是有特殊用途的，比如__len__方法返回长度。在Python中，如果你调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__()方法，所以，下面的代码是等价的：

>>> len('ABC')
3
>>> 'ABC'.__len__()
3

其余的则是 普通属性或方法

'''

# 我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法：

class pig(Animal):
    def __len__(self):
        return 100

p = pig()
print(len(p))


# 实例属性和类属性

# 由于Python是动态语言，根据类创建的实例可以任意绑定属性。

class Undergraduate(object):
    name = 'Student'

s = Undergraduate()
print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
print(Undergraduate.name) # 类的 name 属性
s.name = "Michael"
print(s.name) 

del s.name # # 如果删除实例的name属性
print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了

# 练习：
# 为了统计学生人数，可以增加一个类属性，每创建一个实例，该属性自动增加：

class Undergraduate(object):
    count = 0
    def __init__(self,name):
        self.name = name
        Undergraduate.count += 1

if Undergraduate.count != 0:
    print('测试失败!')
else:
    bart = Undergraduate('Bart')
    if Undergraduate.count != 1:
        print('测试失败!')
    else:
        lisa = Undergraduate('Bart')
        if Undergraduate.count != 2:
            print('测试失败!')
        else:
            print('Undergraduates:', Undergraduate.count)
            print('测试通过!')