Chemical Equation Balancer
Balanciere chemische Gleichungen automatisch.
Verwenden Sie -> oder = zum Trennen von Reaktanten und Produkten. Verwenden Sie + zwischen Verbindungen.
Über dieses Tool
Ein Gleichungsausgleicher für Chemie ist ein wichtiges Werkzeug für Chemiker, Studenten und Lehrkräfte, die sicherstellen müssen, dass chemische Reaktionen korrekt dargestellt werden, mit gleicher Anzahl von Atomen auf beiden Seiten der Gleichung. Das manuelle Ausgleichen von Gleichungen kann zeitaufwändig und fehleranfällig sein, besonders bei komplexen Reaktionen mit mehreren Edukten und Produkten. Dieses Werkzeug automatisiert den Prozess und findet sofort die korrekten stöchiometrischen Koeffizienten, damit Sie sich auf das Verständnis der Chemie konzentrieren können, statt mit Arithmetik zu kämpfen.
Um den Gleichungsausgleicher zu verwenden, geben Sie einfach Ihre unausgeglichene chemische Gleichung in das Eingabefeld ein—verwenden Sie dabei die standardmäßige chemische Notation, zum Beispiel H2 + O2 → H2O für die Wasserstoffverbrennung. Das Werkzeug analysiert Ihre Gleichung, identifiziert alle eindeutigen Elemente und deren Mengen und berechnet dann die minimalen ganzzahligen Koeffizienten, die zum Ausgleichen erforderlich sind. Ob Sie einfache Reaktionen wie Eisenrost oder komplexe organische Synthesen ausgleichen—das Werkzeug bewältigt einstufige Gleichungen schnell und genau.
Dieses Werkzeug ist am nützlichsten für Chemie-Schüler in der Oberstufe und an Universitäten, die sich auf Prüfungen vorbereiten oder Hausaufgaben erledigen, sowie für Lehrkräfte, die ihre Arbeiten überprüfen oder Beispielaufgaben erstellen möchten. Beachten Sie, dass es einzelne Gleichungen ausgleicht—es kann keine Reaktionsprodukte vorhersagen oder Reaktionsmechanismen erklären. Bei sehr großen oder ungewöhnlichen Gleichungen überprüfen Sie das Ergebnis immer gegen chemische Prinzipien, um sicherzustellen, dass die Ausgabe für Ihren spezifischen Kontext sinnvoll ist.
Häufig gestellte Fragen
Code-Implementierung
# Chemical equation balancing using linear algebra
import numpy as np
from fractions import Fraction
def parse_formula(formula):
"""Parse a chemical formula like H2O into {'H': 2, 'O': 1}"""
import re
pattern = r"([A-Z][a-z]?)([0-9]*)"
counts = {}
for element, count in re.findall(pattern, formula):
counts[element] = counts.get(element, 0) + int(count or 1)
return counts
def balance_equation(reactants, products):
"""
Balance a chemical equation.
reactants: list of formula strings, e.g. ["H2", "O2"]
products: list of formula strings, e.g. ["H2O"]
Returns coefficients for [reactants..., products...]
"""
# Collect all elements
all_compounds = reactants + products
all_elements = set()
for compound in all_compounds:
all_elements.update(parse_formula(compound).keys())
elements = sorted(all_elements)
# Build matrix: rows=elements, cols=compounds
# Reactants are positive, products are negative
n = len(all_compounds)
m = len(elements)
matrix = [[Fraction(0)] * n for _ in range(m)]
for j, compound in enumerate(all_compounds):
parsed = parse_formula(compound)
sign = 1 if j < len(reactants) else -1
for i, element in enumerate(elements):
matrix[i][j] = Fraction(sign * parsed.get(element, 0))
# Gaussian elimination to find null space
# (simplified — works for most single-reaction equations)
# For production use, consider sympy:
# from sympy import Matrix
# M = Matrix(matrix)
# coeffs = M.nullspace()[0]
return "Use sympy for robust balancing"
# Example with sympy (recommended)
from sympy import Matrix, lcm
from functools import reduce
def balance_sympy(reactants, products):
import re
all_compounds = reactants + products
elements = sorted(set(
e for f in all_compounds
for e, _ in re.findall(r"([A-Z][a-z]?)([0-9]*)", f)
))
rows = []
for elem in elements:
row = []
for i, f in enumerate(all_compounds):
counts = {e: int(n or 1) for e, n in
re.findall(r"([A-Z][a-z]?)([0-9]*)", f)}
sign = 1 if i < len(reactants) else -1
row.append(sign * counts.get(elem, 0))
rows.append(row)
M = Matrix(rows)
null = M.nullspace()[0]
denom = reduce(lcm, [v.q for v in null])
coeffs = [int(v * denom) for v in null]
return coeffs
coeffs = balance_sympy(["H2", "O2"], ["H2O"])
print(coeffs) # [2, 1, 2] -> 2H2 + O2 -> 2H2OComments & Feedback
Comments are powered by Giscus. Sign in with GitHub to leave a comment.