用珠宝行业来解释：珠宝店（客户端）不需要自己打造钻戒、项链、手镯，而是交给珠宝加工厂（工厂类），只需告诉工厂 "要钻戒" 或 "要项链"，工厂就会根据要求生产出对应属性的珠宝（产品类），并能完成 "定制刻字""材质检测" 等业务流程。
python
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/9 21:10
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : JewelryInfo.py
class JewelryInfo(object):
"""
"""
def __init__(self):
"""
"""
self.sku = None
"""
唯一编号（如：G20260307001）
"""
self.category = None
"""
品类：戒指/项链/手镯
"""
self.material = None
"""
材质：黄金/钻石/翡翠
"""
self.weight = None
"""
克重（黄金）/克拉（钻石）
"""
self.price = None
"""
单价（元）
"""
self.stock = None
"""
初始库存
"""
@property
def sku(self):
"""
唯一编号（如：G20260307001）
:return:
"""
return self.sku
@sku.setter
def sku(self, sku:str):
"""
唯一编号（如：G20260307001）
:param sku:
:return:
"""
self.sku = sku
@property
def category(self):
"""
品类：戒指/项链/手镯
:return:
"""
return self.category
@category.setter
def category(self, category:str):
"""
品类：戒指/项链/手镯
:param category:
:return:
"""
self.category = category
@property
def material(self):
"""
材质：黄金/钻石/翡翠
:return:
"""
return self.material
@material.setter
def material(self, material:str):
"""
材质：黄金/钻石/翡翠
:param material:
:return:
"""
self.material = material
@property
def weight(self):
"""
克重（黄金）/克拉（钻石）
:return:
"""
return self.weight
@weight.setter
def weight(self, weight:float):
"""
克重（黄金）/克拉（钻石）
:param weight:
:return:
"""
self.weight = weight
@property
def price(self):
"""
单价（元）
:return:
"""
return self.price
@price.setter
def price(self, price:float):
"""
单价（元）
:param price:
:return:
"""
self.price = price
@property
def stock(self):
"""
初始库存
:return:
"""
return self.stock
@stock.setter
def stock(self, stock:int):
"""
初始库存
:param stock:
:return:
"""
self.stock = stock
def __str__(self):
"""
自定义打印格式，让珠宝信息更易读"
:return:
"""
return f"珠宝[{self.sku}]：{self.category} | {self.material} | {self.weight}({'' if '钻石' in self.material else '克'}克拉) | 单价{self.price}元 | 库存{self.stock}件"
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:30
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : Jewelry.py
from abc import ABC, abstractmethod
# ----1：定义珠宝产品抽象基类（统一产品接口）
class Jewelry(ABC):
"""
珠宝产品抽象基类（定义统一接口）
"""
def __init__(self, material: str, weight: float, price: float):
"""
:param material:
:param weight:
:param price:
"""
# 珠宝核心属性
self.material = material # 材质（如黄金、铂金、钻石）
self.weight = weight # 重量（克/克拉）
self.price = price # 单价（元/克 或 元/克拉）
@abstractmethod
def engrave(self, text: str) -> None:
"""
抽象方法：定制刻字（不同珠宝刻字规则不同）
:param text:
:return:
"""
pass
# 通用业务：材质检测（所有珠宝通用）
def check_material(self) -> str:
"""
检测珠宝材质是否合格
:return:
"""
qualified_materials = ["黄金", "铂金", "钻石", "翡翠"]
if self.material in qualified_materials:
return f"{self.__class__.__name__}材质检测合格：{self.material}"
else:
return f"{self.__class__.__name__}材质检测不合格：{self.material}"
# 通用业务：计算总价（重量 * 单价）
def calculate_total_price(self) -> float:
"""
计算珠宝总价
:return:
"""
total = self.weight * self.price
print(f"{self.__class__.__name__}总价：{total} 元（重量：{self.weight}，单价：{self.price}）")
return total
python
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： 简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:33
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : Bracelet.py
from Model.SimpleFactory.Jewelry import Jewelry
# ----2：定义具体珠宝产品类（实现抽象接口）
class Bracelet(Jewelry):
"""
# 手镯（具体产品）
"""
def __init__(self, material: str, weight: float, price: float, circumference: float):
"""
:param material:
:param weight:
:param price:
:param circumference:
"""
super().__init__(material, weight, price)
self.circumference = circumference # 手镯特有属性：周长（厘米）
def engrave(self, text: str) -> None:
"""
手镯刻字：仅支持≤10个字符，刻在手镯内侧
:param text:
:return:
"""
if len(text) <= 10:
print(f"手镯刻字完成：{text}（刻在{self.material}手镯内侧，周长：{self.circumference}cm）")
else:
print("手镯刻字失败：字符数超过10个")
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:32
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : DiamondRing.py
from Model.SimpleFactory.Jewelry import Jewelry
# --------2：定义具体珠宝产品类（实现抽象接口）
class DiamondRing(Jewelry):
"""
# 钻戒（具体产品）
"""
def __init__(self, material: str, weight: float, price: float, diamond_carat: float):
"""
:param material:
:param weight:
:param price:
:param diamond_carat:
"""
super().__init__(material, weight, price)
self.diamond_carat = diamond_carat # 钻戒特有属性：钻石克拉
def engrave(self, text: str) -> None:
"""
钻戒刻字：仅支持≤8个字符，刻在戒托内侧
:param text:
:return:
"""
if len(text) <= 8:
print(f"钻戒刻字完成：{text}（刻在{self.material}戒托内侧，钻石克拉：{self.diamond_carat}）")
else:
print("钻戒刻字失败：字符数超过8个")
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:33
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : Necklace.py
from Model.SimpleFactory.Jewelry import Jewelry
# ---2：定义具体珠宝产品类（实现抽象接口）
class Necklace(Jewelry):
"""
# 项链（具体产品）
"""
def __init__(self, material: str, weight: float, price: float, pendant_type: str):
"""
:param material:
:param weight:
:param price:
:param pendant_type:
"""
super().__init__(material, weight, price)
self.pendant_type = pendant_type # 项链特有属性：吊坠类型
def engrave(self, text: str) -> None:
"""
项链刻字：仅支持≤6个字符，刻在吊坠背面
:param text:
:return:
"""
if len(text) <= 6:
print(f"项链刻字完成：{text}（刻在{self.pendant_type}吊坠背面，材质：{self.material}）")
else:
print("项链刻字失败：字符数超过6个")
python
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:34
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : JewelryFactory.py
from Model.SimpleFactory.Jewelry import Jewelry
from Model.SimpleFactory.DiamondRing import DiamondRing
from Model.SimpleFactory.Necklace import Necklace
from Model.SimpleFactory.Bracelet import Bracelet
#---- 3：定义珠宝工厂类（统一创建产品）
class DuJewelryFactory(object):
"""
珠宝加工厂（简单工厂核心类）
"""
@staticmethod
def create_jewelry(jewelry_type: str, **kwargs) -> Jewelry:
"""
创建珠宝对象
:param jewelry_type: 珠宝类型（diamond_ring/necklace/bracelet）
:param kwargs: 珠宝属性（material/weight/price + 特有属性）
:return: 珠宝对象
"""
if jewelry_type == "diamond_ring":
# 校验钻戒必要参数
required = ["material", "weight", "price", "diamond_carat"]
if all(k in kwargs for k in required):
return DiamondRing(**kwargs)
else:
raise ValueError("创建钻戒失败：缺少必要参数（material/weight/price/diamond_carat）")
elif jewelry_type == "necklace":
# 校验项链必要参数
required = ["material", "weight", "price", "pendant_type"]
if all(k in kwargs for k in required):
return Necklace(**kwargs)
else:
raise ValueError("创建项链失败：缺少必要参数（material/weight/price/pendant_type）")
elif jewelry_type == "bracelet":
# 校验手镯必要参数
required = ["material", "weight", "price", "circumference"]
if all(k in kwargs for k in required):
return Bracelet(**kwargs)
else:
raise ValueError("创建手镯失败：缺少必要参数（material/weight/price/circumference）")
else:
raise ValueError(f"不支持的珠宝类型：{jewelry_type}")
python
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：简单工厂模式（Simple Factory Pattern）
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2024.3.6 python 3.11
# os : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 Oracle 21c Neo4j
# Datetime : 2026/3/8 22:36
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : SimpleFactoryBll.py
from Interface.SimpleFactory.DuJewelryFactory import DuJewelryFactory
# ----4：客户端使用（珠宝店下单）
class SimpleFactoryBll(object):
"""
简单工厂模式（Simple Factory Pattern）
"""
def demo(self):
"""
简单工厂模式（Simple Factory Pattern）
:return:
"""
# 1. 珠宝店向工厂下单：定制钻戒
diamond_ring = DuJewelryFactory.create_jewelry(
jewelry_type="diamond_ring",
material="铂金",
weight=5.2, # 戒托重量（克）
price=450, # 铂金单价（元/克）
diamond_carat=0.5 # 钻石克拉
)
# 执行钻戒业务流程
diamond_ring.calculate_total_price() # 计算总价
print(diamond_ring.check_material()) # 材质检测
diamond_ring.engrave("永结同心") # 刻字
print("-" * 50)
# 2. 珠宝店向工厂下单：定制项链
necklace = DuJewelryFactory.create_jewelry(
jewelry_type="necklace",
material="黄金",
weight=8.5, # 项链重量（克）
price=420, # 黄金单价（元/克）
pendant_type="心形" # 吊坠类型
)
# 执行项链业务流程
necklace.calculate_total_price()
print(necklace.check_material())
necklace.engrave("爱你一生")
print("-" * 50)
# 3. 珠宝店向工厂下单：定制手镯
bracelet = DuJewelryFactory.create_jewelry(
jewelry_type="bracelet",
material="翡翠",
weight=30.0, # 手镯重量（克）
price=800, # 翡翠单价（元/克）
circumference=18.5 # 周长
)
# 执行手镯业务流程
bracelet.calculate_total_price()
print(bracelet.check_material())
bracelet.engrave("平安喜乐2026")
调用：
python
# encoding: utf-8
# 版权所有 2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述： 设计模式 Design Patterns
# Author : geovindu,Geovin Du 涂聚文.
# IDE : PyCharm 2023.1 python 3.11
# OS : windows 10
# database : mysql 9.0 sql server 2019, postgreSQL 17.0 oracle 21c Neo4j
# Datetime : 2026/2/18 20:58
# User : geovindu
# Product : PyCharm
# Project : pydesginpattern
# File : main.py
# explain : 学习
import Controller.CheckPatterns
def select_design_pattern() -> tuple[int, Controller.CheckPatterns.DesignPattern | None]:
"""
返回 (序列号, 选中的枚举对象)，退出则返回 (0, None)
:return:
"""
print("\n=== 方式3：用户选择展示 ===")
print("可选设计模式（输入0或q退出）：")
for idx, pattern in enumerate(Controller.CheckPatterns.DesignPattern, 1):
print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")
print("0. 退出")
while True:
user_input = input("\n请输入序号选择要展示的设计模式（输入0/q退出）：").strip()
if user_input in ("0", "q", "Q"):
print("👋 退出选择流程")
return (0, None)
try:
choice = int(user_input)
if 1 <= choice <= len(Controller.CheckPatterns.DesignPattern):
selected_pattern = list(Controller.CheckPatterns.DesignPattern)[choice - 1]
print(f"✅ 你选择了序号：{choice}（对应{selected_pattern._name_to_cn(selected_pattern.name)}）")
return (choice, selected_pattern) # 返回(序列号, 枚举对象)
else:
print(f"❌ 输入无效！请输入1-{len(Controller.CheckPatterns.DesignPattern)}之间的数字，或0/q退出")
except ValueError:
print("❌ 输入无效！请输入数字序号，或0/q退出")
def ask_continue() -> bool:
"""
询问用户是否继续选择，返回True（继续）/False（退出）
"""
while True:
user_choice = input("\n是否继续选择其他设计模式？(y/n)：").strip().lower()
if user_choice == "y":
return True
elif user_choice == "n":
print("👋 感谢使用，程序结束！")
return False
else:
print("❌ 输入无效！请输入 y（继续）或 n（退出）")
if __name__ == '__main__':
# 方式1：用户输入选择展示（交互版）
'''
print("\n=== 方式1：用户选择展示 ===")
print("可选设计模式：")
for idx, pattern in enumerate( bll.CheckPatterns.DesignPattern, 1):
print(f"{idx}. {pattern._name_to_cn(pattern.name)}（{pattern.name}）")
try:
choice = int(input("\n请输入序号选择要展示的设计模式："))
selected_pattern = list( bll.CheckPatterns.DesignPattern)[choice - 1]
selected_pattern.show_example()
except (ValueError, IndexError):
print("❌ 输入无效，请输入正确的序号！")
'''
# 2
print("🎉 设计模式示例展示程序")
while True:
# 1. 选择设计模式
selected_num, selected_pattern = select_design_pattern()
# 2. 判断是否直接退出（输入0/q）
if selected_num == 0:
print("👋 程序结束！")
break
# 3. 执行选中的示例
selected_pattern.show_example()
print(f"\n📌 本次选择的序列号是：{selected_num}")
# 4. 询问是否继续
if not ask_continue():
break # 用户选择不继续，终止循环
print('hi,welcome geovindu.')输出：
