Hi, ich habe das immer so verstanden, das die Nicht-Primzahlen ausgesiebt werden und die Primzahlen übrig bleiben.
kleine Mathe-Spielereien
Ich bin Pazifist und greife niemanden an, auch nicht mit Worten.
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
24.04.2022
Ich habe jetzt einen Code geschrieben, mit dem einafch und gezielt
Primhzahlen verifiziert werden können. Dabei habe ch die Funktion _fiklter- eingesetzt.
Ich stelle diesen zur Überprüfung vor:
import math
u =int(input("Untergrenze :" , ))
o =int(input("Obergrenze :" , ))
def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
print(list(filter(is_prime, range(u, o))))
for zahl1 in filter(is_prime, range(u, o)):
zahl1 == True
i=2
while i < zahl1 /2:
if zahl1 % i ==0 :
print ("Keine Primzahl!")
#print( "Faktor " +str(i))
i=i+1
print( "Die Zahl "+ str(zahl1 ) + " ist eine Primzahl")
#
Ich habe jetzt einen Code geschrieben, mit dem einafch und gezielt
Primhzahlen verifiziert werden können. Dabei habe ch die Funktion _fiklter- eingesetzt.
Ich stelle diesen zur Überprüfung vor:
import math
u =int(input("Untergrenze :" , ))
o =int(input("Obergrenze :" , ))
def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
print(list(filter(is_prime, range(u, o))))
for zahl1 in filter(is_prime, range(u, o)):
zahl1 == True
i=2
while i < zahl1 /2:
if zahl1 % i ==0 :
print ("Keine Primzahl!")
#print( "Faktor " +str(i))
i=i+1
print( "Die Zahl "+ str(zahl1 ) + " ist eine Primzahl")
#
Man benutzt keine Einbuchstabige Variablennamen, wie u statt untergrenze oder o statt obergrenze.
Was soll die 1 bei `zahl1`? zahl1 wird niemals gleich True sein. Mit dem Ergebnis des Vergleichs machst Du aber eh nichts. Was soll das also?
Deine ›is_prime‹-Funktion liefert jetzt für 2 fälschlicherweise False. Beim Programmieren sollte man doch ein Mindestmaß an Ergeiz haben, fehlerfreie Funktionen schreiben zu wollen.
Die while-Schleife wäre besser eine for-Schleife, weil deutlich besser lesbar. Strings setzt man nicht per + zusammen, sondern nutz Formatstrings. Die letzte print-Ausgabe ist falsch, weil nicht jede Zahl eine Primzahl ist.
Was soll die 1 bei `zahl1`? zahl1 wird niemals gleich True sein. Mit dem Ergebnis des Vergleichs machst Du aber eh nichts. Was soll das also?
Deine ›is_prime‹-Funktion liefert jetzt für 2 fälschlicherweise False. Beim Programmieren sollte man doch ein Mindestmaß an Ergeiz haben, fehlerfreie Funktionen schreiben zu wollen.
Die while-Schleife wäre besser eine for-Schleife, weil deutlich besser lesbar. Strings setzt man nicht per + zusammen, sondern nutz Formatstrings. Die letzte print-Ausgabe ist falsch, weil nicht jede Zahl eine Primzahl ist.
Code: Alles auswählen
for i in range(2, zahl1 // 2):
if zahl1 % i == 0:
print("Keine Primzahl!")
# print(f"Faktor {i}")
print(f"Die Zahl {zahl1} ist eine Primzahl")
Ich hoffe, dass es mir unter Umgehung der vob Dir angemahnten Fehler,
endlich gelungen ist, einen vernünftigen und nicht falschen Code zu produzieren.
Jetzt bin ich mit meiner Kunst, nach langen Bemühungen, am Ende.
Mit herzlichen Grüseen und einem dicken Dankeschön für Deine Hilfe.
OSWALD
###Erstellt am 29.04.22 von OSWALD
import math
unten =int(input("Untergrenze :",))
oben =int(input("Obergrenze :" , ))
def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
print(list(filter(is_prime, range(unten, oben))))
for zahl in filter(is_prime, range(unten, oben)):
prim =0
i=2
for i in range(unten, i // 2):
if prim % i == 0:
print(i)
def Prim_Test(i):
if i ==2 or i==3: return True
if i%2==0 or i<2: return False
for i in range(1, int(i**0.5)+1, 2):
return False
return True
i = int(input("untere Primzahl eingeben: "))
max = int(input("oberste Primzahl eingeben: "))
i = range(unten,oben)
even_numbers = list(filter(lambda x: (x%2 == 0), i))
print(even_numbers),
print("Liste frei von falschen Zahlen ")
##############################################
endlich gelungen ist, einen vernünftigen und nicht falschen Code zu produzieren.
Jetzt bin ich mit meiner Kunst, nach langen Bemühungen, am Ende.
Mit herzlichen Grüseen und einem dicken Dankeschön für Deine Hilfe.
OSWALD
###Erstellt am 29.04.22 von OSWALD
import math
unten =int(input("Untergrenze :",))
oben =int(input("Obergrenze :" , ))
def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
print(list(filter(is_prime, range(unten, oben))))
for zahl in filter(is_prime, range(unten, oben)):
prim =0
i=2
for i in range(unten, i // 2):
if prim % i == 0:
print(i)
def Prim_Test(i):
if i ==2 or i==3: return True
if i%2==0 or i<2: return False
for i in range(1, int(i**0.5)+1, 2):
return False
return True
i = int(input("untere Primzahl eingeben: "))
max = int(input("oberste Primzahl eingeben: "))
i = range(unten,oben)
even_numbers = list(filter(lambda x: (x%2 == 0), i))
print(even_numbers),
print("Liste frei von falschen Zahlen ")
##############################################
- __blackjack__
- User
- Beiträge: 13236
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@OSWALD: Die Einrückungstiefe sieht ziemlich willkürlich aus. Das sollten 4 Leerzeichen pro Ebene sein.
Die Funktion `Prim_Test()` wird nirgends verwendet. Und warum im letzten Schritt alle geraden Zahlen zwischen einer Unter- und Obergrenze berechnet werden, ist auch nicht so wirklich klar wenn man Primzahlen ermitteln will.
Alles was nach dem ersten `print()` kommt macht keinen Sinn und führt bei bestimmten Eingabewerten auch zum Programmabbruch weil `i` nicht immer definiert ist, bevor es verwendet wird.
Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Die ruft man nur auf, wenn das Modul als Programm ausgeführt wird, aber nicht wenn es als Modul importiert wird. Dann kann man beispielsweise einzelne Funktionen in einer Python-Shell ”live” ausprobieren und auch automatisierte Tests schreiben.
Die `is_prime()`-Funktion ist immer noch fehlerhaft, denn 2 ist eine Primzahl, aber die Funktion sagt sie wäre es nicht:
Die Funktion `Prim_Test()` wird nirgends verwendet. Und warum im letzten Schritt alle geraden Zahlen zwischen einer Unter- und Obergrenze berechnet werden, ist auch nicht so wirklich klar wenn man Primzahlen ermitteln will.
Alles was nach dem ersten `print()` kommt macht keinen Sinn und führt bei bestimmten Eingabewerten auch zum Programmabbruch weil `i` nicht immer definiert ist, bevor es verwendet wird.
Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Die ruft man nur auf, wenn das Modul als Programm ausgeführt wird, aber nicht wenn es als Modul importiert wird. Dann kann man beispielsweise einzelne Funktionen in einer Python-Shell ”live” ausprobieren und auch automatisierte Tests schreiben.
Code: Alles auswählen
#!/usr/bin/env python3
import math
def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
def main():
unten = int(input("Untergrenze : "))
oben = int(input("Obergrenze : "))
print(list(filter(is_prime, range(unten, oben))))
if __name__ == "__main__":
main()
Code: Alles auswählen
$ py forum7.py
Untergrenze : 0
Obergrenze : 50
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
Please call it what it is: copyright infringement, not piracy. Piracy takes place in international waters, and involves one or more of theft, murder, rape and kidnapping. Making an unauthorized copy of a piece of software is not piracy, it is an infringement of a government-granted monopoly.
Hallo, ich darf mich wieder zurückmelden. Heute mit einem anderen Thema.
Die Auswertung von unendlichen Reihen mit Python, ohne Hilfe andere rBibliotheken,
über die Berechnung von Partialsummen, Abschätzung von Konvergenz und Divergenz.
Als Beispiel: die Berechnung von e.
########## e = (1+1/n)**n
import math
from math import *
Hier das kurze Programm :
n=0
##########e = (1+1/n)**n
Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))
summe=[]
for n in (Beginn, Obergrenze):
n = (( 1+ 1/n)**n)
print(n)
summe.append(n)
print(summe)
####################################
Hier das Ergebnis:
####################################
ython 3.10.4 (tags/v3.10.4:9d38120, Mar 23 2022, 23:13:41) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
Beginn :1
Obergrenze : 5000
2.0
[2.0]
2.718010050101555
[2.0, 2.718010050101555]
Das Ergebnis ist (ab etwa einer Obergrenze von 5000 erkennbar richtig. ch habe die Zahlen gleich doppelt ausgeworfen,
aber mit den folgenden Zahlen kann ich gar nichts anfangen. Sicher kann mich jemand hier aufklären.
Außerdem: Nicht bei allen von mir Reihen waren meine Versuche erfolgreich.
0.050487008068736974
0.012594835613238816
0.0025489379837327123
0.00045250925444257647
7.458712205073751e-05
1.1816348106175658e-05
1.833985745229462e-06
2.816939701466478e-07
4.304014885464642e-08
6.558768101048276e-09
9.98149688872051e-10
1.5180329709333957e-10
2.3079304557044703e-11
3.5082634987650543e-12
5.332436262706794e-13
8.104778137735783e-14
1.2318209415277085e-14
1.872188323654198e-15
2.8454386755477355e-16
4.324618505073087e-17
6.572730291498365e-18
9.989495128643864e-19
1.5182424375625324e-19
2.307483707732941e-20
3.5070028991563684e-21
5.330078299293386e-22
8.100858458974732e-23
1.2311996826871296e-23
1.8712247086544574e-24
2.8439593923330265e-25
4.3223590291399403e-26
6.569287738541901e-27
9.984256533795814e-28
1.5174457640517221e-28
2.3062725190024217e-29
3.505161803933908e-30
5.327279916091014e-31
8.096605204431579e-32
1.2305532442193609e-32
1.870242217103828e-33
2.842466156636773e-34
4.3200895465466265e-35
6.565838487328931e-36
9.979014225791795e-37
1.5166490176498089e-37
2.3050615929506084e-38
3.5033213917412275e-39
5.324482786649144e-40
8.092354019290326e-41
1.2299071327214592e-41
1.869260231958779e-42
2.8409736977872404e-43
4.317821250100233e-44
6.562391043020961e-45
9.973774667147705e-46
1.5158526893460464e-46
2.303851302522727e-47
3.501481945732783e-48
5.3216871257565405e-49
8.088105066186793e-50
1.229261360463325e-50
1.8682787624080136e-51
2.8394820225612686e-52
4.315554144637774e-53
6.558945408818276e-54
9.968537859572889e-55
1.5150567791605058e-55
2.3026416475671123e-56
3.499643465539633e-57
5.318892932747272e-58
8.08385834402893e-59
1.2286159272729094e-59
1.867297808185429e-60
2.8379911305509165e-61
4.313288229536582e-62
6.555501583772494e-63
9.963303801624418e-64
1.5142612868737672e-64
2.3014326277501933e-65
3.4978059506547355e-66
5.3161002068506664e-67
8.0796138516454e-68
1.2279708329721854e-68
1.8663173690204506e-69
2.8365010213449523e-70
4.311023504171651e-71
6.552059566933704e-72
9.958072491858577e-73
1.51346621226641e-73
2.3002242427384855e-74
3.4959694005712494e-75
5.313308947296407e-76
8.075371587865444e-77
1.2273260773832164e-77
1.8653374446426428e-78
2.8350116945323585e-79
4.308759967918298e-80
6.548619357352494e-81
9.952843928832414e-82
9.952843928832414e-82
Gute Zeit OSWALD
Die Auswertung von unendlichen Reihen mit Python, ohne Hilfe andere rBibliotheken,
über die Berechnung von Partialsummen, Abschätzung von Konvergenz und Divergenz.
Als Beispiel: die Berechnung von e.
########## e = (1+1/n)**n
import math
from math import *
Hier das kurze Programm :
n=0
##########e = (1+1/n)**n
Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))
summe=[]
for n in (Beginn, Obergrenze):
n = (( 1+ 1/n)**n)
print(n)
summe.append(n)
print(summe)
####################################
Hier das Ergebnis:
####################################
ython 3.10.4 (tags/v3.10.4:9d38120, Mar 23 2022, 23:13:41) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
Beginn :1
Obergrenze : 5000
2.0
[2.0]
2.718010050101555
[2.0, 2.718010050101555]
Das Ergebnis ist (ab etwa einer Obergrenze von 5000 erkennbar richtig. ch habe die Zahlen gleich doppelt ausgeworfen,
aber mit den folgenden Zahlen kann ich gar nichts anfangen. Sicher kann mich jemand hier aufklären.
Außerdem: Nicht bei allen von mir Reihen waren meine Versuche erfolgreich.
0.050487008068736974
0.012594835613238816
0.0025489379837327123
0.00045250925444257647
7.458712205073751e-05
1.1816348106175658e-05
1.833985745229462e-06
2.816939701466478e-07
4.304014885464642e-08
6.558768101048276e-09
9.98149688872051e-10
1.5180329709333957e-10
2.3079304557044703e-11
3.5082634987650543e-12
5.332436262706794e-13
8.104778137735783e-14
1.2318209415277085e-14
1.872188323654198e-15
2.8454386755477355e-16
4.324618505073087e-17
6.572730291498365e-18
9.989495128643864e-19
1.5182424375625324e-19
2.307483707732941e-20
3.5070028991563684e-21
5.330078299293386e-22
8.100858458974732e-23
1.2311996826871296e-23
1.8712247086544574e-24
2.8439593923330265e-25
4.3223590291399403e-26
6.569287738541901e-27
9.984256533795814e-28
1.5174457640517221e-28
2.3062725190024217e-29
3.505161803933908e-30
5.327279916091014e-31
8.096605204431579e-32
1.2305532442193609e-32
1.870242217103828e-33
2.842466156636773e-34
4.3200895465466265e-35
6.565838487328931e-36
9.979014225791795e-37
1.5166490176498089e-37
2.3050615929506084e-38
3.5033213917412275e-39
5.324482786649144e-40
8.092354019290326e-41
1.2299071327214592e-41
1.869260231958779e-42
2.8409736977872404e-43
4.317821250100233e-44
6.562391043020961e-45
9.973774667147705e-46
1.5158526893460464e-46
2.303851302522727e-47
3.501481945732783e-48
5.3216871257565405e-49
8.088105066186793e-50
1.229261360463325e-50
1.8682787624080136e-51
2.8394820225612686e-52
4.315554144637774e-53
6.558945408818276e-54
9.968537859572889e-55
1.5150567791605058e-55
2.3026416475671123e-56
3.499643465539633e-57
5.318892932747272e-58
8.08385834402893e-59
1.2286159272729094e-59
1.867297808185429e-60
2.8379911305509165e-61
4.313288229536582e-62
6.555501583772494e-63
9.963303801624418e-64
1.5142612868737672e-64
2.3014326277501933e-65
3.4978059506547355e-66
5.3161002068506664e-67
8.0796138516454e-68
1.2279708329721854e-68
1.8663173690204506e-69
2.8365010213449523e-70
4.311023504171651e-71
6.552059566933704e-72
9.958072491858577e-73
1.51346621226641e-73
2.3002242427384855e-74
3.4959694005712494e-75
5.313308947296407e-76
8.075371587865444e-77
1.2273260773832164e-77
1.8653374446426428e-78
2.8350116945323585e-79
4.308759967918298e-80
6.548619357352494e-81
9.952843928832414e-82
9.952843928832414e-82
Gute Zeit OSWALD
Hier noch ein Beispiel: eine harmonische Reihe.
Durch kontinuierliche Erhöhung kann man die Annäherung an die Endsumme
verfolgen. Wen man die letzte Zeile des Programms ausblendet, werden die
einzelnen Werte nicht angezeigt . Ein hohe Obergrenze erreicht den Kontrollwert.
# Die harmonische Reihe 1/x**2
# Summe der Reihe = pi**2/6 = 1.64.......
import math
from math import pi
print("Vorweg : Ergebniskontrolle :" ,pi*pi/6)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")
Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))
x=1
partialsum=[]
for x in range(Beginn, Obergrenze
):
x= (1/x**2)
partialsum.append(x)
print(sum(partialsum))
####################################
Gute Zeit OSWALD
Durch kontinuierliche Erhöhung kann man die Annäherung an die Endsumme
verfolgen. Wen man die letzte Zeile des Programms ausblendet, werden die
einzelnen Werte nicht angezeigt . Ein hohe Obergrenze erreicht den Kontrollwert.
# Die harmonische Reihe 1/x**2
# Summe der Reihe = pi**2/6 = 1.64.......
import math
from math import pi
print("Vorweg : Ergebniskontrolle :" ,pi*pi/6)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")
Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))
x=1
partialsum=[]
for x in range(Beginn, Obergrenze
):
x= (1/x**2)
partialsum.append(x)
print(sum(partialsum))
####################################
Gute Zeit OSWALD
- __blackjack__
- User
- Beiträge: 13236
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@OSWALD: `math` wird importiert, aber nicht verwendet.
Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase).
Die Liste `partialsum` wird gar nicht wirklich verwendet, denn statt die Werte im Speicher zu sammeln und immer wieder alle aufzusummieren, wäre es effizienter nur die aktuelle Summe zu speichern.
Es ist auch verwirrend `x` unnötigerweise vor der Schleife zu initialisieren und *in* der Schleife dann noch mal an einen anderen Wert zu binden.
Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase).
Die Liste `partialsum` wird gar nicht wirklich verwendet, denn statt die Werte im Speicher zu sammeln und immer wieder alle aufzusummieren, wäre es effizienter nur die aktuelle Summe zu speichern.
Es ist auch verwirrend `x` unnötigerweise vor der Schleife zu initialisieren und *in* der Schleife dann noch mal an einen anderen Wert zu binden.
Code: Alles auswählen
#!/usr/bin/env python3
"""
Die harmonische Reihe 1/x²
Summe der Reihe = pi²/6 = 1.64…
"""
from math import pi as PI
def main():
grenzwert = PI ** 2 / 6
print("Vorweg : Ergebniskontrolle:", grenzwert)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")
beginn = int(input("Begin: "))
obergrenze = int(input("Obergrenze: "))
partial_sum = 0
for x in range(beginn, obergrenze):
partial_sum += 1 / x ** 2
print(f"{partial_sum} (Abweichung {grenzwert - partial_sum})")
if __name__ == "__main__":
main()
Please call it what it is: copyright infringement, not piracy. Piracy takes place in international waters, and involves one or more of theft, murder, rape and kidnapping. Making an unauthorized copy of a piece of software is not piracy, it is an infringement of a government-granted monopoly.
Hallo __blackjack__, .
Python ist leider immer noch mein Problem.
Es ist typisch. Wenn man eine Programmiersprache nicht von Grund auf systematisch lernt und glaubt,
dass Python so leicht zu erlernen ist, dann passieren immer wieder diese leidigen Fehler.
Ein technisches Problem habe ich mit dem Kopieren. Bei diesem Vorgang wird das Original-
format des Textes offenbar automatisch verändert. Ich rücke natürlich stets korrekt ein, denn sonst würde
der Code ja nicht laufen.
Da mein Augenlicht nicht mehr das beste ist, tue ich mir mit dem Lesen des Python-Textes im Forum schwer. mit der
kleinen Schriftgröße.
Für das perfekte Superprogramm danke ich natürlich herzlich.
Ic persönlich habe noch nie einen Unterricht in Python oder einer anderen Sprache genossen.
Angelesen ist eben nicht gelernt. Reines Hobby. Vielleicht mache ich doch noch den einen oder anderen Fortschritt
bei Python. Auf jeden Fall macht es riesigen Spaß. Es hätte eben schon vor Jahren Python geben müssen.
Gute Zeit
Oswald
Python ist leider immer noch mein Problem.
Es ist typisch. Wenn man eine Programmiersprache nicht von Grund auf systematisch lernt und glaubt,
dass Python so leicht zu erlernen ist, dann passieren immer wieder diese leidigen Fehler.
Ein technisches Problem habe ich mit dem Kopieren. Bei diesem Vorgang wird das Original-
format des Textes offenbar automatisch verändert. Ich rücke natürlich stets korrekt ein, denn sonst würde
der Code ja nicht laufen.
Da mein Augenlicht nicht mehr das beste ist, tue ich mir mit dem Lesen des Python-Textes im Forum schwer. mit der
kleinen Schriftgröße.
Für das perfekte Superprogramm danke ich natürlich herzlich.
Ic persönlich habe noch nie einen Unterricht in Python oder einer anderen Sprache genossen.
Angelesen ist eben nicht gelernt. Reines Hobby. Vielleicht mache ich doch noch den einen oder anderen Fortschritt
bei Python. Auf jeden Fall macht es riesigen Spaß. Es hätte eben schon vor Jahren Python geben müssen.
Gute Zeit
Oswald
Du musst beim einkopieren des Codes die Code-Tags darum machen. Leider. Das heisst zu Beginn muss
[code*]
stehen, und dann danach
[/code*]
ABER ACHTUNG: ohne die Sternchen!
Du kannst das auch mit dem </>-Knopf im vollstaendigen Editor erledigen lassen. Einfach mal ein bisschen mit der Vorschau herumspielen.
Was die Textgroesse angeht: fuer mich funktioniert es super, den Browser einfach mit "Control-+" und "Control--" oder ueber das Menue alles hochskalieren zu lassen. Probier auch das mal aus. Das Layout der Seite funktioniert dann immer noch gut.
[code*]
stehen, und dann danach
[/code*]
ABER ACHTUNG: ohne die Sternchen!
Du kannst das auch mit dem </>-Knopf im vollstaendigen Editor erledigen lassen. Einfach mal ein bisschen mit der Vorschau herumspielen.
Was die Textgroesse angeht: fuer mich funktioniert es super, den Browser einfach mit "Control-+" und "Control--" oder ueber das Menue alles hochskalieren zu lassen. Probier auch das mal aus. Das Layout der Seite funktioniert dann immer noch gut.
Code: Alles auswählen
Code: Alles auswählen
[code]
Versuch einer korrekten Kopie
########## eine von diversen "Leibniz Reihe"n
# (-1)**n / 2*n +1 = pi/4 =0.79
#Autor:blackjack und OSWALD vom 3.6.22
#!/usr/bin/env python3
from math import pi
print("Partialsumme von pi/4 = ", pi/4)
def main():
grenzwert = 0.79
print("Vorweg : Ergebniskontrolle:", grenzwert)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")
beginn = int(input("Beginn: "))
obergrenze = int(input("Obergrenze: "))
partial_sum = 0
for x in range(beginn, obergrenze):
partial_sum += (-1**x) / (2*x+1)
print(f"{partial_sum} (Abweichung {grenzwert - partial_sum})")
if __name__ == "__main__":
main()
Hallo Oswald, willkommen im Forum und viel Spaß mit Python!
1. Klick auf das Symbol </> - das hatte in deinem letzten Versuch schon funktioniert, ich sehe da sogar 2-3 Code-Felder.
2. Direkt anschließend drücke 4x auf die Return-Taste, um ein paar Leerzeilen zwischen den Code-Tags einzufügen.
3. Zuletzt drücke noch 2x auf die Cursor-nach-oben-Taste, um wieder genau in der Mitte der Leerzeilen zu landen.
An dieser Stelle kannst du dann dein Programm einfügen. Du erhältst eine besser lesbare Darstellung für alle.
Versuch es vielleicht mal so:
1. Klick auf das Symbol </> - das hatte in deinem letzten Versuch schon funktioniert, ich sehe da sogar 2-3 Code-Felder.
2. Direkt anschließend drücke 4x auf die Return-Taste, um ein paar Leerzeilen zwischen den Code-Tags einzufügen.
3. Zuletzt drücke noch 2x auf die Cursor-nach-oben-Taste, um wieder genau in der Mitte der Leerzeilen zu landen.
An dieser Stelle kannst du dann dein Programm einfügen. Du erhältst eine besser lesbare Darstellung für alle.
MorgenGrauen: 1 Welt, 8 Rassen, 13 Gilden, >250 Abenteuer, >5000 Waffen & Rüstungen,
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
Code: Alles auswählen
Hallo, herzlichen Dank für die sehr gute Beschreibung und Hilfe.
Mit einem abschließenden Beitrag zum Thema "Reihen" h ier der Test
#Hier soll zum Abschluß des Themas "Unendliche Reihen"
#noch einmal die Leistungfsfähigkeit von Python demonstriert werden.
#In einer Mathematik-Vorlesung zum Thema stellte der Dozent als
#einführendes Beispiel die Reihe 1/(x**2 -1) vor und bemerkte:
#"diese Reihe hat die Summe 3/4 und das will ich jetzt beweisen".
#
Der mathematische Beweis war dann eine höchst komplizierte Berechnung.
#Die Studenten ? kaum einer konnte zunächst folgen oder begreifen.
#Der Dozent ? " Man muss sich erst mal ein paar Tricks einfallen lassen,
#sonst wird das nix; z.B. muss ich jetzt nicht mit der '1', sondern mit '2'
# als S tart begimnnen! "
#
Natürlich kann der Student mit der alleinigen Anwendung von Python
#Mathmetik niemals begreifen, aber er kann zumindest seine Arbeit
#überprüfen. Es ist so wie mit der Anwendung des Taschenrechners
#beim Lernen des Einmaleins.
import math
from math import *
grenzwert = 0.75
print("Grenzwert = " , grenzwert)
beginn= int(input("Beginn : ",))
obergrenze =int(input("Obergrenze : " ,))
partial_sum =[]
for x in range(beginn, obergrenze):
x = 1/(x**2-1)
partial_sum.append(x)
print(sum(partial_sum))
Gute Zeit OSWALD
- __blackjack__
- User
- Beiträge: 13236
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@OSWALD: Leistungsfähigkeit von Python und den Bibliotheken die es dafür gibt, kann man für diesen Fall wohl eher so zeigen:
Code: Alles auswählen
In [88]: import sympy
In [89]: from sympy.abc import x
In [90]: sympy.pprint(sympy.Sum(1 / (x ** 2 - 1), (x, 2, sympy.oo)))
∞
____
╲
╲ 1
╲ ──────
╱ 2
╱ x - 1
╱
‾‾‾‾
x = 2
In [91]: sympy.pprint(sympy.Sum(1 / (x ** 2 - 1), (x, 2, sympy.oo)).nsimplify())
3/4
Please call it what it is: copyright infringement, not piracy. Piracy takes place in international waters, and involves one or more of theft, murder, rape and kidnapping. Making an unauthorized copy of a piece of software is not piracy, it is an infringement of a government-granted monopoly.
Code: Alles auswählen
[/
Eine neue "Spielerei" von OSWALD
# Die Auswertung von Reihen und die Berechnung
# von Partialsummen steht in einem engen
# mathem. Zusammenung mit der Berechnung
# von bestimmnten Integralen. Dort erfolgt die
# Berechnung allerdings anders und kann in der
# Praxis der angewandten Mathematik eventuell
# viel umständlicher sein.
#
# Um die Rechnerei mit den Zahlen zu vereinfachen,
# habe ich mir einen nützlichen Code ausgedacht.
# Dieser kann auch mit einer höheren Anzahl von
# Polynom-Gliedern durchgeführt werden und erweitert
# damit die Anwendungsmöglichkeiten.
#####################################1.Beispiel
import math
from math import e
# Zur Auswertung geben Sie bitte zuerst die Obergenze(a_oben) und die
# Untergrenze(b_unten) ein. Anschließend erfolgt sofort die Auswertung
# des best. Integrals
def main():
# f(x) = - x**2+ 3*x + 4
# F(x) = - 1/3*x**3 + 3/2*x**2 +4
x = 0
y= 0
a_oben = int(input("a_oben :", ))
b_unten = int(input("b_unten:" , ))
x = - 1/3* a_oben**3 + (3/2* b_unten**2 ) + 4
print(x)
if __name__ == "__main__":
main()
################################### 2.Beispiel
def main():
# f(x) = x**3 - 2*x** 2 - 4*x +5
# F(x) = 1/3*x**4 + 3/2*x**3 - 4/4*x**2 +5 dx
a_oben = int(input("a_oben :", ))
b_unten = int(input("b_unten:" , ))
x = - 1/3* a_oben**3 + 3/2* b_unten**2 - 4/4*b_unten**2 +5
print(x)
if __name__ == "__main__":
main()
######################################3.Beispiel
def main():
# F(x) = 3/4*e** (3*x-4)
a_oben = int(input("a_oben :", ))
b_unten = int(input("b_unten:" , ))
x = 3/4*e**(3*a_oben-4)
print(x)
if __name__ == "__main__":
main()
##############################################
#Zur Kontrolle der einzelnen Terme können Sie das folgende
#beiliegende Programm verwenden
###########Auswertung beliebiger mathematischer Funktionen 29.5.2022
import math
from math import *
print(" A u s w e r t u n g beliebiger mathematischer T e r m e ")
print()
print("")
Wurzel =lambda x,y : x **(1/y)
def W10(Rad, Wp):
mantisse =(1/Wp)* log10(Rad)
Ergebnis= round(10 **mantisse,4 )
return Ergebnis
def Wnat(R, Wp):
mantisse =(1/Wp)* log(R)
Ergebnis= round(2.7183 **mantisse ,6)
return Ergebnis
print(" Geben Sie bitte einzelne oder gleichzeitig mehrere Terme ein:")
print(" erlaubt sind alle mathematischen in Python integrierten Funktionen, sowie eigene Funktionen")
print(" z.B. die hier gelisteten Wurzelfunktionen :")
print("und 'W10)'und 'Wnat' , sowie pi/6, e* 5 , log10, log, W10(e,2) , Wurzel(100,3) usw. ")
print ()
print("Beispiel für eine mehrfache Eingabe: : sin(5)+ cos(0)-exp(2) +W10(100,2) -Wnat(1100,3) +log(2*5 )")
print ()
print ()
print ()
p= input("Bitte Terme zur Auswertung eintragen :" , )
print ()
print ()
print("Ergebnis = :", eval(p))
# bei a_oben = 2 und B_unt ist das Ergebnis = 5.54179201.......
#########################################
code]
Code: Alles auswählen
[/
3.06.22
Die Berechnung des Flächen-Integrals
wurde optimiert.
#1.Beispiel a_oben = 5
# b_unten = 2
# Ergebnis = F_a - F_b
def main():
# f(x) = 5
# F(x) = 5*x +C
a_oben =0
b_unten=0
a_oben = int(input("a_oben :", ))
b_unten = int(input("b_unten:" , ))
print("a_oben = ", a_oben )
print("b_unten= ", b_unten)
x1= 5*a_oben
x2= 5*b_unten
print( F_a - F_b )
if __name__ == "__main__":
main()
#######################
#2.Beispiel
# a_oben = 2
# b:_unten = -2
# Ergebnis = F_a - F_b
def main():
# f(x) = (x- 2 )*(x+2) = (x**2 - 4*x)
# F(x) = 1/3*x**3 - 4*x +C
a_oben =2
b_unten= -2
a_oben = int(input("a_oben :", ))
b_unten = int(input("b_unten:" , ))
print("a_oben = ", a_oben )
print("b_unten= ", b_unten)
F_a = 1/3*a_oben**3 - 4* a_oben
F_b= 1/3*b_unten**3 - 4*(b_unten)
print( F_a - F_b )
if __name__ == "__main__":
main()
Gute Zeit
OSDWALD
code]
Statt Formeln zweimal im Code zu haben, definiert man sich Funktionen. a_oben und b_unten werden mit Werten initialisiert, die gleich durch einen Input überschrieben werden. Bei dieser mathematischen Formel würde man erwarten, dass man Kommazahlen eingeben kann.
Das a und das b sind verwirrend, was ist die Bedeutung der Variablen - a, b oder oben und unten?
Das a und das b sind verwirrend, was ist die Bedeutung der Variablen - a, b oder oben und unten?
Code: Alles auswählen
def integrated_f(x):
# f(x) = (x- 2) * (x+2) = x**2 - 4
return x**3 / 3 - 4 * x
def main():
oben = float(input("obere Grenze :"))
unten = float(input("untere Grenze:"))
print(integrated_f(oben) - integrated_f(unten))
if __name__ == "__main__":
main()
Code: Alles auswählen
[/
HALLO IRIUS:
Herzlichen Dank für dieses geniale MEISTERSTÜCK.
Ich gehe mal davon aus, dass es sich bei diesem Programm um das "berüchtigte" OOP -Konzept handelt.
An OOP habe ich mich bisher noch nicht heran gewagt.
Jetzt versuche ich das umgehend. Ist halt auch nicht unbedingt Anfängersache.
.
Leider hat mein Programmier-Versuch nur bei ganz einfachen Funktionen
des bestimmten Integrals scheinbar geklappt.
Aber eigentlich kann man nur aus den eigenen Fehlern lernen
und professionelle Hilfe ist unersetzbar.
Vielen Dank und gute Zeit OSWALD
code]