七、面向对象编程（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对象，需传入的三个参数

class的名称
继承的父类集合，注意Python支持多重继承，如果只有一个父类，使用tuple的单元素写法（后加逗号）

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）。

秒客网

七、面向对象编程（OOP）

相关文章