kleine Mathe-Spielereien
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()
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()
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.
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()
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.
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()
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
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()
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
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()
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
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()
21.10.2023
Wochenende.
Warum nach harter Arbeit nicht einmal
'spielend' entspannen.
Vorsicht ! Kann süchtig machen.
Gue Zeit OSWALD
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()
################################
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
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__
- User
- Beiträge: 13268
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
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.
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.
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).
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).
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
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))
1.10.23
Hier zunächst noch zwei weitere Beispiele zu asyncio
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())
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)
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())
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
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__
- User
- Beiträge: 13268
- Registriert: Samstag 2. Juni 2018, 10:21
- Wohnort: 127.0.0.1
- Kontaktdaten:
@OSWALD: `asyncio.gather()` macht hier genau gar keinen Sinn. Man kann die Funktion da einfach raus nehmen und nur ``await TimeCount()`` schreiben.
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.
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
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())
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.
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.
Hier die erste einfache Übung;
Gute Zeit OSWALD
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)