Python基礎(chǔ)之(八)類

Freeman 發(fā)布于2019-07-25 10:53 / 475人閱讀

摘要：方法綁定方法多重繼承實(shí)例化實(shí)現(xiàn)了方法和實(shí)例的綁調(diào)用綁定方法非綁定方法在子類中，父類的方法就是非綁定方法，因?yàn)樵谧宇愔校瑳]有建立父類的實(shí)例，卻要是用父類的方法。

類 創(chuàng)建類

第一形式

# !/usr/bin/env python
# coding=utf-8

class Person(object): #object表示繼承自object類，Python3中可省略次內(nèi)容
    """
    This is a sample of Class
    """
    breast = 90  #類的屬性 是靜態(tài)變量
    
    def __init__(self, name): #初始化方法  self為對(duì)象實(shí)例本身
        self.name = name
        
    def get_name(self):  #類的方法
        return self.name
    
    def color(self,color):
        d = {}
        d[self.name] = color;
        return d
    
if __name__ == "__main__":
    girl = Person("songjia")
    print girl.name
    girl.name ="liu"
    print girl.get_name()
    print girl.color("white")
    girl.breast = 80 #修改實(shí)例的屬性
    print girl.breast
    print Person.breast #類屬性不會(huì)隨實(shí)例屬性的改變而改變
    Person.breast = 100
    print Person.breast
    print girl.breast

第二種形式

>>> __metaclass__ = type
>>> class CC:
...     pass
... 
>>> cc = CC()
>>> cc.__class__

>>> type(cc)

實(shí)例

girl = Person("songjia")

類屬性

>>> class A(object):    #Python 3: class A:
...         x = 7  #類的屬性
...

下面列出類的幾種特殊屬性的含義:

C.__name__：以字符串的形式，返回類的名字，注意這時(shí)候得到的僅僅是一個(gè)字符串，它不是一個(gè)類對(duì)象

C.__doc__：顯示類的文檔

C.__base__：類C的所有父類。如果是按照上面方式定義的類，應(yīng)該顯示object，因?yàn)橐陨纤蓄惗祭^承了它。等到學(xué)習(xí)了“繼承”，再來看這個(gè)屬性，內(nèi)容就豐富了

C.__dict__：以字典形式顯示類的所有屬性

C.__module__：類所在的模塊

實(shí)例屬性

>>> class A(object):    #Python 3: class A:
...         x = 7  #類的屬性
... 
>>> foo = A()
>>> foo.x #實(shí)例屬性

類中變量引用可變數(shù)據(jù)

>>> class B(object):
...     y = [1, 2, 3]
    
   >>> B.y         #類屬性
[1, 2, 3]
>>> bar = B()
>>> bar.y       #實(shí)例屬性
[1, 2, 3]

>>> bar.y.append(4)
>>> bar.y
[1, 2, 3, 4]
>>> B.y
[1, 2, 3, 4]

>>> B.y.append("aa")
>>> B.y
[1, 2, 3, 4, "aa"]
>>> bar.y
[1, 2, 3, 4, "aa"]

當(dāng)類中變量引用的是可變對(duì)象是，類屬性和實(shí)例屬性都能直接修改這個(gè)對(duì)象，從而影響另一方的值。

訪問限制

# !/usr/bin/env python
# coding=utf-8

class Person(object):
    """
    This is a sample of Class
    """
    
    def __init__(self, name): #初始化方法  self為對(duì)象實(shí)例本身
        self.__name = name #__xx雙下劃線表示類的私有變量
        
    def get_name(self):  #類的方法
        return self.__name #類的內(nèi)部可以訪問
    
if __name__ == "__main__":
    girl = Person("songjia")
    print girl.get_name()
    print girl._name #無法訪問類的私有變量

文檔字符串

在函數(shù)、類或者文件開頭的部分寫文檔字符串說明，一般采用三重引號(hào)。這樣寫的最大好處是能夠用help()函數(shù)看。

"""This is python lesson"""

def start_func(arg):
   """This is a function."""
   pass

class MyClass:
   """This is my class."""
   def my_method(self,arg):
       """This is my method."""
       pass

繼承 單繼承

#!/usr/bin/env python
# coding=utf-8

class Person(object):        #Python 3: class Person:
    def __init__(self, name):
        self.name = name
    
    def height(self, m):
        h = dict((["height", m],))
        return h

    def breast(self, n):
        b = dict((["breast", n],))
        return b

class Girl(Person):  #繼承
    def get_name(self):
        return self.name

if __name__ == "__main__":
    cang = Girl("liuguoquan")
    print cang.get_name()        #Python 3: print(cang.get_name())，下同，從略
    print cang.height(160)
    print cang.breast(90)

調(diào)用覆蓋的方法

class Girl(Person):
   def __init__(self, name):
       #Person.__init__(self, name) #調(diào)用父類的方法
       super(Girl, self).__init__(name) #調(diào)用父類的方法常用寫法
       self.real_name = "Aoi sola"

   def get_name(self):
       return self.name
       
if __name__ == "__main__":
   cang = Girl("canglaoshi")
   print cang.real_name
   print cang.get_name()
   print cang.height(160)
   print cang.breast(90)

執(zhí)行結(jié)果為：

    Aoi sola
    canglaoshi
    {"height": 160}
    {"breast": 90}

多繼承

#!/usr/bin/env python
# coding=utf-8

class Person(object):        #Python 3: class Person:
    def eye(self):
        print "two eyes"

    def breast(self, n):
        print "The breast is: ",n

class Girl(object):        #Python 3: class Gril:
    age = 28
    def color(self):
        print "The girl is white"

class HotGirl(Person, Girl): #多重繼承
    pass

if __name__ == "__main__":
    kong = HotGirl()
    kong.eye()
    kong.breast(90)
    kong.color()
    print kong.age
    
two eyes
The breast is:  90
The girl is white
28

多重繼承的順序-廣度優(yōu)先

class K1(object):        #Python 3: class K1:
   def foo(self):
       print "K1-foo"    #Python 3: print("K1-foo")，下同，從略

class K2(object):        #Python 3: class K2:
   def foo(self):
       print "K2-foo"
   def bar(self):
       print "K2-bar"

class J1(K1, K2):
   pass

class J2(K1, K2):
   def bar(self):
       print "J2-bar"

class C(J1, J2):
pass
   
if __name__ == "__main__":
print C.__mro__
m = C()
m.foo()
m.bar()
   
K1-foo
J2-bar

代碼中的print C.__mro__是要打印出類的繼承順序。從上面清晰看出來了。如果要執(zhí)行foo()方法，首先看J1，沒有，看J2，還沒有，看J1里面的K1，有了，即C==>J1==>J2==>K1；bar()也是按照這個(gè)順序，在J2中就找到了一個(gè)。

這種對(duì)繼承屬性和方法搜索的順序稱之為“廣度優(yōu)先”。
Python 2的新式類，以及Python 3中都是按照此順序原則搜尋屬性和方法的。

方法 綁定方法

#!/usr/bin/env python
# coding=utf-8

class Person(object):        #Python 3: class Person:
    def eye(self):
        print "two eyes"

    def breast(self, n):
        print "The breast is: ",n

class Girl(object):        #Python 3: class Gril:
    age = 28
    def color(self):
        print "The girl is white"

class HotGirl(Person, Girl): #多重繼承
    pass

if __name__ == "__main__":
    kong = HotGirl() #實(shí)例化實(shí)現(xiàn)了方法和實(shí)例的綁
    kong.eye() #調(diào)用綁定方法

非綁定方法

在子類中，父類的方法就是非綁定方法，因?yàn)樵谧宇愔校瑳]有建立父類的實(shí)例，卻要是用父類的方法。

靜態(tài)方法和類方法

#!/usr/bin/env python
# coding=utf-8

__metaclass__ = type

class StaticMethod: #靜態(tài)方法
    @staticmethod
    def foo():
        print "This is static method foo()."

class ClassMethod: #類方法
    @classmethod
    def bar(cls): #類方法必須有cls參數(shù)
        print "This is class method bar()."
        print "bar() is part of class:", cls.__name__

if __name__ == "__main__":
    static_foo = StaticMethod()    #實(shí)例化
    static_foo.foo()               #實(shí)例調(diào)用靜態(tài)方法
    StaticMethod.foo()             #通過類來調(diào)用靜態(tài)方法
    print "********"
    class_bar = ClassMethod()
    class_bar.bar()
    ClassMethod.bar()
    
This is static method foo().
This is static method foo().
********
This is class method bar().
bar() is part of class: ClassMethod
This is class method bar().
bar() is part of class: ClassMethod

在python中：

@staticmethod表示下面的方法是靜態(tài)方法

@classmethod表示下面的方法是類方法

多態(tài)和封裝 多態(tài)

class Cat:
   def speak(self):
       print "meow!"

class Dog:
   def speak(self):
       print "woof!"

class Bob:
   def bow(self):
       print "thank you, thank you!"
   def speak(self):
       print "hello, welcome to the neighborhood!"
   def drive(self):
       print "beep, beep!"

def command(pet):
   pet.speak()

pets = [ Cat(), Dog(), Bob() ]

for pet in pets:
   command(pet)

Python中的多態(tài)特點(diǎn),Python不檢查傳入對(duì)象的類型，這種方式被稱之為“隱式類型”（laten typing）或者“結(jié)構(gòu)式類型”（structural typing），也被通俗的稱為“鴨子類型”(duck typeing)，Python是弱類型語言。

Java會(huì)檢查傳入對(duì)象的類型，所以是強(qiáng)類型語言。

封裝和私有化

要了解封裝，離不開“私有化”，就是將類或者函數(shù)中的某些屬性限制在某個(gè)區(qū)域之內(nèi)，外部無法調(diào)用。

Python中私有化的方法也比較簡單，就是在準(zhǔn)備私有化的屬性（包括方法、數(shù)據(jù)）名字前面加雙下劃線。例如：

#!/usr/bin/env python
# coding=utf-8

class ProtectMe(object):        #Python 3: class ProtectMe:
    def __init__(self):
        self.me = "qiwsir"
        self.__name = "kivi" #私有變量

    def __python(self): #私有方法
        print "I love Python."        

    def code(self):
        print "Which language do you like?"
        self.__python()

if __name__ == "__main__":
    p = ProtectMe()
    print p.me
    print p.code()

如何將一個(gè)方法變成屬性調(diào)用？

可以使用property函數(shù)。

#!/usr/bin/env python
# coding=utf-8

class ProtectMe(object):        #Python 3: class ProtectMe:
    def __init__(self):
        self.me = "qiwsir"
        self.__name = "kivi" #私有變量

    def __python(self): #私有方法
        print "I love Python."        

    @property
    def code(self):
        print "Which language do you like?"
        self.__python

if __name__ == "__main__":
    p = ProtectMe()
    print p.me
    print p.code #調(diào)用方法名即可