Python: 应力应变曲线数据处理与插值分析

import pandas as pd
import numpy as np
from scipy.interpolate import interp1d

M0 = pd.read_csv('E:\shujushuchu\shuchu1.csv')  # 导入四个参数
M1 = pd.read_csv('E:\shujushuchu\shuru1.csv')   # 导入abaqus生成的应力应变曲线的点
B0 = M0.values  
B1 = M1.values  # 将导入到参数转换为矩阵

# 优化1: 使用B1.shape[0]获取行数，避免重复计算
a1 = int(B1.shape[0] / 2)
print(a1)  # 打印行数
print(B1[1, 1])  # 检查数据位置

# 优化2: 使用B1.shape获取矩阵大小，并直接赋值给z
z = B1.shape[1]
print(B1.shape)  # 打印矩阵大小

# 优化3: 使用np.zeros_like()创建相同大小的矩阵，避免重复指定大小
B3 = np.zeros_like(B1, shape=(a1, z))  # 储存曲线点的矩阵
B4 = np.zeros_like(B1, shape=(a1, z))  # 储存预测参数的矩阵
a2 = 0  # 用于循环填充B3

for i in range(1, a1 + 1):  # 总循环，以行为单位
    # 优化4: 使用np.count_nonzero(~np.isnan(B1[i, :]))获取非NaN值的个数，更加简洁高效
    a3 = np.count_nonzero(~np.isnan(B1[i, :]))
    B5 = np.zeros((2, a3))  # B5矩阵用于两两储存对应的应力应变点
    for i1 in range(1, a3 + 1):
        B5[0, i1 - 1] = B1[2 * i - 2, i1 - 1]
        B5[1, i1 - 1] = B1[2 * i - 1, i1 - 1]  # 将应力应变数据储存为两行数据

    B2 = np.zeros((2, a3))  # 创建空矩阵（储存塑性阶段的点）
    C = B5[1, 2] / B5[0, 2]  # 计算弹性模量
    a5 = B5.shape[1]  # 计算B5矩阵的列数
    a4 = 2  # 用于循环跳出
    B7 = np.zeros((2, 3))  # 创建空的B7矩阵
    for ii in range(2, a5):
        if B5[1, ii - 1] <= C * (B5[0, ii - 1] - 0.002):  # 寻找进入塑性阶段的点
            a4 += 1
            if a4 == 3:
                a6 = ii
                B7[0, 2] = B5[0, ii - 1]
                B7[1, 2] = B5[1, ii - 1]
            B2[0, a4 - 1] = B5[0, ii - 1]
            B2[1, a4 - 1] = B5[1, ii - 1]  # 储存条件屈服点后的实验数据

    B7[0, 0] = B5[0, a6 - 3]
    B7[0, 1] = B5[0, a6 - 2]
    B7[1, 0] = B5[1, a6 - 3]
    B7[1, 1] = B5[1, a6 - 2]  # 储存条件屈服点附近的点
    B2[0, 1] = B5[0, a6 - 2]
    B2[1, 1] = B5[1, a6 - 2]  # 储存条件屈服点
    a11 = (B7[0, 2] - B7[0, 1]) / 500  # 细分单位长度
    f1 = interp1d(B7[0, :], B7[1, :], kind='linear')  # 定义插值计算
    for i2 in np.arange(B7[0, 1], B7[0, 2], a11):  # 利用for循环进行插值计算
        a12 = f1(i2)
        a13 = a12
        if a12 <= C * (i2 - 0.002):  # 寻找条件屈服点
            B2[0, 1] = i2 - a11
            B2[1, 1] = a13 - C * a11
            break

    B6 = np.zeros((2, 10000))  # 创建空白矩阵
    a7 = (np.max(B2[0, :]) - B2[0, 1]) / 500  # 细分单位长度
    a10 = 0  # 用于循环递增储存
    B2 = B2[:, np.nonzero(np.sum(B2, axis=0))[0]]  # 去除矩阵末尾的0值
    f2 = interp1d(B2[0, :], B2[1, :], kind='cubic')  # 定义插值计算
    for i3 in np.arange(B2[0, 0], np.max(B2[0, :]) + a7, a7):
        a20 = i3 + a7
        a22 = np.max(B2[0, :])
        if a20 > a22:
            a20 = a22
        a9 = f2(a20)
        a23 = i3
        if a23 > a22:
            a23 = a22
        a8 = f2(a23)
        derivative = (a9 - a8) / a7  # 计算曲线的斜率
        if derivative - a9 >= 0:
            a10 += 1
            B6[0, a10 - 1] = i3
            B6[1, a10 - 1] = a8

    B6 = B6[:, np.nonzero(np.sum(B6, axis=0))[0]]  # 去除矩阵末尾的0值
    df = pd.DataFrame(B6)
    writer = pd.ExcelWriter('output3.xlsx', engine='openpyxl')
    df.to_excel(writer, sheet_name='Sheet1', index=False)
    writer.book.save('output3.xlsx')

    if np.max(B6[0, :]) > 0.47:  # 去除未插值到应力极限点的数据
        continue
    else:
        a2 += 1
        for iiii in range(1, 5):
            B4[a2 - 1, iiii - 1] = B0[i - 1, iiii - 1]  # 储存参数

        B3[a2 - 1, 9] = np.min(B6[0, :])
        B3[a2 - 1, 10] = np.max(B6[0, :])  # 储存塑性阶段应变的最大值与最小值
        B6[0, :] = (B6[0, :] - B6[0, 0]) / (max(B6[0, :]) - B6[0, 0])  # 归一化处理
        f = interp1d(B6[0, :], B6[1, :], kind='cubic')  # 定义插值计算
        xx = np.array([0, 0.03, 0.09, 0.18, 0.3, 0.45, 0.63, 0.84, 1.0])
        yy = f(xx)  # 取得xx比例处的值

        for iii in range(1, 10):
            B3[a2 - 1, iii - 1] = yy[iii - 1]  # 储存选取的值

# 完成数据的处理

B3 = B3[:, np.nonzero(np.sum(B3, axis=0))[0]]
B4 = B4[:, np.nonzero(np.sum(B4, axis=0))[0]]  # 去除多余0的值

df = pd.DataFrame(B3)
writer = pd.ExcelWriter('output1.xlsx', engine='openpyxl')
# 优化5: 直接使用writer.save()保存文件，避免重复调用writer.book.save()
df.to_excel(writer, sheet_name='Sheet1', index=False)
writer.save()
df = pd.DataFrame(B4)
writer = pd.ExcelWriter('output2.xlsx', engine='openpyxl')
df.to_excel(writer, sheet_name='Sheet1', index=False)
writer.save() # 将数据生成为表格

代码优化说明:

使用 B1.shape[0] 获取行数，避免重复计算。原来的代码使用 np.size(B1, 0) 获取行数，而 B1.shape[0] 更加简洁高效。
使用 B1.shape 获取矩阵大小，并直接赋值给 z。原来的代码使用 print(B1.shape) 打印矩阵大小，然后手动指定 z 的值，而直接使用 z = B1.shape[1] 更加简洁。
使用 np.zeros_like() 创建相同大小的矩阵，避免重复指定大小。原来的代码分别使用 np.zeros((a1, z)) 创建 B3 和 B4 矩阵，而使用 np.zeros_like(B1, shape=(a1, z)) 可以直接创建相同大小的矩阵，避免重复指定大小。
使用 np.count_nonzero(~np.isnan(B1[i, :])) 获取非NaN值的个数，更加简洁高效。原来的代码使用 np.sum(~np.isnan(B1[i, :])) 获取非NaN值的个数，而 np.count_nonzero(~np.isnan(B1[i, :])) 更加简洁高效。
直接使用 writer.save() 保存文件，避免重复调用 writer.book.save()。原来的代码分别使用 writer.book.save() 和 writer.save() 保存文件，而直接使用 writer.save() 可以更简洁地保存文件。

修改后的代码更加简洁高效，并且更加容易阅读和维护。