数据转换步骤说明

以下为将数据从 CSV 转换为 Parquet 的标准化步骤与示例。内容涵盖前期勘探、模式设计、预处理、写出与验证，并提供多种实现方案（PyArrow、Spark、DuckDB），以保证在不同规模与场景下的准确与高效。

一、前期勘探（源CSV）
- 确认文件属性：
  - 字符编码：推荐统一为 UTF-8（处理 BOM）。
  - 分隔符与引号：如逗号、制表符，quote 与 escape 字符；是否包含多行字段（multi-line）。
  - 标题行：是否存在 header，列名是否唯一、是否含空格或特殊字符。
  - 缺失值标记：空字符串、NA、NULL、N/A 等。
- 数据类型线索：
  - 数值列是否含千分位或区域性格式（例如“1,234.56”）。
  - 日期时间格式与时区（ISO8601、yyyy-MM-dd、带偏移等）。
  - 金额或高精度数值列是否需要定点小数（Decimal）。
- 规模与资源：
  - 文件大小与行数，是否需要分块（chunk/streaming）读取来降低内存压力。

二、目标 Parquet 模式与存储策略
- 列类型映射（尽量显式定义，避免自动推断误差）：
  - 整数：int32/int64；若需保留空值，使用支持空值的类型（如 pandas 的 Nullable Int 类型）。
  - 浮点：float32/float64；对金额建议使用 Decimal(precision, scale) 而非浮点。
  - 布尔：boolean；注意 CSV 中的“true/false/0/1/是/否”等归一化。
  - 字符串：utf8；必要时分类编码（dictionary）以提升压缩比。
  - 日期时间：date32、timestamp(ms/us, tz)；保持单位与时区一致。
- 压缩与编码：
  - 压缩：优先使用 Snappy（平衡速度与体积）或 ZSTD（更高压缩比，适度增加CPU）。
  - 字典编码：对低基数字符串启用字典（提升压缩与扫描性能）。
- 分区与文件切分：
  - 分区列：如 dt（日期）、region 等，便于下游分区裁剪（partition pruning）。
  - 目标文件大小：建议 128MB–512MB（大数据场景更高效）。
  - 行组（row group）大小：适度设置以平衡 IO 与并行度。

三、数据预处理
- 列名标准化：去除前后空格，替换非法字符，处理重复列名。
- 值清洗与类型转换：
  - 统一缺失值标记为 NA/None。
  - 去除千分位与本地化格式，标准化小数点。
  - 解析日期时间并对齐时区。
- 质量检查：
  - 基本统计：行数、空值比例、取值范围、唯一值计数等。
  - 规则校验：ID 唯一性、金额非负等业务约束。

四、实现方法与示例

方法A：Python + PyArrow（适合本地或中小规模数据，支持流式写出）
- 依赖安装：pip install pyarrow
- 读取与写出（一次性读入）：
  - 示例（明确类型、压缩、字典编码）：
    import pyarrow as pa
    import pyarrow.csv as csv
    import pyarrow.parquet as pq

    read_options = csv.ReadOptions()  # 可设置 block_size 等
    parse_options = csv.ParseOptions(delimiter=',', quote_char='"', escaping=True, newlines_in_values=True)
    convert_options = csv.ConvertOptions(column_types={
        'id': pa.int64(),
        'ts': pa.timestamp('ms', tz='UTC'),
        'amount': pa.decimal128(18, 2),
        'dt': pa.string()
    }, strings_can_be_null=True)

    table = csv.read_csv('input.csv', read_options=read_options, parse_options=parse_options, convert_options=convert_options)
    pq.write_table(table, 'output.parquet', compression='zstd', use_dictionary=True, write_statistics=True)
- 流式写出（大文件，降低内存占用）：
    reader = csv.open_csv('input.csv', read_options=read_options, parse_options=parse_options, convert_options=convert_options)
    import pyarrow.parquet as pq
    with pq.ParquetWriter('output.parquet', reader.schema, compression='zstd', use_dictionary=True) as writer:
        for batch in reader:
            writer.write_batch(batch)
- 分区写出（数据集目录结构）：
  - 使用 pyarrow.dataset.write_dataset(table, base_dir='parquet_dataset', format='parquet', partitioning=['dt'])
  - 注意：根据 PyArrow 版本选择适当的 partitioning API，确保分区列在 schema 中。

方法B：Apache Spark（适合超大规模、分布式场景）
- 明确 schema，禁用或减少自动推断：
    from pyspark.sql.types import StructType, StructField, LongType, TimestampType, DecimalType, StringType

    schema = StructType([
        StructField('id', LongType(), True),
        StructField('ts', TimestampType(), True),
        StructField('amount', DecimalType(18, 2), True),
        StructField('dt', StringType(), True),
    ])

    df = (spark.read
        .option('header', True)
        .option('multiLine', True)
        .option('escape', '\\')
        .option('quote', '"')
        .option('delimiter', ',')
        .schema(schema)
        .csv('input.csv'))

    spark.conf.set('spark.sql.parquet.compression.codec', 'zstd')

    (df
     .repartition('dt')  # 按分区列重分区以均衡输出
     .write
     .mode('overwrite')
     .partitionBy('dt')
     .parquet('parquet_dataset'))
- 注意事项：
  - 若 CSV 包含本地化数字或复杂清洗逻辑，先在 DataFrame 中进行清洗再写出。
  - 通过 checkpoint 或 cache 控制血缘与内存使用。

方法C：DuckDB（轻量、快速、易用；本地批处理很高效）
- 单文件写出：
    COPY (SELECT
              CAST(id AS BIGINT),
              CAST(ts AS TIMESTAMP),
              CAST(amount AS DECIMAL(18,2)),
              dt
          FROM read_csv_auto('input.csv', header=True))
    TO 'output.parquet' (FORMAT PARQUET, COMPRESSION ZSTD);
- 分区写出（按 dt 分区）：
    COPY (SELECT ... FROM read_csv_auto('input.csv', header=True))
    TO 'parquet_dataset' (FORMAT PARQUET, COMPRESSION ZSTD, PARTITION_BY (dt));
- 说明：
  - 可通过 SELECT 中的 CAST 明确类型，避免自动推断偏差。
  - 支持在 SQL 中进行数据清洗与校验。

五、验证与一致性检查
- 基本一致性：
  - 行数对比：CSV 与 Parquet 读取后的行数一致。
  - 空值率与类型：检查列类型与空值分布是否与预期一致。
- 统计校验：
  - 数值列的总和、最小值、最大值比对。
  - 随机抽样比对若干行的字段值。
- 元数据检查：
  - 检查分区目录结构与分区字段取值。
  - 查看 Parquet 文件大小与行组信息（便于性能优化）。

六、性能与兼容性要点
- 压缩选择：
  - Snappy：平衡速度与体积，广泛兼容。
  - ZSTD：更高压缩比，CPU占用略增；可调级别（一般 3–6 即可）。
- 行组与文件大小：
  - 针对大数据平台，目标文件大小建议 128MB–512MB。
  - 行组大小影响并行度与扫描效率，可根据列宽与查询模式调整。
- 时间戳与时区：
  - 使用统一的时间单位（ms 或 us）与时区；必要时在读取端显式转换。
  - 避免使用过时的 INT96 时间戳，除非特定旧系统要求。
- 字典编码：
  - 低基数字符串列开启字典编码提升压缩与查询性能。
- 兼容性：
  - 下游系统（Spark、Presto、Hive、Arrow）基本均支持标准 Parquet；若有老版本限制，按需调整时间戳或压缩编码。

七、常见问题与处理建议
- 自动推断导致类型错误：显式指定 schema/column_types，避免字符串化或浮点化（尤其整数列因缺失值转为浮点）。
- 本地化数值与日期解析失败：统一格式后再转换；对金额使用 Decimal。
- 多行字段/转义问题：正确设置 CSV 解析参数（quote、escape、newlines_in_values）。
- 字符编码不统一：转换为 UTF-8 并清理非法字节。
- 超大文件内存瓶颈：使用流式/分块读取与写出（PyArrow Streaming、Spark 分布式、DuckDB 流式 SQL）。

通过以上步骤与实践，可在确保类型准确、压缩高效与分区合理的前提下，将 CSV 可靠地转换为 Parquet，满足大数据分析与下游挖掘任务的性能与兼容性要求。

以下为将数据从 XLSX 转换为 JSON 的可操作步骤与注意事项，面向数据挖掘场景，强调结构设计、数据清洗与可靠转换。

一、明确输出需求与JSON结构设计
- 记录粒度：明确一行代表一个实体（例如“用户”、“订单”），或需拆分/聚合。
- 主键与索引：选定可唯一标识记录的字段（如ID），是否需要作为字典键或仅保留为属性。
- 结构形式：
  - 扁平对象数组（常用）：[{"colA": "...", "colB": ...}, ...]
  - JSON Lines（大数据友好）：每行一个JSON对象，便于流式处理和增量加载。
  - 多工作表：为每个工作表生成一个键（如{"Sheet1": [...], "Sheet2": [...]}）。
  - 嵌套对象：若列表达层级关系（如user.name, user.email），需在转换时组装嵌套结构。
- 字段命名规范：统一小写、下划线或驼峰，避免空格与特殊字符，确保数据管道可读性。

二、数据准备与清洗（在转换前完成）
- 标题行识别：确认第一行是否为列名；若非，指定header位置或提供列名映射。
- 类型控制：
  - ID/编码类：以字符串读取，保留前导零（如"00123"）。
  - 日期时间：统一为ISO 8601（如"2023-07-21T10:15:00Z"），避免Excel序列号泄露。
  - 数值与货币：确认小数精度；百分比字段明确是否保留为小数（0.05）或转换为百分数（5）。
  - 布尔：将“是/否”“Y/N”等映射为 true/false。
- 缺失值规范：统一映射为空值 null，避免混用空字符串/NaN。
- 公式处理：将公式单元格转换为静态值，或确保工作簿重新计算并保存；否则可能读取到公式字符串或过期的缓存结果。
- 合并单元格：合并区域仅在左上角存值；按业务需要进行前向填充（forward-fill）以补齐空单元格。
- 空行/空列/隐藏行列：清理不用的行列；根据需求决定是否忽略隐藏内容。
- 去重与一致性：按主键或关键字段去重；统一单位与编码（如货币单位、地域代码）。
- 安全审查：剔除不必要的敏感字段，符合数据治理要求。

三、实现方法一：Python + pandas（适合中等规模文件）
- 适用场景：单表或多表、数万到百万级行、内存可容纳。
- 步骤与示例（单工作表，输出为数组JSON）：
  1) 安装依赖：pip install pandas openpyxl
  2) 读取与类型控制：
     - 指定需要字符串读取的列，避免前导零丢失。
     - 指定需要解析为日期的列。
  3) 缺失值与格式处理：
     - 将NaN/空字符串统一为None，以在JSON中成为null。
     - 统一日期为ISO字符串。
  4) 导出为JSON。

示例代码（单表 -> records）：
import pandas as pd

xlsx_path = "data.xlsx"
sheet = "Sheet1"  # 或具体工作表名
# 需要以字符串读取的列
string_cols = ["id", "code"]

# 读取
df = pd.read_excel(
    xlsx_path,
    sheet_name=sheet,
    dtype={col: "string" for col in string_cols},  # 保留前导零
    engine="openpyxl"
)

# 可选：解析日期列（若Excel中为文本或数值）
# df["date_col"] = pd.to_datetime(df["date_col"], errors="coerce")

# 处理缺失值为None（JSON中输出为null）
df = df.where(df.notnull(), None)

# 导出为UTF-8 JSON数组，日期用ISO格式
json_str = df.to_json(orient="records", force_ascii=False, date_format="iso")
with open("data.json", "w", encoding="utf-8") as f:
    f.write(json_str)

- 多工作表输出为字典：
sheets = pd.read_excel(xlsx_path, sheet_name=None, engine="openpyxl")
out = {}
for name, df in sheets.items():
    df = df.where(df.notnull(), None)
    out[name] = df.to_dict(orient="records")

import json
with open("data_multi_sheets.json", "w", encoding="utf-8") as f:
    json.dump(out, f, ensure_ascii=False)

- 嵌套结构（列名含.号生成子对象）：
def nest_record(rec):
    out = {}
    for k, v in rec.items():
        if "." in k:
            p, c = k.split(".", 1)
            out.setdefault(p, {})[c] = v
        else:
            out[k] = v
    return out

records = [nest_record(r) for r in df.to_dict(orient="records")]
with open("data_nested.json", "w", encoding="utf-8") as f:
    json.dump(records, f, ensure_ascii=False)

四、实现方法二：流式转换（适合超大文件，避免内存占用）
- 适用场景：数百万行以上或内存受限；生成JSON Lines便于管道处理。
- 步骤：用openpyxl的只读模式逐行遍历，输出.ndjson/.jsonl。
示例代码（单表 -> JSON Lines）：
from openpyxl import load_workbook
import json

wb = load_workbook("data.xlsx", read_only=True, data_only=True)
ws = wb["Sheet1"]

rows = ws.iter_rows(values_only=True)
headers = [cell for cell in next(rows)]

with open("data.jsonl", "w", encoding="utf-8") as f:
    for row in rows:
        obj = {}
        for h, v in zip(headers, row):
            # 空值规范化
            if v == "" or v is None:
                obj[h] = None
            else:
                obj[h] = v
        f.write(json.dumps(obj, ensure_ascii=False) + "\n")

- 注意：
  - data_only=True会读取公式的缓存结果；确保工作簿已保存且计算结果最新。
  - 合并单元格需自行补值（如对特定列执行前向填充）。
  - 日期类型如为datetime，将直接序列化为字符串；如需ISO规范，可统一格式化。

五、质量验证与审计
- 结构与语法：
  - 使用jq或Python json模块验证：jq . data.json >/dev/null 或尝试json.loads逐条加载JSON Lines。
- 完整性与一致性：
  - 记录数比对：Excel行数（剔除标题与空行）与JSON对象数一致。
  - 主键重复检查与缺失检查。
  - 类型抽样核对：日期、数值精度、布尔、前导零保持情况。
  - 特殊值与错误值：Excel中的错误（#N/A等）是否正确映射为null或标记。
- 编码与国际化：
  - 确认为UTF-8输出；非ASCII字符完整无损。
- 变更可追溯：
  - 保留转换日志：源文件名、工作表、行计数、清洗规则、时间戳。

六、常见问题与处理建议
- 前导零丢失：为对应列指定dtype为字符串；转换后抽样核对。
- 日期异常为整数：Excel日期序列需显式解析为日期；统一为ISO 8601。
- 百分比与货币：明确单位与表达方式（小数还是百分数）；必要时在转换前做派生字段。
- 合并单元格导致空值：使用forward-fill在分组列（如类别、地区）上填充。
- 公式读取为字符串或旧值：在Excel中将公式“粘贴为值”或重新计算后保存；流式读取时使用data_only=True并确保缓存刷新。
- 大文件OOM：采用JSON Lines流式输出；或分工作表/分批转换；必要时先导出为CSV再做流式JSON转换。

七、输出格式选择建议
- 小中规模：JSON数组（orient="records"）便于一次性加载与下游建模。
- 大规模或管道处理：JSON Lines（.jsonl/.ndjson），每行一个对象，易于分布式摄取与增量更新。
- 多表：字典封装或分别生成多个文件，按下游消费方式决定。

按以上步骤实施，可确保从 XLSX 到 JSON 的转换在结构、类型与质量上满足数据挖掘下游使用需求。

Below is a practical, end-to-end procedure to convert data from XML to JSON in a way that is robust, analyzable, and suitable for data mining workflows.

1) Define objectives and constraints
- Identify downstream consumers and use cases (analytics, ML features, search indexing).
- Decide whether you need a faithful structural representation (document-centric) or a normalized/flattened representation (data-centric).
- Determine acceptable data loss (e.g., dropping XML comments) and ordering requirements.

2) Inspect and profile the XML
- Collect representative samples and any XML Schema (XSD) or DTD.
- Profile structure: element paths, attribute usage, cardinalities, namespaces, and data types.
- Identify large or repeating sections that may require streaming or batching.

3) Design mapping rules from XML to JSON
Establish consistent, explicit rules. Document them and keep them versioned.

- Root and records:
  - Choose whether each XML document maps to one JSON object or to a stream of JSON objects (e.g., JSON Lines for large datasets).
  - If there are repeating “record” elements, map each to an individual JSON object.

- Elements vs attributes:
  - Elements → JSON objects/fields.
  - Attributes → fields on the parent object, with a naming convention if needed (e.g., attribute id → id; or prefix with @id to avoid collisions).
  - Decide how to resolve name collisions between element names and attribute names.

- Repeated elements:
  - Multiple sibling elements with the same name → JSON arrays.

- Text content:
  - Simple text-only elements → field with a scalar value.
  - Mixed content (text interleaved with child elements) → represent as an array of strings/objects, or normalize to text if safe for your use case.

- Namespaces:
  - Decide to preserve prefixes (e.g., dc:title) or map qualified names to unprefixed keys via a lookup table.
  - Avoid colons in keys if downstream tools have constraints; map to dc_title or use nested objects.

- Data typing:
  - Convert strings to typed values where possible: integer, float, boolean, date/time.
  - Define precise parsing rules and formats (e.g., ISO-8601 for timestamps).
  - Preserve leading zeros when they are identifiers (e.g., keep as string to avoid 00123 → 123).

- Missing and null:
  - Distinguish absent elements, present-but-empty elements, and explicit nulls.
  - Decide whether to omit missing fields or include them as null/empty arrays.

- IDs and references:
  - For ID/IDREF or cross-references, decide whether to keep as strings, resolve to nested objects, or emit link structures to support joins later.

- Ordering:
  - JSON objects are unordered; if order matters, represent ordered collections as arrays with explicit order.

- Metadata and provenance:
  - Include source document identifiers, extraction timestamps, and schema versions to support lineage and reproducibility.

4) Plan normalization and flattening (for analytics)
- Decide which nested structures to flatten into top-level fields for feature engineering.
- If needed, produce both:
  - A raw JSON representation (faithful to XML).
  - A curated, analytics-ready JSON (flattened, typed, denormalized).

5) Choose implementation approach and tools
- Small/medium files (in-memory):
  - Python: xmltodict (quick), ElementTree or lxml for more control.
  - Java: Jackson XML module (XmlMapper) → Jackson JSON.
- Large files/streams:
  - Streaming parsers: SAX/StAX (Java), iterparse (Python lxml), ijson for JSON streaming.
  - Produce JSON Lines (one JSON object per line) for scalable processing.
- XSLT/XPath:
  - For schema-driven transformations, XSLT 3.0/XPath 3.1 can build maps/arrays and serialize to JSON (e.g., via fn:serialize with JSON method; processor-specific options apply).
- Command-line (ad hoc):
  - xmlstarlet (XML processing), combined with scripts.
  - yq/xq wrappers (often built on xmltodict) for quick conversions; validate correctness before production use.

6) Implement the transformation
- Parsing:
  - Disable external entity resolution and DTD processing to mitigate XXE and entity expansion attacks.
  - Normalize character encoding to UTF-8.

- Transformation logic (core steps):
  - Walk the XML tree or stream events.
  - For each element:
    - Create an object with fields from attributes (per your naming convention).
    - Process child elements; collect repeated names into arrays.
    - Assign text content to a value field when the element has only text.
  - Apply data type conversions according to rules.
  - Handle namespaces and name mapping.
  - Output the object according to your target format (single JSON, array, or JSON Lines).

- Performance:
  - Stream large repeating sections to avoid holding the full tree in memory.
  - Batch outputs and flush periodically.
  - Consider parallelizing by record where ordering is not required.

7) Validate and test
- Structural validation:
  - Validate XML against XSD if available to catch bad inputs early.
  - Validate JSON against a JSON Schema that encodes your mapping rules and types.

- Data correctness:
  - Unit tests for tricky cases: attributes vs elements, repeated elements, mixed content, namespaces, and type conversions.
  - Spot-check samples: compare original XML values and their JSON counterparts.
  - Check counts: number of records, array lengths, and presence of required fields.

- Regression tests:
  - Fix the mapping rules and test against historical samples to ensure stability.

8) Handle edge cases
- Mixed content: decide whether to preserve structure or normalize to text; document the choice.
- Significant whitespace and CDATA: define normalization rules; avoid accidental trimming of meaningful whitespace.
- Very large integers and floating-point precision: consider using strings if precision must be exact.
- Binary content (base64/hex): keep as strings or extract and store externally with references.
- Comments and processing instructions: typically dropped; include only if explicitly required (e.g., as metadata).

9) Output and packaging
- Format:
  - For batch analytics: JSON Lines (one object per line) is preferred for scalability.
  - For API or single-document use: a single JSON object or array.
- Encoding: UTF-8 without BOM.
- Pretty-print only for debugging; use compact output in production for size and speed.
- Compression: gzip or zstd for large outputs; compatible with many analytics tools.

10) Document the mapping and lineage
- Provide a mapping specification with examples, data types, and null handling.
- Record tool versions, configuration, and schema versions.
- Maintain change logs to support reproducibility and downstream stability.

Minimal example mapping (descriptive)
- XML: <book id="1"><title lang="en">AI</title><author>A. Smith</author><author>B. Lee</author><pages>240</pages></book>
- JSON (data-centric):
  {
    "id": "1",
    "title": { "value": "AI", "lang": "en" },
    "author": ["A. Smith", "B. Lee"],
    "pages": 240
  }
Notes: attributes mapped to sibling fields; repeated author elements mapped to an array; pages converted to number; title’s language preserved.

Security checklist
- Disable DTD and external entities.
- Limit entity expansion and input size.
- Sanitize or reject unexpected namespaces and structures.
- Log transformation errors with enough context; fail fast or quarantine bad records according to policy.

Following this process yields JSON that is type-safe, consistent, and ready for downstream data mining tasks, while scaling to large datasets and maintaining traceability.