Python基础-面向对象1

class Bar:
    def fansik(self, name, age):
        print(name, age)

obj = Bar()
print(obj.fansik('fanjinbao', 19))

一、定义
    函数：
        def + 函数名(参数)

     面向对象：
        class   =>  名字叫Bar的类
        def     =>  名字叫fansik的方法
        ####    self
二、执行
    函数：
        函数名()
    面向对象：
    obj = Bar() # 创建中间人(对象、实例)
    obj.fansik

三、面向对象的封装实例

class Person():
    def __init__(self, name, age, blood='O'):
        self.name = name
        self.age = age
        self.blood = blood
    def outinfo(self):
        print('姓名：%s
年龄：%s
blood type：%s' % (self.name, self.age, self.blood))
fansik = Person('fansik', 89)
fansik.outinfo()

四、面向对象的继承实例

class Father():
    def ff1(self):
        print('fangfa1')

    def ff2(self):
        print('fangfa2')

    def ff3(self):
        print('fangfa3')

class Son(Father):

    def ff4(self):
        print('fangfa4')

fansik = Son()
fansik.ff1()
fansik.ff2()
fansik.ff3()
fansik.ff4()

五、重写父类方法

class Father():
    def ff1(self):
        print('fangfa1')

    def ff2(self):
        print('fangfa2')

    def ff3(self):
        print('fangfa3')

class Son(Father):
    # 重写父类方法
    def ff3(self):
        # 引入父类的方法
        # super(Son, self).ff3()
        # 或者使用这种方式
        # Father.ff3(self)
        print('fangfa4')

fansik = Son()
fansik.ff1()
fansik.ff2()
fansik.ff3()

六、Python中支持多继承
a、左侧有限
b、一条道走到黑
c、同一个根是，根最后执行

class BaseRequest:
    pass

class RequestHandler(BaseRequest):
    def serve_forever(self):
        print('RequestHandler.serve_forever')
        self.process_request()
    def process_request(self):
        print('RequestHandler.prcess_request')

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

class Son(Minx, RequestHandler):
    pass

obj = Son()
obj.serve_forever()
执行结果：
RequestHandler.serve_forever
minx.process_request

说明：serve_forever()中的self.process_request()执行的是Son的process_request()所以输出是minx.process_request

类成员：
    字段
        - 普通字段，保存在对象中，执行职能通过对象访问
        - 静态字段，保存在类中，执行可以通过对象访问，也可以通过类访问
     方法
        - 普通方法，保存在类中，由对象来调用，self --> 对象
        - 静态方法，保存在勒种，由类直接调用
        -   类方法，保存在勒种，有类直接调用，cls --> 当前类
    应用场景：
        如果对象中需要保存一些值，执行某功能时，需要使用对象中的值---->普通方法
        不需要任何对象值，

class Fansik:
    # 静态字段
    country = '中国'
    # 构造方法
    def __init__(self, name):
        # 普通字段
        self.name = name

    # 普通方法
    def common_method(self, name, age):
        print(name, age)

    # 静态方法
    @staticmethod
    def static_method(x, y):
        print(x, y)

    # 类方法
    @classmethod
    def class_method(cls):
        print(cls)
        print('class_method')

fan = Fansik('fanjinbao')
print(Fansik.country)
print(fan.country)
Fansik.static_method(1, 2)
fan.static_method(1, 2)
fan.common_method(1, 2)
Fansik.class_method()

分页的简单实现：

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 = [x for x in range(1000)]
while True:
    page = int(input('要查看的页码：'))
    obj = Pagenation(page)
    print(li[obj.start:obj.end])