数据转换步骤说明

179 浏览
16 试用
3 购买
Oct 16, 2025更新

提供清晰准确的数据转换步骤,适用于技术写作风格。

以下为将数据从 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.
  1. 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.
  1. 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.
  1. 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).
  1. 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.
  1. 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.
  1. 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.
  1. 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).
  1. 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.
  1. 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: AIA. SmithB. Lee240
  • 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.

示例详情

解决的问题

用最短时间,产出“从任意源格式到目标格式”的标准化转换步骤与可执行SOP;根据你的源格式、目标格式与期望语言自动生成清晰流程,覆盖准备、预处理、规则映射、转换执行、质量校验与问题处置,确保可读、可复用、可落地。帮助数据与业务团队减少沟通成本与返工,缩短交付周期,显著降低错误率,并以专业文档形式支持跨团队协作与知识沉淀。

适用用户

数据工程师

快速产出数据迁移与整合方案,生成字段映射、预处理与校验步骤,统一执行标准,显著减少返工与沟通成本。

数据分析负责人

为新报表或模型搭建可靠数据底座,用转换说明对接多源数据,明确口径与验证方法,提升结论可信度。

技术文档写作者

将复杂数据转换过程写成易读的操作文档与培训材料,自动生成检查清单与风险提示,加快发布与落地。

特征总结

一键生成从源到目标的全流程转换指南,覆盖准备、映射、执行与验证,缩短方案制定时间。
自动识别字段差异与命名规范,给出映射建议与改进措施,降低手工比对成本与出错率。
智能给出清洗、去重、缺失值处理等预处理步骤,配优先级与说明,确保转换后数据可用。
结构化输出转换步骤、检查清单与风险提醒,文档可直接用于标准操作与交付,促进跨团队协作。
支持按源格式、目标格式与语言定制,一键生成适配不同项目与地区的说明,减少重复写作。
自动附带质量校验与验收标准,如一致性、完整性与稽核方法,保障流程可追溯与结果可信。
以通俗、清晰、逻辑化的表达拆解复杂转换,让非技术干系人也能理解并参与评审与决策。
紧贴业务目标,在步骤中标注对报表、营销、客服等应用的影响点,指导后续落地与效果评估。

如何使用购买的提示词模板

1. 直接在外部 Chat 应用中使用

将模板生成的提示词复制粘贴到您常用的 Chat 应用(如 ChatGPT、Claude 等),即可直接对话使用,无需额外开发。适合个人快速体验和轻量使用场景。

2. 发布为 API 接口调用

把提示词模板转化为 API,您的程序可任意修改模板参数,通过接口直接调用,轻松实现自动化与批量处理。适合开发者集成与业务系统嵌入。

3. 在 MCP Client 中配置使用

在 MCP client 中配置对应的 server 地址,让您的 AI 应用自动调用提示词模板。适合高级用户和团队协作,让提示词在不同 AI 工具间无缝衔接。

AI 提示词价格
¥15.00元
先用后买,用好了再付款,超安全!

您购买后可以获得什么

获得完整提示词模板
- 共 257 tokens
- 3 个可调节参数
{ 源数据格式 } { 目标数据格式 } { 输出语言 }
获得社区贡献内容的使用权
- 精选社区优质案例,助您快速上手提示词
限时免费

不要错过!

免费获取高级提示词-优惠即将到期

17
:
23
小时
:
59
分钟
:
59