面向對象-練習題

# day 15
'''
1,完成下列功能:
  1.1創建一個人類Person,再類中創建3個靜態變量(靜態字段)
    animal = '高級動物'
    soul = '有靈魂'
    language = '語言'
  1.2在類中定義三個方法,吃飯,睡覺,工作.
  1.3在此類中的__init__方法中,給對象封裝5個屬性:國家,姓名,性別,年齡,  身高.
  1.4實例化四個人類對象:
    第一個人類對象p1屬性為:中國,alex,未知,42,175.
    第二個人類對象p2屬性為:美國,武大,男,35,160.
    第三個人類對象p3屬性為:你自己定義.
    第四個人類對象p4屬性為:p1的國籍,p2的名字,p3的性別,p2的年齡,p3  的身高.
  1.5 通過p1對象執行吃飯方法,方法里面打印:alex在吃飯.
  1.6 通過p2對象執行吃飯方法,方法里面打印:武大在吃飯.
  1.7 通過p3對象執行吃飯方法,方法里面打印:(p3對象自己的名字)在吃飯.
  1.8 通過p1對象找到Person的靜態變量 animal
  1.9 通過p2對象找到Person的靜態變量 soul
  2.0 通過p3對象找到Person的靜態變量 language
'''

# 1.1  創建一個人類Person,再類中創建3個靜態變量(靜態字段)

class Person:
    animal = '高級動物'
    soul = '有靈魂'
    language = '語言'

# 1.2 在類中定義三個方法，吃飯，睡覺，工作。

    def meal(self):
        print('%s在吃飯' % (self.name))
    def sleep(self):
        pass
    def work(self):
        pass
# 1.3在此類中的__init__方法中,給對象封裝5個屬性:國家,姓名,性別,年齡,  身高。
    def __init__(self,nation,name,sex,age,height):
        self.nation = nation
        self.name = name
        self.sex = sex
        self.age = age
        self.height = height
# 1.4 實例化4個人類對象
p1 = Person('中國','alex','未知',42,175)
p2 = Person('美國','武大','男',35,160)
p3 = Person('中國','馬玉剛','男',31,180)
p4 = Person('中國','武大','男',35,180)

# 1.5 通過p1對象執行吃飯方法,方法里面打印:alex在吃飯.
p1.meal()

#  1.6 通過p2對象執行吃飯方法,方法里面打印:武大在吃飯.
p2.meal()

# 1.7 通過p3對象執行吃飯方法,方法里面打印:(p3對象自己的名字)在吃飯.
p3.meal()

# 1.8 通過p1對象找到Person的靜態變量 animal
print(p1.animal)

# 1.9 通過p2對象找到Person的靜態變量 soul
print(p2.soul)

# 2.0 通過p3對象找到Person的靜態變量 language
print(p3.language)

'''
2,通過自己創建類,實例化對象
  在終端輸出如下信息
  小明，10歲，男，上山去砍柴
  小明，10歲，男，開車去東北
  小明，10歲，男，最愛大保健
  老李，90歲，男，上山去砍柴
  老李，90歲，男，開車去東北
  老李，90歲，男，最愛大保健
  老張…
'''
class Person:
    hobbly1 = '上山去砍柴'
    hobbly2 = '開車去東北'
    hobbly3 = '最愛大保健'
    def __init__(self,name,age,sex):  # 封裝對象的屬性。
        self.name = name
        self.age = age
        self.sex = sex
    def show(self):
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly1))
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly2))
        print('%s,%s,%s,%s' % (self.name, self.age, self.sex, self.hobbly3))

p1 = Person('小明', '10歲', '男')
p2 = Person('老李', '90歲', '男')
p1.show()
p2.show()

'''
3,模擬英雄聯盟寫一個游戲人物的類（升級題）.
  要求:
  (1)創建一個 Game_role的類.
  (2) 構造方法中給對象封裝name,ad(攻擊力),hp(血量).三個屬性.
  (3) 創建一個attack方法,此方法是實例化兩個對象,互相攻擊的功能:
      例: 實例化一個對象 蓋倫,ad為10, hp為100
      實例化另個一個對象 劍豪 ad為20, hp為80
      蓋倫通過attack方法攻擊劍豪,此方法要完成 '誰攻擊誰,誰掉了多少血,  還剩多少血'的提示功能.
'''

class Game_role:
    def __init__(self, name, ad, hp):
        self.name = name
        self.ad = ad
        self.hp = hp
    def attack(self,p1):
        p1.hp = p1.hp - self.ad
        print('%s攻擊了%s,%s還剩下%s' % (self.name, p1.name, p1.name, p1.hp))


Gailun = Game_role('蓋倫', 10, 100)
Jianhao = Game_role('劍豪', 20, 80)

Gailun.attack(Jianhao)
Jianhao.attack(Gailun)

'''
4,默寫內容:
  創建一個人類,定義三個靜態變量,在構造方法中封裝3個屬性.然后實例化一個對象,對象調用自己的屬性,對象調用類的靜態方法,
  對象調用類中的方法.
  默寫一下實例化一個對象，具體經歷了哪些階段。
'''

class Person:
    animal = '高級動物'
    soul = '有靈魂'
    language = '語言'

    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age

    def func1(self):
        print('調用類中的方法')
        pass


P1 = Person('馬玉剛', 'men', 31)
print(P1.name)
print(P1.animal)
P1.func1()

'''實例化一個對象具體經歷的階段
（1）實例化對象在內存中產生一個對象空間（內存地址）。
（2）自動執行 __init__方法並且將對象空間傳給了self參數。***
（3）在 __init__方法中，給對象空間封裝一些靜態屬性。
'''

#  Day 16

'''
1，暴力摩托程序（完成下列需求）：
1.1創建三個游戲人物，分別是：
•    蒼井井，女，18，攻擊力ad為20，血量200
•    東尼木木，男，20，攻擊力ad為30，血量150
•    波多多，女，19，攻擊力ad為50，血量80
1.2創建三個游戲武器，分別是：
•    平底鍋，ad為20
•    斧子，ad為50
•    雙節棍，ad為65

1.3 創建三個游戲摩托車，分別是：

•    小踏板，速度60邁
•    雅馬哈，速度80邁
•    寶馬，速度120邁。

完成下列需求（利用武器打人掉的血量為武器的ad + 人的ad）：
（1）蒼井井騎着小踏板開着60邁的車行駛在賽道上。
（2）東尼木木騎着寶馬開着120邁的車行駛在賽道上。
（3）波多多騎着雅馬哈開着80邁的車行駛在賽道上。
（4）蒼井井赤手空拳打了波多多20滴血，波多多還剩xx血。
（5）東尼木木赤手空拳打了波多多30滴血，波多多還剩xx血。
（6）波多多利用平底鍋打了蒼井井一平底鍋，蒼井井還剩xx血。
（7）波多多利用斧子打了東尼木木一斧子，東尼木木還剩xx血。
（8）蒼井井騎着寶馬打了騎着小踏板的東尼木木一雙節棍，東尼木木哭了，還剩xx血。（選做）
（9）波多多騎着小踏板打了騎着雅馬哈的東尼木木一斧子，東尼木木哭了，還剩xx血。（選做）
'''


class Game_Role:
    def __init__(self, name, sex, age, ad, hp):
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.hp = hp
        self.wea = Weapon()  # 將Weapon實例的對象作為Game_Role封裝的一個屬性。
        self.veh = Vehicle()  # 將Vehicle實例的對象作為Game_Role封裝的一個屬性。
    def use_wea(self, wea ):  # 定義使用的武器
        self.wea = wea
    def use_vehicle(self, vehicle,flag = 0 ):   # flag用來標識，如果為0則打印“行駛在賽道上”，否則不打印“行駛在賽道上”。
        self.veh = vehicle
        if flag ==0:
            if self.veh.moto_name == '無':
                pass
            else:
                print('%s騎着%s開着%s邁的車行駛在賽道上' % (self.name, vehicle.moto_name, vehicle.speed))
        else:
            pass
    def Strike(self, p1):
        p1.hp = p1.hp - self.getad()
        if self.wea.name == '赤手空拳'and self.veh.moto_name =='無':
            print("%s%s打了%s%s滴血，%s還剩%s血" % (self.name, self.wea.name, p1.name, self.getad(), p1.name, p1.hp))
        elif self.wea.name != '赤手空拳'and self.veh.moto_name =='無':
            print("%s利用%s打了%s一%s，%s還剩%s血" % (self.name, self.wea.name, p1.name,self.wea.name, p1.name, p1.hp))
        elif self.wea.name != '赤手空拳'and self.veh.moto_name !='無':
            print("%s騎着%s打了騎着%s的%s一%s，%s哭了，還剩%s血。" % (self.name, self.veh.moto_name, p1.veh.moto_name, p1.name, self.wea.name, p1.name, p1.hp))
    def getad(self):  # 動態的得到攻擊力
            if self.wea:
                ad = self.ad + self.wea.ad
            else:
                ad = self.ad
            return ad

class Weapon:
    def __init__(self, name='赤手空拳', ad=0):
        self.name = name
        self.ad = ad


class Vehicle:
    def __init__(self, moto_name='無', speed=0):
        self.moto_name = moto_name
        self.speed = speed

g1 = Game_Role('蒼井井', '女', 18, 20, 200)  # 蒼井井，女，18，攻擊力ad為20，血量200
g2 = Game_Role('東尼木木', '男', 20, 30, 150)  # 東尼木木，男，20，攻擊力ad為30，血量150
g3 = Game_Role('波多多', '女', 19, 50, 80)  # 波多多，女，19，攻擊力ad為50，血量80

w0 = Weapon('赤手空拳', 0)  # 赤手空拳，ad為0
w1 = Weapon('平底鍋', 20)  # 平底鍋，ad為20
w2 = Weapon('斧子', 50)  # 斧子，ad為50
w3 = Weapon('雙節棍', 65)  # 雙節棍，ad為65

v0 = Vehicle('無', 0)  #  無，速度0邁
v1 = Vehicle('小踏板', 60)  # 小踏板，速度60邁
v2 = Vehicle('雅馬哈', 80)  # 雅馬哈，速度80邁
v3 = Vehicle('寶馬', 120)  # 寶馬，速度120邁


# （1）蒼井井騎着小踏板開着60邁的車行駛在賽道上。
g1.use_vehicle(v1)
# （2）東尼木木騎着寶馬開着120邁的車行駛在賽道上。
g2.use_vehicle(v3)
# （3）波多多騎着雅馬哈開着80邁的車行駛在賽道上。
g3.use_vehicle(v2)
# （4）蒼井井赤手空拳打了波多多20滴血，波多多還剩xx血。
g1.use_wea(w0)
g1.use_vehicle(v0)
g1.Strike(g3)
# （5）東尼木木赤手空拳打了波多多30滴血，波多多還剩xx血。
g2.use_wea(w0)
g2.use_vehicle(v0)
g2.Strike(g3)
# （6）波多多利用平底鍋打了蒼井井一平底鍋，蒼井井還剩xx血。
g3.use_wea(w1)
g3.use_vehicle(v0)
g3.Strike(g1)
# # （7）波多多利用斧子打了東尼木木一斧子，東尼木木還剩xx血。
g3.use_wea(w2)
g3.use_vehicle(v0)
g3.Strike(g2)
# # （8）蒼井井騎着寶馬打了騎着小踏板的東尼木木一雙節棍，東尼木木哭了，還剩xx血。（選做）
g1.use_vehicle(v3, 1)
g1.use_wea(w3)
g2.use_vehicle(v1, 1)
g1.Strike(g2)
# # （9）波多多騎着小踏板打了騎着雅馬哈的東尼木木一斧子，東尼木木哭了，還剩xx血。（選做）
g3.use_vehicle(v1, 1)
g3.use_wea(w2)
g2.use_vehicle(v2, 1)
g3.Strike(g2)


# 2，定義一個類，計算圓的周長和面積。
import math


class circle:
    def Perimeter(self, r):  # 定義圓的周長函數,r為半徑。
        perimeter = 2 * math.pi * r
        print('半徑為%s的圓的周長為%s' % (r, perimeter))

    def Acreage(self, r):
        acreage = math.pi * (r ** 2)
        print('半徑為%s的圓的面積為%s' % (r, acreage))


circle1 = circle()
circle1.Perimeter(0.5)  # 半徑為0.5的圓的周長為3.141592653589793
circle1.Acreage(1)  # 半徑為1的圓的面積為3.141592653589793


# 3，定義一個圓環類，計算圓環的周長和面積（升級題）。
import math
class Ring:
    def Ring_perimeter(self,r1,r2): # 定義圓環的周長，r1，r2為內環外環的半徑。
        if r1 < r2:
            ring_perimeter = math.pi*2*(r2-r1)
            print('內徑為%s,外徑為%s的圓環的周長為%s' % (r1, r2, ring_perimeter))
        else:
            ring_perimeter =math.pi*2*(r1-r2)
            print('內徑為%s,外徑為%s的圓環的周長為%s' % (r2, r1, ring_perimeter))
    def Ring_Acreage(self,r1,r2):  # 定義圓環的面積，r1，r2為內環外環的半徑。
        if r1 < r2:
            ring_Acreage = math.pi*(r2**2-r1**2)
            print('內徑為%s,外徑為%s的圓環的面積為%s' % (r1, r2, ring_Acreage))
        else:
            ring_Acreage =math.pi*(r1**2-r2**2)
            print('內徑為%s,外徑為%s的圓環的面積為%s' % (r2, r1, ring_Acreage))
ring1 = Ring()
ring1.Ring_perimeter(2, 1)
ring1.Ring_Acreage(2, 1)

4，默寫內容:創建兩個類，讓一個類的對象的屬性為另一個類的對象。
class Game_Role:
    area = '召喚師峽谷'

    def __init__(self, name, sex, ad, hp):
        self.name = name
        self.sex = sex
        self.ad = ad  # 攻擊力
        self.hp = hp  # 血量

    def fight(self, role1):
        role1.hp = role1.hp - self.ad
        print('%s 攻擊 %s, %s還剩余%s' % (self.name, role1.name, role1.name, role1.hp))
        # print(self, role1)

    def equit_weapon(self, wea):  # 組合： 對象中的屬性是另一個類的對象，將Weapon類的對象sword作為Game_roles類的實例化對象P1的封裝的屬性。
        self.wea = wea


class Weapon:
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad

    def wea_attack(self, role1, role2):
        role2.hp = role2.hp - self.ad
        print('%s 利用 %s 攻擊 %s, %s還剩余%s' % (role1.name, self.name, role2.name, role2.name, role2.hp))
p1 = Game_Role('蓋倫', 'man', 30, 500)
p2 = Game_Role('狗頭', '公', 50, 250)
sword = Weapon('大寶劍', 40)
p1.equit_weapon(sword)  # 此方法就是給p1對象封裝一個屬性，屬性值是sword對象***
p1.wea.wea_attack(p1, p2)  # 通過p1.wea找到sword 然后在sword.wea_attack執行方法,其中self省略了。


#  day17

# 一、簡答題

# 1.面向對象的三大特性是什么？面向對象的三大特性是什么？
# 封裝、繼承、多態

# 2，什么是面向對象的新式類？什么是經典類？
# 新式類：繼承object的類。
# 經典類：不繼承object的類。
# 說明：python2x中經典類和新式類共存；python3x中全部都是新式類。

# 3，面向對象為什么要有繼承？繼承的好處是什么？
# 作用（1）節省代碼（2）提高效率 （3）讓類之間產生關聯

# 4，面向對象中super的作用。
# 調用父類（超類）中需要執行的動態方法。

# 二，代碼題(通過具體代碼完成下列要求)：
'''
1，
a,定義一個父類Animal，在構造方法中封裝三個屬性，姓名，性別，年齡，再給其添加一個eat的方法，方法中顯示%s正在吃飯（%s是哪個對象調用此方法，顯示哪個對象名字）。
b,定義兩個基類Person,Dog，全部繼承這個父類Animal.
c,Person類中，有構造方法，封裝一個皮膚的屬性，有eat方法，方法中顯示人類正在吃飯。
d,Dog類中，有構造方法，封裝一個毛色的屬性，有eat方法，方法中顯示狗狗正在吃飯。
上面這幾個類創建完成之后，完成下列要求：
①： 實例化一個人類的對象，讓其只封裝皮膚屬性。
②： 實例化一個人類的對象，讓其封裝姓名，性別，年齡，皮膚四個屬性。
③： 實例化一個狗類的對象，讓其只封裝毛色屬性。
④： 實例化一個狗類的對象，讓其封裝姓名，性別，年齡，毛色四個屬性。
⑤： 實例化一個人類的對象，讓其只執行父類的eat方法（可以對人類代碼進行修改）。
⑥： 實例化一個狗類的對象，讓其既執行父類的eat方法，又執行子類的eat方法。

# '''

# ①： 實例化一個人類的對象，讓其只封裝皮膚屬性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin):   # 定義人類的皮膚屬性
        self.skin = skin
        # super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
    def eat(self):
        print('人類正在吃飯')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定義狗的毛色屬性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父類封裝的屬性
    def eat(self):
        print('狗狗正在吃飯')
p1 = Person('黃色')

# ②： 實例化一個人類的對象，讓其封裝姓名，性別，年齡，皮膚四個屬性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定義人類的皮膚屬性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
    def eat(self):
        print('人類正在吃飯')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定義狗的毛色屬性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父類封裝的屬性
    def eat(self):
        print('狗狗正在吃飯')
p2 = Person('黃色', '馬玉剛', '男', 31)
p2.eat()

# ③： 實例化一個狗類的對象，讓其只封裝毛色屬性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定義人類的皮膚屬性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
    def eat(self):
        print('人類正在吃飯')
class Dog(Animal):
    def __init__(self, hair):   # 定義狗的毛色屬性
        self.hair = hair
    def eat(self):
        print('狗狗正在吃飯')
d1 = Dog('白色')
d1.eat()

# ④： 實例化一個狗類的對象，讓其封裝姓名，性別，年齡，毛色四個屬性。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定義人類的皮膚屬性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
    def eat(self):
        print('人類正在吃飯')
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定義狗的毛色屬性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父類封裝的屬性
    def eat(self):
        print('狗狗正在吃飯')
d2 = Dog('白色', '哈士奇', '公', 2)
d2.eat()

# ⑤： 實例化一個人類的對象，讓其只執行父類的eat方法（可以對人類代碼進行修改）。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定義人類的皮膚屬性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定義狗的毛色屬性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父類封裝的屬性
p3 = Person('黃色', '馬玉剛', '男', 31)
p3.eat()

# ⑥： 實例化一個狗類的對象，讓其既執行父類的eat方法，又執行子類的eat方法。
class Animal:
    def __init__(self, name, sex, age):
        self.name = name
        self.sex = sex
        self.age = age
    def eat(self):
        print('%s正在吃飯' % (self.name))
class Person(Animal):
    def __init__(self, skin, name, sex, age):   # 定義人類的皮膚屬性
        self.skin = skin
        super(Person, self).__init__(name, sex, age)  # 引用父類封裝的屬性
class Dog(Animal):
    def __init__(self, hair, name, sex, age):   # 定義狗的毛色屬性
        self.hair = hair
        super(Dog, self).__init__(name, sex, age)   # 引用父類封裝的屬性
d3 = Dog('白色', '哈士奇', '公', 2)
d3.eat()
'''
2，
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
可以改動上上面代碼，完成下列需求：
對C類實例化一個對象產生一個c1，然后c1.func()
1, 讓其執行C類中的func
2，讓其執行A類中的func
3，讓其執行B類中的func
4，讓其既執行C類中的func，又執行A類中的func
5，讓其既執行C類中的func，又執行B類中的func

'''

# 01, 讓其執行C類中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
c1 = C()
c1.func()
print(C.__mro__)  # 查看類執行先后的順序。

# 02，讓其執行A類中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        super(C, self).func()  # 通過該行代碼，讓其執行A類中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 03 讓其執行B類中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(B):
    def func(self):
        super().func()

c1 = C()
c1.func()

# 04 讓其既執行C類中的func，又執行A類中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
        super(C, self).func()  # 通過該行代碼，讓其執行A類中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 05 讓其既執行C類中的func，又執行B類中的func
class A:
    def func(self):
        print('in A')

class B:
    def func(self):
        print('in B')

class C(A,B):
    def func(self):
        print('in C')
        super(A, self).func() # 通過該行代碼，讓其執行A類中的func。
c1 = C()
c1.func()
print(C.__mro__)

# 3，下面代碼執行結果是什么？為什么？
class Parent:
    def func(self):
        print('in Parent func')

    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in Son func')

son1 = Son()

# 輸出結果：in Son func
'''
原因：由於在繼承的時候，執行的順序是先在子類/派生類中的方法/變量。，在執行父類（超類）中的方法/變量。本題中子類中包含
func函數，所以會先執行子類中的函數。
'''

# 4
class A:
    name = []

p1 = A()
p2 = A()
p1.name.append(1)
# p1.name，p2.name，A.name 分別是什么？
print(p1.name)   # [1] ，因為name是靜態變量，開辟的空間是唯一的。
print(p2.name)   # [1] ，因為name是靜態變量，開辟的空間是唯一的。
print(A.name)    # [1] ，因為name是靜態變量，開辟的空間是唯一的。

p1.age = 12
# p1.age，p2.age，A.age 分別又是什么？為什么？
print(p1.age)  # 12
print(p2.age)  # 報錯，age是p1的特有屬性
print(A.age)   # 報錯，age是p1的特有屬性