2. 程式人生 > >面向物件程式設計其實很簡單——Python 面向物件（初級篇）

面向物件程式設計其實很簡單——Python 面向物件（初級篇）

阿新 • • 發佈：2018-11-07

概述

  • 面向過程：根據業務邏輯從上到下寫壘程式碼

  • 函式式：將某功能程式碼封裝到函式中，日後便無需重複編寫，僅呼叫函式即可

  • 面向物件：對函式進行分類和封裝，讓開發“更快更好更強...”

面向過程程式設計最易被初學者接受，其往往用一長段程式碼來實現指定功能，開發過程中最常見的操作就是貼上複製，即：將之前實現的程式碼塊複製到現需功能處。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

while True：

    if cpu利用率 > 

90%:

        #傳送郵件提醒

        連線郵箱伺服器

        傳送郵件

        關閉連線

  

    if 硬碟使用空間 > 90%:

        

#傳送郵件提醒

        連線郵箱伺服器

        傳送郵件

        關閉連線

  

    if 記憶體佔用 > 80%:

        #傳送郵件提醒

        

連線郵箱伺服器

        傳送郵件

        關閉連線

隨著時間的推移，開始使用了函數語言程式設計，增強程式碼的重用性和可讀性，就變成了這樣：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

def 傳送郵件(內容)

    #傳送郵件提醒

    連線郵箱伺服器

    傳送郵件

    關閉連線

  

while True：

  

    if cpu利用率 > 90%:

        傳送郵件('CPU報警')

  

    if 硬碟使用空間 > 90%:

        傳送郵件('硬碟報警')

  

    if 記憶體佔用 > 80%:

        傳送郵件('記憶體報警')

今天我們來學習一種新的程式設計方式：面向物件程式設計（Object Oriented Programming，OOP，面向物件程式設計）
注：Java和C#來說只支援面向物件程式設計，而python比較靈活即支援面向物件程式設計也支援函數語言程式設計

 

建立類和物件

面向物件程式設計是一種程式設計方式，此程式設計方式的落地需要使用 “類” 和 “物件” 來實現，所以，面向物件程式設計其實就是對 “類” 和 “物件” 的使用。

　　類就是一個模板，模板裡可以包含多個函式，函式裡實現一些功能

　　物件則是根據模板建立的例項，通過例項物件可以執行類中的函式

271420286872390.jpg

 

  • class是關鍵字，表示類

  • 建立物件，類名稱後加括號即可

ps：類中的函式第一個引數必須是self（詳細見：類的三大特性之封裝）
　　 類中定義的函式叫做 “方法”

1

2

3

4

5

6

7

8

9

10

11

12

13

# 建立類

class Foo:

      

    def Bar(self):

        print 'Bar'

  

    def Hello(self, name):

        print 'i am %s' %name

  

# 根據類Foo建立物件obj

obj = Foo()

obj.Bar()            #執行Bar方法

obj.Hello('wupeiqi') #執行Hello方法

 

誒，你在這裡是不是有疑問了？使用函數語言程式設計和麵向物件程式設計方式來執行一個“方法”時函式要比面向物件簡便

  • 面向物件：【建立物件】【通過物件執行方法】

  • 函式程式設計：【執行函式】

觀察上述對比答案則是肯定的，然後並非絕對，場景的不同適合其的程式設計方式也不同。

總結：函式式的應用場景 --> 各個函式之間是獨立且無共用的資料

面向物件三大特性

面向物件的三大特性是指：封裝、繼承和多型。

一、封裝

封裝，顧名思義就是將內容封裝到某個地方，以後再去呼叫被封裝在某處的內容。

所以，在使用面向物件的封裝特性時，需要：

  • 將內容封裝到某處

  • 從某處呼叫被封裝的內容

第一步：將內容封裝到某處

271641407509817.jpg

 self 是一個形式引數，當執行 obj1 = Foo('wupeiqi', 18 ) 時，self 等於 obj1

                              當執行 obj2 = Foo('alex', 78 ) 時，self 等於 obj2

所以，內容其實被封裝到了物件 obj1 和 obj2 中，每個物件中都封裝了 name 和 age ，之前說的“內容封裝到某處”其在內容裡類似於下圖來儲存。

271653303446704.jpg

第二步：從某處呼叫被封裝的內容

呼叫被封裝的內容時，有兩種情況：

  • 通過物件直接呼叫

  • 通過self間接呼叫

1、通過物件直接呼叫被封裝的內容

上圖展示了物件 obj1 和 obj2 在記憶體中儲存的方式，根據儲存格式可以如此呼叫被封裝的內容：物件.屬性名

1

2

3

4

5

6

7

8

9

10

11

12

13

class Foo:

  

    def __init__(self, name, age):

        self.name = name

        self.age = age

  

obj1 = Foo('wupeiqi', 18)

print obj1.name    # 直接呼叫obj1物件的name屬性

print obj1.age     # 直接呼叫obj1物件的age屬性

  

obj2 = Foo('alex', 73)

print obj2.name    # 直接呼叫obj2物件的name屬性

print obj2.age     # 直接呼叫obj2物件的age屬性

2、通過self間接呼叫被封裝的內容

執行類中的方法時，需要通過self間接呼叫被封裝的內容

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

class Foo:

   

    def __init__(self, name, age):

        self.name = name

        self.age = age

   

    def detail(self):

        print self.name

        print self.age

   

obj1 = Foo('wupeiqi', 18)

obj1.detail()  # Python預設會將obj1傳給self引數，即：obj1.detail(obj1)，所以，此時方法內部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

   

obj2 = Foo('alex', 73)

obj2.detail()  # Python預設會將obj2傳給self引數，即：obj1.detail(obj2)，所以，此時方法內部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

綜上所述，對於面向物件的封裝來說，其實就是使用構造方法將內容封裝到 物件 中，然後通過物件直接或者self間接獲取被封裝的內容。

練習一：在終端輸出如下資訊

  • 小明，10歲，男，上山去砍柴

  • 小明，10歲，男，開車去東北

  • 小明，10歲，男，最愛大保健

  •  

  • 老李，90歲，男，上山去砍柴

  • 老李，90歲，男，開車去東北

  • 老李，90歲，男，最愛大保健

  •  

  • 老張...

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

函數語言程式設計

 

def kanchai(name, age, gender):

    print "%s,%s歲,%s,上山去砍柴" %(name, age, gender)

 

 

def qudongbei(name, age, gender):

    print "%s,%s歲,%s,開車去東北" %(name, age, gender)

 

 

def dabaojian(name, age, gender):

    print "%s,%s歲,%s,最愛大保健" %(name, age, gender)

 

 

kanchai('小明', 10, '男')

qudongbei('小明', 10, '男')

dabaojian('小明', 10, '男')

 

 

kanchai('老李', 90, '男')

qudongbei('老李', 90, '男')

dabaojian('老李', 90, '男')

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

class Foo:

     

    def __init__(self, name, age ,gender):

        self.name = name

        self.age = age

        self.gender = gender

 

    def kanchai(self):

        print "%s,%s歲,%s,上山去砍柴" %(self.name, self.age, self.gender)

 

    def qudongbei(self):

        print "%s,%s歲,%s,開車去東北" %(self.name, self.age, self.gender)

 

    def dabaojian(self):

        print "%s,%s歲,%s,最愛大保健" %(self.name, self.age, self.gender)

 

 

xiaoming = Foo('小明', 10, '男')

xiaoming.kanchai()

xiaoming.qudongbei()

xiaoming.dabaojian()

 

laoli = Foo('小明', 10, '男')

laoli.kanchai()

laoli.qudongbei()

laoli.dabaojian()

上述對比可以看出，如果使用函數語言程式設計，需要在每次執行函式時傳入相同的引數，如果引數多的話，又需要貼上複製了...  ；而對於面向物件只需要在建立物件時，將所有需要的引數封裝到當前物件中，之後再次使用時，通過self間接去當前物件中取值即可。

 

練習二：遊戲人生程式

1、建立三個遊戲人物，分別是：

  • 蒼井井，女，18，初始戰鬥力1000

  • 東尼木木，男，20，初始戰鬥力1800

  • 波多多，女，19，初始戰鬥力2500

2、遊戲場景，分別：

  • 草叢戰鬥，消耗200戰鬥力

  • 自我修煉，增長100戰鬥力

  • 多人遊戲，消耗500戰鬥力

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

# -*- coding:utf-8 -*-

 

# #####################  定義實現功能的類  #####################

 

class Person:

 

    def __init__(self, na, gen, age, fig):

        self.name = na

        self.gender = gen

        self.age = age

        self.fight =fig

 

    def grassland(self):

        """註釋：草叢戰鬥，消耗200戰鬥力"""

 

        self.fight = self.fight - 200

 

    def practice(self):

        """註釋：自我修煉，增長100戰鬥力"""

         

        self.fight = self.fight + 200

 

    def incest(self):

        """註釋：多人遊戲，消耗500戰鬥力"""

         

        self.fight = self.fight - 500

 

    def detail(self):

        """註釋：當前物件的詳細情況"""

 

        temp = "姓名:%s ; 性別:%s ; 年齡:%s ; 戰鬥力:%s"  % (self.name, self.gender, self.age, self.fight)

        print temp

 

         

# #####################  開始遊戲  #####################

 

cang = Person('蒼井井', '女', 18, 1000)    # 建立蒼井井角色

dong = Person('東尼木木', '男', 20, 1800)  # 建立東尼木木角色

bo = Person('波多多', '女', 19, 2500)      # 建立波多多角色

 

cang.incest() #蒼井空參加一次多人遊戲

dong.practice()#東尼木木自我修煉了一次

bo.grassland() #波多多參加一次草叢戰鬥

 

 

#輸出當前所有人的詳細情況

cang.detail()

dong.detail()

bo.detail()

 

 

cang.incest() #蒼井空又參加一次多人遊戲

dong.incest() #東尼木木也參加了一個多人遊戲

bo.practice() #波多多自我修煉了一次

 

#輸出當前所有人的詳細情況

cang.detail()

dong.detail()

bo.detail()

 

遊戲人生

 

二、繼承

繼承，面向物件中的繼承和現實生活中的繼承相同，即：子可以繼承父的內容。

例如：

　　貓可以：喵喵叫、吃、喝、拉、撒

　　狗可以：汪汪叫、吃、喝、拉、撒

如果我們要分別為貓和狗建立一個類，那麼就需要為 貓 和 狗 實現他們所有的功能，如下所示：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

虛擬碼

 

class 貓：

 

    def 喵喵叫(self):

        print '喵喵叫'

 

    def 吃(self):

        # do something

 

    def 喝(self):

        # do something

 

    def 拉(self):

        # do something

 

    def 撒(self):

        # do something

 

class 狗：

 

    def 汪汪叫(self):

        print '喵喵叫'

 

    def 吃(self):

        # do something

 

    def 喝(self):

        # do something

 

    def 拉(self):

        # do something

 

    def 撒(self):

        # do something

 

上述程式碼不難看出，吃、喝、拉、撒是貓和狗都具有的功能，而我們卻分別的貓和狗的類中編寫了兩次。如果使用 繼承 的思想，如下實現：

　　動物：吃、喝、拉、撒

　　   貓：喵喵叫（貓繼承動物的功能）

　　   狗：汪汪叫（狗繼承動物的功能）

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

虛擬碼

 

class 動物:

 

    def 吃(self):

        # do something

 

    def 喝(self):

        # do something

 

    def 拉(self):

        # do something

 

    def 撒(self):

        # do something

 

# 在類後面括號中寫入另外一個類名，表示當前類繼承另外一個類

class 貓(動物)：

 

    def 喵喵叫(self):

        print '喵喵叫'

         

# 在類後面括號中寫入另外一個類名，表示當前類繼承另外一個類

class 狗(動物)：

 

    def 汪汪叫(self):

        print '喵喵叫'

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

程式碼例項

 

class Animal:

 

    def eat(self):

        print "%s 吃 " %self.name

 

    def drink(self):

        print "%s 喝 " %self.name

 

    def shit(self):

        print "%s 拉 " %self.name

 

    def pee(self):

        print "%s 撒 " %self.name

 

 

class Cat(Animal):

 

    def __init__(self, name):

        self.name = name

        self.breed ＝ '貓'

 

    def cry(self):

        print '喵喵叫'

 

class Dog(Animal):

     

    def __init__(self, name):

        self.name = name

        self.breed ＝ '狗'

         

    def cry(self):

        print '汪汪叫'

         

 

# ######### 執行 #########

 

c1 = Cat('小白家的小黑貓')

c1.eat()

 

c2 = Cat('小黑的小白貓')

c2.drink()

 

d1 = Dog('胖子家的小瘦狗')

d1.eat()

 

所以，對於面向物件的繼承來說，其實就是將多個類共有的方法提取到父類中，子類僅需繼承父類而不必一一實現每個方法。

注：除了子類和父類的稱謂，你可能看到過 派生類 和 基類 ，他們與子類和父類只是叫法不同而已。

272229566093488.jpg

 

學習了繼承的寫法之後，我們用程式碼來是上述阿貓阿狗的功能：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

程式碼例項

 

class Animal:

 

    def eat(self):

        print "%s 吃 " %self.name

 

    def drink(self):

        print "%s 喝 " %self.name

 

    def shit(self):

        print "%s 拉 " %self.name

 

    def pee(self):

        print "%s 撒 " %self.name

 

 

class Cat(Animal):

 

    def __init__(self, name):

        self.name = name

        self.breed ＝ '貓'

 

    def cry(self):

        print '喵喵叫'

 

class Dog(Animal):

     

    def __init__(self, name):

        self.name = name

        self.breed ＝ '狗'

         

    def cry(self):

        print '汪汪叫'

         

 

# ######### 執行 #########

 

c1 = Cat('小白家的小黑貓')

c1.eat()

 

c2 = Cat('小黑的小白貓')

c2.drink()

 

d1 = Dog('胖子家的小瘦狗')

d1.eat()

 

那麼問題又來了，多繼承呢？

  • 是否可以繼承多個類

  • 如果繼承的多個類每個類中都定了相同的函式，那麼那一個會被使用呢？

1、Python的類可以繼承多個類，Java和C#中則只能繼承一個類

2、Python的類如果繼承了多個類，那麼其尋找方法的方式有兩種，分別是：深度優先和廣度優先

272315068126604.jpg

 

  • 當類是經典類時，多繼承情況下，會按照深度優先方式查詢

  • 當類是新式類時，多繼承情況下，會按照廣度優先方式查詢

經典類和新式類，從字面上可以看出一個老一個新，新的必然包含了跟多的功能，也是之後推薦的寫法，從寫法上區分的話，如果 當前類或者父類繼承了object類，那麼該類便是新式類，否則便是經典類。

272341313127410.jpg

272341553282314.jpg

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

經典類多繼承

 

class D:

 

    def bar(self):

        print 'D.bar'

 

 

class C(D):

 

    def bar(self):

        print 'C.bar'

 

 

class B(D):

 

    def bar(self):

        print 'B.bar'

 

 

class A(B, C):

 

    def bar(self):

        print 'A.bar'

 

a = A()

# 執行bar方法時

# 首先去A類中查詢，如果A類中沒有，則繼續去B類中找，如果B類中麼有，則繼續去D類中找，如果D類中麼有，則繼續去C類中找，如果還是未找到，則報錯

# 所以，查詢順序：A --> B --> D --> C

# 在上述查詢bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了

a.bar()

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

新式類多繼承

 

class D(object):

 

    def bar(self):

        print 'D.bar'

 

 

class C(D):

 

    def bar(self):

        print 'C.bar'

 

 

class B(D):

 

    def bar(self):

        print 'B.bar'

 

 

class A(B, C):

 

    def bar(self):

        print 'A.bar'

 

a = A()

# 執行bar方法時

# 首先去A類中查詢，如果A類中沒有，則繼續去B類中找，如果B類中麼有，則繼續去C類中找，如果C類中麼有，則繼續去D類中找，如果還是未找到，則報錯

# 所以，查詢順序：A --> B --> C --> D

# 在上述查詢bar方法的過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了

a.bar()

經典類：首先去A類中查詢，如果A類中沒有，則繼續去B類中找，如果B類中麼有，則繼續去D類中找，如果D類中麼有，則繼續去C類中找，如果還是未找到，則報錯

新式類：首先去A類中查詢，如果A類中沒有，則繼續去B類中找，如果B類中麼有，則繼續去C類中找，如果C類中麼有，則繼續去D類中找，如果還是未找到，則報錯

注意：在上述查詢過程中，一旦找到，則尋找過程立即中斷，便不會再繼續找了

 

三、多型 

 Pyhon不支援多型並且也用不到多型，多型的概念是應用於Java和C#這一類強型別語言中，而Python崇尚“鴨子型別”。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

Python虛擬碼實現Java或C#的多型

 

class F1:

    pass

 

 

class S1(F1):

 

    def show(self):

        print 'S1.show'

 

 

class S2(F1):

 

    def show(self):

        print 'S2.show'

 

 

# 由於在Java或C#中定義函式引數時，必須指定引數的型別

# 為了讓Func函式既可以執行S1物件的show方法，又可以執行S2物件的show方法，所以，定義了一個S1和S2類的父類

# 而實際傳入的引數是：S1物件和S2物件

 

def Func(F1 obj):

    """Func函式需要接收一個F1型別或者F1子類的型別"""

     

    print obj.show()

     

s1_obj = S1()

Func(s1_obj) # 在Func函式中傳入S1類的物件 s1_obj，執行 S1 的show方法，結果：S1.show

 

s2_obj = S2()

Func(s2_obj) # 在Func函式中傳入Ss類的物件 ss_obj，執行 Ss 的show方法，結果：S2.show

 

 

 

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

Python “鴨子型別”

 

class F1:

    pass

 

 

class S1(F1):

 

    def show(self):

        print 'S1.show'

 

 

class S2(F1):

 

    def show(self):

        print 'S2.show'

 

def Func(obj):

    print obj.show()

 

s1_obj = S1()

Func(s1_obj) 

 

s2_obj = S2()

Func(s2_obj)

總結 

以上就是本節對於面向物件初級知識的介紹，總結如下：

  • 面向物件是一種程式設計方式，此程式設計方式的實現是基於對 類 和 物件 的使用
  • 類 是一個模板，模板中包裝了多個“函式”供使用
  • 物件，根據模板建立的例項（即：物件），例項用於呼叫被包裝在類中的函式
  • 面向物件三大特性：封裝、繼承和多型

問答專區

問題一：什麼樣的程式碼才是面向物件？

答：從簡單來說，如果程式中的所有功能都是用 類 和 物件 來實現，那麼就是面向物件程式設計了。

問題二：函數語言程式設計 和 面向物件 如何選擇？分別在什麼情況下使用？

答：須知：對於 C# 和 Java 程式設計師來說不存在這個問題，因為該兩門語言只支援面向物件程式設計（不支援函數語言程式設計）。而對於 Python 和 PHP 等語言卻同時支援兩種程式設計方式，且函數語言程式設計能完成的操作，面向物件都可以實現；而面向物件的能完成的操作，函數語言程式設計不行（函數語言程式設計無法實現面向物件的封裝功能）。

所以，一般在Python開發中，全部使用面向物件 或 面向物件和函式式混合使用

面向物件的應用場景:

  1. 多函式需使用共同的值，如：資料庫的增、刪、改、查操作都需要連線資料庫字串、主機名、使用者名稱和密碼

  2. 需要建立多個事物，每個事物屬性個數相同，但是值的需求
    如：張三、李四、楊五，他們都有姓名、年齡、血型，但其都是不相同。即：屬性個數相同，但值不相同

問題三：類和物件在記憶體中是如何儲存？

答：類以及類中的方法在記憶體中只有一份，而根據類建立的每一個物件都在記憶體中需要存一份，大致如下圖：

如上圖所示，根據類建立物件時，物件中除了封裝 name 和 age 的值之外，還會儲存一個類物件指標，該值指向當前物件的類。

當通過 obj1 執行 【方法一】 時，過程如下：

  1. 根據當前物件中的 類物件指標 找到類中的方法
  2. 將物件 obj1 當作引數傳給 方法的第一個引數 self 

相關推薦

面向物件程式設計其實很簡單——Python 面向物件（初級篇）

概述 面向過程：根據業務邏輯從上到下寫壘程式碼 函式式：將某功能程式碼封裝到函式中，日後便無需重複編寫，僅呼叫函式即可 面向物件：對函式進行分類和封裝，讓開發“更快更好更強...” 面向過程程式設計最易被初學者接受，其往往用一長段程式碼來實現指定功能，開發過

Python程式碼實戰（初級篇）————3、企業獎金髮放

題目要求：企業發放的獎金根據利潤提成。利潤(I)低於或等於10萬元時，獎金可提10%；利潤高於10萬元，低於20萬元時，低於10萬元的部分按10%提成，高於10萬元的部分，可提成7.5%；20萬到40萬之間時，高於20萬元的部分，可提成5%；40萬到60萬之間時高於40萬元的

【python基礎】面向物件程式設計（初級篇）

在Python教學中發現，很多同學在走到面向物件程式設計這塊就開始蒙圈了，為了幫助大家更好的理解面向物件程式設計並其能將其用到自己的開發過程中，特寫此文。 概述 面向過程：根據業務邏輯從上到下寫壘程式碼 函式式：將某功能程式碼封裝到函式中，日後便無需重複

Python之面向對象（初級篇）

one 這一 調用 現實生活 ram 每次 open java 自我 面向過程：根據業務邏輯從上到下寫壘代碼 函數式：將某功能代碼封裝到函數中，日後便無需重復編寫，僅調用函數即可 面向對象：對函數進行分類和封裝，讓開發“更快更好更強...” 面向過程編程最易被初學者接受

Python 面向對象（初級篇）

編程方式 can func 中斷 業務 存在 src 面向過程編程 display 概述 面向過程：根據業務邏輯從上到下寫壘代碼 函數式：將某功能代碼封裝到函數中，日後便無需重復編寫，僅調用函數即可 面向對象：對函數進行分類和封裝，讓開發“更快更好更強

指令碼其實很簡單-愛心列印指令碼（1）

教程簡介 本系列教程（指令碼其實很簡單）的目的是熟悉Windows下的bat指令碼和Linux下的bash shell指令碼。 指令碼的特性就在於不依賴於特定環境，直接呼叫作業系統，不需要“中間人”就可以執行。 文章簡介 作為系列的第一篇文章，思來想去，最終兼顧程式設計師和屌絲單身貴族的身份，打算完成

資料持久化其實很簡單 【上】（精華）

        在iOS開發中，資料持久化非常重要，但是新手也很迷茫，該怎麼對資料進行處理呀，哪種方式好，每種方式又有什麼弊端？ 到底該怎麼進行選擇呢，接下來我想給大家分享分享，相互學習。 首先現在常用的資料持久化有4種：         XML屬性列表（plist），Pr

一個簡單python介面開發（flask_restful案例）

執行環境：python3 post引數：user,pwd 介面功能：將引數轉換成字串相加並返回json from flask import Flask, g from flask_restful import reqparse, Api, Resource from f

Python 正則表達式入門（初級篇）

-name regex sna per 級別 腦洞 現在 裏的 改變 Python 正則表達式入門（初級篇） Python 正則表達式入門（初級篇） 本文主要為沒有使用正則表達式經驗的新手入門所寫。轉載請寫明出處 引子 首先

遠程和Ubuntu服務器進行Socket通信，使用python和C#（準備篇）

ESS 簡單 nts 行操作 img passwd ant password users 　　服務器在阿裏雲上，和一般的本地配置方案不太一樣，所以網上的博客裏沒有解決辦法，本人在這裏記錄一下，方便大家交流。 　　由於數據要保存到MySQL數據庫中，使用python對數據進行

單機遊戲—亂世君臨，純python實現大型遊戲開發！（初級篇）

             學習Python中有不明白推薦加入交流群                 號：516107834 &nbs

Eclipse和PyDev搭建完美Python開發環境（Windows篇）

安裝Python 從網站上下載最新的版本，從http://python.org/download/下載。安裝過程與其他Windows軟體類似。這裡使用python2.7.6 在Windows命令列中使用Python 如果你想要從Windows命令列呼叫Python，那麼需要

express搭建簡單的後臺伺服器（入門篇）

說閒話 之前一段時間，工作之餘我還比較閒。我就用Angular做了一個前端小demo，後臺伺服器就簡單用express搭了一下。程式碼都是在公司寫的，沒拿回來。很久沒關注，很多東西都忘記了。今天想重新溫習一下，把一些重要的細節記下來。先從後臺搭起。 安裝

Python知識點整理（基礎篇）

Python 資料型別基礎  字面常量  所謂字面，就是我們在程式中直接以值的行式來操作、表現（可以對照變數）； 所謂常量，是指這些值不能再被改變了。 字面常量的種類： （1）整形 整形數值 預設是int型，例如：22,33 如果要表示一個long型，則加 l、L字尾。例如

python多行註釋 && Eclipse和PyDev搭建完美Python開發環境（Ubuntu篇）

python本身不帶多行註釋，編輯時每行敲一個“#”相當的不方便，其實可以有變通的方法 1. 把要註釋的塊用if 0：包起來,需要注意縮排 2. 把要註釋的塊用'''    '''包起來，也需要注意縮排。不過一般情況下'''是用來做function doc的，所以

express搭建簡單的後臺伺服器（基礎篇）

本文簡單對express的一些重要基礎知識做一下記錄，以加深自己對express基礎的瞭解。 不得不說的路由 作為一個後臺伺服器，你必須要處理來自客戶端的各種請求。這個時候，就要先定義各種請求的處理器，也就是路由。 引用express官方的解釋。

javascript面向物件程式設計--繼承--多重繼承+摻元類（多親繼承）

繼承一般包括 單向繼承 和 多重繼承   多重繼承：一個子類繼承多個超類 function A(x){this.x=x;} A.prototype.getx=function(){return  this.x;} function B(y){this.y=y;}

《面向物件程式設計——C++語言描述》學習筆記（二）

第二章 從C到C++  2.1main函式 1.C++中需要寫int main（）不能只是main（） 2.main()函式裡面最後有一個return 0； 3.main（）被啟動程式碼呼叫，而啟動程式碼是編譯器新增到程式中的，是程式和作業系統的橋樑。 4.C++中main（）中

C語言面向物件程式設計：虛擬函式與多型（3）

 在《 C++ 程式設計思想》一書中對虛擬函式的實現機制有詳細的描述，一般的編譯器通過虛擬函式表，在編譯時插入一段隱藏的程式碼，儲存型別資訊和虛擬函式地址，而在呼叫時，這段隱藏的程式碼可以找到和實際物件一致的虛擬函式實現。     我們在這裡提供

何為面向元件程式設計？與之相比面向物件、面向服務又是什麼？

  件技術和思想的出現都是為了解決所在的那個年代軟體開發的複雜性，物件技術和元件技術也不例外。當然還有很多其它技術，像DBC（契約式程式設計）、AOP、MDA等，這些思想都在影響程式的設計與實現方式。 面向物件、面向服務、面向元件，他們真實的叫法應該是：“面向物件程式設計”“