python之面向对象

面向过程，函数式，面向对象三者之间的区别：

• 面向过程：根据业务逻辑从上到下写垒代码
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...

1.类的基本结构
class A:
    name = 'alex' #  静态属性，静态变量，静态字段。

    def func1(self):  # 函数，动态属性，方法。
        pass

2.函数与面向对象的区别
    1，函数封装一个功能，而面向对象封装多个相关的功能。
    2，面向对象抽象，它是一种思想，站在上帝的角度去理解他。
    3，程序可扩展，对象都是一个个独立的。耦合性，差异性。

3.类与对象的区别
    类：具有相同属性或者功能的一类实物。
    对象：对象是类的具体体现。
类的申明：
　　class 类名:　#class申明一个类，类名首字母大写
　　　　类属性　　
　　　　类方法

实例化：类名加括号就是实例化，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

class Person:   #定义一个人类
    role = 'person'  #人的角色属性都是人
    def __init__(self,name):
        self.name = name  # 每一个角色都有自己的昵称;
        
    def walk(self):  #人都可以走路，也就是有一个走路方法
        print("person is walking...")


print(Person.role)  #查看人的role属性
print(Person.walk)  #引用人的走路方法，注意，这里不是在调用

实例化的过程就是类——>对象的过程

原本我们只有一个Person类，在这个过程中，产生了一个egg对象，有自己具体的名字、攻击力和生命值。

语法：对象名 = 类名(参数)

实例化过程内部进行了三个阶段：
1,在内存中开辟了一个对象空间
2，自动执行类中的__init__方法，并且将对象空间自动传给self参数，其他参数手动传入。
3， 执行__init__方法 给对象空间封装相应的属性。

self

self：在实例化时自动将对象/实例本身传给__init__的第一个参数

类属性的补充

一：我们定义的类的属性到底存到哪里了？有两种方式查看
dir(类名)：查出的是一个名字列表
类名.__dict__:查出的是一个字典，key为属性名，value为属性值

二：特殊的类属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类
类名.__bases__# 类所有父类构成的元组
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类(仅新式类中)

print(Person.animal)  # 查
print(Person.language)
Person.name = 'alex'  # 增
print(Person.name)
Person.animal = '低级动物' # 改
del Person.walk_way  # 删
print(Person.__dict__)

查看,（增删改）类中某个，某些属性 用万能的点 .

类名称空间与对象的名称空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

• 静态属性就是直接在类中定义的变量
• 动态属性就是定义在类中的方法

其中类的数据属性是共享给所有对象的，而类的动态属性是绑定到所有对象的。

创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性

对象操作对象空间
        对象查看对象空间所有的属性  __dict__
        print(obj.__dict__)
        对象操作对象的某个属性 增删改查  万能的点.
    　　对象操作类空间的属性 只能查
对象能调用类中的属性与方法而且只是调用不能改变
对象与对象之间可不可互相调用？
同一个类实例化出来的对象之间是不能互相访问的。
不同类实例化的对象有可能互相访问。
给对象封装属性：__init__ 任意位置。

组合： 给一个类的对象封装一个属性，这个属性是另一个类的对象。
组合的意义：让类的对象与另一个类的对象产生关系，类与类之间产生关系

class Gamerole:
    def __init__(self,nickname,ad,hp):
        self.nickname = nickname
        self.ad = ad
        self.hp = hp

    def attack(self,role):
        role.hp = role.hp - self.ad
        print('%s攻击%s,%s掉了%s血,还剩%s血' %
              (self.nickname,role.nickname,role.nickname,self.ad,role.hp))

    def equip_weaon(self,w):  # 给人物封装了一个武器属性，这个属性值是Weapon类的一个对象
        self.weapon = w   # 组合


class Weapon:
    def __init__(self,name,ad):
        self.name = name
        self.ad = ad
    def fight(self,role1,role2):
        role2.hp = role2.hp - self.ad
        print('%s 用 %s 攻击了%s, %s掉了%s血,还剩%s血'
              %(role1.nickname,self.name,role2.nickname,role2.nickname,self.ad,role2.hp))

p1 = Gamerole('盖伦',20,500)
p2 = Gamerole('剑豪',100,200)
p1.attack(p2)
print(p2.hp)
w1.fight(p1,p2) # 这样不好，动作的发起者应该是人而不是武器
w1 = Weapon('大宝剑',30)
w2 = Weapon('武士刀',80)
print(w1)
p1.equip_weaon(w1)
print(p1.weapon)  #其实 他就是w1
p1.weapon.fight(p1,p2)
让剑豪利用武士刀给盖伦一刀
p2.equip_weaon(w2)
p2.weapon.fight(p2,p1)

 面向对象三大特性（封装，继承，多态）

1.封装
封装的定义
    隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装的优点：
    1. 将变量隔离；
    2. 便于使用；
    3. 提高复用性；
    4. 提高安全性；
封装原则
      1. 将不需要对外提供的内容都隐藏起来；
      2. 把属性都隐藏，提供公共方法对其访问。

封装的分类：广义封装和狭义封装
广义上的封装（把属性函数都放到类里）
class 类名:
    def 方法1(self):pass
是为了只有这个类的对象才能使用定义在类中的方法

狭义上的封装（定义私有成员，私有变量和私有方法）
把一个名字藏在类中（采用变量名前加双下划线方式）
class Goods:
    __discount = 0    # 私有的静态变量
    print(__discount)
print(Goods.__discount)  # 在类的外部不能引用私有的静态变量
类中的静态变量和方法名在程序加载的过程中就已经执行完了，不需要等待调用
在这个类加载完成之前，Goods这个名字还没有出现在内存空间中
私有的静态属性可以在类的内部使用，用来隐藏某个变量的值
类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.

A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，
即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，
    知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形

class Goods:
    __discount = 0    # 私有的静态变量
    # 变形 ： _类名__私有变量

print(Goods.__dict__)
print(Goods._Goods__discount)  # 编程规范的角度上出发 我们不能在类的外部使用私有的变量

class Srudent:
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    def name(self):
        return self.__name
zhuge = Srudent('诸葛',20)
print(zhuge.name())
print(zhuge.age)
zhuge.age = 'aaaa'
print(zhuge.age)

class Goods:
    __discount = 0.7    # 私有的静态变量
    def __init__(self,name,price):
        self.name = name
        self.__price = price

    def price(self):
        return self.__price * Goods.__discount

    def change_price(self,new_price):
        if type(new_price) is int:
            self.__price = new_price
        else:
            print('本次价格修改不成功')

apple = Goods('APPLE',5)
print(apple.price())
apple.change_price('aaaa')
print(apple.price())

class User:
    def __init__(self,username,password):
        self.usr = username
        self.__pwd = password
        self.pwd = self.__getpwd()

    def __getpwd(self):
        return hash(self.__pwd)

obj = User('alex','alex3714')
print(obj.usr,obj.pwd)

类中的私有成员：
    私有的静态属性
    私有的对象属性
    私有的方法

我为什么要定义一个私有变量呢：
    我不想让你看到这个值
    我不想让你修改这个值
    我想让你在修改这个值得时候有一些限制
    有些方法或者属性不希望被子类继承

私有变量能不能在外部被定义？？？

class A :
    __country = 'China'  # 在类的内部会发生变形
    print(__country)      # '_A__country'
print(A.__dict__)
A.__Language = 'Chinese'
print(A.__dict__)

私有变量能不能被继承？？？

class A:
    __country = 'China'
    def __init__(self,name):
        self.__name = name  # '_A__name'

class B(A):
    # print(__country)
    # NameError: name '_B__country' is not defined
    def get_name(self):
        return self.__name  # '_B__name'

b = B('alex')
print(b.__dict__)

property是一个装饰器函数
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,
根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
所有的装饰器函数都怎么用？ 在函数、方法、类的上面一行直接@装饰器的名字
装饰器的分类：
    装饰函数
    装饰方法 ： property
    装饰类

class Student:
    def __init__(self,name,age):
        self.__name = name
        self.age = age
    @property   # 将一个方法伪装成一个属性
    def name(self):
        return self.__name
zhuge = Student('诸葛',20)
print(zhuge.name)

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def area(self):
        return self.r ** 2 * pi
    @property
    def perimeter(self):
        return 2 * self.r * pi

c1 = Circle(10)
print(c1.area)
print(c1.perimeter)
c1.r = 5
print(c1.area)
print(c1.perimeter)

一个方法被伪装成属性之后
应该可以执行一个属性的增删改查操作
那么增加和修改 就对应这被setter装饰的方法 ：这个方法又一个必传的参数new，表示赋值的时候等号后面的值
删除一个属性 对应着 被deleter装饰的方法，这个方法并不能在执行的时候真的删除这个属性，而是你在代码中执行什么就有什么效果
一个静态属性property本质就是实现了get，set，delete三种方法

class Foo:
    @property
    def AAA(self):
        print('get的时候运行我啊')

    @AAA.setter
    def AAA(self,new):
        print('set的时候运行我啊')

    @AAA.deleter
    def AAA(self):
        print('delete的时候运行我啊')

#只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
f1=Foo()
f1.AAA
f1.AAA='aaa'
del f1.AAA

property的应用

class Goods:

    def __init__(self):
        # 原价
        self.original_price = 100
        # 折扣
        self.discount = 0.8

    @property
    def price(self):
        # 实际价格 = 原价 * 折扣
        new_price = self.original_price * self.discount
        return new_price

    @price.setter
    def price(self, value):
        self.original_price = value

    @price.deleter
    def price(self):
        del self.original_price


obj = Goods()
obj.price         # 获取商品价格
obj.price = 200   # 修改商品原价
print(obj.price)
del obj.price     # 删除商品原价

2.继承
    # 继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类
    # 父类又可称为基类或超类，新建的类称为派生类或子类
查看继承方法

    # subclass.__bases__
    #如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。
    #>>> ParentClass1.__bases__
        (<class 'object'>,)
        >>> ParentClass2.__bases__
        (<class 'object'>,)继承与抽象（先抽象后继承）

    抽象即抽取类似或者说比较像的部分
    继承：是基于抽象的结果，通过编程语言去实现它，
    肯定是先经历抽象这个过程，才能通过继承的方式去表达出抽象的结构。
继承的分类：
1.单继承
    语法 ： 子类名（父类名）
    继承与重用
        # 子类可以使用父类中的名字（变量和方法）
    继承与派生
        # 子类在父类的基础上又新创建了自己需要的方法和属性
    父类有的子类没有 - 子类对象直接调用 就会直接执行父类的方法
    父类有的子类也有 - 子类对象调用 直接执行子类中的方法
    想在子类中使用父类的名字 ： 父类名、super()去调用
    当子类当中有要被调用的方法的时候，子类的对象会直接选择子类中的方法、变量,父类中的方法不会被自动执行
    如果我们既想要执行子类的方法，也想要执行父类的方法，那么需要在子类的方法中调用父类的方法：
    1.父类名.方法名(self,...)
    2.super().方法名(...)
抽象类
    抽象类是一个规范，它基本不会实现什么具体的功能，抽象类是不能被实例化
    要想写一个抽象类
        from abc import ABCMeta,abstractmethod
        在这个类创建的时候指定 metaclass = ABCMeta
        在你希望子类实现的方法上加上一个 @abstractmethod装饰器
    使用抽象类
        继承这个类
        在创建新类时，必须实现这个类中被@abstractmethod装饰器装饰的方法
        如果没有写入这个方法则会报错
        TypeError: Can't instantiate abstract class qq with abstract methods pay, shouqian

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):   # 模板的功能
    @abstractmethod     # abstractmethod是一个装饰器，装饰器怎么用？放在函数/类的上一行
    def pay(self):pass

    @abstractmethod
    def shouqian(self):pass

class Alipay(Payment):
    def pay(self,money):
        print('使用支付宝支付了%s元'%money)

class Wechatpay(Payment):
    def pay(self,money):
        print('使用微信支付了%s元'%money)

class ApplePay(Payment):
    def pay(self,money):
        print('使用applepay支付了%s元' % money)

def pay(obj,money):
    obj.pay(money)

2.多继承
    不是所有的语言都支持多继承 java
    c++ 支持多继承

class Animal:
    def __init__(self,name):
        self.name = name
    def talk(self):
        print('%s说话了'%self.name)

    def swim(self):
        print('%s在游泳'%self.name)

    def fly(self):
        print('%s在飞'%self.name)

    def walk(self):
        print('%s在走路'%self.name)
class Animal:
    def __init__(self,name):
        self.name = name

class FlyAnimal(Animal):
    def fly(self):
        print('%s在飞' % self.name)
class WalkAnimal(Animal):
    def walk(self):
        print('%s在走路'%self.name)
class SwimAnimal(Animal):
    def swim(self):
        print('%s在游泳'%self.name)

class Tiger(SwimAnimal,WalkAnimal):
    pass

class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    pass

class Parrot(FlyAnimal,WalkAnimal):
    def talk(self):
        print('%s说话了'%self.name)

swan = Swan('天鹅')
swan.fly()
swan.walk()

继承原理

    python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，

    这个MRO列表就是一个简单的所有基类的线性顺序列表，例如
    >>> F.mro() #等同于F.__mro__
    [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, 
            <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

    这个MRO列表的构造是通过一个C3线性化算法来实现的
    有父类的MRO列表并遵循如下三条准则:
    1.子类会先于父类被检查
    2.多个父类会根据它们在列表中的顺序被检查
    3.如果对下一个类存在两个合法的选择,选择第一个父类

继承的作用：
    减少代码的重用
    提高代码可读性
    规范编程模式

抽象中的几个概念：
    抽象：抽象即抽取类似或者说比较像的部分。是一个从具题到抽象的过程。
    继承：子类继承了父类的方法和属性
    派生：子类在父类方法和属性的基础上产生了新的方法和属性

多继承问题
在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口
钻石继承
新式类：广度优先
经典类：深度优先

接口
    # java c# 不允许多继承
    # 接口 Interface  接口可以被多继承

    # Interface FlyAnimal:  # 规范继承我的类必须实现这个方法
        # def fly():pass    #java不允许写任何代码

    # Interface WalkAnimal:
         #def walk():pass

    # Interface SwimAnimal:
        # def swim():pass

    # class Tiger(WalkAnimal,SwimAnimal):  继承了一个规范
    #     def walk():代码
    #     def swim():代码

新式类和经典类
新式类中
    所有的多继承关系寻找方法的顺序  -  遵循广度优先算法
    继承object
    mro方法
    super : super不是单纯的找父类，而是遵循mro顺序的
新式类
在python3.x版本中 所有的类都是新式类
所有的新式类都有一个默认的父类  ： object
    #class Person1:pass
    # class Person2():pass
    # class Person3(object):pass
    # # p = Person2()  # __init__ 初始化方法
    # print(Person1.__bases__)
    # print(Person2.__bases__)
    # print(Person3.__bases__)

python 2.7
经典类 和 新式类 并存
class Student:pass # 经典类
class Student(object):pass

继承了object的类就是新式类
在py3中所有的类都是新式类
在py2中既有新式类又有经典类

多继承的顺序 在新式类和经典类之间的区别

class A:
    def func(self):
        print('A')

class B(A):
    pass
    # def func(self):
    #     print('B')

class C(A):
    pass
    # def func(self):
    #     print('C')

class D(B,C):
    pass
    # def func(self):
    #     print('D')
print(D.mro())
d = D()
d.func()

新式类中
    所有的多继承关系寻找方法的顺序  -  遵循广度优先算法
    继承object
    mro方法
    super : super不是单纯的找父类，而是遵循mro顺序的

经典类
python2.x
不主动继承object
经典类在找父类中方法的过程中 遵循 —— 深度优先
不提供mro方法和super

class A:
    def func(self):
        print('A')

class B(A):
    def func(self):
        super().func()
        print('B')

class C(A):
    def func(self):
        super().func()
        print('C')

class D(B,C):
    def func(self):
        super().func()
        print('D')

D().func()
B().func()

经典类
    python2.x
    不主动继承object
    经典类在找父类中方法的过程中 遵循 —— 深度优先
    不提供mro方法和super

3.多态

什么是多态呢？
一个类表现出的多种状态 ： 通过继承来实现的
在java中的表现 : 在一个函数中需要给参数指定数据类型，如果这个地方可以接收两个以上类型的参数，
              那么这些类型应该有一个父类，这个父类是所有子类对象的类型
java中运用多态来解决传参数的时候 数据类型的规范问题
def func(Cat mao):pass
def func(Dog gou):pass
def func(Animal gou|mao):pass
在python中：函数的参数不需要指定数据类型，所以我们也不需要通过继承的形式来统一一组类的类型，
            换句话说 所有的对象其实都是object类型，所以在python当中其实处处是多态
鸭子类型
def len(obj)
len() # str list tuple dict set range(3)
print() # 所有的对象都是鸭子类型
不是明确的通过继承实现的多态
而是通过一个模糊的概念来判断这个函数能不能接受这个类型的参数

类与对象调用的方法的区别

类调用自己的方法类型是FunctionType，除调用类方法类型是MethodType

函数调用类方法是MethodType，除调用静态方法时是FunctionType
类方法（只使用类中的资源，且这个资源可以直接用类名引用的使用，那这个方法应该被改为一个类方法）
类中包含的内容
    1.静态属性         类  所有的对象都统一拥有的属性
    2.类方法           类  如果这个方法涉及到操作静态属性、类方法、静态方法                            cls 表示类
    3.静态方法         类  普通方法，不使用类中的命名空间也不使用对象的命名空间   ： 一个普通的函数    没有默认参数
    4.方法            对象                                                                        self 表示对象
    5.property方法    对象                                                                        slef 表示对象

检测对象与类之间的关系（isinstance(object,class)）
判断这个对象是否是这个类、这个类的子类的对象

class A:
    pass
class B(A):
    pass
a = A()
b = B()
print(isinstance(a,A))
print(isinstance(b,A))
print(isinstance(a,B))

检测类与类之间的关系(issubclass(son_class,father_class))
判断一个类是否是另一个类的子类

class A:
    pass
class B(A):
    pass
print(issubclass(A,B))
print(issubclass(B,A))

classmethod,staticmethod方法
classmethod
在类中定义一个类方法 、是一个装饰器
classmethod作用
    如果你的整个方法中都没有用到对象命名空间中的名字，且你用到了类的命名空间中的名字（普通方法和property方法除外）
类方法的默认参数 ： cls 值得是调用这个方法的类
类方法的调用方式 ： 通过类名调用,本质是方法

staticmethod
将一个普通的函数放到类中来就给这个函数加上一个@staticmethod装饰器
这个函数就不需要传默认的参数：self，cls
静态方法的调用方式 ： 通过类名调用，本质还是函数

class Goods:
    __discount = 0.8           # 静态属性
    def __init__(self,price):
        self.__price = price   #  对象属性
        self.name = 'apple'

    @property
    def price(self):
        print(self)
        return self.__price * Goods.__discount

    @classmethod
    def change_discount(cls,new):       # 类方法
        cls.__discount = new

class Foo:
    @classmethod
    def class_method(cls):pass

    @staticmethod　　　　　　　　　　　　#静态方法
    def static_method():pass

    def simple_method(self):
        pass

from types import MethodType,FunctionType
obj = Foo()
print(isinstance(obj.class_method, MethodType))
print(isinstance(obj.class_method, FunctionType))
print(isinstance(obj.static_method, MethodType))
print(isinstance(obj.static_method, FunctionType))
print(isinstance(obj.simple_method, MethodType))
print(isinstance(Foo.simple_method, FunctionType))
print(isinstance(Foo.static_method, FunctionType))
print(isinstance(Foo.class_method, FunctionType))
print(isinstance(Foo.class_method, MethodType))

 反射

通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
反射的四个函数
1.getattr(命名空间,'变量名')  （获取该类型下变量名的属性值）
　　类名.静态属性  getattr(类名,'静态属性')
　　类名.类方法()  getattr(类名,'类方法')()
　　类名.静态方法()  getattr(类名,'静态方法')()

　　对象.对象属性  getattr(对象,'对象属性')
　　对象.方法()    getattr(对象,'方法')()

　　模块名.方法名
　　模块名.类名
　　模块名.变量
　　模块名.函数
import sys
getattr(sys.modules[__name__],'所有定义在这个文件中的名字')

2.hasattr(命名空间,'变量名')（判断是否是该类型下的属性名）
    解析getattr方法
    getattr(变量名：命名空间，字符串：属于一个命名空间内的变量名)
    getattr(Foo,'School')  # Foo.School

3.setattr   改变命名空间变量下值

class Foo:
        Country = 'China'

    def func():
        print('qqxing')
    Foo.School = 'OLDBOY'
    setattr(Foo,'School','OLDOBY')  # 接受三个参数 命名空间 ‘变量名’ 变量值
    print(Foo.__dict__)
    print(getattr(Foo,'School'))
    print(Foo.School)

    setattr(Foo,'func',func)  # 一般没人往空间中添加函数
    print(Foo.__dict__)
    print(Foo.func)

4.delattr   删除命名空间变量

class Foo:
        Country = 'China'

    def func():
        print('qqxing')
    Foo.School = 'OLDBOY'
    setattr(Foo,'School','OLDOBY')  # 接受三个参数 命名空间 ‘变量名’ 变量值
    print(Foo.__dict__)
    print(getattr(Foo,'School'))
    print(Foo.School)

    setattr(Foo,'func',func)  # 一般没人往空间中添加函数
    print(Foo.__dict__)
    print(Foo.func)

反射在应用的实际场景
        input
            用户输入的如果是a，那么就打印1，如果输入的是b就打印2，如果输入的是name，就打印alex
        文件
            从文件中读出的字符串，想转换成变量的名字
        网络
            将网络传输的字符串转换成变量的名字

1.反射类中的变量(静态属性,类方法，静态方法)

class Foo:
    School = 'oldboy'
    Country = 'China'
    language = 'Chiness'

    @classmethod
    def class_method(cls):
        print(cls.School)
    @staticmethod
    def static_method():
        print('in staticmethod')

    def wahaha(self):
        print('wahaha')
print(Foo.School)
print(Foo.Country)
print(Foo.language)
判断实现
if inp == 'School':print(Foo.School)
elif inp == 'Country':print(Foo.Country)
elif inp == 'language':print(Foo.language)

反射实现
while True:
    inp = input('>>>')
    print(getattr(Foo,inp))

2.反射对象中的变量( 对象属性,普通方法)

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eating(self):
        print('%s is eating'%self.name)
alex = Foo('alex_sb',83)
print(getattr(alex,'name'))
print(getattr(alex,'age'))
getattr(alex,'eating')()

3.反射模块中的变量

 import os # os就是一个模块
    # os.rename('test','test.bak')
    # getattr(os,'rename')        #('test','test.bak')

4.反射本文件中的变量

import sys
    print(sys.modules[__name__])     # 反射本文件中的变量 固定的使用这个命名空间
    print(getattr(sys.modules[__name__],'a'))

内置方法
在不是需要程序员定义，本身就存在在类中的方法就是内置方法

内置的方法通常都长这样 ： __名字__
名字 ： 双下方法、 魔术方法、 内置方法

1.__init__
    不需要我们主动调用，而是在实例化的时候内部自动调用的
所有的双下方法，都不需要我们直接去调用,都有另外一种自动触发它的语法

2.__str__
当你打印一个对象的时候 触发__str__
当你使用%s格式化的时候 触发__str__
str强转数据类型的时候  触发__str__

def __str__(self):
    return 'str : %s %s %s %s' % (self.name, self.period, self.price, self.teacher)

3.__repr__
repr是str的备胎
有__str__的时候执行__str__,没有实现__str__的时候，执行__repr__
repr(obj)内置函数对应的结果是 __repr__的返回值
当你使用%r格式化的时候 触发__repr__

  def __repr__(self):
        return 'repr : %s %s %s %s' % (self.name, self.period, self.price, self.teacher)

注意:这俩方法的返回值必须是字符串,否则抛出异常，因为repr的应用范围更广，所以一般建议采用repr

不调用这个方法就可以触发这个方法的执行

class Foo:
    def __str__(self):
        return 'abcd'
    def __repr__(self):
        return 'dcba'
obj = Foo()
__str__ ：
print(obj)
'%s'%obj
str(obj)
__repr__  : # 当使用会触发str方法的方式，但是Foo类内部又没有实现__str__方法的时候，都会调用__repr__
'%r'%obj
repr(obj)

__str__和__repr__执行的优先顺序
学生选择课程的时候，要显示所有的课程

class Foo:
    # def __str__(self):
    #     return 'Foo.str'
    def __repr__(self):
        return 'Foo.repr'


class Son(Foo):
    pass
    # def __str__(self):
    #     return 'Son.str'

    # def __repr__(self):
    #     return 'Son.repr'

s1 = Son()
print(s1)

4.__new__构造方法

class Foo:
    def __init__(self):
        print('初始化方法')
    def __new__(cls, *args, **kwargs):
        print('执行构造方法！')
        # return object.__new__(cls)
        return super().__new__(cls)
obj =Foo()

4.1 在实例化对象时，首先会执行object.__new__方法，然后在执行初始化方法。
4.2 如果在定义父类的时候，定义了__new__的构造方法，则首先执行该构造方法，如果构造方法里没有返回值，则该对象则不会被实例化，
        也不会执行__init__方法

5.析构方法__del__
当对象彻底删除时执行__del__方法
当程序执行完毕时执行del方法

class Dell:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        print('删除执行我')

dd =Dell('肖恩',188)
print(dd.__dict__)
del dd.name
print(dd.__dict__)

6.__len__方法
1.除了int和float不包含len方法其余都有len方法
2.只要对象执行len方法，自动调用__len__方法，且返回值只能是数字

print('__len__' in dir(list))
print('__len__' in dir(str))
print('__len' in dir(int))
print('__len__' in dir(float))
print('__len__' in dir(tuple))
print('__len__' in dir(dict))

class Test:
    def __init__(self,name):
        self.name =name
    def __len__(self):
        return  len(self.name)
test =Test('tom')
print('__len__' in dir(test))
print(len(test))

7.__eq__方法
当执行==时比较两个值是否相等时，自动调用__eq__方法

class Eq:
    def __init__(self,name):
        self.name =name
    def __eq__(self,other):
        return self.__dict__ == other.__dict__
d =Eq(4)
c = Eq(3)
print(d == c)

8.__hash__方法
1.在每一次执行程序时hash值都会发生改变
2.在执行的过程中同一值hash值不会发生改变，不同的值hash值不同

set 的去重机制
    1.对每一个元素进行hash计算出一个内存地址
    2.到这个内存地址上查看
        如果这块内存中没有值
            将这个元素存到对应的内存地址上
        如果这块内存中已经有值
            判断这两个值是否相等
                如果相等 就舍弃后面的值
                如果不相等 就二次寻址再找一个新的空间来存储这个值

例子：
员工类
姓名 年龄 性别 部门
转岗位
姓名 年龄变化了 性别 部门
100个员工，去掉重复的
员工的姓名 性别 是相同的，就认为是同一个员工

class Staff:
    def __init__(self,name,age,sex,dep):
        self.name = name
        self.age = age
        self.sex = sex
        self.dep = dep
    def __hash__(self):
        return hash(self.name + self.sex)
    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True

单实例化对象
每次创建对象时只产生一个实例对象

class Animal:
    __instance =None
    def __new__(cls, *args, **kwargs):
        if Animal.__instance is None:
            Animal.__instance = object.__new__(cls)
        return Animal.__instance
    def __init__(self,name):
        self.name = name

dog = Animal('旺财')
cat = Animal('喵喵')
print(dog)
print(cat)
print(dog.name)
print(cat.name)

只初始化一次对象

class Dog(object):
    __instance =None
    __init__flag = False
    def __new__(cls, name):
        if cls.__instance is None:
            cls.__instance=object.__new__(cls)
        return cls.__instance
    def __init__(self,name):
        if Dog.__init__flag == False:
            self.name = name
            Dog.__init__flag =True
dog1 = Dog('旺财')
print(dog1.name)
dog2 = Dog('可乐')
print(dog2.name)