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('123')

    @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('1213')
        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])    #在方法前加装饰器后，可以直接用 对象名.方法名 访问方法。