面向對象編程——Object Oriented Programming，簡稱OOP，是一種程序設計思想。
OOP把對象作爲程序的基本單元，一個對象包含了數據和操作數據的函數。面向過程 – 程序設計把計算機程序視爲一系列的命令集合，即一組函數的順序執行。 面向對象 –
程序設計把計算機程序視爲一組對象的集合，用對象的調用來完成程序。面向過程與面向對象的區別 ：
以蓋房子舉例：
面向過程：我去買磚瓦水泥，我來砌牆，我去買門，我去做窗戶，我去給房間佈線，我來對房子進行裝修；
面向對象：我讓購買材料的人員去買磚瓦水泥，讓泥瓦匠來砌牆， 讓傢俱城的人給我送門窗過來，讓電工來進行佈線，找裝修公司來進行裝修。區別在哪裏？ 第一種所有的事情都是你去做， 第二種所有的事情都有專門的人去做，我們負責指揮（調用）。
所謂面向對象編程思想，就是說要是有什麼事情去做的話，不要上來就自己去幹，
所有事情都自己幹，如果事情很複雜，那麼過程將會很亂，沒有條理。而應該怎麼樣呢？
應該分工明確，分解這件事情，各司其職，當然這是要由我們去分解，由我們去創建對象，賦予他們職能。 具體的活，再讓他們去幹（調用）。在Python中，所有數據類型都可以視爲對象，當然也可以自定義對象。 自定義的對象數據類型就是面向對象中的類（Class）的概念。
python中面向對象有兩個重要的主題，類和類的實例(對象)類是對某一類具有共同特點的事物的抽象，是對象的定義，像是玩具的模具 類的實例（對象）是類的產物，它存放了類中定義的對象的具體信息，
像是生產線上根據同一個模具生產的不同規格的玩具
# 假設我們要處理學生的信息，爲了表示一個學生的信息，面向過程的程序可以用一個dict表示：
dict1 = {'name': 'xiaoming', 'age': 20}
dict2 = {'name': 'xiaohong', 'age': 19}
def print_stuinfo(studict):
print '%s: %s' % (studict('name'), studict('age'))
# 採用面向對象的程序設計思想，我們首選思考的不是程序的執行流程，
# 而是Student這種數據類型應該被視爲一個對象，這個對象擁有name和age這兩個屬性（Property）。
# 如果要打印一個學生的信息，首先必須創建出這個學生對應的對象，
# 然後，調用對象的print_stuinfo方法，讓對象自己把自己的數據打印出來。
# 類語法
# class 類名(繼承的類的類名):
# 類體代碼
# 注意：類名命名規則：名詞，首字母大寫，如果由多個單詞組成，每個單詞首字母都要大寫
# 類包含成員變量和方法
class Student(object):
"Student information"
# 成員變量
name = 'stu'
age = 18
# __init__()方法是一種特殊的方法。我們稱之爲初始化方法，
# python在創建類的實例的時候，會調用這個類的__init__()方法
# 類中的方法，參數中一定要傳遞self,self指的是對象自己
# 我們根據圖紙來建造房子，房子造好了，每個人都要回自己的家，self相當於門牌號
def __init__(self, name, age):
self.name = name # 類中使用成員變量，用self.來訪問
self.age = age
# 打印學生信息
def print_stuinfo(self):
print '%s: %s' % (self.name, self.age)
# 創建類的實例，並傳遞參數，這裏傳遞的參數，由__init__()方法接收
student = Student('xiaoming', 20)
# 使用 實例.方法 來調用打印學生信息
student.print_stuinfo()
#xiaoming: 20
# 使用 實例.成員變量名 來訪問成員變量(屬性)
print student.name, student.age #xiaoming 20
# 用 類名.__doc__ 來查閱類的文檔說明
print Student.__doc__
# __name__：類名
print Student.__name__
# __module__：模塊名，如果類位於導入的一個模塊中，返回模塊的名稱，
# 如果不是在導入模塊中，返回__main__
print Student.__module__
# 類的所有父類組成的元組
print Student.__bases__
# 類的屬性構成的字典
print Student.__dict__
# 對象銷燬
del student
# print student面向對象的三個特點：封裝，繼承，多態
封裝：對數據的封裝–》列表，元組，字典
對腳本語句的封裝–》函數
對數據，方法的封裝–》類
繼承：子類繼承父類的屬性和方法
多態：不同對象對同一方法響應不同的情況
list1 = [3, 2, 6, 7, 8]
list1.append(9)
print list1
list1.sort()
print list1
# 定義一個子類，繼承list，類體中，什麼都不做
class SubList(list):
pass
print '*' * 30
subList = SubList()
subList.append(9)
subList.append(5)
subList.append(8)
subList.append(4)
print subList
subList.sort()
print subList
# 多態
# 如果子類中有屬性或者方法與父類屬性、方法名字一致，
# 會覆蓋父類的屬性和方法
class A(object):
name = 'A'
def fun(self):
print 'A'
class B(A):
pass
# # 子類屬性覆蓋父類方法
# name = 'B'
#
# # 子類方法覆蓋父類方法
# def fun(self):
# print 'B'
# a = A()
# a.fun()
#
# b = B()
# b.fun()
類的私有屬性與方法
默認情況下，python中屬性都是公開的，可以直接訪問
私有屬性：__private_attr，以雙下劃線開頭
class JustCounter(object):
__secretCount = 0 # 私有變量
publicCount = 0 # 公開變量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print self.__secretCount
def get_secret_count(self):
return self.__secretCount
def set_secret_count(self, num):
self.__secretCount = num
return self.__secretCount
def __print_info(self):
print '私有方法'
#創建了對象
counter = JustCounter()
#調用.count()函數，打印私有變量
counter.count()
counter.count()
#打印公開變量
print counter.publicCount
print '----------------------'
# print counter.__secretCount # 報錯，實例不能直接訪問私有變量
# counter.__print_info() #報錯，實例不能直接訪問私有方法
# python使用的是名字重整的技術，改變了私有變量的值：_類名__變量名
# 如果我們一定要訪問私有變量的話
print counter._JustCounter__secretCount # 雖然可以，但是我們並不推薦使用這種方法
print counter.get_secret_count()
# 先用set方法賦值，再用get取值
counter.set_secret_count(5)
print counter.get_secret_count()class Test(object):
# 對象方法
def object_test(self):
print 'object method'
# 類方法
@classmethod
def class_test(cls):
print 'class method'
# 要在類中使用靜態方法，需在類成員函數前面加上 @ staticmethod標記符，
# 以表示下面的成員函數是靜態函數。
# 使用靜態方法的好處是，不需要定義實例即可使用這個方法。
# 另外，多個實例共享此靜態方法。
@staticmethod
def static_test():
print 'static method'
# 調用實例方法
test1 = Test()
test1.object_test() #object method
Test.object_test(test1) #object method
# 調用類方法
test1.class_test()#class method
Test.class_test() #class method
# 調用靜態方法
test1.static_test() #static method
Test.static_test() #static method
# 繼承父類Test，繼承父類的屬性和方法
class SubTest(Test):
# 對父類方法的覆蓋
@classmethod
def class_test(cls):
print cls
print 'subclass method'
# 調用子類的類方法
SubTest.class_test()
#<class 'class_test.just_ounter.SubTest'>
#subclass method
# 調用父類中的其他方法
subTest = SubTest()
subTest.object_test()
SubTest.object_test(subTest)
SubTest.static_test()
# 類的繼承
class A(object):
pass
class B(object):
pass
class C(A):
pass
class D(B, C):
pass
print A.__bases__
print B.__bases__
print C.__bases__
print D.__bases__#-*-coding:utf-8-*-
class Rabbit(object):
"This is a rabiit"
# 屬性
color = 'white'
legs = 4
longEars = 2
name = 'Mr Big'
# 方法
def setName(self,name):
self.name = name
def run(self):
print '跑的嗖嗖快~~'
def eat_carrot(self):
print '恩，我最喜歡胡蘿蔔！！！'
def bite(self):
print '憋惹我，會咬人……'
def playing_cute(self):
print '我叫 %s , 可撒嬌，會賣萌n(*≧▽≦*)n'%self.name
ra = Rabbit()
Rabbit()
# 調用其中的方法
ra.run()
ra.eat_carrot()
ra.bite()
ra.playing_cute()
# 類是對象的模板，像是玩具的模具，對象是根據模具所生產出來的玩具
ra1 = Rabbit()
# ra1.setName('white rabbit')
# ra1.playing_cute()
# ra1.name = 'rabbit1'
# ra1.playing_cute()
ra1.setName('rabbit2')
ra1.playing_cute()
# ra2 = Rabbit()
# ra2.setName('black rabbit')
# ra2.playing_cute()
