python-------面向对象，继承，封装，多态

''
面向对象编程
'''
class Student(object):
    #初始化方法定义 self 指向实例化的本身
    def __init__(self,name,age,score):
        self.name = name
        self.age  = age
        self.score  = score

    def print_score(self):
        print('%s: %s: %s' % (self.name,self.age,self.score))
#实例化两个对象
# xiaohong，xiaoming就相当于是两个对象，可以直接打点调用本身的属性
xiaohong = Student('xiaohong',14,98)
xiaoming = Student('xiaoming',15,99)
#print(xiaoming.name)
#print(type(xiaoming.name))
#xiaohong.print_score()
#xiaoming.print_score()
#print(id(xiaohong))#分配不同的内存空间，每一次实例化 都会分配不同的内存控件
#print(id(xiaoming))

'''
    封装，继承，多态
'''
class Student(object):
    #初始化方法定义 self 指向实例化的本身
    def __init__(self,name,age,score):
        self.name = name
        self.age  = age
        self.score  = score

    def print_score(self):
        print('%s: %s: %s' % (self.name,self.age,self.score))

    def get_score(self):
        if self.score >=90:
            return  'A'
        elif self.score >=60:
            return  'B'
        else:
            return 'C'

xiaosan = Student('xiaosan',15,99)
#print(xiaosan.get_score())

'''
    访问限制
    类中初始化的时候的属性如果希望是"私有属性"可以在self
    调用的时候在前面添加两个下划线“_”比如：
    self.name = name 修改为self.__name = name
    变成私有属性之后就不能通过属性访问了比如：print(xiaoming.name) 这种不能访问
    需要通过方法访问属性
'''

class Student(object):
    #初始化方法定义 self 指向实例化的本身
    def __init__(self,name,age,score):
        self.__name = name
        self.__age  = age
        self.__score  = score

    def print_score(self):
        print('%s: %s: %s' % (self.__name,self.__age,self.__score))
    def get_level(self):
        if self.__score >=90:
            return  'A'
        elif self.__score >=60:
            return  'B'
        else:
            return 'C'
    def set_score(self,score):
        if 0<score<100:
            self.__score = score
        else:
            raise ValueError('大于0小于100')
    def get_score(self):
        return  self.__score


#xiaosan = Student('xiaosan',15,64)
#print(xiaosan.set_score(44))
#print(xiaosan.get_score())

'''
实例属性 ：
    必须通过初始化或者实例化对象,通过对象去访问
类属性：
    不需要实例化对象，直接通过类名访问 
'''
#实例属性
class Student(object)   :
    def __init__(self, name):
        self.name = name
#s = Student('Bob')
#print(id(s))
# s = Student('Bob')
#print(id(s))
#print(s.name)
#类属性
class Student(object):
    name = 'Student'
#print(Student.name)

'''
    总结今日：
    1.类定义的时候使用class关键字，初始化函数的时候使用 __init__(self):
      其中self是关键字,pyThon自带的（self 指向实例化的本身），self后面可以跟其余的变量名称
    2. 访问限制
        类中初始化的时候的属性如果希望是"私有属性"可以在self
        调用的时候在前面添加两个下划线“_”比如：
        self.name = name 修改为self.__name = name
        变成私有属性之后就不能通过属性访问了比如：print(xiaoming.name) 这种不能访问
        需要通过方法访问属性（在使用set和get方法的时候也是需要使用）比如
        def set_score(self,score):
            if 0<score<100:
                self.__score = score
            else:
                raise ValueError('大于0小于100')
        def get_score(self):
            return  self.__score
    3.实例属性和类属性
        实例属性定义的位置是在_init_方法里面的,类属性定义的位置是在类中，函数之外
        实例属性每次实例化就会生成一个属性的对象,在内存中的地址不一样
    #实例属性
    class Student(object)   :
        def __init__(self, name):
            self.name = name
    s = Student('Bob')
    print(s.name)
    #类属性
    class Student(object):
        name = 'Student'
        print(Student.name)
'''



class Student(object):
    def __init__(self, name, gender):
        self.name = name
        self.__gender = gender

    def set_gender(self,gender):
        if gender=='男' or gender =='女':
            self.__gender = gender
        else:
            raise ValueError('输入不合法')
    def get_gender(self):
        return self.__gender

stu1 = Student('fengxuegang','男')

print(stu1.name)
stu1.set_gender('123')
print(stu1.name)
print(stu1.get_gender())












class Animal(object):
    def run(self):
        print("----------------动物跑")





class Dog(Animal):#继承
    def run(self): #如果定义的函数名称和参数和父类定义的函数一样的话，则重写了父类的方法
       # super().run()#调用父类的run方法
        print("----------------狗在奔跑")
class Cat(Animal):#继承
    def run(self): #如果定义的函数名称和参数和父类定义的函数一样的话，则重写了父类的方法
       # super().run()#调用父类的run方法
        print("----------------猫在奔跑")
'''
    多态
'''
a = Dog()
b = Animal()
print(isinstance(a,Dog))#True
print(isinstance(a,Animal))#True
print(isinstance(b,Dog))#False
print(isinstance(b,Animal))#True

#调用runs方法，需要传递 Animal类的对象或者Animal 的子类
def runs(animal):
    animal.run()

runs(Dog())
runs(Cat())
runs(Animal())

'''
类型判断
'''
import types
def fn():
    pass
print(type(fn)==types.FunctionType)