面向对象串讲

'''
文件处理
    read(3）：
        1 文件打开方式为文本模式时，代表读取3个字符
        2 文件打开模式为b模式时，代表读取3个字节
        
    f.tell() 指针位置为
    
    文件指针移动
        f.seek(offset,whence)
        
        offset --开始的偏移量，也就是代表需要移动偏移的字节数
        whence:可选，默认值为0 给offset参数一个定义，表示要从哪个位置开始偏移
            0 代表从文件开头开始算起 
            1 代表从当前位置开始算起  b模式下
            2 代表从文件末尾算起   b模式下
        
        
        f.seek(0,2) 偏移量0 移动到文件尾位置

函数：函数就是实现某一功能的工具
    函数的基本使用（原则：先定义，后调用）
        定义阶段发生什么事：只检测语法，不执行代码



面向过程思想：
    核心是‘过程’二字，过程指的是解决问题的步骤是，先干什么在干什么
    基于该思想编写程序，相当于一条流水线，一种机械式的思维方式

面向对象思想：
    核心是 对象 二字，对象指的是数据与方法的结合体。也就是容器
    基于该思想编写程序，就好比创造世界，一种上帝式的思维方式。
    

面向对象
    面向对象的核心就是对象二字，对象（对象就是容器，箱子）的精髓在于'整合'


1类与对象
    对象是特征与技能的结合体，即数据与方法。 容器/名称空间
    类则是一系列对象相似的特征与技能的结合体，即相似的数据与方法。 容器/名称空间
    
    类的两种用途：
        1 当容器去用
            类的数据属性
            类的函数属性
        2 调用类的过程称之为实例化，结果就是对象
            实例化时方式两件事：
                1 先产生一个空对象
                2 触发__init__(空对象,arg1,age2....)
                
    面向对象三大特性
        封装：
            把一堆数据属性与方法方法属性 整合 到对象里面。
            
        隐藏：
            __属性----》把属性变形了，即隐藏起来了！
        
        继承：
            父类是一些类共有的数据属性与方法属性的结合体
            子类可以继承父类的属性，还可以派生出自己独有的属性
        
        组合：
            1 即继承父类的属性，且不与父类耦合到一起
            2 把一个对象作为另一个对象的属性
            组合是继承的一种应用
        
        多态：
            1 抽象类
            2 鸭子类型
        
    对象的绑定方法
        给对象用的，由对象来调用，会自动把对象本身当做第一个参数传给self
    
    classmethod  staticmethod(非绑定方法） property
    
        property 装饰器 将被装饰的方法属性伪装成数据属性（像对象的name age sex之类的) 会自动加括号 然后内部代码是return出去返回值
        然后外部调用的时候就和调用数据属性类似 
    

2继承与派生
    1 什么是继承
        继承是一种新建类的方式，新建的类称之为子类/派生类，被继承类称之为父类/超类/基类

        继承描述的是一种遗传的关系，特点：
            1 子类可以遗传/重用父类的属性（减少代码冗余）
            2 一个子类可以同时继承多个父类
            3 在继承的背景下，类分为新式类与经典类

        子类如何重用父类属性？
        在继承背景下属性的查找顺序？？
        新式类 经典类

    2 为何要用继承
        解决类与类之间代码冗余的问题

    3 如何继承
     class Foo:
            pass

        class Bar(Foo):
            x=1

        obj=Bar()

     4 在子类派生新方法中重用父类功能的两种方式：
        方式一：指名道姓地访问某一个类的函数
            特点：
                1：与继承无关
                2：没有自动传值的效果
        方式二：super(自己的类名，self)会得到一个特殊的对象，该对象专门用来访问'父类'中的属性，完全参照mro列表
            特点：
                1 严格依赖继承，完全参照mro列表
                2 有自动传值的效果

3 组合
    1 什么是组合
        组合指的是一个对象拥有某一个属性，该属性的值来自于另一个类的对象
             class OldboyStudent:
            pass

        class OldboyTeacher:
            pass

        class Course:
            pass


        stu=OLdboyStudent()
        tea=OLdboyTeacher()

        obj=Course()

        stu.attr=obj
        tea.attr=obj

    2 为何要用组合
        解决类与类之间代码冗余的问题（例子是 教务系统管理员 与老师学生的初始化相同，老师与学生有选课功能）


4 多态
    多态指的是同一种事物的多种形态
    多态性：指的是可以在不用考虑具体类型前提下而直接使用对象
    多态的精髓就是'统一' 二字

    python 崇尚鸭子类型

5面向对象高级：
    1 反射：
        通过 字符串 来操作类与对象的属性
        hasattr()
            判断对象或者类的属性是否存在
            
        getattr()
            获取对象或类的属性
            参数1：对象（类也对象，存有数据属性，方法属性）
            参数2：‘属性名’
            参数3: 默认值 不存在的时候不会异常
        
        setattr()
            设置对象或者类的属性
            不存在则新建
        delattr()
            删除对象或类的属性
        
        
    
    2类的内置方法
        __init__(): 调用类的时候自动触发__init__。
        __str__():  在对象被打印时自动触发 可以自定义打印对象的内容（此方法内，必须return一个字符串类型的值）
        __del__:在对象被删除时先自动触发该方法，可以用来回收对象以外其他相关资源，比如系统资源

'''

# 一 绑定方法：绑定给谁就应该由谁类调用，谁类调用就会将谁当做第一个参数传入
#  1绑定给对象的方法：类中定义的函数默认就是绑定给对象的
#  2绑定给类的方法：为类中定义的函数加上一个装饰器classmethod


# 二：非绑定方法：即不与类绑定，又不与对象绑定，意味着对象和类都可以调用，无论谁来调用都是一个普通的函数，没有自动传值的效果

# class Foo:
#     def f1(self):
#         print(self)
#
#     @classmethod
#     def f2(cls):
#         print(cls)
#
#     @staticmethod
#     def f3(x,y):
#         print('f3',x+y)
#
#
# obj=Foo()
# # print(obj.f1)
# # obj.f1()
#
# # print(Foo.f2)
# # Foo.f2()
# # print(obj.f2)
# # obj.f2()
#
# print(Foo.f3)
# print(obj.f3)
#
# Foo.f3(1,2)
# obj.f3(3,4)

# 应用

# import  settings #导入settings下面的IP 和port
# class MySql:
#     def __init__(self,ip,port):
#         self.id=self.create_id()
#         self.ip=ip
#         self.port=port
#
#     def tell_info(self):
#         print('id:%s ip:%s port:%s'%(self.id,self.ip,self.port))
#
#     @classmethod  #提供额外的实例化方式，从配置文件中加载配置
#     def from_conf(cls):
#         return cls(settings.IP,settings.PORT)
#
#     @staticmethod
#     def create_id():
#         import uuid
#         return uuid.uuid4()
#
# # obj2=MySql('1.2.2.','3306')
# obj2=MySql.from_conf()
# # print(obj2.__dict__)
#
#
# obj2.tell_info()

class Bar:
    pass
class Foo(Bar):
    pass

print(issubclass(Foo,Bar)) #True   判断Foo是否是Bar的子类

obj=Foo()
print(isinstance(obj,Foo))  #True 判断obj是否是Foo的类型