kleine Mathe-Spielereien

[OSWALD]

8.12.2023
Ich habe erkannt, dass ich in Python nicht viel weiter
kommen werde, wenn ich mich nicht endlich
v i e l intensiver mit NUMPY beschäftigen werde.
Ich glaube, es lohnt sich.
Hier gleich ein schönes Beispiel.
Gute Zeit OSWALD

Code: Alles auswählen

mport numpy as np
import matplotlib.pyplot as plt
 
# let img1 be an image with no features
bild1 = np.array([np.array([400, 200]), np.array([255, 145])])
bild2 = np.array([np.array([400, 255]), np.array([400,255])])
bild3 = np.array([np.array([7, 3]), np.array([8, 9])])
 
kernel_horizontal = np.array([np.array([0, 3]), np.array([-3, 4])])
print(kernel_horizontal, 'is a kernel for detecting horizontal edges')
 
kernel_vertical = np.array([np.array([0,-1]), np.array([7, -1])])
print(kernel_vertical, 'is a kernel for detecting vertical edges')
 
# We will apply the kernels on the images by
 
 
def apply_kernel(bild1, kernel):
    return np.sum(np.multiply(bild1, kernel))
 
# bild1 plotten
plt.imshow(bild1)
plt.axis('off')
plt.title('bild1- Leiste erlaubt Veränderung der Daten ')
plt.show()
 

print('Horizontales Kanten-Konfidenzintervall:', apply_kernel(bild1, 
                                            kernel_horizontal))
print('Vertikales  Kanten-Kconfidenzintervall:', apply_kernel(bild1, 
                                            kernel_vertical))
 
# bild2 plotten
plt.imshow(bild2)
plt.axis('off')
plt.title('bild2')
plt.show()
 

print('Horizontales Kanten-Konfidenzintervall :', apply_kernel(bild2, 
                                            kernel_horizontal))
print('Vertikales   Kanten-Konfidenzintervall:', apply_kernel(bild2, 
                                            kernel_vertical))
# bild3 plotten
plt.imshow(bild3)
plt.axis('off')
plt.title('bild3')
plt.show()
 

print('Horizontales Kanten-Kconfidenzintervall:', apply_kernel(bild3, 
                                            kernel_horizontal))
print('Vertical edge confidence score:', apply_kernel(bild3, 
                                            kernel_vertical))

[OSWALD]

10.12.2023
Zum Einstieg in - numpy - beginne ich mit
einfachen Methoden, mit denen diverse
np.Arrays berechnet werden können. (dtype int)
Alles einfach, aber eine wichtige Grundlage.
Gute Zeit Oswald

Code: Alles auswählen

print()
print(np.mean(data))
 
print()
print(data.sum())
print(data.sum() + data.sum())
print(data.sum()- data.sum())       
print(data.sum() * data.sum())    
print(data.sum() / data.sum())     

print()

print(data.mean(axis=0))
print()
print(data.sum(axis=1))
print()
print(data.cumsum())
print(data.cumprod()) 

print()
print(data.argmin())
print(data.argmax())
print()
print(data.std())
print(data.var())

[OSWALD]

11.12.2023
Als erste Methode habe ich -Slicing- ausgewählt.
Slicing scheint mir die am meisten verbreitete ' Methode'
nicht nur in numpy, sondern generell auf allen technischen
Gebieten weltweit bis hin zum 3D-Drucker.
Ihre Bedeutung speziell in numpy wird durch
den kleinen Beitrag schnell klar und einfach.
Bei den 6 Elementen im gezeigten Beispiel dürfte die
Anzahl der möglichen Einzelergebnisse bei mehr als
Tausend Permutationen, mindestens aber bei 720 , liegen,
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np

p = ['P','y','t','h','o','n']
print(p[0:4])
['P','y','t','h']
print(p[1:4])
['y','t','h']
print(p[2:4])
['t','h']
print(p[3:4])
['h']
print(p[0:2])
['P']
print(p[0:1])
['y']
print(p[4:5])
['o']

[__blackjack__]

@OSWALD: Interessant wie Du die Bedeutung in Numpy zeigen willst, mit einem Beispiel das Numpy überhaupt nicht benutzt. Und in der Anzahl hast Du Dich auch stark verschätzt. Es sind nicht mal annähernd 720 mögliche Ergebnisse. Nur 22 für eine Sequenz mit 6 Elementen:

Code: Alles auswählen

[['P'],
 ['y'],
 ['t'],
 ['h'],
 ['o'],
 ['n'],
 ['P', 'y'],
 ['y', 't'],
 ['t', 'h'],
 ['h', 'o'],
 ['o', 'n'],
 ['P', 'y', 't'],
 ['y', 't', 'h'],
 ['t', 'h', 'o'],
 ['h', 'o', 'n'],
 ['P', 'y', 't', 'h'],
 ['y', 't', 'h', 'o'],
 ['t', 'h', 'o', 'n'],
 ['P', 'y', 't', 'h', 'o'],
 ['y', 't', 'h', 'o', 'n'],
 ['P', 'y', 't', 'h', 'o', 'n']]

[OSWALD]

]12.12.23
@__blackjack__
Irrtum1 entstand bei erster Orientierung an untenstehendem Code
Irrtum2. ich übersah, dass beim slicing der Original- Inhalt von arrays konstan.
bleibt . Es geht um den Index.
Vielen Dank für Betreuung und Geduld
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np

# Create the following rank 2 array with shape (3, 4)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
print("Array mit shape(3,4)\n "               ,a)
print()
# mit SLICING  subarray consisting of the first 2 rows
# and columns 1 and 2; b is the following array of shape (2, 2):
# [[2 3]
#  [6 7]]
b = a[:2, 1:3]
print(b)
# A slice of an array is a view into the same data, so modifying it
# will modify the original array.
print(a[0, 1])   # Prints "2"
b[0, 0] = 77     # b[0, 0] is the same piece of data as a[0, 1]
print(a[0, 1])   # Prints "77"
#You can also mix integer indexing with slice indexing.


# Create the following rank 2 array with shape (3, 4)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])

# Two ways of accessing the data in the middle row of the array.
# Mixing integer indexing with slices yields an array of lower rank,
# while using only slices yields an array of the same rank as the
# original array:

(row_r1) = a[1, :]    # Rank 1 view of the second row of a
print(row_r1)
print(row_r1, row_r1.shape)  # Prints "[5 6 7 8] (4,)"
 

 

[OSWALD]

12.12.23
Jetzt weiß ich, dass ich beim slicing nur dann
numpy implementieren muss , wenn ich auch
Elemente aus numpy verwende.
z.B. bei folgendem Code , der wie hier etwa
np.arrays verwendet.
Oswald

Code: Alles auswählen

import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6]], np.int64)
print(x)                                 #class 'numpy.ndarray'>
x.shape
(2, 3)
print(x.dtype)
 #The array can be indexed using Python container-like syntax:

# The element of x in the *second* row, *third* column, namely, 6.
print(x[1, 2])

#For example slicing can produce views of the array:
y = x[:1,-2]                                         #ode rx [:1;,-3]  . dann [3]
print(y)
y = x[:,1]
y[0] = 9 # this also changes the corresponding element in x
print(y)
print(x)

[OSWALD]

13.12.23
Zur Abwechslung mal ein kleines Tool,
das ich zufällig gefunden habe.
(den beiliegendenText einfach als Block einserzen)
Gute Zeit Oswald

Code: Alles auswählen

text = str(input("Beliebigen Text  eingeben: ")) ohne      # , (),  " ",  etc,
such = str(input("Welches Wort  oder Zahl soll gesucht werden: "))
print ("und wie oft kommt das gesuchte Wort vor ?")
print("Das Wort" , such , "wurde" , text.count(such), "mal gefunden.")


#Beispiel 
#NumPy ist das grundlegende Paket für wissenschaftliches Rechnen in Python.
#Es handelt sich um eine Python-Bibliothek, die ein mehrdimensionales Array-Objekt,
#verschiedene abgeleitete Objekte (z. B. maskierte Arrays und Matrizen)  21 22 34 567 21, 21,56777
#und eine Reihe von Routinen für schnelle Operationen an Arrays bereitstellt,
#einschließlich mathematischer, logischer, Formmanipulation, Sortierung, Auswahl und E/A ,
#diskrete Fourier-Transformationen, grundlegende lineare Algebra, grundlegende statistische Operationen,
#Zufallssimulation und vieles mehr.

[OSWALD]

13..12.23
Am besten kopiert man den Text direkt
aus dem web.
Oswald

[OSWALD]

13,12.23
Die kürzeste und brillianteste
Primfaktorzerlegung, die mir bisher
bekannt geworden ist , ziege ich hier:
Gute Zeit OSWALD

Code: Alles auswählen

#                   Kürzeste mir  biher bekannte Primfaktorzerlegung

zahl =  1234321

print ("Die gewählte  Zahl enthält  folgende Primfaktoren: ", zahl)
d=2
while zahl > 1:
   if zahl%d==0:
      print (d)
      zahl=zahl/d
      continue
   d=d+1

[OSWALD]

13.12.23
zurück zu numpy.
hier das ( nicht ganz einfache) Prnizip
der Faltung. Habe ich es 100%ig verstanden?
Ich arbeite jedenfalls daran.
OSWALD

Code: Alles auswählen

import numpy as np

def Multiply(filter,I,row,col):
    #function for filter and I window multiplication
    result=0
    for i in range(3):
        for c in range(3):
            result=result+filter[i][c]*I[i+row][col+c]

    return result

def Convolution(filter,I):
    Result = np.random.rand(3,4)
    for i in range(3):
        for c in range(4):
            Result[i][c]=Multiply(filter,I,i,c)
    return Result


if __name__=="__main__":
   filter=np.array([[-2,0,1],
              [-4,0,4],
              [-2,0,2]])
   I=np.array([[8,8,8,10,10,10],[8,8,8,10,10,10],[8,8,8,10,10,10],[9,9,9,9,9,9],[9,9,9,9,9,9]])
   result=Convolution(filter, I)

[OSWALD]

13.12.23
Nun ein NUMPY-Filterarray, das
alle gerade Zahlen herausfiltert
OSWALD

Code: Alles auswählen

import numpy as np

arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 10,  20, 33,])

# Create an empty list
filter_arr = []

# go through each element in arr
for element in arr:
  # if the element is completely divisble by 2, set the value to True, otherwise False
  if element % 2 == 0:
    filter_arr.append(True)
  else:
    filter_arr.append(False)

newarr = arr[filter_arr]

print(filter_arr)
print(newarr)

[__blackjack__]

Die kürzeste Primfaktorzerlegung ist sie nicht selbst zu implementieren:

Code: Alles auswählen

In [2]: import sympy

In [3]: sympy.primefactors(1234321)
Out[3]: [11, 101]

Das Faltungsbeispiel ”mit Numpy” ist mal wieder kein Beispiel für Numpy weil dort nichts von Numpy verwendet wird. Das hätte man auch einfach mit Listen schreiben können.

Unsinnig ist auch das erstellen eines Arrays mit Zufallswerten wo keiner dieser Werte irgendwo verwendet wird. Die werden alle durch andere Werte überschrieben bevor das zurückgegeben wird.

Der Code ohne Numpy:

Code: Alles auswählen

#!/usr/bin/env python3


def multiply(filter_, I, row, col):
    # function for filter and I window multiplication
    return sum(
        filter_[i][c] * I[i + row][col + c] for i in range(3) for c in range(3)
    )


def convolution(filter_, I):
    return [[multiply(filter_, I, i, c) for c in range(4)] for i in range(3)]


def main():
    filter_ = [[-2, 0, 1], [-4, 0, 4], [-2, 0, 2]]
    I = [
        [8, 8, 8, 10, 10, 10],
        [8, 8, 8, 10, 10, 10],
        [8, 8, 8, 10, 10, 10],
        [9, 9, 9, 9, 9, 9],
        [9, 9, 9, 9, 9, 9],
    ]
    result = convolution(filter_, I)
    print(result)


if __name__ == "__main__":
    main()

Und auch das letzte Beispiel benutzt Numpy wieder nicht richtig. Die Maske zum selektieren bastelt man sich nicht mit einer Schleife über die Array-Elemente, sondern mit einem Ausdruck der Numpy-Arrays verwendet, auf ”einen Schlag”:

Code: Alles auswählen

In [13]: arr = np.array([1, 2, 3, 4, 5, 6, 7, 8, 10, 20, 33])

In [14]: arr % 2 == 0
Out[14]: 
array([False,  True, False,  True, False,  True, False,  True,  True,
        True, False])

In [15]: arr[arr % 2 == 0]
Out[15]: array([ 2,  4,  6,  8, 10, 20])

Selbst wenn man sich eine Python-Liste mit Wahrheitswerten erstellen würde, nicht so umständlich mit einer ``for``-Schleife, ``if`` und ``else`` und literalen `True` und `False`, sondern einfach als „list comprehension“:

Code: Alles auswählen

In [16]: [value % 2 == 0 for value in arr]
Out[16]: [False, True, False, True, False, True, False, True, True, True, False]

[OSWALD]

14.12.2023
Eindeutig; numpy und matplotlib.
Mit ganz einfachem Code kann man eine
Menge math. Funktionen darstrellen.Das geschieht
in diesem Fall durch ihre Verbindung mit x oder y.
Der Phantasie sind hier kaum Grenzen gesetzt.
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np 
from matplotlib import pyplot as plt 

x = np.arange(3,15,0.1)    #np.numpy-array
y = 2 * x**3  + 5 
plt.title("Matplotlib and  numpy:                     any ccode  just for fun") 
plt.xlabel("x-Achse") 
plt.ylabel("y-Achse") 
#plt.plot(x*np.sin(x) ,y) 
plt.plot(x,np.cos(y)/y)
plt.grid()
plt.show()

(any code just for fun)

[OSWALD]

14.12.2023
Matplotlib läuft natürlich auch o h n e numpy ,z.B. mit Listen
Oswald

Code: Alles auswählen

from matplotlib import pyplot as plt 
x = [5,8,10] 
y = [12,16,6]  

x2 = [6,9,11] 
y2 = [6,15,7] 
plt.bar(x, y, align = 'center') 
plt.bar(x2, y2, color = 'g', align = 'center') 
plt.title('Mit L i s t e n  läuft matplotlib  auch o h n e  numpy') 
plt.ylabel('Y-Achse') 
plt.xlabel('X-Achse')  
plt.show()

(any code just for fun)

[OSWALD]

16.12.2023
Je mehr ich mich mit numpy beschäftige,
umso mehr erkenne ich, dass ich mich zunächst auf
das Wesentliche in den einzelnen Kapiteln beschränken muss.
Ich habe mir zunächst die numpy-arrays und ufunc
angeschaut. Hier zwei exemplarische Beispiele .
Oswald

Code: Alles auswählen

#  Erzeugung  einiger  numpy-Arrays

a = np.array([1,2,4])    
print("1.",      a)
print()
b = np.arange(1,15,2) #        [1,3,5,7,9,11,13,15]
print("2.",      b)
print()
c=  np.linspace(0,1,6) #         [0.0,0.2,0.4,0.6,0.8,1.0]
print("3."  ,     c)
print()
d = np.ones((3,3)) #                3x3 array of ones, erzeugt nur Eeinser
print("4. "   ,       d)
print()
e = np.zeros((2,5,3)) #             2x5x3 array of zeros   ,erzeugt nur Nullen
print("5."              ,e)
print()
f = np.eye(4) #                         4x4 unit ‘matrix‘
print("6.",              f)
print()
g = np.diag(np.array([1,2,3,4])) # diagonal ‘matrix‘
print(g)
print()
h = np.random.rand(4)               # array with [0,1]
print(h)
print()
i = np.random.randn(4,5) #        4x5 array (norm. dist)
print(i)

[OSWALD]

16t.12.2023
Nun zu ufunc( als Teil von numpy)
Was sind ufuncs
ufuncs sind mathematische Funktionen, die elementweise auf
np-Arrays angewendet werden:
z.B
np.add(a,b) wird auch aufgerufen bei 'a + b'
np.exp(data)
np.sqrt(data)
np.log(data)
Das normale math-Modul kann nicht auf ndarrays
angewendet werden.
Data können auf diverse Weise eiungetragen werden.
Hier eine Einführung zur ersten Orientierung.
Eingehendere Beispiele folgen,
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np
print("Einrichtung des Arrays  für ufunc")
data = np.arange(0,10)
print(data)
print()
print("Berechnung des  Sinus der Elemente")
print(np.sin(data))
print()
print("Potenzen der Eelemente")
print(np.exp(data))
print() 

x = np.random.randn(8)
y = np.random.randn(8)
 
np.maximum(x, y)
print()
x = np.random.randn(8)
y = np.random.randn(8)
print("Berechnet  MAXIMA   der Elemente")
print(np.maximum(x,y))

[OSWALD]

16.12.23
Hier ein weiteres Beispiel von ufunc .
OSWALD

Code: Alles auswählen

#Ufuncs arbeiten nur innerhalb von numpy -ARRAYS ,    auf alle Elemente

import numpy as np
print("Eigene ufunc  erstellen")
print("durch Inhalte  von x und y addieren  zu   ' ufunc' "  )
def myadd(x, y):
  return x+y
myadd = np.frompyfunc(myadd, 2, 1)
print(myadd([1, 2, 3, 4], [5, 6, 7, 8]))
print()



print("Überprüfen , ob diese Funktion tatsächkich eine Ufunc ist:")
print(type(np.add))


if type(np.add) == np.ufunc:
  print('add is ufunc')
else:
  print('add is not ufunc')
print()
print("Elemente von zwei  np.arrays addieren")
arr1 = np.array([10, 11, 12, 13, 14, 15])
arr2 = np.array([20, 21, 22, 23, 24, 25])
newarr = np.add(arr1, arr2)
print(newarr)

print() 
print("Nachkommastellen abschneiden")
arr = np.trunc([-3.1666, 3.6667])
print(arr)
 
print("#Berechnen Sie die diskrete Differenz des folgenden Arrays:")
print(" so wird gerechnet ; b-a,  c-a,  d-c  ")
#arr = np.array([10, 15, 25, 5])
arr = np.array([1, 5, 1  , 35]) 
#arr = np.array([1, 13, 20, 5])
newarr = np.diff(arr)
print(newarr)
print()
 

print("Sinush  pi/2 ")
      
 
x = np.sinh(np.pi/2)
print(x)
print()

print("Berechnen e Cos-Werte für alle Werte in arr:")
 
arr = np.array([np.pi/2, np.pi/3, np.pi/4, np.pi/5])
x = np.cos(arr)
print(x)
print()


#finden Sie den Winkel von 1,0:
print("Berechnen  Winkel von 45°  für arcsinh ")
import numpy as np

x = np.arcsinh(45.0)
print(x)
print()

[OSWALD]

leine Mathe-Spielereien
Vorschau: Re: kleine Mathe-Spielereien
24.12.2023
Python und seine Bibliotheken spielen eine
bedeutende Rolle in Finanzwirtschaft und
Statistik, dabe ispeziell auch numpy.
Statistik ist Mathematik pur , bestehend aus
Formeln ohne Ende.
Und genau dafür ist Python praedestiniert.
Man sollte als Anfänger, der sich an dieses
Thema heranwagt, zumindest eine leise Ahnung haben
was Statistik ist.
Python bietet das Werkzeug für die Umsetzung des
Datendschungels in die praktische Anwendung.
Die erste Frage sit, wo fange ich als Anfänger an.
Unten, bei der Datenerfassung, bei den Vertielungen
oder bei der Monte Carlo Simulation. usw.
Einen großen Überblick dafü,r was auf mich zukommt,
gewinne ich, wenn ich z.B. bei der ANOVA.
Hier ein erstes (abschreckendes ) Beispiel.

Code: Alles auswählen

Die ANOVA, oder auch Varianzanalyse, ist ein multivariantes Analyseverfahren,
#das die Mittelwerte von mehreren verschiedenen Stichproben miteinander vergleicht.

from urllib.request import urlopen
import numpy as np

np.set_printoptions(precision=4, suppress=True)

import pandas as pd

pd.set_option("display.width", 100)
import matplotlib.pyplot as plt
from statsmodels.formula.api import ols
from statsmodels.graphics.api import interaction_plot, abline_plot
from statsmodels.stats.anova import anova_lm

try:
    salary_table = pd.read_csv("salary.table")
except:  # recent pandas can read URL without urlopen
    url = "http://stats191.stanford.edu/data/salary.table"
    fh = urlopen(url)
    salary_table = pd.read_table(fh)
    salary_table.to_csv("salary.table")

E = salary_table.E
M = salary_table.M
X = salary_table.X
S = salary_table.S

#Take a look at the data:

plt.figure(figsize=(6, 6))
symbols = ["D", "^"]
colors = ["r", "g", "blue"]
factor_groups = salary_table.groupby(["E", "M"])
for values, group in factor_groups:
    i, j = values
    plt.scatter(group["X"], group["S"], marker=symbols[j], color=colors[i - 1], s=144)
plt.xlabel("Experience")
plt.ylabel("Salary")

#
#../../../_images/examples_notebooks_generated_interactions_anova_5_1.png

#Fit a linear model:

formula = "S ~ C(E) + C(M) + X"
lm = ols(formula, salary_table).fit()
print(lm.summary())

                           # OLS Regression Results
#==============================================================================
#Dep. Variable:                      S   R-squared:                       0.957
#Model:                            OLS   Adj. R-squared:                  0.953
#Method:                 Least Squares   F-statistic:                     226.8
#Date:                Thu, 14 Dec 2023   Prob (F-statistic):           2.23e-27
#Time:                        14:44:31   Log-Likelihood:                -381.63
#No. Observations:                  46   AIC:                             773.3
#Df Residuals:                      41   BIC:                             782.4
#Df Model:                           4
#Covariance Type:            nonrobust
#==============================================================================
#                 coef    std err          t      P>|t|      [0.025      0.975]
#------------------------------------------------------------------------------
#Intercept   8035.5976    386.689     20.781      0.000    7254.663    8816.532
#C(E)[T.2]   3144.0352    361.968      8.686      0.000    2413.025    3875.045
#C(E)[T.3]   2996.2103    411.753      7.277      0.000    2164.659    3827.762
#C(M)[T.1]   6883.5310    313.919     21.928      0.000    6249.559    7517.503
#X            546.1840     30.519     17.896      0.000     484.549     607.819
#==============================================================================
#Omnibus:                        2.293   Durbin-Watson:                   2.237
#Prob(Omnibus):                  0.318   Jarque-Bera (JB):                1.362
#Skew:                          -0.077   Prob(JB):                        0.506
#Kurtosis:                       2.171   Cond. No.                         33.5
#===========================================================================
 
 
 

[OSWALD]

26.12.2023
Wo fange ich an ?
Eine schwierige frage. Ich beginne bei den Daten,
Ohne Daten keine Statistik.
Daten :
Zufallsvariable(randomisiert):
stetig (Wahrscheinlichkeits-Funktion) F(x) = Summe f(xi)
diskrete(Wahrscheinlichkeits-Dichte) F(x) = Integral f(t)dt

Verteilungen:
Eine statistische Verteilung oder Wahrscheinlichkeitsverteilung beschreibt,
wie Werte für ein Feld verteilt sind.
Mit anderen Worten, die statistische Verteilung veranschaulicht,
welche Werte häufig vorkommen und welche nicht.
Deshalb kurz etwas über Daten.
Dazu die wichtigste Verteilng;

Code: Alles auswählen

#Für eine Nμ; σ - verteilte Zufallsgröße gelten folgende Sigma-Regeln:
#Intervall I P (X ∈ I)
#[μ − σ; μ + σ] ≈ 0,683
#[μ − 2 σ; μ + 2 σ] ≈ 0,954
#[μ − 3 σ; μ + 3 σ] ≈ 0,997
#              Intervall I P (X ∈ I)
#[μ − 1,64 σ; μ + 1,64 σ] ≈ 0,90
#μ   − 1,96 σ; μ + 1,96 σ] ≈ 0,95
#[μ − 2,58 σ; μ + 2,58 σ] ≈ 0,99                                                                                                  

import numpy as np
import matplotlib.pyplot as plt
mu = 2
sigma = 0.5   # Durchschnitt und Stabdardabweichung

s = np.random.normal(mu, sigma, 100000)

#Überprüfen Sie den Mittelwert und die Varianz:
abs(mu - np.mean(s))
0.0   
abs(sigma - np.std(s, ddof=1))
0.1  

#Anzeige des Histogramms der Proben, zusammen mit die Wahrscheinlichkeitsdichtefunktion:

count, bins, ignored = plt.hist(s, 30, density=True)
print(count)
print()
print(bins)
plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *

               np.exp( - (bins - mu)**2 / (2 * sigma**2) ),

         linewidth=2, color='green')

plt.title("Normalverteilung")
plt.grid()
plt.show()
code]

[OSWALD]

27.12.23
einige Beispiele für die Beschaffung von
Datenmaterial.
Jetzt kann über die Verwendung der Daten
entschieden werden.
Gute Zeit OSWALD

Code: Alles auswählen

#         Zur  Gewinnung von Daten           für die beschreibende Statistik
# Für eine sinnvolle Statistik ist  die Auswahl des richtigen  Zahlenmaterials wichtig.
#          hierzu einige Beispiele
import numpy as np
print ("Zufallszahlen")
import numpy as np 
r = np.random.uniform(size=40) 
print(r)
print() ############
print("Zahlen mit  1D-ARRAYS")
 
random_array = np.random.uniform(0.0, 1.0, 10) 
print("1D Array with random values : \n", random_array)
################
print("Zahlen aus einer Normalverteilung entnommen")

mu, sigma = 0, 0.1 # mean and standard deviation
s = np.random.normal(mu, sigma, 100)
print(s)
print(mu,sigma)


#########
print("Zahlen       aus Poisson-Verteilung")
s = np.random.poisson(lam=(10., 50.), size=(10, 2))
print(s)
 


print("Integer erzeugen")
np.random.randint(10, size=10)
#array([1, 0, 0, 0, 1, 1, 0, 0, 1, 0])
print(np.random.randint(54, size=10))
#array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
#Generate a 2 x 4 array of ints between 0 and 4, inclusive:
print(np.random.randint(5, size=(2, 10)))
#array([[4, 0, 2, 1],
     #  [3, 2, 2, 0]])
print()

print("Daten aus Llsten entnehmen ")
import random

population = [1.2, 2.2, 3.7, 4.4, 5.2, 6.7, 7.7, 8.4, 9.3, 10.5]
sample_size =  6
sample = random.sample(population, sample_size)
print(sample)