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('测试通过!')
