Das deutsche Python-Forum

Code: Alles auswählen

from tkinter import *
import subprocess
from subprocess import  *
from tkinter.filedialog import askopenfilename

def code1():
    subprocess.call(["C:/windows/system32/mspaint.exe"])
         
        #subprocess.call(["C:/Program Files/Internet Explorer/iexplore.exe"])

def code2():
     subprocess.call(["C:/windows/system32/calc.exe"])

def code3():
     subprocess.call(["C:/Program Files/Internet Explorer/iexplore.exe"])

def code4():
    subprocess.call( [ "C:\Program Files\Google\Chrome\Application\chrome.exe" ])                                                                   

def NewFile():
    print("New File!")

def OpenFile():
    name = askopenfilename 
    print(name)

def About():
    print("example of a menu" )



window = Tk()

menu = Menu(window)
window.config(menu=menu)
filemenu = Menu(menu)
menu.add_cascade(label="File", menu=filemenu)
filemenu.add_command(label="P a i n t", command=code1)
filemenu.add_command(label= "C a l c  ", command=code2)
filemenu.add_command(label= "E x p l o r e " ,command  =code3)
filemenu.add_command(label= "G o o g l e" , command = code4)

filemenu.add_separator()
filemenu.add_command(label="Exit", command=window.quit)

helpmenu = Menu(menu)
menu.add_cascade(label="Help", menu=helpmenu)
helpmenu.add_command(label="About...", command=About)

mainloop()

Code: Alles auswählen

mport subprocess
from subprocess import *
import tkinter as tk
from tkinter.filedialog import askopenfilename, asksaveasfilename
#########################
 
def open_file():
    """Öffne einen Dateiordner """
    filepath = askopenfilename(
        filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")]
    )
    if not filepath:
        return
    txt_edit.delete(1.0, tk.END)
    with open(filepath, "r") as input_file:
        text = input_file.read()
        txt_edit.insert(tk.END, text)
    window.title(f"Texteditor   - {filepath}")

def save_file():
    """Save the current file as a new file."""
    filepath = asksaveasfilename(
        defaultextension="txt",
        filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
    )
    if not filepath:
        return
    with open(filepath, "w") as output_file:
        text = txt_edit.get(1.0, tk.END)
        output_file.write(text)
    window.title(f"Text Editor Application - {filepath}")

 #########################
def code1():
    subprocess.call(["C:/windows/system32/mspaint.exe"]) 
#########################
window = tk.Tk()
window.title("Öffne Dateiordner, Text, Scrollen, Speichern als, Löschen ")
window.geometry("800x400")
 
txt_edit = tk.Text(window)
fr_buttons = tk.Frame(window, relief=tk.RAISED, bd=3)
btn_open = tk.Button(fr_buttons, text="Open", command=open_file)
btn_save = tk.Button(fr_buttons, text="Save As...", command=save_file)
btn_laden = tk.Button(fr_buttons, text="Laden..", command=code1())
 
btn_open.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
btn_save.grid(row=1, column=0, sticky="ew", padx=5)

fr_buttons.grid(row=0, column=0, sticky="ns")
txt_edit.grid(row=0, column=1, sticky="nsew")

window.mainloop()

Code: Alles auswählen

[/

  
import subprocess
from subprocess import *
import tkinter as tk
from tkinter.filedialog import askopenfilename, asksaveasfilename
#########################
 
def open_file():
    """Öffne einen Dateiordner """
    filepath = askopenfilename(
        filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")]
    )
    if not filepath:
        return
    txt_edit.delete(1.0, tk.END)
    with open(filepath, "r") as input_file:
        text = input_file.read()
        txt_edit.insert(tk.END, text)
    window.title(f"Texteditor   - {filepath}")

def save_file():
    """Save the current file as a new file."""
    filepath = asksaveasfilename(
        defaultextension="txt",
        filetypes=[("Text Files", "*.txt"), ("All Files", "*.*")],
    )
    if not filepath:
        return
    with open(filepath, "w") as output_file:
        text = txt_edit.get(1.0, tk.END)
        output_file.write(text)
    window.title(f"Text Editor Application - {filepath}")

 #########################
#def code1():
#    #subprocess.call(["C:/windows/system32/mspaint.exe"]) 
#     subprocess.run(["Windows\(C:)GUIRechner.py"]) 


#########################
window = tk.Tk()
window.title("Öffne Dateiordner, Text, Scrollen, Speichern als, Löschen ")
window.geometry("800x400")
 
txt_edit = tk.Text(window)
fr_buttons = tk.Frame(window, relief=tk.RAISED, bd=3)
btn_open = tk.Button(fr_buttons, text="Open", command=open_file)
btn_save = tk.Button(fr_buttons, text="Save As...", command=save_file)
#btn_laden = tk.Button(fr_buttons, text="GUIRechner..", command=code1())
 
btn_open.grid(row=0, column=0, sticky="ew", padx=5, pady=5)
btn_save.grid(row=1, column=0, sticky="ew", padx=5)

fr_buttons.grid(row=0, column=0, sticky="ns")
txt_edit.grid(row=0, column=1, sticky="nsew")

window.mainloop()




code]

Code: Alles auswählen

from dataclasses import dataclass
from dataclasses import field
from dataclasses import InitVar
import pandas as pd
import random 
from math import *
@dataclass
class DataClass_Modern(object):

    # Invisible attribute (init-only)
    attr0:InitVar[int] = 81

    # Initialized attribute
    attr1:int   =0
    attr2:float =0.
    attr3:str   ='undefined'
    attr4:list  = field(default_factory=list)

    # Generated attribute
    attr5:float = field(init=False)

    # Generated attribute - read property
    @property
    def attr5(self)->float:
        return sqrt(abs(self._attrHidden))

    # Generated attr - set property (required by dataclasses)
    @attr5.setter
    def attr5(self,_):pass # Do nothing, this is a read-only attribute

    def __post_init__(self,attr0):
        # Make a copy of the init-only attribute to a local attribute that
        # is used for the generated attribute (via a property)
        self._attrHidden = attr0 # This attribute should remain hidden from pandas
    @classmethod

    def rand_factory(cls):
        '''
        Returns an object of the calling class with randomized initialization attributess
        '''
        return cls(
            attr0=random.randint(-1e3,1e3),
            attr1=random.randint(-1e6,1e6),
            attr2=random.random(),
            attr3=random.choice(
                [
                    'Tool',
                    'PinkFloyd',
                    'Soundgarden',
                    'FaithNoMore',
                    'aPerfectCircle',
                    'KingCrimson',
                    'PearlJam',
                    'ChildrenOfBodom']),
            attr4=random.choices(range(100,999),k=3)
        )

if __name__ == '__main__':

    rand_objects = [DataClass_Modern.rand_factory() for _ in range(10)]
    df = pd.DataFrame(rand_objects)

    print(df)

#Google ermittelt den Cumulative Layout Shift durch eine Formel, 
#die die beiden Variablen „impact friction“ und „distance friction“
# miteinander multipliziert:
#  =CLS-Wert#

Code: Alles auswählen

from math import *
import pandas as pd 
import numpy as np 


print("         Test 1" )

zahlen1 =[]   
zahlen  =   [ [12, 17, 19 ], [ 14, 28, 13] , [ 23,14,36]]
 
df = pd.DataFrame(zahlen ) 
print(df)
       
df +df  
print (df+df) 

df-df  
print (df-df) 

df *df  
print (df*df) 
      
df/df  
print(df/df) 
############################# 
print("           Test 2") 
zahlen =[]   
zahlen  = [[sin(1), cos(3), tan(0.5)], [ 14, 28, 13]] 
df2 = pd.DataFrame(zahlen)  

df2 + df2  
print (df2+df) 

df2-df2  
print (df2-df2) 

df2 *df2  
print (df2*df2) 
      
df2/df2  
print(df2/df2) 

#############################
print("          Test 3")
            
       
zahlen3 =[]   
zahlen3 = [[sin(1), cos(3), tan(0.5)], [ log(14), exp(0.35), log10(16)]] 
df3 = pd.DataFrame(zahlen3)
 
df3 + df3  
print (df3+df3) 

df3-df3  
print (df3-df3) 

df3 *df3  
print (df3*df3) 
      
df3/df3  
print(df3/df2) 

Code: Alles auswählen

from math import *
import pandas as pd 
import numpy as np 

   
zahlen  =   [ [12, 17, 19 ], [ 14, 28, 13] , [ 23,14,36]]
df = pd.DataFrame(zahlen ) 

zahlen1 =   [ [1, 7, 19 ], [ 4, 8, 3] , [ 3,4,6]]
df1 = pd.DataFrame(zahlen1) 
  
print(df+df1) 
print(df-sin(5) )
print(df*df1)
print(df/ 1/3)

############################ 
  
zahlen =[]   
zahlen  = [[sin(1), cos(3), tan(0.5)], [ 14, 28, 13]] 
zahlen1 = [[ 1   ,3       , 5      ], [  3  ,3 , 2 ]]
df = pd.DataFrame(zahlen)  
df2 = pd.DataFrame(zahlen1)
 
print(df2+df) 
print(df-df2) 
print(df*df2) 
print(df/df2) 
print(df **3)   
#############################



 
 

Code: Alles auswählen

import numpy as np
import pandas as pd


df = pd.DataFrame({'Punkte': [np.nan, 12, 15, 14, 19],
                   'Helfer': ['5', np.nan, '7', '9', '12'],
                   'rebounds': ['11', '8', '10', '6', '6']})  

print("  Zunächst  das   Original Dataframe  ") 
print("  Es enthält zwei Leerstellen ")
print(df)
 
 
print( "   Spaltendatentypen anzeigen")
df.dtypes
print(df.dtypes)
dtype: object
print("     Konvertieren einer einzelnen Spalte in Float")
print( "    Es betrifft die Spalte  'Helfer' ")
#"assists" von string in float konvertieren
df['Helfer'] = df['Helfer'].astype(float)
print(df.dtypes) 
df.dtypes
print(df)
 
print("Spalten 'rebounds' u.'Helfer'  in float konvertieren")
df[['Helfer', 'rebounds']] = df[['Helfer','rebounds']].astype(float)
print(df)

df.dtypes#Spaltendatentypen anzeigen
print(df.dtypes)

 
dtype: object
#Beispiel 3: Alle Spalten in Float umwandeln
#Die folgende Syntax zeigt, wie Sie alle Spalten im DataFrame in Floats konvertieren:

#konvertieren Sie alle Spalten in Float
df.dtypes
df = df.astype(float)
print()
print("Spaltendatentypen  jetzt  :"      )
dtype: object

print("Konvertieren von String in Float und Füllen von NaN-Werten")
print("'Helfer'von Strings in Floats  u.die NaN-Werte mit Nullen füllen")

#konvertiere "assists" von string in float und fülle NaN-Werte mit Nullen aus
df['Helfer'] = df['Helfer'].astype(float).fillna(0)
print(df)
print("Jetzt letztes DataFrame anzeigen.")
print(df['Helfer'])                          
 

Code: Alles auswählen

[
 
 #konvertiere "Helfer" von string in float und fülle NaN-Werte mit Nullen aus
df['Punkte'] = df['Punkte'].astype(float).fillna(0)
df['Helfer'] = df['Helfer'].astype(float).fillna(0) 
print(df)
print("Jetzt letztes DataFrame anzeigen.")
print(df['Punkte'])                          
 


/code]

Code: Alles auswählen

import numpy as np
from scipy import*  
from math import  *
import pandas as pd
a = pd.DataFrame([1,2,3,6,2,3,1,8,9,10])
b = pd.DataFrame([1,2,3,4,5,6,7,8,9,10]) 
c = pd.DataFrame([1,1,1,1,1,1,1,1,1,1])

#########################
#print(3* a **3)
#print(b**3)
#print(3*c**3)
#########################
#print(a**2 + 2*a*b + b**2)  
#print(3*(a + b) * 2*(a - b))
print(a/(a+b)+a*b)
print((a-b)/(b +c -a))
 
#print(b + 3*np.pi- 2*exp(2) )
##print(4*a*3 + b**3 )       
#(3*( a + 2*a + a**2)* (3-b**3 )-c ) 
##print(( a + b-c) * (a-b))

Code: Alles auswählen

#   Einfaches bestimmtes Integral

import scipy.integrate as spi
import numpy as np

print("Integral,Fläche von b -a)" )
integrand = lambda x :   3*x**3 +6
a = 1                     
b = 2.5

result, error  = spi.quad(integrand, a, b)
print('Ergebnis: ', result)
print('geschätzter Fehler ', error)
 

Code: Alles auswählen

import sympy as sy
# Sympy-Variablen initiieren:
x = sy.S( 'x' )
a, b = sy.S( [1,2] ) # hier Ober- /Untergrenze
# Bestimmtes Integral berechnen:

    
sy.integrate( sy.pi * (x**2 + x + 1/x) , (x,a,b) )
print("Hinweis  zu Zeile 10: 1/x wird zu log() ")  
print("Exaktes Ergebnis = :",sy.integrate( sy.pi * (x**2 + x + 1/x) , (x,a,b) )) 
 
sy.integrate( sy.pi * (x**2 + x + 1/x) , (x,a,b) ).evalf()
print(" jetzt Auswertung mit eval ")
print("Ergebnis2=:",sy.integrate( sy.pi * (x**2 + x + 1/x) , (x,a,b) ).evalf()                                                  ) 

Code: Alles auswählen

import scipy.integrate as spi
import numpy as np
print("Parabelfläche  von x**2  : Rotation um die X-Achse                                                     ")
print("Berechnung der Mantelfläche ")
 

integrand = lambda x :  np.pi *x**2 *(x**2+1) **1/2
a = 1.
b = 3

result, none = spi.fixed_quad(integrand, a, b, n=5)
print('Mantelfläche =: ', result)
 
print()#################################################
 
print("Parabelfläche von x**2  : Rotation um die X-Achse ")
print("Integral  fixed_quad mit scipy")

print('Integral über Pi * f(Pi*x**2) **2 ')
       
integrand = lambda x :  np.pi * (x**2)**2 
a = 1
b = 3
result, none = spi.fixed_quad(integrand, a, b, n=5)
print("Volumen  =:" ,result)

Code: Alles auswählen

Code: Alles auswählen

1.
from math import *
import numpy as np
import scipy
from scipy.integrate import quad 
def func(x):
    return  x +  sin(x) -cos(x) + exp(x) 

integral,error = scipy.integrate.quad(func,0,2)
print("Ergebnis als Summe aller Elemente : " + str(integral))
print("Der Fehler   = :" +str(error))

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

2.from  sympy  import  sin , asin ,cos , atan , tan ,  exp ,  log , integrate  
from  sympy  import  integrate 
from  sympy.abc  import  x ,y  ,z
print(integrate ( 1  /  x ,  x ) )
 
print(integrate ( 1 / x ) )
 
print(integrate ( log ( x),  x ) )
 
print(integrate ( log ( x )) )
 
print(integrate ( exp ( x )  /  ( 1  +  exp ( 2  *  x )) ,  x ) )
 
print(integrate ( cos ( x ) ** 4  *  sin ( x ) ** 3 ,  x ) )
 
print(integrate ( cos ( x ) ** 4  *  sin ( x ) ** 5 ,  x ) )
 
print(integrate ( tan ( x ),  x ) )
  
print(integrate ( sin ( x ),  x ) )
 
print(integrate ( asin (x) ,x ))

print(integrate ( atan (y) , y ))

print(integrate ( 1/z**3 ,z  )) 

Code: Alles auswählen

mport numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
 


def func(x):
    return   x**2  


a, b = 4, 9  # integral limits
x = np.linspace(2, 10)
y = func(x)

fig, ax = plt.subplots()
ax.plot(x, y, 'r', linewidth=2)
ax.set_ylim(bottom=0)

# Make the shaded region
ix = np.linspace(a, b)
iy = func(ix)
verts = [(a, 1), *zip(ix, iy), (b, 0)]
poly = Polygon(verts, facecolor='0.9', edgecolor='0.5')
ax.add_patch(poly)

ax.text(0.5 * (a + b), 30, r"$\int_a^b f(x**2)\mathrm{d}x$",
        horizontalalignment='center', fontsize=20)

fig.text(0.9, 0.05, '$x$')
fig.text(0.1, 0.9, '$y$')

ax.spines[['top', 'right']].set_visible(False)
ax.set_xticks([a, b], labels=['$a$', '$b$'])
ax.set_yticks([])
plt.title('Funktion =  x**2,.      Grenzen a=4, b=9 ') 
plt.grid(True) 
plt.show()

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

Code: Alles auswählen

from sympy import *
x = symbols('x')



f = 7*x**5- ln(x)+3
print("f(x) =", f)
print("Stammfunktion: F(x) =", integrate(f, x))
print("Ableitung: f'(x) =", diff(f, x))
print() 
 
f =  - 2*x**2   + log(4*x) * 1/x
print("f(x) =", f)
print("Stammfunktion: F(x) =", integrate(f, x))
print("Ableitung: f'(x) =", diff(f, x))
print() 


f =     exp(x) + sin(2*x)*cos(x)
print("f(x) =", f)
print("Stammfunktion: F(x) =", integrate(f, x))
print("Ableitung: f'(x) =", diff(f, x))
 

Code: Alles auswählen

Code: Alles auswählen

import sympy
import numpy as np 
import numpy as np
from scipy.interpolate import make_interp_spline
 
A =-0.5      #siehe Zeeile 33
B= 1.5       #--ort A,B einsetzen'

def main():
   x = sympy.symbols('x')
   bogenlänge_y =  3*x**3 +2*x**2 +5    # sqrt ist die Wurzel
    # diff ist die Ableitung
   z = sympy.sqrt(1 + sympy.diff(bogenlänge_y, x) ** 2)
   print(z)
    # integrate ist die Integration
   s = sympy.integrate(z, (x, A, B))
   print(s) 
    # N wandelt das sympy-Objekt in eine Dezimalzahl
   bogenlänge_s = sympy.N(s, 7)
    
   print(f"Bogenlänge für y = {bogenlänge_y}")
   print(f"Grenzen a ={A}, b ={B}")
   print(f"Bogenlänge s = {bogenlänge_s}")


if __name__ == '__main__':
   main()

import matplotlib.pyplot as plt
import numpy as np

# Definieren der x- und y-Werte
x = np.arange(A,B,0.1)
y = x**4 - 4*x**3 

# Diagramm der Werte erstellen
plt.plot(x,y)

#Füllen Sie den Bereich zwischen den beiden Linien aus
plt.fill_between(x, y, np.max(y), color='red', alpha=.5)