Python之面封装以及内置方法

面向对象

面向对象的三大特点

封装：将类中的方法封装起来。这样修改方法中的代码而不会影响外界代码的使用；外面的对象对方法的调用只有这样的一个接口，使用者的代码不会被修改。
继承：在同一个类中，我们可以定义对个方法（函数），如果后面的函数需要调用父类的方法，这种被称为继承；
多态：不同的子类对象调用相同的方法 产生不同的结果。
编程语言分为2种，面向对象和面向过程。

面向对象：--------->侧重谁来做。

相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

面向过程：-------->侧重怎么做？

1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大。

面向对象有两个核心的概念：
类：是一类具有相同特征或行为的事物的一个统称
比如猫类，狗类可以统称为动物
对象：由类创建出来的一个具体的存在
类和对象的关系：先有类再有对象
类是模板 对象是根据这个模板创建出来的
类只需要有一个 对象可以有多个

类：属性(这一类事务的共同信息) 和 方法(你能完成的动作)
1.类名：这类事物的名字(大驼峰命名法)
大驼峰命名法：
1.每个单词的首字母大写
2.单词与单词之间没有下划线
2.属性:这个类创建出来的对象有什么特征
3.方法:这个类创建出来的对象有什么行为

类名的确定
名词提炼法分析整个业务流程，出现的名词，通常就是找到的类。
属性和方法的确定
对 对象的特征描述，通常可以定义成属性
对象具有的行为(动词)，通常可以定义为方法
提示：需求中没有涉及的属性或方法在设计类时，不需要考虑

定义一个初级的类

# _*_ coding: UTF-8 -*-
class Cat:  ##定义一个类
    def eat(self):
        print('%s 爱吃鱼' %(self.name))
    def drink(self):
        print('猫要喝水')
hellokitty=Cat() #类的实例化（产生一个对象）
hellokitty.name = 'apple' #给对象起个名字
print(hellokitty)
hellokitty.eat()

self:
每一个对象都会带一个self参数，这个参数指代的是对象的内存地址空间，如果是多个对象的时候，则每一个函数调用的时候则指代那一个对象的内存地址空间。
调用方法的时候，程序员就不需要传递self参数(定义的时候，第一个参数必须是self)

初始化方法

初始化方法：类名（）就可以创建一个对象，类名创建的时候python解释器会执行哪些操作：
1.为对象在内存中分配空间—>创建对象
2.自动调用初始化方法为对象的属性设置初始值
这个初始化方法是内置方法，是专门用来定义一个类具有哪些属性。
下面的程序设置的是一个cat类。

# _*_ coding: UTF-8 -*-
class Cat:
    def __init__(self,name):
        self.name=name
    def eat(self):
        print('%s 爱吃鱼' %(self.name))
    def drink(self):
        print('%s要喝水' %(self.name))
tom = Cat('ttom') #实例化一个对象，起名为ttom
tom.eat()
tom.drink()

_str_内置方法

str:在python中，使用print输出对象变量的时候
默认情况下这个变量引用的对象是由哪一个类创建的对象及其在内存中的地址
如果在开发中 希望使用print输出变量的时候，能够打印自定义内容
就可以利用__str__这个内置的方法

class Cat:
    def __init__(self,name):
        self.name = name
    def __str__(self):
        # 返回必须是一个字符串
        return '我是 %s' %(self.name)
tom = Cat('ttom')
print(tom)
addr = id(tom)
print(addr)
# 十六进制
print('%x' %(addr))
# 十进制
print('%d' %(addr))

_del_内置方法

1、手动调用del删除

class Cat:
    def __init__(self,name):
        self.name = name
        print('%s 来了' %(self.name))
    def __del__(self):
        print('%s 走了' %(self.name))
tom  = Cat('tttom')
print(tom.name)
del tom
print('*' * 50)
print(tom.name)

2、程序自动调用del删除

class Cat:
    def __init__(self,name):
        self.name = name
        print('%s 来了' %(self.name))
    def __del__(self):
        print('%s 走了' %(self.name))
tom  = Cat('tttom')
print(tom.name)
print('*' * 50)
print(tom.name)

封装

1.封装是面向对象编程的一大特点
2.面向对象编程的第一步，将属性和方法封装到一个抽象（因为类不能直接使用）的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

需求：
1.小明体重75.0公斤
2.小明每次跑步都会减肥0.5公斤
3.小明每次吃东西体重都会增加1公斤

class Person:
    def __init__(self,name,weight):
        self.name=name
        self.weight=weight
    def __str__(self):
        return '我的名字叫%s,我的体重%skg' %(self.name,self.weight)
    def run(self):
        self.weight-=0.5
        print('%s去跑完步后，体重为%s' %(self.name,self.weight))
    def eat(self):
        self.weight+=1
        print('%s吃完东西后，体重为%s' %(self.name,self.weight))
a=Person('小明',55)
print(a)
a.eat()
a.run()

实现一个关于家居及房子大小方面的类

需求：
“”"

1.房子有户型,总面积和家具名称列表
新房子是没有家具的
2.家具有名字和占地面积，其中
eg:占地 6平方米
3.将以上三件家具添加到房子中
4.打印房子的时候，要求输出：户型 总面积 剩余面积 家具名称列表
“”"

class Furniture:
    def __init__(self,name,area):
        self.name=name
        self.area=area
    def __str__(self):
        return '%s占地%s平方米' %(self.name,self.area)
class House:
    def __init__(self,style,area):
        self.style=style
        self.area=area
        self.free_area=area #剩余面积
        self.Fur_item=[]
    def __str__(self):
        return '该户型是%s，面积共%s平方，家具有：%s,剩余%.2f平方' \
               %(self.style,self.area,self.Fur_item,self.free_area)
    def add_Fur(self,item):
        if item.area>self.free_area:
            print('%s的面积太大，无法添加' %(item.name))
            return
        self.Fur_item.append(item.name)
        self.free_area-=item.area
#创建家具
bed=Furniture('床',3.6)
table=Furniture('桌子',2)
bench=Furniture('板凳',0.8)
#打印家具的属性
print(bed)
print(table)
print(bench)
###########
#创建房子
hh=House('三室一厅',127)
print(hh)# 打印房子属性
#将家具添加到房子里
hh.add_Fur(bed)  #一个类创建出来的对象可以调用另一个对象
hh.add_Fur(table)
hh.add_Fur(bench)
#打印房子属性
print(hh)

“”"
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
“”"

class Gun:
    def __init__(self,name):
        self.name=name
        self.bul_count=0
    def add_bullet(self,count):
        self.bul_count+=count
    def shoot(self):
        if self.bul_count<=0:
            print('%s没有子弹了' %(self.name))
        self.bul_count-=1
        print('%s有%s发子弹' %(self.name,self.bul_count))
class Soldier:
    def __init__(self,name):
        self.name=name
        self.gun=None
    def kaihuo(self):
        if self.gun==None:
            print('%s没有枪，不能开火' %(self.name))
        self.gun.add_bullet(50) #self.gun=ak47,想调用枪的加子弹的方法，必须是有子弹的类(Gun)产生的对象
        self.gun.shoot()
ak47=Gun('Ak47')#产生一把枪
ryan=Soldier('Ryan')#产生一个士兵
ryan.gun=ak47 #给士兵一把枪，
ryan.kaihuo() #原本50发，射了一发，还有49