用Python+PyRFC批量处理SAP数据？一个读取SPFLI表的脚本带你快速上手

Python+PyRFC实战：高效读取SAP航空数据表的完整指南

引言

在传统企业IT架构中，SAP系统往往承载着核心业务数据，但如何将这些数据高效提取并用于现代数据分析一直是开发者的痛点。想象一下，当你需要从SAP系统中获取航班时刻表数据进行分析时，传统方式可能需要等待IT部门导出报表，或者编写复杂的ABAP程序。而今天，我们将展示如何用Python生态中的PyRFC工具包，直接与SAP系统建立桥梁，实现数据的实时获取和处理。

PyRFC作为SAP官方推荐的Python接口工具，已经发展到2.x版本，稳定性和功能都有了显著提升。不同于早期版本对Unicode支持不足的问题，现在的PyRFC可以完美处理多语言数据，特别是对于国际化的航空数据（如包含中文机场名称的情况）也能游刃有余。

1. 环境准备与SDK配置

1.1 安装SAP NW RFC SDK

PyRFC本质上是SAP NW RFC SDK的Python封装，因此需要先安装这个基础开发包。最新版本的SDK可以从SAP官网获取（需要SAP账号权限），也可以从PyRFC项目的GitHub仓库找到兼容版本。

安装完成后，需要配置两个关键环境变量：

# Windows系统示例
set SAPNWRFC_HOME=C:\path_to_sdk\nwrfcsdk
set PATH=%PATH%;%SAPNWRFC_HOME%\lib;%SAPNWRFC_HOME%\bin

验证安装是否成功：

import pyrfc
print(pyrfc.get_nwrfcsdk_version())  # 应显示类似'7200.0.28'的版本号

1.2 安装PyRFC包

推荐使用pip安装最新稳定版：

pip install pynwrfc

如果遇到版本冲突，可以尝试指定版本：

pip install pyrfc==2.1.0

2. 建立SAP连接基础

2.1 连接参数配置

连接SAP系统需要以下核心参数：

conn_params = {
    "ashost": "sap.example.com",  # SAP应用服务器地址
    "sysnr": "00",               # 系统编号
    "client": "100",             # 客户端编号
    "user": "developer",         # 用户名
    "passwd": "secure_password", # 密码
    "lang": "EN"                 # 语言代码
}

重要提示 ：实际项目中，建议将敏感信息存储在环境变量或配置文件中，不要硬编码在脚本里。

2.2 连接测试与错误处理

稳健的连接代码应该包含错误处理：

import pyrfc
from pyrfc import ConnectionError

try:
    conn = pyrfc.Connection(**conn_params)
    print("连接成功！SAP系统信息：", conn.get_system_info())
except ConnectionError as e:
    print(f"连接失败: {e}")
finally:
    conn.close() if 'conn' in locals() else None

3. 读取SPFLI航空数据表示例

3.1 理解SPFLI表结构

SPFLI是SAP自带的示例航班数据表，包含以下关键字段：

字段名	描述	数据类型
CARRID	航空公司代码	CHAR(3)
CONNID	航班连接号	NUMC(4)
COUNTRYFR	出发国家	CHAR(3)
CITYFROM	出发城市	CHAR(20)
AIRPFROM	出发机场	CHAR(3)
COUNTRYTO	到达国家	CHAR(3)
CITYTO	到达城市	CHAR(20)
AIRPTO	到达机场	CHAR(3)

3.2 使用RFC_READ_TABLE函数

以下是读取SPFLI表的完整示例：

def read_spfli_data(conn_params, country_filter=None):
    conn = pyrfc.Connection(**conn_params)
    
    # 构建查询选项
    options = []
    if country_filter:
        options.append({"TEXT": f"COUNTRYFR EQ '{country_filter}'"})
    
    # 指定需要获取的字段
    fields = [
        {"FIELDNAME": "CARRID"},
        {"FIELDNAME": "CONNID"},
        {"FIELDNAME": "COUNTRYFR"},
        {"FIELDNAME": "CITYFROM"},
        {"FIELDNAME": "AIRPFROM"},
        {"FIELDNAME": "COUNTRYTO"},
        {"FIELDNAME": "CITYTO"},
        {"FIELDNAME": "AIRPTO"}
    ]
    
    result = conn.call(
        'RFC_READ_TABLE',
        QUERY_TABLE="SPFLI",
        DELIMITER="|",
        OPTIONS=options,
        FIELDS=fields
    )
    
    # 处理返回数据
    data = []
    for row in result['DATA']:
        values = row['WA'].split('|')
        data.append(dict(zip([f['FIELDNAME'] for f in result['FIELDS']], values)))
    
    conn.close()
    return data

3.3 数据转换与增强

原始数据返回格式较为简单，我们可以用pandas进行增强处理：

import pandas as pd

def get_flight_data_as_dataframe(conn_params, country=None):
    raw_data = read_spfli_data(conn_params, country)
    df = pd.DataFrame(raw_data)
    
    # 类型转换
    df['CONNID'] = df['CONNID'].astype(int)
    
    # 添加计算列
    df['ROUTE'] = df['AIRPFROM'] + '-' + df['AIRPTO']
    
    return df

4. 高级应用与性能优化

4.1 批量处理大量数据

当处理大型表时，需要分批次获取数据：

def read_large_table_in_batches(conn_params, table_name, batch_size=10000):
    conn = pyrfc.Connection(**conn_params)
    row_skip = 0
    all_data = []
    
    while True:
        result = conn.call(
            'RFC_READ_TABLE',
            QUERY_TABLE=table_name,
            ROWCOUNT=batch_size,
            ROWSKIP=row_skip
        )
        
        if not result['DATA']:
            break
            
        # 处理数据...
        all_data.extend(process_data(result))
        
        row_skip += batch_size
    
    conn.close()
    return all_data

4.2 并行处理技术

对于需要处理多个表或复杂查询的情况，可以使用Python的并发特性：

from concurrent.futures import ThreadPoolExecutor

def parallel_read_tables(conn_params, table_list):
    with ThreadPoolExecutor(max_workers=4) as executor:
        futures = {
            executor.submit(read_spfli_data, conn_params, table): table
            for table in table_list
        }
        
        results = {}
        for future in concurrent.futures.as_completed(futures):
            table_name = futures[future]
            results[table_name] = future.result()
    
    return results

4.3 数据缓存策略

频繁读取相同数据时，考虑实现缓存机制：

from functools import lru_cache
import hashlib

@lru_cache(maxsize=32)
def cached_read_table(conn_params, table_name, query=None):
    params_hash = hashlib.md5(str(conn_params).encode()).hexdigest()
    cache_key = f"{params_hash}_{table_name}_{query}"
    
    # 实际读取逻辑...
    return read_table_data(conn_params, table_name, query)

5. 实际业务场景应用

5.1 航班数据分析案例

假设我们需要分析某航空公司的航线网络：

def analyze_airline_routes(df):
    # 计算各航空公司航线数量
    route_counts = df.groupby('CARRID')['ROUTE'].nunique()
    
    # 找出枢纽机场（连接最多的机场）
    hub_airports = pd.concat([
        df['AIRPFROM'].value_counts(),
        df['AIRPTO'].value_counts()
    ]).groupby(level=0).sum().sort_values(ascending=False)
    
    # 国际航线占比
    international = (df['COUNTRYFR'] != df['COUNTRYTO']).mean()
    
    return {
        'route_counts': route_counts,
        'hub_airports': hub_airports,
        'international_ratio': international
    }

5.2 数据可视化集成

结合matplotlib或Plotly进行可视化：

import plotly.express as px

def visualize_routes(df):
    fig = px.scatter_geo(df,
                        lat='LATITUDE',  # 假设已添加经纬度数据
                        lon='LONGITUDE',
                        hover_name='CITYFROM',
                        color='CARRID',
                        title='航空公司航线网络')
    fig.show()

5.3 异常检测与数据质量检查

def data_quality_check(df):
    # 检查缺失值
    missing_values = df.isnull().sum()
    
    # 异常值检测
    unusual_airports = df[~df['AIRPFROM'].str.match('^[A-Z]{3}$')]
    
    # 时间合理性检查（假设有飞行时间字段）
    if 'FLIGHT_TIME' in df:
        unreasonable_time = df[df['FLIGHT_TIME'] > 20]  # 超过20小时的航班
        
    return {
        'missing_values': missing_values,
        'unusual_airports': unusual_airports,
        'unreasonable_time': unreasonable_time if 'FLIGHT_TIME' in df else None
    }

6. 安全与最佳实践

6.1 连接安全管理

from cryptography.fernet import Fernet
import os

class SAPConnectionManager:
    def __init__(self, key_file='sap_key.key'):
        self.key = self._get_or_create_key(key_file)
        self.cipher = Fernet(self.key)
    
    def _get_or_create_key(self, key_file):
        if os.path.exists(key_file):
            with open(key_file, 'rb') as f:
                return f.read()
        else:
            key = Fernet.generate_key()
            with open(key_file, 'wb') as f:
                f.write(key)
            return key
    
    def encrypt_credentials(self, plain_params):
        encrypted = {
            k: self.cipher.encrypt(v.encode()).decode() 
            for k, v in plain_params.items()
        }
        return encrypted
    
    def decrypt_credentials(self, encrypted_params):
        return {
            k: self.cipher.decrypt(v.encode()).decode()
            for k, v in encrypted_params.items()
        }

6.2 性能监控与日志

import logging
import time
from contextlib import contextmanager

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('sap_rfc')

@contextmanager
def log_rfc_call(func_name):
    start_time = time.time()
    logger.info(f"开始调用RFC函数: {func_name}")
    try:
        yield
    except Exception as e:
        logger.error(f"RFC调用失败: {func_name}, 错误: {str(e)}")
        raise
    finally:
        duration = time.time() - start_time
        logger.info(f"RFC调用完成: {func_name}, 耗时: {duration:.2f}秒")

# 使用示例
with log_rfc_call('RFC_READ_TABLE'):
    result = conn.call('RFC_READ_TABLE', ...)

6.3 单元测试策略

import unittest
from unittest.mock import MagicMock

class TestSAPRFC(unittest.TestCase):
    def setUp(self):
        self.mock_conn = MagicMock()
        self.test_data = {
            'DATA': [{'WA': 'AA|100|US|NEW YORK|JFK|GB|LONDON|LHR'}],
            'FIELDS': [{'FIELDNAME': 'CARRID'}, ...]
        }
        
    def test_read_spfli_data(self):
        self.mock_conn.call.return_value = self.test_data
        result = read_spfli_data(self.mock_conn)
        self.assertEqual(len(result), 1)
        self.assertEqual(result[0]['CARRID'], 'AA')
        
    def test_empty_result(self):
        self.mock_conn.call.return_value = {'DATA': []}
        result = read_spfli_data(self.mock_conn)
        self.assertEqual(len(result), 0)