14_Python語法示例(面向對象)

1.自己寫一個Student類,此類的對象有屬性name, age, score, 用來保存學生的姓名,年齡,成績

# 1)寫一個函數input_student讀入n個學生的信息,用對象來存儲這些信息(不用字典),並返回對象的列表
# 2)寫一個函數output_student 打印這些學生信息(格式不限)
class Student():
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    
    
def input_student():
    L = []
    while True:
        name = input("姓名:")
        if not name:
            break
        age = input("年齡:")
        score = input("成績:")
        s = Student(name, age, score)
        L.append(s)
    return L


def output_student(lst):
    for i in lst:
        print("姓名:%s 年齡:%s 成績:%s" % (i.name, i.age, i.score))
        

def main():
    L = input_student()
    output_student(L)
    
    
main()

2.定義一個類Huamn(人類),定義函數input_human錄入信息,main調用顯示信息

# 有三個屬性: 姓名name,年齡age,家庭住址address (可以省略沒有)
# 有方法: show_info 用來顯示人的信息,update_age用來讓這個人的年齡增加一歲
class Huamn():
    total_count = 0
    def __init__(self, name, age, address=None):
        self.name = name
        self.age = age
        self.address = address
        self.__class__.total_count += 1
        
    def show_info(self):
        print("姓名:%s 年齡:%s 地址:%s" % (self.name, self.age, self.address))
        
    def updata_age(self):
        self.age += 1
    
    @classmethod
    def get_huamn_count(cls):
        return cls.total_count
        
    def __del__(self):
        self.__class__.total_count -= 1
    
        
def input_human():
    L = []
    while True:
        name = input("姓名:")
        if not name:
            break
        age = int(input("年齡:") or '0')
        address = input("地址:")
        s = Huamn(name, age, address)
        L.append(s)
    return L
    
    
def main():
    L = input_human()
    for obj in L:
        obj.show_info()  # 列出所有人的信息
    for obj in L:
        obj.updata_age()  # 讓所有人都長一歲
    for obj in L:
        obj.show_info()  # 再次列表所有人的信息
    print("當前總人數是%s" % Huamn.get_huamn_count())
    
    
main()

3.寫一個自行車類有騎行方法,調用時顯示騎行里程km,再寫一個電動自行車類繼承第一個類,添加電池電量屬性,同時有兩個方法

# fill_charge(vol) 用來充電, vol 為電量(度), run(km) 方法用於騎行,每騎行10km消耗電量1度
# 當電量消耗盡時調用Bicycle的run方法騎行並顯示騎行結果
class Bycycle():
    def run(self, km):
        print("自行車騎行了%s公里" % km)
        

class Ebicycle(Bycycle):
    def __init__(self, valume):
        self.valume = valume
        
    def fill_charge(self, vol):
        self.valume += vol
        
    def run(self, km):
        e_km = min(km, self.valume * 10)
        self.valume -= e_km / 10  # 電量消耗
        if e_km > 0:
            print("電動自行車騎行了", e_km, "公里")
        if km > e_km:  # 判斷沒電后行駛的過程
            super().run(km - e_km)
        
        
b = Ebicycle(5)
b.run(10)
b.run(100)
b.fill_charge(6)
b.run(70)

4.寫一個實現迭代器協議的類 Primes 讓此類可以生成從b開始的n個素數

class Primes:
    @staticmethod
    def __isprime(x):
        for i in range(2, x):
            if x % i == 0:
                return False
        return True

    def __init__(self, b, n):
        self.begin = b
        self.count = n
        
    def __iter__(self):
        self.cur_pos = self.begin  # 設置迭代的起始值
        self.cur_count = 0  # 用於記錄已生成幾個
        return self

    def __next__(self):
        # 已完成生成, 不需要再生成, 我停止迭代
        if self.cur_count >= self.count:
            raise StopIteration
        self.cur_count += 1  # 計數加1
        while True:
            if self.__isprime(self.cur_pos):
                v = self.cur_pos
                self.cur_pos += 1
                return v
            self.cur_pos += 1  # 為下一次循環做准備


for x in Primes(10, 4):
    print(x)  # 11 13 17 19

5.實現文件的復制(建議使用二進制方式進行操作)

def mycp(src_file, dst_file):
    '''
        src_file 源文件名
        dst_file 目標文件名
    '''
    try:
        with open(src_file, 'rb') as fr, open(dst_file, 'wb') as fw:
            # 如果文件太大則分次進行搬移
            while True:
                b = fr.read(4096)
                if not b:  # 如果字節串為空則停止復制
                    break
                fw.write(b)
    except:
        return False
    return True


def main():
    src = input("請輸入源文件名: ")
    dst = input("請輸入目標文件名: ")
    if mycp(src, dst):
        print("復制文件成功")
    else:
        print("復制文件失敗")


main()

6.實現兩個自定義列表的相加

class MyList:
    def __init__(self, iterable):
        self.data = [x for x in iterable]

    def __repr__(self):
        return 'MyList(%r)' % self.data

    def __add__(self, rhs):
        return MyList(self.data + rhs.data)

    def __mul__(self, rhs):
        return MyList(self.data * rhs)


L1 = MyList([1, 2, 3])
L2 = MyList(range(4, 7))
L3 = L1 + L2
print("L3 =", L3)  # MyList([1,2,3,4,5,6])
L4 = L1 * 2  # 實現乘法運算
print('L4 =', L4)  # MyList([1,2,3,1,2,3])

7.實現有序集合類 OrderSet(), 能實現兩個集合的交集 &, 並集 | 補集 -, 對稱補集 ^, ==, != 等操作(寫集合相同)

class OrderSet:
    def __init__(self, iterable):
        self.data = [x for x in iterable]
    
    def __repr__(self):
            return 'OrderSet(%r)' % self.data
            
    def __and__(self, rhs):
        return  OrderSet(set(self.data) & set(rhs.data))
        
    def __or__(self, rhs):
        return OrderSet(set(self.data) | set(rhs.data)) 
        
    def __xor__(self, rhs):
        return OrderSet(set(self.data) ^ set(rhs.data))
        
        
s1 = OrderSet([1,2,3,4])
s2 = OrderSet([3,4,5])
print(s1 & s2)  # OrderSet([3,4])
print(s1 | s2)  # OrderSet([1,2,3,4,5])
print(s1 ^ s2)  # OrderSet([1,2,5])
if OrderSet([1,2,3]) != OrderSet([1,2,3,4]):
    print("不相同")  # 不相同

8.模擬英雄聯盟寫一個游戲人物的類

"""
    (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, p):
        p.hp = p.hp - self.ad
        print("%s攻擊了%s, %s掉了%s血, 還剩%s血" % (self.name, p.name, p.name, self.ad, p.hp))
        
        
p1 = Game_role('蓋倫', 10, 100)
p2 = Game_role('劍豪', 20, 80)

p1.attack(p2)  # 蓋倫攻擊了劍豪, 劍豪掉了10血, 還剩70血

9.暴力摩托程序(完成下列需求)

"""
    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邁
    1.4 完成下列需求(利用武器打人掉的血量為武器的ad + 人的ad):
        (1)蒼井井騎着小踏板開着60邁的車行駛在賽道上
        (2)東尼木木騎着寶馬開着120邁的車行駛在賽道上
        (3)波多多騎着雅馬哈開着80邁的車行駛在賽道上
        (4)蒼井井赤手空拳打了波多多20滴血,波多多還剩xx血
        (5)東尼木木赤手空拳打了波多多30滴血,波多多還剩xx血
        (6)波多多利用平底鍋打了蒼井井一平底鍋,蒼井井還剩xx血
        (7)波多多利用斧子打了東尼木木一斧子,東尼木木還剩xx血
        (8)蒼井井騎着寶馬打了騎着小踏板的東尼木木一雙節棍,東尼木木哭了,還剩xx血
        (9)波多多騎着小踏板打了騎着雅馬哈的東尼木木一斧子,東尼木木哭了,還剩xx血
"""
class GameRole:
    """游戲角色類"""
    def __init__(self, name, sex, age, ad, hp):
        self.name = name
        self.sex = sex
        self.age = age
        self.ad = ad
        self.hp = hp
        
    def add_moto(self, mo):
        self.mo = mo
        
    def attack(self,p):
        p.hp = p.hp - self.ad
        print('%s赤手空拳打了%s%s滴血,%s還剩%s血' % (self.name, p.name, self.ad, p.name, p.hp))

    def add_weapon(self, wea):
        self.wea = wea

    def road_rush(self, p):
        p.hp = p.hp - self.ad - self.wea.ad
        print('%s騎着%s打了騎着%s的%s一%s,%s哭了,還剩%s血' \
              %(self.name, self.mo.name, p.mo.name, p.name, self.wea.name, p.name, p.hp))
            

class Weapon:
    """武器類"""
    def __init__(self, name, ad):
        self.name = name
        self.ad = ad
        
    def fight(self,p1,p2):
        p2.hp = p2.hp - p1.ad - self.ad
        #print('%s利用%s打了%s一%s,%s還剩%s血' % 
        #    (p1.name,self.name,p2.name,self.name,p2.name,p2.hp))
        print('{0}利用{1}打了{2}一{1},{2}還剩{3}血'.format(p1.name, self.name, p2.name, p2.hp))
        

class Moto:
    """摩托車類"""
    def __init__(self, name, speed):
        self.name = name
        self.speed = speed
        
    def drive(self, p):
        print('%s騎着%s開着%d邁的車行駛在賽道上' % (p.name, self.name, self.speed))


p1 = GameRole('蒼井井', '女', 18, 20, 200)
p2 = GameRole('東尼木木', '男', 20, 30, 150)
p3 = GameRole('波多多', '女', 19, 50, 80)

w1 = Weapon('平底鍋', 20)
w2 = Weapon('斧子', 50)
w3 = Weapon('雙節棍', 65)

m1 = Moto('小踏板', 60)
m2 = Moto('雅馬哈', 80)
m3 = Moto('寶馬', 120)

# 組合: 給p1 對象封裝了一個屬性,屬性值 m1這個對象
p1.add_moto(m1)
p1.mo.drive(p1)  # 蒼井井騎着小踏板開着60邁的車行駛在賽道上

p2.add_moto(m2)
p2.mo.drive(p2)  # 東尼木木騎着雅馬哈開着80邁的車行駛在賽道上

p3.add_moto(m3)
p3.mo.drive(p3)  # 波多多騎着寶馬開着120邁的車行駛在賽道上

p1.attack(p3)  # 蒼井井赤手空拳打了波多多20滴血,波多多還剩60血
p2.attack(p3)  # 東尼木木赤手空拳打了波多多30滴血,波多多還剩30血

p3.add_weapon(w1)
p3.wea.fight(p3, p1)  # 波多多利用平底鍋打了蒼井井一平底鍋,蒼井井還剩130血
p3.add_weapon(w2)
p3.wea.fight(p3, p2)  # 波多多利用斧子打了東尼木木一斧子,東尼木木還剩50血

p1.add_moto(m3)
p1.add_weapon(w3)
p2.add_moto(m1)
p1.road_rush(p2)  # 蒼井井騎着寶馬打了騎着小踏板的東尼木木一雙節棍,東尼木木哭了,還剩-35血

p3.add_moto(m1)
p2.add_moto(m2)
p3.road_rush(p2)  # 波多多騎着小踏板打了騎着雅馬哈的東尼木木一斧子,東尼木木哭了,還剩-135血

10.有1000個員工如果幾個員工對象的姓名和性別相同,這是一個人,請對這1000個員工做去重

class Employee:
    def __init__(self, name, age, sex, partment):
        self.name = name
        self.age = age
        self.sex = sex
        self.partment = partment
    def __hash__(self):
        return hash('%s%s'%(self.name, self.sex))
    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:
            return True


employ_lst = []
for i in range(200):
    employ_lst.append(Employee('echo', i, 'male', 'python'))
for i in range(200):
    employ_lst.append(Employee('Rubicon', i, 'male', 'python'))
for i in range(200):
    employ_lst.append(Employee('master', i, 'male', 'python'))

# print(employ_lst)
# set集合的去重機制: 先調用hash,再調用eq,eq不是每次都觸發,只有hash值相等的時候才會觸發
employ_set = set(employ_lst)
for person in employ_set:
    print(person.__dict__)

11.反射實現選課系統

"""userinfo文件內容
    echo|123456|Manager
    jojo|666|Student
    master|2222|Teacher
"""
class Manager:
    OPERATE_DIC = [
        ('創造學生賬號', 'create_student'),
        ('創建課程', 'create_course'),
        ('查看學生信息', 'check_student_info'),
    ]

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

    def create_student(self):
        print('創建學生賬號')

    def create_course(self):
        print('創建課程')

    def check_student_info(self):
        print('查看學生信息')


class Student:
    OPERATE_DIC = [
        ('查看所有課程', 'check_course'),
        ('選擇課程', 'choose_course'),
        ('查看已選擇的課程', 'choosed_course')
    ]

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

    def check_course(self):
        print('check_course')

    def choose_course(self):
        print('choose_course')

    def choosed_course(self):
        print('查看已選擇的課程')


def login():
    username = input('user: ')
    password = input('pwd: ')
    with open('userinfo') as f:
        for line in f:
            user, pwd, ident = line.strip().split('|')  # ident = 'Manager'
            if user == username and pwd == password:
                print('登錄成功')
                return username, ident


def main():
    usr, id = login()
    print('user,id :', usr, id)
    file = sys.modules['__main__']
    cls = getattr(file, id)  # Manager = getattr(當前文件,'Manager')
    obj = cls(usr)
    operate_dic = cls.OPERATE_DIC
    while True:
        for num, i in enumerate(operate_dic, 1):
            print(num, i[0])
        choice = int(input('num >>>'))
        choice_item = operate_dic[choice-1]
        getattr(obj, choice_item[1])()


if __name__ == '__main__':
    main()

12.飛機大戰游戲

    1.項目目錄結構
        ~/Desktop/Python/03_飛機大戰游戲 $ tree -L 1
        .
        ├── __pycache__
        ├── images
        ├── plane_main.py
        └── plane_sprites.py

    2.plane_main.py文件代碼

import pygame
from plane_sprites import *


class PlaneGame(object):
    """飛機大戰主游戲"""

    def __init__(self):
        pygame.init()
        print("游戲初始化")

        # 1.創建游戲的窗口
        self.screen = pygame.display.set_mode(SCREEN_RECT.size)

        # 2.創建游戲的時鍾
        self.clock = pygame.time.Clock()
        # 3.調用私有方法完成精靈和精靈組的創建
        self.__create_sprites()

        # 4.設置定時器時間-創建敵機 ENEMY_TIME時間出場一次
        pygame.time.set_timer(CREATE_ENEMY_EVENT, ENEMY_TIME)
        # 5.設定定時器時間-英雄子彈 FIRE_TIME時間發射一次
        pygame.time.set_timer(HERO_FIRE_EVENT, FIRE_TIME)
        # 6.設定定時器時間-敵機子彈 ENEMY_FIRE_EVENT時間發射一次
        pass

    def __create_sprites(self):

        # 創建背景精靈和精靈組
        bg1 = Background()
        bg2 = Background(True)

        self.back_group = pygame.sprite.Group(bg1, bg2)

        # 創建敵機的精靈組
        self.enemy_group = pygame.sprite.Group()

        # 創建英雄的精靈和精靈組
        self.hero = Hero()
        self.hero_group = pygame.sprite.Group(self.hero)

    def start_game(self):
        # print("游戲開始...")

        while True:

            # 1.設置刷新幀率
            self.clock.tick(FRAME_PER_SEC)
            # 2.事件監聽
            self.__event_handler()
            # 3.碰撞檢測
            self.__check_collide()
            # 4.更新/繪制精靈組
            self.__update_sprites()
            # 5.更新顯示
            pygame.display.update()

    def __event_handler(self):
        """事件監聽"""

        for event in pygame.event.get():

            # 判斷是否退出游戲
            if event.type == pygame.QUIT:
                PlaneGame.__game_over()
            # 監聽敵機出場事件
            elif event.type == CREATE_ENEMY_EVENT:
                # print(CREATE_ENEMY_EVENT, "敵機出場...")
                # 創建敵機精靈
                enemy = Enemy()

                # 將敵機精靈添加到敵機精靈組
                self.enemy_group.add(enemy)
            # 監聽英雄發射子彈事件
            elif event.type == HERO_FIRE_EVENT:
                self.hero.fire()
            # 事件監聽模式獲取按鍵
            # elif event.type == pygame.KEYDOWN and \
            #         event.key == pygame.K_RIGHT:
            #     print("單次向右移動...")

        # 使用鍵盤提供的方法獲取鍵盤按鍵-返回按鍵元組
        # 獲取鍵盤按鍵鍵位
        keys_pressed = pygame.key.get_pressed()
        # 判斷元組中對應的按鍵索引值
        if keys_pressed[pygame.K_RIGHT]:
            # print("持續向右移動...")
            self.hero.around = True
            self.hero.speed = HERO_RIGHT_LEFT
        elif keys_pressed[pygame.K_LEFT]:
            self.hero.around = True
            self.hero.speed = -HERO_RIGHT_LEFT
        elif keys_pressed[pygame.K_UP]:
            self.hero.around = False
            self.hero.speed = -HERO_UP_DOWN
        elif keys_pressed[pygame.K_DOWN]:
            self.hero.around = False
            self.hero.speed = HERO_UP_DOWN
        else:
            self.hero.speed = 0

    def __check_collide(self):
        """碰撞檢測"""

        # 1.子彈摧毀敵機
        pygame.sprite.groupcollide(self.hero.bullets, self.enemy_group, True, True)

        # 2.敵機撞毀英雄
        enemies = pygame.sprite.spritecollide(self.hero, self.enemy_group, True)

        #  判斷列表是否有類容
        if len(enemies) > 0:

            # 讓英雄犧牲
            self.hero.kill()

            # 結束游戲
            PlaneGame.__game_over()

    def __update_sprites(self):
        """更新顯示"""

        self.back_group.update()
        self.back_group.draw(self.screen)

        self.enemy_group.update()
        self.enemy_group.draw(self.screen)

        self.hero_group.update()
        self.hero_group.draw(self.screen)

        self.hero.bullets.update()
        self.hero.bullets.draw(self.screen)

    @staticmethod
    def __game_over():
        print("游戲結束")

        pygame.quit()
        exit()


if __name__ == '__main__':
    # 創建游戲對象
    game = PlaneGame()

    # 啟動游戲
    game.start_game()

    3.plane_sprites.py文件代碼

import random
import pygame


# 屏幕大小的常量
SCREEN_RECT = pygame.Rect(0, 0, 480, 700)
# 屏幕的刷新幀率
FRAME_PER_SEC = 60
# 屏幕的背景圖像
BG1_PNG = "./images/background2.png"

# 創建敵機的定時器常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
# 敵人出現時間的間隔,多少毫秒出現
ENEMY_TIME = 300
# 敵機的圖片
ENEMY1_PNG = "./images/enemy4.png"
# 敵機的最大/最小速度
ENEMY_MAX_SD = 7
ENEMY_MIN_SD = 3

# 英雄的圖片
HERO_PNG = "./images/me3.png"
# 英雄距離屏幕底端的距離
HERO_MAX_Y = 120
# 英雄左右移動速度
HERO_RIGHT_LEFT = 4
# 英雄上下移動速度
HERO_UP_DOWN = 2

# 英雄發射子彈的定時器常量
HERO_FIRE_EVENT = pygame.USEREVENT + 1
# 英雄子彈自動發射間隔 0.5秒發射一次
FIRE_TIME = 500
# 英雄子彈圖片
BULLET_PNG = "./images/bomb.png"
# 英雄子彈飛行速度
BULLET_TIME = -3


class GameSprite(pygame.sprite.Sprite):
    """飛機大戰游戲精靈"""

    def __init__(self, image_name, speed=1):
        # 調用父類的初始化方法
        super().__init__()

        # 定義對象的屬性
        self.image = pygame.image.load(image_name)
        self.rect = self.image.get_rect()
        self.speed = speed

    def update(self):
        # 屏幕的垂直方向上移動
        self.rect.y += self.speed


class Background(GameSprite):
    """游戲背景精靈"""

    def __init__(self, is_alt=False):

        # 1.調用父類方法實現精靈的創建(images/rect/speed)
        super().__init__(BG1_PNG)

        # 2.判斷是否是交替圖像,如果是則設置初始位置
        if is_alt:
            self.rect.y = -self.rect.height

    def update(self):

        # 1.調用父類的方法實現
        super().update()

        # 2.判斷是否移出屏幕,移出則將圖像設置到屏幕的上方
        if self.rect.y >= SCREEN_RECT.height:
            self.rect.y = -self.rect.height
        pass


class Enemy(GameSprite):
    """敵機精靈"""

    def __init__(self):
        # 1.調用父類方法,創建敵機精靈,同時指定敵機圖片
        super().__init__(ENEMY1_PNG)
        # 2.指定敵機的初始隨機速度
        self.speed = random.randint(ENEMY_MIN_SD, ENEMY_MAX_SD)
        # 3.指定敵機的初始隨機位置,bottom=y+height
        self.rect.bottom = 0

        max_x = SCREEN_RECT.width - self.rect.width
        self.rect.x = random.randint(0, max_x)

    def update(self):
        # 1.調用父類方法保持垂直方向的飛行
        super().update()
        # 2.判斷是否飛出屏幕,是則從精靈組中刪除敵機
        if self.rect.y >= SCREEN_RECT.height:
            # print("飛出屏幕,需要從精靈組刪除...")
            # kill方法可以將精靈從所有精靈組中移出,自動銷毀
            self.kill()

    def __del__(self):
        # print("敵機銷毀 %s" % self.rect)
        pass


class Hero(GameSprite):
    """英雄精靈"""

    def __init__(self):

        # 1.調用父類方法,設置images/speed
        super().__init__(HERO_PNG, 0)

        # 2.設置英雄的初始位置
        self.rect.centerx = SCREEN_RECT.centerx
        self.rect.bottom = SCREEN_RECT.bottom - HERO_MAX_Y

        # 3.設置英雄的初始控制模式,True左右飛行,False上下飛行
        self.around = True

        # 4.創建子彈的精靈組
        self.bullets = pygame.sprite.Group()

    def update(self, ):

        # 英雄在水平/垂直方向移動
        if self.around:
            self.rect.x += self.speed
        else:
            self.rect.y += self.speed

        # 控制英雄不能離開屏幕,right=x+width
        if self.rect.x < 0:
            self.rect.x = 0
        elif self.rect.right > SCREEN_RECT.right:
            self.rect.right = SCREEN_RECT.right
        elif self.rect.y < 0:
            self.rect.y = 0
        elif self.rect.bottom > SCREEN_RECT.bottom:
            self.rect.bottom = SCREEN_RECT.bottom

    def fire(self):
        # print("發射子彈...")

        for i in (0, 1):
            # 1.創建子彈精靈
            bullet = Bullet()

            # 2.設置精靈的位置
            bullet.rect.bottom = self.rect.y - i * 50
            bullet.rect.centerx = self.rect.centerx

            # 3.將精靈添加到精靈組
            self.bullets.add(bullet)


class Bullet(GameSprite):
    """子彈精靈"""

    def __init__(self):
        # 調用父類方法,設置子彈圖片和初始速度
        super().__init__(BULLET_PNG, BULLET_TIME)

    def update(self):
        # 調用父類方法,讓子彈沿垂直方向飛行
        super().update()

        # 判斷子彈是否飛出屏幕
        if self.rect.bottom < 0:
            self.kill()

    def __del__(self):
        # print("子彈被銷毀...")
        pass

    4.完整項目網盤鏈接: https://pan.baidu.com/s/1CagTcHaIdt_vH6HyDiOYPA  密碼: qkwa