Python攻关之面向对象初级

一、定义类并执行类中的方法

class 类名：
    def 方法名(self,arg):
        print(arg)

中间人 = 类名()
中间人.方法名(参数)

二、

 class people:
     def name(self,ming):
         print(ming)
 o = people()
 o.name('zph')

三、

 class Bar:
     def foo(self,arg):
         print(self,arg)
 z1 = Bar()
 print(z1)
 z1.foo(111)
 print('***************')
 z2 = Bar()
 print(z2)
 z2.foo(222)

四、

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

 z = Bar()
 z.name = 'zph'
 z.age = 18
 z.gender = 'zhong'
 z.foo(666)

 z1 = Bar()
 z1.name = 'll'
 z1.age = 18
 z1.gender = 'nv'
 z1.foo(888)

五、

class Person:
    def __init__(self,name,age):      #构造方法  构造方法的特性： 类名()  自动执行构造方法
        self.n = name
        self.a = age
    def show(self):
        print("%s-%s"%(self.n,self.a))
lihua = Person('李华',18)
lihua.show()

六、面向对象的总结

1、如何创建类

 class 类名：
 pass

2、创建方法

 构造方法，__init__(self, arg)
 obj = 类('a1')
 普通方法
 obj = 类(‘xxx’)
 obj.普通方法名()

七、面向对象三大特性之一：封装
1.

class Bar:
    def __init__(self, n, a):
        self.name = n
        self.age = a
        self.xue = 'o'


b1 = Bar('alex', 123)

b2 = Bar('eric', 456)

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

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

八、面向对象三大特性之一 继承

1.类的定义

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):
        # super(S, self).f2()   #执行父类（基类）的f2方法    推荐
        #F.f2(self)     #同上的另一种方法
        print("S.f2")      #如果自己不想继承父类的方法，那就自己写一个方法（重写，防止执行父类中的方法）
'''
obj = S()
obj.s1()
obj.f1()
obj.f2()           #此时没有提加super，就没有继承父类的f2
'''

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

总结：
如果既想用父类的方法，也想用子类的方法，有两种方式：
super(子类,self).父类中的方法(…) eg:super(S, self).f2() 推荐
父类名.父类中的方法(self,…) eg:F.f2(self)

2.子类继承多个父类

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

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

class S(F1,F2):
    pass

obj = S()
obj.a()

总结：
python 中支持多继承
左侧优先
一条道走到黑
如果有了同一个跟，跟最后执行

import socketserver
obj = socketserver.ThreadingTCPServer(1,2)
obj.serve_forever()

九、面向对象三大特性之一 多态

首先Python不支持多态，也不用支持多态，python是一种多态语言，崇尚鸭子类型。

多态简单来说就是指多种状态，指的是：1、同一个实体同时具有多种形态，可以理解为同一个实例对象具有不同的属性：2、同一种操作作用于不同的实例对象会有不同的解释，产生不同的结果，也就是说，不同的实例对象调用同一种方法会产生不同的结果。

例子：

class A:    
    def prt(self):    
        print "A"    

class B(A):    
    def prt(self):    
        print "B"    

class C(A):    
    def prt(self):    
        print "C"    

class D(A):    
    pass    

class E:    
    def prt(self):    
        print "E"    

class F:    
    pass    

def test(arg):    
    arg.prt()    

a = A()    
b = B()    
c = C()    
d = D()    
e = E()    
f = F()    

test(a)    
test(b)    
test(c)    
test(d)    
test(e)    
test(f) 

结果
A
B
C
A
E

没有谁规定test方法是接收的参数是什么类型的。test方法只规定，接收一个参数，调用这个参数的prt方法。在运行的时候如果这个参数有prt方法，python就执行，如果没有，python就报错，因为abcde都有prt方法，而f没有，所以得到了上边得结果，这就是python的运行方式。