python：類1——類和物件基礎

一、OO = Object Oriented 物件導向　　

OOP物件導向程式設計、OOA物件導向分析、OOD物件導向設計

 

二、屬性+方法——>類（資料和函式）

class Turtle():   #類名約定用大寫
    #屬性
    color = 

    #方法
    def climb(self):
        pass
    def run(self):
        pass

tt = Turtle()    #建立物件
tt.run()    #呼叫

class Myclass(list):繼承list
　　pass
list2 = Myclass()
list2.append(4)
list2.append(3)
list2.sort()

class A：
　　def fun(self):
　　　　print('I am A')
class B:
　　def fun(self):
　　　　print('I am B')
a = A()
b = B()
a.fun()
b.fun()#名字一樣，列印不一樣，就是多型

OOP三大特徵：

封裝：資訊隱蔽技術

繼承：子類自動共享父類之間數 據和方法的機制

多型：不同物件對同一方法響應不同的行動

 

三、self是什麼？相當於c++的this指標！

由一個類可以生成無數個物件，當一個物件的方法被呼叫的時候，物件會把自身作為第一個引數傳給self引數，Python就知道是哪個物件在呼叫方法了。例如：

class Ball():
    def setName(self, name):
        self.name = name
    def kick(self):
        print("我叫%s，誰踢我。。。" % self.name)

a = Ball()
a.setName('qiu A')
b = Ball()
b.setName('qiu B')
a.kick()
b.kick()　　　　#a物件和b物件個返回個的，正是因為self的幫助

　

四、Python的魔法方法（被雙下滑線包圍）

__init__(self)構造方法，用於例項化物件傳入引數

上邊兩個例子沒有顯性宣告構造方法，試用預設的無慘__init__()

#coding:utf8
class Ball:
        def __init__(self, name):
                self.name = name
        def kick(self):
                print("I am %s, 該死的，誰踢我" % self.name)

a = Ball('土豆')
a.kick()
c = Ball() #報錯

 

五、公有和私有

公有變數可以通過點操作符訪問

私有變數(名字改編"_類名__變數名"name mangling技術)只需在變數名或函式名前加上“__”兩個下劃線！此時點name或者點__name都不能訪問到（報錯），試用getName()

#coding:utf8
class Person:
        __name = "liyi"
        def getName(self):　　　　　　#通過方法訪問
                return self.__name

p = Person()
#p.name　　報錯
#p.__name　報錯
p.getName()
p._Person__name  　　　　　　　　　　　 #會訪問到liyi

 私有方法也是加兩個下劃線

python：類5——Python 的類的下劃線命名有什麼不同？

 

六、繼承

1、如果子類中定義與父類同名的方法或屬性，則會自動覆蓋父類對應的方法或屬性

#coding:utf8
class Parent:
        def hello(self):
                print('父類方法hello')
        def func(self):
                print('父類方法func')
class Child(Parent):
        def func(self):
                print('子類方法func，覆蓋了父類方法')

p = Child()
p.hello()
p.func()


[root@CentOS6 ~]# python test.py 
父類方法hello
子類方法func，覆蓋了父類方法

2、supper()方法

（技術一：呼叫未繫結的父類方法）呼叫父類的構造方法（父類點init方法，注意self引數），
　　　　　　　　　　　　　　　　此處的self不是分類的例項物件，而是子類Shark的例項物件，相當於Fish.__init__(Shark),因為被重寫了。
（技術二：使用supper函式<更好>）：supper函式能自動找到需要的基類的方法，而且還會為我們自動傳入self引數
　　　　　　　　　　　　　　　　supper().__init__()，不用給出基類的名字，會自動把所有父類、父父類的方法；所以修改基類名字時，不用一一修改

#coding:utf8
import random as r
class Fish:
def __init__(self):

                self.x = r.randint(0, 10)
                self.y = r.randint(0, 10)
        def move(self):
                self.x -= 1
                print("我的位置是:", self.x, self.y)

class Goldfish(Fish):
        pass
class Carp(Fish):
        pass
class Salmon(Fish):
        pass
class Shark(Fish):　　　　　　　　　　　　#定義鯊魚，除了位置屬性還要有個是否飢餓的屬性
        def __init__(self):　　　　 　　#重寫就會覆蓋
　　　　　　　　  Fish.__init__(self)   #（技術一：呼叫未繫結的父類方法）
　　　　　　　　　　　　　　　　　　　　　　 （技術二：使用supper函式<更好>）
                self.hungry = True
        def eat(self):
                if self.hungry:
                        print("吃貨的夢想就是天天有的吃")
                        self.hungry = False
                else:
                        print("太撐了，吃不下了")

g = Goldfish()
s = Shark()
s.eat()
g.move()

3、多重繼承:會使語法混亂，儘量不用

class Base1:
    pass
class Base2:
    pass
class C(Base1, Base2):
    pass

 

七、組合類：把類的例項化放到新類裡邊（橫向關係，繼承是縱向關係）

#coding:utf8
把魚類物件和烏龜類物件放到水池類中
class Turtle:
        def __init__(self, x):
                self.num = x
class Fish:
        def __init__(self, x):
                self.num = x
class Pool:
        def __init__(delf, x, y):　　#傳入x個烏龜y個魚
                self.turtle = Turtle(x)
                self.fish = Fish(y)
        def print_num(self):
                print("水池總共有烏龜%d只，小魚%d條" % (self.turtle.num, self.fish.num)　　#這裡self.turtle是不對的，必須是self.turtle.num

 

八、Mix-in機制（魚c擴充套件）

pass

 

九、類、類物件、例項物件：是三個不同的東西！

#coding:utf8
class C:　　　 #類
        count = 0
a = C()
b = C()
a.count　　　　　#例項物件的count
C.count　　　　　#類物件的count
a.count = 10　　#a.count返回10  b.count返回0  C.count返回0
C.count = 100   #a.count返回10（因為上一步已經覆蓋，看不到上一層） b.count返回100（未覆蓋，看到上一層）  C.count返回100
對例項物件賦值後，會覆蓋掉類物件，而看不到類物件

下邊的會覆蓋上邊的！

 

十、屬性和方法相同，屬性會把方法覆蓋掉！　　

　　屬性名用名詞，方法名用動詞

 

---

擴充套件：Python繫結概念

Python嚴格要求方法需要有例項才能被呼叫，這種限制其實就是Python所謂的繫結概念。所以需要在方法定義時加上self

 

bb.__dict__檢視例項所擁有的屬性

BB.__dict__檢視類所擁有的的屬性，可以看到方法，會有好多東西，用來跟蹤與類相關的值。例項物件會共用，但會被例項屬性覆蓋；以dict鍵值對返回

刪除類物件後，例項物件（static靜態的）依然存在在記憶體中，只有當程式退出時才會釋放。