七、面向对象编程（OOP）

面向对象编程：一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

1、类（class）

• class：自定义的对象数据类型。基于类创建多个对象，每个对象具备类的通用行为，首字母大写（面向对象的设计思想是抽象出Class，根据Class创建Instance【实例】）
• __init__方法：第一个参数self表示创建的实例本身，在内部把各种属性绑定到self，因为self指向创建的实例本身。可把一些必要的属性先填进去，如：姓名、年龄等

 #创建一个类，假设为人
 class Person(object):
     #使用__init__方法初始化创建的实例属性
     def __init__(self,name,age,gender):
         self.name = name
         self.age = age
         self.gender = gender
     #定义创建的实例所拥有的技能
     def eat(self):
         print('%s,You have the skills to eat' %self.name)
     def motion(self):
         print('%s,%s,is a %s'%(self.name,self.age,self.gender))

 #创建实例
 j = Person('jack',18,'boy')
 l = Person('lisa',18,'girl')
 #使用技能
 j.eat()
 l.motion()

 输出：
 jack,You have the skills to eat
 lisa,18,is a girl

• 数据封装：类本身所拥有的数据，在内部使用函数封装起来，称为类的方法。（如下文的print_name与get_name两个函数）

• 访问限制：在方法前用双下划线：__xx 表示默认数据不被外部重新修改

   class Person(object):
       def __init__(self,name,age):
           self.__name = name
           self.__age = age
       def print_name(self):
           print('%s %s'%(self.__name,self.__age))
       #使用新函数为外部需要获取私有参数，外部无法直接使用self.name调用数据
       def get_name(self):
           return self.__name
   jack = Person('jack',19)
   print(jack.print_name())
   print(jack.get_name())
  
   输出：
   jack 19
   None
   jack

• 继承：可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。

   #Dog类继承Animal类，可使用其内部方法
   class Animal(object):
       def run(self):
           print('Animal is running')
   class Dog(Animal):
       pass

• 测试对象属性：
  • hasattr（Person,'x'）：判断Person对象是否有‘x’属性；
  • setattr（Person,'y'，18）:设置一个属性‘y’以及对应的值；
  • getattr（Person,'y'，404）：获取属性‘y’的值，如属性不存在时可设置返回值，不然会得到AttributeError的错误。
• 类属性：直接在class中定义的属性，归类所有。所有实例共享一个属性；
• 实例属性：属于各个实例所创建的属性，互不干扰（实例属性和类属性不使用相同的名字，相同时实例属性会屏蔽类属性）。

   class Animal(object):
       class_name = 'dog'    #类属性
       def __init__(self,name):
           self.name = name
   c = Animal('cat')   #实例属性
   print(c.name)
   print(c.class_name)
  
   输出：
   cat
   dog

• super（）：是用于调用父类(超类)的一个方法

   class People(object):
       def print(self):
           print('父类方法')
   class Man(People):
       def print(self):
           print('子类方法')
   s = Man()
   s.print()
   super(Man,s).print()
  
   输出：
   子类方法
   父类方法

• __slots__：定义一个特殊的变量，来限制该class实例能添加的属性

   class People(object):
       __slots__ = ('name','age')
   s = People()    #创建新的实例
   s.name = 'jcak'    #绑定属性
   s.age = 18
   #s.score = 90    #再添加属性时得到AttributeError的错误

• @property装饰器：把一个方法变成属性调用的。单个getter为可读，再定义.setter属性为可读写。

   #用@property给一个Screen对象加上width和height属性，以及一个只读属性resolution
   class Screen(object):
       @property
       def width(self):
           return self._width
       @width.setter
       def width(self,input_width):
           self._width = input_width
       @property
       def height(self):
           return self._height
       @height.setter
       def height(self,input_height):
           self._height = input_height
       @property
       def resolution(self):
           return self._width*self.height
   s = Screen()
   s.width = 1024
   s.height = 768
   print('resolution =', s.resolution)
   if s.resolution == 786432:
       print('测试通过!')
   else:
       print('测试失败!')
  
   输出：
   resolution = 786432
   测试通过!

• 定制类：形如__xxx__的变量或者函数名来定制类
• __str__、__call__、__dco__、__dict__、__class__　　　　

   class Student(object):
       '''描述类信息'''
       def __init__(self, name):
           self.name = name
  
       def __str__(self):
           return 'Student Object (name:%s)' % self.name
  
       def __call__(self, *args, **kwargs):
           return '实例对象s +（）直接运行'
  
   s = Student('jack')
   print(s)    #默认输出_str__中返回的内容
   print(s.__doc__)     #输出描述类信息
   print(s.__module__)  #当前操作对象所在的模块
   print(s.__class__)    #当前操作对象的类
   print(s())    #对实例直接调用，返回call的内容
   # print(Student.__dict__)   #以字典形式返回当前类中所有对应的关系
   print(s.__dict__)
  
   输出：
   Student Object (name:jack)
   描述类信息
   __main__
   <class '__main__.Student'>
   实例对象s +（）直接运行
   {'name': 'jack'}

• __iter__

   class Cycle():
       def __init__(self):
           self.a,self.b = 0,1
       def __iter__(self):    #返回一个迭代对象
           return self
       def __next__(self):    #获取下一个值
           self.a,self.b = self.a+self.b,self.b
           if self.a > 4:
               raise StopIteration
           return self.a
  
   for n in Cycle():
       print(n)
  
   输出：
   1
   2
   3
   4

• __getitem__、__setitem__（设置）、__delitem__（删除）

   class Cycle():
       def __getitem__(self, i):    #返回索引
           a,b = 1,1
           for x in range(i):
               a,b = a+b,b
           return a
  
   print(Cycle()[3])
   class Cycle(): #q求切片
       def __getitem__(self,n):
           start = n.start
           stop = n.stop
           l = []
           a,b =1,1
           for x in range(stop):
               if x >= start:
                   l.append(a)
               a,b = b,a+b
           return l
   print(Cycle()[1:4])
  
   输出：
   3
   [1, 2, 3]

• • __getattr__：当调用的属性不存在时，会从getattr获取属性，并返回值，要让class只响应特定的几个　　属性，我们就要按照约定，抛出AttributeError的错误

     语法：
     getattr(object, name[, default])
    
     object -- 对象
     name -- 字符串，对象属性。
     default -- 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。

     class Student(object):
    
         def __getattr__(self, attr):
             if attr=='age':
                 return lambda: 25
             raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

  • __setattr__：设置属性值，该属性必须存在

     语法：setattr(object,name,value)    对象；对象属性；属性值。
    
     class Num():
         foo = 1
     a = Num()
     print(getattr(a,'foo')) #获取属性的值
     setattr(a,'foo',8)  #设置属性的值
     print(a.foo)
    
     输出：
     1
     8

• 枚举类

   #@unique装饰器可以帮助检查保证没有重复值
   from enum import Enum, unique
   @unique
   class Weekday(Enum):
       Sun = 0 # Sun的value被设定为0
       Mon = 1
  
   day = Weekday.Mon
   print(day.value)    #使用value的值或得枚举常量
   #----*----
    Month = Enum('Month', ('Jan', 'Feb'))
   for name, member in Month.__members__.items():
       print(name, '=>', member, ',', member.value)
   print(Month.Jan.value)
  
   输出：
   1
   #----*----
   Jan => Month.Jan , 1
   Feb => Month.Feb , 2
   1

• type（）：可用来创建一个class对象，需传入的三个参数

1. class的名称
2. 继承的父类集合，注意Python支持多重继承，如果只有一个父类，使用tuple的单元素写法（后加逗号）
3. class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上　　

    def fn(self,name = 'World'):
        print('Hello,%s' %name)
    H = type('Hello',(object,),dict(hello = fn))    # H 最好与 Hello 写一样防止混淆
    # class Hello(object):
    #     def hello(self, name='world'):
    #         print('Hello, %s.' % name)
    h = H()
    h.hello()
    print(type(H))
    print(H.__name__)
   
    输出：
    Hello,World
    <class 'type'>
    Hello

• Metaclass：元类，metaclass允许创建类或者修改类，类相当于metaclass创建的实例（内容较复杂，先行省略！！！）

• __name__ 与 __main__：python的文件有两种使用的方法，一是直接作为脚本执行，二是import到其他的python脚本中被调用（模块重用）执行。if __name__ == 'main': 的作用就是控制这两种情况执行代码的过程，在if __name__ == '__main__': 下的代码只有在第一种情况下（即文件作为脚本直接执行）才被执行，而import到其他脚本中是不会被执行的。每个python模块都包含内置的变量__name__,当运行模块被执行的时候，__name__等于文件名（包含了后缀.py）；如果import到其他模块中，则__name__等于模块名称（不包含后缀.py）。而“__main__”等于当前执行文件的名称（包含了后缀.py）。