python笔记

                    python笔记 - day7-1 之面向对象编程                      

什么时候用面向对象：

　　多个函数的参数相同；
　　当某一些函数具有相同参数时，可以使用面向对象的方式，将参数值一次性的封装到对象，以后去对象中取值即可；

self是什么？　　　　

　　self是一个python自动会给传值得参数；　　

　　哪个对象执行方法，self就是哪个对象；

　　

例：
class SQLHelper:
    def __init__(self,a1,a2,a3):
        print("自动执行")
        self.hhost = a1
        self.uusername = a2
        self.pwd = a3

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

obj1 = SQLHelper('C1.SALT.COM','alex',123)
obj1.fetch("select * from A")
#如果SQLHelper后面加括号，表示执行SQLHelper的__init__方法；
#obj1如果执行了__init__方法，self就等于obj1
#如：
    def __init__(self,a1,a2,a3):
        print("自动执行")
        obj1.hhost = a1
        obj1.uusername = a2
        obj1.pwd = a3


obj2 = SQLHelper('www.baidu.com','freddy',123)
obj2.create("create ........")
#obj2如果执行了__init__方法，self就等于obj2
#如：
    def __init__(self,a1,a2,a3):
        print("自动执行")
        obj2.hhost = a1
        obj2.uusername = a2
        obj2.pwd = a3

构造方法：　　

　　类中有一个特殊的方法，__init__，类()自动执行；

　　创建对象，后面加括号，表示遇到__init__方法，就执行__init__方法；

面向对象，三大特性：　　

　　封装，继承，多态；

 “函数式编程”，与“面向对象编程”比较：

函数式编程：使用函数式编程，如果执行每个函数，都要重新传入参数，比较麻烦：

def fetch(host,username,password,sql):
    pass
def create(host,username,password,sql):
    pass
def remove(host,username,pasword,uid):
    pass
def modify(host,username,password,name):
    pass

 面向对象编程：可以创建一个对象，到时候想要执行哪个方法，调用自己创建的对象即可；

class SQLHelper:

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        pass


    def remove(self,uid):
        pass


    def modify(self,name):
        pass

#类里面的方法只能通过对象来调用
obj = SQLHelper()

obj.hhost = "www.mysql.com"
obj.uusername = "freddy"
obj.pwd = '123'

obj.fetch("select * from A")

标准面向对象写法：

class SQLHelper:
    def __init__(self,a1,a2,a3):
        print("自动执行")
        self.hhost = a1
        self.uusername = a2
        self.pwd = a3

    def fetch(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

    def create(self,sql):
        print(self.hhost)
        print(self.uusername)
        print(self.pwd)
        print(sql)

#这里会把自定义的三个参数，分别传给fetch，create；
obj1 = SQLHelper('c1.salt.com','alex',123)

#调用上面创建的对象，并执行额外的命令
obj1.fetch("select * from A")

#调用这个对象，执行额外的命令
obj1.create("create database aaa")

取其它对象下面的值：

class c1:
    def __init__(self,name,obj):
        self.name = name
        self.obj = obj

class c2:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name)
        
c2_obj = c2('aa',11)
c1_obj = c1("alex",c2_obj)

# - 取出来c2_obj下的age是多少？
# - c2_obj赋值给c1_obj了，先打印c1_obj，
# - c2_obj赋值给c1_obj下的obj了，再打印c1_obj.obj，相当于打印的c2_obj
# - 最后再c2_obj里面取出age的值即可

print(c1_obj.obj.age)

类之前的方法调用，三个类：

class c1:
    def __init__(self,name,obj):
        self.name = name
        self.obj = obj

class c2:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def show(self):
        print(self.name)
        # return 123

class c3:
    def __init__(self,a1):
        self.money = 123
        self.aaa = a1

#如何使用C3类，调用c2类下的show方法？
c2_obj = c2('freddy',11)
#c2_obj是c2类型
# - name = 'aa'
# - age = 11

c1_obj = c1("alex",c2_obj)
#c1_obj是c1类型
# - name = "alex"
# - obj = c2_obj
c3_obj = c3(c1_obj)
#使用c3_obj找到c2下的name
print(c3_obj.aaa.obj.age)

#使用c3_obj执行show方法
ret = c3_obj.aaa.obj.show()
print(ret)

继承：

class F1:
    def show(self):
        print('show')

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

class F2(F1):
    def __init__(self,name):
        self.name = name

    def bar(self):
        print('bar')
    def show(self):
        print('F2.show')

#F2类下找不到foo方法，就继续去F1下找foo方法，因为F2类继承了F1类；
#继承就相当于把父类的内容，在子类中创建了一份；
#子类可以继承父类，父类不能继承子类；
obj = F2('alex')
obj.foo()

#F1和F2类里面都有show方法，这里创建对象是F2的类，优先调用F2类下的show方法
obj = F2('alex')
obj.show()

面向对象之单继承：

class S1:
    def F1(self):
        self.F2()
    def F2(self):
        pass

class S2(S1):
    def F3(self):
        self.F1()
    def F2(self):
        pass


obj = S2()
obj.F3()
#这里执行的是S2下的F2

obj = S1()
obj.F1()
#这里执行的是S1下的F2

面向对象之多继承，继承都是从底层开始找：

 方法一：最简单的多继承，通过C3继承了C2，C1，通过C3类，可以执行C2，C1里面的方法

class C1:
    def f1(self):
        print("f1")

class C2:
    def f2(self):
        print("f2")

class C3(C2,C1):
    def f3(self):
        print("f3")

obj = C3()
obj.f1()
obj.f2()
obj.f3()

方法二：一条道，走到黑，如果父类只有一个子类，就是先去子类找，找不到再往右找；

　　　　查找顺序：C3.f2(没有) → C1.f2(没有) → C0.f2(有，执行)，没有就执行C2.f2

class C0:
    def f2(self):
        print("C0.F2")

class C1(C0):
    def f3(self):
        print("C1.F3")

class C2:
    def f2(self):
        print("C2.f2")

class C3(C1,C2):
    def f3(self):
        print("f3")
obj = C3()
obj.f2()

结果：C0.F2

方法三：如果一个父类，有两个子类，执行顺序：

　　　　C3.f2(没有) → C1.f2(没有) → C0.f2(没有，就不往上找了) → C3.f2(回到原点，没有) → C2.f2(有，执行)

class C_2:
    def f2(self):
        print("C-2,F2")

class C_1(C_2):
    def f2(self):
        print("C_1.F2")
class C0(C_2):
    def f3(self):
        print("C0.F2")

class C1(C0):
    def f3(self):
        print("C1.F3")
class C2(C_1):
    def f2(self):
        print("C2.f2")

class C3(C1,C2):
    def f3(self):
        print("f3")

obj = C3()
obj.f2()

看源码必须要懂这个原理：

执行：obj = A()

　　　obj.forever()

A → process() → __init__   【找到init了，obj = A()执行完了，回到原点，开始执行obj.forever() 】

A → process() → __init__ → __init__ , run(),process() → forever()【找到了，执行这个方法】

执行：self.run()

　　A → process() → __init__ → __init__ , run()【找到了，执行这个方法】

执行：self.process()

　　A → process(),【找到了，执行这个方法】

这个模块源码，就是引用了上面的方法：

import socketserver

#加括号，是个函数执行这个函数，
# 是个类，执行init方法
obj = socketserver.ThreadingTCPServer()

obj.serve_forever()