使用pandas库高效输出JSON格式数据的技巧与方法从基础操作到高级应用解决数据转换中的常见问题

威震华夏关云长 · 发表于 2025-10-3 01:30:25

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

在数据分析和处理领域，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其易于阅读和编写、易于机器解析和生成的特点，被广泛应用于Web应用程序和API中。Python的pandas库作为数据分析的强大工具，提供了丰富的功能来处理JSON数据。本文将深入探讨如何使用pandas高效地输出JSON格式数据，从基础操作到高级应用，并解决数据转换过程中可能遇到的常见问题。

1. pandas与JSON基础

1.1 pandas库简介

pandas是Python中一个强大的数据分析库，提供了快速、灵活和富有表现力的数据结构，旨在使数据清洗和分析工作变得更加简单。它主要提供了两种数据结构：Series（一维数组）和DataFrame（二维表格型数据结构）。

1.2 JSON数据格式简介

JSON是一种轻量级的数据交换格式，基于JavaScript的一个子集。它采用完全独立于编程语言的文本格式，但也使用了类似于C语言家族的习惯。JSON数据可以表示为：

• 对象（无序的键/值对集合）
• 数组（有序的值列表）
• 值（字符串、数字、布尔值、null、对象或数组）

1.3 pandas与JSON的结合

pandas提供了read_json()和to_json()两个核心函数，分别用于读取和输出JSON数据。这两个函数提供了丰富的参数选项，可以满足不同场景下的JSON数据处理需求。

2. 基础操作：读取与输出JSON数据

2.1 使用pandas读取JSON数据

pandas的read_json()函数可以将JSON数据转换为DataFrame。以下是基本用法：

import pandas as pd
# 从JSON字符串读取
json_string = '{"name": "John", "age": 30, "city": "New York"}'
df = pd.read_json(json_string, orient='index')
print(df)
# 从JSON文件读取
df = pd.read_json('data.json')
print(df)

复制代码

orient参数是read_json()函数中非常重要的参数，它指定了JSON字符串的预期格式：

• ‘split’：字典包含索引、列和数据
• ‘records’：列表形式的记录，如[{column -> value}, … , {column -> value}]
• ‘index’：字典形式的索引，如{index -> {column -> value}}
• ‘columns’：字典形式的列，如{column -> {index -> value}}
• ‘values’：仅值数组

2.2 使用pandas输出JSON数据

pandas的to_json()方法可以将DataFrame转换为JSON格式。以下是基本用法：

import pandas as pd
# 创建一个DataFrame
data = {'name': ['John', 'Anna', 'Peter'],
'age': [30, 25, 40],
'city': ['New York', 'London', 'Paris']}
df = pd.DataFrame(data)
# 将DataFrame转换为JSON字符串
json_string = df.to_json()
print(json_string)
# 将DataFrame保存为JSON文件
df.to_json('output.json')

复制代码

与read_json()类似，to_json()方法也提供了orient参数，用于指定输出的JSON格式：

# 不同的orient参数示例
print("orient='records':")
print(df.to_json(orient='records'))
print("\norient='index':")
print(df.to_json(orient='index'))
print("\norient='columns':")
print(df.to_json(orient='columns'))
print("\norient='split':")
print(df.to_json(orient='split'))

复制代码

2.3 处理嵌套JSON数据

在实际应用中，我们经常遇到嵌套的JSON数据。pandas可以通过json_normalize()函数处理这种情况：

import pandas as pd
from pandas import json_normalize
# 嵌套JSON数据
nested_json = [
{
"name": "John",
"age": 30,
"contact": {
"email": "john@example.com",
"phone": "123-456-7890"
},
"hobbies": ["reading", "swimming"]
},
{
"name": "Anna",
"age": 25,
"contact": {
"email": "anna@example.com",
"phone": "098-765-4321"
},
"hobbies": ["painting", "traveling"]
}
]
# 使用json_normalize处理嵌套JSON
df = json_normalize(nested_json)
print(df)
# 如果需要进一步处理嵌套的列表或字典
df_hobbies = json_normalize(nested_json, 'hobbies', ['name', 'age'])
print("\nHobbies DataFrame:")
print(df_hobbies)

复制代码

3. 高级应用：复杂JSON数据处理

3.1 自定义JSON输出格式

有时，我们需要按照特定的格式输出JSON数据，这可以通过自定义函数和to_json()的参数组合来实现：

import pandas as pd
import json
# 创建DataFrame
data = {'name': ['John', 'Anna', 'Peter'],
'age': [30, 25, 40],
'city': ['New York', 'London', 'Paris']}
df = pd.DataFrame(data)
# 自定义JSON输出格式
def custom_json_format(df):
# 将DataFrame转换为字典列表
records = df.to_dict(orient='records')
# 添加自定义结构
custom_output = {
"metadata": {
"count": len(df),
"columns": list(df.columns)
},
"data": records
}
return json.dumps(custom_output, indent=4)
# 使用自定义函数
custom_json = custom_json_format(df)
print(custom_json)

复制代码

3.2 处理大型JSON数据

处理大型JSON文件时，内存可能会成为问题。以下是几种处理大型JSON数据的方法：

import pandas as pd
import json
# 假设我们有一个大型JSON文件，包含多个记录
# 我们可以逐行读取并处理
def process_large_json(file_path, chunk_size=1000):
chunks = []
with open(file_path, 'r') as file:
# 假设每行是一个JSON对象
chunk = []
for line in file:
try:
record = json.loads(line.strip())
chunk.append(record)
if len(chunk) >= chunk_size:
df_chunk = pd.DataFrame(chunk)
chunks.append(df_chunk)
chunk = []
except json.JSONDecodeError:
continue
# 处理最后一个可能不满chunk_size的块
if chunk:
df_chunk = pd.DataFrame(chunk)
chunks.append(df_chunk)
# 合并所有块
if chunks:
return pd.concat(chunks, ignore_index=True)
else:
return pd.DataFrame()
# 使用示例
# large_df = process_large_json('large_data.json')

复制代码

import ijson
import pandas as pd
def stream_json_to_dataframe(file_path, path_to_items):
"""
使用ijson流式处理大型JSON文件
参数:
file_path: JSON文件路径
path_to_items: 指向JSON中项目列表的路径，例如'item'或'users.item'
返回:
DataFrame
"""
items = []
with open(file_path, 'rb') as file:
for item in ijson.items(file, path_to_items):
items.append(item)
# 可以在这里添加条件，只收集部分数据
# 或者每N个项目创建一个DataFrame并处理
return pd.DataFrame(items)
# 使用示例
# df = stream_json_to_dataframe('large_data.json', 'users.item')

复制代码

3.3 复杂JSON结构的转换

有时我们需要处理更复杂的JSON结构，如包含嵌套对象和数组的JSON。以下是一些处理方法：

import pandas as pd
import json
from pandas import json_normalize
# 复杂的JSON结构
complex_json = {
"school": "ABC High School",
"students": [
{
"id": 1,
"name": "John",
"grades": {
"math": 90,
"science": 85,
"history": 78
},
"contacts": [
{"type": "email", "value": "john@example.com"},
{"type": "phone", "value": "123-456-7890"}
]
},
{
"id": 2,
"name": "Anna",
"grades": {
"math": 95,
"science": 92,
"history": 88
},
"contacts": [
{"type": "email", "value": "anna@example.com"},
{"type": "phone", "value": "098-765-4321"}
]
}
]
}
# 将复杂的JSON转换为DataFrame
def process_complex_json(json_data):
# 首先提取学生基本信息
students_df = json_normalize(json_data['students'])
# 提取成绩信息
grades_df = json_normalize(
json_data['students'],
'grades',
['id', 'name']
)
# 提取联系信息
contacts_df = json_normalize(
json_data['students'],
'contacts',
['id', 'name']
)
return {
'students': students_df,
'grades': grades_df,
'contacts': contacts_df
}
# 处理复杂JSON
result = process_complex_json(complex_json)
print("Students DataFrame:")
print(result['students'])
print("\nGrades DataFrame:")
print(result['grades'])
print("\nContacts DataFrame:")
print(result['contacts'])

复制代码

3.4 使用pandas和自定义编码器处理特殊数据类型

当DataFrame包含特殊数据类型（如datetime、period等）时，直接转换为JSON可能会导致问题。以下是处理方法：

import pandas as pd
import json
from datetime import datetime
# 创建包含特殊数据类型的DataFrame
data = {
'name': ['John', 'Anna', 'Peter'],
'join_date': [datetime(2020, 1, 1), datetime(2020, 2, 15), datetime(2019, 11, 30)],
'last_active': [pd.Timestamp('2021-01-10'), pd.Timestamp('2021-02-20'), pd.Timestamp('2021-01-05')],
'salary': [50000.50, 60000.75, 75000.25]
}
df = pd.DataFrame(data)
# 自定义JSON编码器
class PandasJSONEncoder(json.JSONEncoder):
def default(self, obj):
if hasattr(obj, 'to_json'):
return obj.to_json()
elif hasattr(obj, 'isoformat'):
return obj.isoformat()
elif isinstance(obj, (pd.Timestamp, pd.Period)):
return str(obj)
return super().default(obj)
# 使用自定义编码器
json_str = json.dumps(df.to_dict(orient='records'), cls=PandasJSONEncoder, indent=2)
print(json_str)
# 或者使用pandas的to_json方法并处理日期
df['join_date'] = df['join_date'].dt.strftime('%Y-%m-%d')
df['last_active'] = df['last_active'].dt.strftime('%Y-%m-%d')
json_str = df.to_json(orient='records', date_format='iso')
print("\nUsing pandas to_json with date formatting:")
print(json_str)

复制代码

4. 常见问题及解决方案

4.1 处理JSON中的日期和时间

问题：JSON不直接支持日期和时间格式，导致在转换过程中可能丢失日期信息或格式不正确。

解决方案：

import pandas as pd
import json
from datetime import datetime
# 创建包含日期的DataFrame
df = pd.DataFrame({
'date': pd.date_range('2020-01-01', periods=3),
'value': [10, 20, 30]
})
# 方法1：在转换为JSON前将日期格式化为字符串
df['date_str'] = df['date'].dt.strftime('%Y-%m-%d')
json_str = df[['date_str', 'value']].to_json(orient='records')
print("Method 1 - Pre-format dates:")
print(json_str)
# 方法2：使用自定义编码器
class DateTimeEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, (datetime, pd.Timestamp)):
return obj.isoformat()
return super().default(obj)
# 转换为字典列表，然后使用自定义编码器
records = df.to_dict(orient='records')
json_str = json.dumps(records, cls=DateTimeEncoder, indent=2)
print("\nMethod 2 - Custom encoder:")
print(json_str)
# 方法3：使用pandas的to_json方法并指定日期格式
json_str = df.to_json(orient='records', date_format='iso')
print("\nMethod 3 - pandas to_json with date_format='iso':")
print(json_str)

复制代码

4.2 处理非ASCII字符

问题：JSON数据中包含非ASCII字符时，可能会出现编码问题。

解决方案：

import pandas as pd
# 创建包含非ASCII字符的DataFrame
df = pd.DataFrame({
'name': ['张三', '李四', '王五'],
'city': ['北京', '上海', '广州'],
'description': ['喜欢运动', '热爱音乐', '爱好阅读']
})
# 方法1：指定ensure_ascii=False
json_str = df.to_json(orient='records', force_ascii=False)
print("Method 1 - force_ascii=False:")
print(json_str)
# 方法2：在保存到文件时指定编码
df.to_json('non_ascii.json', orient='records', force_ascii=False)
# 读取非ASCII JSON文件
df_read = pd.read_json('non_ascii.json', orient='records', encoding='utf-8')
print("\nRead back from file:")
print(df_read)

复制代码

4.3 处理NaN和null值

问题：pandas中的NaN值在转换为JSON时可能需要特殊处理。

解决方案：

import pandas as pd
import numpy as np
import json
# 创建包含NaN值的DataFrame
df = pd.DataFrame({
'id': [1, 2, 3, 4],
'name': ['John', 'Anna', 'Peter', None],
'score': [85, np.nan, 92, 78],
'active': [True, False, None, True]
})
# 方法1：使用to_json的默认行为（NaN转为null）
json_str = df.to_json(orient='records')
print("Method 1 - Default behavior (NaN becomes null):")
print(json_str)
# 方法2：在转换前填充NaN值
df_filled = df.fillna({
'name': 'Unknown',
'score': 0,
'active': False
})
json_str = df_filled.to_json(orient='records')
print("\nMethod 2 - Fill NaN values before conversion:")
print(json_str)
# 方法3：使用自定义处理函数
def custom_nan_handler(obj):
if isinstance(obj, float) and np.isnan(obj):
return None # 或者返回其他自定义值
return obj
records = df.to_dict(orient='records')
json_str = json.dumps(records, default=custom_nan_handler)
print("\nMethod 3 - Custom NaN handler:")
print(json_str)

复制代码

4.4 处理大型DataFrame的内存问题

问题：当处理大型DataFrame时，直接转换为JSON可能会导致内存不足。

解决方案：

import pandas as pd
import json
# 创建一个大型DataFrame（示例中使用小型DataFrame，但原理相同）
df = pd.DataFrame({
'id': range(100000),
'value': [i**2 for i in range(100000)]
})
# 方法1：分块处理并写入文件
def dataframe_to_json_chunks(df, file_path, chunk_size=10000):
with open(file_path, 'w') as f:
f.write('[\n') # 开始JSON数组
for i, chunk in enumerate(np.array_split(df, len(df) // chunk_size + 1)):
if i > 0:
f.write(',\n') # 在块之间添加逗号
chunk_str = chunk.to_json(orient='records')
# 去除开头的'['和结尾的']'，因为我们已经在文件中写了它们
chunk_str = chunk_str[1:-1]
f.write(chunk_str)
f.write('\n]') # 结束JSON数组
# 使用分块方法
# dataframe_to_json_chunks(df, 'large_output.json')
# 方法2：逐行处理
def dataframe_to_json_lines(df, file_path):
with open(file_path, 'w') as f:
for record in df.to_dict(orient='records'):
f.write(json.dumps(record) + '\n')
# 使用逐行方法
# dataframe_to_json_lines(df, 'large_output.jsonl')
# 方法3：使用生成器减少内存使用
def generate_json_records(df):
for record in df.to_dict(orient='records'):
yield json.dumps(record)
# 使用生成器
# with open('large_output.jsonl', 'w') as f:
# for json_record in generate_json_records(df):
# f.write(json_record + '\n')

复制代码

4.5 处理复杂的嵌套结构

问题：当JSON包含复杂的嵌套结构时，直接转换为DataFrame可能会丢失信息或结构混乱。

解决方案：

import pandas as pd
from pandas import json_normalize
import json
# 复杂的嵌套JSON
complex_nested_json = {
"company": "Tech Corp",
"departments": [
{
"name": "Engineering",
"employees": [
{
"id": 1,
"name": "John",
"skills": ["Python", "Java", "SQL"],
"projects": [
{"name": "Project A", "role": "Lead"},
{"name": "Project B", "role": "Developer"}
]
},
{
"id": 2,
"name": "Anna",
"skills": ["JavaScript", "React", "Node.js"],
"projects": [
{"name": "Project C", "role": "Developer"},
{"name": "Project D", "role": "Consultant"}
]
}
]
},
{
"name": "Marketing",
"employees": [
{
"id": 3,
"name": "Peter",
"skills": ["SEO", "Content", "Analytics"],
"projects": [
{"name": "Campaign X", "role": "Manager"},
{"name": "Campaign Y", "role": "Analyst"}
]
}
]
}
]
}
# 方法1：使用json_normalize处理多层嵌套
def process_complex_nested(json_data):
# 首先提取部门信息
departments = []
for dept in json_data['departments']:
dept_info = {
'department_name': dept['name'],
'company': json_data['company']
}
departments.append(dept_info)
dept_df = pd.DataFrame(departments)
# 提取员工信息
employees = []
for dept in json_data['departments']:
for emp in dept['employees']:
emp_info = {
'id': emp['id'],
'name': emp['name'],
'department': dept['name'],
'company': json_data['company'],
'skills': emp['skills']
}
employees.append(emp_info)
emp_df = pd.DataFrame(employees)
# 提取项目信息
projects = []
for dept in json_data['departments']:
for emp in dept['employees']:
for proj in emp['projects']:
proj_info = {
'project_name': proj['name'],
'role': proj['role'],
'employee_id': emp['id'],
'employee_name': emp['name'],
'department': dept['name'],
'company': json_data['company']
}
projects.append(proj_info)
proj_df = pd.DataFrame(projects)
return {
'departments': dept_df,
'employees': emp_df,
'projects': proj_df
}
# 处理复杂嵌套JSON
result = process_complex_nested(complex_nested_json)
print("Departments DataFrame:")
print(result['departments'])
print("\nEmployees DataFrame:")
print(result['employees'])
print("\nProjects DataFrame:")
print(result['projects'])
# 方法2：递归处理嵌套结构
def flatten_json(data, parent_key='', sep='_'):
items = {}
for k, v in data.items():
new_key = f"{parent_key}{sep}{k}" if parent_key else k
if isinstance(v, dict):
items.update(flatten_json(v, new_key, sep=sep))
elif isinstance(v, list):
for i, item in enumerate(v):
if isinstance(item, dict):
items.update(flatten_json(item, f"{new_key}{sep}{i}", sep=sep))
else:
items[f"{new_key}{sep}{i}"] = item
else:
items[new_key] = v
return items
# 使用递归扁平化
flattened = flatten_json(complex_nested_json)
flat_df = pd.DataFrame([flattened])
print("\nFlattened DataFrame:")
print(flat_df)

复制代码

5. 最佳实践和性能优化

5.1 选择合适的orient参数

选择正确的orient参数可以显著提高JSON处理的效率和可读性：

import pandas as pd
import time
# 创建一个中等大小的DataFrame
df = pd.DataFrame({
'id': range(10000),
'name': [f'Name_{i}' for i in range(10000)],
'value': [i**2 for i in range(10000)]
})
# 测试不同orient参数的性能
orients = ['split', 'records', 'index', 'columns', 'values']
results = {}
for orient in orients:
start_time = time.time()
json_str = df.to_json(orient=orient)
end_time = time.time()
results[orient] = {
'time': end_time - start_time,
'size': len(json_str)
}
# 打印结果
print("Performance comparison of different orient parameters:")
for orient, metrics in results.items():
print(f"{orient}: Time = {metrics['time']:.4f}s, Size = {metrics['size']} bytes")

复制代码

5.2 使用压缩技术减少JSON文件大小

对于大型JSON文件，使用压缩可以显著减少存储空间：

import pandas as pd
import gzip
import json
# 创建一个大型DataFrame
df = pd.DataFrame({
'id': range(100000),
'name': [f'Name_{i}' for i in range(100000)],
'value': [i**2 for i in range(100000)]
})
# 方法1：使用gzip压缩
def save_compressed_json(df, file_path):
json_str = df.to_json(orient='records')
with gzip.open(file_path, 'wt', encoding='utf-8') as f:
f.write(json_str)
# 保存压缩的JSON文件
# save_compressed_json(df, 'large_data.json.gz')
# 读取压缩的JSON文件
def read_compressed_json(file_path):
with gzip.open(file_path, 'rt', encoding='utf-8') as f:
json_str = f.read()
return pd.read_json(json_str, orient='records')
# 读取压缩的JSON文件
# df_read = read_compressed_json('large_data.json.gz')
# 方法2：使用pandas的内置压缩支持
df.to_json('large_data.json.gz', orient='records', compression='gzip')
df_read = pd.read_json('large_data.json.gz', orient='records', compression='gzip')

复制代码

5.3 使用多进程处理大型JSON数据

对于非常大的JSON数据集，可以使用多进程来加速处理：

import pandas as pd
import json
from multiprocessing import Pool, cpu_count
import numpy as np
# 创建一个非常大的DataFrame
large_df = pd.DataFrame({
'id': range(1000000),
'name': [f'Name_{i}' for i in range(1000000)],
'value': [i**2 for i in range(1000000)]
})
# 定义处理函数
def process_chunk(chunk):
# 这里可以添加任何需要的数据处理逻辑
# 示例中我们只是将每个值乘以2
chunk['value'] = chunk['value'] * 2
return chunk.to_json(orient='records')
# 使用多进程处理
def parallel_json_processing(df, num_processes=None):
if num_processes is None:
num_processes = cpu_count()
# 将DataFrame分成多个块
chunks = np.array_split(df, num_processes)
# 创建进程池
with Pool(num_processes) as pool:
results = pool.map(process_chunk, chunks)
# 合并结果
combined_json = '[' + ','.join(results) + ']'
return combined_json
# 使用多进程处理
# json_result = parallel_json_processing(large_df)
# df_processed = pd.read_json(json_result)

复制代码

5.4 使用类型优化减少JSON大小

通过优化数据类型，可以减少生成的JSON文件大小：

import pandas as pd
import numpy as np
# 创建一个DataFrame，使用默认数据类型
df_default = pd.DataFrame({
'id': range(10000),
'name': [f'Name_{i}' for i in range(10000)],
'value': [i**2 for i in range(10000)],
'active': [True if i % 2 == 0 else False for i in range(10000)]
})
# 创建一个DataFrame，使用优化的数据类型
df_optimized = pd.DataFrame({
'id': range(10000),
'name': [f'Name_{i}' for i in range(10000)],
'value': [i**2 for i in range(10000)],
'active': [True if i % 2 == 0 else False for i in range(10000)]
})
# 优化数据类型
df_optimized['id'] = pd.to_numeric(df_optimized['id'], downcast='unsigned')
df_optimized['value'] = pd.to_numeric(df_optimized['value'], downcast='integer')
df_optimized['active'] = df_optimized['active'].astype('boolean')
# 比较JSON输出大小
json_default = df_default.to_json(orient='records')
json_optimized = df_optimized.to_json(orient='records')
print(f"Default DataFrame JSON size: {len(json_default)} bytes")
print(f"Optimized DataFrame JSON size: {len(json_optimized)} bytes")
print(f"Size reduction: {((len(json_default) - len(json_optimized)) / len(json_default)) * 100:.2f}%")

复制代码

5.5 使用高效的JSON库

除了标准的json库，还可以使用更高效的JSON处理库：

import pandas as pd
import json
import ujson # 需要安装: pip install ujson
import orjson # 需要安装: pip install orjson
# 创建一个DataFrame
df = pd.DataFrame({
'id': range(10000),
'name': [f'Name_{i}' for i in range(10000)],
'value': [i**2 for i in range(10000)]
})
# 转换为字典列表
records = df.to_dict(orient='records')
# 使用标准json库
import time
start_time = time.time()
json_str = json.dumps(records)
std_time = time.time() - start_time
std_size = len(json_str)
# 使用ujson
start_time = time.time()
ujson_str = ujson.dumps(records)
ujson_time = time.time() - start_time
ujson_size = len(ujson_str)
# 使用orjson
start_time = time.time()
orjson_bytes = orjson.dumps(records)
orjson_time = time.time() - start_time
orjson_size = len(orjson_bytes)
# 比较结果
print(f"Standard json: Time = {std_time:.4f}s, Size = {std_size} bytes")
print(f"ujson: Time = {ujson_time:.4f}s, Size = {ujson_size} bytes")
print(f"orjson: Time = {orjson_time:.4f}s, Size = {orjson_size} bytes")

复制代码

6. 结论

本文详细介绍了使用pandas库高效输出JSON格式数据的技巧与方法，从基础操作到高级应用，并解决了数据转换中的常见问题。我们学习了如何：

1. 使用pandas的read_json()和to_json()函数进行基本的JSON数据读取和输出
2. 处理嵌套JSON数据，包括使用json_normalize()函数
3. 实现自定义JSON输出格式，满足特定需求
4. 处理大型JSON数据，包括分块处理和流式处理
5. 解决常见问题，如日期时间处理、非ASCII字符、NaN值处理等
6. 优化性能，包括选择合适的orient参数、使用压缩技术、多进程处理等

通过掌握这些技巧和方法，您可以更高效地使用pandas处理JSON数据，无论是在数据分析、Web开发还是API集成等场景中。随着数据量的不断增长和数据处理需求的日益复杂，这些技能将变得越来越重要。

希望本文能帮助您更好地理解和使用pandas处理JSON数据，提高数据处理的效率和质量。

版权声明

1、转载或引用本网站内容(使用pandas库高效输出JSON格式数据的技巧与方法从基础操作到高级应用解决数据转换中的常见问题)须注明原网址及作者(威震华夏关云长)，并标明本网站网址(https://pixtech.org/)。

2、对于不当转载或引用本网站内容而引起的民事纷争、行政处理或其他损失，本网站不承担责任。

3、对不遵守本声明或其他违法、恶意使用本网站内容者，本网站保留追究其法律责任的权利。

本文地址: https://pixtech.org/thread-40733-1-1.html

活动公告

使用pandas库高效输出JSON格式数据的技巧与方法从基础操作到高级应用解决数据转换中的常见问题

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

版权声明

立华奏

友情链接

Telegram

Discord

Tencent QQ