py面向对象编程（类属性/实例属性/实例方法、__私有变量、继承/多态/鸭子类型：如文件对象的read()方法、获取对象信息：dir()/isinstance()/hasattr()等）

#py面向对象编程.py
#类属性/实例属性/实例方法、__私有变量、继承/多态/鸭子类型：如文件对象的read()方法、获取对象信息：dir()/isinstance()/hasattr()等


# =============================================================================
# #面向对象编程（类属性/实例属性/实例方法、__私有变量、继承/多态）
# #面向对象的程序设计把计算机程序视为一组对象的集合，
# #每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
# #
# #Python中，所有数据类型都可以视为对象，当然也可以自定义对象。即创建Class类。
# #封装、继承和多态是面向对象的三大特点
# =============================================================================
'''
一、类属性 与 实例属性 及 实例方法
1、#使用： class来创建类，后面紧接着类名(类名通常首字母大写来区分与函数func)，紧接着是(object)表示继承于哪个类。所有类的基类都是 object
2、#使用：变量赋值来创建类实例化对象，类的的初始化方法__init__里如果有参数，则实例化对象需要填写参数。
3、#注意：如果删除 实例化对象属性 后，再次调用将会输出 同名的类属性。
#注意：类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。


二、类的内部访问限制（__私有变量）
#类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。

1、#使用：__两个下划线加在属性名称前面使其变成私有变量，私有变量有内部可以访问，外部不能直接访问。
2、#使用：定义实例化方法get和set方法 来供外部 访问和设置 私有变量方法。
#在定义方法中，可以对参数做检查，避免传入无效的参数

3、#注意：类对象的私有变量其实是解释器自动更改成了 _类名__变量名 的格式。


三、继承 和 多态/鸭子类型（如文件对象的read()方法）
1、#继承 即可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。
2、#多态 即鸭子类型 及 当子类和父类都拥有相同的类方法时，相当于子类方法覆盖了父类方法。
#多态的表现 即 动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。

#鸭子类型 即只要实现了参数调用的方法就可以作为参数来使用。例如文件对象的read()方法。

3、#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。


四、获取对象信息：type()/isinstance()/dir()/hasattr()、getattr()、setattr()
1、#使用：type(obj_or_name) 来获取对象类型
2、#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。

3、#使用：dir(obj) 来返回一个对象的所有属性和方法。
#注意：类似__XXX__这样的属性和方式是有特殊用途的，称为魔法属性、魔法方法。
#比如__len__方法返回长度,即a.__len__等同于len(a)
#普通属性和方法如 'ABC'.lower() 返回小写

4、#使用：hasattr(obj,'name')判断参数obj是否含有name属性或方法
5、#使用：getattr(obj,'name',value)获取参数obj对象的name属性,如果不存在则输出参数value
6、#使用：setattr(obj,'name',value)设置参数obj对象的name属性为参数value
#注意：参数name为字符串类型

7、#使用：hasattr(obj,'open') 来判断fp对象是否存在read方法，
#如果存在，则该对象是一个流，如果不存在，则无法读取。


'''



#################### 类属性 与 实例属性 及 实例方法
#使用： class来创建类，后面紧接着类名(类名通常首字母大写来区分与函数func)，紧接着是(object)表示继承于哪个类。所有类的基类都是 object

#使用：变量赋值来创建类实例化对象，类的的初始化方法__init__里如果有参数，则实例化对象需要填写参数。

#注意：如果删除 实例化对象属性 后，再次调用将会输出 同名的类属性。
#注意：类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。


#使用： class来创建类，后面紧接着类名(类名通常首字母大写来区分与函数func)，紧接着是(object)表示继承于哪个类。所有类的基类都是 object
class Student(object):          
    name='Stud'                       #类属性
    def __init__(self):               #通过参数self来指定该方法为实例化对象方法
        """初始化方法，通过self参数来指定 构建实例化对象的属性
        如果初始化方法内加上属性，则实例化对象时需要传入参数，否则报错
        """
        self.name='xiaoxiao'          #实例化属性
#        score=100                    #如果变量前不指定self，则此非实例化属性 
    def print_score(self):            #通过参数self来指定该方法为实例化对象方法
        print('%s: %s' %(self.name, self.score))
Student.name                          #输出类名称
Student.name='aaaa'                   #赋值修改类属性名称
Student.name                        

#使用：变量赋值来创建类实例化对象，类的的初始化方法__init__里如果有参数，则实例化对象需要填写参数。
s=Student('小王',99)                  #创建实例化对象
s.name                                #输出实例化对象属性
s.name='xiaowang'                     #赋值设置实例化对象属性
s.name                       

b=Student('小张',98)
b.name
b.print_score()                       #调用实例化对象方法

#注意：如果删除 实例化对象属性 后，再次调用将会输出 同名的类属性。
#注意：类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。
del b.name                     
b.name




#################### 类的内部访问限制（__私有变量）
#类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。

#使用：__两个下划线加在属性名称前面使其变成私有变量，私有变量有内部可以访问，外部不能直接访问。

#使用：定义实例化方法get和set方法 来供外部 访问和设置 私有变量方法。
#在定义方法中，可以对参数做检查，避免传入无效的参数

#注意：类对象的私有变量其实是解释器自动更改成了 _类名__变量名 的格式。


#使用：__两个下划线加在属性名称前面使其变成私有变量，私有变量有内部可以访问，外部不能直接访问。
class Student(object):
    def __init__(self, name, score):
        """类属性、实例化对象属性 的自由设置和删除，可通过私有名称来对其 访问限制。
        使用：__两个下划线加在属性名称前面使其变成私有变量，
        私有变量只有内部可以访问，外部不能直接访问。"""
        self.__name= name
        self.__score= score
    def print_score(self):
        print('%s: %s' %(self.__name,self.__score))

bart=Student('Bart Simpson',59)
#bart.__name                         #外部访问__私有变量将会异常。


#使用：定义实例化方法get和set方法 来供外部 访问和设置 私有变量方法。
#在定义方法中，可以对参数做检查，避免传入无效的参数
class Student(object):
    def __init__(self, name, score):
        self.__name=name
        self.__score=score
    """定义get方法来供外部访问属性 """
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    """定义set方法来供外部设置属性"""
    def set_name(self,name):
        self.__name=name
    def set_score(self,score):
        """#在定义方法中，可以对参数做检查，避免传入无效的参数"""
        if 0<=score<=100:
            self.__score=score
        else:
            raise ValueError('成绩输入有误（0-100）')
bart=Student('Bart Simpson',1000)
bart.get_name()
bart.get_score()

bart.set_name('ddd')
bart.get_name()

bart.set_score(101)    #超出参数设定，引发异常

#注意：类对象的私有变量其实是解释器自动更改成了 _类名__变量名 的格式。
#bart.__name           #私有变量外部不可访问
bart._Student__name    #私有变量名称其实是解释器自动更改成了 _类名__变量名 的格式。





#################### 继承 和 多态/鸭子类型（如文件对象的read()方法）
#继承 即可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。

#多态 即鸭子类型 及 当子类和父类都拥有相同的类方法时，相当于子类方法覆盖了父类方法。
#多态的表现 即 动态语言的鸭子类型特点决定了继承不像静态语言那样是必须的。

#鸭子类型 即只要实现了参数调用的方法就可以作为参数来使用。例如文件对象的read()方法。

#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。




#####继承
class Animal(object):
    def run(self):
        print('Animal is running...')
class Dog(Animal):
    """继承 即 可以把父类的所有功能都直接拿过来，这样就不必重零做起"""
    pass
class Cat(Animal):
    """子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写"""
    def run(self):
        print('Cat is running...')
dog=Dog() 
cat=Cat()
dog.run() 
cat.run()

#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。
help(isinstance)
isinstance(dog,Dog)      #dog属于Dog类
isinstance(dog,Animal)   #dog属于Animal类
isinstance(Animal,Cat)   #Animal不属于Cat类


#####多态
def run_twice(animal):
    """定义一个函数，执行两次参数对象的run()方法。
    即：参数为一个对象，该参数对象需要具备run方法"""
    animal.run()
    animal.run()
run_twice(Animal())
run_twice(cat)
run_twice(Cat())
"""#鸭子类型 即只要实现了参数调用的方法就可以作为参数来使用。例如文件对象的read()方法。"""
class Timer():
    def run(self):
        print('Start...')
run_twice(Timer())




#################### 获取对象信息：type()/isinstance()/dir()/hasattr()、getattr()、setattr()
#使用：type(obj_or_name) 来获取对象类型
#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。

#使用：dir(obj) 来返回一个对象的所有属性和方法。
#注意：类似__XXX__这样的属性和方式是有特殊用途的，称为魔法属性、魔法方法。
#比如__len__方法返回长度,即a.__len__等同于len(a)
#普通属性和方法如 'ABC'.lower() 返回小写

#使用：hasattr(obj,'name')判断参数obj是否含有name属性或方法
#使用：getattr(obj,'name',value)获取参数obj对象的name属性,如果不存在则输出参数value
#使用：setattr(obj,'name',value)设置参数obj对象的name属性为参数value
#注意：参数name为字符串类型

#使用：hasattr(obj,'open') 来判断fp对象是否存在read方法，
#如果存在，则该对象是一个流，如果不存在，则无法读取。



#####
#使用：type(obj_or_name) 来获取对象类型
type(123)
type('str')
type(object)
type(None)
type(abs)


#####
#使用：ininstance(obj,class_or_tuple) 来判断 参数boj对象 是否属于 参数2类型，返回Bool值。
help(isinstance)
isinstance(dog,Dog)      #dog属于Dog类
isinstance(dog,Animal)   #dog属于Animal类
isinstance(Animal,Cat)   #Animal不属于Cat类
#能用type()判断的基本类型也可以用isinstance()判断：
isinstance('str',str)
#还可以判断是某些类型的一种
isinstance([1,2,3,4],(list,tuple))


#####
#使用：dir(obj) 来返回一个对象的所有属性和方法。
#如dir(str)获取str的所有属性和方法
dir(str)
dir('123')
dir(Cat)    

#注意：类似__XXX__这样的属性和方式是有特殊用途的，称为魔法属性、魔法方法。
#比如__len__方法返回长度,即a.__len__等同于len(a)
#普通属性和方法如 'ABC'.lower() 返回小写
'ABC'.lower()


#####
#使用：hasattr(obj,'name')判断参数obj是否含有name属性或方法
#使用：getattr(obj,'name',value)获取参数obj对象的name属性,如果不存在则输出参数value
#使用：setattr(obj,'name',value)设置参数obj对象的name属性为参数value
#注意：参数name为字符串类型

help(hasattr)
help(getattr)
help(setattr)

class MyObject(object):
    def __init__(self):
        self.x=9
    def power(self):
        return self.x * self.x
obj=MyObject()

hasattr(obj,'x')      #返回True
hasattr(obj,'power')  #返回True
hasattr(obj,'y')      #返回False

getattr(obj,'x')
getattr(obj,'y',10)   #如果没有y属性和方法则输出参数10

setattr(obj,'y',11)
getattr(obj,'y')

#如果可以直接写：
sum = obj.x + obj.y
sum
#就不要写：
sum = getattr(obj, 'x') + getattr(obj, 'y')
sum


#使用：hasattr(obj,'open') 来判断fp对象是否存在read方法，
#如果存在，则该对象是一个流，如果不存在，则无法读取。
hasattr(obj,'open')