オブジェクト指向のpythonの三つの特徴は-----カプセル化、継承、ポリモーフィズム

1、パッケージ

パッケージングは、抽象クラスのプロパティとメソッドは、カプセル化、オブジェクト指向プログラミングの主要な特徴である
データが内部に格納され、プログラムの他の部分にのみ許可操作（方法部材）を介してデータを操作します。オブジェクトを作成するために、外部のクラスを使用して、オブジェクトのメソッド呼び出しを聞かせて
私たちが直接しかし、この方法の内部実装の詳細を知らなくても、内部データオブジェクトを操作し、インスタンスメソッドを呼び出すことによって。オブジェクトの方法の詳細は、クラス内部に封入されています

------------------- ------------------練習

デマンド
1.暁明は75.0キロ体重
各実行は0.5キロ失うことになる。2.暁明が
それぞれ増加します体重の1キロを食べる3.ボブ

デマンド
1.暁明と実行中の小さな美容愛
2.メル体重45.0キロを
各ランナーは0.5キロ失うことになる。2.
3.それぞれが体重の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
xiaoming = Person('小名',75.0)
xiaoming.run()
xiaoming.eat()
print(xiaoming)
xiaomei = Person('小美',45.0)
xiaomei.eat()
print(xiaomei)

------------------- ------------------練習

生徒の成績に基づいて、グレードの達成をゲット

class Student:
    def __init__(self,name,score):
        #初始化方法，当使用类创建实例的时候都会调该方法
        self.name = name
        self.score = score
    def get_grade(self):
        #对数据封装
        if self.score > 90:
            print('A')
        elif self.score >80:
            print('B')
        else:
            print('C')

toto = Student('toto',95)  # 创建对象
toto.get_grade()  # 直接使用对象调用方法，得到结果

#输出结果：
A

別のオブジェクトクラスへのオブジェクトのプロパティを作成することができます

------------------- ------------------練習

要件：
1.マンションは、家具の総面積と名前のリストがある
新しい家は家具なしで
家具が名前とエリアがある2。
5：ベッド
テーブル：4つの
椅子：6
3. 3以上を収容するために家具を追加しますで
、残りのエリアのアパートの家具名リストの総面積：4.印刷の家、必要な出力

class Furniture:   # 限定义家具类
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return 'this is %s, %d square '

#使用类创建好对象之后，该对象可以作为参数用于其他函数调用。

class House:  #在定义房子类
    def __init__(self,type,squa):
        self.fu_list = []
        self.type = type
        self.leftsqua = self.allsqua = squa
    def __str__(self):
        return ' 户型是: %s\n 总面积是: %.2f\n 剩余面积: %.2f\n 家具列表:%s' \
               %(self.type,self.allsqua,self.leftsqua,self.fu_list)
    def add_furn(self,item):  # 在房子类的方法中使用的参数是家具类的一个实例
        if item.area<self.allsqua:
            self.fu_list.append(item.name)
            self.leftsqua -=item.area
        else:
            return
bed = Furniture('bed',5)
desk = Furniture('desk',4)
chair = Furniture('cabinet',6)   # 先实例化 家具

house1 = House('三室',120)  # 在实例化房子
house1.add_furn(bed)   # 再使用房子对象的方法，传入的参赛是家具实例
house1.add_furn(desk)
house1.add_furn(chair)
print(house1)

#输出结果：
 户型是: 三室
 总面积是: 120.00
 剩余面积: 105.00
 家具列表:['bed', 'desk', 'cabinet']

------------------- ------------------練習

1.ライアンAK47兵士があります
。2.兵士が発砲することができます（トリガーを発射兵士が引かれる）
弾丸を発射できる銃3.（弾丸が出て解雇）
4.銃の弾丸をロードすることができます-弾丸の数を増やすには、

class Gun:   # 定义枪类
    def __init__(self,name):
        self.name = name
        self.count = 3   # 属性：枪名称以及子弹数量
    def add_bullet(self):  # 方法：添加子弹，将子弹数充值3
        self.count = 3
    def launch_bullet(self):   # 发射子弹
        if self.count <= 0:
            self.add_bullet()   #如果没有子弹，先进行添加子弹
        self.count -= 1   # 然后子弹减少一个
        print('%s 已经成功发射子弹 剩余子弹%d' %(self.name,self.count))

class Solair:   # 定义士兵类
    def __init__(self,name):
        self.name = name   # 设置属性 ：name
    def shoot(self,gun):  # 定义方法：直接调用枪对象的方法
        gun.launch_bullet()


AK47 = Gun('AK47')   # 实例化一个枪对象
ryan = Solair('Ryan')   #实例化一个士兵对象
ryan.shoot(AK47)  # 士兵对象调用开火方法
ryan.shoot(AK47)
ryan.shoot(AK47)
ryan.shoot(AK47)

#结果：
AK47 已经成功发射子弹 剩余子弹2
AK47 已经成功发射子弹 剩余子弹1
AK47 已经成功发射子弹 剩余子弹0
AK47 已经成功发射子弹 剩余子弹2

2、継承

私たちは、クラスを定義するとき、彼らは既存のクラスを継承することができOOPのプログラミングでは、新しいクラスをサブクラス（サブクラス）と呼ばれ、継承されたクラスは、基本クラス、親クラスまたはスーパークラスと呼ばれています（基本クラス、スーパークラス）

最大の利点は、あなたが書くために同じコードを繰り返す必要はありません、サブクラスはコードの再利用を実現するために、親クラスのすべての機能を取得することです。

class Animal():  #定义动物类
    def run(self):
        print('running~~')
    def call(self):
        print('hahahah')   # 动物类中存在两个方法

class Cat(Animal):   # 定义猫类，继承动物类
    pass  
tom = Cat()  # 常见一个猫类实例
tom.run()  # 该实例可以直接调用动物类的方法

#输出结果：
running~~

いくつかの方法は、サブクラスで独自の特定の機能を追加することができます

class Animal():
    def run(self):
        print('running~~')
    def call(self):
        print('hahahah')
class Cat(Animal):
    def eat(self):
        print('爱吃鱼')
tom = Cat()
tom.run()  # 调用父类的方法
tom.eat()  # 使用自己类的方法

#输出结果：
running~~
爱吃鱼

コードが実行されている時に仮想サブクラスの完全な要件を達成することができない親クラスのメソッドは、メソッド、私たちが言う、サブクラスは親クラスのメソッドをカバーし、書き換えることができる場合は、常にメソッドのサブクラスを呼び出します。

class Animal():
    def run(self):
        print('running~~')   #父类中存在run方法
    def call(self):
        print('hahahah')
class Cat(Animal):
    def run(self):
        print('跑得快')    # 子类中也存在run方法
    def eat(self):
        print('爱吃鱼')
tom = Cat()
tom.run()   # 当实例调用run方法的时候，总是调用的子类中的程序

#运行结果：
跑得快

これは、親クラスのメソッドを拡張することができます。そのもとに新しいコンテンツを追加し、親クラスのメソッドの内容を保存します。）それを必要とするサブサブクラスとスーパークラスで定義され、メソッドのスーパー（に書き込みます。コール（）（2によって達成親クラスのメソッド（自己）python2.x）としてのみ同様、必要な拡張を追加内容は、することができます。

class Animal():
    def run(self):
        print('running~~')
    def call(self):
        print('hahahah')
class Cat(Animal):
    def run(self):
        super().run()    # 继承父类给方法的内容，同时添加扩展的内容
        print('跑得快')
    def eat(self):
        print('爱吃鱼')
tom = Cat()
tom.run()

#输出结果：
running~~
跑得快

サブクラスで初期化メソッドを使用して、親クラスでも）（必要にスーパーサブクラスの初期化メソッドを使用する際の初期化メソッドを使用します。ときのinit（）、親クラスの初期化メソッドの拡張を継承すべきでない表現、競合エラーが発生します。

class Animal():
    def __init__(self,name):
        self.name = name
    def run(self):
        print('running~~')
    def call(self):
        print('hahahah')
class Cat(Animal):
    def __init__(self,color,name):
        super().__init__(name)   #在子类中必须使用该语句，表示继承父类中的属性。
        self.color = color
    def run(self):
        super().run()
        print('跑得快')
    def eat(self):
        print('爱吃鱼')
tom = Cat('tom','red')
print(tom.name)
print(tom.color)

#输出结果：
red
tom

サブサブクラスの複数の親クラスを継承し、同じ親クラスのメソッドの複数、このメソッドを呼び出すと、親クラスエディトリアルが継承されること、時間がかかり、このサブクラスのインスタンスが存在する場合これは、親クラスを使用する方法。推奨されるメソッドの定義は、同じ名前を使用しないようにしよう

class A:   #定义A 类
    def lala(self):
        print('lala')
    def toto(self):
        print('toto')  # 其中由来两个方法
class B:  # 定义B类
    def lala(self):
        print('LALA')
    def toto(self):
        print('TOTO')   # 其中由两个方法，并且方法名称和A中方法名称一致
class C(A,B):   #定义类C 继承A，B 两个类
    pass
class D(B,A):   # 定义类D 继承B，A 两个类
    pass

c = C()
d = D()

c.lala()  
d.lala()

c.toto()
d.toto()    # 当继承父类的顺序不同的时候，导致调用的方法是不同的内容，默认调用位置靠前的父类方法

#输出结果：
lala
LALA
toto
TOTO

3、多型

異なる結果は、カプセル化、継承の前提であり、パラメータ、ない場合の出力オブジェクトが異なる場合、変更するパラメータの関数を必要とする機能があり、

クラスのインスタンスは、異なる状況では異なる形態を有することができるように、それは同様のことをいいます。多型の異なる内部構造を有するオブジェクトが同じ外部インターフェイスを共有できるようにします。これは、異なるオブジェクトごとに異なる特定のアクションが意味するが、一般的なクラスを介して、彼ら（これらの操作は）同じように呼び出すことができます。

異なるサブクラスオブジェクトは、実行の異なる結果を生成し、同じメソッドを呼び出し

まず、データ型、その後いくつかのノート。私たちは、クラスを定義するとき、私たちは、実際にデータ型を定義します。私たちは、データ型を定義し、全く別のクラスの動物（オブジェクト）のdictない、などSTR、リストとしてPythonのデータ型、付属しています：

    def run(self):
        print('Animal is running...')

class Dog(Animal):
    pass

class Cat(Animal):
    pass

a = list()
b = Animal()
c = Dog()
d = Cat()

print(isinstance(a,list))
print(isinstance(b,Animal))
print(isinstance(c,Dog))
print(isinstance(d,Cat))

#输出结果：
True
True
True
True

オブジェクトのクラスのうちの子供がインスタンス化されている間だけでなく、それが親クラスのタイプも、タイプのサブクラスです。階層では、データ・タイプは、それがまた、親として見ることができるデータのタイプのサブクラスのインスタンスがある場合。動物犬の例では、親クラスは、犬がインスタンスをインスタンス用いて、そのインスタンスは、両方の犬の種類、動物の種類です。

class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):
    pass

b = Animal()
c = Dog()

print(isinstance(b,Animal))
print(isinstance(c,Dog))
print(isinstance(c,Animal))

#输出结果：
True
True
True

犬、猫Animalクラスから継承し、方法を実行し、動物、犬、猫：まず、3つのカテゴリがあります。

 class Animal(object):
    def run(self):
        print('Animal is running...')
class Dog(Animal):
    def run(self):
        print('Dog is running')
class Cat(Animal):
    def run(self):
        print('Cat is running')

多型のメリットを理解し、我々はまだ型動物の変数を受け入れる関数を記述する必要があります。

   def run_twice(animal):
        animal.run()
        animal.run()
当我们传入Animal类的实例时，run_twice()就打印出：
def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Animal())

#输出结果：
Animal is running...
Animal is running...

実施例および猫犬動物のクラスの例は、データ・タイプとすることができるので、それはまた、クラスインスタンスと猫犬着信クラス、関数の出力として、引数として機能することができます。

def run_twice(animal):
    animal.run()
    animal.run()

run_twice(Dog())
run_twice(Cat())

#输出结果：
Dog is running
Dog is running

Cat is running
Cat is running

今サブクラス定義として親クラスの動物、例えば、引数として、関数は通常動作をrun_twiceことができます。

class Tortoise(Animal):
    def run(self):
        print('Tortoise is running slowly~~~')
run_twice(Tortoise())

#输出结果：
Tortoise is running slowly~~~
Tortoise is running slowly~~~

キー：

動物の新しいサブクラスは、すべての変更は、実際には、任意の依存性または動物のメソッドのパラメータの関数としては、修正なしで実行されているようにするrun_twice（）を持っていません

動物の機能は、我々は犬、猫、亀を渡す必要があるとき、型のパラメータを必要と......、私たちはそれだけでその動物の種類を受信する必要が、その後、犬、猫、亀......すべての動物の種類、およびので、動物に従い、タイプが動作することができます。正常動作するように機能します。

実行動物のタイプ（）メソッドので、したがって、限り動物のクラスまたはサブクラスなどの任意のタイプの着信、自動的に実行の実際の型（）コースの方法であって、各実行方法及び動作の実際のタイプのコンテンツを呼び出しますデータが同じではない、結果は同じに動作します、これは多型です。

変数のために、私たちは、正確にどのサブタイプを知らなくても、あなたが安全にrun（）メソッドを呼び出し、特定の呼び出し（）メソッドを実行することができ、それは動物の種類であることを知っておく必要がある動物、犬、猫や亀の役割でありますオブジェクトに、オブジェクトの正確な型は、ランタイムによって決定され、

呼び出し側はちょうどかかわらず、細部の、呼び出し、私たちは動物のサブクラスの1種類を追加するときに、ちょうど、正しく書くために元のコードが呼び出される方法を制御していないことを確認run（）メソッドを作ります。これが有名な「開閉」の原則であります：

拡張のためのオープン：新しい動物は、サブクラスが許可
アニマル無修正依存型run_twice（）関数など：変更のため閉鎖しました。