En étudiant Python, j'ai réalisé qu'il serait facile de calculer des nombres complexes, alors j'ai essayé de voir s'il était vraiment facile d'implémenter la loi d'Ohm utilisée en génie électrique en Python.
C'est l'une des règles les plus importantes de l'électrotechnique et c'est la première formule à apprendre.
V = IR
Ohm'sLawDC.py
# V = IR for DC circuit
print('Empty a parameter to calculate')
V = float(input('Input V : ') or 0)
I = float(input('Input I : ') or 0)
R = float(input('Input R : ') or 0)
if not V:
V = R * I
elif not I:
I = V / R
elif not R:
R = V / I
else:
print('Empty a parameter to calculate')
print('V =', V, '[V]')
print('I =', I, '[A]')
print('R =', R, '[Ω]')
C'est la première partie d'entrée, mais on suppose que les paramètres entrés vides seront calculés. Par conséquent, si vous convertissez l'entrée telle qu'elle est comme indiqué ci-dessous, une erreur se produira au moment de la conversion avec le paramètre de l'entrée vide.
V = float(input('Input V : '))
Par conséquent, j'ai écrit qu'après avoir entré le type str une fois, il n'est converti que lorsque l'entrée n'est pas vide. J'aimerais vraiment pouvoir avoir une notation plus simple ... J'ai vérifié la valeur initiale de l'entrée et si elle ne pouvait pas être définie, mais je n'ai pas pu trouver un tel argument orz
PostScript 10/11/2019 On m'a dit dans les commentaires que la notation suivante peut être utilisée. De cette façon, j'ai pu le convertir en un nombre sans instruction if. c'est incroyable!
V = float(input('Input V : ') or 0)
L'opérateur ou juge en fait la valeur sur le côté gauche comme vraie ou fausse et renvoie le résultat. Profondément, je vois ... https://docs.python.org/ja/3/library/stdtypes.html#boolean-operations-and-or-not
Le résultat est affiché comme suit.
Empty a parameter to calculate
Input V : 100
Input I :
Input R : 50
V = 100.0 [V]
I = 2.0 [A]
R = 50.0 [Ω]
C'est le sujet principal de cette époque. Je n'ai pas utilisé du tout de nombres complexes pour DC, mais pour AC, j'ai besoin de calculer des nombres complexes avec l'impédance (Z) ajoutée.
v = iz
z = \sqrt{(r^2+x^2)}
La différence avec DC est que ** $ x $ (Réactance) ** est ajouté aux paramètres. Cette réactance représente la composante imaginaire du circuit AC.
Écrivons maintenant la loi d'Ohm dans les circuits AC en Python. Assurez-vous de calculer le paramètre vide de $ v $, $ i $, $ r $, $ x $.
Ohm'sLawAC.py
# v = iz for AC circuit
print('Empty a parameter to calculate')
v = complex(input('Input v[V] : ') or 0)
i = complex(input('Input i[A] : ') or 0)
r = complex(input('Input r[Ω] : ') or 0)
x = complex(input('Input x[jΩ] : ') or 0)*1j
if not v:
z = (r ** 2 + (x / 1j) ** 2) ** (1/2)
v = z * i
elif not i:
z = (r ** 2 + (x / 1j) ** 2) ** (1/2)
i = v / z
elif not r:
z = v / i
r = (z ** 2 - (x / 1j) ** 2) ** (1/2)
elif not x:
z = v / i
x = (z ** 2 - r ** 2) ** (1/2) *1j
else:
print('Empty a parameter to calculate')
print('v =', v, '[V]')
print('i =', i, '[A]')
print('r =', r, '[Ω]')
print('x =', x, '[jΩ]')
print('z =', z, '[Ω]')
Étonnamment, il était difficile de saisir des nombres réels et de convertir en interne des nombres réels en nombres complexes. C'est facile tant que vous savez que vous pouvez convertir du réel en imaginaire avec "* 1j".
Le résultat est affiché comme suit.
Empty a parameter to calculate
Input v[V] : 10
Input i[A] : 2
Input r[Ω] : 3
Input x[jΩ] :
v = (10+0j) [V]
i = (2+0j) [A]
r = (3+0j) [Ω]
x = 4j [jΩ]
z = (5+0j) [Ω]
Je pourrais certainement calculer la loi d'Ohm en utilisant des nombres complexes. Il y avait des voyages occasionnels tels que la partie entrée / sortie et la méthode de conversion des nombres réels en nombres complexes, mais si vous savez comment écrire des nombres imaginaires en Python, le reste fonctionnera tant que vous écrivez la formule de calcul docilement, donc il n'y a presque pas de problème. était. Je pense que c'était vraiment facile.
Après tout, vous êtes incroyable! Python-kun!
Recommended Posts