week6：面向对象基础

一、基本概念

1.1、python  函数式+面向对象

函数式编程可以做所有的事，是否合适？

函数：def+函数名（参数):

二、面向对象

2.1、如何创建类

class 类名：
        pass

 
2.3、创建方法

def   __init__(self,arg):
        obj = 类('a1')
        obj = 类(‘xxx’)

        obj.普通方法名()

"""
class Bar:

    def foo(self):
        print(self.name)

z = Bar()

z.foo()
"""

#self:   代指调用方法的对象（中间人）

class Bar:

    def foo(self, arg):
        print(self, arg)

z1 = Bar()
print(z1)
z1.foo(111)
print('================')
z2 = Bar()
print(z2)
z2.foo(666)

输出结果：

<__main__.Bar object at 0x00000201C2CC7748>
<__main__.Bar object at 0x00000201C2CC7748> 111
================
<__main__.Bar object at 0x00000201C2CC7CC0>
<__main__.Bar object at 0x00000201C2CC7CC0> 666

class Bar:

    def foo(self, arg):
        print(self, self.name, self.age, self.gender, arg)

z = Bar()
z.name = 'alex'
z.age = 84
z.gender = 'zhong'
z.foo(666)

z1 = Bar()
z1.name = 'eric'
z1.age = 73
z1.gender = 'nv'
z1.foo(666)

输出结果：

<__main__.Bar object at 0x0000028B41307CC0> alex 84 zhong 666
<__main__.Bar object at 0x0000028B41307D30> eric 73 nv 666 

2.4、面向对象三大特性之一：封装

    class Bar:
        def __init__(self, n,a):
            self.name = n
            self.age = a
            self.xue = 'o'
            
    b1 = Bar('alex', 123)
    
    b2 = Bar('eric', 456)

class Bar:
    def __init__(self,n1,n2,n3):
        self.nam1=n1
        self.nam2=n2
        self.nam3=n3
        self.nam4=n3
        self.nam5=n3
        self.nam6=n3

    def foo(self):
        print(self.nam1,self.nam2,self.nam3,self.nam4,self.nam5,self.nam6)

z = Bar(1,2,3)
print(z.nam1)
z.foo()

输出结果：

1
1 2 3 3 3 3

class Person:

    def __init__(self, name,age):

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

        self.n = name
        self.a = age
        self.x = '0'
    def show(self):
        print('%s-%s' %(self.n, self.a))
lihuan = Person('李欢', 18)
lihuan.show()

hu = Person('互相林', 73)
hu.show()

输出结果：

李欢-18
互相林-73

2.5、适用场景：
        如果多个函数中有一些相同参数时，转换成面向对象

    class DataBaseHelper:
    
        def __init__(self, ip, port, username, pwd):
            self.ip = ip
            self.port = port
            self.username = username
            self.pwd = pwd
        
        def add(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
        
        def delete(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
        
        def update(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接
            
        def get(self,content):
            # 利用self中封装的用户名、密码等   链接数据
            print('content')
            # 关闭数据链接

s1 = DataBaseHelper('1.1.1.1',3306, 'alex', 'sb')

2.6、面向对象三大特性之二：继承

    1、继承
        
        class 父类：
            pass
            
        class 子类(父类):
            pass

class F:

    def f1(self):
        print('F.f1')

    def f2(self):
        print('F.f2')

class S(F):
    def s1(self):
        print('S.s1')

    def f2(self):
        # obj
        print('S.f2')
        # super(S, self).f2() # 执行父类（基类）中的f2方法
        # F.f2(self)          # 执行父类（基类）中的f2方法

   """
obj = S()
obj.s1()
obj.f2()
"""
"""
obj = S()
obj.s1() # s1中的self是形参，此时代指 obj
obj.f1() # self用于指调用方法的调用者
""" 

# obj = S()
# obj.f2()

2、重写
        防止执行父类中的方法      

3、self永远是执行改方法的调用者

4、
       super(子类, self).父类中的方法(...)
       父类名.父类中的方法(self,...)
       
5、Python中支持多继承

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

class Base:
    def a(self):
        print('Base.a')


class F0(Base):
    def a1(self):
        print('F0.a')

class F1(F0):
    def a1(self):
        print('F1.a')

class F2(Base):
    def a1(self):
        print('F2.a')

class S(F1,F2):
    pass

obj = S()
obj.a()

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

输出结果：

RequestHandler.init
BaseReuqest.init
RequestHandler.serve_forever
minx.process_request

# import socketserver
#
#
# obj = socketserver.ThreadingTCPServer(1,2) # 创建对象，找init
# obj.serve_forever()

可以看一下源码执行流程。

2.7、面向对象三大特性之三：多态
    ====> 原生多态

 
    # Java
        string v = 'alex'
        
        def func(string arg):
            print(arg)
            
        func('alex')
        func(123)
    
    # Python 
        v = 'alex'
        
        def func(arg):
            print(arg)
            
            
        func(1)
        func('alex')

三、 面向对象中高级

class Foo:

    def __init__(self, name):

        # 普通字段
        self.name = name 

    # 普通方法
    def show(self):
        print(self.name)

obj = Foo('alex')
obj.name
obj.show()

类成员：
    # 字段
        - 普通字段，保存在对象中，执行只能通过对象访问
        - 静态字段，保存在类中，  执行 可以通过对象访问 也可以通过类访问
        
    # 方法
        - 普通方法，保存在类中，由对象来调用，self=》对象
        - 静态方法，保存在类中，由类直接调用
        -  类方法，保存在类中，由类直接调用，cls=》当前类

    ##应用场景：
        如果对象中需要保存一些值，执行某功能时，需要使用对象中的值　－＞　普通方法
        不需要任何对象中的值，静态方法
             

class Foo:
    def __init__(self):
        self.name ='a'

    def bar(self):
        # self是对象
        print('bar')

    @staticmethod
    def sta():
        print('123')

    @staticmethod
    def stat(a1, a2):
        print(a1, a2)

    @classmethod
    def classmd(cls):
        # cls 是类名
        print(cls)
        print('classmd')

Foo.sta()  ##123
Foo.stat(1, 2)#1 2
Foo.classmd()##<class '__main__.Foo'>  classmd


obj = Foo()
obj.bar()#bar

obj = Foo()
Foo.bar(obj)#bar

    # 属性（特性）
        - 不伦不类

class Foo:
    def __init__(self):
        self.name = 'a'
        # obj.name
        self.name_list = ['alex']

    # obj.bar()
    def bar(self):
        # self是对象
        print('bar')

    # 用于执行 obj.per
    @property
    def perr(self):

        return self.name_list

    # obj.per = 123
    @perr.setter
    def perr(self, val):
        print(val)

    @perr.deleter
    def perr(self):

        print(666)

obj = Foo()
r = obj.perr
print(r)#123

obj.perr = 123
#
del obj.perr

  
中国的所有省份，用面向对象知识表示？

class Province:
    # 静态字段，属于类
    country =  '中国'
    
    def __init__(self, name):
        # 普通字段，属于对象
        self.name = name
        
henan = Province('河南')
henan.name
henan.name = "河南南"

利用属性，实现分页

class Pergination:

    def __init__(self, current_page):
        try:
            # qwer
            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(1000):
    li.append(i)

while True:
    p = input('请输入要查看的页码：') # 1,每页显示10条
    obj = Pergination(p)
    print(li[obj.start:obj.end])

class Foo:

    #两种写法相等
    # def f1(self):
    #     return 123
    # 
    # per = property(fget=f1)

    # @property
    # def per(self):
    #     return 123

class Foo:

    def f1(self):
        return 123

    def f2(self, v):
        print(v)
    def f3(self):
        print('del')

    per = property(fget=f1, fset=f2, fdel=f3, doc='adfasdfasdfasdf')

    # @property
    # def per(self):
    #     return 123

 
obj = Foo()
ret = obj.per
print(ret)  ##123

obj.per = 123456  ##123456

del obj.per  ##del