如何在Python中根据数组/矩阵维度自动创建Ax、Ay等变量？

Hey there! Let's break down your two Python questions one by one—both are about cutting down on repetitive manual work, which is exactly what we love to automate in Python 😊

First off, let's get one thing clear: dynamically creating standalone variable names (like var1, var2, etc.) isn't the most practical or Pythonic approach. It makes your code harder to maintain, and you'll run into headaches trying to iterate over those variables later.

Instead, use a dictionary or list to store your values—this lets you easily access, iterate, and manage them based on the array's length. Here's a quick example:

# Sample array
my_array = [15, 30, 45, 60]
# Dictionary to store "variables"
dynamic_vars = {}

for idx in range(len(my_array)):
    # Create a key like "var1", "var2"
    var_key = f"var{idx + 1}"
    dynamic_vars[var_key] = my_array[idx]

# Access your values like this
print(dynamic_vars["var1"])  # Output: 15
print(dynamic_vars["var3"])  # Output: 45

If you prefer a list (since array indices are already sequential), it's even simpler:

dynamic_vars_list = my_array.copy()
print(dynamic_vars_list[0])  # Equivalent to var1

Both approaches are way more flexible than cluttering your namespace with arbitrary variable names.

Great question—this is perfect for automation! The core idea of Cramer's rule is replacing each column of your coefficient matrix A with the constant term vector b to get matrices Aₓ, Aᵧ, etc. Instead of manually writing each one, we can loop through each column and generate these matrices on the fly.

Let's use numpy (the go-to library for matrix operations) to demonstrate—calculating determinants becomes trivial with it:

import numpy as np

# Example 3x3 linear system:
# 2x + y - z = 8
# -3x - y + 2z = -11
# -2x + y + 2z = -3
coefficient_matrix = np.array([[2, 1, -1], [-3, -1, 2], [-2, 1, 2]])
constant_vector = np.array([8, -11, -3])

# Store all Aₓ, Aᵧ, A_z in a dictionary
cramer_matrices = {}
matrix_dim = coefficient_matrix.shape[0]  # Get n for n x n matrix

for col_idx in range(matrix_dim):
    # Make a copy of the original matrix (don't modify the original!)
    current_matrix = coefficient_matrix.copy()
    # Replace the current column with the constant vector
    current_matrix[:, col_idx] = constant_vector
    # Generate variable name (x, y, z... based on column index)
    var_name = chr(ord('x') + col_idx)
    cramer_matrices[f"A{var_name}"] = current_matrix

# Now you can access Ax, Ay, Az just like manually created variables
print("Ax matrix:\n", cramer_matrices["Ax"])

# Calculate solutions using determinants
det_A = np.linalg.det(coefficient_matrix)
solutions = {}

for mat_name, mat in cramer_matrices.items():
    det_mat = np.linalg.det(mat)
    # Extract the variable name (e.g., "x" from "Ax")
    var = mat_name[1]
    solutions[var] = det_mat / det_A

print("\nFinal solutions:", solutions)

This code works for any n x n system—just update coefficient_matrix and constant_vector, and it'll automatically generate all required Aₓ, Aᵧ, ..., Aₙ matrices. No manual typing needed!

If you don't want to use a dictionary, you could also store the matrices in a list and access them by index (e.g., cramer_list[0] for Aₓ), but the dictionary makes it easier to map directly to variable names like x, y, z.

内容的提问来源于stack exchange，提问作者Sahil Jhawar