Python_oldboy_自動化運維之路_面向對象（十）

面向對象編程

OOP編程是利用「類」和「對象」來建立各類模型來實現對真實世界的描述，使用面向對象編程的緣由一方面是由於它可使程序的維護和擴展變得更簡單，而且能夠大大提升程序開發效率 ，另外，基於面向對象的程序可使它人更加容易理解你的代碼邏輯，從而使團隊開發變得更從容。

面向對象的幾個核心特性以下

Class 類
一個類便是對一類擁有相同屬性的對象的抽象、藍圖、原型。在類中定義了這些對象的都具有的屬性（variables(data)）、共同的方法

Object 對象
一個對象便是一個類的實例化後實例，一個類必須通過實例化後方可在程序中調用，一個類能夠實例化多個對象，每一個對象亦能夠有不一樣的屬性，就像人類是指全部人，每一個人是指具體的對象，人與人以前有共性，亦有不一樣

Encapsulation 封裝
在類中對數據的賦值、內部調用對外部用戶是透明的，這使類變成了一個膠囊或容器，裏面包含着類的數據和方法

Inheritance 繼承
一個類能夠派生出子類，在這個父類裏定義的屬性、方法自動被子類繼承

Polymorphism 多態
多態是面向對象的重要特性,簡單點說:「一個接口，多種實現」，指一個基類中派生出了不一樣的子類，且每一個子類在繼承了一樣的方法名的同時又對父類的方法作了不一樣的實現，這就是同一種事物表現出的多種形態。
編程其實就是一個將具體世界進行抽象化的過程，多態就是抽象化的一種體現，把一系列具體事物的共同點抽象出來, 再經過這個抽象的事物, 與不一樣的具體事物進行對話。
對不一樣類的對象發出相同的消息將會有不一樣的行爲。好比，你的老闆讓全部員工在九點鐘開始工做, 他只要在九點鐘的時候說：「開始工做」便可，而不須要對銷售人員說：「開始銷售工做」，對技術人員說：「開始技術工做」, 由於「員工」是一個抽象的事物, 只要是員工就能夠開始工做，他知道這一點就好了。至於每一個員工，固然會各司其職，作各自的工做。
多態容許將子類的對象看成父類的對象使用，某父類型的引用指向其子類型的對象,調用的方法是該子類型的方法。這裏引用和調用方法的代碼編譯前就已經決定了,而引用所指向的對象能夠在運行期間動態綁定

1.最簡單的類：

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/

class Dog(object):
    print("I am a dog!")

d=Dog()

2.基本類的使用方法，理解self的做用：就是爲了調用

#理解self的做用
#正常狀況下：self.name = name就是個局部變量，是不能夠被其餘函數調用
#可是個人需求就是個人狗可能有不少的功能（balk，eat），都要去調用name這個變量，那就要想出一個方法，在這整個狗（類）之間容許互相調用的一個方式
#這時self的功能就出現了

class Dog(object):

    def __init__(self,name,type):　　　　　　　　　　 #初始化函數（構造函數）
        self.name = name　　　　　　　　　　　　　　　　#d.name=name至關於下面用函數表示的
        self.type = type　　　　　　　　　　　　　　　　#d.type=type

    def balk(self):　　　　　　　　　　　　　　　　　　　#self=d 至關於將另一個函數當作參數傳給了這個balk的函數，因此就能夠被調用
        print("[%s]I am a dog!" %self.name )　　　

    def eat(self，food): print("[%s] eating [%s]!" %self.name,food)

d = Dog('wangcai','zangao') 　　　　　　　　　　　　　　#此時就把狗這個角色生成了，生成了可是沒有幹任何事，這就是一個實例（對象）
print(d.name,d.type) 　　　　　　　　　　　　　　　　　　 #可是能夠打印顯示出相關的屬性，name，type 
d.balk() 　　　　　　　　　　　　　　　　　　　　　　　　　 #狗能夠執行某個動做，執行函數

d.name = 'wamgcai_1'　　　　　　　　　　　　　　　　　　　#還能夠賦值
print(d.name)

#用函數模擬以上的場景,balk執行wangwang的動做，須要知道是誰叫的，要調用dog函數

def dog(name):
    data = {'name':name}
    return data

def balk(dog_obg):
    print('[%s] wang wang.....' %dog_obg['name'])

d = dog('wangcai')

balk(d)

3.類變量

# -*- coding: UTF-8 -*-
#blog:http://www.cnblogs.com/linux-chenyang/
#
#類變量
#1.做爲默認公有屬性
#2.全局修改或者增長新屬性
class Dog(object):
    age = 22　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#類變量：存在類的內存地址裏，能夠被全部實例共享引用。
    name = '全局'                                           #定義個全局變量，假如沒有self.name，那麼默認會打印全局
    def __init__(self,name,type):
#        self.name = name    　　　　　　　　　　　　　　　　　　　　
        self.type = type

    def balk(self):
        print("[%s]I am a dog!" %self.name,self.age )       #沒有寫self.age也能被調用

    def eat(self,food):
        print('[%s] eating [%s]' %(self.name,food))

d = Dog('wangcai','zangao')
d.balk()

【類變量的用法】能夠用於默認的屬性

class People(object):
    nationality = "CN"
    def __init__(self,name,age,job):
        pass

p=People('lijun',22,'IT')
p2=People('lijun_test',22,'IT')

print(p.nationality)                   #生成一個實例，假如不穿參數進去就是cn
p.nationality = 'JP'                   #能夠修改
print(p.nationality)

People.weapon = 'Big baojian'          #假設：你不知道有多少個實例，p，p1，p2....都須要給新加個功能，全局修改東西
print(p2.weapon)                       #全部的實例均可以調用了

4.實例變量（成員屬性）

    構造函數裏面變量都是實例變量
    每一個實例，存在本身內存空間裏的屬性

self.name = name
self.type = type

5.共有屬性就是類變量

6.私有屬性（不想被別人訪問到的屬性）

　　__sex 表明私有屬性，僅能在實例的內部各函數（方法）中調用
　　隱藏一些功能的實現細節，只給外部暴露調用接口

class People(object):
    nationality = 'CN'      #類變量，存在類的內存地址裏，能夠被全部實例共享引用
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.__sex = sex        #兩個下換線表明私有屬性，僅能在實例的內部各函數調用

    def go_to_toilet(self):
        if self.__sex == "boy":
            print('stand up....')
        else:
            print('跪着。。。。')

#若外面想非想調用sex變量，能夠封裝一下
    def get__sex(self):
        return self.__sex

p = People('wangcai','18','boy')

#print(p.sex)               #此時sex就沒法從外部調用了
p.go_to_toilet()            #此時函數內部可使用sex的變量
print(p.get__sex())         #能夠實現外面能夠

 

 面向對象的特性：

封裝（私有屬性）

 

封裝最好理解了。封裝是面向對象的特徵之一，是對象和類概念的主要特性。

 

封裝，也就是把客觀事物封裝成抽象的類，而且類能夠把本身的數據和方法只讓可信的類或者對象操做，對不可信的進行信息隱藏。