Как можно усовершенствовать код и сократить его?

Question

У меня есть код, не могу понять, как в функцию закинуть в цикл. x1, y1, z1 и x2, y2, z2 и так далее., имеют разные размеры массива, в этом заключается вся сложность.

import numpy as np
import math

x = []
y = []
z = []
file_dir1 = r'D:\Python\Laba_1\alfa.txt'
x1, y1, z1 = np.loadtxt(file_dir1, usecols = (0, 1, 2), unpack=True)
x.append(x1)
y.append(y1)
z.append(z1)
file_dir2 = r'D:\Python\Laba_1\gamma.txt'
x2, y2, z2 = np.loadtxt(file_dir2, usecols = (0, 1, 2), unpack=True)
x.append(x2)
y.append(y2)
z.append(z2)

file_dir3 = r'D:\Python\Laba_1\Mn.txt'
x3, y3, z3 = np.loadtxt(file_dir3, usecols = (2, 3, 4), unpack=True)
x.append(x3)
y.append(y3)
z.append(z3)
file_dir3 = r'D:\Python\Laba_1\C.txt'
x4, y4, z4 = np.loadtxt(file_dir3, usecols = (2, 3, 4), unpack=True)
x.append(x4)
y.append(y4)
z.append(z4)

alfa = [2, 1, 1]
gamma = [2, 2, 0]
Mn_C = [4, 2, 0]

p = [24, 12, 24]

O1 = math.radians(41.12)
O2 = math.radians(37.4)
O3 = math.radians(19.15)
O = [O1, O2, O3]
PLG = []
for i in range(len(O)):
    plg = (1 + math.cos(2*O[i])**2)/((math.sin(O[i])**2)*math.cos(O[i]))
    PLG.append(plg)
print('PLG = ', PLG)

Iint = [83,9, 11.1, 4.6]
Ka1 = 1.5406
Ka2 = 1.5444
Kacp = (2*Ka1 + Ka2)/3
sinO_lambda = []
for i in range(len(O)):
    sinO_lam = math.sin(O[i])/Kacp
    sinO_lambda.append(sinO_lam)
print(sinO_lambda)
f = [12.5, 13.3, 18.2, 3]
pi = math.pi

def F_hkl(f, pi, x, y, z):
    return f[0] * math.cos(2 * pi * (alfa[0] * x + alfa[1] * y + alfa[2] * z)) + f[0] * math.sin(2 * pi * (alfa[0] * x + alfa[1] * y + alfa[2] * z))

F_alfa = sum(F_hkl(f, pi, x[0][i], y[0][i], z[0][i]) for i in range(len(x[0])))

def F_hkl(f, pi, x, y, z):
    return f[1] * math.cos(2 * pi * (gamma[0] * x + gamma[1] * y + gamma[2] * z)) + f[1] * math.sin(2 * pi * (gamma[0] * x + gamma[1] * y + gamma[2] * z))
F_gamma = sum(F_hkl(f, pi, x[1][i], y[1][i], z[1][i]) for i in range(len(x[1])))

def F_hkl(f, pi, x, y, z):
    return f[2] * math.cos(2 * pi * (Mn_C[0] * x + Mn_C[1] * y + Mn_C[2] * z)) + f[2] * math.sin(2 * pi * (Mn_C[0] * x + Mn_C[1] * y + Mn_C[2] * z))
F_Mn = sum(F_hkl(f, pi, x[2][i], y[2][i], z[2][i]) for i in range(len(x[2]))) ** 2

def F_hkl(f, pi, x, y, z):
    return f[3] * math.cos(2 * pi * (Mn_C[0] * x + Mn_C[1] * y + Mn_C[2] * z)) + f[3] * math.sin(2 * pi * (Mn_C[0] * x + Mn_C[1] * y + Mn_C[2] * z))
F_C = sum(F_hkl(f, pi, x[3][i], y[3][i], z[3][i]) for i in range(len(x[3]))) ** 2
F_Mn_C = math.sqrt(F_Mn + F_C)


print('F(hkl) = ', math.floor(F_alfa),' ', F_gamma, ' ', F_Mn_C)

Answer 1

Имеется ввиду это

for it,andit in ([file,file,...],[usecols,usecols....]):
    xx, yy, zz = np.loadtxt(it, usecols = andit, unpack=True)
    x.append(xx)    
    y.append(yy)
    z.append(zz)

Но у вас имеются другие проблеммы: есть три функции с одним именем, что вводит в заблуждение, может исспользовать анонимные функции?

Answer 2

Вы используете массивы там, где они совершенно не нужны. Можно произвести расчет по каждому файлу в отдельности, не загружая все 4 одновременно в память. Примерно так:

def sumFile(name, cols, f, vec):
    x, y, z = np.loadtxt(name, usecols = cols, unpack=True)
    def F_hkl(x, y, z):
        return f * math.cos(2 * math.pi * (vec[0] * x + vec[1] * y + vec[2] * z)) + f * math.sin(2 * math.pi * (vec[0] * x + vec[1] * y + vec[2] * z))
    return sum(F_hkl(x[i], y[i], z[i]) for i in range(len(x))) ** 2

alfa = [2, 1, 1]
gamma = [2, 2, 0]
Mn_C = [4, 2, 0]
f = [12.5, 13.3, 18.2, 3]

F_alfa =  sumFile(r'D:\Python\Laba_1\alfa.txt',  (0, 1, 2), 12.5, alfa)
F_gamma = sumFile(r'D:\Python\Laba_1\gamma.txt', (0, 1, 2), 13.3, gamma)
F_Mn =    sumFile(r'D:\Python\Laba_1\Mn.txt',    (2, 3, 4), 18.2, Mn_C)
F_C =     sumFile(r'D:\Python\Laba_1\C.txt',     (2, 3, 4),    3, Mn_C)

БЛОГ НА HUSL

Как можно усовершенствовать код и сократить его?

Ответы (2 шт):