电商系统项目教程

Python电商系统项目实战教程

目录

1. 第一章：项目基础与环境搭建
2. 第二章：产品模块开发
3. 第三章：客户模块开发
4. 第四章：订单与支付模块
5. 第五章：工具模块与系统整合
6. 第六章：完整项目实战
7. 第七章：项目扩展与优化

---

第一章：项目基础与环境搭建

1.1 项目概述

1.1.1 什么是电商系统

电商系统（E-commerce System）是支持在线商品交易的信息系统。一个基础的电商系统通常包含：

• 商品管理：维护商品信息、价格、库存
• 客户管理：管理用户注册、登录、个人信息
• 订单管理：处理购物车、订单生成、状态跟踪
• 支付系统：处理付款、退款等资金操作

1.1.2 本项目学习目标

通过本项目的学习，你将掌握：

• Python面向对象编程（OOP）的核心概念
• 如何使用模块和包组织大型项目
• 类的设计原则和方法
• 实际项目开发流程

1.1.3 技术栈

• 编程语言：Python 3.x
• 核心概念：面向对象编程、模块化设计
• 设计模式：单例模式、工厂模式（简化版）

1.2 环境搭建

1.2.1 创建项目目录

首先，创建项目文件夹结构：

ecommerce/                  # 项目根目录
├── __init__.py            # 主包初始化文件
├── main.py                # 程序入口
├── customers/             # 客户子包
│   ├── __init__.py
│   └── customer.py
├── orders/                # 订单子包
│   ├── __init__.py
│   ├── order.py
│   └── payment.py
├── products/              # 产品子包
│   ├── __init__.py
│   ├── product.py
│   └── inventory.py
└── utils/                 # 工具子包
    ├── __init__.py
    └── helpers.py

1.2.2 创建包初始化文件

每个包文件夹都需要一个 __init__.py 文件（可以为空）：

ecommerce/init.py

"""
电商系统主包
"""

__version__ = "1.0.0"
__author__ = "Python学习者"

ecommerce/products/init.py

"""
产品模块包
"""

ecommerce/customers/init.py

"""
客户模块包
"""

ecommerce/orders/init.py

"""
订单模块包
"""

ecommerce/utils/init.py

"""
工具模块包
"""

1.3 Python模块与包基础

1.3.1 什么是模块

模块是包含 Python 代码的 .py 文件。使用模块可以将代码逻辑分离，提高可维护性。

# 导入模块的几种方式
import module_name              # 导入整个模块
from module_name import func    # 导入特定函数
from module_name import *       # 导入所有内容（不推荐）

1.3.2 什么是包

包是包含多个模块的文件夹，必须包含 __init__.py 文件。

# 导入包中的模块
from package.module import ClassName

1.3.3 相对导入与绝对导入

# 绝对导入（推荐）
from products.product import Product

# 相对导入
from .product import Product    # 同级目录
from ..utils.helpers import func  # 上级目录的子包

1.4 本章小结

• 了解了电商系统的基本组成
• 学习了项目目录结构的设计
• 掌握了模块和包的基本概念

---

第二章：产品模块开发

2.1 产品类设计基础

2.1.1 面向对象基础概念

类（Class） 是创建对象的蓝图，对象（Object） 是类的实例。

# 基础类定义
class Product:
    pass  # 空类

# 创建对象
p = Product()

2.1.2 定义产品类

产品类需要存储：产品ID、名称、价格、类别。

products/product.py

"""
产品类定义
"""

class Product:
    """产品类"""

    def __init__(self, product_id, name, price, category):
        """
        初始化产品

        参数说明：
            product_id: 产品唯一标识符（字符串）
            name: 产品名称（字符串）
            price: 产品价格（浮点数）
            category: 产品类别（字符串）
        """
        self.product_id = product_id
        self.name = name
        self.price = price
        self.category = category

关键点解析：

• __init__ 是构造方法，创建对象时自动调用
• self 代表对象本身，用于访问实例属性
• 属性（如 self.name）存储对象的数据

2.1.3 添加字符串表示方法

为了让打印对象更友好，添加 __str__ 方法：

    def __str__(self):
        """字符串表示"""
        return f"产品(ID:{self.product_id}, 名称:{self.name}, 价格:¥{self.price:.2f}, 类别:{self.category})"

测试代码：

# 创建产品对象
iphone = Product("P001", "iPhone 15", 5999.00, "手机")
print(iphone)  # 输出: 产品(ID:P001, 名称:iPhone 15, 价格:¥5999.00, 类别:手机)

2.2 产品类功能扩展

2.2.1 添加折扣功能

为产品添加计算折扣价格的方法：

    def apply_discount(self, discount_rate):
        """
        应用折扣

        参数：
            discount_rate: 折扣率 (0-1之间，如0.2表示8折)
        返回：
            折扣后的价格
        异常：
            ValueError: 当折扣率不在有效范围时抛出
        """
        if 0 <= discount_rate <= 1:
            return self.price * (1 - discount_rate)
        else:
            raise ValueError("折扣率必须在0到1之间")

使用示例：

iphone = Product("P001", "iPhone 15", 5999.00, "手机")
discounted_price = iphone.apply_discount(0.1)  # 9折
print(f"折扣后价格: ¥{discounted_price:.2f}")  # 输出: 折扣后价格: ¥5399.10

2.2.2 创建产品数据

定义一些示例产品数据供测试使用：

# 示例产品数据
PRODUCTS = {
    "P001": Product("P001", "iPhone 15", 5999.00, "手机"),
    "P002": Product("P002", "MacBook Pro", 12999.00, "电脑"),
    "P003": Product("P003", "AirPods", 1299.00, "耳机")
}

2.3 库存管理类

2.3.1 设计库存类

库存类负责管理产品的库存数量。

products/inventory.py

"""
库存管理模块
"""

from products.product import Product, PRODUCTS


class Inventory:
    """库存管理类"""

    def __init__(self):
        """初始化库存"""
        # 使用字典存储库存，key为产品ID，value为数量
        self.stock = {
            "P001": 50,  # iPhone 15
            "P002": 20,  # MacBook Pro
            "P003": 100  # AirPods
        }

2.3.2 实现库存查询

    def check_stock(self, product_id):
        """
        检查库存

        参数：
            product_id: 产品ID
        返回：
            库存数量，如果产品不存在返回0
        """
        return self.stock.get(product_id, 0)

2.3.3 实现库存更新

    def reduce_stock(self, product_id, quantity):
        """
        减少库存（售出商品时调用）

        参数：
            product_id: 产品ID
            quantity: 减少的数量
        返回：
            bool: 操作是否成功
        """
        if self.stock.get(product_id, 0) >= quantity:
            self.stock[product_id] -= quantity
            return True
        else:
            return False

    def add_stock(self, product_id, quantity):
        """
        增加库存（进货时调用）

        参数：
            product_id: 产品ID
            quantity: 增加的数量
        """
        if product_id in self.stock:
            self.stock[product_id] += quantity
        else:
            self.stock[product_id] = quantity

2.4 产品模块实战练习

2.4.1 练习1：创建产品

from products.product import Product

# 创建新产品
ipad = Product("P004", "iPad Pro", 8999.00, "平板")
print(ipad)

# 计算折扣价
discount_price = ipad.apply_discount(0.15)
print(f"85折价格: ¥{discount_price:.2f}")

2.4.2 练习2：库存管理

from products.inventory import Inventory

# 创建库存管理器
inventory = Inventory()

# 查询库存
print(f"iPhone库存: {inventory.check_stock('P001')}台")

# 售出2台
if inventory.reduce_stock("P001", 2):
    print("售出成功")
    print(f"剩余库存: {inventory.check_stock('P001')}台")
else:
    print("库存不足")

# 进货10台
inventory.add_stock("P001", 10)
print(f"进货后库存: {inventory.check_stock('P001')}台")

2.5 本章小结

• 学习了类的定义和 __init__ 构造方法
• 掌握了 __str__ 方法自定义对象输出
• 实现了产品类和库存管理类
• 理解了异常处理（ValueError）

---

第三章：客户模块开发

3.1 客户类设计

3.1.1 客户信息建模

客户需要存储：客户ID、姓名、邮箱、地址、订单历史。

customers/customer.py

"""
客户类定义
"""


class Customer:
    """客户类"""

    def __init__(self, customer_id, name, email, address):
        """
        初始化客户

        参数：
            customer_id: 客户唯一标识
            name: 客户姓名
            email: 客户邮箱
            address: 客户地址
        """
        self.customer_id = customer_id
        self.name = name
        self.email = email
        self.address = address
        self.order_history = []  # 订单历史列表

3.1.2 添加字符串表示

    def __str__(self):
        """字符串表示"""
        return f"客户(ID:{self.customer_id}, 姓名:{self.name}, 邮箱:{self.email})"

3.2 订单历史管理

3.2.1 添加订单到历史

    def add_order(self, order):
        """
        添加订单到历史记录

        参数：
            order: 订单对象
        """
        self.order_history.append(order)

3.2.2 获取订单历史

    def get_order_history(self):
        """
        获取订单历史

        返回：
            订单历史列表的副本（防止外部直接修改）
        """
        return self.order_history.copy()

3.3 客户模块实战练习

3.3.1 练习：创建客户并管理订单

from customers.customer import Customer

# 创建客户
customer = Customer("C001", "张三", "zhangsan@example.com", "北京市朝阳区")
print(customer)

# 模拟添加订单（假设order是一个订单对象）
# customer.add_order(order)

# 查看订单历史
# history = customer.get_order_history()
# print(f"历史订单数: {len(history)}")

3.4 本章小结

• 学习了列表作为对象属性的使用
• 理解了数据封装（返回列表副本）
• 掌握了客户类的设计方法

---

第四章：订单与支付模块

4.1 订单类设计

4.1.1 订单属性分析

订单需要包含：订单号、客户信息、商品列表、订单状态。

orders/order.py

"""
订单类定义
"""


class Order:
    """订单类"""

    # 类属性：订单号计数器，所有订单共享
    order_counter = 1000

    def __init__(self, customer, items):
        """
        初始化订单

        参数：
            customer: 客户对象
            items: 商品列表 [(产品对象, 数量), ...]
        """
        Order.order_counter += 1
        self.order_id = f"ORD{Order.order_counter}"
        self.customer = customer
        self.items = items
        self.status = "待支付"

关键点解析：

• order_counter 是类属性，所有 Order 实例共享
• 每次创建订单，计数器自动递增，生成唯一订单号
• items 是列表，每个元素是 (产品, 数量) 元组

4.1.2 计算订单总价

    def calculate_total(self):
        """
        计算订单总金额

        返回：
            订单总金额
        """
        total = 0
        for product, quantity in self.items:
            total += product.price * quantity
        return total

4.1.3 字符串表示

    def __str__(self):
        """字符串表示"""
        items_str = ", ".join([f"{product.name} x{quantity}" for product, quantity in self.items])
        return f"订单({self.order_id}), 客户:{self.customer.name}, 商品:{items_str}, 总价:¥{self.calculate_total():.2f}, 状态:{self.status}"

4.2 支付处理器

4.2.1 设计支付类

orders/payment.py

"""
支付处理模块
"""


class PaymentProcessor:
    """支付处理器"""

    def __init__(self):
        """初始化支付处理器"""
        self.payment_methods = ["信用卡", "支付宝", "微信支付"]

4.2.2 实现支付处理

    def process_payment(self, order, payment_method):
        """
        处理支付

        参数：
            order: 订单对象
            payment_method: 支付方式
        返回：
            tuple: (是否成功, 消息)
        """
        # 检查支付方式是否支持
        if payment_method not in self.payment_methods:
            return False, "不支持的支付方式"

        total_amount = order.calculate_total()

        # 模拟支付处理
        if total_amount > 0:
            order.status = "已支付"
            return True, f"支付成功，金额: ¥{total_amount:.2f}"
        else:
            return False, "订单金额无效"

4.3 订单与支付实战练习

4.3.1 练习：创建订单

from customers.customer import Customer
from products.product import PRODUCTS
from orders.order import Order

# 创建客户
customer = Customer("C001", "张三", "zhangsan@example.com", "北京市朝阳区")

# 准备商品
items = [
    (PRODUCTS["P001"], 1),  # 1台iPhone
    (PRODUCTS["P003"], 2)   # 2个AirPods
]

# 创建订单
order = Order(customer, items)
print(order)
print(f"订单总价: ¥{order.calculate_total():.2f}")

4.3.2 练习：处理支付

from orders.payment import PaymentProcessor

# 创建支付处理器
processor = PaymentProcessor()

# 处理支付
success, message = processor.process_payment(order, "支付宝")
print(f"支付结果: {message}")
print(f"订单状态: {order.status}")

4.4 本章小结

• 学习了类属性的使用（订单计数器）
• 掌握了元组列表的数据结构
• 理解了支付处理的基本流程
• 学习了返回多个值的元组用法

---

第五章：工具模块与系统整合

5.1 辅助函数模块

5.1.1 设计工具函数

utils/helpers.py

"""
辅助函数模块
"""


def format_currency(amount):
    """
    格式化货币

    参数：
        amount: 金额（数字）
    返回：
        格式化后的货币字符串
    示例：
        >>> format_currency(1234.5)
        '¥1,234.50'
    """
    return f"¥{amount:,.2f}"


def validate_email(email):
    """
    验证邮箱格式（简单验证）

    参数：
        email: 邮箱地址
    返回：
        bool: 是否有效
    """
    return "@" in email and "." in email


def print_separator():
    """打印分隔线"""
    print("=" * 50)

5.2 工具函数使用示例

5.2.1 格式化货币

from utils.helpers import format_currency

price = 1234567.89
print(format_currency(price))  # 输出: ¥1,234,567.89

5.2.2 验证邮箱

from utils.helpers import validate_email

emails = ["test@example.com", "invalid-email", "user@domain"]
for email in emails:
    result = validate_email(email)
    print(f"{email}: {'有效' if result else '无效'}")

5.3 本章小结

• 学习了工具函数的封装
• 掌握了字符串格式化技巧
• 理解了模块的复用性

---

第六章：完整项目实战

6.1 主程序设计

6.1.1 程序入口

main.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
主程序文件
演示如何使用电商系统模块和包
"""

print("=== 电商系统演示 ===")

# 添加当前目录到Python路径
import sys
import os

current_dir = os.path.dirname(os.path.abspath(__file__))
if current_dir not in sys.path:
    sys.path.insert(0, current_dir)

# 导入电商系统模块
try:
    from products.product import Product, PRODUCTS
    from products.inventory import Inventory
    from customers.customer import Customer
    from orders.order import Order
    from orders.payment import PaymentProcessor
    from utils.helpers import format_currency, validate_email, print_separator

    print("✅ 所有模块导入成功！")
except ImportError as e:
    print(f"❌ 模块导入失败: {e}")
    sys.exit(1)

6.1.2 完整业务流程

# 演示电商系统功能
print_separator()

# 1. 创建客户
print("1. 创建客户")
customer = Customer("C001", "张三", "zhangsan@example.com", "北京市朝阳区")
print(f"   客户信息: {customer}")

# 2. 验证客户邮箱
print("\n2. 验证客户邮箱")
is_valid = validate_email(customer.email)
print(f"   邮箱验证结果: {is_valid}")

# 3. 查看产品信息
print("\n3. 查看产品信息")
print("   可用产品:")
for product_id, product in PRODUCTS.items():
    print(f"   - {product}")

# 4. 检查库存
print("\n4. 检查库存")
inventory = Inventory()
for product_id in ["P001", "P002", "P003"]:
    stock = inventory.check_stock(product_id)
    product = PRODUCTS[product_id]
    print(f"   {product.name} 库存: {stock}台")

# 5. 创建订单
print("\n5. 创建订单")
items = [
    (PRODUCTS["P001"], 1),
    (PRODUCTS["P003"], 2)
]
order = Order(customer, items)
print(f"   订单详情: {order}")

# 6. 计算订单总价
print("\n6. 计算订单总价")
total = order.calculate_total()
print(f"   订单总价: {format_currency(total)}")

# 7. 处理支付
print("\n7. 处理支付")
payment_processor = PaymentProcessor()
success, message = payment_processor.process_payment(order, "支付宝")
print(f"   支付结果: {message}")
print(f"   订单状态: {order.status}")

# 8. 更新库存
print("\n8. 更新库存")
if success:
    for product, quantity in items:
        inventory.reduce_stock(product.product_id, quantity)

    print("   库存更新后:")
    for product, quantity in items:
        stock = inventory.check_stock(product.product_id)
        print(f"   - {product.name} 剩余库存: {stock}台")

print_separator()
print("🎉 电商系统演示完成！")

6.2 运行项目

6.2.1 命令行运行

cd ecommerce
python main.py

6.2.2 预期输出

=== 电商系统演示 ===
✅ 所有模块导入成功！
==================================================
1. 创建客户
   客户信息: 客户(ID:C001, 姓名:张三, 邮箱:zhangsan@example.com)

2. 验证客户邮箱
   邮箱验证结果: True

3. 查看产品信息
   可用产品:
   - 产品(ID:P001, 名称:iPhone 15, 价格:¥5999.00, 类别:手机)
   - 产品(ID:P002, 名称:MacBook Pro, 价格:¥12999.00, 类别:电脑)
   - 产品(ID:P003, 名称:AirPods, 价格:¥1299.00, 类别:耳机)

4. 检查库存
   iPhone 15 库存: 50台
   MacBook Pro 库存: 20台
   AirPods 库存: 100台

5. 创建订单
   订单详情: 订单(ORD1001), 客户:张三, 商品:iPhone 15 x1, AirPods x2, 总价:¥8597.00, 状态:待支付

6. 计算订单总价
   订单总价: ¥8,597.00

7. 处理支付
   支付结果: 支付成功，金额: ¥8597.00
   订单状态: 已支付

8. 更新库存
   库存更新后:
   - iPhone 15 剩余库存: 49台
   - AirPods 剩余库存: 98台
==================================================
🎉 电商系统演示完成！

6.3 本章小结

• 完成了完整的电商系统开发
• 实现了从客户创建到支付的完整流程
• 掌握了多模块协作的方法

---

第七章：项目扩展与优化

7.1 功能扩展建议

7.1.1 添加购物车功能

class ShoppingCart:
    """购物车类"""

    def __init__(self, customer):
        self.customer = customer
        self.items = []

    def add_item(self, product, quantity):
        """添加商品到购物车"""
        self.items.append((product, quantity))

    def remove_item(self, product_id):
        """从购物车移除商品"""
        self.items = [(p, q) for p, q in self.items if p.product_id != product_id]

    def clear(self):
        """清空购物车"""
        self.items = []

    def calculate_total(self):
        """计算总价"""
        return sum(p.price * q for p, q in self.items)

7.1.2 添加订单状态流转

class Order:
    """增强版订单类"""

    # 定义状态流转规则
    STATUS_FLOW = {
        "待支付": ["已支付", "已取消"],
        "已支付": ["待发货"],
        "待发货": ["已发货"],
        "已发货": ["已完成"],
        "已完成": [],
        "已取消": []
    }

    def change_status(self, new_status):
        """修改订单状态"""
        if new_status in self.STATUS_FLOW.get(self.status, []):
            self.status = new_status
            return True
        return False

7.2 代码优化建议

7.2.1 添加异常处理

def process_payment(self, order, payment_method):
    try:
        if payment_method not in self.payment_methods:
            raise ValueError(f"不支持的支付方式: {payment_method}")

        total_amount = order.calculate_total()

        if total_amount <= 0:
            raise ValueError("订单金额必须大于0")

        # 模拟支付API调用
        # ...

        order.status = "已支付"
        return True, f"支付成功，金额: ¥{total_amount:.2f}"

    except ValueError as e:
        return False, str(e)
    except Exception as e:
        return False, f"支付处理异常: {str(e)}"

7.2.2 添加日志记录

import logging

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)

class PaymentProcessor:
    def process_payment(self, order, payment_method):
        logger.info(f"开始处理订单 {order.order_id} 的支付")
        # ... 处理逻辑 ...
        logger.info(f"订单 {order.order_id} 支付完成")

7.3 数据库集成思路

7.3.1 使用SQLite存储数据

import sqlite3

class Database:
    """数据库管理类"""

    def __init__(self, db_path="ecommerce.db"):
        self.conn = sqlite3.connect(db_path)
        self.create_tables()

    def create_tables(self):
        """创建数据表"""
        cursor = self.conn.cursor()

        # 创建产品表
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS products (
                product_id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                price REAL NOT NULL,
                category TEXT
            )
        ''')

        self.conn.commit()

7.4 本章小结

• 了解了功能扩展的方向
• 学习了异常处理和日志记录
• 掌握了数据库集成的基本思路

---

附录：完整代码参考

A.1 项目文件结构

ecommerce/
├── __init__.py
├── main.py
├── customers/
│   ├── __init__.py
│   └── customer.py
├── orders/
│   ├── __init__.py
│   ├── order.py
│   └── payment.py
├── products/
│   ├── __init__.py
│   ├── product.py
│   └── inventory.py
└── utils/
    ├── __init__.py
    └── helpers.py

A.2 各模块完整代码

（各模块代码见前文各章节）

---

总结

通过本教程的学习，你已经：

1. 掌握了Python面向对象编程

   • 类的定义和使用
   • 属性和方法
   • 构造方法 __init__
   • 字符串表示 __str__

2. 理解了模块和包的组织

   • 如何创建模块
   • 如何组织包结构
   • 导入语句的使用

3. 完成了电商系统开发

   • 产品管理模块
   • 客户管理模块
   • 订单和支付模块
   • 工具函数模块

4. 具备了项目扩展能力

   • 了解功能扩展方向
   • 掌握代码优化技巧
   • 理解数据库集成方法

继续加油，你可以在此基础上构建更完善的电商系统！