一、面向對象

類的設計：在程序開發中，要設計一個類，通常需要滿足以下三個要求：

1、類名? 這類事物的名字，滿足大駝峰命名法

2、屬性 這類事物具有什么樣的特征

3、 方法? 這類事物具有什么樣的行為

eg:小明今年18歲，身高1.75，每天早上要跑步，會去吃東西

類名：Person()? 屬性：name，age，height??? 方法：run() eat()

(1)

# 小貓愛吃魚，小貓要喝水

class? Cat():

def eat(self):

print '小貓愛吃魚'

def? drink(self):

print '小貓要喝水'

tom = Cat()???? # 創建貓對象

tom.eat()

tom.drink()

# 小狗愛睡覺，小狗愛吃肉

class? Dog():

def sleep(self):

print '小狗愛睡覺'

def eat(self):

print '小狗愛吃肉'

xiaoxiao = Dog()

xiaoxiao.sleep()

xiaoxiao.eat()

(2)

class? Dog():

def sleep(self):

print '小狗愛睡覺'

def eat(self):

print '小狗愛吃肉'

xiaoxiao = Dog()

xiaoxiao.name = 'xiaoxiao'

xiaoxiao.sleep()

xiaoxiao.eat()

print xiaoxiao

# addr = id(xiaoxiao)

# print '%x' %addr

# print '%d' %addr

#再創建一個狗對象

benben = Dog()

benben.name = 'benben'

benben.eat()

benben.sleep()

print? benben

(3)

初始化方法

我們已經知道了使用類名() 就可以創建一個對象

當使用類名()創建對象時，python的解釋器會自動執行以下操作：

1、為對象在內存中分配空間 --創建對象

2、調用初始化方法為對象的屬性設置初始值?? 初始化方法(__init__)這個初始化方法就是__init__方法，是對象的內置方法

專門是用來定義一個類具有那些屬性的方法

class? Dog():

def? __init__(self,new_name):

self.name = new_name

def sleep(self):

print '%s 愛睡覺'? % self.name

xiaoxiao = Dog('xiaoxiao')?? # 使用類名()創建對象的時候，會自動調用初始化方法__init__

print xiaoxiao.name

xiaoxiao.sleep()

benben = Dog('benben')

benben.sleep()

二、內置方法

(1)__del__

1、在python中

當使用類名()創建對象時，為對象分配萬空間后，自動調用__init__

當一個對象被從內存中銷毀前，會自動調用__del__方法

"""

class Dog():

def __init__(self,new_name):

self.name = new_name

print '%s 來了' %self.name

def __del__(self):

print '%s 走了' %self.name

xiaoxiao = Dog('xiaoxiao')

print xiaoxiao.name

print '_' * 50

2、

class Dog():

def __init__(self,new_name):

self.name = new_name

print '%s 來了' %self.name

def __del__(self):

print '%s 走了' %self.name

xiaoxiao = Dog('xiaoxiao')

print xiaoxiao.name

del xiaoxiao

print '_' * 50

(2)__str__

1、在python中，使用python輸出對象變量

默認情況下，會輸出這個變量引用的對象是由哪一個類創建的對象

以及在內存中的地址(十六進制表示)

如果在開發中，希望使用print輸出對象變量時

能夠打印自定義的內容，就可以利用__str__這個內置方法了

"""

class Dog():

def __init__(self,name):

self.name = name

tom = Dog('tom')

print tom

2、

class Dog():

def __init__(self,name):

self.name = name

def __str__(self): #必須返回一個字符串

return '我是%s' %self.name

tom = Dog('tom')

print tom

三、封裝

1、封裝是面向對象編程的一大特點

2、面向對象編程的第一步，將屬性和方法封裝到一個抽象的類中

3、外界使用類創建對象，然后讓對象調用方法

4、對象方法的細節都被封裝在類的內部

(1)

需求：

1、tom和xiaoxiao都愛吃東西愛跑步

2、tom體重75

3、xiaoxiao體重50

4、每次跑步都會減少0.5公斤

5、每次吃東西都會增加1公斤

"""

class person():

def __init__(self, name,weight):

self.name = name

self.weight =weight

def __str__(self):

return '我的名字叫%s,體重是%.2f' %(self.name,self.weight)

def? run(self):

print '%s 愛跑步' % self.name

self.weight -= 0.5??? # 在對象的方法內部，是可以直接訪問對象的屬性

def? eat(self):

print '%s 愛吃' % self.name

self.weight += 1.0

tom = person('tom',75.0)

tom.run()

tom.eat()

print tom

xiaoxiao = person('xiaoxiao',50.0)

xiaoxiao.run()

xiaoxiao.eat()

print xiaoxiao

(2)

需求：

1、房子有戶型，總面積和家具名稱列表

新房子沒有任何的家具

2、家具有名字和占地面積，其中

床：占4平方

衣柜：占2平方

餐桌：占1.5平方

3、將以上三件家具添加到房子中

4、打印房子時，要求輸出：戶型，總面積，剩余面積，家具名稱列表

"""

class? HouseItem():

def __init__(self, name,square):

self.name = name

self.square = square

def __str__(self): #必須返回一個字符串

return '%s的占地面積為%.2f' %(self.name,self.square)

chuang= HouseItem ('chuang',4)

print chuang

yigui = HouseItem('yigui',2)

print yigui

canzhuo =HouseItem('canzhuo',1.5)

class? House():

def __init__(self,huxing,square):

self.huxing = huxing

self.square = square

self.free_square = square?? # 剩余面積

self.item_list = []???????? # 家具名稱列表

def __str__(self):

return '戶型：%s\n總面積：%.2f\n剩余面積：%.2f\n家具列表：%s' % (self.huxing,self.square,self.free_square,self.item_list)

def? add_item(self,item):

print '要添加的家具%s' % item

if item.square > self.free_square:

print '%s面積太大無法添加' %item.square

return

self.item_list.append(item.name)

self.free_square -=item.square

my_home = House('兩室一廳',180)? # 創建房子

# 添加家具

my_home.add_item(chuang)

my_home.add_item(yigui)

my_home.add_item(canzhuo)

print my_home

(3)

1、士兵瑞恩有一把AK47

2、士兵可以開火

3、槍能夠發射子彈

4、槍能夠裝填子彈(增加子彈的數量)

class? Gun():

def __init__(self,model):

self.model = model? #? 槍的型號

self.bullet_count = 0?? #子彈的數量

def? add_bullet(self,count):

self.bullet_count += count

def shoot(self):

if self.bullet_count <= 0:? #? 判斷子彈的數量

print '沒有子彈了'

self.bullet_count -= 1?? #發射子彈

print '%s 突突突 %d' %(self.model,self.bullet_count)

class? Soldier():

def? __init__(self,name):

self.name = name

self.gun = None

def fire(self):

if self.gun == None:

print? '%s沒有槍' %self.name

return

print 'go!!!'

self.gun.add_bullet(50)

self.gun.shoot()

ak47 = Gun('ak47')

ak47.add_bullet(50)

ak47.shoot()

ryan = Soldier('Ryan')

ryan.gun = ak47

ryan.fire()

print? ryan.gun

總結

以上是生活随笔為你收集整理的linux 封装python,基于linux下python学习（封装）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。