linux 封装python,基于linux下python学习（封装）

一、面向对象

类的设计：在程序开发中，要设计一个类，通常需要满足以下三个要求：

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