Pythonのオブジェクト指向 - オブジェクト指向の実践

Pythonのオブジェクト指向 - オブジェクト指向の実践

オブジェクト指向パッケージケース（A）

01パッケージ

1.パッケージは、オブジェクト指向プログラミングの主要な特徴である
2のオブジェクト指向プログラミングの最初のステップ - 属性とパッケージ化方法抽象にクラスで
3 外部使用のクラスを作成するオブジェクトを、次いで方法呼び出すためにオブジェクトをせ
4.にオブジェクトメソッドを詳細はされているカプセル化して、クラスの内部

02暁明の愛のランニング

要求
1.暁明を体重 75.0キロ
各2暁明をランナーは体重0.5キロ失うことになる
各3ボブを食べる重い1キロを

class Person:
    def __init__(self,name,weight):
        # self.属性 = 形参
        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

xiaoming = Person("小明",75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

（1）小カリタスは、拡張を実行している - リトルアメリカの愛の実行を

需要
ランニング1.暁明と小さな美の愛を
2暁明を計量 75.0キロ
3.メルを計量 45.0キロを
4すべての実行が 0.5キロ減少します
。5.それぞれが食べる 1キロ増えます

ヒント
では1を、オブジェクトの内部の方法、次のことが可能に直接オブジェクトにアクセス属性の
2に同じクラスを作成するために、複数のオブジェクト間のプロパティをお互いを乱すことなく

class Person:
    def __init__(self,name,weight):
        # self.属性 = 形参
        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

xiaoming = Person("小明",75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

xiaomei = Person("小美",45.0)
xiaomei.eat()
xiaomei.run()
print(xiaomei)

03家具店

需要
1. ハウス（ハウス）持っ台、総面積と名前のリスト提出
　　あらゆる家具ずに、新しい家のを
2 家具（HouseItem）が持っている名前をし、エリアカバー
　　**シモンズ（ベッド）**4万平方メートルの面積
　　ワードローブを（胸）面積2平方メートル
　　テーブル（表）1.5平方メートルの面積
3.上記の3つの追加の家具する収容
4家を印刷、必要な出力：サイズ、総面積と残りの領域、家具名リストを

残りのエリア
1.家のオブジェクトを作成するとき、定義し、残りの領域の特性を、初期値と総面積に等しい
あなたが部屋にADD_ITEM道を呼び出す場合2. 家具を追加し、しましょう=家具エリア-残りの家具を

家具や調度品は、オブジェクトを作成します

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

# 1.创建家具
bed = HouseItem("席梦思",4)
chest = HouseItem("衣柜",2)
table = HouseItem("餐桌",1.5)

print(bed)
print(chest)
print(table)

クラス定義の家

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):
         # Python 能够自动的将一对括号内部的代码连接在一起
        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)

# 2.创建房子对象
my_home = House("两室一厅",60)

my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)

print(my_home)

概要

1.创建了一个房子类，使用到__init__和__str__两个内置方法
2.准备了一个add_item方法准备添加家具
3.使用房子类创建了一个房子对象
4.让房子对象调用了三次add_item方法，将三件家具以实参传递到add_item内部

添加家具

需求
1.判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
2.将家具的名称追加到家具名称列表中
3.用房子的剩余面积 - 家具面积

    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

面向对象封装案例（二）

目标

1.士兵突击案例
2.身份运算符

封装

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

一个对象的属性可以是另一个类创建的对象

01 士兵突击

需求
1.士兵 许三多有一把AK47
2.士兵可以开火
3.枪能够发射子弹
4.枪装填子弹——增加子弹数量

class Gun:
    def __init__(self,model):
        # 1.枪的型号
        self.model = model
        
        # 2.子弹的数量
        self.bullet_count = 0
        
    def add_bullet(self,count):
        self.bullet_count += count
        
    def shoot(self):
        # 1.判断子弹数量
        if self.bullet_count <= 0:
            print("[%s] 没有子弹了..." %self.model)
            return
        
        # 2.发射子弹，-1
        self.bullet_count -= 1
        
        # 3.提示发射信息
        print("[%s] 突突突... [%d]" %(self.model,self.bullet_count))

class Soldier:
    def __init__(self,name):
        # 1.姓名
        self.name = name
        # 2.枪-新兵没有枪
        self.gun = None
    def __str__(self):
        return "%s 有一把 %s" %(self.name,self.gun)
    def fire(self):
        # 1.判断士兵是否有枪
        if self.gun is None:
            print("[%s] 还没有枪..." %self.name)
            return

        # 2.高喊口号
        print("冲啊...[%s]" %self.name)

        # 3.让枪装填子弹
        self.gun.add_bullet(50)

        # 4.让枪发射子弹
        self.gun.shoot()

# 1.创建枪对象
ak47 = Gun("AK47")

# 2.创建许三多
xusanduo = Soldier("许三多")
xusanduo.gun = ak47
xusanduo.fire()

02 身份运算符

身份运算符用于比较两个对象的内存地址是否一致——是否是对同一个对象的引用
在 Python 中针对 None 比较时，建议使用 is 判断

运算符	描述	示例
is	is 是判断两个标识符是不是引用同一个对象	x is y，类似id(x) ==id(y)
is not	is not 是判断两个标识符是不是引用不同对象	x is not y，类似id(a) != id(b)

is 与 == 区别：

is 用于判断两个变量 引用对象是否为同一个
== 用于判断引用变量的值是否相等

私有属性和私有方法

01 应用场景及定义方式

应用场景

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)

# 私有方法，同样不允许在外界直接访问
# xiaofang.__secret()

02 伪私有属性和私有方法（科普）

ヒント：毎日の開発では、対象にアクセスするには、このアプローチ、私有財産またはプライベートメソッドを使用していない
何もありませんが、Pythonのを本当の意味のプライベート
1. プロパティは、メソッド、命名は、実際のある名前いくつかの特別な処理を行うには、その外の世界ということにアクセスすることはできません
2 治療法を：に名前クラス名が先行_ => _クラス名の名前を__

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._Women__age)
# 访问私有方法
xiaofang._Women__secret()