kleine Mathe-Spielereien

[OSWALD]

8.10.23
Hier noch ein Beispiel mit einem Code aus
meinem "Archiv" " zum Thema .
Die Auswahl an Farben aus cmap ist ausreichend.
Gute Zeit OSWALD




[/code]
import matplotlib.pyplot as plt
import numpy as np

plt.rcParams["figure.figsize"] = [6, 5]
plt.rcParams["figure.autolayout"] = True

N = 10

x = np.random.rand(N)
y = np.random.rand(N)

#
for xy in zip(x, y):
plt.annotate('(%.2f, %.2f)' % xy, xy=xy)

plt.title("Jeder Punkt mit Koordinaten")
plt.show()

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



# create a grid
grid_points = 10
grid_x = np.linspace(0,1,grid_points)
grid_y = grid_x.copy()

# initiate array of ones (white)
image = np.ones([grid_points, grid_points])
for xp, yp in zip(x,y):
# selecing the closest point in grid
index_x = np.argmin(np.abs(xp - grid_x))
index_y = np.argmin(np.abs(yp - grid_y))
# setting to black
image[index_x,index_y] = 0
ncolors = len(plt.rcParams['axes.prop_cycle'])
#shift = np.linspace(0,3 , ncolors, endpoint=False)
#for s in shift:
# s= 1
# ax.set_xlabel('x-axis')
# ax.set_ylabel('y-axis')

# by the columns and y by the rows
fig, ax = plt.subplots()
ax.imshow(
image. T,
origin='lower',
cmap=plt.get_cmap('Wistia'))
plt.show()

[OSWALD]

13.10.2023
betr. Differentialgleichungen
Zur aktuellen wirtschaftlichen Situation habe ich
versucht ein " Idealmodle = für die Beziehung
Zins , Inflation --> Erwartungswert ( = Wachstum)
zu erstellen. Die Basis iist dabei die Basis ist eine R.I.S DGL.

Code: Alles auswählen

#Simulation  von Zins inflation und Erwartungswert

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
tmax=100
#Anfangswerte
S0= 3.5     #Zinsen in %
I0= 4.5       #IInflation in %
R0=  - 3      #Wachstum in %
N=S0+I0+R0
#Parameter
b=1.0  #
g=0.08 #
#DGL-System
def dgl(t,ya):
    S,I,R=  ya
    dS_dt=-b*S*I/N    
    dI_dt=b*S*I/N-g*I 
    dR_dt=g*I        
    return [dS_dt,dI_dt,dR_dt]
#Anfangswerte
y0 = [S0,I0,R0]
t = np.linspace(0, tmax, 200)
z=solve_ivp(dgl,[0,tmax],y0,dense_output=True) 
S, I, R = z.sol(t) 
print("Wachstum in %")
print(np.floor(R))
print() 
print("Inflation  in %")
print(np.floor(I))
print()
print("Zinsen in % ")
print(np.floor(S))


fig, ax = plt.subplots(figsize=(8,6))
ax.plot(t, S,'b-', lw=2, label="Zinsen %")
ax.plot(t, I,'r--',lw=2, label="Inflation")
ax.plot(t, R,'g:', lw=2, label="Wachstum")
ax.legend(loc="best")
ax.set_xlabel("Zeit: Tage oder   Wochen")
ax.set_ylabel("Startwerte für Wachstum,Inflation ,Zinsen in %   ")
ax.grid(True)
plt.show()  

[OSWALD]

13.10.2023
zum obigen Code wäre vielleicht noch anzumerken:
Sinnvoll wären vielleicht noch einigeandere Parameter hinzuzufügen:
Verhältnis €/$ und Export/Import
Gute Zeit Oswald

[OSWALD]

15.10.2023
Gestartet mit 'kleinen Mathe-Spielchen'
angelangt bei der 'Spieltheorie', (Entscheidungstheorie)
mit großer Bedeutung in Wirtschaft und Wissenschaft.
Dafür 2 Beispiele.
' Zusammenstoß zweier Massen '
Zwei massengleiche Kugeln stoßen mit hoher Geschwindigkeit zusammen
und werden in einem bestimmten Winkel weit hinaus- 'geschleudert.,
Animation Kann sehr variabel gesteuert werden.

'Game-Life' : Zentrale Funktion hier wieder BItmap und viele anderen
Module , quasi eine Kontrolel des bisher in Python Gelernten.

Code: Alles auswählen

# Folgende Parameter der Original-DGL  wurden  abgeändert:
#  Radius ,Masse , Anfangsposition und Anfangsgeschwindigkeit und Winkel 
#  
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import matplotlib.animation
import scipy.integrate

# Simulationszeitdauer T und Schrittweite dt [s].
T = 8
dt = 0.01

# Federkonstante beim Aufprall [N/m].
D = 5e3

# Massen der beiden Teilchen [kg].
m1 = 12.0                  
m2 =  10.0

# Radien der beiden Teilchen [m].
R1 = 2.6
R2 = 2.6

# Anfangspositionen [m].
r0_1 = np.array([20, .0])
r0_2 = np.array([.0 , 20])



# Anfangsgeschwindigkeiten [m/s].
v0_1 = np.array([-16.3 ,0.0])
v0_2 = np.array([0.0, -16.3])


def dgl(t, u):
    r1, r2, v1, v2 = np.split(u, 4)

    # Berechne den Abstand der Mittelpunkte.
    dr = np.linalg.norm(r1-r2)

    # Berechne, wie weit die Kugeln ineinander eingedrungen sind.
    dist = max(R1 + R2 - dr, 0)

    # Die Kraft wirkt, sobald sich die Oberflächen berühren.
    F = D * dist

    # Berechne die Vektoren der Beschleunigung. Der
    # Beschleunigungsvektor ist jeweils parallel zur
    # Verbindungslinie der beiden Kugelmittelpunkte.
    er = (r1 - r2) / dr
    a1 = F / m1 * er
    a2 = -F / m2 * er

    # Gib die Zeitableitung des Zustandsvektors zurück.
    return np.concatenate([v1, v2, a1, a2])


# Lege den Zustandsvektor zum Zeitpunkt t=0 fest.
u0 = np.concatenate((r0_1, r0_2, v0_1, v0_2))

# Löse die Bewegungsgleichung bis zum Zeitpunkt T.
result = scipy.integrate.solve_ivp(dgl, [0, T], u0,
                                   max_step=dt,
                                   t_eval=np.arange(0, T, dt))
t = result.t
r1, r2, v1, v2 = np.split(result.y, 4)

 
# Erstelle eine Figure und eine Axes mit Beschriftung.
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.set_xlabel('x [m]')
ax.set_ylabel('y [m]')
ax.set_xlim([-20.5,20.5])
ax.set_ylim([-20.5, 20.5])
ax.set_aspect('equal')
ax.grid()

# Lege die Linienplots für die Bahnkurve an.
bahn1, = ax.plot([0], [0], '-r', zorder=4)
bahn2, = ax.plot([0], [0], '-b', zorder=3)

# Erzeuge zwei Kreise für die Darstellung der Körper.
kreis1 = mpl.patches.Circle([0, 0], R1, color='green', zorder=4)
kreis2 = mpl.patches.Circle([0, 0], R2, color='red', zorder=3)
ax.add_artist(kreis1)
ax.add_artist(kreis2)


def update(n):
    # Aktualisiere die Position der beiden Körper.
    kreis1.set_center(r1[:, n])
    kreis2.set_center(r2[:, n])
    # Plotte die Bahnkurve bis zum aktuellen Zeitpunkt.
    bahn1.set_data(r1[0, :n], r1[1, :n])
    bahn2.set_data(r2[0, :n], r2[1, :n])
    return kreis1, kreis2, bahn1, bahn2


# Erstelle die Animaiton und starte sie.
ani = mpl.animation.FuncAnimation(fig, update, interval=10,
                                  frames=t.size, blit=True)
plt.show()

[OSWALD]

15.10.2023
Hier 'GAME-Life , eines von vielen analogen Beispielen.
Wenn die Animation läuft, kann sie nicht gesteuert werden,
Verlauf und und Ergebnis durch diverse Parameter.
N steuert z.B mit den gezeigten Zahlen die Größe der erstellten Bitmaps.

Gute Zeit OSWALD

Code: Alles auswählen

 Python code to implement Conway's Game Of Life
import argparse
import numpy as np
import matplotlib.pyplot as plt 
import matplotlib.animation as animation
 
# setting up the values for the grid
ON = 255
OFF = 0
vals = [ON, OFF]
 
def randomGrid(N):
 
    """returns a grid of NxN random values"""
    return np.random.choice(vals, N*N, p=[0.2, 0.8]).reshape(N, N)
 
def addGlider(i, j, grid):
 
    """adds a glider with top left cell at (i, j)"""
    glider = np.array([[0, 1, 235], 
                       [235,  1, 235], 
                       [0,  235, 235]])
    grid[i:i+3, j:j+3] = glider
 
def addGosperGliderGun(i, j, grid):
 
    """adds a Gosper Glider Gun with top left
       cell at (i, j)"""
    gun = np.zeros(11*38).reshape(11, 38)
 
    gun[5][1] = gun[5][2] = 255
    gun[6][1] = gun[6][2] = 255
 
    gun[3][13] = gun[3][14] = 255
    gun[4][12] = gun[4][16] = 255
    gun[5][11] = gun[5][17] = 255
    gun[6][11] = gun[6][15] = gun[6][17] = gun[6][18] = 255
    gun[7][11] = gun[7][17] = 255
    gun[8][12] = gun[8][16] = 255
    gun[9][13] = gun[9][14] = 255
 
    gun[1][25] = 255
    gun[2][23] = gun[2][25] = 255
    gun[3][21] = gun[3][22] = 255
    gun[4][21] = gun[4][22] = 255
    gun[5][21] = gun[5][22] = 255
    gun[6][23] = gun[6][25] = 255
    gun[7][25] = 255
 
    gun[3][35] = gun[3][36] = 255
    gun[4][35] = gun[4][36] = 255
 
    grid[i:i+11, j:j+38] = gun
 
def update(frameNum, img, grid, N):
 
    # copy grid since we require 8 neighbors 
    # for calculation and we go line by line 
    newGrid = grid.copy()
    for i in range(N):
        for j in range(N):
 
            # compute 8-neighbor sum
            # using toroidal boundary conditions - x and y wrap around 
            # so that the simulation takes place on a toroidal surface.
            total = int((grid[i, (j-1)%N] + grid[i, (j+1)%N] +
                         grid[(i-1)%N, j] + grid[(i+1)%N, j] +
                         grid[(i-1)%N, (j-1)%N] + grid[(i-1)%N, (j+1)%N] +
                         grid[(i+1)%N, (j-1)%N] + grid[(i+1)%N, (j+1)%N])/255)
 
            # apply Conway's rules
            if grid[i, j]  == ON:
                if (total < 2) or (total > 3):
                    newGrid[i, j] = OFF
            else:
                if total == 3:
                    newGrid[i, j] = ON
 
    # update data
    img.set_data(newGrid)
    grid[:] = newGrid[:]
    return img,
 
# main() function
def main():
 
    # Command line args are in sys.argv[1], sys.argv[2] ..
    # sys.argv[0] is the script name itself and can be ignored
    # parse arguments
    parser = argparse.ArgumentParser(description="Runs Conway's Game of Life simulation.")
 
    # add arguments
    parser.add_argument('--grid-size', dest='N', required=False)
    parser.add_argument('--mov-file', dest='movfile', required=False)
    parser.add_argument('--interval', dest='interval', required=False)
    parser.add_argument('--glider', action='store_true', required=False)
    parser.add_argument('--gosper', action='store_true', required=False)
    args = parser.parse_args()
     
    # set grid size
    N =16
    #8. 16, 32 , 64, 128, 256
    if args.N and int(args.N) > 8:
        N = int(args.N)
         
    # set animation update interval
    updateInterval = 50
    if args.interval:
        updateInterval = int(args.interval)
 
    # declare grid
    grid = np.array([])
 
    # check if "glider" demo flag is specified
    if args.glider:
        grid = np.zeros(N*N).reshape(N, N)
        addGlider(1, 1, grid)
    elif args.gosper:
        grid = np.zeros(N*N).reshape(N, N)
        addGosperGliderGun(10, 10, grid)
 
    else:   # populate grid with random on/off -
            # more off than on
        grid = randomGrid(N)
 
    # set up animation
    fig, ax = plt.subplots()
    img = ax.imshow(grid, interpolation='nearest')
    ani = animation.FuncAnimation(fig, update, fargs=(img, grid, N, ),
                                  frames = 10 ,
                                  interval=updateInterval,
                                  save_count=0)
 
    # # of frames? 
    # set output file
    if args.movfile:
        ani.save(args.movfile, fps=30, extra_args=['-vcodec', 'libx364'])
                 #364
 
    plt.show()
 
# call main
if __name__ == '__main__':
    main()

[OSWALD]

18.10.2023
Bei meiner Beschäftigung mit scipy.optimize bin ich
auf die (berühmte) Rosenbrock - Funktion gestoßen ,
von der es zahlreiche Visualisierungen und
eine umfangreiche Literatur gibt.
Welches wirklich der Original-Code des Erfinders ist, weiß ich nicht.
Ich habe eine Veränderung am Code vorgenommen
und zeige hier das Ergebnis.
Diese Funktion wird für Testzwacke verwendet.
Ich bin derzeit bemüht das alles zu verstehen und zeige
hier den abgewandelten Code.


Gute Zeit OSWALD

Code: Alles auswählen

# Visualisierung der  Rosenbrock-Funktion

from matplotlib import pyplot as plt
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
def f(x1, x2): return 100*(x2*x1**2)**2+(x1-1)**2
x1 = np.linspace(-20, 20)
x2 = np.linspace(-20, 20)
X1, X2 = np.meshgrid(x1, x2)
F = f(x1, x2)
plt.contour(X1, X2, f(X1, X2))

def plotter(E, A):
  fig = plt.figure(figsize = [15, 15])
  ax = plt.axes(projection='3d')
  ax.plot_surface(X1, X2, f(X1, X2), cmap='jet', alpha=0.8)
  ax.plot_wireframe(X1, X2, f(X1, X2), rcount=15, ccount=15)
  ax.view_init(elev=E, azim=A)
  ax.set_xlabel('X')
  ax.set_ylabel('Y')
  ax.set_zlabel('f(X, Y)')
  ax.contourf(x1, x2, f(X1, X2))
  print("solution 2")
plotter(45, 45)
from ipywidgets import interactive
iplot = interactive(plotter, E = (-90, 90, 5),
                             A = (-90, 90, 5))
plt.show()

[OSWALD]

18.10.2023
Hier zeige ich die Original -Rosenbrock-Funktion.
Wenn das erste Abbild erreicht ist, dann
setzen Sie den Cursor auf auf die Bildschirmoberfläche
und beginnen mit gedrückter Maus mit kreisförmigen
Bewegungen
Mich hat das Ergebnis sehr überrascht. ????
Gute Zeit OSWALD

Code: Alles auswählen

 Visualisierung der  Rosenbrock-Funktion

from matplotlib import pyplot as plt
from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
def f(x1, x2): return 100*(x2- x1**2)**2+(x1-1)**2
x1 = np.linspace(-20, 20)
x2 = np.linspace(-20, 20)
X1, X2 = np.meshgrid(x1, x2)
F = f(x1, x2)
print(F) 
plt.contour(X1, X2, f(X1, X2))

def plotter(E, A):
  fig = plt.figure(figsize = [15, 15])
  ax = plt.axes(projection='3d')
  ax.plot_surface(X1, X2, f(X1, X2), cmap='jet', alpha=0.8)
  ax.plot_wireframe(X1, X2, f(X1, X2), rcount=15, ccount=15)
  ax.view_init(elev=E, azim=A)
  ax.set_xlabel('X')
  ax.set_ylabel('Y')
  ax.set_zlabel('f(X, Y)')
  ax.contourf(x1, x2, f(X1, X2))
  print("solution 2")
plotter(45, 45)
from ipywidgets import interactive
iplot = interactive(plotter, E = (-90, 90, 5),
                             A = (-90, 90, 5))
plt.show()

[OSWALD]

21.10.2023
Wochenende.
Warum nach harter Arbeit nicht einmal
'spielend' entspannen.
Vorsicht ! Kann süchtig machen.
Gue Zeit OSWALD

Code: Alles auswählen

import matplotlib.pyplot as plt
import numpy as np
from math import *
# prepare some coordinates
x, y, z = np.indices((10,10, 10))

# draw cuboids in the top left and bottom right corners, and a link between
# them
cube1 = (x < 1) & (y < 1) & (z < 1  )
cube2 = (x < 5) & (y <= 5) & (z >=  5)
link = abs(x-   y) - abs(y  - z) + abs(z - x) <=1

# combine the objects into a single boolean array
voxelarray = cube1 | cube2 | link

# set the colors of each object
colors = np.empty(voxelarray.shape, dtype=object)
colors[link] = 'magenta'
colors[cube1] = 'blue'
colors[cube2] = 'green'

# and plot everything
ax = plt.figure().add_subplot(projection='3d')
ax.voxels(voxelarray, facecolors=colors, edgecolor='k')

plt.show()
##################################
 
# prepare some coordinates
x, y, z = np.indices((10, 10,10))

# draw cuboids in the top left and bottom right corners, and a link between
# them
cube1 = (x < 3) & (y > 3) & (z > 3)
cube2 = (x < 5) & (y < 5) & (z < 5)
link = abs(x - y) + abs(y - z) + abs(z - x) <= 3

# combine the objects into a single boolean array
voxelarray = cube1 | cube2 | link

# set the colors of each object
colors = np.empty(voxelarray.shape, dtype=object)
colors[link] = 'red'
colors[cube1] = 'yellow'
colors[cube2] = 'green'

# and plot everything
ax = plt.figure().add_subplot(projection='3d')
ax.voxels(voxelarray, facecolors=colors, edgecolor='k')

plt.show()
################################

##################################
import matplotlib.pyplot as plt
import numpy as np

# prepare some coordinates
x, y, z = np.indices((10, 10,10))

# draw cuboids in the top left and bottom right corners, and a link between
# them
cube1 = (x > 2) & (y > 2) & (z > 2)
cube2 = (x <= 9) & (y <= 2) & (z <= 9)
link = abs(x* y) + abs(y - z) + abs(z - x) >= 1

# combine the objects into a single boolean array
voxelarray = cube1 | cube2 | link

# set the colors of each object
colors = np.empty(voxelarray.shape, dtype=object)
colors[link] = 'red'
colors[cube1] = 'magenta'
colors[cube2] = 'green'

# and plot everything
ax = plt.figure().add_subplot(projection='3d')
ax.voxels(voxelarray, facecolors=colors, edgecolor='k')

plt.show()
################################

[OSWALD]

26.10.2023 Python hat auch eine eigene Datenbank : Sqlite3.
Es hat eine Weile gedauert, aber ich habe mich inzwischen auch in diese
Thematik eingearbeitet. Inzwischen konnte ich meine
Stromabrechnung und meine private Steuererklärung erstellen.
Es war mrt wichtig , meinen Stromverbrauch kontrollieren zu
können. Sqlite3 ist eine einfache Datenbank, erfüllt aber durchaus ihren Zweck..
Das Ergebnis zeige ich hier. Alle Berechnungen laufen innerhalb
des Codes ab.
Zur Betrachtung der der eigentlichen Tabelle(n) verwende ich
den DB Browser Sqlite. Meine SQULITE3 hat (braucht) nur eine Tabelle.
Gute Zeit OSWALD

Code: Alles auswählen

#         Ich will   meinen Stromverbrauch  kontrollieren

print("==================================")
print(" Wie setzt sich  der Strompreis zusammen ?")
print("Arbeitspreis  =  Preis pro KWh ,  0.3164  , hier also etwa 31 cent  ")
print("Verbrauch    = KWh ")
print("Stromkosten  = Arbeitspreis * KWh")
print("  +    Fixkosten =  177 € ")
print("  +   19% Mehrwertsteuer   ")
print("==================================")

import sqlite3
from sqlite3 import dbapi2 as sqlite
import time
 
print("Neueste Version von Sqlite3:",                     sqlite3.sqlite_version)      
##############################
lt=time.localtime()
print(time.strftime("%d.%m.%Y",lt))
################################ 
 
connection = sqlite3.connect ("MeinSTROM.db")
cursor = connection.cursor()
connection.commit()

 
cursor.execute("""CREATE TABLE IF NOT EXISTS  Verbrauch (
AblesenStart          VARCHAR(4),
ZählerStart                INTEGER,
AblesenAkt       VARCHAR(4),
ZählerAkt          INTEGER,
Arbeitspreis            INTEGER,
KWh                        INTEGER,
Stromkosten            INTEGER,
FiXpreis                   INTEGER,
Nettopreis                 INTEGER,
MWST                     INTEGER,
Arbeitstage               INTEGER,
proMonat                  INTEGER

);""" 
)
connection.commit()
 
 
#######################
proMonat=0 
Fixpreis = 177
AblesenStart =    "01.01 .2023       "                          
ZählerStart =  1000                                        #FiX   zum 1.1.23XXXXXXXXXXXXXXXXXXXX
AblesenAkt  = "25.10.2023"
                          
ZählerAkt    =    3000                                      #laufende Ablesung    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
KWh = ZählerAkt -ZählerStart                        #ergibt aktueller Verbrauch KWh

 

print("                 Aktueller Stand der Berechnung")


print("                     Verbrauch:" ,  KWh,   "KWh")
print()
Arbeitspreis = 0.3164                           
print("Arbeitspreis :" ,   0.3164)
Stromkosten  =Arbeitspreis * KWh 
Arbeitstage = 298

proMonat =round(( KWh/ Arbeitstage) * 30.5
                )
print ("Verbrauch pro Monat  :",   proMonat , "KWh)" )
print("Stromkosten  für", 298 , "Arbeitstage:      ", round(Stromkosten,0), "€")
print("Endpreis = Stromkosten+Fixpreis +MWST" ,  " siehe  Jahresrechnung" )

Nettopreis = round(Stromkosten ,1)
print("Nettopreis = " , round(Nettopreis,1),"€")
                              
MWST =  round(Nettopreis * 0.19,2)
print("MWST = : " ,  round(MWST,2) , "€")     
Endpreis = Nettopreis  +   MWST
print ("Endpreis  o h n e Fixkosten ", round(Endpreis,2 ) ,"  € ")
print()
##Fixkosten  177.46 ab  01.01.2023


################
print()
print()
  
cursor.execute(""" INSERT INTO  Verbrauch
                           VALUES (?,?,?,?,?,?,?,?,?,?,?,?)
                            
                           """, (AblesenStart,ZählerStart,AblesenAkt, ZählerAkt, Arbeitspreis, KWh,
                                 round(Stromkosten,0),     Fixpreis, Nettopreis ,MWST, Arbeitstage ,proMonat   )   )
                                   

cursor.execute(" SELECT   *   from    Verbrauch  ")                                    
ergebnis = cursor.fetchall()
print (ergebnis)
ergebnis =0
 
connection.commit()
connection.close() 

[__blackjack__]

Das sieht so aus als würden Werte und daraus berechnete Werte in die Datenbank eingetragen. Das macht man nicht, weil man die Werte ja jederzeit wieder berechnen kann. Und es fehlt eine ID als Primärschlüssel. VARCHAR(4) passt nicht zu "01.01 .2023 " und *das* sollte auch weder Leerzeichen enthalten, noch überhaupt als Zeichenkette im Programm existieren. Das ist ja ziemlich deutlich ein Datum. Also DATE in SQL und `datetime.date` in Python.

[OSWALD]

Ich gebe zu, Bequemlichkeit ist hier nicht angebracht, aber hier erfüllt es seinen Zweck.
Bei meiner 'privaten 'Steuerschätzung auf Sqlite3 ' sind alle angemahnten Anforderungen erflültl:.
ID Primärschlüssel , fünf Tabellen ,ausreichende VARCHAR-Breite usw sind hier vorhanden.

Ich hatte auch schon einmal mysql implementiert , incl. workbench.
Ist halt sehr aufwendig und kein echter Bedarf für mein Hobby.
Gute Zeit OSWALD


Nur wer stetig sich bemüht, den können wir erlösen(frei nach Faust II).

[OSWALD]

1.11.2023
Es geht jetzt um --asyncio---
Für mich eines der schwersten Module in Python
Es ist ganz leicht zu laden:
mit shell : python -m asyncio .
Aber dann. nach langer Lektüre der Theorie
bleibt nur noch der Versuch an einfachen Beispielen
sich dem Thema zu nähern.
Immer noch aber versuche ich vergeblich die 'Coroutinen
mit konkretem sinnvollem Inhalt zu füllen.
Ich werde es weiter versuchen.
Hier einige einfache Beispiele, die ich
vollständig verstanden habe.
Gute Zeit OSWALD

Code: Alles auswählen

mport asyncio
import random


async def Produkt(queue, n):
    for x in range(1, n + 1):
        # produce an item
        print("Produkt {}/{}".format(x, n))
        # simulate i/o operation using sleep
        await asyncio.sleep(random.random())
        item = str(x)
        # put the item in the queue
        await queue.put(item)

    # indicate the producer is done
    await queue.put(None)


async def Verbrauch(queue):
    while True:
        # wait for an item from the producer
        item = await queue.get()
        if item is None:
            # the producer emits None to indicate that it is done
            break

        # process the item
        print("Verbrauch {}".format(item))
        # simulate i/o operation using sleep
        await asyncio.sleep(random.random())


loop = asyncio.get_event_loop()
queue = asyncio.Queue()
asyncio.ensure_future(Produkt(queue, 10), loop=loop)
loop.run_until_complete(Verbrauch(queue))

[OSWALD]

1.10.23
Hier zunächst noch zwei weitere Beispiele zu asyncio

Code: Alles auswählen

import asyncio
import datetime

async def display_date():
    loop = asyncio.get_running_loop()
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        await asyncio.sleep(1)

asyncio.run(display_date())

#######################
import asyncio
import time

async def main():

  # Using asyncio.create_task() method to create a task
    task1 = asyncio.create_task(foo('task 1'))
    task2 = asyncio.create_task(foo('task 2'))

    print(f"started at {time.strftime('%X')}")

# Wait until both tasks are completed
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")

async def foo(text):
  print(text)
  await asyncio.sleep(10)

asyncio.run(main())

[OSWALD]

1.11-2023
Betr.: asyncio
Hier nun mein erster Versuch
zwei Co-Routinen mit Inhalt zu füllen.
Gute Zeit OSWALD

'(wer immer strebend sich bemüht, den können wir erlösen' (FaustII)

Code: Alles auswählen

import asyncio
import time

async def say_after(delay, what):
    
    await asyncio.sleep(5*delay)
    print(what)

async def main():
    print(f"Start der Co-Routine1 : {time.strftime('%X')}")

    await say_after(1, 'x= 25 +30')
    print("ein Test. Ich hoffe, dass der erste Anstz richtig ist") 

    print( 'x= 55')
    print(f"Start der Co-Routine2 : {time.strftime('%X')}")
    await say_after(2, 'y =100-50')
    print('y= 50')
    print(f"Sekunden später: {time.strftime('%X')}")

asyncio.run(main())
######################################
print()
###########

async def main():
    task1 = asyncio.create_task( say_after(1, '1.Co-Route'))

    task2 = asyncio.create_task(  say_after(1,' 2.Co-Route'))

    print(f"started at {time.strftime('%X')}")

    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2

    print(f"finished at {time.strftime('%X')}")
async def main():
    async with asyncio.TaskGroup() as tg:
        task1 = tg.create_task(
            say_after(1, '1.Co-Route'))

        task2 = tg.create_task(
            say_after(2, '2.Co-Route'))

        print(f"Die Startzeit war also  um{time.strftime('%X')}")

    # The await is implicit when the context manager exits.

    print(f"Und ds  Ende  war {time.strftime('%X')}")
asyncio.run(main()) 

[OSWALD]

3.11.23
Abschließend noch eine weitere Möglichkeit
Co-Routinen mit asyncio einzurichten, dieses Mal aber mit
asyncio.gather.
Insgesamt bleiben für mich zu diesem Thema immer
noch sehr viele Fragen offen, deren Klärung ich
den Profis überlassen muss.
Gute Zeit OSWALD

Code: Alles auswählen

import asyncio

# define a TimeCount function using async
async def TimeCount():
    print("Jetzt  ist es 7 Uhr")
    print("Ich stehe auf und gehe ins Bad" )
    await asyncio.sleep(1)
    print("Um 8 Uhr früstücke ich bis etwa 8 Uhr 30")
    print("Ich lese meine Zeitung und gehe dann an den PC") 
    await asyncio.sleep(1)
    print("Ich lese nun die ersten Zeilen aus dem 'Schätzgräber':")
    print("Arm am Beutel, krank am Herzen,schleppt ich meine alten Tage")
    print("Armut ist die größte Plage, Reichtum ist das höchste Gut")
    await asyncio.sleep(1)
    print("Jetzt ist 9 Uhr geworden und ich gehe ins Deutsche 'Python Forum")
    print("Hier stelle ich einen Code mit      'asyncio.gather'  vor.")
    print("mit anderen Worten ist das nichts anderes  als eine Sammlung")
    print("von diversen  anderen möglichen  Co-Routinen unter asyncio  ")
    await asyncio.sleep(1)
    print("Ich glaube, dass ich mich jetzt genügend mit 'asyncio  beschäftigt habe.")
    print("Ich möchte noch viele andere Module in Python kennenlernen.")
# lets create a main function
async def main():
    # we will pass the TimeCount() into the asyncio gather functio
    await asyncio.gather(TimeCount())

if __name__ == "__main__":
    import time
    tpc = time.perf_counter()
asyncio.run(main())
Timeup = time.perf_counter() - tpc
 
print(f"{__file__} executed in {Timeup:0.2f} seconds.")
print("bei längeren Routinen muss  sleep() - Zeit  erhöht werden")

[__blackjack__]

@OSWALD: `asyncio.gather()` macht hier genau gar keinen Sinn. Man kann die Funktion da einfach raus nehmen und nur ``await TimeCount()`` schreiben.

[OSWALD]

Also doppelt gemoppelt ?
Man lernt eben nicht aus.
Viele Grüße von OSWALD , ein dankbarer Schüler.


I see it's approaching lunchtime, so let's take a break.

[OSWALD]

4.11.2023
Ob es sinnvoll ist oder nicht ,
,kann ich hier nicht beurteilen,
aber ein bisschen Mathe geht auch
bei 'asyncio'.
Natürlich auch mit mehreren Co-Routinen,
mit Mathe und Text gleichzeitig.
Gute Zeit OSWALD

Code: Alles auswählen

import asyncio
from math import *
async def mathe(x, y):
    print(f"Mathe{x} by {y}")
    await asyncio.sleep(1)
    if y == 0:
       raise ZeroError("Cannot divide by zero")
    else: 
       return  x - y*sin(1)
    
async def main():
     
    result = await asyncio.gather(
        mathe(10 ,  2.5-1.2),
        mathe(20., 3.7*cos(1)),
        mathe(30., 1.5),


        return_exceptions=True,   
    )
     
    for r in result:
        if isinstance(r, Exception):
            print(f"Error: {r}")
        else:
            print(f"Result: {r}")


# run the main coroutine
asyncio.run(main())

[OSWALD]

11.11.2023

Ich habe mich doch noch an das heikle Thema
--multiprocessing -- herangewagt:
Es brauchte einen sehr langen Anlauf bis
ich endlich einen zunehmenden Durchblick gewinnen konnte.
-Learning by doing - und der Versuch viele Codes
zu analysieren. Außerdem musste ich mir viel Wissen über
Python , CPU , Gil etc und auch Threads aneignen,
sowie Python-Bibliotheken durchforsten und daraus
Module imortieren.
Jetzt kann ich endlich einige Scripts, von ich
glaube sie verstanden zu haben, präsentieren.

[OSWALD]

Hier die erste einfache Übung;
Gute Zeit OSWALD

Code: Alles auswählen

from multiprocessing import Pool
from os import getpid
from math import *
import os
pid = os.getpid() 
print("Prozess-ID", pid)  
    
def myfunc(i):
      return i **3 +  cos(i)

if __name__ == '__main__':
    with Pool() as pool:
        result = pool.map(myfunc,[1, 2, 3, 4, 5])
        print(result)