from faker import Faker
import pandas as pd
import json
from datetime import datetime
# 創(chuàng)建一個Faker實例
fake = Faker('zh_CN')  # 使用中文本地化
# 生成基本個人信息
def generate_user():
    return {
        "name": fake.name(),
        "address": fake.address(),
        "email": fake.email(),
        "phone_number": fake.phone_number(),
        "job": fake.job(),
        "company": fake.company(),
        "birth_date": fake.date_of_birth(minimum_age=18, maximum_age=80).isoformat(),
        "credit_card": fake.credit_card_full(),
        "profile": fake.paragraph(nb_sentences=3)
    }
# 生成示例數(shù)據(jù)集
users = [generate_user() for _ in range(5)]
for user in users:
    print(json.dumps(user, ensure_ascii=False, indent=2))

pip install faker

from faker import Faker
# 創(chuàng)建Faker實例
fake = Faker()  # 默認英語
# fake = Faker('zh_CN')  # 中文
# fake = Faker(['zh_CN', 'en_US'])  # 多語言
# 生成基本數(shù)據(jù)
print(fake.name())          # 姓名
print(fake.address())       # 地址
print(fake.text())          # 文本段落
print(fake.email())         # 電子郵件
print(fake.date())          # 日期

# 使用中文區(qū)域設(shè)置
fake_cn = Faker('zh_CN')
print(f"中文姓名: {fake_cn.name()}")
print(f"中文地址: {fake_cn.address()}")
print(f"中文手機: {fake_cn.phone_number()}")
# 日本區(qū)域設(shè)置
fake_jp = Faker('ja_JP')
print(f"日本姓名: {fake_jp.name()}")
print(f"日本地址: {fake_jp.address()}")
# 多語言支持
multi_fake = Faker(['en_US', 'zh_CN', 'ja_JP'])
print(multi_fake.name())  # 隨機使用一種語言

from faker.providers import BaseProvider
# 創(chuàng)建自定義Provider
class ProductProvider(BaseProvider):
    categories = ['電子產(chǎn)品', '家居用品', '服裝', '食品', '圖書']
    electronic_products = ['手機', '筆記本電腦', '平板', '耳機', '智能手表']
    def product_category(self):
        return self.random_element(self.categories)
    def electronic_product(self):
        return self.random_element(self.electronic_products)
    def product_id(self):
        return f"PRD-{self.random_int(10000, 99999)}"
    def product_with_price(self):
        return {
            'id': self.product_id(),
            'name': f"{self.electronic_product()} {self.random_element(['Pro', 'Max', 'Ultra', 'Lite'])}",
            'price': round(self.random_number(digits=3) + self.random_element([0.99, 0.49, 0.79]), 2),
            'stock': self.random_int(0, 1000)
        }
# 添加Provider到Faker實例
fake = Faker()
fake.add_provider(ProductProvider)
# 使用自定義Provider生成數(shù)據(jù)
print(fake.product_category())
print(fake.electronic_product())
print(fake.product_id())
print(fake.product_with_price())

# 設(shè)置種子以生成一致數(shù)據(jù)
Faker.seed(1234)
fake = Faker()
# 創(chuàng)建用戶與訂單關(guān)聯(lián)數(shù)據(jù)
def create_user_with_orders(user_id):
    user = {
        'id': user_id,
        'name': fake.name(),
        'email': fake.email(),
        'address': fake.address()
    }
    orders = []
    for i in range(fake.random_int(1, 5)):
        order = {
            'order_id': f"ORD-{user_id}-{i+1}",
            'user_id': user_id,
            'date': fake.date_this_year().isoformat(),
            'amount': round(fake.random_number(4)/100, 2),
            'status': fake.random_element(['待付款', '已付款', '已發(fā)貨', '已完成'])
        }
        orders.append(order)
    return user, orders
# 生成3個用戶及其訂單
for i in range(1, 4):
    user, orders = create_user_with_orders(i)
    print(f"用戶: {user}")
    print(f"訂單: {orders}")
    print("---")

import pandas as pd
from faker import Faker
import numpy as np
fake = Faker('zh_CN')
# 創(chuàng)建模擬銷售數(shù)據(jù)
def create_sales_dataframe(rows=1000):
    data = {
        'date': [fake.date_between(start_date='-1y', end_date='today') for _ in range(rows)],
        'product': [fake.random_element(['手機', '電腦', '平板', '耳機', '手表']) for _ in range(rows)],
        'region': [fake.province() for _ in range(rows)],
        'sales_rep': [fake.name() for _ in range(rows)],
        'quantity': [fake.random_int(1, 10) for _ in range(rows)],
        'unit_price': [fake.random_int(100, 5000) for _ in range(rows)]
    }
    df = pd.DataFrame(data)
    # 添加計算列
    df['total'] = df['quantity'] * df['unit_price']
    # 確保日期類型正確
    df['date'] = pd.to_datetime(df['date'])
    # 按日期排序
    df = df.sort_values('date')
    return df
# 創(chuàng)建銷售數(shù)據(jù)框
sales_df = create_sales_dataframe()
print(sales_df.head())
print(sales_df.info())
# 基本統(tǒng)計分析
print(sales_df.groupby('product')['total'].sum())
print(sales_df.groupby('region')['total'].sum().sort_values(ascending=False).head(5))

import json
from faker import Faker
from datetime import datetime, timedelta
fake = Faker()
# 生成API響應(yīng)數(shù)據(jù)
def generate_api_response(num_items=10):
    response = {
        "status": "success",
        "code": 200,
        "timestamp": datetime.now().isoformat(),
        "data": {
            "items": [generate_product() for _ in range(num_items)],
            "pagination": {
                "page": 1,
                "per_page": num_items,
                "total": fake.random_int(100, 500),
                "pages": fake.random_int(5, 50)
            }
        }
    }
    return response
def generate_product():
    return {
        "id": fake.uuid4(),
        "name": f"{fake.color_name()} {fake.random_element(['T恤', '褲子', '鞋', '帽子'])}",
        "description": fake.paragraph(),
        "price": round(fake.random_number(4)/100, 2),
        "category": fake.random_element(["男裝", "女裝", "童裝", "運動", "配飾"]),
        "rating": round(fake.random.uniform(1, 5), 1),
        "reviews_count": fake.random_int(0, 1000),
        "created_at": fake.date_time_this_year().isoformat(),
        "tags": fake.words(nb=fake.random_int(1, 5))
    }
# 生成并保存JSON數(shù)據(jù)
api_data = generate_api_response(5)
print(json.dumps(api_data, indent=2))
# 保存到文件
with open('sample_api_response.json', 'w') as f:
    json.dump(api_data, f, indent=2)

import pandas as pd
import numpy as np
from faker import Faker
from datetime import datetime, timedelta
fake = Faker()
# 生成模擬服務(wù)器監(jiān)控數(shù)據(jù)
def generate_server_metrics(days=30, interval_minutes=15):
    # 計算數(shù)據(jù)點總數(shù)
    total_points = int((days * 24 * 60) / interval_minutes)
    # 生成時間序列
    start_date = datetime.now() - timedelta(days=days)
    timestamps = [start_date + timedelta(minutes=i*interval_minutes) for i in range(total_points)]
    # 創(chuàng)建基礎(chǔ)趨勢數(shù)據(jù)
    base_cpu = np.sin(np.linspace(0, days * np.pi, total_points)) * 15 + 40
    base_memory = np.sin(np.linspace(0, days * np.pi * 2, total_points)) * 10 + 65
    base_disk = np.linspace(60, 85, total_points)  # 緩慢增長趨勢
    # 添加隨機波動
    cpu_usage = base_cpu + np.random.normal(0, 5, total_points)
    memory_usage = base_memory + np.random.normal(0, 3, total_points)
    disk_usage = base_disk + np.random.normal(0, 1, total_points)
    # 模擬偶發(fā)性峰值
    peak_indices = np.random.choice(range(total_points), size=int(total_points*0.01), replace=False)
    cpu_usage[peak_indices] += np.random.uniform(20, 40, size=len(peak_indices))
    memory_usage[peak_indices] += np.random.uniform(15, 25, size=len(peak_indices))
    # 確保數(shù)值在合理范圍內(nèi)
    cpu_usage = np.clip(cpu_usage, 0, 100)
    memory_usage = np.clip(memory_usage, 0, 100)
    disk_usage = np.clip(disk_usage, 0, 100)
    # 創(chuàng)建數(shù)據(jù)框
    df = pd.DataFrame({
        'timestamp': timestamps,
        'cpu_usage': cpu_usage,
        'memory_usage': memory_usage,
        'disk_usage': disk_usage,
        'network_in': np.random.exponential(scale=5, size=total_points),
        'network_out': np.random.exponential(scale=3, size=total_points),
        'server_id': fake.random_element(['srv-01', 'srv-02', 'srv-03', 'srv-04']),
    })
    return df
# 生成服務(wù)器監(jiān)控數(shù)據(jù)
metrics_df = generate_server_metrics(days=7)
print(metrics_df.head())
# 保存到CSV
metrics_df.to_csv('server_metrics.csv', index=False)

from faker import Faker
import random
import json
from datetime import datetime, timedelta
fake = Faker('zh_CN')
# 創(chuàng)建用戶檔案并關(guān)聯(lián)行為數(shù)據(jù)
def generate_user_profile():
    # 基本屬性
    gender = fake.random_element(['男', '女'])
    first_name = fake.first_name_male() if gender == '男' else fake.first_name_female()
    last_name = fake.last_name()
    # 生成用戶出生日期，年齡范圍18-65
    birth_date = fake.date_of_birth(minimum_age=18, maximum_age=65)
    age = (datetime.now().date() - birth_date).days // 365
    # 生成地理位置
    province = fake.province()
    city = fake.city()
    # 創(chuàng)建興趣標簽
    interests = fake.random_elements(
        elements=('旅游', '美食', '健身', '閱讀', '電影', '音樂', '攝影', '游戲', '購物', '投資', '科技', '體育'),
        length=random.randint(2, 5),
        unique=True
    )
    # 隨機收入水平
    income_levels = ['5000以下', '5000-10000', '10000-20000', '20000-30000', '30000以上']
    income = fake.random_element(income_levels)
    # 學(xué)歷水平
    education_levels = ['高中', '大專', '本科', '碩士', '博士']
    education = fake.random_element(education_levels)
    # 職業(yè)類別
    job = fake.job()
    # 用戶行為數(shù)據(jù)
    visit_frequency = random.randint(1, 30)  # 每月訪問次數(shù)
    avg_session_time = random.randint(60, 3600)  # 平均會話時長(秒)
    # 偏好數(shù)據(jù)
    preferred_categories = fake.random_elements(
        elements=('電子產(chǎn)品', '服裝', '家居', '食品', '美妝', '圖書', '運動', '母嬰'),
        length=random.randint(1, 4),
        unique=True
    )
    # 最近登錄數(shù)據(jù)
    last_login = fake.date_time_between(start_date='-30d', end_date='now').isoformat()
    # 購買行為
    purchase_count = random.randint(0, 20)
    # 模擬幾次購買記錄
    purchases = []
    if purchase_count > 0:
        for _ in range(min(5, purchase_count)):
            purchase_date = fake.date_time_between(start_date='-1y', end_date='now')
            purchases.append({
                'purchase_id': fake.uuid4(),
                'date': purchase_date.isoformat(),
                'amount': round(random.uniform(50, 2000), 2),
                'items': random.randint(1, 10),
                'category': fake.random_element(preferred_categories) if preferred_categories else '未分類'
            })
    # 組裝完整檔案
    profile = {
        'user_id': fake.uuid4(),
        'username': fake.user_name(),
        'name': f"{last_name}{first_name}",
        'gender': gender,
        'birth_date': birth_date.isoformat(),
        'age': age,
        'email': fake.email(),
        'phone': fake.phone_number(),
        'location': {
            'province': province,
            'city': city,
            'address': fake.address()
        },
        'demographics': {
            'income': income,
            'education': education,
            'occupation': job
        },
        'interests': interests,
        'behavior': {
            'visit_frequency': visit_frequency,
            'avg_session_time': avg_session_time,
            'preferred_categories': preferred_categories,
            'last_login': last_login
        },
        'purchases': {
            'count': purchase_count,
            'total_spent': round(sum(p['amount'] for p in purchases), 2) if purchases else 0,
            'recent_items': purchases
        },
        'registration_date': fake.date_time_between(start_date='-5y', end_date='-1m').isoformat(),
        'is_active': fake.boolean(chance_of_getting_true=90)
    }
    return profile
# 生成10個用戶檔案
users = [generate_user_profile() for _ in range(10)]
# 打印用戶檔案示例
print(json.dumps(users[0], ensure_ascii=False, indent=2))

# 在Django項目的management/commands/generate_fake_data.py中
from django.core.management.base import BaseCommand
from faker import Faker
from django.contrib.auth.models import User
from myapp.models import Profile, Product, Order, OrderItem
import random
from django.utils import timezone
from datetime import timedelta
class Command(BaseCommand):
    help = '生成測試數(shù)據(jù)'
    def add_arguments(self, parser):
        parser.add_argument('--users', type=int, default=50, help='用戶數(shù)量')
        parser.add_argument('--products', type=int, default=100, help='產(chǎn)品數(shù)量')
        parser.add_argument('--orders', type=int, default=200, help='訂單數(shù)量')
    def handle(self, *args, **options):
        fake = Faker('zh_CN')
        num_users = options['users']
        num_products = options['products']
        num_orders = options['orders']
        self.stdout.write(self.style.SUCCESS(f'開始生成{num_users}個用戶...'))
        # 生成用戶和個人資料
        for i in range(num_users):
            username = fake.user_name()
            # 避免用戶名重復(fù)
            while User.objects.filter(username=username).exists():
                username = fake.user_name()
            user = User.objects.create_user(
                username=username,
                email=fake.email(),
                password='password123',  # 開發(fā)環(huán)境固定密碼方便測試
                first_name=fake.first_name(),
                last_name=fake.last_name(),
                date_joined=fake.date_time_between(start_date='-2y', end_date='now')
            )
            profile = Profile.objects.create(
                user=user,
                phone_number=fake.phone_number(),
                address=fake.address(),
                bio=fake.paragraph(),
                birth_date=fake.date_of_birth(minimum_age=18, maximum_age=80)
            )
        self.stdout.write(self.style.SUCCESS(f'生成{num_users}個用戶完成!'))
        # 生成產(chǎn)品
        self.stdout.write(self.style.SUCCESS(f'開始生成{num_products}個產(chǎn)品...'))
        categories = ['電子產(chǎn)品', '服裝', '家居', '食品', '美妝', '圖書', '運動', '母嬰']
        for i in range(num_products):
            category = random.choice(categories)
            Product.objects.create(
                name=f"{fake.word().title()} {fake.random_element(['Pro', 'Plus', 'Max', 'Mini'])}",
                description=fake.paragraph(),
                price=round(random.uniform(10, 5000), 2),
                stock=random.randint(0, 1000),
                category=category,
                sku=f"SKU-{fake.random_number(digits=6)}",
                created_at=fake.date_time_between(start_date='-1y', end_date='now'),
                is_active=fake.boolean(chance_of_getting_true=90)
            )
        self.stdout.write(self.style.SUCCESS(f'生成{num_products}個產(chǎn)品完成!'))
        # 生成訂單和訂單項
        self.stdout.write(self.style.SUCCESS(f'開始生成{num_orders}個訂單...'))
        users = list(User.objects.all())
        products = list(Product.objects.all())
        for i in range(num_orders):
            user = random.choice(users)
            order_date = fake.date_time_between(start_date='-1y', end_date='now')
            status_choices = ['pending', 'processing', 'shipped', 'delivered', 'cancelled']
            status = random.choice(status_choices)
            # 根據(jù)訂單狀態(tài)設(shè)置相應(yīng)日期
            placed_at = order_date
            processed_at = placed_at + timedelta(hours=random.randint(1, 24)) if status != 'pending' else None
            shipped_at = processed_at + timedelta(days=random.randint(1, 3)) if status in ['shipped', 'delivered'] else None
            delivered_at = shipped_at + timedelta(days=random.randint(1, 5)) if status == 'delivered' else None
            order = Order.objects.create(
                user=user,
                status=status,
                placed_at=placed_at,
                processed_at=processed_at,
                shipped_at=shipped_at,
                delivered_at=delivered_at,
                shipping_address=fake.address(),
                payment_method=fake.random_element(['credit_card', 'debit_card', 'paypal', 'alipay', 'wechat_pay']),
                shipping_fee=round(random.uniform(0, 50), 2)
            )
            # 為每個訂單生成1-5個訂單項
            items_count = random.randint(1, 5)
            order_products = random.sample(products, items_count)
            for product in order_products:
                quantity = random.randint(1, 5)
                price_at_purchase = product.price * (1 - random.uniform(0, 0.2))  # 模擬折扣
                OrderItem.objects.create(
                    order=order,
                    product=product,
                    quantity=quantity,
                    price_at_purchase=round(price_at_purchase, 2)
                )
            # 計算并更新訂單總金額
            order.total_amount = sum(item.quantity * item.price_at_purchase for item in order.items.all())
            order.save()
        self.stdout.write(self.style.SUCCESS(f'生成{num_orders}個訂單完成!'))
        self.stdout.write(self.style.SUCCESS('所有測試數(shù)據(jù)生成完成!'))

# 較慢的方式
[Faker().name() for _ in range(10000)]
# 更快的方式
fake = Faker()
[fake.name() for _ in range(10000)]

def user_generator(count):
    fake = Faker()
    for _ in range(count):
        yield {
            "name": fake.name(),
            "email": fake.email(),
            "address": fake.address()
        }
# 使用生成器迭代而不是一次性加載所有數(shù)據(jù)
for user in user_generator(1000000):
    process_user(user)  # 一次處理一條數(shù)據(jù)