kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

Erstellung am 3.11.2022   von OSWALD
from dataclasses import dataclass
from math import *
  

@dataclass 
class Stereo() : 
    name : str  
    radius  :int  = 2 
    hoehe :  float = 10
    laenge:  int =   15
    
     
    Stereo  =  ("Kugelvolumen  =", (2 ** 3 * pi *4/3 ),0, 0 , 0) 
    print( Stereo )    
    Stereo  =  ("Kreisfläche  =", ( 2**2  * pi) ,2,10 ,10)
    print( Stereo )
    Stereo  =  ("Kreisumfang = ",(  2 *pi ),0,0 ,0 ) 
    print(Stereo)
    Stereo  =  ("Zylinder = ", ( 2**2 *pi * 15) ,0,0,0)
    print(Stereo) 
    print()
##################################


@dataclass
class Mathe:
  funktion:str
  x: float
  y :float


if __name__ == '__main__':

  wert = Mathe("Fcos(4)- sin(39 ))  ", cos(4) -sin(3) ,0    )
  print(wert)
  wert =  Mathe(" E * PI= ", (e * pi)/ 10, 0)
  print(wert)              
  wert= Mathe("300**1/3  =)" , (300**(1/3)), 0)
  

4.11.22
DATACLASS ist nichts anderes als eine 'verkapselte' normale Klasse.
Hier zwei erste und einfache Beispiele.
Bei der Programmierung von dataclas- Anwendungen ist vor allem zu
beachten, dass die 'Positionsargumente in der ricjtigen Reihenfolge
eingesetzt werden.

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

@OSWALD: Die Klasse `Stereo` ist falsch. Und wird auch nirgends verwendet. Der Code auf Klassenebene gehört dort nicht hin.
“It should be noted that no ethically-trained software engineer would ever consent to write a `DestroyBaghdad` procedure. Basic professional ethics would instead require him to write a `DestroyCity` procedure, to which `Baghdad` could be given as a parameter.” — Nathaniel Borenstein
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

5.11.22
Hallo blackjack , das war narürlich falsch, einfach gedankenlos. :roll:
So ist es natürlich richtig:

Code: Alles auswählen


from dataclasses import dataclass
from math import *
 
###################################
@dataclass
class Mathe:
  funktion:str
   
  x: float
  y :float 
   

if __name__ == '__main__':

   
  wert =  Mathe(" E * PI= ", (e * pi)/ 10, 0)
  print(wert)              
  wert= Mathe("300**(1/3 ) =)" , (300**(1/3)), 0)
  print(wert)
  wert=Mathe("1 /4**1/2  = )", ( 1/4**(1/2)) ,3*cos(2))
  print(wert)
  wert=Mathe("Hallo  OSWALD nicht leichtsinnig werden!! =  " , 3* 3 ,12/38)
  print(wert)
  wert = Mathe("Kugelvolumen ",( 4/3 * 2**3*pi), cos(2))
  print(wert)
  wert  = Mathe("Zylinder  ",(1**2*pi* 2), (cos(5)*exp(3) ))
  print(wert)
  wert = Mathe("Kreisfläche  u. Umfang",(1**2 * pi), 2*pi  )
  print(wert)

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

7.11.2022
Zahl- und Wortpalindrome sind sehr häufig.
Für Wortpalindrome gibt es eine mfangreiche Liste auf Wikipedia.
Zahlpalinndrome sind leicht zu erkenn oder zu konstruieren.
(anbei u. vielen anderen ein Code füf ZP.
Auch für Wortpalindrome gibt es Programme.

Aber wie häufig sind Palindromprimzahlen ?
Zwei habe ich im unteren Zahlenbereich gefunden
imit Primfaktorenzerlegung.
Es sind 34543 7891987

Die größten Chacen , eine PZ-Zahl zu finden , liegen bei Zahlen, die
PZ , die mit 3....3 u. 7.....7 beginnen und enden..

Code: Alles auswählen

num=int(input(" Bitte eine Zahl eingeben   :"  ,))
temp=num  
rev=0
while(num>0):
    dig=num%10
    rev=rev*10+dig
    num=num//10
if(temp==rev):

    print("Jetzt ist die Zahl ein Palimdrom")
else:
    print("Das ist kein Palindrom") 
Alles auch nur eine Spielerei, aber in der Zahlentheorie
durchaus noch ein Thema.

Gute Zeit OSWALD
Sirius3
User
Beiträge: 16664
Registriert: Sonntag 21. Oktober 2012, 17:20

Ein! Leerzeichen um Operatoren erhöht die Lesbarkeit ungemein. while und if sind keine Funktionen, sollten also nicht wie solche geschrieben werden; die Klammern sind hier überflüssig.
Am einfachsten geht der Vergleich über die Stringrepräsentation:

Code: Alles auswählen

if int(str(num)[::-1]) == num:
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

8.11.2022
Ich habe mich nach langem auch an ein sehr schweres Kapitel
herangewagt. Es sind die Funktionen des 'Itertools' .
Die einzelnen Funktionen sind , bis auf wenige, relativ leicht
zu verstehen.Davon habe ich einzelne hier vorgestellt.
Der Zugang zu itertools gelang erst, als ich erkannte, dass
auch numpy und evl operator zu importieren sind.
Die eigentlichen und großen Verständnisprobleme liegen
in der Anwendung der itertools- Funktionen in der Praxis.
Ein Beispiel liegt im zu letzt gezeigten Code vor.
Es gibt auch noch ein 'more-itertools'.
Der Zugang scheint aber schwierig zu sein.
Ein giutes Stück Arbeit liegt also insgesamt noch vor mir.
Gute Zeit OSWALD



Code: Alles auswählen


## Auswahl von Itertolls-Funktionen


#Funktion beginnt bei 10 und erhöht Schritt  um 4
#itertools kann nur zusammen mit numpy geladen werden 
import itertools
import numpy as np
import operator

for i in itertools.count(10,2):
    print(i) 
    if i > 20: 
        break

print()



#Akkumulation    
# 2*1, 3*2, 6t*4,24*5=120 

data = [1, 2, 3, 4, 5]
result = itertools.accumulate(data, operator.mul) 
for each in result: 
    print(each)
    

print()    

#Funktion  'max' gibt größtes  Element zurück

data  = [1,2, 3, 7.7, 50 , 2, 0, 4, 5, 0 , 10,30 ]
result = itertools.accumulate(data, max) 
for each in result: 
    print(each)

print()

# Itertools chain führt arrays zusammen
L1 = [[1, 2, 3, 4,20,30,40], [5, 6, 7,99,97,98], [81, 9, 100]]
flat_list = list(itertools.chain(*L1))
print(sorted(flat_list))
 

print()

#Permutationen einfach
 
inp_list = [4, 5, 6],[ 7,3,5]
permutations = list(itertools.permutations(inp_list))
print(permutations)
 
print() 
#und komplex 
inp_list = [1, 2, 3]
permutations = []
for i in range(1,len(inp_list)+1):
    permutations.extend(list(itertools.permutations(inp_list, r=i)))
print(permutations)

print()

#Jetzt ein Beispiel für die Anwendung einer itertool-Funktion
#in der Programmierpraxis: Quadrieren von Listennihalt 

n = 10
def fibonacci_nums(x=0, y=1):
    yield x
    while True:
        yield y
        x, y = y, x + y
print("Zuerst 10 Fibonaccizahlen erzeugen:")
result = list(itertools.islice(fibonacci_nums(), n))
print(result)
square = lambda x: x * x 
print("\Danach kann die Iteration des Listeninhalts erfolgen ")
print(list(map(square, result)))

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

12.11.2022
Nach technischen Problemen jetzt weitere
itertools-Funktionen.
Bei längerem arbeiten mit Itertools-Funktionen kann
der Speicher zu einem Restart zwingen.

Code: Alles auswählen


             
from itertools import*
import operator
 
print("itertools Akkumulation mit Operatoren") 
data = [3, 4, 6, 2, 1]
print(list(accumulate(data, operator.mul)) )     
print() 

data = [3, 4, 6, 2, 1]
print(list(accumulate(data, operator.add)) )     
print() 

data = [3, 4, 6, 2, 1]
print(list(accumulate(data, operator.pow)) )    

data = [3, 4, 6, 2, 1]
print(list(accumulate(data, operator.sub)) )    
print() 


print(list(accumulate(data, max)))              
print()
 
 
  
print("itertools.tee")
import itertools 
li= ['rot', 'orange', 'gelb', 'grün', 'blau'] 
 
 
#li = [2, 0, 2] 
    
# storing list in iterator 
iti = iter(li) 
    
# itertools.tee  erstellt  beliebig viele Listen von Iteratoren  
# iti bestimmt die maximale Anzahl von Iteratoren
it = itertools.tee(iti,4 ) 

  
print ("Die erzeugten Listen: ") 
for i in range (0, 3  ): 
    print (list(it[i])) 
print() 

# 
 
Daten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
result = itertools.dropwhile(lambda x: x<5, Daten) 
for each in result: 
    print(each)
print()

print("Gruppen mit Text") 
things = [("Tier", "Hund"), ("Tier", "Tiger"),
          ("Pflanze", "Eiche"), ("Fahrzeug",                                                                   "Motorrad"), 
          
          ("Fahrzeug", "Laster"),  ("Fahrzeug","Fahrrad ")]

for key, group in groupby(things, lambda x: x[0]):
    for thing in group:
        print(thing[1], key)
    print("")
 
print("Gruppen mit Zahlen")
l = [0, 0, 0, 1, 1, 2, 0, 0]
print([(k, list(g)) for k, g in itertools.groupby(l)])
# [(0, [0, 0, 0]), (1, [1, 1]), (2, [2]), (0, [0, 0])]
    
print()
print("Gruppierung mit lambda")

things = [("Tier", "Hund"), ("Tier", "Tiger"),
          ("Pflanze", "Eiche"), ("Fahrzeug",                                                                   "Motorrad"), 
          ("Fahrzeug", "Laster"),  ("Fahrzeug","Fahrrad ")]

for key, group in groupby(things, lambda x: x[0]):
    for thing in group:
        print(thing[1], key)
    print("")
print() 

print("itertools.product  für große Datenmengen")

values = ["Ass", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Bube", "Dame" , "King"] 
suits = ["Hearts", "Diamonds", "Clubs", "Spades"] 
print(list(itertools.product(values, suits)))

import string
print("Übertragen einer Zeichenkette")
print(list(itertools.compress(string.ascii_lowercase, itertools.cycle([1, 0, 0])))) 
['a', 'd', 'g', 'j', 'm', ' p', 's', 'v', 'y']
print(list(itertools.compress(string.ascii_uppercase, map(lambda x: x % 3 == 0, itertools.count())))) 
['a', 'd', 'g', 'j' , 'm', 'p', 's', 'v', 'y']






Jetzt ist Kreativität gefordert.
"Ich versuch was draus zu machen"
Gute Zeit OSWALD
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

18.11.22
Zurück zu Pandas. Pandas kann viel mehr als 'Series 'und 'DataFrame.', die sehr einfch zu
handhaben sind.Aufwendiger ist die Einarbeitung zin andere Funktionen,
wie :'pivot' und *groupby.' Ihre Bedeutun in der Datenanalyse ist beachtlich
und wird in den Bibliotheken sehr ausführlich behabdelt.
Beide weisen einige Ähnlichkeiten auf und beide enthalten
Dutzende von 'Variationen' , von denen ich einige probiert habe.
Heute geht es um 'pivot' .
Gute Zeit OSWALD

Code: Alles auswählen

import pandas as pd 
import numpy as np
 

print("1.Erstellung  DataFrame  aus Dict-Daten")
df = pd.DataFrame({'Student Names' : ['Jenny', 'Singh', 'Charles', 'Richard', 'Veena'],
                   'Category' : ['Online', 'Offline', 'Offline', 'Offline', 'Online'],
                   'Gender' : ['Female', 'Male', 'Male', 'Male', 'Female'],
                  'Courses': ['Java', 'Spark', 'PySpark','Hadoop','C'],
                   'Fee': [15000, 17000, 27000, 29000, 12000],
                   'Discount': [1100, 800, 1000, 1600, 600]})
print(df)
print("-------------") 

  
print("2.Erstellung der Pivot-Tabelle aus DF- Daten ")
# 
p_table = pd.pivot_table(df, index=['Gender']) 
print(p_table)
print("--------------")
 
print("3:Pivot-Tabelle Index/ Gender ")
p_table = pd.pivot_table(df, index=['Gender', 'Category'])                     
print(p_table)
print("--------------") 

print("4.Discount  Durchschnitt,  Summe  m ,w.   ") 
p_table = pd.pivot_table(df, index=['Gender'], aggfunc= {'Fee': 'mean', 'Discount': 'sum'})
print(p_table)
print("-------------") 

 
print("5.Pivot-Tabelle Parameterdarstellung")
p_table = pd.pivot_table(df, index = ['Gender'], values = ['Discount'], aggfunc = 'mean' )
print(p_table)
print("-------------") 

 
print("6.Pivot-Tabelle Spaltenanordnung")
p_table = pd.pivot_table(df, index= ['Gender'], 
          columns = ['Fee'], values=['Discount'], aggfunc = 'mean' )
print(p_table)
print("-------------")



print("7.Füllung der fehlenden Daten mit Null ")
tabble = pd.pivot_table(df, index= ['Gender'], columns = ['Fee'], 
        values=['Discount'], aggfunc = 'mean', fill_value = 0 )
print(p_table)
print("--------------") 


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

21.11.22
Nach 'Pivotisierung von DataFrames' versuche ich jetzt
mich dem Thema 'Gruppierung von Dataframes zu näheren.
Das geht nur mit praktischen Beispielen, nachdem man sich
zum Thema 'eingelesen'.
Hier eine Zusammenstellung von diversen Gruppierungen
eines DataFrames., die einen leichteren Einstieg ermöglchen
sollen.
Gute Zeit OSWALD


Code: Alles auswählen

import time 
import pandas as pd
import numpy as np

print("Erstellung des DataFrames")

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)
print(df)
#time.sleep(0)
print()

print("Vor jeder Neugruppierung wird der DtaFrame erneuert.")
print(df.groupby('Team'))
  
 

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

print (df.groupby('Team').groups)
print() 


 
data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
  'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
  'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
  'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
  'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

print(df.groupby(['Team','Year']).groups)
 

 

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

grouped = df.groupby('Year')

for name,group in grouped:
   print( name)
   print (group)
 
print()
 
 


data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

grouped = df.groupby('Year')
print( grouped.get_group(2014))
 
print()
  
 
data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

grouped = df.groupby('Year')
print(grouped['Points'].agg(np.mean))
 
print()
 
 
 
data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

 
grouped = df.groupby('Team')
print(grouped.agg(np.size))
 
print()
 

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

grouped = df.groupby('Team')
print( grouped['Points'].agg([np.sum, np.mean, np.std]))
 
print()

       
 

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)

grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print (grouped.transform(score))
 
print()


print("zum Schluß wird DataFrame 'entleert'") 
data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)
print(df)
print (df.groupby('Team').filter(lambda x: len(x) >= 5))
################################################################  




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

22.11.22
Und hier zur Ergänzung noch einige in der Praxis von Pandas
anwendbare Funktionen , Es sind keinwegs die letzten .
könnten aber für das Verständnis hilfreich sein.
Gute Zeit OSWALD

Code: Alles auswählen


import numpy as np
import time 
import pandas as pd

data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
   'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
   'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
   'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
   'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(data)



print(df)
#time.sleep(20)
print()
print("Daten g e z i e l t auswählen ")
print(df.iloc[:3, :2])
 
 
print("Zufallszahlen nach Standort auswählen.  ")
df=pd.DataFrame(np.random.randn(3, 4) )
print(df) 
 
print(df.iloc[:3, :1])
 
print(" soweit    Alles 'Slicing '  ")       

df=pd.DataFrame(np.random.randn(6, 3) )
print(df) 
print()
print("Indizierung von Zahlen ")
print(data ['Points'])
 

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

23.November . Mathematiker begehen heute den Fibonacci-Tag.
Aus diesem Anlass möchte ich dem Forumspublikum
ein geniales Kunstwerk präsentieren, das ich heute zufällig
im Netz gefunden habe.
Viel Spass und gute Zeit Oswald

Code: Alles auswählen


  
from functools import lru_cache
from matplotlib.patches import Arc, Circle, Rectangle
from itertools import combinations
import matplotlib.pyplot as plt
import random
import math
import re

FIBONACCI = [2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]
DIRECTIONS = [('right', 'up'), ('right', 'down'), ('left', 'down'), ('left', 'up')]
ANGLES = [(90, 180), (0, 90), (-90, 0), (180, 270)]
CCW_ANGLES = [(0, 90), (90, 180), (180, 270), (270, 360)]
cycles = [
    (4, 2, 1),
    (-2, -1),
    (-14, -7, -20, -10, -5),
    (
        -50, -25, -74,
        -37, -110, -55,
        -164, -82, -41,
        -122, -61, -182,
        -91, -272, -136,
        -68, -34, -17
    )
]
loops = {term: len(cycle) for cycle in cycles for term in cycle}
stops = {term: cycle[-1] for cycle in cycles for term in cycle}

@lru_cache(maxsize=None)
def fibonacci(n):
    s = []
    a, b = 0, 1
    for i in range(n):
        s.append(a)
        a, b = b, a + b
    return s

@lru_cache(maxsize=None)
def spectrum_position(n):
    if not isinstance(n, int):
        raise TypeError('`n` should be an integer')
    if n < 0:
        raise ValueError('`n` must be non-negative')
    n %= 1530
    if 0 <= n < 255:
        return f'#ff{n:02x}00'
    elif 255 <= n < 510:
        return f'#{510-n:02x}ff00'
    elif 510 <= n < 765:
        return f'#00ff{n-510:02x}'
    elif 765 <= n < 1020:
        return f'#00{1020-n:02x}ff'
    elif 1020 <= n < 1275:
        return f'#{n-1020:02x}00ff'
    elif 1275 <= n < 1530:
        return f'#ff00{1530-n:02x}'

@lru_cache(maxsize=None)
def factorize(n):
    assert isinstance(n, int)
    assert n >= 2
    factors = []
    while not n % 2:
        factors.append(2)
        n /= 2
    
    for i in range(3, int(n**.5+1), 2):
        while not n % i:
            factors.append(i)
            n /= i
    
    if n > 1:
        factors.append(int(n))
    return factors

@lru_cache(maxsize=None)
def dice_average(n):
    factors = factorize(n)
    if len(factors) == 1:
        return (1, n * 2 - 1)
    else:
        maxf = max(factors)
        factors.remove(maxf)
        return (math.prod(factors), maxf * 2 - 1)

@lru_cache(maxsize=None)
def hailstone(n):
    if not isinstance(n, int):
        raise TypeError('n should be an integer')
    
    if n == 0:
        raise ValueError('n should not be 0')
    
    sequence = [n]
    loop_iter = 0
    looping = False
    while True:
        if not looping and n in loops:
            loop_terms = loops[n]
            looping = True
        
        if looping:
            loop_iter += 1
            if loop_iter == loop_terms:
                break
        
        if n % 2:
            n = 3 * n + 1
        else:
            n /= 2
        
        sequence.append(int(n))
    
    return sequence

def sin(x): return math.sin(math.radians(x))
def cos(x): return math.cos(math.radians(x))
def tan(d): return math.tan(math.radians(d))

@lru_cache(maxsize=None)
def negate(ls): return [-e for e in ls]

@lru_cache(maxsize=None)
def rotate(point, deg):
    x, y = point
    x1 = x * cos(deg) - y * sin(deg)
    y1 = y * cos(deg) + x * sin(deg)
    return (x1, y1)

@lru_cache(maxsize=None)
def square_vertices(init_pos, side, direction):
    x0, y0 = init_pos
    hd, vd = direction
    x1 = x0 + side if hd == 'right' else x0 - side
    y1 = y0 + side if vd == 'up' else y0 - side
    return [(x0, y0), (x1, y0), (x1, y1), (x0, y1)]

def make_square(init_pos, side, direction, color=None):
    vertices = square_vertices(init_pos, side, direction)
    x, y = zip(*vertices)
    minx = min(x)
    miny = min(y)
    if not color:
        color = '#'+random.randbytes(3).hex()
    return Rectangle((minx, miny), side, side, color=color, alpha=0.5), vertices

@lru_cache(maxsize=None)
def first_level(number):
    assert number > 2
    half = 180 / number
    x1 = (16 / (1 + tan(half) ** 2)) ** .5
    y1 = (16 - x1 ** 2) ** .5
    k = y1 - tan(half - 90) * x1
    x2 = -k / tan(half - 90)
    r = ((x1 - x2) ** 2 + y1 ** 2) ** .5
    return (x2, r)

@lru_cache(maxsize=None)
def next_level(distance, radius):
    base = (distance - radius) / (distance + radius)
    new_radius = radius * base
    new_distance = distance - radius - new_radius
    return (new_distance, new_radius)

@lru_cache(maxsize=None)
def fade_color(color, strength):
    assert re.match(r'^#[0-9a-f]{6}$', color)
    assert 0 < strength <= 1
    color = int(color[1:], 16)
    r, g, b = [round(((color>>i)%256)*strength) for i in (16, 8, 0)]
    return f'#{r:02x}{g:02x}{b:02x}'

def fibonacci_spiral(n, c=12, bsquare=True, barc=True, reverse=False):
    assert barc or bsquare
    colors = [spectrum_position(int(1530*i/c)) for i in range(c)]
    sequence = fibonacci(n+1)
    init_pos = (0, 0)
    vertexes = []
    shapes = []
    for i, n in enumerate(sequence[1:]):
        direction = DIRECTIONS[i % 4] if not reverse else DIRECTIONS[::-1][i % 4]
        angle = ANGLES[i % 4] if not reverse else CCW_ANGLES[i % 4]
        square, vertices = make_square(init_pos, n, direction, colors[i%c])
        center = vertices[[1, 3][i % 2]]
        a, b = angle
        arc = Arc(center, 2*n, 2*n, theta1=a, theta2=b, edgecolor='k', lw=3.0)
        if bsquare: shapes.append(square)
        if barc: shapes.append(arc)
        init_pos = vertices[-2]
        vertexes.extend(vertices)
    
    return shapes, vertexes

def fibonacci_arcs(n, degree, color='k' ,reverse=False, alpha=0.75, lw=2):
    sequence = fibonacci(n)
    init_pos = (0, 0)
    vertexes = []
    shapes = []
    for i, n in enumerate(sequence[1:]):
        direction = DIRECTIONS[i % 4] if not reverse else DIRECTIONS[::-1][i % 4]
        angle = ANGLES[i % 4] if not reverse else CCW_ANGLES[i % 4]
        vertices = square_vertices(init_pos, n, direction)
        rotated_vertices = [rotate(pos, degree) for pos in vertices]
        index = [1, 3][i % 2]
        center = rotated_vertices[index]
        a, b = [(i + degree) % 360 for i in angle]
        arc = Arc(center, 2*n, 2*n, theta1=a, theta2=b, edgecolor=color, lw=lw, alpha=alpha)
        init_pos = vertices[-2]
        shapes.append(arc)
        vertexes.extend(rotated_vertices)
    
    return shapes, vertexes

################################################################
# plotting functions

def plot_hailstone(n, real=False):
    assert n > 1
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    numbers = list(range(-n, 0)) + list(range(1, n))
    for i in numbers:
        ax.plot(hailstone(i))
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    if real:
        plt.axis('scaled')
    plt.box(False)
    plt.set_cmap('rainbow')
    plt.show()

def plot_spiral(n, c, barc=True, bsquare=True, reverse=False):
    shapes, vertexes = fibonacci_spiral(n, c, barc=barc, bsquare=bsquare, reverse=reverse)
    x, y = zip(*vertexes)
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    for shape in shapes:
        ax.add_patch(shape)
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    ax = plt.gca()
    ax.set_xlim([min(x), max(x)])
    ax.set_ylim([min(y), max(y)])
    plt.show()

def plot_lolipop(n, arms, lw=1):
    arcs = []
    points = []
    u = 360/arms
    for i in range(arms):
        shapes, vertices = fibonacci_arcs(n, i*u, color='k', alpha=1, lw=lw)
        arcs.extend(shapes)
        points.extend(vertices)
    
    x, y = zip(*points)
    a, b = points[-2]
    radius = (a*a+b*b)**.5
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    for arc in arcs:
        ax.add_patch(arc)
    
    ax.add_patch(Arc((0, 0), 2*radius, 2*radius, theta1=0, theta2=360, edgecolor='k', lw=lw))
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    ax = plt.gca()
    ax.set_xlim([min(x), max(x)])
    ax.set_ylim([min(y), max(y)])
    plt.show()

def plot_sunflower(n, cw, color=True, alpha=0.75):
    assert cw in FIBONACCI and cw <= 144
    i = FIBONACCI.index(cw)
    ccw = FIBONACCI[i+1]
    arcs = []
    points = []
    cwu = 360/cw
    ccwu = 360/ccw
    color_cwu = 1530/cw
    color_ccwu = 1530/ccw
    for i in range(cw):
        color1 = spectrum_position(round(i*color_cwu)) if color else 'k'
        shapes, vertices = fibonacci_arcs(n, i*cwu, color=color1, alpha=alpha)
        arcs.extend(shapes)
        points.extend(vertices)
    
    for i in range(ccw):
        color2 = spectrum_position(round(1530-i*color_ccwu)) if color else 'k'
        shapes, vertices = fibonacci_arcs(n, (90+i*ccwu)%360, color=color2, reverse=True, alpha=alpha)
        arcs.extend(shapes)
        points.extend(vertices)
    
    x, y = zip(*points)
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    for arc in arcs:
        ax.add_patch(arc)
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    ax = plt.gca()
    ax.set_xlim([min(x), max(x)])
    ax.set_ylim([min(y), max(y)])
    plt.show()

def recur_plot_circle(division, levels, fade=0.9):
    assert division > 2
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    rotation_diff = 90 / division
    unit_rotation = 360 / division
    color_increment = 1530 / division
    distance, radius = first_level(division)
    max_distance = distance + radius
    for level in range(levels):
        for index in range(division):
            center = rotate((0, distance), level * rotation_diff + index * unit_rotation)
            color = spectrum_position(round(index * color_increment))
            color = fade_color(color, fade**level)
            ax.add_patch(Circle(center, radius, color=color))
        distance, radius = next_level(distance, radius)
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    ax = plt.gca()
    ax.set_xlim([-max_distance, max_distance])
    ax.set_ylim([-max_distance, max_distance])
    plt.show()

def plot_star(number):
    assert number > 2
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    unit_rotation = 360 / number
    points = []
    for i in range(number):
        points.append(rotate((0, 4), unit_rotation*i))
    
    for a, b in combinations(points, r=2):
        x, y = zip(*[a, b])
        ax.plot(x, y)
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    ax = plt.gca()
    ax.set_xlim([-4, 4])
    ax.set_ylim([-4, 4])
    plt.set_cmap('rainbow')
    plt.show()

def plot_tetragram(n):
    assert n > 2 and not (n - 2) % 3
    averages = [dice_average(i) for i in range(2, n)]
    fig = plt.figure(frameon=False)
    ax = fig.add_subplot(111)
    ax.set_axis_off()
    for a, b, c in zip(averages[::3], averages[1::3], averages[2::3]):
        x, y = zip(*[a, b, c])
        ax.triplot(x, y)
        ax.triplot(negate(x), y)
        ax.triplot(negate(x), negate(y))
        ax.triplot(x, negate(y))
        ax.triplot(y, x)
        ax.triplot(negate(y), x)
        ax.triplot(negate(y), negate(x))
        ax.triplot(y, negate(x))
    
    fig.subplots_adjust(left=0, bottom=0, right=1, top=1, wspace=0, hspace=0)
    plt.axis('scaled')
    plt.box(False)
    plt.set_cmap('rainbow')
    plt.show()

if __name__ == '__main__':
    plot_hailstone(128)
    plot_hailstone(12, 1)
    plot_spiral(24, 6)
    plot_spiral(24, 6, reverse=True)
    plot_lolipop(25, 12)
    for i in (2, 3, 5, 8, 13):
        plot_sunflower(24, i)
    
    for i in (3, 6, 12, 24):
        recur_plot_circle(i, round(i/2))
    
    for i in range(4, 13):
        plot_star(i)
    
    for i in range(14, 32, 3):
        plot_tetragram(i)















Benutzeravatar
Dennis89
User
Beiträge: 684
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo Oswald,

da sind ein paar schöne Grafiken dabei. Danke für das teilen.

Grüße
Dennis
“A ship is always safe at the shore, but that is not what it is built for.”
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

26.11.2022
Nach wie vor ist das herunterladen von CSV-Dateien ein
ungelöstes(?) Problem , zumondest für mich.
Es sind die Trennzeichen und ihre notwendige Umstellung .
Ich habe zunächst versucht, Dict-Daten mit @DataClass
zu erzeugen und dann 'händisch umzuschreiben.
Es gelingt zwar ein DataFrame zu erzeugen, aber dieses
und auch das mühsame Umschreiben auf Kommata als Trennzeichen
sind unzumutbar.
Nachfolgend der Code und das Ergebnis.
Ich habe ein Programm gefunden, das angeblich die Lösung bringt,
halte es aber für unbrauchbar.

Code: Alles auswählen

from dataclasses import dataclass, asdict
import numpy as np
import pandas as pd
@dataclass
class DFrame:
    Name: str
    Beruf: str
    Alter: int
    Ort: str
    Strasse:str
    Gehalt:int



if __name__ == '__main__':   
 
    wert = DFrame('Meier','Gärtner', 34, 'München','Adler', 2500)
    print(asdict(wert)) 
    wert = DFrame('Müller','Bäcker', 24, 'Landshut','Bach ' ,2100)      
    print(asdict(wert))
    wert = DFrame('Frank','Maler',' 27' ,'Freising','Garten',2100 )
    print(asdict(wert))

    print()
 
df = pd.DataFrame({"Spalte1":['Name', 'Meier', 'Beruf', 'Gärtner', 'Alter', 34, 'Ort', 'München', 
                 'Strasse', 'Adler', 'Gehalt', 2500],

                
                 "Spalte2":['Name', 'Müller', 'Beruf', 'Bäcker', 'Alter', 24,  'Ort', 'Landshut', 
                 'Strasse', 'Bach ', 'Gehalt', 2100],

                 "Spalte3":['Name', 'Frank', 'Beruf', 'Maler', 'Alter', ' 27', 'Ort', 'Freising', 
                 'Strasse', 'Garten', 'Gehalt', 2100]})
print(df)

###############################################
{'Name': 'Meier', 'Beruf': 'Gärtner', 'Alter': 34, 'Ort': 'München', 'Strasse': 'Adler', 'Gehalt': 2500}
{'Name': 'Müller', 'Beruf': 'Bäcker', 'Alter': 24, 'Ort': 'Landshut', 'Strasse': 'Bach ', 'Gehalt': 2100}
{'Name': 'Frank', 'Beruf': 'Maler', 'Alter': ' 27', 'Ort': 'Freising', 'Strasse': 'Garten', 'Gehalt': 2100}

    Spalte1   Spalte2   Spalte3
0      Name      Name      Name
1     Meier    Müller     Frank
2     Beruf     Beruf     Beruf
3   Gärtner    Bäcker     Maler
4     Alter     Alter     Alter
5        34        24        27
6       Ort       Ort       Ort
7   München  Landshut  Freising
8   Strasse   Strasse   Strasse
9     Adler     Bach     Garten
10   Gehalt    Gehalt    Gehalt
11     2500      2100      2100



Irgendwann kommt Jeder an seine Grenzen


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

@OSWALD: Der Teil mit Pandas macht so überhaupt gar keinen Sinn. Erstens gehören Datensätze in Zeilen und nicht in Spalten, und dann gehören in die Zellen auch nur die *Daten* und nicht die *Schüssel*. Die Schlüssel wären hier die Spaltenüberschriften.
“It should be noted that no ethically-trained software engineer would ever consent to write a `DestroyBaghdad` procedure. Basic professional ethics would instead require him to write a `DestroyCity` procedure, to which `Baghdad` could be given as a parameter.” — Nathaniel Borenstein
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

Hallo Blackjack, Du hast wieder einmal absolut Recht.
Der Pandas -Teil war ein Versuch und nicht mehr.
'Experimentieren' ist Glückssache. Pandas reagiert not amused.
Ich bleibe jedenalls am Thema CSV.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 105
Registriert: Freitag 18. März 2022, 17:32

01.12.2022
Die Lösung des Problems 'CSV'
kann ich nur für meine Syste,, also Windoes10 und
mit eigenen Daten sinnvoll lösen.
Um eigene Daten für eeine CSV-D atei zu erhalten,
nütze ich SQLTE 3,
Das ist die einfachste Datenbank. Diese und
eine Tabelle , aus der ich eine CSV - Datei gewinnen
werde ich versuchen mit dem bekannten DB-Brower vornehmen.
Mehr zu diesem gelegentlich. Mit diesem Browser lassen sich
über 'exportiren' u. importieren CSV -M Dateien erstellen.
Gerne würde würde ich die Beurteilung über Sinn u. Maxchbarkeit
meines Versuchs erfahre. Es ist alles ja sehr aufwneig.
Hier Code und Tabelle.

Code: Alles auswählen


import sqlite3
from sqlite3 import dbapi2 as sqlite
import os 
import time
##############################
lt=time.localtime()
print(time.strftime("%d.%m.%Y",lt))
################################ 
  
connection = sqlite3.connect (" adressen,db")
cursor = connection.cursor()
connection.commit()

 
cursor.execute("""CREATE TABLE IF NOT EXISTS  MyDaten (
PersNR      INTEGER NOT NULL PRIMARY KEY,
Vorname     VARCHAR,
Nachname  VARCHAR,
Wohnort     VARCHAR,
Strasse      VARVHAR,
Beruf          VARCHAR,
Gehalt        INTEGER
);""" 
)
 
connection.commit()

PersNR  = 21
Vorname = " Anna  "
Nachname = " Maier "
Wohnort = "Rosenheim "
Strasse = " Sonnen"
Beruf =    " Musikerin"
Gehalt   =     4366
cursor.execute(""" INSERT  INTO     MyDaten     
                       VALUES (?,?,?,?,?,?,?)
                      """, (PersNR ,   Vorname, Nachname, Wohnort, Strasse, Beruf, Gehalt  ) 
                            ) 
cursor.execute("SELECT  *  FROM MyDaten")
ergebnis = cursor.fetchall()
print(ergebnis)

connection.commit()
connection.close()


1	 Horst  	 Maier 	München   	Landshut  	 Ingenieur 	4600
2	 Maria  	 Sommer 	München   	Landshuter  	unbekannt	5100
5	 Andreas  	 Wolf 	Straubing  	  Markt 3	 Designer in	6345
7	Rudolf	Rainer	Passau  	 Donauweg	 Händler	5266
8	Rudolf	 Meier 	Passau  	 Landauer	Musikhändler	7800
10	 A nna  	 Maier 	Rosenheim 	 Sonnen	 Musikerin	4366

Gute Zeit OSWALD
Antworten