Python教程6

# -*-coding:utf-8-*-
""""
面向对象：相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定不过职责---要做的事情（方法）
2.根据职责确定不同的对象，在对象内部封装不同的方法
特点：
注重对象和职责，不同的对象承担不同的职责
更加适合对复杂的需求变化，是专门对应复炸项目的开发，提供固定的套路
需要在面向对象的基础上，再学习一些面向对象的语法
两个核心概念：
类：是对一群具有相同特征或者行为的事务一个统称，是抽象的，不能直接使用（类包括属性和方法）
对象：是类创建的一个具体的存在
类是模板，对象根据模板创建出来的
类只有一个，而对象可以用很多个，不同的对象之间属性可能会各不相同
类中定义的属性和方法，对象中就有什么属性和方法，不能多，野不能少

再开发程序中，设计类需要满足三个要素：
类名，属性，方法
"""

""""
dir 内置函数（知道）
在python中对象是无所不在的，变量，数据，函数都是对象
验证方法：
1.在标识符/数据 后面输入一个.，然后按TAB键会显示对象能调用的方法列表
2.使用内置函数dir传入标识符/数据 ，可以查看对象内所有的属性和方法的一个列表
"""


def demo():
    """"这是个测试函数"""
    print("hello python")


demo()
print(dir(demo))  # dir()内置函数的使用
print(demo.__doc__)  # 内置函数__doc__的使用

# 定义简单的类（只包含方法）,创建对象
"""
class 类名：
    def 方法1（self,参数列表）
        pass
    def 方法2（self,参数列表）
        pass
创建对象：
对象变量 = 类名（）
"""


# 第一个面向对象的程序：小猫爱吃鱼，小猫要喝水
class Cat:
    def eat(self):  # 哪一个对象调用的方法，self就是哪一个对象的引用
        print("%s猫爱吃鱼" % self.name)

    def drink(self):
        print("小猫要喝水")


# 创建猫对象
tom = Cat()
tom.name = "Tom"  #如果这行增加的属性在猫的方法tom.eat()和tom.drink（）后，则会报错
tom.eat()
tom.drink()
# 对象同样使用引用
print(tom)
addr = id(tom)
print("%d" % addr)  # %d 十进制打印输出
print("%x" % addr)  # %x 十六进制打印输出

# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)  # 两只猫tom和lazy_cat的内存地址不一样，
lazy_cat2 = lazy_cat  # 这两只猫内存一样

# 给某个对象增加属性，不推荐使用

# -*-coding:utf-8-*-
""""
初始化方法：
当使用类名（）创建对象时，会执行以下操作：
1.为对象在内存中分配空间--创建对象
2.为对象的属性设置初始值--初始化方法（__init__）
"""


class Cat:
    def __init__(self):
        print("这是初始化方法")


tom = Cat()  # 使用类名（）创建对象时，会自动调用初始化方法
"""__init__(self)方法时专门用来定义一个类具有那些属性方法！"""


# 在初始方法内部定义属性
class Cat1:
    def __init__(self):
        print("这是Cat1类初始化方法")
        self.name = "Tom"


tom = Cat1()
print(tom.name)


# 使用参数设置属性的初始值
class Cat2():
    def __init__(self, new_name):
        self.name = new_name

    def eat(self):
        print("%s 爱吃鱼" % self.name)


ton = Cat2("黄小鱼")
print(ton.name)
ton.eat()

# __del__方法，如果希望对象在被销毁前，在做些事情
print("__del__对象销毁方法")


class Cat3():
    def __init__(self, new_name):
        self.name = new_name
        print("这是初始化方法，%s 我来了" % self.name)

    def __del__(self):
        print("这是对象销毁方法，%s 我去了" % self.name)


ton1 = Cat3("TON")
print("-" * 50)  # 注意销毁方法，是在程序结束时，即此行后打印。
del ton1  # del ton1可以提前销毁对象
print("*" * 50)

# __str__方法，使用print输出对象变量，默认情况下，会输出这个变量的引用对象，
# 是由哪一个类创建的对象，以及在内存中的地址（十六进制表示），__str__这个内置的方
# 法可以自定义内容，注意：__str__这个方法必须返回一个字符串
print("__str__方法")  # 常用来打印变量


class Cat4():
    def __init__(self, new_name):
        self.name = new_name
        print("这是初始化方法，%s 我来了" % self.name)

    def __del__(self):
        print("这是对象销毁方法，%s 我去了" % self.name)

    def __str__(self):
        print("这是__str__方法")
        return "我是小猫%s" % self.name


tomm = Cat4("tomm")
print(tomm)

# -*-coding:utf-8-*-
""""
封装：
1.封装是面向对象的一个特点
2.面向对象的第一步，将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部
"""
"""封装实例，小明爱跑步，需求：小明体重75.0公斤，每次跑步减肥0.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)
        pass

    def run(self):
        print("%s 爱跑步，锻炼身体" % self.name)
        self.weight -= 0.5

    def eat(self):
        print("%s 爱吃东西，是个美食家" % self.name)
        self.weight += 1.0


xm = Person("小明", 75.0)
xm.run()
xm.eat()
print(xm)
""""在对象方法内部，是可以直接访问对象的属性的，同一个类中，多个对象之间属性不干扰"""
# 小美对象
xiaomei = Person("小美", 45)
xiaomei.eat()
xiaomei.run()
print(xiaomei)
print(xm)  # 小明的体重不会增加

#-*-coding:utf-8-*-
# 案列2，摆放家具
""""
1.房子有户型，总面积和家具名称列表
新房子没有任何家具
2.家具有名字和占地面加，其中：
席梦思占地4平米
衣柜占地2平米
餐桌占地1.5平米
3.将以上三件餐具添加到房子中
4.打印房子时，需要输出：户型，总面积，剩余面积，家具名称列表
"""


class HouseItem:
    def __init__(self, name, area):
        self.name = name
        self.area = area

    def __str__(self):
        return "[%s] 占地%.2f " % (self.name, self.area)


class House:
    def __init__(self, house_type, area):
        self.house_type = house_type
        self.area = area
        # 剩余面积
        self.free_area = area
        # 家具列表
        self.item_list = []

    def __str__(self):
        return ("【户型】: %s \n【总面积】：%.2f[剩余面积:%.2f] \n【家具】："                 "%s" % (self.house_type, self.area, self.free_area,
                        self.item_list))

    def add_item(self, item):
        print("要添加%s" % item)
        #1.判断家具的面积
        if item.area > self.free_area:
            print("！！！%s 面积太大，无法添加！！！" % item.name)
            return
        #2.将家具的名称添加到列表
        self.item_list.append(item.name)
        #3.计数剩余面积
        self.free_area -= item.area

# 创建家具
bed = HouseItem("席梦思", 40)
chest = HouseItem("衣柜", 2)
table = HouseItem("餐桌", 20)
print(bed)
print(chest)
print(table)
# 创建房子对象
my_home = House("两室一厅", 60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

# -*-coding:utf-8-*-
""""
一个对象的属性可以时另外一个类创建的对象
实例，士兵突击：
1.士兵许三多有一把AK47
2.士兵可以开火
3.枪能发射子弹
4.抢能装填子弹--增加子弹的数量
"""
print("！！！！士兵突击开始！！！！")


class Gun:
    def __init__(self, model):
        self.model = model
        # 抢子弹初始值为0
        self.bullet_count = 0

    def add_bullet(self, count):
        self.bullet_count += count
        print("增加子弹数[%d]" % count)

    def shoot(self):
        # 判断子弹数量
        if self.bullet_count <= 0:
            print("！！！没有子弹，赶紧补充")
            return
        # 发射子弹
        self.bullet_count -= 3
        # 提示发射信息
        print("[%s] 突 突 突 . . .！剩余子弹[%d]" % (self.model, self.bullet_count))


# 士兵类
class Soldier:
    def __init__(self, name):
        self.name = name
        # 不知道初始值可以设置为None
        self.gun = None

    def fire(self):
        # 判断是否有枪
        """身份运算符，比较两个对象内存地址是否一致。==是变量值比较
        is /is not: x is y或者x is not y
        if self.gun is None:(建议使用)
        """
        if self.gun == None:
            print("[%s]还没有枪！" % self.name)
            return
        # 高喊口号
        print("冲啊。。。。。[%s]" % self.name)
        # 装填子弹
        self.gun.add_bullet(50)
        # 发射子弹
        self.gun.shoot()


ak47 = Gun("AK47")
xsd = Soldier("许三多")  # 定义许三多对象
xsd.gun = ak47
xsd.fire()
print(xsd.gun)

# -*-coding:utf-8-*-
"""
在实际开发中，对象的某些属性或方法，可能只希望在对象的内部使用，而不
希望在外部被访问到：
1.私有属性就是对象不希望公开的属性
2.私有方法就是对象不希望公开的方法
3.在定义私有属性或方法时，在属性名或者方法名前，增加两个下划线，定义的就是
  私有属性或者私有方法
"""


class Women:
    def __init__(self, name):
        self.name = name
        self.__age = 18

    def secret(self):
        print("%s的年龄时 %d" % (self.name, self.__age))


xiaofang = Women("小芳")
#  print(xiaofang.__age)  # 报错，私有属性在外界不能访问
print(xiaofang._Women__age)  # 科普，python中没有完全的私有的属性，用这种方式同样可以访问
xiaofang.secret()  # 同样，私有方法类似