Python——面向对象

一、创建类

语法格式：

class 类名:
    pass

创建方法：

1 构造方法

 class Person:

     def __init__(self, name,age):

         #构造方法，构造方法的特性， 类名() 自动执行构造方法

         self.n = name
         self.a = age

　执行构造方法：

 obj = Person('李欢', 18)

2 普通方法：

 class Person:

     def show(self):
         pass

执行普通方法：

 obj = Person（）
 obj.show()

二、封装

self代指obj，指调用方法的调用者

 class Bar:
         def __init__(self, n,a):
             self.name = n
             self.age = a
             self.xue = 'o'

 obj1 = Bar('alex', 123)

 obj2 = Bar('eric', 456)

三、继承

继承格式：

 class 父类：　　　　#基类
   pass

 class 子类(父类):　　#派生类
   pass

重写父类方法后，希望执行父类方法和重写后的方法。

方法一： super(子类, self).父类中的方法(...)
方法二： 父类名.父类中的方法(self,...)

 class f:
     def eat(self):
         print('Eating')

     def sleep(self):
         print('f is sleeping')

 class s(f): 　　#在括号中加入要继承的父类
     def sleep(self):　　　　#重写父类方法
         super(s,self).sleep()   #方法一
         print('s is sleeping')
         f.sleep(self)           #方法二

 obj = s()
 obj.sleep()
 obj.eat()

支持多继承

多继承特点：

a. 左侧优先
b. 一条道走到黑
c. 同一个根时，根最后执行

 class BaseReuqest:

     def __init__(self):
         print('BaseReuqest.init')

 class RequestHandler(BaseReuqest):
     def __init__(self):
         print('RequestHandler.init')
         BaseReuqest.__init__(self)

     def serve_forever(self):
         # self,是obj
         print('RequestHandler.serve_forever')
         self.process_request()

     def process_request(self):
         print('RequestHandler.process_request')

 class Minx:

     def process_request(self):
         print('minx.process_request')

 class Son(Minx, RequestHandler): #按照从左到右，一条线走到底，如果有相同的根，则根最后执行
     pass

 obj = Son() # init
 obj.serve_forever()

obj = Son进行实例化时，先自动执行init方法，Son类中没有init，则在第一个父类中找init方法，Minx中没有init，去第二个父类中找init方法，以此执行完init方法之后，再去调用server_forever()普通方法。

四、类成员

字段

• 静态字段

  静态字段保存在类，可以通过对象访问，也可以通过类访问。

• 普通字段

  普通字段保存在对象中，只能通过对象访问。

例：

 class Province:
     country = 'China'       #静态字段
     def __init__(self,name):
         self.name = name        #普通字段

 obj = Province('beijing')
 print(obj.name)
 print(Province.country)

方法

• 普通方法

  普通方法保存在类中，由对象来调用。self表示对象

• 静态方法

  静态方法保存在类中，由类直接调用

• 类方法

  类方法保存在类中，由类直接调用，cls代指当前类

例：

 class foo:

     def bar(self):          #普通方法，self是对象
         print('ok')

     @staticmethod           #静态方法
     def sta():
         print('')

     @staticmethod           #静态方法
     def stat(a,b):
         print(a,b)

     @classmethod            #类方法
     def aaa(cls):　　　　　　#cls是类名
         print('class method')

 obj = foo()
 obj.bar()
 foo.sta()
 foo.stat(1,2)
 foo.aaa()

不伦不类——属性

通过加装饰器，以另一种形式访问对应的方法。

 class foo:
     @property　　　　#用于执行obj.bar
     def bar(self):
         print('')
         return 666

     @bar.setter　　　　#用于执行obj.bar = 123
     def bar(self,val):
         print(val)

     @bar.deleter　　　　#通过del obj.bar可以定位并访问下面的方法
     def bar(self):
         print(999)

 obj = foo()
 obj.bar
 obj.bar = 123
 del obj.bar

实例：

实现分页

 class Pagenation:

     def __init__(self,current_page):

         try:
             p = int(current_page)
         except Exception as e:
             p = 1

         self.page = p

     @property
     def start(self):
         val = (self.page - 1) * 10
         return val

     @property
     def end(self):
         val = self.page * 10
         return val

 li = []
 for i in range(5000):
     li.append(i)

 while True:
     page = input('>>>')
     obj = Pagenation(page)
     # print(li[obj.start() : obj.end()])
     print(li[obj.start:obj.end])    #在方法前加装饰器后，可以直接用 对象名.方法名 访问方法。