Python-Basis-14th

周五，晴，记录生活分享点滴

参考博客：https://www.cnblogs.com/wupeiqi/p/4493506.html

Python版本：3.5

面向对象（初级）

创建类

含义

类是一个模板，模板里包含多个函数，函数里实现一些功能

对象是根据模板创建的实例，通过实例对象可以执行类中的函数

格式

class + 类名

对象 = 类名 + () 

class Bar:  # Bar是一个类名称

    def foo(self, 参数):  # self是一个特殊参数，必填
        print(self, 参数)

obj = Bar()  # 根据类Bar创建obj对象

# 创建类
class Bar:
     
    def Foo(self):
        print 'Foo'
 
    def Hello(self, name):
        print 'i am %s' %name
 
# 根据类Bar创建对象obj
obj = Bar()
obj.Foo()            #执行Foo方法
obj.Hello('chung') #执行Hello方法　

创建方法

构造方法

__init__(self, 参数)

obj = 类() 

class Bar:
    
    def __init__(self):  # __init__ 是 python 内部调用的
        print(123)

obj = Bar()  # 只要类后面加上括号，就自动执行

普通方法

obj = 类('xxx') 

obj.普通方法名()

class Bar:

    def foo(self):
        print(456)

obj.foo()  # 通过obj主动调用foo执行

三大特性

封装（常用）

将内容封装到某处

含义：1. 将内容封装到某处

    2. 从某处调用被封装的内容

class Foo:
    def __init__(self, n, a):
        self.name = name
        self.age = age
        self.blood = 'o'
            
obj1 = Foo('zhangsan', 23)  # 将zhangsan和23分别封装到name、age的属性中
obj2 = Foo('lisi', 45)  # 将lisi和45分别封装到name、age的属性中

从某处调用被封装的内容

方式：1. 通过对象直接调用

    2. 通过self间接调用

# 通过对象直接调用

class Foo:
 
    def __init__(self, name, age):
        self.name = name
        self.age = age
 
obj1 = Foo('zhangsan', 23)
print obj1.name    # 直接调用obj1对象的name属性
print obj1.age     # 直接调用obj1对象的age属性
 
obj2 = Foo('lisi', 45)
print obj2.name    # 直接调用obj2对象的name属性
print obj2.age     # 直接调用obj2对象的age属性

# 通过 self 间接调用

class Foo:
  
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    def detail(self):
        print self.name
        print self.age
  
obj1 = Foo('zhangsan', 23)
obj1.detail()  # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 zhangsan ；self.age 是 23
  
obj2 = Foo('lisi', 45)
obj2.detail()  # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 lisi ； self.age 是 45

小结：

对于面向对象的封装，使用构造方法将内容封装到对象中，

然后通过对象直接或者self间接获取被封装的内容。

适用场景

如果多个函数中有一些相同参数时，转换成面向对象

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, 'chung', '123456')

封装的层层嵌套

class F1:

    def __init__(self):
        self.name = 123

class F2:

    def __init__(self, a):
        self.ff = a # [name=123]

class F3:

    def __init__(self, b):
        self.dd = b

f1 = F1()  # [name=123]
f2 = F2(f1)# [ff=[name=123]]
f3 = F3(f2) # [dd=[ff=[name=123]]]
# 找到123并输出
print(f3.dd.ff.name)

继承

含义

子可以继承父的内容

class F:  # class 父类：
    def f1(self):
        print('F.f1')        
    def f2(self):
        print('F.f2')
        
class S(F):  # class 子类(父类):
    def s1(self):
        print('S.s1')
        
obj = S()

obj.s1()
obj.f1()

重写

防止执行父类中的方法

class F:
    def f1(self):
        print('F.f1')
        
    def f2(self):
        print('F.f2')
        
class S(F):
    def s1(self):
        print('S.s1')
        
    def f1(self):  # 通过在子类S中重写，可以防止执行父类F中的方法
        print('S.f1')

obj = S()

obj.f1()

self

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

class F:
    def f1(self):  # self指f1的obj
        print('F.f1')
        
class S(F):
    def s1(self):  # self指s1的obj
        print('S.s1')
        
obj = S()

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

super

super(子类, self).父类中的方法(...)

父类名.父类中的方法(self,...)

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):
        print('S.f2')  # 如果print在前，先执行S的f2；如果super在前，先执行F的f2
        super(S, self).f2()  # 第一种执行父类（基类）中的f2方法
        # F.f2(self)  # 第二种执行父类（基类）中的f2方法

obj = S()

obj.f2()

多继承

a. 左侧优先

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

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

class S(F1,F2):  # 从左到右，先执行F1，再执行F2
    pass

obj = S()
obj.a()

b. 一条道走到黑

class Base:
    def a1(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 a(self):
        print('F2.a')

class S(F1,F2):  # 先找F1，走到尽头没有，再找F2
    pass

obj = S()
obj.a()

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):  # 当F1与F2最后的父级为同一个根时，先按顺序找完F1、F2，最后执行根
    pass

obj = S()
obj.a()

多态

# Java
    string v = 'chung'  # 需要指明变量的类型

    def func(string arg):
        print(arg)

    func('chung')
    func(123)
    
# Python 
    v = 'chung'  # 直接使用变量

    def func(arg):
        print(arg)

    func(1)
    func('chung')