kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@OSWALD: Die Laufvariablen so zu benennen wie das worüber iteriert wird, ist keine gute Idee. Und Listen in der Einzahl zu benennen auch nicht. `abzug` steht ja (bei der ersten Verwendung des Namens) nicht für *einen* Abzug, sondern für mehrere Abzüge.

Die `map()`-Funktion ist auch ganz nett:

Code: Alles auswählen

#!/usr/bin/env python3
from math import cos, exp, sin
from operator import sub as subtract


def main():
    gesamtwerte = [sin(5), cos(4), sin(1)]
    abzuege = [cos(3), sin(2), exp(2)]

    for profit in map(subtract, gesamtwerte, abzuege):
        print(f"Profit: {profit}")


if __name__ == "__main__":
    main()
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo lakjack , Danke für
die schnelle Antwort. Habe dein Programm schnell umgesetzt, mit ganz 'irren' Werten,
die aber anscheinend alle exakt umgesetzt werden. Schon ganz schön 'cool'.
Gute Zeit OSWALD

Code: Alles auswählen



#!/usr/bin/env python3
from math import cos, exp, sin, e,log
from operator import sub as subtract


def main():
    gesamtwerte = [sin(5)**3, cos(4)**1/e, sin(1)**-2]
    abzuege = [cos(3), log(2), exp(2)]

    for profit in map(subtract, gesamtwerte, abzuege):
        print(f"Profit: {profit}")


if __name__ == "__main__":
    main()


OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Funktionen in Python
Wer nachts nicht schlafen kann, muss nicht unbedingt 'Schäfchen zählen'.
Hier eine wirksame Alternative.
NOch einmal hier OSWALD

Code: Alles auswählen


def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]
 
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return

 
# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")
  
# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print( "Values inside the function: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print( "Values outside the function: ", mylist)
 
 
# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist = [1,2,3,4]; # This would assig new reference in mylist
   print ("Values inside the function: ", mylist)
   return

# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print ("Values outside the function: ", mylist)
  
 
  
  
#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return;

  
  
 

 
#!/usr/bin/python

# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print (str)
   return;

# Now you can call printme function
printme( str = "My string")

# Function definition is here
def printinfo( name, age ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print ("Age ", age)
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
 
 
 
#!/usr/bin/python

# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print ("Name: ", name)
   print( "Age ", age)
   return;

# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )
 
 

# Function definition is here
def printinfo( arg1, *vartuple ):
   "This prints a variable passed arguments"
   print ("Output is: ")
   print (arg1)
   for var in vartuple:
      print (var)
   return;

 
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;

# Now you can call sum as a function
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))
 
 
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print ("Inside the function : ", total)
   return total;

# Now you can call sum function
total = sum( 10, 20 );
print( "Outside the function : ", total )
 
  
total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print( "Inside the function local total : ", total)
   return total;

# Now you can call sum function
sum( 10, 20 );
print( "Outside the function global total : ", total )




Gute Zeit
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Die Frage 'ist die Zahl der Primzahlen in der Fibonacci-Folge unendlich groß?'
ist bis heute ein ungelöstes Problem der Mathematik.
Was kann der Python-Fan tun, um dieser Frage selbst einmal nachzugehen.
Dazu habe ich im Internet nach Programmen gesucht, die einmal sehr schnell sind, um auch
lange Fibonacci-.Folgen in annehmbarer Zeit zu testen und dann ein Programm, das
sehr zuverlässig bestimmen kann, ob eine Ptrimahl vorliegt oder nicht.
Icjh habe 2 solche Programme gefunden, die sich nach meiner Meiunung
dafür sehr gut eignen.
Zuerst ermittelt man die F-Folge mit 100 Zahlen, eventuell auch höher.
Aus der erhaltenen Liste trägt man die 'Verdachtszahlen ' ein und prüft auf
Primzahl.
Natürlich wieder nur ein Spielchen, aber man kann dabei aus etwas PYTHON
lernen

.

Code: Alles auswählen


# Beispiele    A LLES Prmzahlen :
#"n = 130021, 148091, 201107, 397379, 433781, 590041, 593689, 604711, 931517, 1049897,
#1285607, 1636007, 1803059, 1968721, 2904353, 3244369, 3340367"



import math
import time 
 
print(time.strftime("%d.%m.%Y %H:%M:%S"))                           
now = time.localtime()                                                              
print( now.tm_mday,".",now.tm_mon,".", now.tm_year   )
 
from math import sqrt
print("                            Negative Zahlen werden nicht akzeptiert")
def get_posint1(msg = "Bitte eine natürliche Zahl  (>  2 )  eingeben: "): 
        
        try:
          eingabe = int(input(msg))
          return eingabe  
          print(" Bitte nochmals probieren...")
        except ValueError:
            print(" Ungültige Eingabe,")

def sieb(n):
    L = [True]*n                  # L = Liste mit  'gültigen  Werten
    L[0] = L[1] = False        #  keine Primzahlen
    sqrtN = int(sqrt(n))       # Grenze für  die Suche
    i = 2
    while i <= sqrtN:
        if L[i]:                         # L[i] muss True sein
            for j in range(2*i, n, i):
                L[j] = False
        i = i + 1
    liste_prim = []                 #die Liste mit Primzahlen  ist  - noch - l e e r
    for j in range(n):
        if L[j]:
            liste_prim.append(j)
    return liste_prim

def trial_div(n):
    liste_faktoren = []
    exponent = 0
    
    sqrt_n = int(sqrt(n))
    liste_prim = sieb(sqrt_n)
    
    index = 0
    while index < len(liste_prim):
        d = liste_prim[index]
        exponent = 0
        while n % d == 0:
            exponent += 1
            n = n // d
        if exponent > 0:
            liste_faktoren.append([d, exponent])
        index += 1    
    
    if n != 1:
        liste_faktoren.append([n, 1])
    return liste_faktoren   


def pretty_print(n, L):
    """
    Diese Funktion druckt die Primfaktorzerlegung in dieser Form aus
      p1^e1 * p2^e2 * ... * pk^ek.
    """
    m = len(L) - 1
    print(n, "=", end = " ")
    for i in range(m):
        if L[i][1] != 1:
            print(str(L[i][0]) + "^" + str(L[i][1]), end = " * ")
        else:
            print(str(L[i][0]),  end = " * ")
    if L[m][1] != 1:
        print(str(L[m][0]) + "^" + str(L[m][1]))        
    else:
        print(str(L[m][0]))     
#############################Main  als Funktion !!    
def main():
    print()
    print("***************************")
    print("    Primfaktorzerlegung   ")
    print("***************************")
    print()
    n = get_posint1()
    print()

    #start = clock()
    
    P = trial_div(n)
   # stop = clock()

    lenP = len(P)
    if (lenP == 1) and (P[0][1] == 1):
        print(n, "ist eine Primzahl")
    else: 
        pretty_print(n, P)
    
        # Ueberpruefung
        produkt = 1
        for i in range(lenP):
            produkt = produkt * (P[i][0]**P[i][1])
        if produkt == n:
            print("\nÜberprüfung korrekt     \n")
        else:
            print("\nFehler\n")

main()

###############################################

def fib(n):
    """Display the n first terms of Fibonacci sequence"""
    a, b = 0, 1
    i = 0
    while i < n:
        print(b)
        a, b = b, a+b
        i +=1

fib(100)
 


Viel Spass und Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

11.10.2022 17:47:34
11 . 10 . 2022
Negative Zahlen werden nicht akzeptiert

***************************
Primfaktorzerlegung
***************************

Bitte eine natürliche Zahl (> 2 ) eingeben: 420196140727489673

420196140727489673 = 6709 * 144481 * 433494437

Überprüfung korrekt

Wie zu ersehen ,köönen mit 8GB Hauptspeicher noch 8 Stellige Zahlen
innerhalb von 30 sec bearbeitet werden.
Die Primzahlen sind bei 100 F-Zahlen im oberen Bereich die
Primzahlen sehr rar.
Ich werde jetzt die Memory-Grenze meines PC austesten.
OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Für 18 Stellen reicht der Hauptspeicher mit 8 GB noch aus.
Bei Erweiterung durch den Spielespeicher wurden noch 19 Stellen bearbeitet,
aber selbst nach 30 min noch kein Ergebnis geliefert. Abbruch.
Bis zu 50 Stellen wurden 11 Proimzahlen ermittelt.
Insgesamt konnten also technisch bedingt keine zufriedenstellenden
Ergebissen erzielt werden.
Gute Zeit OSWALD
nezzcarth
User
Beiträge: 1632
Registriert: Samstag 16. April 2011, 12:47

OSWALD hat geschrieben: Dienstag 11. Oktober 2022, 16:22 Zuerst ermittelt man die F-Folge mit 100 Zahlen, eventuell auch höher.
Aus der erhaltenen Liste trägt man die 'Verdachtszahlen ' ein und prüft auf
Primzahl.
Bedeutet das, du tippst/kopierst die Ausgabe der Fibonnaci-Erzeugung per Hand in einen Eingabe-Prompt? Eigentlich kannst du den Code mit wenigen Änderungen so anpassen, dass das automatisch passiert, z.B. indem du die Fibonacci-Zahlen mit einem Generator erzeugst:

Code: Alles auswählen

In [32]: def iter_fibonacci():
    ...:     a, b = 0, 1
    ...:     while True:
    ...:         yield a
    ...:         a, b = a+b, a
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

15.10.2022

Hallo nezzcarth, danke für die gute Idee.
Ich werde umehend versuchen sie umzusetzen.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen


###########FIBONACCI mit MAP-Funktion
def fibonacci(count): 
    fib_list = [0, 1] 
  
    any(map(lambda _: fib_list.append(sum(fib_list[-2:])), range(2, count))) 
    return fib_list[:count] 
print(fibonacci(40)) 

16.10.22
Leider konnte ich den Vorschlag von nezzcarth nicht
erfolgreich umsetzen.
Das eigentliche Problem konnte damit auch nicht gelöst werden.
Gesuchtrist immer noch ein Code, der die Auswahl von Partialbereichen erlaubt
Als 'Ersatz' habe ich zunächst einen sehr eleganten Code gefunden.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

##########OSWALD  am  17.10.2022
from functools import lru_cache

@lru_cache(maxsize=1000)
def fibonacci(n):
    if n == 1 :
        return 1
    elif n == 2:
        return 2
    elif n > 2:
        return fibonacci(n-1) + fibonacci(n-2)
    unten=0
    oben =0
unten = int(input("Untergrenze :", ))
oben =  int(input("Obergrenze :",  ))


for i in range(unten,oben):
    print(i, '::', fibonacci(i))






17.10.22
Hier ist der notwendige Code, um beliebige Intervalle
uas der Fobonacci-S erie zu erzeugen: gier ewin Beispi:el
============= RESTART: C:\PYTHON310\FIBONA CCIHOME\FIBOvovBisaaa.py ============
Untergrenze :300
Obergrenze :320
300 :: 359579325206583560961765665172189099052367214309267232255589801
301 :: 581811569836004006491505558634099066259034153405766997246569401
302 :: 941390895042587567453271223806288165311401367715034229502159202
303 :: 1523202464878591573944776782440387231570435521120801226748728603
304 :: 2464593359921179141398048006246675396881836888835835456250887805
305 :: 3987795824799770715342824788687062628452272409956636682999616408
306 :: 6452389184720949856740872794933738025334109298792472139250504213
307 :: 10440185009520720572083697583620800653786381708749108822250120621
308 :: 16892574194241670428824570378554538679120491007541580961500624834
309 :: 27332759203762391000908267962175339332906872716290689783750745455
310 :: 44225333398004061429732838340729878012027363723832270745251370289
311 :: 71558092601766452430641106302905217344934236440122960529002115744
312 :: 115783425999770513860373944643635095356961600163955231274253486033
313 :: 187341518601536966291015050946540312701895836604078191803255601777
314 :: 303124944601307480151388995590175408058857436768033423077509087810
315 :: 490466463202844446442404046536715720760753273372111614880764689587
316 :: 793591407804151926593793042126891128819610710140145037958273777397
317 :: 1284057871006996373036197088663606849580363983512256652839038466984
318 :: 2077649278811148299629990130790497978399974693652401690797312244381
319 :: 3361707149818144672666187219454104827980338677164658343636350711365
320 :: 5439356428629292972296177350244602806380313370817060034433662955746

Jetzt wird die Suche nach hohen Primzahlen bei Fibonacci möglich
- mit geignetem Werkzeug.
Gute Zeit Oswald
nezzcarth
User
Beiträge: 1632
Registriert: Samstag 16. April 2011, 12:47

OSWALD hat geschrieben: Montag 17. Oktober 2022, 10:20 Hier ist der notwendige Code, um beliebige Intervalle
Der von dir gezeigte Code funktioniert leider eben nicht für beliebige Intervalle, sondern ist beschränkt auf den Wert des Parameters "maxsize" + die Rekursionsgrenze von Python (500 - etwas "technischem Versatz", je nach Ausführungsumgebung). In Ipython klappt es bei mir z.B. nur mit Werten < 1494. Das liegt daran, dass auch die gezeigte Version letztendlich rekursiv arbeitet und dies nur mit einem Cache etwas auffängt. Mein Vorschlag kommt ohne Rekursion aus und benötigt nur die letzten beiden Werte. Möchte man erst ab einer bestimmten Fibonacci-Zahl beginnen, ist es einfach, den Code so anzupassen, dass man "a" und "b" mit zwei bereits bekannten Fibonaccizahlen initialisiert und von dort dann fortfährt.

Ich glaube, man muss auch bei der Terminologie berücksichtigen. In deinem Beispiel ist die untere Schranke die 300ste Fibonacci-Zahl, nicht deren Wert. Wenn man indes bestimmte Zahlenbereiche untersuchen möchte, würde ich jedoch denken, dass man den Wert der Zahl meint und nicht ihre Position in der Folge.

Anbei mal ein Beispiel, das "endlos" alle Zahlen durchprobiert:

Code: Alles auswählen

#!/usr/bin/env python3
from sympy.ntheory.primetest import isprime

def iter_fibonacci(a=0, b=1):
    while True:
        yield a
        a, b = a + b, a

def main():
    for i, candidate in enumerate(iter_fibonacci()):
        if isprime(candidate):
            print(i, candidate)

if __name__ == '__main__':
    main()
In weniger als zwei Minuten komme ich dabei z.B. auf folgende Zahl:

Code: Alles auswählen

1056597787330886165607283376335772947912004036112564579874375352759594439245750115025661751635771858498604063538249919150521910143408974582829038241321765899686974372065892543538158617334073268472725275364083905833609186070912661512269116100758775431451837305406774829615930445817607326150685658795315867111693264823732004839656664575237111288179099232440466298431582104527085532877031549603964884101691956585163355851591142327980744624330187879064855304798755771686797051547007947771882372952667893427143690224381067780291488291525844107323034231967453469607389798265139480514915570754010362634536063309050925069684058402883158793747384557423242752292859137029927002634958591300831686286270148295738141642265185159474092374071727835227879093337721218970960045114467179521256582820857644478939615872693259767625051656784436320536214888099246970935202477840794020001804824934094322942647313245015464146235410381690956788503264561405618174143168558794485590593621905074843445469861525661965245856307816345300556329589695975628440616169746340959867964538987362157854244708043842221402221963277716301052548247805899502717820052033072255313071657586884240821681100976940998736672322113547366478126078861119513619044370696083360828601809924884717575519821133956492114471403028698547136465705828789219477311237793325673906241774008541206351713780742201285265869533452824000524673440422889327800328362335547519511501666197619108063285902418799306753187272256356221431103854880105596403020095508495581348319107302916061047962850483220408241536724453572645136434687510278707999281526171375525625955687762398910760113471086947693290849443284396138463694877303972778628913002680531451135439058230938508307644282628222440206903725318897236157720164030865445790151149151226995439617177019234605884244198267136453281188424540649497573644414770526808655328967088370380579677911448765589873573311772376689968432217235625731351030824652263016860210144187956704470629348157475577780655133842312690878825193342235991049335995169792504550670357

Das verwendet jetzt eine Funktion aus dem Sympy-Paket, die einen geeigneten, effizienten Primzahlentest wählt. Kann aber natürlich auch ein selbstgeschriebener MIller-Rabin-Test oder so sein, wenn man möchte. Wenn man ab einem bestimmten Zahlenbereich suchen möchte, ist das wie gesagt mit minimalem Aufwand umsetzbar. Für einen bestimmten Zahlenbereich bietet sich auch ein Sieb an.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo nezzcarth, wie bereits erwähnt, war ich nicht in der Lage Deinen Vorschlag
erfolgreich umzusetzen. Ich wäre nie in der Lage einen perfekten, professionellen
Code zu schreiben. Alles im Rahmen meiner Möglichkeiten. Ein 'Spielchen' eben.
Deshalb sind mir in mehrfacher Hinsicht sehr reale Grenzen gesetzt.
Jedenfalls werde ich Dein Programm sofort studieren und testen, swie
weit ich mit meinem PC komme. 'learning by Doing.
Als Mitglied hier im Python - Forum hat man den großen Vorteil, immer wieder
vom Wissen und Können der PythonProfis zu profitieren , zu lernen.
Dafür bin ich sehr dankbar und sicher auch die zahlreichen Leser , vor allem wohl Studenten.
Eine Frage noch: habe ich richtig verstanden, dass meine Ergebnisse, also die konkreten
Fibo-Zahlen , in den hohen Bwreichen , falsch sind ?
Ich möchte mich noch einmal für Deine wertvolle Beratung danken.
Ich werde dadurch nch stärker zu meinem Hobby moriviert.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo nezzcarth, wie bereits erwähnt, war ich nicht in der Lage Deinen Vorschlag
erfolgreich umzusetzen. Ich wäre nie in der Lage einen perfekten, professionellen
Code zu schreiben. Alles im Rahmen meiner Möglichkeiten. Ein 'Spielchen' eben.
Deshalb sind mir in mehrfacher Hinsicht sehr reale Grenzen gesetzt.
Jedenfalls werde ich Dein Programm sofort studieren und testen, swie
weit ich mit meinem PC komme. 'learning by Doing.
Als Mitglied hier im Python - Forum hat man den großen Vorteil, immer wieder
vom Wissen und Können der PythonProfis zu profitieren , zu lernen.
Dafür bin ich sehr dankbar und sicher auch die zahlreichen Leser , vor allem wohl Studenten.
Eine Frage noch: habe ich richtig verstanden, dass meine Ergebnisse, also die konkreten
Fibo-Zahlen , in den hohen Bwreichen , falsch sind ?
Ich möchte mich noch einmal für Deine wertvolle Beratung danken.
Ich werde dadurch nch stärker zu meinem Hobby moriviert.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

18.10.2022
Ich habe die Auswertungen beider Programme verglichen
Beide Programme ergeben exakt die gleichjen Zahlen.
Es wird allerdings eine Verschiebung um eine Nummer festgestellt.
Ich nehme an, dass es sich um unterschiedliche S tartwerte handelt,
Welcher Startwert ist korrekt ?
Die Frage ist jetzt :bis zu welcher Höhe .
Der Test wurde mit Spyder 5 ausgeführt.

Gute Zeit OSWALD


137 19134702400093278081449423917
359 475420437734698220747368027166749382927701417016557193662268716376935476241 NEZ
#######################################################
136 :: 19134702400093278081449423917
358 :: 475420437734698220747368027166749382927701417016557193662268716376935476241 OSW
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Beide Startwerte sind korrekt. Es kommt darauf an ob die Fibonacci-Folge mit 0, 1 oder mit 1, 1 beginnt. Es gibt sogar Leute die sagen die beginnt mit 1, 2.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
nezzcarth
User
Beiträge: 1632
Registriert: Samstag 16. April 2011, 12:47

OSWALD hat geschrieben: Dienstag 18. Oktober 2022, 08:39 Hallo nezzcarth, wie bereits erwähnt, war ich nicht in der Lage Deinen Vorschlag
erfolgreich umzusetzen. Ich wäre nie in der Lage einen perfekten, professionellen
Code zu schreiben. Alles im Rahmen meiner Möglichkeiten. Ein 'Spielchen' eben.
Deshalb sind mir in mehrfacher Hinsicht sehr reale Grenzen gesetzt.
Das ist auch völlig in Ordnung und mein Hinweis war nur als konstruktiver Vorschlag gemeint. Da ich selbst Primzahlen mag, finde ich zudem die Fragestellung interessant :) . Entschuldige bitte, falls das falsch angekommen ist.
Eine Frage noch: habe ich richtig verstanden, dass meine Ergebnisse, also die konkreten
Fibo-Zahlen , in den hohen Bwreichen , falsch sind ?
Nein, die berechneten Zahlen sind korrekt. Mein Kommentar bezog sich nur darauf, dass der Code zur Berechnung der Fibonacci-Zahlen, den du gezeigt hattest, nicht für beliebe Untergrenzen funktioniert. Er ist begrenzt auf Werte um 1500. Das liegt daran, dass die Funktion rekursiv implementiert ist (sich also immer wieder selbst aufruft, bis ein Ende erreicht ist).
Python hat eine eingebaute Rekursionsgrenze bei 500 (+ etwas "technischem Versatz"). Mit dem "@lru_cache", wird diese Grenze auf etwa 1500 erhöht. Theoretisch kann man natürlich auch die Grenze und/oder den Cache erhöhen. Aber die prinzipielle Beschränkung bleibt bestehen. Zudem "merkt" der Rechner sich viel mehr Zahlen als nötig wären, die alle im Speicher bleiben. Bei der Variante, die ich gezeigt habe, werden immer nur die letzten beiden Werte vorgehalten. Daher besteht die Rekursionsgrenze nicht und man kann "beliebig" viele Fibonacci-Zahlen erzeugen (bis dann irgendwann eine andere technische Grenze kommt; in modernen Python Versionen etwa, wenn man Zahlen mit 4300+ Stellen ausgeben möchten – was man aber deaktivieren könnte).
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

'Im Jahre 1859 sah Bernhard Riemann in der Zetafunktion den Schlüssel, um die Anzahl der Primzahlen in einem bestimmten Intervall vorauszusagen.'(aus NZZ)

Hier geht es nur um 'Mathe-Spielchen. Aber ganz im Sinne des Python Forums.
Alles OK
Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[/

import pandas  as pd
import numpy as np
from math import  *
dict = {"StromDATEN": ["01.11.22",      #EröffnungsDatum
                  4573,            #Zählerstand Eröffnung      
                  "12.11.22",      #Datum aktuell 
                  5000,           # Ablesung  KWh
                  0.3164,         # Arbeitspreis 
                  5000-4573,      # aktueller Verbrauch KWh
                  0.3164*135,     # aktuelle  Stromkosten €
                  0.19*135,       # anfallende Mehrwertsteuer
                  177,          # Mehrwertsteuer, verändern
                  0.19*135+135+174],   # Stromkosten+ Fixkosten+Mehrwertsteuer
                                      
                     
            
     
      "MATH.Funktionen":[log(2),exp(2.1),sin(3),0,0,0,0,0,0,0],                                      
                     
      "Rechnen":[0,"Fix",0,0,0,0,(30**3),0,0,0],
      "Sonstiges":[0,"Fix",0,0,125**1/2,0,0,6*5,0,0]}          

inhalt = pd.DataFrame(dict)

 
inhalt.index = ["DatumFix","KWhFIX", "DatumNeu", "KWhNeu",
               "ArbeitsPr", "KWhAkt","LdKosten", 
               "MWSt","FixKosten","TOTAL "]
 

print(inhalt)


code]
01.11.2022

Mit dem Einstieg in die pandas-Bibliothek von Python
nun mein erster Versuch .
in der Energiekrise ist es angebracht die Strom kosten zu kontrollieren.
Der Code ist ein 'DataFrame' konstrukt.
Man kann zwei der Columnen auch zur Berechnung von Termen und
mehr verwenden. 

Gute Zeit  OSWALD
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

Ist keine wirklich sinnvolle Verwendung von Pandas. Spaltenwerte müssten davon von einem Typ sein und alle Werte in einer Spalte die gleiche Bedeutung haben, was hier nur die "MATH.Funktionen"-Spalte ist. Alle anderen Spalten fallen wegen gemischter Typen auf `object` zurück. Sämtliche Rechnungen passieren *bevor* die Daten in den `DataFrame` gesteckt werden. Letztlich wird das Objekt also nur wegen der Darstellung mittels `print()` verwendet.
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

2..11.22.
Hallo blackjack, vollkommen richtig , es ging mir nur darum, das Prinzip
von DataFrame als eine von vielen Möglichkeiten bei pandas zu verstehen,.
Ich habe einfach den Inhalt meiner SQlite 3- Anwendung übernommen.
Noch einfacher wäre es natürlich mit 'reinem' PYTHON gegangen.
Mit besten Grüßen OSWALD
Antworten